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 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)
{
// 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 );
CppUnit::TextUi::TestRunner runner;
CppUnit::TestFactoryRegistry ®istry = CppUnit::TestFactoryRegistry::getRegistry();
runner.addTest( registry.makeTest() );
runner.run( controller, "" );
// Resultate im Compiler-Format ausgeben
CppUnit::CompilerOutputter compileroutputter( &result, std::cerr );
compileroutputter.write();
// Rueckmeldung, ob Tests erfolgreich waren
return ( result.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) {
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() {
// 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;
}
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(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;
}
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[])
{
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;
}
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 );
TestRunner runner;
TestFactoryRegistry & registry = TestFactoryRegistry::getRegistry();
// run all tests if none specified on command line
Test * test_to_run = registry.makeTest();
if (argc > 1)
test_to_run = test_to_run->findTest(argv[1]);
runner.addTest( test_to_run );
// runner.run(controller);
try
{
std::cout << "Running tests" /*<< testPath*/ << endl;;
// runner.run( controller, testPath );
runner.run(controller);
// std::cerr << std::endl;
// Print test in a compiler compatible format.
CppUnit::CompilerOutputter outputter( &result, std::cerr );
outputter.write();
}
catch ( std::invalid_argument &e ) // Test path not resolved
{
std::cerr << std::endl
<< "ERROR: " << e.what()
<< std::endl;
return 0;
}
// result.runTest();
// results.printResults();
// runner.prin();
return result.wasSuccessful() ? 0 : 1;
}
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 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 (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()
{
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;
}
// 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*/)
{
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 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;
}
/*! 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();
}
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;
}
/**
* @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[])
{
// 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;
}
