bool TestRegistry::testShouldRun(Utest* test, TestResult& result)
{
if (groupFilter_ == 0) groupFilter_ = new SimpleString();
if (nameFilter_ == 0) nameFilter_ = new SimpleString();
if (test->shouldRun(*groupFilter_, *nameFilter_)) return true;
else {
result.countFilteredOut();
return false;
}
}
void Handle (TestResult& result, const char* condition,
const char* testname, const char* filename, int linenumber)
{
if (!g_bHandleExceptions)
throw;
const size_t size = 1024;
char msg[size] = "Unhandled exception ";
strncat( msg, condition, size );
result.AddFailure (Failure (msg, testname, filename, linenumber));
}
void ReproduceListener::onTestFinished(const TestMetadata &metadata,
const TestResult &result) {
if (metadata.id.empty()) {
return;
}
FailureResult failure;
if (result.match(failure)) {
m_reproduceMap.emplace(metadata.id, failure.reproduce);
}
}
virtual void run() {
TestResultCollector collector;
// create a test result and add the listeners
TestResult result;
result.addListener(&collector);
// create a test runner
TestRunner runner;
MyTest test1;
MyTest2 test2;
runner.addTest(&test1);
runner.addTest(&test2);
runner.run(result);
//RTF_TEST_REPORT(Asserter::format("count: %d", collector.failedCount()));
RTF_TEST_CHECK(collector.testCount() == 2, "Checking tests count");
RTF_TEST_CHECK(collector.passedCount() == 1, "Checking passed count");
RTF_TEST_CHECK(collector.failedCount() == 1, "Checking failed count");
}
void TestOutput::printCurrentTestEnded(const TestResult& res)
{
if (verbose_) {
print(" - ");
print(res.getCurrentTestTotalExecutionTime());
print(" ms\n");
}
else {
printProgressIndicator();
}
}
/*
* Run the test suite, return 0 on success, 1 on error.
*/
int main(void) {
TestResult controller;
TestResultCollector result;
controller.addListener(&result);
BriefTestProgressListener progress;
controller.addListener(&progress);
TestRunner runner;
runner.addTest( TestFactoryRegistry::getRegistry().makeTest() );
runner.run(controller);
CompilerOutputter outputter(&result, std::cerr);
outputter.write();
return result.wasSuccessful() ? 0 : 1;
}
void EndTest(const std::string&,
const std::string&,
const TestParametersDescriptor&,
const TestResult& result) override
{
_stream << Console::TextBlue
<< Console::TextDefault
<< std::setprecision(5)
<< std::setw(9)
<< result.IterationsPerSecondAverage()
<< " fps";
}
void runPreviousTest()
{
if (currentTest_ == 0) return;
if (firstTestInGroup_) {
result_.currentGroupStarted(currentTest_);
firstTestInGroup_ = false;
}
result_.currentTestStarted(currentTest_);
millisTime += timeTheTestTakes_;
if (testFailure_) {
result_.addFailure(*testFailure_);
delete testFailure_;
testFailure_ = 0;
}
result_.currentTestEnded(currentTest_);
}
void Runner::runTestAt(unsigned int index, TestResult& result) const {
TestCase* test = tests_[index]();
result.setTestName(test->testName());
printf("Testing %s: ", test->testName());
fflush(stdout);
#if JSON_USE_EXCEPTION
try {
#endif // if JSON_USE_EXCEPTION
test->run(result);
#if JSON_USE_EXCEPTION
}
catch (const std::exception& e) {
result.addFailure(__FILE__, __LINE__, "Unexpected exception caught:")
<< e.what();
}
#endif // if JSON_USE_EXCEPTION
delete test;
const char* status = result.failed() ? "FAILED" : "OK";
printf("%s\n", status);
fflush(stdout);
}
USING_NAMESPACE_CPPUNIT
void TestSetupTest::testTestSetup()
{
TestSuite* suite = new TestSuite("2Tests");
suite->addTest(new TestCaseTest::SuccessTestCase("SuccessTestCase"));
suite->addTest(new TestCaseTest::FailureTestCase("FailureTestCase"));
TestTestSetup test(suite);
TEST_ASSERT_EQUALS(2, test.countTestCases());
TEST_ASSERT_EQUALS("2Tests", test.getName());
TEST_ASSERT_EQUALS("suite 2Tests", test.toString());
TestResult result;
test.run(&result);
TEST_ASSERT(test.wasSetUp);
TEST_ASSERT(test.wasTornDown);
TEST_ASSERT_EQUALS(2, result.runCount());
TEST_ASSERT_EQUALS(1, result.failureCount());
TEST_ASSERT_EQUALS(0, result.errorCount());
TEST_ASSERT(!result.wasSuccessful());
}
void TestRunnerThread::run()
{
QtTestListener listener(m_output_widget, m_result_widget);
TestResult result;
global_logger().set_enabled(false);
const filesystem::path old_current_path =
Application::change_current_directory_to_tests_root_path();
m_repository.run(listener, result);
filesystem::current_path(old_current_path);
global_logger().set_enabled(true);
const int failed_count = static_cast<int>(result.get_case_failure_count());
const int passed_count = static_cast<int>(result.get_case_execution_count()) - failed_count;
emit signal_finished(passed_count, failed_count);
}
TEST_F(TestBCAsyncMatch, SubmitTurn)
{
TestBCAsyncMatch::CreateMatch();
TestResult tr;
Json::Value matchState;
matchState["map"] = "level01";
Json::FastWriter fw;
m_bc->getAsyncMatchService()->submitTurn(GetUser(UserA)->m_profileId,
m_matchId.c_str(),
0,
fw.write(matchState).c_str(),
NULL,
GetUser(UserB)->m_profileId,
fw.write(matchState).c_str(),
fw.write(matchState).c_str(),
&tr);
tr.run(m_bc);
TestBCAsyncMatch::AbandonMatch();
}
bool
Runner::runAllTest( bool printSummary ) const
{
unsigned int count = testCount();
std::deque<TestResult> failures;
for ( unsigned int index = 0; index < count; ++index )
{
TestResult result;
runTestAt( index, result );
if ( result.failed() )
{
failures.push_back( result );
}
}
if ( failures.empty() )
{
if ( printSummary )
{
printf( "All %d tests passed\n", count );
}
return true;
}
else
{
for ( unsigned int index = 0; index < failures.size(); ++index )
{
TestResult &result = failures[index];
result.printFailure( count > 1 );
}
if ( printSummary )
{
unsigned int failedCount = static_cast<unsigned int>( failures.size() );
unsigned int passedCount = count - failedCount;
printf( "%d/%d tests passed (%d failure(s))\n", passedCount, count, failedCount );
}
return false;
}
}
TEST_F(TestBCGroup, CancelGroupInvitation)
{
Authenticate(UserA);
CreateGroup();
TestResult tr;
m_bc->getGroupService()->inviteGroupMember(
_groupId.c_str(),
GetUser(UserB)->m_profileId,
eGroupMember::ADMIN,
"",
&tr);
tr.run(m_bc);
m_bc->getGroupService()->cancelGroupInvitation(
_groupId.c_str(),
GetUser(UserB)->m_profileId,
&tr);
tr.run(m_bc);
DeleteGroup();
}
void TextResultPrinter::listFailures(const TestResult& result) const
{
if (isAllPassed())
return;
out << RED << "[ FAILED ] "
<< WHITE << numOfTotalFail << " tests, listed below:\n";
result.listFailures([&](const TestFailure& failure){
out << RED << titleFor(failure)
<< WHITE << failure.getTestName() << std::endl;
});
}
void StdOutput::TestCompleted(ISingleTest &test, const TestResult &result)
{
if (result.TestOK())
{
m_os << "." << std::flush;
m_okCount++;
return;
}
m_os << "[" << test.getTestNumber() << "=X]" << std::flush;
m_exceptionsCount++;
m_resultList.push_back(result);
}
TEST_F(TestBCGroup, RemoveGroupMember)
{
CreateGroupAsUserA(true);
Authenticate(UserB);
TestResult tr;
m_bc->getGroupService()->joinGroup(
_groupId.c_str(),
&tr);
tr.run(m_bc);
Logout();
Authenticate(UserA);
m_bc->getGroupService()->removeGroupMember(
_groupId.c_str(),
GetUser(UserB)->m_profileId,
&tr);
tr.run(m_bc);
DeleteGroup();
}
TEST_F(TestBCGroup, ListGroupsPageByOffset)
{
Authenticate(UserA);
std::string context = CreateContext(10, 1, "groupType", _groupType);
TestResult tr;
m_bc->getGroupService()->listGroupsPage(
context.c_str(),
&tr);
tr.run(m_bc);
context = tr.m_response["data"]["context"].asString();
m_bc->getGroupService()->listGroupsPageByOffset(
context.c_str(),
1,
&tr);
tr.run(m_bc);
Logout();
}
void Assert::assertFail( const Toolkit::Core::SourceLine& srcLine, const TestResultType& res, const QString& message ) const {
TestResult testRes;
testRes.setAssertType( TestResult::ASSERT_FAIL );
testRes.setSourceLine( srcLine );
testRes.setResultType( TestResultType( res ) );
testRes.setMessage( message );
m_Report->addResult( testRes.getResultType() );
if( m_Report->willWriteResultType( testRes.getResultType() ) ) {
m_Report->writeAssert( testRes );
};
throwAssertException( srcLine, testRes.getResultType().getResultType(), message );
};
void Assert::assertException( const Toolkit::Core::SourceLine& srcLine, int assertType, const QString& message, const TestResultType& resType, const QString& expName, const QString& expMessage ) const {
TestResult testRes;
testRes.setAssertType( assertType );
testRes.setSourceLine( srcLine );
testRes.setResultType( TestResultType( resType ) );
testRes.setMessage( message );
m_Report->addResult( testRes.getResultType() );
if( m_Report->willWriteResultType( testRes.getResultType() ) ) {
m_Report->writeAssertException( testRes, expName, expMessage );
};
throwAssertException( srcLine, testRes.getResultType().getResultType(), message );
};
bool Test::check(long expected, long actual, TestResult& result, const SimpleString& fileName, long lineNumber) {
if (expected == actual)
return true;
result.addFailure (
Failure (
name_,
StringFrom (__FILE__),
__LINE__,
StringFrom (expected),
StringFrom (actual)));
return false;
}
int main(int argc, char **argv) {
TestResult controller;
TestResultCollector result;
controller.addListener(&result);
BriefTestProgressListener progress;
controller.addListener(&progress);
TestRunner runner;
runner.addTest(TestFactoryRegistry::getRegistry().makeTest());
runner.run(controller);
// compiler output
CompilerOutputter coutputter(&result, stdCOut());
coutputter.write();
// output test result for jenkins
std::ofstream ofs("test_result.xml");
CPPUNIT_NS::XmlOutputter outputter(&result, ofs,"UTF-8");
outputter.write();
return result.wasSuccessful() ? 0 : 1;
}
TEST_F(TestBCEntity, GetPageOffset)
{
GenerateDefaultEntites(20);
Json::Value context;
Json::FastWriter fw;
context["pagination"]["rowsPerPage"] = 12;
context["pagination"]["pageNumber"] = 1;
context["searchCriteria"]["entityType"] = m_entityType;
TestResult tr;
m_bc->getEntityService()->getPage(fw.write(context).c_str(), &tr);
tr.run(m_bc);
std::string context_str = tr.m_response["data"]["context"].asString();
tr.reset();
m_bc->getEntityService()->getPageOffset(context_str.c_str(), 1, &tr);
tr.run(m_bc);
DeleteAllDefaultEntities();
}
int main(int argc, char** argv)
{
TestResult testresult;
TestResultCollector collectedresults;
BriefTestProgressListener progress;
testresult.addListener(&collectedresults);
testresult.addListener(&progress);
TestRunner testrunner;
testrunner.addTest (TestFactoryRegistry::getRegistry().makeTest());
testrunner.run(testresult);
CompilerOutputter compileroutputter(&collectedresults, std::cerr);
compileroutputter.write();
// Output XML for Jenkins CPPunit plugin
/*ofstream xmlFileOut("cppTestBasicMathResults.xml");
XmlOutputter xmlOut(&collectedresults, xmlFileOut);
xmlOut.write();*/
return collectedresults.wasSuccessful() ? 0 : 1;
}
/// Run the test suite and return a count of failures
int TestSuite::report() {
auto failures = 0;
auto count = 0;
for (auto i = 0; i < this->tests.size(); ++i) {
TestResult *t = this->tests.at(i);
count += 1;
printf("exec: %s ", t->name);
if (t->run()) {
printf("\033[32mOK\033[0m\n");
}
else {
failures += 1;
printf("\033[31;1mFAIL\033[0m\n");
}
}
if (failures > 0) {
printf("\033[31;1mFAILED (%d/%d passed)\033[0m\n", count - failures, count);
}
else {
printf("SUCCESS\n");
}
return failures;
}
void TestBCAsyncMatch::CreateMatchWithInitialTurn()
{
TestResult tr;
Json::FastWriter fw;
Json::Value player2Data;
player2Data["id"] = GetUser(UserB)->m_profileId;
player2Data["platform"] = "BC";
Json::Value players(Json::arrayValue);
players.append(player2Data);
Json::Value matchState;
matchState["map"] = "level01";
m_bc->getAsyncMatchService()->createMatchWithInitialTurn(fw.write(players).c_str(),
NULL,
NULL,
GetUser(UserB)->m_profileId,
fw.write(matchState).c_str(),
&tr);
tr.run(m_bc);
m_matchId = tr.m_response["data"]["matchId"].asString();
}
bool Test::check(const std::string& expected, const std::string& actual, TestResult& result, const std::string& fileName, long lineNumber)
{
if (expected == actual)
return true;
result.addFailure (
Failure (
name_,
boost::lexical_cast<std::string> (__FILE__),
__LINE__,
expected,
actual));
return false;
}
TEST_F(TestBCGroup, ApproveGroupJoinRequest)
{
CreateGroupAsUserA();
Authenticate(UserB);
TestResult tr;
m_bc->getGroupService()->joinGroup(
_groupId.c_str(),
&tr);
tr.run(m_bc);
Logout();
Authenticate(UserA);
m_bc->getGroupService()->approveGroupJoinRequest(
_groupId.c_str(),
GetUser(UserB)->m_profileId,
eGroupMember::MEMBER,
"",
&tr);
tr.run(m_bc);
DeleteGroup();
}
void TestSuite::run(
const IFilter& filter,
ITestListener& test_listener,
TestResult& cumulated_result) const
{
TestResult test_suite_result;
run_suite(
filter,
test_listener,
test_suite_result,
cumulated_result);
cumulated_result.merge(test_suite_result);
}
TEST_F(TestBCGroup, ReadGroupEntitiesPageByOffset)
{
Authenticate(UserA);
CreateGroup();
std::string context = CreateContext(10, 1, "groupId", _groupId);
TestResult tr;
m_bc->getGroupService()->readGroupEntitiesPage(
context.c_str(),
&tr);
tr.run(m_bc);
context = tr.m_response["data"]["context"].asString();
m_bc->getGroupService()->readGroupEntitiesPageByOffset(
context.c_str(),
1,
&tr);
tr.run(m_bc);
DeleteGroup();
Logout();
}
