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