tursom/memgraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Code review D8 changes

Browse Source
This commit is contained in:
sale 2016-11-29 11:46:29 +00:00
parent 228ae4cc72
commit b4fc263be1
4 changed files with 69 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
include/utils/command_line/arguments.hpp
View File

@ -8,19 +8,32 @@
#include <set>
#include <string>
#include <vector>
#include "utils/exceptions/basic_exception.hpp"
#include "utils/option.hpp"
#define REGISTER_ARGS(argc, argv) \
ProgramArguments::instance().register_args(argc, argv)
#define REGISTER_REQUIRED_ARGS(vector) \
ProgramArguments::instance().register_required_args(vector)
#define GET_ARG(flag, default_value) \
ProgramArguments::instance().get_arg(flag, default_value)
#define GET_ARGS(flag, default_value) \
ProgramArguments::instance().get_arg_list(flag, default_value)
#define CONTAINS_FLAG(flag) ProgramArguments::instance().contains_flag(flag)
#define CLEAR_ARGS() ProgramArguments::instance().clear()
// TODO namespace utils
namespace {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-function"
class ProgramArgumentException : public std::exception {
class ProgramArgumentException : public BasicException {
public:
virtual const char *what() const throw() {
return "Invalid Command Line Arguments";
}
} arg_exception;
ProgramArgumentException(const std::string &mess)
: BasicException("ProgramArgumentException: " + mess + ".") {}
};
class ProgramArguments {
private:
@ -48,10 +61,10 @@ class ProgramArguments {
public:
Argument(const std::string &arg) : arg_(arg) {}
std::string GetString() { return arg_; }
int GetInteger() { return std::atoi(arg_.c_str()); };
float GetFloat() { return std::atof(arg_.c_str()); };
long GetLong() { return std::atol(arg_.c_str()); }
std::string get_string() { return arg_; }
int get_int() { return std::atoi(arg_.c_str()); };
float get_float() { return std::atof(arg_.c_str()); };
long get_long() { return std::atol(arg_.c_str()); }
};
static ProgramArguments &instance() {
@ -75,7 +88,7 @@ class ProgramArguments {
i++;
std::string arg(*(argv + i));
if (!is_flag(arg))
arguments_[flag].push_back(arg);
arguments_[flag].emplace_back(arg);
else {
i--;
break;
@ -86,7 +99,8 @@ class ProgramArguments {
if (required_arguments_.empty()) return;
if (!is_valid()) throw arg_exception;
if (!is_valid())
throw ProgramArgumentException("Required Args not satisfied.");
}
void register_required_args(std::vector<std::string> args) {
@ -94,7 +108,8 @@ class ProgramArguments {
if (arguments_.empty()) return;
if (!is_valid()) throw arg_exception;
if (!is_valid())
throw ProgramArgumentException("Required Args not satisfied.");
}
bool contains_flag(const std::string &flag) {
@ -157,3 +172,4 @@ Option<std::string> take_argument(std::vector<std::string> &all,
#pragma clang diagnostic pop
}
// namespace utils

18
tests/benchmark/data_structures/concurrent/concurrent_map.cpp
View File

@ -30,7 +30,7 @@ using IntegerGenerator = NumberGenerator<std::uniform_int_distribution<int>,
std::default_random_engine, int>;
// Global arguments
int MAX_ELEMENTS = 1 << 20, MULTIPLIER = 2;
int MAX_ELEMENTS = 1 << 18, MULTIPLIER = 2;
int THREADS, RANGE_START, RANGE_END, STRING_LENGTH;
/*
@ -107,20 +107,16 @@ auto BM_ContainsValue = [](benchmark::State& state, auto* map, auto elements) {
-string-length number
*/
void parse_arguments(int argc, char** argv) {
ProgramArguments::instance().register_args(argc, argv);
REGISTER_ARGS(argc, argv);
RANGE_START =
ProgramArguments::instance().get_arg("-start", "0").GetInteger();
RANGE_END =
ProgramArguments::instance().get_arg("-end", "1000000000").GetInteger();
RANGE_START = GET_ARG("-start", "0").get_int();
RANGE_END = GET_ARG("-end", "1000000000").get_int();
THREADS = std::min(
ProgramArguments::instance().get_arg("-threads", "1").GetInteger(),
THREADS = std::min(GET_ARG("-threads", "1").get_int(),
(int)std::thread::hardware_concurrency());
STRING_LENGTH = ProgramArguments::instance()
.get_arg("-string-length", "128")
.GetInteger();
STRING_LENGTH =
ProgramArguments::instance().get_arg("-string-length", "128").get_int();
}
int main(int argc, char** argv) {

20
tests/benchmark/data_structures/concurrent/concurrent_map_mix.cpp
View File

@ -77,14 +77,11 @@ auto BM_Rape = [](benchmark::State& state, auto* map, auto& elements) {
-threads number
*/
void parse_arguments(int argc, char** argv) {
ProgramArguments::instance().register_args(argc, argv);
REGISTER_ARGS(argc, argv);
INSERT_PERC =
ProgramArguments::instance().get_arg("-insert", "50").GetInteger();
DELETE_PERC =
ProgramArguments::instance().get_arg("-delete", "20").GetInteger();
CONTAINS_PERC =
ProgramArguments::instance().get_arg("-find", "30").GetInteger();
INSERT_PERC = GET_ARG("-insert", "50").get_int();
DELETE_PERC = GET_ARG("-delete", "20").get_int();
CONTAINS_PERC = GET_ARG("-find", "30").get_int();
if (INSERT_PERC + DELETE_PERC + CONTAINS_PERC != 100) {
std::cout << "Invalid percentage" << std::endl;
@ -92,14 +89,11 @@ void parse_arguments(int argc, char** argv) {
exit(-1);
}
RANGE_START =
ProgramArguments::instance().get_arg("-start", "0").GetInteger();
RANGE_START = GET_ARG("-start", "0").get_int();
RANGE_END =
ProgramArguments::instance().get_arg("-end", "1000000000").GetInteger();
RANGE_END = GET_ARG("-end", "1000000000").get_int();
THREADS = std::min(
ProgramArguments::instance().get_arg("-threads", "1").GetInteger(),
THREADS = std::min(GET_ARG("-threads", "1").get_int(),
(int)std::thread::hardware_concurrency());
}

60
tests/unit/program_argument.cpp
View File

@ -7,53 +7,47 @@
#pragma clang diagnostic ignored "-Wwritable-strings"
TEST_CASE("ProgramArgument FlagOnly Test") {
ProgramArguments::instance().clear();
CLEAR_ARGS();
int argc = 2;
char* argv[] = {"ProgramArgument FlagOnly Test", "-test"};
ProgramArguments::instance().register_args(argc, argv);
ProgramArguments::instance().register_required_args({"-test"});
REGISTER_ARGS(argc, argv);
REGISTER_REQUIRED_ARGS({"-test"});
REQUIRE(ProgramArguments::instance().contains_flag("-test") == true);
REQUIRE(CONTAINS_FLAG("-test") == true);
}
TEST_CASE("ProgramArgument Single Entry Test") {
ProgramArguments::instance().clear();
CLEAR_ARGS();
int argc = 3;
char* argv[] = {"ProgramArgument Single Entry Test", "-bananas", "99"};
ProgramArguments::instance().register_required_args({"-bananas"});
ProgramArguments::instance().register_args(argc, argv);
REGISTER_REQUIRED_ARGS({"-bananas"});
REGISTER_ARGS(argc, argv);
REQUIRE(
ProgramArguments::instance().get_arg("-bananas", "100").GetInteger() ==
99);
REQUIRE(GET_ARG("-bananas", "100").get_int() == 99);
}
TEST_CASE("ProgramArgument Multiple Entries Test") {
ProgramArguments::instance().clear();
CLEAR_ARGS();
int argc = 4;
char* argv[] = {"ProgramArgument Multiple Entries Test", "-files",
"first_file.txt", "second_file.txt"};
ProgramArguments::instance().register_args(argc, argv);
REGISTER_ARGS(argc, argv);
auto files = ProgramArguments::instance().get_arg_list("-files", {});
auto files = GET_ARGS("-files", {});
REQUIRE(files[0].GetString() == "first_file.txt");
REQUIRE(files[0].get_string() == "first_file.txt");
}
TEST_CASE("ProgramArgument Combination Test") {
ProgramArguments::instance().clear();
CLEAR_ARGS();
int argc = 14;
char* argv[] = {"ProgramArgument Combination Test",
"-run_tests",
"-tests",
@ -69,27 +63,23 @@ TEST_CASE("ProgramArgument Combination Test") {
"-import",
"data.txt"};
ProgramArguments::instance().register_args(argc, argv);
REGISTER_ARGS(argc, argv);
REQUIRE(ProgramArguments::instance().contains_flag("-run_tests") == true);
REQUIRE(CONTAINS_FLAG("-run_tests") == true);
auto tests = ProgramArguments::instance().get_arg_list("-tests", {});
REQUIRE(tests[0].GetString() == "Test1");
REQUIRE(tests[1].GetString() == "Test2");
REQUIRE(tests[2].GetString() == "Test3");
auto tests = GET_ARGS("-tests", {});
REQUIRE(tests[0].get_string() == "Test1");
REQUIRE(tests[1].get_string() == "Test2");
REQUIRE(tests[2].get_string() == "Test3");
REQUIRE(
ProgramArguments::instance().get_arg("-run_times", "0").GetInteger() ==
10);
REQUIRE(GET_ARG("-run_times", "0").get_int() == 10);
auto exports = ProgramArguments::instance().get_arg_list("-export", {});
REQUIRE(exports[0].GetString() == "test1.txt");
REQUIRE(exports[1].GetString() == "test2.txt");
REQUIRE(exports[2].GetString() == "test3.txt");
auto exports = GET_ARGS("-export", {});
REQUIRE(exports[0].get_string() == "test1.txt");
REQUIRE(exports[1].get_string() == "test2.txt");
REQUIRE(exports[2].get_string() == "test3.txt");
REQUIRE(
ProgramArguments::instance().get_arg("-import", "test.txt").GetString() ==
"data.txt");
REQUIRE(GET_ARG("-import", "test.txt").get_string() == "data.txt");
}
#pragma clang diagnostic pop