inline bool run(Environment& environment, Suite& tests, Setup const&... setup) { // retrieve compact status auto is_compact = args("compact",false); auto is_fail_only = args("fail-only",false); environment.compact(is_compact); environment.fail_only(is_fail_only); // randomize test on non-null random seed option if(auto seed = args("random",0u)) { ::stf::detail::shuffle( tests.begin(), tests.end(), std::mt19937{seed} ); } for(auto& t : tests ) { scenario_header(environment,t); auto count = environment.tests(); t(environment); process_invalid(environment, count); environment.stream() << std::endl; } return ::stf::report(environment,setup...); }
void AddTest(Suite& ts) { ts.add(std::auto_ptr<Suite>(new CTestDataBox)); ts.add(std::auto_ptr<Suite>(new CTestThreadSync)); ts.add(std::auto_ptr<Suite>(new CTestSerialize)); ts.add(std::auto_ptr<Suite>(new CTestPeutils)); }
int Suite::run( vector<string> suites ){ for ( unsigned int i = 0; i < suites.size(); i++ ) { if ( _suites->find( suites[i] ) == _suites->end() ) { cout << "invalid test [" << suites[i] << "], use --list to see valid names" << endl; return -1; } } list<string> torun(suites.begin(), suites.end()); if ( torun.size() == 0 ) for ( map<string,Suite*>::iterator i=_suites->begin() ; i!=_suites->end(); i++ ) torun.push_back( i->first ); list<Result*> results; for ( list<string>::iterator i=torun.begin(); i!=torun.end(); i++ ){ string name = *i; Suite * s = (*_suites)[name]; assert( s ); log() << "going to run suite: " << name << endl; results.push_back( s->run() ); } Logstream::get().flush(); cout << "**************************************************" << endl; cout << "**************************************************" << endl; cout << "**************************************************" << endl; int rc = 0; int tests = 0; int fails = 0; int asserts = 0; for ( list<Result*>::iterator i=results.begin(); i!=results.end(); i++ ){ Result * r = *i; cout << r->toString(); if ( abs( r->rc() ) > abs( rc ) ) rc = r->rc(); tests += r->_tests; fails += r->_fails; asserts += r->_asserts; } Result totals ("TOTALS"); totals._tests = tests; totals._fails = fails; totals._asserts = asserts; cout << totals.toString(); // includes endl return rc; }
void UniTest() { Suite ts; AddTest(ts); std::auto_ptr<Output> output(new XmlOutput); ts.run(*output, true); Test::XmlOutput* const xml_output = dynamic_cast<XmlOutput*>(output.get()); if (xml_output) { std::ofstream fout("./test_pellets.xml"); xml_output->generate(fout, true, "zpublic"); } }
//skriver ut data om suitene. void Hotell::displaySuite(){ Suite *tempSuite; for (int x = 1; x <= rom[2]->no_of_elements(); x++){ tempSuite = (Suite*)rom[2]->remove_no(x); rom[2]->add(tempSuite); tempSuite->display(); } _getch(); }
//skriver data til fil. void Hotell::tilfil(){ //filnavnet er egen variabel. ofstream fil (filnavn+".DTA"); //Statisk data fil << navn << endl; fil << postnummer << " " << addresse << endl; fil << telefon << " " << fax << " " << mail << endl; fil << frokost << " " << seng << " " << antFascilliteter << endl; //beskrivelse av fascillitetene. for(int x = 1; x <= antFascilliteter; x++){ fil << fascilliteter[x] << endl; } for(int y = 0; y < 3; y++){ //data om alle rom skriver seg selv. Singel *tempSingel; Dobbel *tempDobbel; Suite *tempSuite; fil << rom[y]->no_of_elements() << endl; for (int x = 1; x <= rom[y]->no_of_elements(); x++){ if(y == 0){ tempSingel = (Singel*)rom[y]->remove_no(x); rom[y]->add(tempSingel); tempSingel->toFile(fil); } else if (y == 1){ tempDobbel = (Dobbel*)rom[y]->remove_no(x); rom[y]->add(tempDobbel); tempDobbel->toFile(fil); } else if (y == 2){ tempSuite = (Suite*)rom[y]->remove_no(x); rom[y]->add(tempSuite); tempSuite->toFile(fil); } fil << endl; } } }
bool GetKeysRegistry::GetNextKey(DescriptorTypeID &type) { if(m_iNextKey == m_iNumKeys) return false; OSErr err = m_DescriptorProcs->GetKey(*m_Descriptor, m_iNextKey, &m_CurKey); if(err) throw ExceptionSPErr(StringUtil::ssprintf("GetKeysRegistry::GetKey(%i)", m_iNextKey), err); err = m_DescriptorProcs->GetType(*m_Descriptor, m_CurKey, &type); if(err) throw ExceptionSPErr(StringUtil::ssprintf("GetKeysRegistry::GetType(%08x)", m_CurKey), err); ++m_iNextKey; return true; }
bool GetKeysRegistry::GetBoolean() { Boolean bValue; OSErr iErr = m_DescriptorProcs->GetBoolean(*m_Descriptor, m_CurKey, &bValue); if(iErr) throw ExceptionSPErr(StringUtil::ssprintf("GetKeysRegistry::GetBoolean(%08x)", m_CurKey), iErr); return !!bValue; }
float GetKeysRegistry::GetFloat() { double fValue; OSErr iErr = m_DescriptorProcs->GetFloat(*m_Descriptor, m_CurKey, &fValue); if(iErr) throw ExceptionSPErr(StringUtil::ssprintf("GetKeysRegistry::GetFloat(%08x)", m_CurKey), iErr); return (float) fValue; }
int GetKeysRegistry::GetInteger() { int32 iValue; OSErr iErr = m_DescriptorProcs->GetInteger(*m_Descriptor, m_CurKey, &iValue); if(iErr) throw ExceptionSPErr(StringUtil::ssprintf("GetKeysRegistry::GetInteger(%08x)", m_CurKey), iErr); return iValue; }
DescriptorEnumID GetKeysRegistry::GetEnum() { DescriptorEnumID iValue; DescriptorEnumTypeID type; OSErr iErr = m_DescriptorProcs->GetEnumerated(*m_Descriptor, m_CurKey, &type, &iValue); if(iErr) throw ExceptionSPErr(StringUtil::ssprintf("GetKeysRegistry::GetEnumerated(%08x)", m_CurKey), iErr); return iValue; }
void Runner::Run() { Print("Starting Test Runner: %s\n", iDesc); SetAssertThrows(true); gPass = 0; gFail = 0; Suite* suite = iFirst; TUint i=1; for(; suite != 0; i++) { Print("Suite %d: %s\n", i,suite->Description()); try { suite->Test(); } catch(OpenHome::Exception& e) { Print("\nFAILURE: Suite: %d caused an unhandled exception: %s. Exception thrown at: File: %s. Line: %d\n",i,e.Message(),e.File(),e.Line()); Print("Last successful test: %s:%d\n", gLastSuccessfulFile, gLastSuccessfulLine); gFail++; } catch(...) { Print("\nFAILURE: Suite: %d caused an unhandled, unknown exception\n", i); Print("Last successful test: %s:%d\n", gLastSuccessfulFile, gLastSuccessfulLine); gFail++; } Print("\n"); Suite* finishedSuite = suite; suite = suite->iNext; delete finishedSuite; } Print("Finished Test Runner: %s\n", iDesc); Print("%d of %d tests passed.\n",gPass, gPass+gFail); Print("%d of %d tests failed.\n",gFail, gPass+gFail); if (gFail != 0) { const char* a = getenv("ABORT_ON_FAILURE"); if ( a == NULL || atoi(a) == 1 ) { // If env var is unset, or is set to "1", then exit. exit(1); } } }
void AddTest(Suite& ts) { // ts.add(std::auto_ptr<Suite>(new CTestDataBox)); // ts.add(std::auto_ptr<Suite>(new CTestThreadSync)); // ts.add(std::auto_ptr<Suite>(new CTestSerialize)); // ts.add(std::auto_ptr<Suite>(new CTestPeutils)); // ts.add(std::auto_ptr<Suite>(new CTestThreadPool)); // ts.add(std::auto_ptr<Suite>(new CTestDesignPattern)); // ts.add(std::auto_ptr<Suite>(new CTestEvent)); // ts.add(std::auto_ptr<Suite>(new CTestTimer)); // ts.add(std::auto_ptr<Suite>(new CTestLuaBind)); ts.add(std::auto_ptr<Suite>(new CTestWinUtils)); }
void PutKeysRegistry::PutPercent(DescriptorKeyID key, float f) { SPErr iErr = m_DescriptorProcs->PutFloat(*m_Descriptor, key, f); if(iErr) throw ExceptionSPErr(StringUtil::ssprintf("PutKeysRegistry::PutPercent(%08x)", key), iErr); }
void PutKeysRegistry::PutInteger(DescriptorKeyID key, int i) { SPErr iErr = m_DescriptorProcs->PutInteger(*m_Descriptor, key, i); if(iErr) throw ExceptionSPErr(StringUtil::ssprintf("PutKeysRegistry::PutInteger(%08x)", key), iErr); }
void PutKeysRegistry::Finish() { SPErr iErr = m_RegistryProcs->Register(plugInUniqueID, *m_Descriptor, true); if(iErr) throw ExceptionSPErr("m_RegistryProcs->Register", iErr); }
int Suite::run( int argc , char ** argv ){ list<string> torun; for ( int i=1; i<argc; i++ ){ string s = argv[i]; if ( s == "-list" ){ for ( map<string,Suite*>::iterator i=_suites->begin() ; i!=_suites->end(); i++ ) cout << i->first << endl; return 0; } if ( s == "-debug" ){ logLevel = 1; continue; } torun.push_back( s ); if ( _suites->find( s ) == _suites->end() ){ cout << "invalid test [" << s << "] use -list to see valid names" << endl; return -1; } } if ( torun.size() == 0 ) for ( map<string,Suite*>::iterator i=_suites->begin() ; i!=_suites->end(); i++ ) torun.push_back( i->first ); list<Result*> results; for ( list<string>::iterator i=torun.begin(); i!=torun.end(); i++ ){ string name = *i; Suite * s = (*_suites)[name]; assert( s ); log() << "going to run suite: " << name << endl; results.push_back( s->run() ); } cout << "**************************************************" << endl; cout << "**************************************************" << endl; cout << "**************************************************" << endl; int rc = 0; int tests = 0; int fails = 0; int asserts = 0; for ( list<Result*>::iterator i=results.begin(); i!=results.end(); i++ ){ Result * r = *i; cout << r->toString(); if ( abs( r->rc() ) > abs( rc ) ) rc = r->rc(); tests += r->_tests; fails += r->_fails; asserts += r->_asserts; } cout << "TOTALS tests:" << tests << " fails: " << fails << " asserts calls: " << asserts << endl; return rc; }
int Suite::run( const std::vector<std::string>& suites , const std::string& filter , int runsPerTest ) { if (_allSuites().empty()) { log() << "error: no suites registered."; return EXIT_FAILURE; } for ( unsigned int i = 0; i < suites.size(); i++ ) { if ( _allSuites().count( suites[i] ) == 0 ) { log() << "invalid test suite [" << suites[i] << "], use --list to see valid names" << std::endl; return EXIT_FAILURE; } } std::vector<std::string> torun(suites); if ( torun.empty() ) { for ( SuiteMap::const_iterator i = _allSuites().begin(); i !=_allSuites().end(); ++i ) { torun.push_back( i->first ); } } std::vector<Result*> results; for ( std::vector<std::string>::iterator i=torun.begin(); i!=torun.end(); i++ ) { std::string name = *i; Suite* s = _allSuites()[name]; fassert( 16145, s ); log() << "going to run suite: " << name << std::endl; results.push_back( s->run( filter, runsPerTest ) ); } log() << "**************************************************" << std::endl; int rc = 0; int tests = 0; int fails = 0; int asserts = 0; for ( std::vector<Result*>::iterator i=results.begin(); i!=results.end(); i++ ) { Result* r = *i; log() << r->toString(); if ( abs( r->rc() ) > abs( rc ) ) rc = r->rc(); tests += r->_tests; fails += r->_fails; asserts += r->_asserts; } Result totals ("TOTALS"); totals._tests = tests; totals._fails = fails; totals._asserts = asserts; log() << totals.toString(); // includes endl return rc; }
int suite_run() { int i, stage; char *extra; void (*func)(); passed = failed = 0; printf("Starting suite %s (%d tests)\n",suite.name, suite.num_tests); for ( i = 0; i < suite.num_tests; i++ ) { if ( setjmp(jmpbuf) == 0 ) { #ifndef NO_LOG_RUNNING printf("Running test %s..",suite.testnames[i]); #endif failed_message = NULL; stage = 0; if ( suite.setup ) { suite.setup(); } func = suite.tests[i]; stage++; func(); stage++; if ( suite.teardown ) { suite.teardown(); } #ifndef NO_LOG_PASSED #ifdef NO_LOG_RUNNING printf("Running test %s..",suite.testnames[i]); #endif printf("...passed\n"); #endif passed++; } else { extra = ""; switch ( stage ) { case 0: extra = "(in setup)"; /* Fall through */ case 1: /* Protect ourselves against teardown failing */ if ( setjmp(jmpbuf) == 0 ) { if ( suite.teardown() ) { suite.teardown(); } } else { stage = 3; } break; case 2: extra = "(in teardown) "; break; } #ifdef NO_LOG_RUNNING printf("Running test %s..",suite.testnames[i]); #endif printf("...failed %s%s:%d (%s)%s\n",extra,failed_file, failed_line, failed_message,stage == 3 ? " (and in teardown)" : ""); failed++; } } printf("%d run, %d passed, %d failed\n", suite.num_tests, passed, failed); return failed != 0; }
void PutKeysRegistry::PutBoolean(DescriptorKeyID key, bool b) { SPErr iErr = m_DescriptorProcs->PutBoolean(*m_Descriptor, key, b); if(iErr) throw ExceptionSPErr(StringUtil::ssprintf("PutKeysRegistry::PutBoolean(%08x)", key), iErr); }
int Suite::run( const std::vector<std::string>& suites , const std::string& filter , int runsPerTest ) { if (_allSuites().empty()) { log() << "error: no suites registered."; return EXIT_FAILURE; } for ( unsigned int i = 0; i < suites.size(); i++ ) { if ( _allSuites().count( suites[i] ) == 0 ) { log() << "invalid test suite [" << suites[i] << "], use --list to see valid names" << std::endl; return EXIT_FAILURE; } } std::vector<std::string> torun(suites); if ( torun.empty() ) { for ( SuiteMap::const_iterator i = _allSuites().begin(); i !=_allSuites().end(); ++i ) { torun.push_back( i->first ); } } std::vector<Result*> results; for ( std::vector<std::string>::iterator i=torun.begin(); i!=torun.end(); i++ ) { std::string name = *i; Suite* s = _allSuites()[name]; fassert( 16145, s ); log() << "going to run suite: " << name << std::endl; results.push_back( s->run( filter, runsPerTest ) ); } log() << "**************************************************" << std::endl; int rc = 0; int tests = 0; int asserts = 0; int millis = 0; Result totals ("TOTALS"); std::vector<std::string> failedSuites; for ( std::vector<Result*>::iterator i=results.begin(); i!=results.end(); i++ ) { Result* r = *i; log() << r->toString(); if ( abs( r->rc() ) > abs( rc ) ) rc = r->rc(); tests += r->_tests; if ( !r->_fails.empty() ) { failedSuites.push_back(r->toString()); for ( std::vector<std::string>::const_iterator j=r->_fails.begin(); j!=r->_fails.end(); j++ ) { const std::string& s = (*j); totals._fails.push_back(r->_name + "/" + s); } } asserts += r->_asserts; millis += r->_millis; } totals._tests = tests; totals._asserts = asserts; totals._millis = millis; log() << totals.toString(); // includes endl // summary if ( !totals._fails.empty() ) { log() << "Failing tests:" << std::endl; for ( std::vector<std::string>::const_iterator i=totals._fails.begin(); i!=totals._fails.end(); i++ ) { const std::string& s = (*i); log() << "\t " << s << " Failed"; } log() << "FAILURE - " << totals._fails.size() << " tests in " << failedSuites.size() << " suites failed"; } else { log() << "SUCCESS - All tests in all suites passed"; } return rc; }
void PutKeysRegistry::PutEnum(DescriptorKeyID key, DescriptorEnumID e, DescriptorEnumTypeID type) { SPErr iErr = m_DescriptorProcs->PutEnumerated(*m_Descriptor, key, type, e); if(iErr) throw ExceptionSPErr(StringUtil::ssprintf("PutKeysRegistry::PutEnum(%08x)", key), iErr); }