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));
}
