643 lines
17 KiB
C++
643 lines
17 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "CQTest.h"
|
|
#include "CQTestUnitTestHelper.h"
|
|
|
|
#include "Tickable.h"
|
|
|
|
namespace CQTestTests
|
|
{
|
|
TEST(Minimal, "TestFramework.CQTest")
|
|
{
|
|
ASSERT_THAT(IsTrue(true));
|
|
};
|
|
|
|
TEST_CLASS(From, "TestFramework.CQTest.Core.GenerateDirectory.TokenProduces.[GenerateTestDirectory]")
|
|
{
|
|
TEST_METHOD(FolderStructure)
|
|
{
|
|
FString Expected = TEXT("CQTest");
|
|
ASSERT_THAT(IsTrue(TestRunner->TestDir.EndsWith(Expected), FString::Printf(TEXT("TestDir to end with %s but TestDir is %s produced from %s"), *Expected, *TestRunner->TestDir, *TestRunner->GetTestSourceFileName())));
|
|
}
|
|
};
|
|
|
|
TEST_CLASS(Produces, "TestFramework.CQTest.Core.GenerateDirectory")
|
|
{
|
|
TEST_METHOD(WithPlugins_AppearsInPlugins)
|
|
{
|
|
FString GeneratedDirectory = TestDirectoryGenerator::Generate(TEXT("Projects/MyProject/Plugins/PluginOne/Source/Test.cpp"));
|
|
ASSERT_THAT(AreEqual(FString(TEXT("MyProject.Plugins.PluginOne")), GeneratedDirectory));
|
|
}
|
|
|
|
TEST_METHOD(WithPlatforms_AppearsInPlatforms)
|
|
{
|
|
FString GeneratedDirectory = TestDirectoryGenerator::Generate(TEXT("Projects/MyProject/Platforms/PlatformOne/Source/Test.cpp"));
|
|
ASSERT_THAT(AreEqual(FString(TEXT("MyProject.Platforms.PlatformOne")), GeneratedDirectory));
|
|
}
|
|
|
|
TEST_METHOD(WithoutPluginsOrPlatforms_FallsBackToSource)
|
|
{
|
|
FString GeneratedDirectory = TestDirectoryGenerator::Generate(TEXT("Project/MyProject/Source/MyProjectFolder/Test.cpp"));
|
|
ASSERT_THAT(AreEqual(FString(TEXT("MyProject.Source.MyProjectFolder")), GeneratedDirectory));
|
|
}
|
|
};
|
|
|
|
TEST_CLASS(SourceAndFile, "TestFramework.CQTest.Core")
|
|
{
|
|
TEST_METHOD(SetsSourceFile)
|
|
{
|
|
ASSERT_THAT(AreEqual(FString(__FILE__), TestRunner->GetTestSourceFileName()));
|
|
}
|
|
|
|
TEST_METHOD(SetsLine_WithLineOfTestClass)
|
|
{
|
|
ASSERT_THAT(AreEqual(__LINE__ - 2, TestRunner->GetTestSourceFileLine(TEXT("SetsLine_WithLineOfTestClass"))));
|
|
}
|
|
};
|
|
|
|
TEST_CLASS(DefaultFixtureTestFlags, "TestFramework.CQTest.Core")
|
|
{
|
|
TEST_METHOD(SetsApplicationContextMask)
|
|
{
|
|
ASSERT_THAT(AreEqual(EAutomationTestFlags_ApplicationContextMask, TestRunner->GetTestFlags() & EAutomationTestFlags_ApplicationContextMask));
|
|
}
|
|
|
|
TEST_METHOD(SetsProductFilter)
|
|
{
|
|
ASSERT_THAT(AreEqual(EAutomationTestFlags::ProductFilter, TestRunner->GetTestFlags() & EAutomationTestFlags::ProductFilter));
|
|
}
|
|
};
|
|
|
|
TEST_CLASS_WITH_FLAGS(OverrideFixtureTestFlags, "TestFramework.CQTest.Core", EAutomationTestFlags_ApplicationContextMask | EAutomationTestFlags::EngineFilter)
|
|
{
|
|
TEST_METHOD(GetTestFlags_ReturnsSetAutomationTestFlags)
|
|
{
|
|
ASSERT_THAT(AreEqual(EAutomationTestFlags_ApplicationContextMask | EAutomationTestFlags::EngineFilter, TestRunner->GetTestFlags()));
|
|
}
|
|
};
|
|
|
|
TEST_CLASS_WITH_FLAGS_AND_TAGS(OverrideFixtureTestFlagsAndTags, "TestFramework.CQTest.Core.Tags", EAutomationTestFlags_ApplicationContextMask | EAutomationTestFlags::EngineFilter, "[CQFlagsTest][FlagsExtraTag][CQTaggedTests]")
|
|
{
|
|
TEST_METHOD(GetTestFlags_ReturnsSetAutomationTestFlags_HasExpectedTags)
|
|
{
|
|
ASSERT_THAT(AreEqual(EAutomationTestFlags_ApplicationContextMask | EAutomationTestFlags::EngineFilter, TestRunner->GetTestFlags()));
|
|
|
|
const FString TestTags = TestRunner->GetTestTags();
|
|
ASSERT_THAT(IsTrue(TestTags.Contains(TEXT("[CQFlagsTest]"))));
|
|
ASSERT_THAT(IsTrue(TestTags.Contains(TEXT("[FlagsExtraTag]"))));
|
|
}
|
|
|
|
TEST_METHOD_WITH_TAGS(GetTestFlags_HasExpectedMethodTags, "[CQClassWithFlagsAndTagsMethod]")
|
|
{
|
|
const FString ThisMethodName = TEXT("GetTestFlags_HasExpectedMethodTags");
|
|
const FString TestTags = TestRunner->GetTestMethodTags(ThisMethodName);
|
|
ASSERT_THAT(IsTrue(TestTags.Contains(TEXT("[CQFlagsTest]"))));
|
|
ASSERT_THAT(IsTrue(TestTags.Contains(TEXT("[FlagsExtraTag]"))));
|
|
ASSERT_THAT(IsTrue(TestTags.Contains(TEXT("[CQClassWithFlagsAndTagsMethod]"))));
|
|
}
|
|
};
|
|
|
|
TEST_CLASS(TestFixtureTest, "TestFramework.CQTest.Core")
|
|
{
|
|
bool SetupCalled = false;
|
|
bool ShouldAddErrorDuringTearDown = false;
|
|
uint32 SomeNumber = 0;
|
|
FString ExpectedError = TEXT("Error reported in TearDown");
|
|
|
|
BEFORE_EACH()
|
|
{
|
|
SetupCalled = true;
|
|
SomeNumber++;
|
|
}
|
|
|
|
AFTER_EACH()
|
|
{
|
|
if (ShouldAddErrorDuringTearDown)
|
|
{
|
|
Assert.Fail(ExpectedError);
|
|
}
|
|
}
|
|
|
|
protected:
|
|
void ProtectedMethodDefinedInFixture() const {}
|
|
|
|
void AddExpectedErrorDuringTearDown()
|
|
{
|
|
ShouldAddErrorDuringTearDown = true;
|
|
Assert.ExpectError(ExpectedError);
|
|
}
|
|
|
|
TEST_METHOD(CanAccessProtectedFixtureMethods)
|
|
{
|
|
ProtectedMethodDefinedInFixture();
|
|
}
|
|
|
|
TEST_METHOD(BeforeRunTest_CallsSetup)
|
|
{
|
|
ASSERT_THAT(IsTrue(SetupCalled));
|
|
}
|
|
|
|
TEST_METHOD(AfterRunTest_CallsTearDown)
|
|
{
|
|
AddExpectedErrorDuringTearDown();
|
|
}
|
|
|
|
TEST_METHOD(BackingFixture_ResetsStateBetweenTestsPartOne)
|
|
{
|
|
ASSERT_THAT(AreEqual(1, SomeNumber));
|
|
}
|
|
|
|
TEST_METHOD(BackingFixture_ResetsStateBetweenTestsPartTwo)
|
|
{
|
|
ASSERT_THAT(AreEqual(1, SomeNumber));
|
|
}
|
|
};
|
|
|
|
TEST_CLASS(TestFixtureConstructor, "TestFramework.CQTest.Core")
|
|
{
|
|
bool SetupCalled = false;
|
|
uint32 SomeNumber = 0;
|
|
|
|
TestFixtureConstructor()
|
|
{
|
|
SetupCalled = true;
|
|
SomeNumber++;
|
|
}
|
|
|
|
protected:
|
|
TEST_METHOD(ConstructorIsCalled_BeforeRunTest)
|
|
{
|
|
ASSERT_THAT(IsTrue(SetupCalled));
|
|
}
|
|
|
|
TEST_METHOD(BackingFixture_ResetsStateBetweenTestsPartOne)
|
|
{
|
|
ASSERT_THAT(AreEqual(1, SomeNumber));
|
|
}
|
|
|
|
TEST_METHOD(BackingFixture_ResetsStateBetweenTestsPartTwo)
|
|
{
|
|
ASSERT_THAT(AreEqual(1, SomeNumber));
|
|
}
|
|
};
|
|
|
|
|
|
TEST_CLASS(TestAssertionInBefore, "TestFramework.CQTest.Core")
|
|
{
|
|
FString ExpectedError = TEXT("Expected Error Message");
|
|
|
|
BEFORE_EACH()
|
|
{
|
|
Assert.Fail(ExpectedError);
|
|
}
|
|
|
|
AFTER_EACH()
|
|
{
|
|
ClearExpectedError(*this->TestRunner, ExpectedError);
|
|
}
|
|
|
|
TEST_METHOD(BeforeTest_AssertionFailure_DoesNotRunTestMethod)
|
|
{
|
|
Assert.Fail(TEXT("TEST_METHOD should not run if assertion fails in BEFORE_EACH"));
|
|
}
|
|
};
|
|
|
|
TEST_CLASS(BeforeAndAfterAll, "TestFramework.CQTest.Core")
|
|
{
|
|
inline static uint32 BeforeAllCallCount = 0;
|
|
FString ExpectedError = TEXT("Expected Error Message");
|
|
|
|
BEFORE_ALL()
|
|
{
|
|
BeforeAllCallCount++;
|
|
}
|
|
|
|
AFTER_ALL()
|
|
{
|
|
BeforeAllCallCount = 0;
|
|
}
|
|
|
|
BEFORE_EACH()
|
|
{
|
|
ASSERT_THAT(AreEqual(1, BeforeAllCallCount));
|
|
}
|
|
|
|
AFTER_EACH()
|
|
{
|
|
ClearExpectedError(*this->TestRunner, ExpectedError);
|
|
ASSERT_THAT(AreEqual(1, BeforeAllCallCount));
|
|
}
|
|
|
|
TEST_METHOD(StaticMember_IsAvailable_DuringTest)
|
|
{
|
|
ASSERT_THAT(AreEqual(1, BeforeAllCallCount));
|
|
}
|
|
|
|
TEST_METHOD(BeforeAll_IsCalled_OnlyOnce)
|
|
{
|
|
ASSERT_THAT(AreEqual(1, BeforeAllCallCount));
|
|
}
|
|
|
|
TEST_METHOD(AfterAll_WhenTestFails_StillFires)
|
|
{
|
|
Assert.Fail(ExpectedError);
|
|
}
|
|
};
|
|
|
|
static_assert(HasBeforeAll<BeforeAndAfterAll>);
|
|
static_assert(HasAfterAll<BeforeAndAfterAll>);
|
|
|
|
TEST(ValidateAfterAll, "TestFramework.CQTest.Core")
|
|
{
|
|
ASSERT_THAT(AreEqual(0, BeforeAndAfterAll::BeforeAllCallCount));
|
|
}
|
|
|
|
// --------------------------------------------------------
|
|
// Latent commands are awaited
|
|
// --------------------------------------------------------
|
|
template <typename Test>
|
|
class FMinimumCallCommand : public IAutomationLatentCommand
|
|
{
|
|
public:
|
|
FMinimumCallCommand(Test* InTest, int32 expectedCount)
|
|
: ExecutingTest(InTest), ExpectedCount(expectedCount) {}
|
|
|
|
bool Update() override
|
|
{
|
|
if (ExecutingTest)
|
|
{
|
|
ExecutingTest->IncrementExecutedCommandsCount();
|
|
}
|
|
CurrentCount++;
|
|
return CurrentCount == ExpectedCount;
|
|
}
|
|
|
|
Test* ExecutingTest;
|
|
int32 ExpectedCount{ 0 };
|
|
int32 CurrentCount{ 0 };
|
|
};
|
|
|
|
TEST_CLASS(AddCommandTests, "TestFramework.CQTest.Core")
|
|
{
|
|
void SetExpectedExecutedCommandsCount(int32 count)
|
|
{
|
|
ExpectedExecutedCommandsCount = count;
|
|
}
|
|
void IncrementExecutedCommandsCount()
|
|
{
|
|
ExecutedCommandsCount++;
|
|
}
|
|
|
|
int32 ExpectedExecutedCommandsCount{ 0 };
|
|
int32 ExecutedCommandsCount{ 0 };
|
|
|
|
BEFORE_EACH()
|
|
{
|
|
for (int32 i = 0; i < 3; i++)
|
|
{
|
|
AddCommand(new FMinimumCallCommand(this, i + 1));
|
|
}
|
|
}
|
|
|
|
AFTER_EACH()
|
|
{
|
|
if (ExpectedExecutedCommandsCount > 0)
|
|
{
|
|
ASSERT_THAT(AreEqual(ExpectedExecutedCommandsCount, ExecutedCommandsCount));
|
|
}
|
|
}
|
|
|
|
TEST_METHOD(Test_WithCommandsInBeforeTest_ExecutesCommandsBeforeRun)
|
|
{
|
|
ASSERT_THAT(AreEqual(1 + 2 + 3, ExecutedCommandsCount));
|
|
}
|
|
|
|
TEST_METHOD(Test_WithLatentCommandsInTest_ExecutesCommandsBeforeTearDown)
|
|
{
|
|
ExpectedExecutedCommandsCount = ExecutedCommandsCount * 2;
|
|
for (int32 i = 0; i < 3; i++)
|
|
{
|
|
AddCommand(new FMinimumCallCommand(this, i + 1));
|
|
}
|
|
}
|
|
};
|
|
|
|
TEST_CLASS(LatentActionsTest, "TestFramework.CQTest.Core")
|
|
{
|
|
TArray<FString> CommandLog;
|
|
|
|
TFunction<bool(LatentActionsTest*)> Assertion;
|
|
TArray<FString> KnownStrings = {
|
|
TEXT("One"),
|
|
TEXT("Two"),
|
|
TEXT("Three"),
|
|
TEXT("Four")
|
|
};
|
|
|
|
AFTER_EACH()
|
|
{
|
|
ASSERT_THAT(IsTrue(Assertion(this)));
|
|
}
|
|
|
|
TEST_METHOD(Do_OnCommandBuilder_AddsLatentCommand)
|
|
{
|
|
TestCommandBuilder.Do([&]() { CommandLog.Add(KnownStrings[0]); });
|
|
ASSERT_THAT(IsTrue(CommandLog.IsEmpty()));
|
|
Assertion = [](LatentActionsTest* test) {
|
|
return !test->CommandLog.IsEmpty();
|
|
};
|
|
}
|
|
|
|
TEST_METHOD(MultipleDoCalls_OnCommandBuilder_AddsAllCommands)
|
|
{
|
|
TestCommandBuilder.Do([&]() {
|
|
CommandLog.Add(KnownStrings[0]);
|
|
})
|
|
.Do([&]() {
|
|
CommandLog.Add(KnownStrings[1]);
|
|
})
|
|
.Do([&]() {
|
|
CommandLog.Add(KnownStrings[2]);
|
|
});
|
|
|
|
Assertion = [](LatentActionsTest* test) {
|
|
if (test->CommandLog.Num() != 3)
|
|
{
|
|
return false;
|
|
}
|
|
for (int32 Index = 0; Index < 3; Index++)
|
|
{
|
|
if (test->CommandLog[Index] != test->KnownStrings[Index])
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
}
|
|
|
|
TEST_METHOD(DoAndAddCommand_InTheSameTest_AddCommandsInOrder)
|
|
{
|
|
TestCommandBuilder.Do([&]() { CommandLog.Add(KnownStrings[0]); });
|
|
AddCommand(new FExecute(*TestRunner, [&]() { CommandLog.Add(KnownStrings[1]); }));
|
|
TestCommandBuilder.Do([&]() { CommandLog.Add(KnownStrings[2]); });
|
|
AddCommand(new FExecute(*TestRunner, [&]() { CommandLog.Add(KnownStrings[3]); }));
|
|
|
|
Assertion = [](LatentActionsTest* test) {
|
|
if (test->CommandLog.Num() != 4)
|
|
{
|
|
return false;
|
|
}
|
|
for (int32 Index = 0; Index < 4; Index++)
|
|
{
|
|
if (test->CommandLog[Index] != test->KnownStrings[Index])
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
}
|
|
};
|
|
|
|
|
|
TEST_CLASS(LatentActionOnTearDown, "TestFramework.CQTest.Core")
|
|
{
|
|
FString ExpectedError = TEXT("ExpectedErrorShouldBeCleared");
|
|
|
|
TEST_METHOD(Teardown_Fires_AfterAll)
|
|
{
|
|
TestCommandBuilder.Do([&]() {
|
|
Assert.Fail(ExpectedError);
|
|
})
|
|
.OnTearDown([&]() {
|
|
ClearExpectedError(*TestRunner, ExpectedError);
|
|
});
|
|
}
|
|
|
|
TEST_METHOD(Teardown_Fires_InReverseOrder)
|
|
{
|
|
TestCommandBuilder.OnTearDown([&]() {
|
|
ClearExpectedError(*TestRunner, ExpectedError);
|
|
}).OnTearDown([&]() {
|
|
Assert.Fail(ExpectedError);
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
TEST_CLASS(LatentActionErrors, "TestFramework.CQTest.Core")
|
|
{
|
|
FString ExpectedError = TEXT("ExpectedError");
|
|
|
|
AFTER_EACH()
|
|
{
|
|
ClearExpectedError(*TestRunner, ExpectedError);
|
|
}
|
|
|
|
TEST_METHOD(Assertion_InLatentActions_PreventsAdditionalLatentActions)
|
|
{
|
|
TestCommandBuilder.Do([&]() {
|
|
Assert.Fail(ExpectedError);
|
|
})
|
|
.Then([&]() {
|
|
Assert.Fail("Unexpected Error");
|
|
});
|
|
}
|
|
|
|
TEST_METHOD(Timeout_InLatentActions_ProvidesTimeoutInErrorMessage)
|
|
{
|
|
Assert.ExpectErrorRegex(TEXT("\\d{2,} milliseconds"));
|
|
TestCommandBuilder.StartWhen([]() {
|
|
return false;
|
|
}, FTimespan::FromMilliseconds(50));
|
|
}
|
|
};
|
|
|
|
// --------------------------------------------------------
|
|
// Tickable Game Objects Tick
|
|
// --------------------------------------------------------
|
|
struct FTestTickable : public FTickableGameObject
|
|
{
|
|
virtual TStatId GetStatId() const override
|
|
{
|
|
return TStatId();
|
|
}
|
|
|
|
virtual void Tick(float DeltaTime) override
|
|
{
|
|
TickCount++;
|
|
}
|
|
|
|
virtual bool IsTickableInEditor() const override
|
|
{
|
|
return true;
|
|
}
|
|
|
|
void ResetTickCount()
|
|
{
|
|
TickCount = 0;
|
|
}
|
|
|
|
uint32 TickCount = 0;
|
|
};
|
|
|
|
TEST_CLASS(GameObjectsTickTest, "TestFramework.CQTest.Core")
|
|
{
|
|
BEFORE_EACH()
|
|
{
|
|
Tickable.ResetTickCount();
|
|
AddCommand(new FWaitUntil(*TestRunner, [&]() { return Tickable.TickCount > 2; }));
|
|
}
|
|
AFTER_EACH()
|
|
{
|
|
ASSERT_THAT(IsTrue(Tickable.TickCount > 2));
|
|
}
|
|
|
|
FTestTickable Tickable{};
|
|
|
|
TEST_METHOD(TestWithTickableGameObject_WaitingForTicksInSetup_WillAllowGameObjectToTick)
|
|
{
|
|
TestCommandBuilder.Do([this]() { ASSERT_THAT(IsTrue(Tickable.TickCount > 2)); });
|
|
}
|
|
|
|
TEST_METHOD(TestWithTickableGameObject_WaitingForTicksInSetup_WillBeCompleteDuringRunStep)
|
|
{
|
|
ASSERT_THAT(IsTrue(Tickable.TickCount > 2));
|
|
}
|
|
};
|
|
|
|
DEFINE_LOG_CATEGORY_STATIC(TestSuppressLog, Log, All);
|
|
|
|
TEST_CLASS(SuppressWarningsAndErrors, "TestFramework.CQTest.Core")
|
|
{
|
|
bool bExpectError{ false };
|
|
bool bExpectWarning{ false };
|
|
FString ExpectedError = TEXT("ExpectedError");
|
|
|
|
AFTER_EACH()
|
|
{
|
|
static FString FormattedMessage = FString::Printf(TEXT("TestSuppressLog: %s"), *ExpectedError);
|
|
if (bExpectError)
|
|
{
|
|
ClearExpectedErrors(*this->TestRunner, { TEXT("will be marked as failing due to errors"), FormattedMessage });
|
|
}
|
|
if (bExpectWarning)
|
|
{
|
|
ClearExpectedWarning(*this->TestRunner, FormattedMessage);
|
|
}
|
|
}
|
|
|
|
TEST_METHOD(SuppressWarnings_WithWarnings_SuppressesWarning)
|
|
{
|
|
TestRunner->SetSuppressLogWarnings();
|
|
UE_LOG(TestSuppressLog, Warning, TEXT("This log should be suppressed"));
|
|
}
|
|
|
|
TEST_METHOD(SuppressWarnings_WithError_DoesNotSuppressError)
|
|
{
|
|
TestRunner->SetSuppressLogWarnings();
|
|
bExpectError = true;
|
|
UE_LOG(TestSuppressLog, Error, TEXT("%s"), *ExpectedError);
|
|
}
|
|
|
|
TEST_METHOD(SuppressErrors_WithWarnings_DoesNotSuppressWarning)
|
|
{
|
|
TestRunner->SetSuppressLogErrors();
|
|
bExpectWarning = true;
|
|
UE_LOG(TestSuppressLog, Warning, TEXT("%s"), *ExpectedError);
|
|
}
|
|
|
|
TEST_METHOD(SuppressErrors_WithError_SuppressesError)
|
|
{
|
|
TestRunner->SetSuppressLogErrors();
|
|
UE_LOG(TestSuppressLog, Error, TEXT("This log should be suppressed"));
|
|
}
|
|
|
|
TEST_METHOD(SuppressErrors_ChangedMidTest_RespectsChanges)
|
|
{
|
|
TestRunner->SetSuppressLogErrors();
|
|
UE_LOG(TestSuppressLog, Error, TEXT("This log should be suppressed"));
|
|
TestRunner->SetSuppressLogErrors(ECQTestSuppressLogBehavior::False);
|
|
bExpectError = true;
|
|
UE_LOG(TestSuppressLog, Error, TEXT("%s"), *ExpectedError);
|
|
}
|
|
};
|
|
|
|
TEST_CLASS(AutomationEvents, "TestFramework.CQTest.Core")
|
|
{
|
|
bool bIsExpectingError{ false };
|
|
bool bIsExpectingWarning{ false };
|
|
FString ExpectedMessage = TEXT("ExpectedMessage");
|
|
|
|
AFTER_EACH()
|
|
{
|
|
if (bIsExpectingError)
|
|
{
|
|
ClearExpectedErrors(*this->TestRunner, { TEXT("will be marked as failing due to errors"), ExpectedMessage });
|
|
}
|
|
if (bIsExpectingWarning)
|
|
{
|
|
ClearExpectedWarning(*this->TestRunner, ExpectedMessage);
|
|
}
|
|
}
|
|
|
|
TEST_METHOD(InfoEvent)
|
|
{
|
|
AddInfo(ExpectedMessage);
|
|
ASSERT_THAT(IsTrue(DoesEventExist(*this->TestRunner, FAutomationEvent(EAutomationEventType::Info, ExpectedMessage))));
|
|
}
|
|
|
|
TEST_METHOD(WarningEvent)
|
|
{
|
|
bIsExpectingWarning = true;
|
|
AddWarning(ExpectedMessage);
|
|
ASSERT_THAT(IsTrue(DoesEventExist(*this->TestRunner, FAutomationEvent(EAutomationEventType::Warning, ExpectedMessage))));
|
|
}
|
|
|
|
TEST_METHOD(ConditionalEvent)
|
|
{
|
|
FString InvalidErrorMessage = TEXT("This should not be an error");
|
|
AddErrorIfFalse(true, InvalidErrorMessage);
|
|
ASSERT_THAT(IsFalse(DoesEventExist(*this->TestRunner, FAutomationEvent(EAutomationEventType::Error, InvalidErrorMessage))));
|
|
AddErrorIfFalse(false, ExpectedMessage);
|
|
bIsExpectingError = true;
|
|
ASSERT_THAT(IsTrue(DoesEventExist(*this->TestRunner, FAutomationEvent(EAutomationEventType::Error, ExpectedMessage))));
|
|
}
|
|
|
|
TEST_METHOD(ErrorEvent)
|
|
{
|
|
bIsExpectingError = true;
|
|
AddError(ExpectedMessage);
|
|
ASSERT_THAT(IsTrue(DoesEventExist(*this->TestRunner, FAutomationEvent(EAutomationEventType::Error, ExpectedMessage))));
|
|
}
|
|
};
|
|
|
|
TEST_CLASS_WITH_TAGS(CQTags, "TestFramework.CQTest.Core.Tags", "[CQTest][ExtraTag][CQTaggedTests]")
|
|
{
|
|
TEST_METHOD(CheckTagsAreValid)
|
|
{
|
|
const FString TestTags = TestRunner->GetTestTags();
|
|
ASSERT_THAT(IsTrue(TestTags.Contains(TEXT("[CQTest]"))));
|
|
ASSERT_THAT(IsTrue(TestTags.Contains(TEXT("[ExtraTag]"))));
|
|
}
|
|
|
|
TEST_METHOD_WITH_TAGS(CheckTagsAreValid_HasExpectedMethodTags, "[CQClassWithTagsMethod]")
|
|
{
|
|
const FString ThisMethodName = TEXT("CheckTagsAreValid_HasExpectedMethodTags");
|
|
const FString TestTags = TestRunner->GetTestMethodTags(ThisMethodName);
|
|
ASSERT_THAT(IsTrue(TestTags.Contains(TEXT("[CQTest]"))));
|
|
ASSERT_THAT(IsTrue(TestTags.Contains(TEXT("[ExtraTag]"))));
|
|
ASSERT_THAT(IsTrue(TestTags.Contains(TEXT("[CQClassWithTagsMethod]"))));
|
|
}
|
|
|
|
TEST_METHOD_WITH_TAGS(CheckTagsAreValid_HasExpectedMethodTagsNoLeak, "[CQClassWithTagsNoLeakMethod]")
|
|
{
|
|
const FString ThisMethodName = TEXT("CheckTagsAreValid_HasExpectedMethodTagsNoLeak");
|
|
const FString TestTags = TestRunner->GetTestMethodTags(ThisMethodName);
|
|
ASSERT_THAT(IsTrue(TestTags.Contains(TEXT("[CQClassWithTagsNoLeakMethod]"))));
|
|
ASSERT_THAT(IsFalse(TestTags.Contains(TEXT("[CQClassWithTagsMethod]"))));
|
|
}
|
|
};
|
|
} // namespace CQTestTests
|