int main(int argc, char **argv) {
srand(time(NULL));
if (TEST) runSuite();
else {
try {run();}
catch (std::exception &e) {
std::cout << "Error: " << e.what() << "\n";
}
}
}
/** Main program.
* @return 0 in case all tests ran successfully, otherwise 1.
*/
int main(void) {
int retVal = 0;
runSuite(&suite1);
if (runnerData->testCaseFailureCount != TEST_FAILURES_FOR_VERIFICATION) {
fprintf(stderr, "Error: %d test cases failed, expected %d test cases to fail.\n", (int) runnerData->testCaseFailureCount, (int) TEST_FAILURES_FOR_VERIFICATION);
retVal = 1;
}
#ifdef TEST_CASES_FOR_VERIFICATION
if (runnerData->testCaseCount != TEST_CASES_FOR_VERIFICATION) {
fprintf(stderr, "Test Cases: %d but expected %d\n", runnerData->testCaseCount, TEST_CASES_FOR_VERIFICATION);
retVal = 1;
}
#endif
return retVal;
}
int run_test(const char* name) {
int ret = 0;
// Run all tests for NULL parameter
if(name == NULL) {
// We suppose that there is only one suite
runSuite(&suite1);
// Verify all test were executed
if(runnerData->testCaseCount != TEST_CASES_FOR_VERIFICATION) {
printf("Test Cases: %d but expected %d\n", (int) runnerData->testCaseCount, TEST_CASES_FOR_VERIFICATION);
ret = -1;
}
} else {
bool found = false;
const TestSuite_t *const *suites = suite1.suites;
if (suites != NULL) {
for(; NULL != *suites; suites++) {
// Find specific test function name from test fixtures
TestFixture_t* fixture = (TestFixture_t*)*suites;
if(!strncmp(fixture->name, name, strlen(name))) {
runFixture(fixture, NULL);
found = true;
break;
}
}
}
if(!found) {
printf("Cannot find requested test : [%s]\n", name);
return -2;
}
}
if(runnerData->testCaseFailureCount != 0)
ret = -3;
printf("Test Cases: %d Success: %d Errors: %d\n", (int)runnerData->testCaseCount,
(int)runnerData->testCaseCount - runnerData->testCaseFailureCount,
(int)runnerData->testCaseFailureCount);
runnerData->testCaseCount = 0;
runnerData->testCaseFailureCount = 0;
return ret;
}
/** Main program.
* @param argc
* Number of command line arguments.
* @param argv
* Command line arguments.
* The first optional argument is a number of expected test cases to fail, which defaults to zero.
* The second optional argument is a number of expected test cases in total.
* @return 0 in case all tests ran successfully, otherwise 1.
*/
int main(int argc, char *argv[])
{
struct arguments arguments = { 0, 0 };
argp_parse(&argp, argc, argv, 0, 0, &arguments);
if (optind >= argc)
runSuite(&suite1);
else
runSuitesFromIds(argc - optind, &argv[optind]);
if (arguments.expectedTestCaseFailureCount != runnerData->testCaseFailureCount)
errx(EXIT_FAILURE, "expected failed test cases: %d; actual failed test cases: %" PRId16, arguments.expectedTestCaseFailureCount, runnerData->testCaseFailureCount);
if ((arguments.expectedTestCaseCount != 0) && (arguments.expectedTestCaseCount != runnerData->testCaseCount))
errx(EXIT_FAILURE, "expected test cases: %d; actual test cases: %" PRId16, arguments.expectedTestCaseCount, runnerData->testCaseCount);
return EXIT_SUCCESS;
}
int main()
{
int retcode = 0;
struct testcase testcases[] = {
TESTCASE(tgps_nmea_nextField),
TESTCASE(tgps_nmea_checksum),
TESTCASE(tgps_nmea_GPGSA),
TESTCASE(tgps_nmea_GPRMC),
TESTCASE(tgps_nmea_GPGGA),
TESTCASE(tgps_nmea_GPGSV),
};
/* initialize things */
/* run test suite on the airborne code */
retcode = runSuite((char*)"airborne_test_results.xml",
(char*)"airborne",
testcases,
sizeof(testcases)/sizeof(testcases[0]));
return (retcode == 0) ? 0 : -1;
}
int main()
{
runSuite();
return 0;
}
int main(){
runSuite();
}
int main(int argc, char *argv[])
{
try
{
// command line info
TCLAP::CmdLine cmd("Agros2D solver", ' ', versionString().toStdString());
TCLAP::SwitchArg logArg("l", "enable-log", "Enable log", false);
TCLAP::SwitchArg remoteArg("r", "remote-server", "Run remote server", false);
TCLAP::ValueArg<std::string> problemArg("p", "problem", "Solve problem", false, "", "string");
TCLAP::ValueArg<std::string> scriptArg("s", "script", "Solve script", false, "", "string");
TCLAP::ValueArg<std::string> testArg("t", "test", "Run tests", false, "list", "string");
cmd.add(logArg);
cmd.add(remoteArg);
cmd.add(problemArg);
cmd.add(scriptArg);
cmd.add(testArg);
// parse the argv array.
cmd.parse(argc, argv);
CleanExit cleanExit;
AgrosSolver a(argc, argv);
// enable log
a.setEnableLog(logArg.getValue());
// run remote server
if (remoteArg.getValue())
{
a.runRemoteServer();
return a.exec();
}
if (!problemArg.getValue().empty())
{
if (QFile::exists(QString::fromStdString(problemArg.getValue())))
{
QFileInfo info(QString::fromStdString(problemArg.getValue()));
if (info.suffix() == "a2d")
{
a.setFileName(QString::fromStdString(problemArg.getValue()));
QTimer::singleShot(0, &a, SLOT(solveProblem()));
return a.exec();
}
else
{
std::cout << QObject::tr("Unknown suffix.").toStdString() << std::endl;
return 1;
}
}
}
else if (!scriptArg.getValue().empty())
{
if (QFile::exists(QString::fromStdString(scriptArg.getValue())))
{
QFileInfo info(QString::fromStdString(scriptArg.getValue()));
if (info.suffix() == "py")
{
a.setFileName(QString::fromStdString(scriptArg.getValue()));
QTimer::singleShot(0, &a, SLOT(runScript()));
return a.exec();
}
else
{
std::cout << QObject::tr("Unknown suffix.").toStdString() << std::endl;
return 1;
}
}
}
else if (!testArg.getValue().empty())
{
if (QString::fromStdString(testArg.getValue()) == "list")
{
QTimer::singleShot(0, &a, SLOT(printTestSuites()));
}
else
{
a.setScriptSuite(QString::fromStdString(testArg.getValue()));
QTimer::singleShot(0, &a, SLOT(runSuite()));
}
return a.exec();
}
else
{
return 1;
}
}
catch (TCLAP::ArgException &e)
{
std::cerr << "error: " << e.error() << " for arg " << e.argId() << std::endl;
return 1;
}
}
void UnitTestSystem::init()
{
GameSystem::init();
gfx::GfxEngine *gfxEngine = gfx::GfxEngine::getEngine();
float screenWidth = static_cast<float>(gfxEngine->getScreenWidth());
float screenHeight = static_cast<float>(gfxEngine->getScreenHeight());
mDebugConsole->setMaxEntries(100);
mDebugConsole->setVisible(true);
int suiteCount = 0;
runSuite(tests::TestBase);
runSuite(tests::TestMouseManager);
runSuite(tests::TestMap);
runSuite(tests::TestCharacter);
runSuite(tests::TestLua);
runSuite(tests::TestLuaQuest);
runSuite(tests::TestLuaEventListener);
runSuite(tests::TestLuaCharacter);
runSuite(tests::TestLuaStats);
runSuite(tests::TestLuaStatModifiers);
runSuite(tests::TestLuaItem);
runSuite(tests::TestLuaInventory);
runSuite(tests::TestLuaTileType);
runSuite(tests::TestLuaTile);
runSuite(tests::TestLuaTileSet);
runSuite(tests::TestLuaEngine);
runSuite(tests::TestLevelable);
runSuite(tests::TestDialogue);
runSuite(tests::TestLuaDialogue);
runSuite(tests::TestEventInterface);
runSuite(tests::TestLuaMap);
runSuite(tests::TestItem);
runSuite(tests::TestPathTokeniser);
runSuite(tests::TestUtilData);
runSuite(tests::TestLuaDataTable);
runSuite(tests::TestUtils);
runSuite(tests::TestBodyParts);
runSuite(tests::TestLuaAsset);
runSuite(tests::TestStore);
runSuite(tests::TestLuaStore);
runSuite(tests::TestTransform);
const std::vector<std::string> &failed = tests::TestSuite::getFailedTests();
if (failed.size() > 0)
{
std::stringstream ss;
ss << "-------------------\nFailed tests: ";
std::vector<std::string>::const_iterator iter;
bool first = true;
for (iter = failed.begin(); iter != failed.end(); ++iter)
{
if (!first)
{
ss << ", ";
}
first = false;
ss << iter->c_str();
}
ss << "\n-------------------";
am_log("FAILED", ss);
}
else
{
std::stringstream ss;
ss << "-------------------\nAll ";
ss << suiteCount << " tests passed!";
ss << "\n-------------------";
am_log("PASSED", ss);
}
}
int main() {
Suite *s = createRssconSuite();
int ret = runSuite(s, false);
return (ret == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
