// ---------------------------------------------------------------------------
// Test entry point
// ---------------------------------------------------------------------------
bool testRefStack()
{
XERCES_STD_QUALIFIER wcout << L"----------------------------------\n"
<< L"Testing RefStackOf template class\n"
<< L"----------------------------------" << XERCES_STD_QUALIFIER endl;
bool retVal = true;
try
{
// Call other local methods to do specific tests
XERCES_STD_QUALIFIER wcout << L"Testing RefStackOf basics" << XERCES_STD_QUALIFIER endl;
if (!basicTests())
{
XERCES_STD_QUALIFIER wcout << L"RefStackOf basic tests failed" << XERCES_STD_QUALIFIER endl;
retVal = false;
}
else
{
XERCES_STD_QUALIFIER wcout << L"RefArrayOf constructor tests passed"
<< XERCES_STD_QUALIFIER endl;
}
XERCES_STD_QUALIFIER wcout << XERCES_STD_QUALIFIER endl;
}
catch(const XMLException& toCatch)
{
XERCES_STD_QUALIFIER wcout << L" ERROR: Unexpected exception!\n Msg: "
<< toCatch.getMessage() << XERCES_STD_QUALIFIER endl;
return false;
}
return retVal;
}
// ---------------------------------------------------------------------------
// Test entry point
// ---------------------------------------------------------------------------
bool testRefHashTable()
{
XERCES_STD_QUALIFIER wcout << L"----------------------------------\n"
<< L"Testing RefHashTableOf class\n"
<< L"----------------------------------" << XERCES_STD_QUALIFIER endl;
bool retVal = true;
try
{
XERCES_STD_QUALIFIER wcout << L"Testing basic RefHashtable methods" << XERCES_STD_QUALIFIER endl;
if (!basicTests())
{
XERCES_STD_QUALIFIER wcout << L"RefHashtable basic test methods failed"
<< XERCES_STD_QUALIFIER endl;
retVal = false;
}
else
{
XERCES_STD_QUALIFIER wcout << L"RefHashtable basic tests passed" << XERCES_STD_QUALIFIER endl;
}
XERCES_STD_QUALIFIER wcout << XERCES_STD_QUALIFIER endl;
}
catch(const XMLException& toCatch)
{
XERCES_STD_QUALIFIER wcout << L" ERROR: Unexpected exception!\n Msg: "
<< toCatch.getMessage() << XERCES_STD_QUALIFIER endl;
return false;
}
return retVal;
}
/**
* Unit test for UiList data structure.
*/
main() {
cout << "running basic tests\n";
basicTests();
cout << "basic tests passed\n";
// add more systematic tests for each individual method
}
tcu::TestCaseGroup* createBasicSemaphoreTests (tcu::TestContext& testCtx)
{
de::MovePtr<tcu::TestCaseGroup> basicTests(new tcu::TestCaseGroup(testCtx, "semaphore", "Basic semaphore tests"));
addFunctionCase(basicTests.get(), "one_queue", "Basic semaphore tests with one queue", basicOneQueueCase);
addFunctionCase(basicTests.get(), "multi_queue", "Basic semaphore tests with multi queue", basicMultiQueueCase);
addFunctionCase(basicTests.get(), "chain", "Semaphore chain test", basicChainCase);
return basicTests.release();
}
int main(void) {
uint8_t rc4State[256]; // RC4 state
const uint8_t rc4Key[132] = "This is a key that I am typing in so that I have something to test with, and then I can start testing. I just need more characters.";
uint8_t key[LIGHTMAC_KEY_LENGTH];
uint8_t singleblock[L_BLOCK_LENGTH];
unsigned int singleblockLength = L_BLOCK_LENGTH;
uint8_t multiblock[4*L_BLOCK_LENGTH];
unsigned int multiblockLength = 4*L_BLOCK_LENGTH;
uint8_t empty[0] = {};
unsigned int smallfractionalLength = L_BLOCK_LENGTH-1;
uint8_t smallfractional[L_BLOCK_LENGTH-1];
unsigned int largefractionalLength = 4*L_BLOCK_LENGTH-1;
uint8_t largefractional[4*L_BLOCK_LENGTH-1];
printf("Maximum message length: %llu bytes.\n", maxMessageLength());
arcfour_key_setup(rc4State, rc4Key, 131);
arcfour_generate_stream(rc4State, key, LIGHTMAC_KEY_LENGTH);
arcfour_generate_stream(rc4State, singleblock, singleblockLength);
basicTests(singleblock, singleblockLength, key, "Single block");
arcfour_generate_stream(rc4State, key, LIGHTMAC_KEY_LENGTH);
arcfour_generate_stream(rc4State, multiblock, multiblockLength);
basicTests(multiblock, multiblockLength, key, "Multi block");
arcfour_generate_stream(rc4State, key, LIGHTMAC_KEY_LENGTH);
basicTests(empty, 0, key, "Empty string");
arcfour_generate_stream(rc4State, key, LIGHTMAC_KEY_LENGTH);
arcfour_generate_stream(rc4State, smallfractional, smallfractionalLength);
basicTests(smallfractional, smallfractionalLength, key, "Small fractional message");
arcfour_generate_stream(rc4State, key, LIGHTMAC_KEY_LENGTH);
arcfour_generate_stream(rc4State, largefractional, largefractionalLength);
basicTests(largefractional, largefractionalLength, key, "Large fractional message");
}
// ---------------------------------------------------------------------------
// Test entry point
// ---------------------------------------------------------------------------
bool testBitSet()
{
XERCES_STD_QUALIFIER wcout << L"----------------------------------\n"
<< L"Testing BitSet class\n"
<< L"----------------------------------" << XERCES_STD_QUALIFIER endl;
bool retVal = true;
try
{
XERCES_STD_QUALIFIER wcout << L"Testing basic BitSet methods" << XERCES_STD_QUALIFIER endl;
if (!basicTests())
{
XERCES_STD_QUALIFIER wcout << L"Bitset basic test methods failed" << XERCES_STD_QUALIFIER endl;
retVal = false;
}
else
{
XERCES_STD_QUALIFIER wcout << L"Bitset basic tests passed" << XERCES_STD_QUALIFIER endl;
}
XERCES_STD_QUALIFIER wcout << XERCES_STD_QUALIFIER endl;
XERCES_STD_QUALIFIER wcout << L"Testing BitSet logical bit ops methods" << XERCES_STD_QUALIFIER endl;
if (!bitopsTests())
{
XERCES_STD_QUALIFIER wcout << L"Bitset logical bit ops failed" << XERCES_STD_QUALIFIER endl;
retVal = false;
}
else
{
XERCES_STD_QUALIFIER wcout << L"Bitset logical bit ops passed" << XERCES_STD_QUALIFIER endl;
}
XERCES_STD_QUALIFIER wcout << XERCES_STD_QUALIFIER endl;
}
catch(const XMLException& toCatch)
{
XERCES_STD_QUALIFIER wcout << L" ERROR: Unexpected exception!\n Msg: "
<< toCatch.getMessage() << XERCES_STD_QUALIFIER endl;
return false;
}
return retVal;
}
main() {
basicTests();
}
int main(int argc, char** argv)
{
U32 seed=0;
int seedset=0;
int argNb;
int nbTests = nbTestsDefault;
int testNb = 0;
int proba = FUZ_COMPRESSIBILITY_DEFAULT;
int result=0;
U32 duration=0;
/* Check command line */
programName = argv[0];
for(argNb=1; argNb<argc; argNb++)
{
char* argument = argv[argNb];
if(!argument) continue; /* Protection if argument empty */
/* Decode command (note : aggregated commands are allowed) */
if (argument[0]=='-')
{
if (!strcmp(argument, "--no-prompt"))
{
no_prompt=1;
seedset=1;
displayLevel=1;
continue;
}
argument++;
while (*argument!=0)
{
switch(*argument)
{
case 'h':
return FUZ_usage();
case 'v':
argument++;
displayLevel=4;
break;
case 'q':
argument++;
displayLevel--;
break;
case 'p': /* pause at the end */
argument++;
pause = 1;
break;
case 'i':
argument++;
nbTests=0; duration=0;
while ((*argument>='0') && (*argument<='9'))
{
nbTests *= 10;
nbTests += *argument - '0';
argument++;
}
break;
case 'T':
argument++;
nbTests = 0; duration = 0;
for (;;)
{
switch(*argument)
{
case 'm': duration *= 60; argument++; continue;
case 's':
case 'n': argument++; continue;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9': duration *= 10; duration += *argument++ - '0'; continue;
}
break;
}
break;
case 's':
argument++;
seed=0;
seedset=1;
while ((*argument>='0') && (*argument<='9'))
{
seed *= 10;
seed += *argument - '0';
argument++;
}
break;
case 't':
argument++;
testNb=0;
while ((*argument>='0') && (*argument<='9'))
{
testNb *= 10;
testNb += *argument - '0';
argument++;
}
break;
case 'P': /* compressibility % */
argument++;
proba=0;
while ((*argument>='0') && (*argument<='9'))
{
proba *= 10;
proba += *argument - '0';
argument++;
}
if (proba<0) proba=0;
if (proba>100) proba=100;
break;
default:
;
return FUZ_usage();
}
}
}
}
/* Get Seed */
printf("Starting lz4sg tester (%i-bits, %s)\n", (int)(sizeof(size_t)*8), LZ4_VERSION);
if (!seedset) seed = FUZ_GetMilliStart() % 10000;
printf("Seed = %u\n", seed);
if (proba!=FUZ_COMPRESSIBILITY_DEFAULT) printf("Compressibility : %i%%\n", proba);
DISPLAYLEVEL(1, "Seed = %u Compressibility = %i%%\n", seed, proba);
if (nbTests<=0) nbTests=1;
if (testNb==0) result = basicTests(seed, ((double)proba) / 100);
if (result) return 1;
return fuzzerTests(seed, nbTests, testNb, ((double)proba) / 100, duration);
}
void
run()
{
basicTests();
stressTest();
}
