int main(int argc, char ** argv) { Util::init(); const std::string testPath = (argc > 1) ? std::string(argv[1]) : ""; CppUnit::TestResult controller; CppUnit::TestResultCollector result; controller.addListener(&result); CppUnit::BriefTestProgressListener progress; controller.addListener(&progress); CppUnit::TestRunner runner; runner.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest()); runner.run(controller, testPath); std::ofstream fileStream("cppunit_results.xml"); CppUnit::XmlOutputter xmlOutput(&result, fileStream, "UTF-8"); xmlOutput.write(); CppUnit::TextOutputter textOutput(&result, std::cout); textOutput.write(); return result.wasSuccessful() ? 0 : 1; }
int main( int argc, char *argv[] ) { // informs test-listener about testresults CppUnit::TestResult testresult; // register listener for collecting the test-results CppUnit::TestResultCollector collectedresults; testresult.addListener( &collectedresults ); // insert test-suite at test-runner by registry CppUnit::TestRunner testrunner; testrunner.addTest( CppUnit::TestFactoryRegistry :: getRegistry().makeTest() ); testrunner.run( testresult ); // output results in compiler-format CppUnit::CompilerOutputter compileroutputter( &collectedresults, std::cerr ); compileroutputter.write(); // writing result on a XML file std::ofstream xmlFileOut( "testresults.xml" ); CppUnit::XmlOutputter xmlOut(&collectedresults, xmlFileOut); xmlOut.write(); // return 0 if tests were successful return collectedresults.wasSuccessful() ? 0 : 1; }
int main(int /*argc*/, char ** /*argv*/) { Util::init(); CppUnit::TestResult controller; CppUnit::TestResultCollector result; controller.addListener(&result); CppUnit::BriefTestProgressListener progress; controller.addListener(&progress); CppUnit::TestRunner runner; runner.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest()); runner.run(controller); std::ofstream fileStream("cppunit_results.xml"); CppUnit::XmlOutputter xmlOutput(&result, fileStream, "UTF-8"); xmlOutput.write(); CppUnit::TextOutputter textOutput(&result, std::cout); textOutput.write(); return 0; }
int main (int argc, char* argv[]) { // informs test-listener about testresults CppUnit::TestResult testresult; // register listener for collecting the test-results CppUnit::TestResultCollector collectedresults; testresult.addListener (&collectedresults); // register listener for per-test progress output CppUnit::BriefTestProgressListener progress; testresult.addListener (&progress); // insert test-suite at test-runner by registry CppUnit::TestRunner testrunner; testrunner.addTest (CppUnit::TestFactoryRegistry::getRegistry ().makeTest ()); testrunner.run (testresult); // output results in compiler-format CppUnit::CompilerOutputter compileroutputter (&collectedresults, std::cerr); compileroutputter.write (); // return 0 if tests were successful return collectedresults.wasSuccessful () ? 0 : 1; }
int main( int argc, char** argv ) { // informs test-listener about testresults CppUnit::TestResult controller; // register listener for collecting the test-results CppUnit::TestResultCollector result; controller.addListener( &result ); // register listener for per-test progress output CppUnit::BriefTestProgressListener progress; controller.addListener( &progress ); // insert test-suite at test-runner by registry CppUnit::TestRunner testrunner; testrunner.addTest( CppUnit::TestFactoryRegistry::getRegistry().makeTest() ); if( argc > 1 ) { testrunner.run( controller, argv[1] ); } else { testrunner.run( controller, "" ); } // output results in compiler-format CppUnit::CompilerOutputter compileroutputter( &result, std::cerr ); compileroutputter.write(); }
int main() { // Create the event manager and test controller CppUnit::TestResult controller; // Add a listener that collects test result CppUnit::TestResultCollector result; controller.addListener( &result ); // Add a listener that print dots as test run. CppUnit::BriefTestProgressListener progress; controller.addListener( &progress ); // Add the top suite to the test runner CppUnit::TestRunner runner; runner.addTest( CppUnit::TestFactoryRegistry::getRegistry().makeTest() ); runner.run( controller ); CppUnit::TextOutputter output(&result, std::cout); std::cout << std::endl << "==================================================" << std::endl << "Papyrus Library Unit Tests: " << std::endl; output.printHeader(); output.printStatistics(); output.printFailures(); return result.wasSuccessful() ? 0 : 1; }
bool TestRunner::run() { CppUnit::TestRunner *pthis = this; pthis->run(*m_result); m_outputter->write(); return m_monitor->wasSuccessful(); }
int main(int ac, char **av) { CryptoInitializer ci; std::vector<std::string> args; for (int i = 0; i < ac; ++i) args.push_back(std::string(av[i])); CppUnit::TestRunner runner; runner.addTest("CryptoTestSuite", CryptoTestSuite::suite()); return runner.run(args) ? 0 : 1; }
int main(int argc, char* argv[]) { std::string testPath = (argc > 1) ? std::string(argv[1]) : ""; // Create the event manager and test controller CppUnit::TestResult controller; // Add a listener that collects test result CppUnit::TestResultCollector result; controller.addListener(&result); // Add a listener that print dots as test run. CppUnit::BriefTestProgressListener progress; controller.addListener(&progress); // Add the top suite to the test runner CppUnit::TestRunner runner; runner.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest()); try { std::cout << "Running " << testPath; runner.run(controller, testPath); std::cerr << std::endl; // Print test in a compiler compatible format. CppUnit::CompilerOutputter outputter(&result, std::cerr); outputter.write(); #if defined(_MSC_VER) && _MSC_VER > 1500 char *xml = NULL; ::_dupenv_s(&xml, NULL, "CPPUNIT_XML"); #else char *xml = ::getenv("CPPUNIT_XML"); #endif if(xml && !::strcmp(xml, "1")) { std::ofstream xmlfileout("cpptestresults.xml"); CppUnit::XmlOutputter xmlout(&result, xmlfileout); xmlout.write(); } #if defined(_MSC_VER) && _MSC_VER > 1500 ::free(xml); #endif } catch(std::invalid_argument &e){ std::cerr << std::endl << "ERROR: " << e.what() << std::endl; return 0; } return result.wasSuccessful() ? 0 : 1; }
bool runPlugin(const CommandLineParser &arguments) { CppUnit::PlugInManager pluginManager; pluginManager.load(arguments.plugName); // Create the event manager and test controller CppUnit::TestResult controller; // Add a listener that collects test result CppUnit::TestResultCollector result; controller.addListener(&result); // Add a listener CppUnit::BriefTestProgressListener progress; controller.addListener(&progress); pluginManager.addListener(&controller); // Add the top suite to the test runner CppUnit::TestRunner runner; runner.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest()); try { if (arguments.testPaths.empty()) { std::cout << "Running " << std::endl; runner.run(controller); } else { for (const auto & p : arguments.testPaths) { std::cout << "Running " << p << std::endl; runner.run(controller, p); } } std::cerr << std::endl; // Print test in a compiler compatible format. CppUnit::CompilerOutputter outputter(&result, std::cerr); outputter.write(); if (!arguments.xmlOutputFile.empty()) { std::ofstream file(arguments.xmlOutputFile); CppUnit::XmlOutputter xOutputter(&result, file); xOutputter.write(); } } catch (std::invalid_argument &e) // Test path not resolved { std::cerr << std::endl << "ERROR: " << e.what() << std::endl; return false; } return result.wasSuccessful(); }
int main(int argc, char* argv[]) { // VMime initialization vmime::platform::setHandler<vmime::platforms::posix::posixHandler>(); // Parse arguments bool xmlOutput = false; for (int c = 1 ; c < argc ; ++c) { const std::string arg = argv[c]; if (arg == "--xml") xmlOutput = true; } // Run the tests if (xmlOutput) { // Get the test suites from the registry and add them to the list of tests to run CppUnit::TestRunner runner; for (unsigned int i = 0 ; i < getTestModules().size() ; ++i) { runner.addTest(CppUnit::TestFactoryRegistry:: getRegistry(getTestModules()[i]).makeTest()); } std::auto_ptr <XmlTestListener> xmlListener(new XmlTestListener); CppUnit::TestResult controller; controller.addListener(xmlListener.get()); CppUnit::TestResultCollector result; controller.addListener(&result); runner.run(controller); xmlListener->output(std::cout); // Return error code 1 if a test failed return result.wasSuccessful() ? 0 : 1; } else { // Get the top level suite from the registry CppUnit::TextUi::TestRunner runner; runner.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest()); return runner.run() ? 0 : 1; } }
int wmain(int argc, wchar_t* argv[]) { std::vector<std::string> args; for (int i = 0; i < argc; ++i) { char buffer[1024]; std::wcstombs(buffer, argv[i], sizeof(buffer)); args.push_back(std::string(buffer)); } CppUnit::TestRunner runner; runner.addTest("FoundationTestSuite", FoundationTestSuite::suite()); return runner.run(args) ? 0 : 1; }
// call List() if m_list or runner.addTest() otherwise void AddTest(CppUnit::TestRunner& runner, Test *test) { if (m_list) List(test); else runner.addTest(test); }
int main() { CppUnit::TestResult r; CppUnit::TestResultCollector rc; r.addListener(&rc); // 准备好结果收集器 CppUnit::TestRunner runner; // 定义执行实体 runner.addTest(CppUnit::TestFactoryRegistry::getRegistry("alltest").makeTest()); runner.run(r); // 运行测试 CppUnit::TextOutputter o(&rc, std::cout); o.write(); // 将结果输出 //system("pause"); return rc.wasSuccessful() ? 0 : -1; }
int main(int argc, char* argv[]) { CppUnit::TestRunner runner; CppUnit::TestFactoryRegistry ®istry = CppUnit::TestFactoryRegistry::getRegistry(); runner.addTest( registry.makeTest() ); CppUnit::TestResult controller; CppUnit::TestResultCollector result; controller.addListener(&result); runner.run(controller); CustomOutputter outputter(&result, std::cerr); outputter.write(); return result.wasSuccessful() ? 0 : 1; }
int runTest(const std::string& testName, int argc, char* argv[]) { DebugFilter::shouldWriteToConsole(false); for (int i = 1; i < argc; ++i) { if ((strcmp("-v", argv[i]) == 0) || (strcmp("--verbose", argv[i]) == 0)) { DebugFilter::shouldWriteToConsole(true); } } // Create the event manager and test controller CppUnit::TestResult controller; // Add a listener that collects test result CppUnit::TestResultCollector result; controller.addListener(&result); #if 0 // original CppUnit progress listener // Add a listener that print dots as test run. CppUnit::TextTestProgressListener progress; #else BWTestProgressListener progress; #endif controller.addListener(&progress); CppUnit::TestRunner runner; runner.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest()); BWUnitTest::unitTestInfo("Running %s:\n", testName.c_str()); runner.run(controller); BWUnitTest::unitTestError("\n"); // Print test in a compiler compatible format. CppUnit::CompilerOutputter outputter(&result, std::cout); outputter.write(); return result.testFailures(); }
int main( int argc, char* argv[] ) { string xmlPath = ""; string currentParse = ""; for( int i = 1; i < argc; i++ ){ string s = argv[i]; if( s.substr( 0, 1 ) == "-" ){ currentParse = s; }else{ if( currentParse == "-o" ){ xmlPath = s; }else if( currentParse == "-f" ){ TestUtil::setFixtureRootPath( s ); } currentParse = ""; } } CppUnit::TestResult controller; CppUnit::TestResultCollector results; controller.addListener( &results ); CppUnit::BriefTestProgressListener progress; if( xmlPath.size() == 0 ){ controller.addListener( &progress ); } CppUnit::TestRunner runner; runner.addTest( CppUnit::TestFactoryRegistry::getRegistry().makeTest() ); runner.run( controller ); if( xmlPath.size() == 0 ){ CppUnit::CompilerOutputter outputter( &results, CppUnit::stdCOut() ); outputter.write(); }else{ std::ofstream ofs( xmlPath.c_str() ); CppUnit::XmlOutputter outputter( &results, ofs, "UTF-8" ); outputter.write(); } return results.wasSuccessful() ? 0 : 1; }
int main(int argc, char* argv[]) { // Create the event manager and test controller CppUnit::TestResult controller; // Add a listener that colllects test result CppUnit::TestResultCollector result; controller.addListener( &result ); // Add a listener that print dots as test run. CppUnit::TextTestProgressListener progress; controller.addListener( &progress ); // Add the top suite to the test runner CppUnit::TestRunner runner; runner.addTest( CppUnit::TestFactoryRegistry::getRegistry().makeTest() ); try { std::cout << "Running "; CPPUNIT_NS::TestRunner runner; runner.addTest( CPPUNIT_NS::TestFactoryRegistry::getRegistry().makeTest() ); runner.run( controller ); std::cerr << std::endl; // Print test in a compiler compatible format. CppUnit::CompilerOutputter outputter( &result, std::cerr ); outputter.write(); cin.get(); } catch ( std::invalid_argument &e ) // Test path not resolved { std::cerr << std::endl << "ERROR: " << e.what() << std::endl; return 0; } return result.wasSuccessful() ? 0 : 1; }
int main( int argc, char* argv[] ) { std::string testPath = (argc > 1) ? std::string( argv[1] ) : ""; // Create the event manager and test controller CppUnit::TestResult controller; // Add a listener that colllects test result CppUnit::TestResultCollector result; controller.addListener( &result ); // Add a listener that print dots as test run. CppUnit::TextTestProgressListener progress; controller.addListener( &progress ); // Add the top suite to the test runner CppUnit::TestRunner runner; runner.addTest( CppUnit::TestFactoryRegistry::getRegistry().makeTest() ); try { clock_t t = clock(); std::cout << "Unit running " << testPath; runner.run( controller, testPath ); std::cerr << std::endl; // Print test in a compiler compatible format. CppUnit::CompilerOutputter outputter( &result, std::cerr ); outputter.write(); double dt = ((double) clock() - t) / CLOCKS_PER_SEC; std::cout << "Timed: " << dt << "s" << std::endl; } catch( std::invalid_argument &e ) { // Test path not resolved std::cerr << std::endl << "ERROR: " << e.what() << std::endl; return 0; } return result.wasSuccessful() ? 0 : 1; }
int main (int argc, char* argv[]) { // stores test results (listener) CppUnit::TestResult testresult; CppUnit::TestResultCollector collectedresults; testresult.addListener (&collectedresults); // get testsuit and add it to our TestRunner CppUnit::TestRunner tester; tester.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest()); // run unit tests tester.run(testresult); // format results in a nice compiler friendly format CppUnit::CompilerOutputter compileroutputter( &collectedresults, std::cout); compileroutputter.write (); // returns 0 on success return collectedresults.wasSuccessful () ? 0 : 1; }
/** * @brief Main test runner for available fixtures * @return True if all the tests were successfull, false otherwise */ int main(int argc, char *argv[]) { std::string path = (argc > 1) ? std::string(argv[1]) : ""; /* create event manager and test controller */ CppUnit::TestResult controller; /* add a listener that collects the results */ CppUnit::TestResultCollector result; controller.addListener(&result); /* add a listener that prints dots while the test runs */ CppUnit::TextTestProgressListener progress; controller.addListener( &progress ); /* add a listener that prints each running test */ //CppUnit::BriefTestProgressListener progress; //controller.addListener( &progress ); /* add the suites to the test runner */ CppUnit::TestRunner runner; runner.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest()); try { runner.run(controller, path); std::cerr << "\n"; /* add compiler formatted output */ CppUnit::CompilerOutputter outputter(&result, std::cerr); outputter.write(); } /* invalid path */ catch (std::invalid_argument &e) { std::cerr << "\n" << "ERROR: " << e.what() << "\n"; return 0; } /* return result for autobuild tools */ return result.wasSuccessful() ? 0 : 1; }
int main(int ac, char **av) { Poco::Net::HTTPStreamFactory::registerFactory(); Poco::Net::HTTPSStreamFactory::registerFactory(); NetSSLApp app; try { app.init(1, av); } catch (Poco::Exception& exc) { std::cout << exc.displayText() << std::endl; return 1; } std::vector<std::string> args; for (int i = 0; i < ac; ++i) args.push_back(std::string(av[i])); CppUnit::TestRunner runner; runner.addTest("NetSSLTestSuite", NetSSLTestSuite::suite()); return runner.run(args) ? 0 : 1; }
int main (int argc,const char *argv[]) { CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest(); assert(argc == 2); std::ofstream xml(argv[1]); CppUnit::TestResult controller; CppUnit::TestResultCollector result; controller.addListener( &result ); CppUnit::TestRunner runner; runner.addTest(suite); runner.run(controller); CppUnit::XmlOutputter xout( &result, xml ); CppUnit::CompilerOutputter tout( &result, std::cout); xout.write(); tout.write(); return result.wasSuccessful() ? 0 : 1 ; }
int main(int argc, char* argv[]) { bool verbose = false; bool outputXML = false; // Parse parameters std::vector<std::string> testsToRun; for (int i = 1; i < argc; ++i) { std::string param(argv[i]); if (param == "--verbose") { verbose = true; } else if (param == "--xml") { outputXML = true; } else { testsToRun.push_back(param); } } if (testsToRun.empty()) { testsToRun.push_back(""); } // Set up the listeners CppUnit::TestResult controller; CppUnit::TestResultCollector result; controller.addListener(&result); CppUnit::TextTestProgressListener progressListener; CppUnit::BriefTestProgressListener verboseListener; if (!outputXML) { if (verbose) { controller.addListener(&verboseListener); } else { controller.addListener(&progressListener); } } // Run the tests CppUnit::TestRunner runner; runner.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest()); for (std::vector<std::string>::const_iterator i = testsToRun.begin(); i != testsToRun.end(); ++i) { try { runner.run(controller, *i); } catch (const std::exception& e) { std::cerr << "Error: " << e.what() << std::endl; return -1; } } // Output the results if (outputXML) { CppUnit::XmlOutputter outputter(&result, std::cout); outputter.write(); } else { CppUnit::TextOutputter outputter(&result, std::cerr); outputter.write(); } return result.wasSuccessful() ? 0 : 1; }
int main(const std::vector<std::string>& args) { CppUnit::TestRunner runner; runner.addTest("NetSSLTestSuite", NetSSLTestSuite::suite()); return runner.run(_targs) ? 0 : 1; }
/* Test program */ int main(int argc, char** argv) { CppUnit::TestResult testresult; CppUnit::TestResultCollector collectedresults; CppUnit::TestRunner testrunner; std::ofstream fb; std::list< std::string > test_list; #ifdef HAVE_GETOPT_LONG int c; struct option long_options[] = { {"help", 0, 0, 'h'}, {"list", 0, 0, 'l'}, {0, 0, 0, 0} }; while ((c = getopt_long(argc, argv, "hl", long_options, NULL)) != -1) { switch (c) { case 'h': std::cout << "Usage: " << argv[0] << " [test name]\n"; std::cout << "\nOptions:\n" << " -h, --help Show this help message and exit\n" << " -l, --list List available tests and exit" << std::endl; exit(EXIT_SUCCESS); case 'l': { CppUnit::Test *t = CppUnit::TestFactoryRegistry::getRegistry().makeTest(); std::cout << "Available test suites:\n"; printTest(std::cout, t); delete t; exit(EXIT_SUCCESS); } } } if (optind < argc) { while (optind < argc) { test_list.push_back(argv[optind++]); } } #endif testresult.addListener(&collectedresults); testrunner.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest()); if (test_list.empty()) testrunner.run(testresult); else { std::list<std::string>::const_iterator it; for (it = test_list.begin(); it != test_list.end(); ++it) { testrunner.run(testresult, *it); } } fb.open((std::string(argv[0]) + ".xml").c_str()); CppUnit::XmlOutputter xml_outputter(&collectedresults, fb); xml_outputter.write(); fb.close(); fb.open((std::string(argv[0]) + ".cmp").c_str()); CppUnit::CompilerOutputter comp_outputter(&collectedresults, fb); comp_outputter.write(); fb.close(); CppUnit::TextOutputter txt_outputter(&collectedresults, std::cout); txt_outputter.write(); return collectedresults.wasSuccessful() ? 0 : 1; }