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[])
{
// set up logger
//log4cxx::BasicConfigurator::configure();
CppUnit::TestFactoryRegistry ®istry = CppUnit::TestFactoryRegistry::getRegistry();
if (argc == 1)
registry.addRegistry("All");
else
{
// run just the specified tests
for (int i=1; i<argc; i++)
registry.addRegistry(argv[i]);
}
CppUnit::TextUi::TestRunner runner;
runner.addTest(registry.makeTest());
// Errors have line numbers
runner.setOutputter(
CppUnit::CompilerOutputter::defaultOutputter(
&runner.result(),
std::cerr ) );
CppUnit::TestResult controller;
CppUnit::TestResultCollector result;
controller.addListener(&result);
// register listener for per-test progress output
// verbose, per-test output: test : OK
CppUnit::BriefTestProgressListener progress;
controller.addListener (&progress);
runner.run(controller);
// output stderr summary report
CppUnit::TextOutputter compilerOutputter(&result, std::cerr);
compilerOutputter.write();
// output xml report
std::ofstream strm("result.xml");
CppUnit::XmlOutputter xmlOutputter(&result, strm);
xmlOutputter.write();
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::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();
char *xml = ::getenv("CPPUNIT_XML");
if(xml && !::strcmp(xml, "1")) {
std::ofstream xmlfileout("cpptestresults.xml");
CppUnit::XmlOutputter xmlout(&result, xmlfileout);
xmlout.write();
}
}
catch(std::invalid_argument &e){
std::cerr << std::endl
<< "ERROR: " << e.what()
<< std::endl;
return 0;
}
return result.wasSuccessful() ? 0 : 1;
}
// If TestSuite is not changes, the following code don't need to change.
int main()
{
CppUnit::TestResult r;
CppUnit::TestResultCollector listener;
CppUnit::TestResultCollector result;
r.addListener(&listener);
r.addListener(&result);
CppUnit::TextUi::TestRunner runner;
//Get test suit.
CppUnit::Test *test = CppUnit::TestFactoryRegistry::getRegistry("alltest").makeTest();
// Add this test suit to test runner.
runner.addTest( test );
//output log to run.log file.
std::ofstream ofile;
ofile.open("run.log");
CppUnit::TextOutputter outputter(&listener, ofile);;
//This would occur code dumped.reason unkonwn.
//runner.setOutputter(&outputter);
//output result to result.xml.
std::ofstream file( "result.xml" );
CppUnit::XmlOutputter xml( &result, file );
//run the test runner.
runner.run(r);
//write to file.
outputter.write();
xml.write();
//close ofstream.
ofile.close();
file.close();
//output test results to console.
CppUnit::TextOutputter o(&listener, std::cout);
o.write();
return listener.wasSuccessful() ? 0 : -1;
}
int main(int argc, char *argv[])
{
po::options_description opt(std::string("Usage: ") + argv[0] + " [Options] [Test Path] ...\nOptions");
opt.add_options()
("help,h", "Print this help")
("verbose,v", "Verbose mode")
("test-path,t", po::value<std::vector<std::string> >(), "Specify the test path");
po::positional_options_description p;
p.add("test-path", -1);
po::variables_map vars;
try {
po::store(po::command_line_parser(argc, argv).options(opt).positional(p).run(), vars);
po::notify(vars);
if (vars.count("help") != 0) {
std::cerr << opt << std::endl;
return 1;
}
if (vars.count("verbose") == 0) {
Logger::get_instance().set_level(Logger::LEVEL_FATAL);
}
} catch (std::exception &e) {
std::cerr << "Error: " << e.what() << std::endl;
std::cerr << opt << std::endl;
return 1;
}
CppUnit::TextTestRunner runner;
runner.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest());
if (vars.count("test-path") > 0) {
CppUnit::TestResult controller;
CppUnit::TestResultCollector result;
controller.addListener(&result);
CppUnit::TextTestProgressListener progress;
controller.addListener(&progress);
const std::vector<std::string> &v = vars["test-path"].as<std::vector<std::string> >();
BOOST_FOREACH(std::string i, v) {
std::cout << i << " ";
try {
runner.run(controller, i);
} catch (std::invalid_argument &e) {
std::cerr << "ERROR: " << e.what() << std::endl;
return 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 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[]) {
TestLogListener listener;
CppUnit::TestResult testresult;
testresult.addListener (&listener);
CppUnit::TextUi::TestRunner runner;
runner.addTest( TestTupleOperatorsSuite::suite() );
runner.addTest( TestTupleEqualsTest::suite() );
runner.run(testresult);
return EXIT_SUCCESS;
}
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;
}
/*! Runs the specified tests located in the root suite.
* \param root Root suite that contains all the test of the DLL.
* \param testPaths Array of string that contains the test paths of all the test to run.
* \param numberOfPath Number of test paths in \a testPaths. If 0 then \a root suite
* is run.
* \return \c true if the run succeed, \c false if a test failed or if a test
* path was not resolved.
*/
bool
runDllTest( CppUnit::Test *root,
TCHAR *testPaths[],
int numberOfPath )
{
CppUnit::TestResult controller;
CppUnit::TestResultCollector result;
controller.addListener( &result );
CppUnit::TextTestProgressListener progress;
controller.addListener( &progress );
NotOwningTestRunner runner;
if ( numberOfPath == 0 )
runner.addTest( root );
else
{
for ( int index =0; index < numberOfPath; ++index )
{
const TCHAR *testPath = testPaths[index];
try
{
runner.addTest( root->resolveTestPath( testPath).getChildTest() );
}
catch ( std::invalid_argument & )
{
TCERR << _T("Failed to resolve test path: ") << testPath << std::endl;
return false;
}
}
}
runner.run( controller );
std::cerr << std::endl;
CppUnit::CompilerOutputter outputter( &result, std::cerr );
outputter.write();
return result.wasSuccessful();
}
/**
* @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 argc, char* argv[])
{
CppUnit::TestResult r;
CppUnit::TestResultCollector rc;
r.addListener(&rc); // 准备好结果收集器
SimpleTest t;
t.run(&r); // 运行测试用例
CppUnit::TextOutputter o(&rc, std::cout);
o.write(); // 将结果输出
return 0;
}
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::TestResult controller;
CppUnit::TestResultCollector result;
CppUnit::TextUi::TestRunner runner;
controller.addListener(&result);
CppUnit::TestFactoryRegistry ®istry = CppUnit::TestFactoryRegistry::getRegistry();
runner.addTest(registry.makeTest());
runner.run(controller);
std::ofstream xmlFileOut("test-results.xml");
CppUnit::XmlOutputter xmlOut(&result, xmlFileOut);
xmlOut.write();
CryptoFactory::reset();
return result.wasSuccessful() ? 0 : 1;
}
int main (int argc , char** argv)
{
std::ofstream xml("./cppUnit_output.xml",ios::app);
CppUnit::TestResult controller;
CppUnit::TestResultCollector result;
controller.addListener( &result );
TestRunner runner;
runner.addTest(Manipulation_test::suite());
runner.run(controller);
CppUnit::XmlOutputter outputter( &result, xml );
CppUnit::TextOutputter outputter2( &result, std::cerr );
outputter.write();
outputter2.write();
return result.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 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;
}
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()
{
CppUnit::TextUi::TestRunner runner;
CppUnit::TestFactoryRegistry& registry = CppUnit::TestFactoryRegistry::getRegistry();
CppUnit::TestResult controller;
CppUnit::TestResultCollector result;
controller.addListener(&result);
runner.addTest(registry.makeTest());
std::ofstream xmlout("results.xml");
CppUnit::XmlOutputter out(&result, xmlout);
CppUnit::TextOutputter console(&result, std::cout);
runner.run(controller, "");
out.write();
console.write();
return result.wasSuccessful()? 0: 1;
}
int
main(int argc, char **argv)
{
CppUnit::TestResult controller;
CppUnit::TestResultCollector result;
CppUnit::TextUi::TestRunner runner;
runner.addTest(cuda::Tests::suite());
strcpy(cuda::Tests::filename, argv[2]);
if (argc == 3 && strcmp(argv[1], "-i") == 0)
{
controller.addListener(&result);
runner.run(controller);
std::ofstream xmlFileOut("cuda_results.xml");
CppUnit::XmlOutputter xmlOut(&result, xmlFileOut);
xmlOut.write();
}
else if (argc == 4 && strcmp(argv[3], "-o") == 0)
runner.run();
else
std::cout<<"Usage "<<argv[0]<<" -i <test filename>\n -o";
return 0;
}
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;
}
/* 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;
}