RemoveIfNotToBeRun(const std::vector<std::string>& specificationsToRun) : specificationsToRun(specificationsToRun) {}

bool operator()(Runnable* runnable) {

return std::find(specificationsToRun.begin(), specificationsToRun.end(), runnable->getName()) == specificationsToRun.end();

}

const std::vector<std::string>& specificationsToRun;

boost::program_options::options_description options("Options");

options.add_options()

("output,o", boost::program_options::value<std::string>(), "define output format. Allowed values: junit console")

("no-logs", "do not create log files when using JUnitReporter. No effect on other reporters")

("report-dir", boost::program_options::value<std::string>(), "directory where JUnit reports are created")

("specification,s", boost::program_options::value<std::vector<std::string> >(&specificationsToRun),"specification to be run, if multiple specifications will be run, the option can be repeated")

("multithreaded,m", "run tests using multiple threads to shorten execution time")

("help,h", "show help");

arguments = new boost::program_options::variables_map();

boost::program_options::store(boost::program_options::parse_command_line(argc, argv, options), *arguments);

boost::program_options::notify(*arguments);

if (arguments->count("help")) {

std::cout << options << std::endl;

exit(0);

}

OutputStream* output = createOutputStream();

Reporter* reporter = createReporter(*output);

std::vector<Runnable*> specs = SpecificationRegistry::instance().getSpecifications();

std::vector<Runnable*>::iterator last = specs.end();

if (!specificationsToRun.empty()) {

RemoveIfNotToBeRun removeIfNotToBeRun(specificationsToRun);

last = std::remove_if(specs.begin(), specs.end(), removeIfNotToBeRun);

}

int threads(1);

if (arguments->count("multithreaded")) {

threads = std::max((unsigned int)1, boost::thread::hardware_concurrency());

}

ThreadPool pool(threads);

pool.start(specs.begin(), last, *reporter);

bool failures = reporter->anyBehaviorFailed();

delete reporter;

delete output;

return failures;