bool UUnitTest::ValidateUnitTestSettings(bool bCDOCheck/*=false*/) { bool bSuccess = true; // The unit test must specify some ExpectedResult values UNIT_ASSERT(ExpectedResult.Num() > 0); TArray<EUnitTestVerification> ExpectedResultList; ExpectedResult.GenerateValueArray(ExpectedResultList); // Unit tests should not expect unreliable results, without being marked as unreliable UNIT_ASSERT(!ExpectedResultList.Contains(EUnitTestVerification::VerifiedUnreliable) || bUnreliable); // Unit tests should never expect 'needs-update' as a valid unit test result // @todo JohnB: It might make sense to allow this in the future, if you want to mark unit tests as 'needs-update' before running, // so that you can skip running those unit tests UNIT_ASSERT(!ExpectedResultList.Contains(EUnitTestVerification::VerifiedNeedsUpdate)); // Every unit test must specify a timeout value UNIT_ASSERT(UnitTestTimeout > 0); return bSuccess; }
void TestBiblioName(docLanguage language) { const char* name = NameByLanguage(language); UNIT_ASSERT(name != NULL); UNIT_ASSERT(strlen(name) > 2); TestName(language, name); }
void TestFullName(docLanguage language) { const char* name = FullNameByLanguage(language); UNIT_ASSERT(name != NULL); UNIT_ASSERT(strlen(name) == 0 || strlen(name) > 3); if (strlen(name)) TestName(language, name); }
void THashTest::TestHSet2() { yhash_set<int, THash<int>, TEqualTo<int> > s; TPair<yhash_set<int, THash<int>, TEqualTo<int> >::iterator, bool> p = s.insert(42); UNIT_ASSERT(p.second); UNIT_ASSERT(*(p.first) == 42); p = s.insert(42); UNIT_ASSERT(!p.second); }
void TestIsoName(docLanguage language) { const char* name = IsoNameByLanguage(language); UNIT_ASSERT(name != NULL); UNIT_ASSERT(strlen(name) == 0 || strlen(name) == 2 || !strcmp(name, "mis") || !strncmp(name, "bas-", 4)); if (strlen(name)) TestName(language, name); }
void MakeSlowCapturingTest(const char* regexp, const char* text, size_t position, bool ans, const ystring& captured = ystring(""), const Pire::Encoding& encoding = Pire::Encodings::Utf8()) { Pire::SlowCapturingScanner sc = SlowCompile(regexp, position, encoding); SlowCapturingScanner::State st = RunRegexp(sc, text); SlowCapturingScanner::SingleState fin; bool ifCaptured = sc.GetCapture(st, fin); if (ans) { UNIT_ASSERT(ifCaptured); ystring answer(text, fin.GetBegin(), fin.GetEnd() - fin.GetBegin()); UNIT_ASSERT_EQUAL(answer, captured); } else { UNIT_ASSERT(!ifCaptured); } }
inline void TestVirtuality() { try { ythrow TFileError() << "1"; UNIT_ASSERT(false); } catch (const TIoException&) { } catch (...) { UNIT_ASSERT(false); } try { ythrow TFileError() << 1; UNIT_ASSERT(false); } catch (const TSystemError&) { } catch (...) { UNIT_ASSERT(false); } try { ythrow TFileError() << '1'; UNIT_ASSERT(false); } catch (const yexception&) { } catch (...) { UNIT_ASSERT(false); } try { ythrow TFileError() << 1.0; UNIT_ASSERT(false); } catch (const TFileError&) { } catch (...) { UNIT_ASSERT(false); } }
void TestBig5() { UNIT_ASSERT(!NCodepagePrivate::NativeCodepage(CODES_BIG5)); const char* UTF8 = "\xe5\xad\xb8\xe7\x94\x9f\xe7\xb8\xbd\xe4\xba\xba\xe6\x95\xb8\xe6\x99\xae\xe9\x80\x9a\xe7\x8f\xad"; const char* BIG5 = "\xbe\xc7\xa5\xcd\xc1\x60\xa4\x48\xbc\xc6\xb4\xb6\xb3\x71\xaf\x5a"; TestIconv(UTF8, BIG5, CODES_BIG5); }
inline void TestMtpTaskPool() { TMtpTasksPool pool; TMtpTasksPool::TMtpTaskFromPoolRef task = pool.Acquire(); UNIT_ASSERT(task.Get() != 0); }
//! tests propagation of an exception through C code //! @note on some platforms, for example GCC on 32-bit Linux without -fexceptions option, //! throwing an exception from a C++ callback through C code aborts program inline void TestMixedCode() { const int N = 26082009; try { TestCallback(&CallbackFun, N); UNIT_ASSERT(false); } catch (int i) { UNIT_ASSERT_VALUES_EQUAL(i, N); } }
void TSysIpTest::TestIpToString() { ui8 ipArr[][4] = {{192, 168, 0, 1}, {87, 255, 18, 167}, {255, 255, 0, 31}, {188, 225, 124, 255}}; const char* ipStr[] = {"192.168.0.1", "87.255.18.167", "255.255.0.31", "188.225.124.255"}; for (size_t i = 0; i < ARRAY_SIZE(ipStr); ++i) { UNIT_ASSERT(IpToString(*ReinterpretCast<TIpHost*>(&(ipArr[i]))) == ipStr[i]); } }
void TSysIpTest::TestIpFromString() { const char* ipStr[] = {"192.168.0.1", "87.255.18.167", "255.255.0.31", "188.225.124.255"}; ui8 ipArr[][4] = {{192, 168, 0, 1}, {87, 255, 18, 167}, {255, 255, 0, 31}, {188, 225, 124, 255}}; for (size_t i = 0; i < ARRAY_SIZE(ipStr); ++i) { const ui32 ip = IpFromString(ipStr[i]); UNIT_ASSERT(memcmp(&ip, ipArr[i], sizeof(ui32)) == 0); } }
inline void TestFormat1() { try { throw yexception() << 1 << " qw " << 12.1; UNIT_ASSERT(false); } catch (...) { const Stroka err = CurrentExceptionMessage(); UNIT_ASSERT_VALUES_EQUAL(err, "1 qw 12.1"); } }
inline void TestRaise1() { try { Throw2DontMove(); UNIT_ASSERT(false); } catch (...) { Stroka err = CurrentExceptionMessage(); char *ptr = err.begin(); while ((ptr = strchr(ptr, '\\')) != 0) *ptr = '/'; UNIT_ASSERT_VALUES_EQUAL(err, "util/generic/yexception_ut.cpp:8: 1 qw 12.1"); } }
inline void TestThreadId() { TIdTester tst; TThread thr(tst.DoRun, &tst); tst.Thr = &thr; thr.Start(); thr.Join(); UNIT_ASSERT_EQUAL(tst.Cur, tst.Real); UNIT_ASSERT(tst.Cur != 0); }
void THashTest::TestHMSet1() { hmset s; UNIT_ASSERT(s.count(star) == 0); s.insert(star); UNIT_ASSERT(s.count(star) == 1); s.insert(star); UNIT_ASSERT(s.count(star) == 2); hmset::iterator i = s.find(char(40)); UNIT_ASSERT(i == s.end()); i = s.find(star); UNIT_ASSERT(i != s.end()); UNIT_ASSERT(*i == '*'); UNIT_ASSERT(s.erase(star) == 2); }
void UUnitTest::TickIsComplete(float DeltaTime) { // If the unit test was verified as success/fail (i.e. as completed), end it now if (!bCompleted && VerificationState != EUnitTestVerification::Unverified) { if (!bVerificationLogged) { if (VerificationState == EUnitTestVerification::VerifiedNotFixed) { UNIT_LOG(ELogType::StatusFailure, TEXT("Unit test verified as NOT FIXED")); } else if (VerificationState == EUnitTestVerification::VerifiedFixed) { UNIT_LOG(ELogType::StatusSuccess, TEXT("Unit test verified as FIXED")); } else if (VerificationState == EUnitTestVerification::VerifiedUnreliable) { UNIT_LOG(ELogType::StatusWarning, TEXT("Unit test verified as UNRELIABLE")); } else if (VerificationState == EUnitTestVerification::VerifiedNeedsUpdate) { UNIT_LOG(ELogType::StatusWarning | ELogType::StyleBold, TEXT("Unit test NEEDS UPDATE")); } else { // Don't forget to add new verification states UNIT_ASSERT(false); } bVerificationLogged = true; } if (!bDeveloperMode) { EndUnitTest(); } } }
static void TestSurrogates(const char* str, const wchar16* wide, size_t wideSize) { size_t sSize = strlen(str); size_t wSize = sSize * 2; TArrayHolder<wchar16> w(new wchar16[wSize]); size_t read = 0; size_t written = 0; NICONVPrivate::RecodeToUnicode(CODES_UTF8, str, w.Get(), sSize, wSize, read, written); UNIT_ASSERT(read == sSize); UNIT_ASSERT(written == wideSize); UNIT_ASSERT(!memcmp(w.Get(), wide, wideSize)); TArrayHolder<char> s(new char[sSize]); NICONVPrivate::RecodeFromUnicode(CODES_UTF8, w.Get(), s.Get(), wideSize, sSize, read, written); UNIT_ASSERT(read == wideSize); UNIT_ASSERT(written == sSize); UNIT_ASSERT(!memcmp(s.Get(), str, sSize)); }
void THashTest::TestInsertErase() { typedef yhash_map<Stroka, size_t, THash<Stroka>, TEqualTo<Stroka> > hmap; typedef hmap::value_type val_type; { hmap values; UNIT_ASSERT(values.insert(val_type("foo", 0)).second); UNIT_ASSERT(values.insert(val_type("bar", 0)).second); UNIT_ASSERT(values.insert(val_type("abc", 0)).second); UNIT_ASSERT(values.erase("foo") == 1); UNIT_ASSERT(values.erase("bar") == 1); UNIT_ASSERT(values.erase("abc") == 1); } { hmap values; UNIT_ASSERT(values.insert(val_type("foo", 0)).second); UNIT_ASSERT(values.insert(val_type("bar", 0)).second); UNIT_ASSERT(values.insert(val_type("abc", 0)).second); UNIT_ASSERT(values.erase("abc") == 1); UNIT_ASSERT(values.erase("bar") == 1); UNIT_ASSERT(values.erase("foo") == 1); } }
void THashTest::TestHMap1() { typedef yhash_map<char, Stroka, THash<char>, TEqualTo<char> > maptype; maptype m; // Store mappings between roman numerals and decimals. m['l'] = "50"; m['x'] = "20"; // Deliberate mistake. m['v'] = "5"; m['i'] = "1"; UNIT_ASSERT(!strcmp(m['x'].c_str(),"20")); m['x'] = "10"; // Correct mistake. UNIT_ASSERT(!strcmp(m['x'].c_str(),"10")); UNIT_ASSERT(!m.has('z')); UNIT_ASSERT(!strcmp(m['z'].c_str(),"")); UNIT_ASSERT(m.has('z')); UNIT_ASSERT(m.count('z') == 1); TPair<maptype::iterator, bool> p = m.insert(TPair<const char, Stroka>('c', Stroka("100"))); UNIT_ASSERT(p.second); p = m.insert(TPair<const char, Stroka>('c', Stroka("100"))); UNIT_ASSERT(!p.second); //Some iterators compare check, really compile time checks maptype::iterator ite(m.begin()); maptype::const_iterator cite(m.begin()); cite = m.begin(); maptype const& cm = m; cite = cm.begin(); UNIT_ASSERT((maptype::const_iterator)ite == cite); UNIT_ASSERT(!((maptype::const_iterator)ite != cite)); UNIT_ASSERT(cite == (maptype::const_iterator)ite); UNIT_ASSERT(!(cite != (maptype::const_iterator)ite)); }
void TestWrongName(const char* name) { docLanguage reversed = LanguageByName(name); UNIT_ASSERT(reversed == LANG_UNK); docLanguage reversedStrict = LanguageByNameStrict(name); UNIT_ASSERT(reversedStrict == LANG_MAX); }
void TestName(docLanguage language, const char* name) { docLanguage reversed = LanguageByName(name); UNIT_ASSERT(language == reversed); docLanguage reversedStrict = LanguageByNameStrict(name); UNIT_ASSERT(language == reversedStrict); }
void THashTest::TestHMMap1() { typedef yhash_multimap<char, int, THash<char>, TEqualTo<char> > mmap; mmap m; UNIT_ASSERT(m.count('X') == 0); m.insert(TPair<const char, int>('X', 10)); // Standard way. UNIT_ASSERT(m.count('X') == 1); m.insert(TPair<const char, int>('X', 20)); // jbuck: standard way UNIT_ASSERT(m.count('X') == 2); m.insert(TPair<const char, int>('Y', 32)); // jbuck: standard way mmap::iterator i = m.find('X'); // Find first match. UNIT_ASSERT((*i).first == 'X'); UNIT_ASSERT((*i).second == 10); i++; UNIT_ASSERT((*i).first == 'X'); UNIT_ASSERT((*i).second == 20); i = m.find('Y'); UNIT_ASSERT((*i).first == 'Y'); UNIT_ASSERT((*i).second == 32); i = m.find('Z'); UNIT_ASSERT(i == m.end()); size_t count = m.erase('X'); UNIT_ASSERT(count == 2); //Some iterators compare check, really compile time checks mmap::iterator ite(m.begin()); mmap::const_iterator cite(m.begin()); UNIT_ASSERT((mmap::const_iterator)ite == cite); UNIT_ASSERT(!((mmap::const_iterator)ite != cite)); UNIT_ASSERT(cite == (mmap::const_iterator)ite); UNIT_ASSERT(!(cite != (mmap::const_iterator)ite)); typedef yhash_multimap<size_t, size_t> HMapType; HMapType hmap; //We fill the map to implicitely start a rehash. for (size_t counter = 0; counter < 3077; ++counter) { hmap.insert(HMapType::value_type(1, counter)); } hmap.insert(HMapType::value_type(12325, 1)); hmap.insert(HMapType::value_type(12325, 2)); UNIT_ASSERT(hmap.count(12325) == 2); //At this point 23 goes to the same bucket as 12325, it used to reveal a bug. hmap.insert(HMapType::value_type(23, 0)); UNIT_ASSERT(hmap.count(12325) == 2); }
static void TestIconv(const Stroka& utf8, const Stroka& other, ECharset enc) { Wtroka wide0 = CharToWide(utf8, CODES_UTF8); Wtroka wide1 = CharToWide(other, enc); UNIT_ASSERT(wide0 == wide1); Stroka temp = WideToChar(wide0, CODES_UTF8); UNIT_ASSERT(temp == utf8); temp = WideToChar(wide0, enc); UNIT_ASSERT(temp == other); temp = Recode(enc, CODES_UTF8, other); UNIT_ASSERT(temp == utf8); temp = Recode(CODES_UTF8, enc, utf8); UNIT_ASSERT(temp == other); size_t read = 0; size_t written = 0; RECODE_RESULT res = RecodeToUnicode(enc, other.c_str(), wide1.begin(), other.size(), wide1.size(), read, written); UNIT_ASSERT(res == RECODE_OK); UNIT_ASSERT(read == other.size()); UNIT_ASSERT(written == wide1.size()); UNIT_ASSERT(wide0 == wide1); res = RecodeFromUnicode(enc, wide0.c_str(), temp.begin(), wide0.size(), temp.size(), read, written); UNIT_ASSERT(res == RECODE_OK); UNIT_ASSERT(read == wide0.size()); UNIT_ASSERT(written == other.size()); UNIT_ASSERT(temp == other); }
TSharedPtr<SLogWindow> FLogWindowManager::CreateLogWindow(FString Title, ELogType ExpectedFilters, bool bStatusWindow) { TSharedPtr<SLogWindow> ReturnVal = NULL; // Instead of searching for the first empty space, try to create log windows in a row pattern based upon the grid int FreeGridPos = FindFreeGridPos(); bool bMinimizeWindow = false; // If there is a free position, create the log window if (FreeGridPos != INDEX_NONE) { LastLogWindowPos = FreeGridPos; FLogGridEntry& CurEntry = GridSpaces[FreeGridPos]; ReturnVal = SNew(SLogWindow, Title, CurEntry.Left, CurEntry.Top, LogWidth, LogHeight) .bStatusWindow(bStatusWindow) .ExpectedFilters(ExpectedFilters); CurEntry.LogWindow = ReturnVal; } // If there isn't a free position, add to the overflow window array, and start the window minimized else { UNIT_ASSERT(GridSpaces.Num() > 0); // All minimized entries go into the first grid location FLogGridEntry& OverflowLoc = GridSpaces[0]; ReturnVal = SNew(SLogWindow, Title, OverflowLoc.Left, OverflowLoc.Top, LogWidth, LogHeight) .bStatusWindow(bStatusWindow) .ExpectedFilters(ExpectedFilters); bMinimizeWindow = true; OverflowWindows.Add(ReturnVal); } if (ReturnVal.IsValid()) { #if TARGET_UE4_CL >= CL_DEPRECATEDEL OnWindowClosedDelegateHandles.Add(ReturnVal.Get(), ReturnVal->MultiOnWindowClosed.AddRaw(this, &FLogWindowManager::OnWindowClosed)); #else ReturnVal->MultiOnWindowClosed.AddRaw(this, &FLogWindowManager::OnWindowClosed); #endif FSlateApplication::Get().AddWindow(ReturnVal.ToSharedRef()); if (bMinimizeWindow) { ReturnVal->Minimize(); } // Flash all newly focused windows, so it's clear the window is new (since it may take the place of an old window) else { ReturnVal->FlashWindow(); } } return ReturnVal; }
bool ANUTActor::NotifyControlMessage(UNetConnection* Connection, uint8 MessageType, FInBunch& Bunch) { bool bHandledMessage = false; if (MessageType == NMT_NUTControl) { uint8 CmdType = 0; FString Command; FNetControlMessage<NMT_NUTControl>::Receive(Bunch, CmdType, Command); // Console command if (CmdType == ENUTControlCommand::Command_NoResult || CmdType == ENUTControlCommand::Command_SendResult) { UE_LOG(LogUnitTest, Log, TEXT("NMT_NUTControl: Executing command: %s"), *Command); FStringOutputDevice CmdResult; CmdResult.SetAutoEmitLineTerminator(true); bool bCmdSuccess = false; bCmdSuccess = GEngine->Exec(GetWorld(), *Command, CmdResult); UE_LOG(LogUnitTest, Log, TEXT("NMT_NUTControl: Command result: %s"), *CmdResult); bool bSendResult = CmdType == ENUTControlCommand::Command_SendResult; if (bSendResult) { uint8 ReturnCmdType = (bCmdSuccess ? ENUTControlCommand::CommandResult_Success : ENUTControlCommand::CommandResult_Failed); FNetControlMessage<NMT_NUTControl>::Send(Connection, ReturnCmdType, CmdResult); } } // Console command result else if (CmdType == ENUTControlCommand::CommandResult_Failed || CmdType == ENUTControlCommand::CommandResult_Success) { bool bCmdSuccess = CmdType == ENUTControlCommand::CommandResult_Success; if (bCmdSuccess) { UE_LOG(LogUnitTest, Log, TEXT("NMT_NUTControl: Got command result:")); UE_LOG(LogUnitTest, Log, TEXT("%s"), *Command); } else { UE_LOG(LogUnitTest, Log, TEXT("NMT_NUTControl: Failed to execute command")); } } // Ping request else if (CmdType == ENUTControlCommand::Ping) { uint8 TempCmdType = ENUTControlCommand::Pong; FString Dud; FNetControlMessage<NMT_NUTControl>::Send(Connection, TempCmdType, Dud); } // Pong reply - this should only be implemented by custom unit tests; hence the assert else if (CmdType == ENUTControlCommand::Pong) { UNIT_ASSERT(false); } // Custom implemented events, with the result triggered through 'NotifyEvent' else if (CmdType == ENUTControlCommand::WatchEvent) { // NOTE: Only the last NetConnection to request a WatchEvent, will receive notifications EventWatcher = Connection; // Watch for the end of seamless travel if (Command == TEXT("SeamlessTravelEnd")) { FCoreUObjectDelegates::PostLoadMap.AddStatic(&ANUTActor::NotifyPostLoadMap); } } // Event watch notification - should only be implemented by custom unit tests else if (CmdType == ENUTControlCommand::NotifyEvent) { UNIT_ASSERT(false); } // Create an actor instance (the 'summon' console command, doesn't work without a cheat manager) else if (CmdType == ENUTControlCommand::Summon) { const TCHAR* Cmd = *Command; FString SpawnClassName = FParse::Token(Cmd, false); bool bForceBeginPlay = FParse::Param(Cmd, TEXT("ForceBeginPlay")); // Hack specifically for getting the GameplayDebugger working - think the mainline code is broken bool bGameplayDebuggerHack = FParse::Param(Cmd, TEXT("GameplayDebuggerHack")); UClass* SpawnClass = FindObject<UClass>(NULL, *SpawnClassName); if (SpawnClass != NULL) { FActorSpawnParameters SpawnParms; SpawnParms.Owner = GetOwner(); AActor* NewActor = GetWorld()->SpawnActor<AActor>(SpawnClass, SpawnParms); if (NewActor != NULL) { UE_LOG(LogUnitTest, Log, TEXT("Successfully summoned actor of class '%s'"), *SpawnClassName); if (bForceBeginPlay && !NewActor->HasActorBegunPlay()) { UE_LOG(LogUnitTest, Log, TEXT("Forcing call to 'BeginPlay' on newly spawned actor.")); NewActor->BeginPlay(); } if (bGameplayDebuggerHack) { // Assign the LocalPlayerOwner property, to the PC owning this NUTActor, using reflection (to avoid dependency) UObjectProperty* LocalPlayerOwnerProp = FindField<UObjectProperty>(NewActor->GetClass(), TEXT("LocalPlayerOwner")); if (LocalPlayerOwnerProp != NULL) { LocalPlayerOwnerProp->SetObjectPropertyValue( LocalPlayerOwnerProp->ContainerPtrToValuePtr<UObject*>(NewActor), GetOwner()); } else { UE_LOG(LogUnitTest, Log, TEXT("WARNING: Failed to find 'LocalPlayerOwner' property. Unit test broken.")); } // Also hack-disable ticking, so that the replicator doesn't spawn a second replicator NewActor->SetActorTickEnabled(false); } } else { UE_LOG(LogUnitTest, Log, TEXT("SpawnActor failed for class '%s'"), *Command); } } else { UE_LOG(LogUnitTest, Log, TEXT("Could not find actor class '%s'"), *Command); } } // Suspend the game, until a resume request is received (used for giving time, to attach a debugger) else if (CmdType == ENUTControlCommand::SuspendProcess) { UE_LOG(LogUnitTest, Log, TEXT("Suspend start.")); // Setup a named pipe, to monitor for the resume request FString ResumePipeName = FString::Printf(TEXT("%s%u"), NUT_SUSPEND_PIPE, FPlatformProcess::GetCurrentProcessId()); FPlatformNamedPipe ResumePipe; bool bPipeCreated = ResumePipe.Create(ResumePipeName, true, false); if (bPipeCreated) { if (!ResumePipe.OpenConnection()) { UE_LOG(LogUnitTest, Log, TEXT("WARNING: Failed to open pipe connection.")); } } else { UE_LOG(LogUnitTest, Log, TEXT("WARNING: Failed to create resume pipe.")); } // Spin/sleep (effectively suspended) until a resume request is received while (true) { if (bPipeCreated && ResumePipe.IsReadyForRW()) { int32 ResumeVal = 0; if (ResumePipe.ReadInt32(ResumeVal) && !!ResumeVal) { UE_LOG(LogUnitTest, Log, TEXT("Got resume request.")); break; } } FPlatformProcess::Sleep(1.0f); } ResumePipe.Destroy(); UE_LOG(LogUnitTest, Log, TEXT("Suspend end.")); } bHandledMessage = true; } return bHandledMessage; }
inline void TestGetPageSize() { UNIT_ASSERT(NSystemInfo::GetPageSize() >= 4096); }
inline void TestNumberOfCpus() { UNIT_ASSERT(NSystemInfo::NumberOfCpus() > 0); UNIT_ASSERT_EQUAL(NSystemInfo::NumberOfCpus(), NSystemInfo::CachedNumberOfCpus()); }