static int do_test (void) { if (signal (SIGUSR1, sigusr1_handler) == SIG_ERR) FAIL_EXIT1 ("signal (SIGUSR1): %m\n"); sigset_t sigs; sigemptyset (&sigs); sigaddset (&sigs, SIGUSR2); if (sigprocmask (SIG_BLOCK, &sigs, NULL) != 0) FAIL_EXIT1 ("sigprocmask (SIGBLOCK, SIGUSR2): %m"); pid_t pid = signal_sender (); int signo = 0; int ret = sigwait (&sigs, &signo); if (ret != 0) { support_record_failure (); errno = ret; printf ("error: sigwait failed: %m (%d)\n", ret); } TEST_VERIFY (signo == SIGUSR2); int status; xwaitpid (pid, &status, 0); TEST_VERIFY (status == 0); return 0; }
void CAliasTest::Run() { memset(&m_context, 0, sizeof(m_context)); m_context.value1[0] = CONSTANT_1; m_context.value1[1] = CONSTANT_2; for(unsigned int i = 0; i < 4; i++) { m_context.value2[i] = CONSTANT_3; m_context.value3[i] = CONSTANT_3; } m_context.value4[0] = 0x01234567; m_context.value4[1] = 0x01234567; m_context.value4[2] = 0x01234567; m_context.value4[3] = 0x01234567; m_function(&m_context); TEST_VERIFY(m_context.result != 0); TEST_VERIFY(m_context.value4[0] == (CONSTANT_3 * 2)); TEST_VERIFY(m_context.value4[1] == 0); TEST_VERIFY(m_context.value4[2] == 0); TEST_VERIFY(m_context.value4[3] == (CONSTANT_3 * 2)); }
void SoundTest::PlayStopEffect(PerfFuncData * data) { SoundInstance * clickInst = sndClick->Play(); TEST_VERIFY(clickInst->GetState() == SoundInstance::STATE_PLAYING); sndClick->Stop(); TEST_VERIFY(clickInst->GetState() == SoundInstance::STATE_FORCED_STOPPED); }
void SoundTest::PlayStopMusic(PerfFuncData * data) { SoundInstance * musicInst = music->Play(); TEST_VERIFY(musicInst->GetState() == SoundInstance::STATE_PLAYING); music->Stop(); TEST_VERIFY(musicInst->GetState() == SoundInstance::STATE_FORCED_STOPPED); }
void CRandomAluTest3::Run() { memset(&m_context, 0, sizeof(CONTEXT)); m_context.number1 = TEST_NUMBER1; m_context.number2 = TEST_NUMBER2; m_function(&m_context); TEST_VERIFY(m_context.number1 == static_cast<uint32>(TEST_NUMBER1 ^ TEST_NUMBER2)); TEST_VERIFY(m_context.number2 == m_context.number1); }
/* Return a string of SIZE characters. */ const char * repeating_string (int size) { TEST_VERIFY (size >= 0); TEST_VERIFY (size <= repeat_size); const char *repeated_shifted = repeat + repeat_size - size; TEST_VERIFY (strlen (repeated_shifted) == size); return repeated_shifted; }
void CFpIntMixTest::Run() { memset(&m_context, 0, sizeof(CONTEXT)); m_context.multiplier = 2; m_function(&m_context); TEST_VERIFY(m_context.multiplier == 2); TEST_VERIFY(*reinterpret_cast<uint32*>(&m_context.number1) == 200); TEST_VERIFY(m_context.number2 == 2.0f); TEST_VERIFY(m_context.result == 200); }
void HashMapTest::HashMapInsertRemoveGetTest(PerfFuncData * data) { const int sz = 20000; DAVA::int32 i; DAVA::Vector<DAVA::uint32> vect; DAVA::HashMap<DAVA::int32, DAVA::uint32> map; vect.resize(sz); for(i = 0; i < sz; ++i) { DAVA::uint32 v = (i + 1); // any value vect[i] = v; map.Insert(i, v); } // Get test for(i = 0; i < sz; ++i) { TEST_VERIFY(vect[i] == map[i]); } // remove some items for (int i = 0; i < sz/10; i++) { int index = DAVA::Random::Instance()->Rand(sz); vect[i] = 0; map.Remove(i); } // check get after remove for (int i = 0; i < sz; i++) { if(0 != vect[i]) { TEST_VERIFY(vect[i] == map[i]); } } // iterator test DAVA::HashMap<DAVA::int32, DAVA::uint32>::Iterator iter = map.Begin(); for(; iter != map.End(); ++iter) { TEST_VERIFY(vect[iter.GetKey()] == iter.GetValue()); } // 0-size hash map iterator test DAVA::HashMap<DAVA::int32, DAVA::uint32> map0; iter = map0.Begin(); for (; iter != map0.End(); ++iter) {} }
void SoundTest::CreateInvalidSounds(PerfFuncData * data) { Sound * sound = 0; sound = Sound::Create("", (Sound::eType)1111); TEST_VERIFY(sound == 0); sound = Sound::Create("?InvalidPath", Sound::TYPE_STATIC); TEST_VERIFY(sound == 0); sound = Sound::CreateFX("", Sound::TYPE_STATIC); TEST_VERIFY(sound == 0); sound = Sound::CreateFX("//InvalidPath", (Sound::eType)333); TEST_VERIFY(sound == 0); sound = Sound::CreateMusic("", (Sound::eType)222); TEST_VERIFY(sound == 0); sound = Sound::CreateMusic(":\\InvalidPath", Sound::TYPE_STREAMED); TEST_VERIFY(sound == 0); #ifdef __DAVAENGINE_IPHONE__ sound = Sound::CreateMusic("~res:/Sounds/null.caf", Sound::TYPE_STREAMED); TEST_VERIFY(sound == 0); SafeRelease(sound); #else sound = Sound::CreateMusic("~res:/Sounds/null.ogg", Sound::TYPE_STREAMED); TEST_VERIFY(sound == 0); SafeRelease(sound); #endif }
void CMemAccessTest::Run() { memset(&m_context, 0, sizeof(m_context)); memset(&m_memory, 0x80, sizeof(m_memory)); m_context.offset = 0x4; m_context.memory = m_memory; m_context.array0[ARRAY_IDX_1] = CONSTANT_1; m_function(&m_context); TEST_VERIFY(m_memory[1] == CONSTANT_1); TEST_VERIFY(m_context.result0 == 0x80808080); TEST_VERIFY(m_context.result1 == CONSTANT_1); TEST_VERIFY(m_context.array0[ARRAY_IDX_0] == CONSTANT_2); }
void LocalizationTest::TestFunction(TestTemplate<LocalizationTest>::PerfFuncData *data) { FilePath srcFile = srcDir + (files[currentTest] + ".yaml"); FilePath cpyFile = cpyDir + (files[currentTest] + ".yaml"); FileSystem::Instance()->CopyFile(srcFile, cpyFile); LocalizationSystem* localizationSystem = LocalizationSystem::Instance(); localizationSystem->SetCurrentLocale(files[currentTest]); localizationSystem->InitWithDirectory(cpyDir); localizationSystem->SaveLocalizedStrings(); localizationSystem->Cleanup(); bool res = CompareFiles(srcFile, cpyFile); String s = Format("Localization test %d: %s - %s", currentTest, files[currentTest].c_str(), (res ? "passed" : "fail")); Logger::Debug(s.c_str()); data->testData.message = s; TEST_VERIFY(res); ++currentTest; }
void PVRTest::TestFunction(PerfFuncData * data) { DVASSERT(currentTest < TESTS_COUNT); if(IsCurrentTestAccepted()) { ReloadSprites(); TextureUtils::CompareResult result = TextureUtils::CompareSprites(decompressedPNGSprite, pvrSprite, formats[currentTest]); float32 differencePersentage = ((float32)result.difference / ((float32)result.bytesCount * 256.f)) * 100.f; data->testData.message = Format("\nDifference: %f%%\nCoincidence: %f%%", differencePersentage, 100.f - differencePersentage); compareResultText->SetText(StringToWString(data->testData.message)); Logger::Debug(data->testData.message.c_str()); TEST_VERIFY(differencePersentage < (float32)ACCETABLE_DELTA_IN_PERSENTS); //Save images for visual comparision Image *firstComparer = TextureUtils::CreateImageAsRGBA8888(decompressedPNGSprite); Image *secondComparer = TextureUtils::CreateImageAsRGBA8888(pvrSprite); FilePath documentsPath = FileSystem::Instance()->GetCurrentDocumentsDirectory(); ImageSystem::Instance()->Save(documentsPath + Format("PVRTest/src_number_%d.png", currentTest), firstComparer); ImageSystem::Instance()->Save(documentsPath + Format("PVRTest/dst_number_%d.png", currentTest), secondComparer); SafeRelease(firstComparer); SafeRelease(secondComparer); } ++currentTest; }
static int do_test (void) { sem_t s; struct timespec ts; struct timeval tv; TEST_COMPARE (sem_init (&s, 0, 1), 0); TEST_COMPARE (TEMP_FAILURE_RETRY (sem_wait (&s)), 0); TEST_COMPARE (gettimeofday (&tv, NULL), 0); TIMEVAL_TO_TIMESPEC (&tv, &ts); /* We wait for half a second. */ ts.tv_nsec += 500000000; if (ts.tv_nsec >= 1000000000) { ++ts.tv_sec; ts.tv_nsec -= 1000000000; } errno = 0; TEST_COMPARE (TEMP_FAILURE_RETRY (sem_timedwait (&s, &ts)), -1); TEST_COMPARE (errno, ETIMEDOUT); struct timespec ts2; TEST_COMPARE (clock_gettime (CLOCK_REALTIME, &ts2), 0); TEST_VERIFY (ts2.tv_sec > ts.tv_sec || (ts2.tv_sec == ts.tv_sec && ts2.tv_nsec > ts.tv_nsec)); return 0; }
void CCmp64Test::Run() { memset(&m_context, 0, sizeof(m_context)); m_context.value0 = m_value0; m_context.value1 = m_value1; m_function(&m_context); uint32 resultEq = (m_value0 == m_value1) ? 1 : 0; uint32 resultNe = (m_value0 != m_value1) ? 1 : 0; uint32 resultBl = static_cast<uint64>(m_value0) < static_cast<uint64>(m_value1) ? 1 : 0; uint32 resultLt = static_cast<int64>(m_value0) < static_cast<int64>(m_value1) ? 1 : 0; uint32 resultLe = static_cast<int64>(m_value0) <= static_cast<int64>(m_value1) ? 1 : 0; uint32 resultAb = static_cast<uint64>(m_value0) > static_cast<uint64>(m_value1) ? 1 : 0; uint32 resultGt = static_cast<int64>(m_value0) > static_cast<int64>(m_value1) ? 1 : 0; TEST_VERIFY(m_context.resultEq == resultEq); TEST_VERIFY(m_context.resultNe == resultNe); TEST_VERIFY(m_context.resultBl == resultBl); TEST_VERIFY(m_context.resultLt == resultLt); TEST_VERIFY(m_context.resultLe == resultLe); TEST_VERIFY(m_context.resultAb == resultAb); TEST_VERIFY(m_context.resultGt == resultGt); }
void SoundTest::CreateValidSounds(PerfFuncData * data) { Sound * sound = 0; sound = Sound::CreateFX("~res:/Sounds/click.wav", Sound::TYPE_STATIC); TEST_VERIFY(sound != 0); SafeRelease(sound); #ifdef __DAVAENGINE_IPHONE__ sound = Sound::CreateMusic("~res:/Sounds/map.caf", Sound::TYPE_STREAMED); TEST_VERIFY(sound != 0); SafeRelease(sound); #else sound = Sound::CreateMusic("~res:/Sounds/map.ogg", Sound::TYPE_STREAMED); TEST_VERIFY(sound != 0); SafeRelease(sound); #endif }
static int do_test (void) { /* It first allocates a open file description lock range which can not be represented in a 32 bit struct flock. */ struct flock64 lck64 = { .l_type = F_WRLCK, .l_whence = SEEK_SET, .l_start = (off64_t)INT32_MAX + 1024, .l_len = 1024, }; int ret = fcntl64 (temp_fd, F_OFD_SETLKW, &lck64); if (ret == -1 && errno == EINVAL) /* OFD locks are only available on Linux 3.15. */ FAIL_UNSUPPORTED ("fcntl (F_OFD_SETLKW) not supported"); TEST_VERIFY_EXIT (ret == 0); /* Open file description locks placed through the same open file description (either by same file descriptor or a duplicated one created by fork, dup, fcntl F_DUPFD, etc.) overwrites then old lock. To force a conflicting lock combination, it creates a new file descriptor. */ int fd = open64 (temp_filename, O_RDWR, 0666); TEST_VERIFY_EXIT (fd != -1); /* It tries then to allocate another open file descriptior with a valid non-LFS bits struct flock but which will result in a conflicted region which can not be represented in a non-LFS struct flock. */ struct flock lck = { .l_type = F_WRLCK, .l_whence = SEEK_SET, .l_start = INT32_MAX - 1024, .l_len = 4 * 1024, }; int r = fcntl (fd, F_OFD_GETLK, &lck); if (sizeof (off_t) != sizeof (off64_t)) TEST_VERIFY (r == -1 && errno == EOVERFLOW); else TEST_VERIFY (r == 0); return 0; }
void CMemAccessRefTest::Run() { memset(&m_context, 0, sizeof(m_context)); for(uint32 i = 0; i < MEMORY_SIZE; i++) { m_memory[i] = nullptr; } m_memory[LOAD_IDX] = &m_context.readValue; m_context.readValue = CONSTANT_1; m_context.memory = m_memory; m_function(&m_context); TEST_VERIFY(m_context.readValueResult == CONSTANT_1); TEST_VERIFY(m_context.nullCheck0 != 0); TEST_VERIFY(m_context.nullCheck1 == 0); TEST_VERIFY(m_context.nullCheck2 != 0); TEST_VERIFY(m_context.nullCheck3 == 0); }
void SoundTest::Update(float32 timeElapsed) { if(effectPlayTest) { if(effectIns->GetState() == SoundInstance::STATE_PLAYING) return; else TEST_VERIFY(effectIns->GetState() == SoundInstance::STATE_COMPLETED); } TestTemplate<SoundTest>::Update(timeElapsed); }
static int do_test (void) { activate_test_gconv_modules (); TEST_VERIFY (iconv_open ("UTF-8", "tst-gconv-init-failure//") == (iconv_t) -1); if (errno != ENOMEM) FAIL_EXIT1 ("unexpected iconv_open error: %m"); return 0; }
void CMdFpFlagTest::Run() { CONTEXT ALIGN16 context; memset(&context, 0, sizeof(CONTEXT)); context.src0[0] = 0.123412f; context.src0[1] = -0.2324f; context.src0[2] = 0.f; context.src0[3] = -0.f; context.src1[0] = 60.f; context.src1[1] = 600.f; context.src1[2] = -60.f; context.src1[3] = 6.f; context.src2[0] = -5.5f; context.src2[1] = 0; context.src2[2] = -7.5f; context.src2[3] = -8.5f; m_function(&context); TEST_VERIFY(context.dstIsNegative0 == 0x4); TEST_VERIFY(context.dstIsZero0 == 0x3); TEST_VERIFY(context.dstIsNegative1 == 0x2); TEST_VERIFY(context.dstIsZero1 == 0x0); TEST_VERIFY(context.dstIsNegative2 == 0xB); TEST_VERIFY(context.dstIsZero2 == 0x4); }
void CMdFpFlagTest::Run() { //Some documentation about the flags: //IsNegative -> Set when value's sign bit is set (regardless of value) //IsZero -> Set when value is either +0 or -0 CONTEXT ALIGN16 context; memset(&context, 0, sizeof(CONTEXT)); context.src0[0] = 0.123412f; context.src0[1] = -0.2324f; context.src0[2] = 0.f; context.src0[3] = -0.f; context.src1[0] = 60.f; context.src1[1] = 600.f; context.src1[2] = -60.f; context.src1[3] = 6.f; context.src2[0] = -5.5f; context.src2[1] = 0; context.src2[2] = -7.5f; context.src2[3] = -8.5f; m_function(&context); TEST_VERIFY(context.dstIsNegative0 == 0x5); TEST_VERIFY(context.dstIsZero0 == 0x3); TEST_VERIFY(context.dstIsNegative1 == 0x2); TEST_VERIFY(context.dstIsZero1 == 0x0); TEST_VERIFY(context.dstIsNegative2 == 0xB); TEST_VERIFY(context.dstIsZero2 == 0x4); }
/* Test GCONV_PATH to the directory containing the program executable. */ static void activate_test_gconv_modules (void) { unsigned long ptr = getauxval (AT_EXECFN); if (ptr == 0) { printf ("warning: AT_EXECFN not support, cannot run test\n"); exit (EXIT_UNSUPPORTED); } char *test_program_directory = dirname (xstrdup ((const char *) ptr)); TEST_VERIFY (setenv ("GCONV_PATH", test_program_directory, 1) == 0); free (test_program_directory); }
static int do_test (void) { TEST_VERIFY (_XOPEN_IOV_MAX == 16); /* Value required by POSIX. */ TEST_VERIFY (uio_maxiov_value () >= _XOPEN_IOV_MAX); TEST_VERIFY (IOV_MAX == uio_maxiov_value ()); TEST_VERIFY (UIO_MAXIOV == uio_maxiov_value ()); TEST_VERIFY (sysconf (_SC_UIO_MAXIOV) == uio_maxiov_value ()); TEST_VERIFY (sysconf (_SC_IOV_MAX) == uio_maxiov_value ()); return 0; }
void CSimpleMdTest::Run() { memset(&m_context, 0, sizeof(m_context)); for(unsigned int i = 0; i < 4; i++) { m_context.op1[i] = i * 0x10000; m_context.op2[i] = i; } m_function(&m_context); for(unsigned int i = 0; i < 4; i++) { TEST_VERIFY(m_context.result[i] == m_context.op1[i] + m_context.op2[i]); } }
static int do_test (void) { test_exact_fit ("abc", 5); test_exact_fit ("abc.", 5); { char long_name[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa." "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa." "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa." "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa."; TEST_VERIFY (strlen (long_name) == NS_MAXCDNAME - 1); test_exact_fit (long_name, NS_MAXCDNAME); long_name[sizeof (long_name) - 1] = '\0'; test_exact_fit (long_name, NS_MAXCDNAME); } return 0; }
void CAliasTest2::Run() { memset(&m_context, 0, sizeof(m_context)); for(int i = 0; i < 4; i++) { m_context.value2[i] = 1.0f; } m_function(&m_context); TEST_VERIFY(m_context.value1[0] == 3.0f); TEST_VERIFY(m_context.value1[1] == 3.0f); TEST_VERIFY(m_context.value1[2] == 3.0f); TEST_VERIFY(m_context.value1[3] == 4.0f); TEST_VERIFY(m_context.value3[0] == 4.0f); TEST_VERIFY(m_context.value3[1] == 4.0f); TEST_VERIFY(m_context.value3[2] == 4.0f); TEST_VERIFY(m_context.value3[3] == 4.0f); }
static int do_test (void) { char *dir = support_create_temp_directory ("tst-xreadlink-"); char *symlink_name = xasprintf ("%s/symlink", dir); add_temp_file (symlink_name); /* The limit 10000 is arbitrary and simply there to prevent an attempt to exhaust all available disk space. */ for (int size = 1; size < 10000; ++size) { char *contents = xmalloc (size + 1); for (int i = 0; i < size; ++i) contents[i] = 'a' + (rand () % 26); contents[size] = '\0'; if (symlink (contents, symlink_name) != 0) { if (errno == ENAMETOOLONG) { printf ("info: ENAMETOOLONG failure at %d bytes\n", size); free (contents); break; } FAIL_EXIT1 ("symlink (%d bytes): %m", size); } char *readlink_result = xreadlink (symlink_name); TEST_VERIFY (strcmp (readlink_result, contents) == 0); free (readlink_result); xunlink (symlink_name); free (contents); } /* Create an empty file to suppress the temporary file deletion warning. */ xclose (xopen (symlink_name, O_WRONLY | O_CREAT, 0)); free (symlink_name); free (dir); return 0; }
void CMdMemAccessTest::Run() { memset(&m_context, 0, sizeof(m_context)); memset(m_memory, 0x20, sizeof(m_memory)); m_context.array = m_memory; for(unsigned int i = 0; i < 4; i++) { m_context.op[i] = i * 0x10000; } m_function(&m_context); TEST_VERIFY(m_context.result[0] == 0x20202020); TEST_VERIFY(m_context.result[1] == 0x20202020); TEST_VERIFY(m_context.result[2] == 0x20202020); TEST_VERIFY(m_context.result[3] == 0x20202020); TEST_VERIFY(m_memory[4] == 0x00000); TEST_VERIFY(m_memory[5] == 0x10000); TEST_VERIFY(m_memory[6] == 0x20000); TEST_VERIFY(m_memory[7] == 0x30000); }
static void narrow (const char *path) { FILE *old_stdin = stdin; stdin = xfopen (path, "r"); TEST_COMPARE (getchar (), 'a'); TEST_COMPARE (getchar_unlocked (), 'b'); char ch = 1; TEST_COMPARE (scanf ("%c", &ch), 1); TEST_COMPARE (ch, 'c'); TEST_COMPARE (call_vscanf ("%c", &ch), 1); TEST_COMPARE (ch, 'd'); char buf[8]; memset (buf, 'X', sizeof (buf)); /* Legacy interface. */ extern char *gets (char *); TEST_VERIFY (gets (buf) == buf); TEST_COMPARE_BLOB (buf, sizeof (buf), "ef\0XXXXX", sizeof (buf)); fclose (stdin); stdin = old_stdin; }
void CAlu64Test::Run() { memset(&m_context, 0, sizeof(m_context)); m_context.value0 = CONSTANT_1; m_context.value1 = CONSTANT_2; m_context.value2 = CONSTANT_3; m_context.value3 = CONSTANT_4; m_function(&m_context); TEST_VERIFY(m_context.resultAdd0 == (CONSTANT_1 + CONSTANT_2)); TEST_VERIFY(m_context.resultAdd1 == (CONSTANT_3 + CONSTANT_4)); TEST_VERIFY(m_context.resultAddCst == (CONSTANT_1 + CONSTANT_5)); TEST_VERIFY(m_context.resultSub0 == (CONSTANT_1 - CONSTANT_2)); TEST_VERIFY(m_context.resultSub1 == (CONSTANT_3 - CONSTANT_4)); TEST_VERIFY(m_context.resultSubCst == (CONSTANT_5 - CONSTANT_1)); }