int main(int argc, char **argv)
{
ArgumentSet args;
ArgumentMap kwargs;
process_args(argc, argv, args, kwargs);
if(kwargs.count("help"))
{
usage(argc, argv);
return 0;
}
if(kwargs.count("list"))
{
UnitTestDriver::s_driver().list_tests();
return 0;
}
if(kwargs.count("sizes"))
{
set_test_sizes(kwargs["sizes"]);
}
else
{
set_test_sizes("default");
}
bool passed = UnitTestDriver::s_driver().run_tests(args, kwargs);
if (kwargs.count("concise"))
std::cout << ((passed) ? "PASSED" : "FAILED") << std::endl;
return (passed) ? EXIT_SUCCESS : EXIT_FAILURE;
}
int main(int argc, char *argv[])
{
QCoreApplication app(argc, argv);
QString title = "This is a ctags wrapper. Does not require sooo many options.\nVersion: ";
title.append(BUILD_VERSION);
ArgumentParser parser(argc, argv);
parser.set_title(title);
parser.add_argument("--clear", "store_true", "clear");
parser.add_argument("--gen", "store_true", "gen");
parser.add_argument("--help", "store_true", "help");
parser.add_argument("-h", "store_true", "help");
ArgumentMap vm = parser.parse_args();
if (app.arguments().count() == 1)
{
parser.print_help();
return 1;
}
if (vm.count("help") > 0)
{
parser.print_help();
return 0;
}
QString path = QPath::join( QStringList()<<DATA_PATH << qos.env["PROJECT"] );
QString tagfile = QPath::join(path,"c.txt");
if (vm.count("clear") > 0)
{
if (!qos.remove(tagfile) )
return 1;
}
if (vm.count("gen") > 0)
{
if (!qos.is_dir(path))
{
if (!qos.makedirs(path))
{
qos.printerr("Could not create folders");
return 1;
}
}
QString cwd = qos.getcwd();
QSubProcess proc;
proc.start( QStringList()<<"ctags"<<"-a"<<"--tag-relative=no"<<"-R"<<"-f"<<tagfile<<" "<<cwd);
}
QTimer::singleShot(1,&app, SLOT(quit()));
return app.exec();
}
bool UnitTestDriver::run_tests(std::vector<UnitTest *>& tests_to_run, const ArgumentMap& kwargs)
{
std::time_t start_time = std::time(0);
bool verbose = kwargs.count("verbose");
bool concise = kwargs.count("concise");
std::vector< TestResult > test_results;
if (verbose && concise)
{
std::cout << "--verbose and --concise cannot be used together" << std::endl;
exit(EXIT_FAILURE);
}
if (!concise)
std::cout << "Running " << tests_to_run.size() << " unit tests." << std::endl;
for(size_t i = 0; i < tests_to_run.size(); i++){
UnitTest& test = *tests_to_run[i];
if (verbose)
std::cout << "Running " << test.name << "..." << std::flush;
try
{
// time the test
std::clock_t start = std::clock();
// run the test
test.run();
// test passed
record_result(TestResult(Pass, std::clock() - start, test), test_results);
}
catch (unittest::UnitTestFailure& f)
{
record_result(TestResult(Failure, std::numeric_limits<std::clock_t>::max(), test, f.message), test_results);
}
catch (unittest::UnitTestKnownFailure& f)
{
record_result(TestResult(KnownFailure, std::numeric_limits<std::clock_t>::max(), test, f.message), test_results);
}
catch (std::bad_alloc& e)
{
record_result(TestResult(Error, std::numeric_limits<std::clock_t>::max(), test, e.what()), test_results);
}
catch (unittest::UnitTestError& e)
{
record_result(TestResult(Error, std::numeric_limits<std::clock_t>::max(), test, e.message), test_results);
}
// immediate report
if (!concise)
{
if (verbose)
{
switch(test_results.back().status)
{
case Pass:
std::cout << "\r[PASS] ";
std::cout << std::setw(10) << 1000.f * float(test_results.back().elapsed) / CLOCKS_PER_SEC << " ms";
break;
case Failure:
std::cout << "\r[FAILURE] "; break;
case KnownFailure:
std::cout << "\r[KNOWN FAILURE] "; break;
case Error:
std::cout << "\r[ERROR] "; break;
default:
break;
}
std::cout << " " << test.name << std::endl;
}
else
{
switch(test_results.back().status)
{
case Pass:
std::cout << "."; break;
case Failure:
std::cout << "F"; break;
case KnownFailure:
std::cout << "K"; break;
case Error:
std::cout << "E"; break;
default:
break;
}
}
}
if (!post_test_sanity_check(test, concise))
{
return false;
}
std::cout.flush();
}
double elapsed_minutes = double(std::time(0) - start_time) / 60;
// summary report
if (!concise)
report_results(test_results, elapsed_minutes);
// if any failures or errors return false
for(size_t i = 0; i < test_results.size(); i++)
if (test_results[i].status != Pass && test_results[i].status != KnownFailure)
return false;
// all tests pass or are known failures
return true;
}
int main(int argc, char *argv[])
{
QCoreApplication app(argc,argv);
ArgumentParser parser(argc, argv);
parser.add_argument("--get", "store_true", "get");
parser.add_argument("--list", "store_true", "list");
parser.add_argument("--upload", "upload");
parser.add_argument("--delete", "store_true", "delete");
parser.add_argument("-h", "store_true", "help");
parser.add_argument("--help","store_true","help");
parser.add_notes(notes);
ArgumentMap vm = parser.parse_args();
QStringList args = parser.get_args();
if (vm.count("help") > 0 || app.arguments().count() == 1)
{
parser.print_help();
app.exit(0);
return 0;
}
if (parser.error != "")
{
qCritical() << parser.error;
app.exit(1);
return 1;
}
TemplateMgr tpl;
if (vm.count("list") > 0)
{
QStringList temps = tpl.templates();
for(int i=0;i<temps.count();i++)
{
QOSystem::printerr(temps[i]);
}
}
else if (vm.count("upload") > 0)
{
if (args.count() != 1)
{
QOSystem::printerr("Invalid number of arguments");
app.exit(1);
}
QString src = args[0];
QString val = vm["upload"];
QString data;
if (!QFileManager::readfile(src, data))
{
QOSystem::printerr("Could not read file");
app.exit(1);
return 1;
}
if (!tpl.setTemplate(val, src, data))
{
QOSystem::printerr("Could not set template");
app.exit(1);
return 1;
}
app.exit(0);
return 0;
}
else if (vm.count("delete") > 0)
{
if (!tpl.removeTemplate(args[0]))
{
QOSystem::printerr("Could not remove template");
app.exit(1);
return 1;
}
}
else if (vm.count("get") > 0)
{
TemplateItem item;
QMap<QString,QString> dict;
if (vm.count("env") > 0)
{
dict = QOSystem::getEnvDict();
}
if (!tpl.getTemplate(args[0], item, dict))
{
QOSystem::printerr("Could not get template");
app.exit(1);
return 1;
}
QOSystem::printerr(item.name);
if (!QFileManager::writefile(item.name, item.data))
{
QOSystem::printerr("Could not write template");
app.exit(1);
return 1;
}
}
return 0;
}
