Test *ArchivoAdjuntoTest::suite()
{
typedef struct _Entrada
{
char *nombre;
void (ArchivoAdjuntoTest::*metodo)();
} Entrada;
static Entrada pruebas[] =
{
{"testSize", &ArchivoAdjuntoTest::testSize},
{"testFilename", &ArchivoAdjuntoTest::testFilename},
{"testConstructorFilename", &ArchivoAdjuntoTest::testConstructorFilename},
{"testReadTextData", &ArchivoAdjuntoTest::testReadTextData},
{"testReadZeroTextData", &ArchivoAdjuntoTest::testReadZeroTextData},
{"testReadDataNoExiste", &ArchivoAdjuntoTest::testReadDataNoExiste},
{"testEncode", &ArchivoAdjuntoTest::testEncode}
};
int TotalEntradas = sizeof(pruebas)/sizeof(Entrada);
TestSuite *suite = new TestSuite("ArchivoAdjunto");
for (int i=0; i<TotalEntradas; i++)
suite->addTest( new ArchivoAdjuntoTestCaller(pruebas[i].nombre, pruebas[i].metodo) );
return suite;
}
static Test* suite() {
TestSuite* testsSuite = new TestSuite("NelderMeadTest");
testsSuite->addTest(new TestCaller<NelderMeadTest>("creationTest", &NelderMeadTest::creationTest));
testsSuite->addTest(new TestCaller<NelderMeadTest>("calculateTest", &NelderMeadTest::calculateTest));
return testsSuite;
}
static Test* suite()
{
TestSuite* suite = new TestSuite( "QuizTest");
suite->addTest( new TEST_CALLER( QuizTest, testQuestion));
suite->addTest( new TEST_CALLER( QuizTest, testAnswer));
return suite;
}
void runTestCase(void* item, void* extraData) {
TestCase testCase = (TestCase)item;
TestSuite testSuite = (TestSuite)extraData;
int result;
if(!testSuite->onlyPrintFailing) {
printTestName(testCase->name);
}
if(testCase->testCaseFunc != NULL) {
if(testSuite->setup != NULL) {
testSuite->setup();
}
result = testCase->testCaseFunc();
if(result == 0) {
if(!testSuite->onlyPrintFailing) {
printTestSuccess();
}
testSuite->numSuccess++;
}
else {
printTestFail();
testSuite->numFail++;
}
if(testSuite->teardown != NULL) {
testSuite->teardown();
}
}
else {
if(!testSuite->onlyPrintFailing) {
_printTestSkipped();
}
testSuite->numSkips++;
}
}
void TestSuite::ThreadProc(void* inParam)
{
LOG("Entering TestSuite::ThreadProc");
TestSuite* instance = reinterpret_cast<TestSuite*>(inParam);
if (instance)
{
string filename;
float counter = 1.0f;
while(instance->mProcessing && (filename = instance->getNextFile()) != "")
{
TestSuiteGame theGame(instance, filename);
if(theGame.isOK)
{
theGame.observer->loadTestSuitePlayer(0, &theGame);
theGame.observer->loadTestSuitePlayer(1, &theGame);
theGame.observer->startGame(theGame.gameType, /*instance->mRules*/Rules::getRulesByFilename("testsuite.txt"));
theGame.initGame();
while(!theGame.observer->didWin())
theGame.observer->Update(counter++);
}
}
}
LOG("Leaving TestSuite::ThreadProc");
}
Test *StreamCase::suite()
{
TestSuite *suite = new StreamCase;
/*
* Register all sub stream test suites.
*/
STREAM_REGISTER_SUB_SUITE(memStream);
STREAM_REGISTER_SUB_SUITE(strStream);
STREAM_REGISTER_SUB_SUITE(fileStream);
STREAM_REGISTER_SUB_SUITE(ffileStream);
STREAM_REGISTER_SUB_SUITE(tempStream);
STREAM_REGISTER_SUB_SUITE(zlibStream);
STREAM_REGISTER_SUB_SUITE(backStream);
extern CppUnit::Test* GetlargeFileSuite();
Test *lfs = GetlargeFileSuite();
if (lfs)
suite->addTest(lfs);
/*
** Add more stream subtests here
*/
return suite;
}
Test *QueryTestCase::suite ()
{
TestSuite *testSuite = new TestSuite ("QueryTestCase");
testSuite->addTest (makeTestCaller("testSimpleQuery", &QueryTestCase::testSimpleQuery));
testSuite->addTest (makeTestCaller("testSimpleSelectiveIterator", &QueryTestCase::testSimpleSelectiveIterator));
return testSuite;
}
Test*
PCXTests::suite() {
typedef TestCaller<PCXTests> Caller;
TestSuite* suite = new TestSuite();
suite->addTest(new Caller("Test PCX Loader", &PCXTests::testLoader));
return suite;
}
Test*
BMPTests::suite() {
typedef TestCaller<BMPTests> Caller;
TestSuite* suite = new TestSuite();
suite->addTest(new Caller("Test BMP Loader", &BMPTests::testLoader));
return suite;
}
TestSuite* Taggle_test_suite()
{
TestSuite *suiteOfTests = new TestSuite;
suiteOfTests->addTest(new TestCaller<TaggleTest>("senseTest", &TaggleTest::senseTest));
return suiteOfTests;
} // TaggleTest_suite
Test* TestSetupTest::suite()
{
TestSuite* suite = new TestSuite("TestSetupTest");
suite->addTest(new TEST_CALLER(TestSetupTest, testTestSetup));
suite->addTest(new TEST_CALLER(TestSetupTest, testSetUpError));
suite->addTest(new TEST_CALLER(TestSetupTest, testTearDownError));
return suite;
}
Test* TarjetaCAPIeTTest::suite()
{
TestSuite *suite = new TestSuite("eToken con CryptoAPI");
suite->addTest( new TarjetaCAPIeTTestCaller("PedirPIN", &TarjetaCAPIeTTest::testPedirPIN) );
return (suite);
}
Test* StringTest::suite() {
TestSuite *suite = new TestSuite();
suite->addTest(new TestCaller<StringTest>("test_size", &StringTest::test_size));
suite->addTest(new TestCaller<StringTest>("test_affectation", &StringTest::test_affectation));
suite->addTest(new TestCaller<StringTest>("test_charAt", &StringTest::test_charAt));
suite->addTest(new TestCaller<StringTest>("test_equals", &StringTest::test_equals));
return suite;
}
Test *
GraphicsDefsTestSuite()
{
TestSuite *testSuite = new TestSuite();
testSuite->addTest(new ConstantsTest("Constants"));
return testSuite;
}
Test*
PNGTests::suite() {
typedef TestCaller<PNGTests> Caller;
TestSuite* suite = new TestSuite();
suite->addTest(new Caller("Test PNG Loader", &PNGTests::testLoader));
suite->addTest(new Caller("Test PNG Writer", &PNGTests::testWriter));
return suite;
}
Test* GlobalsTest::getTestSuite()
{
TestSuite* s = new TestSuite();
s->addTest(new TestCaller<GlobalsTest>("testing XML escaping",
&GlobalsTest::escape));
s->addTest(new TestCaller<GlobalsTest>("testing XML unescape",
&GlobalsTest::unescape));
return s;
}
static Test* suite()
{
TestSuite* suite = new TestSuite( "CounterTest");
suite->addTest( new TEST_CALLER( CounterTest, test_init));
suite->addTest( new TEST_CALLER( CounterTest, test_incr));
suite->addTest( new TEST_CALLER( CounterTest, test_decr));
suite->addTest( new TEST_CALLER( CounterTest, test_clear));
return suite;
}
Test* multiplyTest::suite()
{
TestSuite *suiteOfTests = new TestSuite( "multiplyTest" );
suiteOfTests->addTest(new TestCaller<multiplyTest>("testMultiply", &multiplyTest::testMultiply));
suiteOfTests->addTest(new TestCaller<multiplyTest>("testRefMultiply", &multiplyTest::testRefMultiply));
suiteOfTests->addTest(new TestCaller<multiplyTest>("testValarrayMultiply", &multiplyTest::testValarrayMultiply));
return suiteOfTests;
}
Test* IndOutputDataPackageTest::suite()
{
TestSuite *suiteOfTests = new TestSuite( "IndOutputDataPackageTest" );
// Test cases for this unit test.
suiteOfTests->addTest( new TestCaller<IndOutputDataPackageTest>( "equalCase", &IndOutputDataPackageTest::equalCase ) );
return suiteOfTests;
}
Test*
JPEGTests::suite() {
typedef TestCaller<JPEGTests> Caller;
TestSuite* suite = new TestSuite();
suite->addTest(new Caller("JPEG Loader", &JPEGTests::testLoader));
suite->addTest(new Caller("Incomplete JPEG", &JPEGTests::testIncomplete));
return suite;
}
Test *TestAngle::suite()
{
TestSuite *testsuite = new TestSuite;
testsuite->addTest(new TestAngle ());
testsuite->addTest(new TestAngleClass<Radian> ());
testsuite->addTest(new TestAngleClass<Degree> ());
testsuite->addTest(new TestAngleClass<Hour> ());
return testsuite;
}
Test* isDmatEpsEqualTest::suite()
{
TestSuite *suiteOfTests = new TestSuite( "isDmatEpsEqualTest" );
// Test cases for this unit test.
suiteOfTests->addTest( new TestCaller<isDmatEpsEqualTest>( "equalAndNotEqualCase", &isDmatEpsEqualTest::equalAndNotEqualCase ) );
return suiteOfTests;
}
int main(int argc, char *args[]) {
TestSuite suite;
suite.addTestCase(AutoRef<TestCase>(new DatagramSocketTestCase));
TestReport report(suite.testAll());
report.validate();
return 0;
}
Test* broadCastEndOfSpkTest::suite()
{
TestSuite *suiteOfTests = new TestSuite;
// duplicate the following example for each test case, replacing the case name.
suiteOfTests->addTest(new TestCaller<broadCastEndOfSpkTest>("testBroadcastEndOfSpk", testBroadcastEndOfSpk));
return suiteOfTests;
}
Test *TestDx::suite ()
{
TestSuite *testSuite = new TestSuite("TestDx");
testSuite->addTest (new TestCaller <TestDx> ("testFoo", &TestDx::testFoo));
testSuite->addTest (new TestCaller <TestDx> ("testPrintIntrinsics", &TestDx::testPrintIntrinsics));
testSuite->addTest (new TestCaller <TestDx> (" testDxCmdLineArgs", &TestDx:: testDxCmdLineArgs));
return testSuite;
}
Test* ValidacionCertificadoCAPITest::suite()
{
TestSuite *suite = new TestSuite("ValidacionCertificadoCAPI");
suite->addTest( new ValidacionCertificadoCAPITestCaller("testValidarAlmacenCerrado", &ValidacionCertificadoCAPITest::testValidarAlmacenCerrado) );
suite->addTest( new ValidacionCertificadoCAPITestCaller("testEstaRevocado", &ValidacionCertificadoCAPITest::testEstaRevocado) );
suite->addTest( new ValidacionCertificadoCAPITestCaller("testEstaCaducado", &ValidacionCertificadoCAPITest::testEstaCaducado) );
return (suite);
}
int main(int argc, char *args[]) {
TestSuite ts;
ts.addTestCase(AutoRef<TestCase>(new HeapTestCase));
TestReport report(ts.testAll());
report.validate();
return 0;
}
TestSuite* DocumentFragmentTest_suite()
{
TestSuite *suiteOfTests = new TestSuite;
suiteOfTests->addTest(new TestCaller<DocumentFragmentTest<string_type, string_adaptor> >("test1", &DocumentFragmentTest<string_type, string_adaptor>::test1));
suiteOfTests->addTest(new TestCaller<DocumentFragmentTest<string_type, string_adaptor> >("test2", &DocumentFragmentTest<string_type, string_adaptor>::test2));
suiteOfTests->addTest(new TestCaller<DocumentFragmentTest<string_type, string_adaptor> >("test3", &DocumentFragmentTest<string_type, string_adaptor>::test3));
suiteOfTests->addTest(new TestCaller<DocumentFragmentTest<string_type, string_adaptor> >("test4", &DocumentFragmentTest<string_type, string_adaptor>::test4));
suiteOfTests->addTest(new TestCaller<DocumentFragmentTest<string_type, string_adaptor> >("test5", &DocumentFragmentTest<string_type, string_adaptor>::test5));
return suiteOfTests;
} // DocumentFragmentTest_suite
Test* lambdaTest::suite()
{
TestSuite *suiteOfTests = new TestSuite("lambdaTest");
// duplicate the following example for each test case, replacing the case name.
suiteOfTests->addTest(new TestCaller<lambdaTest>("testWithD", &lambdaTest::testWithD));
suiteOfTests->addTest(new TestCaller<lambdaTest>("testWithoutD", &lambdaTest::testWithoutD));
return suiteOfTests;
}
Test* OW_StringStreamTestCases::suite()
{
TestSuite *testSuite = new TestSuite ("OW_StringStream");
testSuite->addTest (new TestCaller <OW_StringStreamTestCases>
("testSomething",
&OW_StringStreamTestCases::testSomething));
return testSuite;
}
