C++ (Cpp) TestSuite::addTest 예제들

예제 #1

파일: OW_ProviderManagerTestCases.cpp 프로젝트: kkaempf/openwbem

Test* OW_ProviderManagerTestCases::suite()
{
	TestSuite *testSuite = new TestSuite ("OW_ProviderManager");

	testSuite->addTest (new TestCaller <OW_ProviderManagerTestCases>
			("testInit",
			&OW_ProviderManagerTestCases::testInit));

	testSuite->addTest (new TestCaller <OW_ProviderManagerTestCases>
			("testGetInstanceProvider",
			&OW_ProviderManagerTestCases::testGetInstanceProvider));
	testSuite->addTest (new TestCaller <OW_ProviderManagerTestCases>
			("testGetMethodProvider",
			&OW_ProviderManagerTestCases::testGetMethodProvider));
#ifndef OW_DISABLE_ASSOCIATION_TRAVERSAL
	testSuite->addTest (new TestCaller <OW_ProviderManagerTestCases>
			("testGetAssociatorProvider",
			&OW_ProviderManagerTestCases::testGetAssociatorProvider));
#endif
	testSuite->addTest (new TestCaller <OW_ProviderManagerTestCases>
			("testGetIndicationProvider",
			&OW_ProviderManagerTestCases::testGetIndicationProvider));

	return testSuite;
}

예제 #2

파일: Tester.cpp 프로젝트: kaorun55/CppUnitxHelper

	static Test* suite()
	{
		TestSuite* suite = new TestSuite( "QuizTest");
		suite->addTest( new TEST_CALLER( QuizTest, testQuestion));
		suite->addTest( new TEST_CALLER( QuizTest, testAnswer));
		return suite;
	}

예제 #3

파일: nelderMead_test.cpp 프로젝트: codersship/inz

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

예제 #4

파일: QueryTestCase.cpp 프로젝트: defbobo/python-patterns-examples

Test *QueryTestCase::suite ()
{
  TestSuite *testSuite = new TestSuite ("QueryTestCase");
    testSuite->addTest (makeTestCaller("testSimpleQuery", &QueryTestCase::testSimpleQuery));   
    testSuite->addTest (makeTestCaller("testSimpleSelectiveIterator", &QueryTestCase::testSimpleSelectiveIterator));

  return testSuite;
}

예제 #5

파일: StringTest.cpp 프로젝트: fmoule/cacao

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

예제 #6

파일: TestSetupTest.cpp 프로젝트: kaorun55/CppUnitxHelper

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

예제 #7

파일: GlobalsTest.cpp 프로젝트: Konnekt/lib-jabberoo

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

예제 #8

파일: JPEGTests.cpp 프로젝트: marcclintdion/iOS_WIN3

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

예제 #9

파일: multiplyTest.cpp 프로젝트: ernstae/sysforpopkinetics

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

예제 #10

파일: testAngle.cpp 프로젝트: Abhishekpatil/SonATA

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

예제 #11

파일: Tester.cpp 프로젝트: kaorun55/CppUnitxHelper

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

예제 #12

파일: lambdaTest.cpp 프로젝트: ernstae/sysforpopkinetics

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

예제 #13

파일: TestDx.cpp 프로젝트: Abhishekpatil/SonATA

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

예제 #14

파일: test_DocumentFragment.hpp 프로젝트: QuentinFiard/arabica

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

예제 #15

파일: ValidacionCertificadoCAPITest.cpp 프로젝트: jmnavarro/PKI_Cryptocard_Engine

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

예제 #16

파일: ValidacionCertificadoCLTest.cpp 프로젝트: jmnavarro/PKI_Cryptocard_Engine

Test* ValidacionCertificadoCLTest::suite()
{
	TestSuite *suite = new TestSuite("ValidacionCertificadoCL (requiere tarjetas C, D y E)");

	suite->addTest( new ValidacionCertificadoCLTestCaller("ValidarAlmacenCerrado", &ValidacionCertificadoCLTest::testValidarAlmacenCerrado) );
	suite->addTest( new ValidacionCertificadoCLTestCaller("CertificadoValido", &ValidacionCertificadoCLTest::testCertificadoValido) );
	suite->addTest( new ValidacionCertificadoCLTestCaller("CertificadoRevocado", &ValidacionCertificadoCLTest::testCertificadoRevocado) );
	suite->addTest( new ValidacionCertificadoCLTestCaller("CertificadoCaducado", &ValidacionCertificadoCLTest::testCertificadoCaducado) );

	return (suite);
}

예제 #17

파일: TestSite.cpp 프로젝트: dano1564/SonATA

Test *TestSite::suite ()
{
    TestSuite *testSuite = new TestSuite("TestSite");

    testSuite->addTest (new TestCaller <TestSite> ("testDxStatus", &TestSite::testDxStatus));
    testSuite->addTest (new TestCaller <TestSite> ("testGetNssComponentTree", &TestSite::testGetNssComponentTree));
    testSuite->addTest (new TestCaller <TestSite> ("testGetDxsForIfc", &TestSite::testGetDxsForIfc));
    testSuite->addTest (new TestCaller <TestSite> ("testCopy", &TestSite::testCopy));

    return testSuite;
}

예제 #18

파일: CertCLTest.cpp 프로젝트: jmnavarro/PKI_Cryptocard_Engine

Test* CertCLTest::suite()
{
	TestSuite *suite = new TestSuite("CertCL (requiere Tarjeta B)");

	suite->addTest( new CertCLTestCaller("Serializar",		&CertCLTest::testSerializar) );
	suite->addTest( new CertCLTestCaller("Deserializar",	&CertCLTest::testDeserializar) );
	suite->addTest( new CertCLTestCaller("CrearDesdeBuffer",&CertCLTest::testCrearDesdeBuffer) );
	suite->addTest( new CertCLTestCaller("Clonar",			&CertCLTest::testClonar) );

	return (suite);
}

예제 #19

파일: elsqTest.cpp 프로젝트: ernstae/sysforpopkinetics

Test* elsqTest::suite()
{
  TestSuite *suiteOfTests = new TestSuite("elsqTest");

    // duplicate the following example for each test case, replacing the case name.
    suiteOfTests->addTest(new TestCaller<elsqTest>("valarrayTest", &elsqTest::valarrayTest));
    suiteOfTests->addTest(new TestCaller<elsqTest>("fixedTest",    &elsqTest::fixedTest));
    suiteOfTests->addTest(new TestCaller<elsqTest>("genericTest",  &elsqTest::genericTest));

    return suiteOfTests;
}

예제 #20

파일: test_Siblings.hpp 프로젝트: QuentinFiard/arabica

TestSuite* SiblingsTest_suite() 
{
  TestSuite *suiteOfTests = new TestSuite;

  suiteOfTests->addTest(new TestCaller<SiblingsTest<string_type, string_adaptor> >("test1", &SiblingsTest<string_type, string_adaptor>::test1));
  suiteOfTests->addTest(new TestCaller<SiblingsTest<string_type, string_adaptor> >("test2", &SiblingsTest<string_type, string_adaptor>::test2));
  suiteOfTests->addTest(new TestCaller<SiblingsTest<string_type, string_adaptor> >("test3", &SiblingsTest<string_type, string_adaptor>::test3));
  suiteOfTests->addTest(new TestCaller<SiblingsTest<string_type, string_adaptor> >("test4", &SiblingsTest<string_type, string_adaptor>::test4));

  return suiteOfTests;
} // SiblingsTest_suite

예제 #21

파일: TestChan.cpp 프로젝트: Abhishekpatil/SonATA

Test *TestChan::suite ()
{
	TestSuite *testSuite = new TestSuite("TestChan");

	testSuite->addTest (new TestCaller <TestChan> ("testFoo", 
                                                       &TestChan::testFoo));

	testSuite->addTest (new TestCaller <TestChan> ("testPrintIntrinsics",
                                                       &TestChan::testPrintIntrinsics));

	return testSuite;
}

예제 #22

파일: main.cpp 프로젝트: Moddus/lucino

int main( int argc, char** argv )
{
    Initialize();

    lcn_log_stream = stderr;
    TestSuite suite;

    suite.addTest( new TermQueryTest() );
    suite.addTest( new DocumentTest() );

    return suite.runTests();
}

예제 #23

파일: TestSseDxArchiverInterfaceLib.cpp 프로젝트: Abhishekpatil/SonATA

Test *TestSseDxArchiverInterfaceLib::suite ()
{
	TestSuite *testSuite = new TestSuite("TestSseDxArchiverInterfaceLib");

	testSuite->addTest (new TestCaller <TestSseDxArchiverInterfaceLib> ("testFoo", &TestSseDxArchiverInterfaceLib::testFoo));

	testSuite->addTest (new TestCaller <TestSseDxArchiverInterfaceLib> ("testDxArchiverIntrinsics", &TestSseDxArchiverInterfaceLib::testDxArchiverIntrinsics));

	testSuite->addTest (new TestCaller <TestSseDxArchiverInterfaceLib> ("testPrint", &TestSseDxArchiverInterfaceLib::testPrint));

	return testSuite;
}

예제 #24

파일: KillCellRuleTest.cpp 프로젝트: DarthParth/EpollDemo

 static Test *suite() {
     TestSuite *suite = new TestSuite("KillCellRuleTest");
     suite->addTest(
             new TestCaller<KillCellRuleTest>(
                     "testKillCellWithInsufficientNeighbors",
                     &KillCellRuleTest::testKillCellWithInsufficientNeighbors));
     suite->addTest(
             new TestCaller<KillCellRuleTest>(
                     "testKeepAliveCellWithSufficientNeighbors",
                     &KillCellRuleTest::testKeepAliveCellWithSufficientNeighbors));
     return suite;
 }

예제 #25

파일: AlmacenCertificadoCAPITest.cpp 프로젝트: jmnavarro/PKI_Cryptocard_Engine

Test* AlmacenCertificadoCAPITest::suite()
{
	TestSuite *suite = new TestSuite("AlmacenCertificadoCAPI");

	suite->addTest( new AlmacenCertificadoCAPITestCaller("OpenAlmacen",	  				&AlmacenCertificadoCAPITest::testOpenAlmacen) );
	suite->addTest( new AlmacenCertificadoCAPITestCaller("LoadCertificadoFromAsunto",	&AlmacenCertificadoCAPITest::testLoadCertificadoFromAsunto) );
	suite->addTest( new AlmacenCertificadoCAPITestCaller("LoadCertificadoFromNumSerie", &AlmacenCertificadoCAPITest::testLoadCertificadoFromNumSerie) );
	suite->addTest( new AlmacenCertificadoCAPITestCaller("EnumerarCertificados",		&AlmacenCertificadoCAPITest::testEnumerarCertificados) );
	suite->addTest( new AlmacenCertificadoCAPITestCaller("Añadir CRL",					&AlmacenCertificadoCAPITest::testAddCRL) );

	return (suite);
}

예제 #26

파일: OW_ProviderMuxLoaderTestCases.cpp 프로젝트: kkaempf/openwbem

Test* OW_ProviderMuxLoaderTestCases::suite()
{
    TestSuite *testSuite = new TestSuite ("OW_ProviderIFCLoader");

    testSuite->addTest (new TestCaller <OW_ProviderMuxLoaderTestCases>
                        ("testLoadIFCs",
                         &OW_ProviderMuxLoaderTestCases::testLoadIFCs));
    testSuite->addTest (new TestCaller <OW_ProviderMuxLoaderTestCases>
                        ("testFailLoadIFCs",
                         &OW_ProviderMuxLoaderTestCases::testFailLoadIFCs));

    return testSuite;
}

예제 #27

파일: TaipanTestCase.cpp 프로젝트: svn2github/Escript

TestSuite* TaipanTestCase::suite()
{
  //
  // create the suite of tests to perform.
  TestSuite *testSuite = new TestSuite("TaipanTestCase");

  testSuite->addTest(new TestCaller<TaipanTestCase>(
              "testAll",&TaipanTestCase::testAll));
  testSuite->addTest(new TestCaller<TaipanTestCase>(
              "testN1",&TaipanTestCase::testN1));
  testSuite->addTest(new TestCaller<TaipanTestCase>(
              "testN0",&TaipanTestCase::testN0));
  return testSuite;
}

예제 #28

파일: OW_EnumerationTestCases.cpp 프로젝트: kkaempf/openwbem

Test* OW_EnumerationTestCases::suite()
{
	TestSuite *testSuite = new TestSuite ("OW_Enumeration");
	testSuite->addTest (new TestCaller <OW_EnumerationTestCases>
			("testInputIterator",
			&OW_EnumerationTestCases::testInputIterator));
	testSuite->addTest (new TestCaller <OW_EnumerationTestCases>
			("testInsertIterator",
			&OW_EnumerationTestCases::testInsertIterator));
	testSuite->addTest (new TestCaller <OW_EnumerationTestCases>
			("testCreation",
			&OW_EnumerationTestCases::testCreation));
	testSuite->addTest (new TestCaller <OW_EnumerationTestCases>
			("testAll",
			&OW_EnumerationTestCases::testAll));
	testSuite->addTest (new TestCaller <OW_EnumerationTestCases>
			("testQueue",
			&OW_EnumerationTestCases::testQueue));
	testSuite->addTest (new TestCaller <OW_EnumerationTestCases>
			("testAllBig",
			&OW_EnumerationTestCases::testAllBig));
	testSuite->addTest (new TestCaller <OW_EnumerationTestCases>
			("testQueueBig",
			&OW_EnumerationTestCases::testQueueBig));
	testSuite->addTest (new TestCaller <OW_EnumerationTestCases>
			("testReleaseFile",
			&OW_EnumerationTestCases::testReleaseFile));

	return testSuite;
}

예제 #29

파일: linearInterpolateTest.cpp 프로젝트: ernstae/sysforpopkinetics

Test* linearInterpolateTest::suite()
{
  TestSuite *suiteOfTests = new TestSuite( "linearInterpolateTest" );

  suiteOfTests->addTest(new TestCaller<linearInterpolateTest>(
    "doTest", 
    &linearInterpolateTest::doTest ));

  suiteOfTests->addTest(new TestCaller<linearInterpolateTest>(
    "equalIndepVarTest", 
    &linearInterpolateTest::equalIndepVarTest ));

  return suiteOfTests;
}

예제 #30

파일: replaceSubblockTest.cpp 프로젝트: ernstae/sysforpopkinetics

Test* replaceSubblockTest::suite()
{
  TestSuite *suiteOfTests = new TestSuite( "replaceSubblockTest" );

    // duplicate the following example for each test case, replacing the case name.
    suiteOfTests->addTest(new TestCaller<replaceSubblockTest>
		                 ("testReplaceSubblockDoubleMatrix", 
                                  &replaceSubblockTest::testReplaceSubblockDoubleMatrix));

    suiteOfTests->addTest(new TestCaller<replaceSubblockTest>
		                 ("testReplaceSubblockValarray", 
                                  &replaceSubblockTest::testReplaceSubblockValarray));

    return suiteOfTests;
}