void init()
{
ok_count = 0;
exceptions_count = 0;
failures_count = 0;
terminations_count = 0;
warnings_count = 0;
not_passed.clear();
}
void test_completed(const tut::test_result& tr) override
{
if (tr.group != current_group)
{
os << std::endl << tr.group << ": " << std::flush;
current_group = tr.group;
}
os << tr << std::flush;
// update global statistics
switch (tr.result) {
case test_result::ok:
ok_count++;
break;
case test_result::fail:
case test_result::rethrown:
failures_count++;
break;
case test_result::ex:
case test_result::ex_ctor:
exceptions_count++;
break;
case test_result::warn:
warnings_count++;
break;
case test_result::term:
terminations_count++;
break;
case test_result::skipped:
skipped_count++;
break;
case tut::test_result::dummy:
assert( (tr.result != tut::test_result::dummy) && "Should never be called");
} // switch
if ( (tr.result != tut::test_result::ok) &&
(tr.result != tut::test_result::skipped) )
{
not_passed.push_back(tr);
}
}
void test_completed(const tut::test_result& tr)
{
if (tr.group != current_group)
{
os << std::endl << tr.group << ": " << std::endl;
current_group = tr.group;
}
os << tr << std::flush;
if (tr.result == tut::test_result::ok)
{
ok_count++;
}
else if (tr.result == tut::test_result::ex)
{
exceptions_count++;
}
else if (tr.result == tut::test_result::ex_ctor)
{
exceptions_count++;
}
else if (tr.result == tut::test_result::fail)
{
failures_count++;
}
else if (tr.result == tut::test_result::warn)
{
warnings_count++;
}
else
{
terminations_count++;
}
if (tr.result != tut::test_result::ok)
{
not_passed.push_back(tr);
}
}
bool all_ok() const
{
return not_passed.empty();
}
void run_completed()
{
os << std::endl;
if (not_passed.size() > 0)
{
not_passed_list::const_iterator i = not_passed.begin();
while (i != not_passed.end())
{
tut::test_result tr = *i;
os << std::endl;
os << "---> " << "group: " << tr.group
<< ", test: test<" << tr.test << ">"
<< (!tr.name.empty() ? (std::string(" : ") + tr.name) : std::string())
<< std::endl;
#if defined(TUT_USE_POSIX)
if(tr.pid != getpid())
{
os << " child pid: " << tr.pid << std::endl;
}
#endif
os << " problem: ";
switch(tr.result)
{
case test_result::rethrown:
os << "assertion failed in child" << std::endl;
break;
case test_result::fail:
os << "assertion failed" << std::endl;
break;
case test_result::ex:
case test_result::ex_ctor:
os << "unexpected exception" << std::endl;
if( tr.exception_typeid != "" )
{
os << " exception typeid: "
<< tr.exception_typeid << std::endl;
}
break;
case test_result::term:
os << "would be terminated" << std::endl;
break;
case test_result::warn:
os << "test passed, but cleanup code (destructor) raised"
" an exception" << std::endl;
break;
default:
break;
}
if (!tr.message.empty())
{
if (tr.result == test_result::fail)
{
os << " failed assertion: \"" << tr.message << "\""
<< std::endl;
}
else
{
os << " message: \"" << tr.message << "\""
<< std::endl;
}
}
++i;
}
}
os << std::endl;
os << "tests summary:";
if (terminations_count > 0)
{
os << " terminations:" << terminations_count;
}
if (exceptions_count > 0)
{
os << " exceptions:" << exceptions_count;
}
if (failures_count > 0)
{
os << " failures:" << failures_count;
}
if (warnings_count > 0)
{
os << " warnings:" << warnings_count;
}
os << " ok:" << ok_count;
os << std::endl;
}
bool all_ok() const override
{
return not_passed.empty();
}