std::vector<std::string> TesterAnalizer::generate_args( int column, Collector::Method method )
{
std::vector<std::string> args;
if( Helper::is_integer( method.params[ column ].type ) )
{
args = generate_ints( column, method );
} else if( Helper::is_string( method.params[ column ].type ) )
{
args = generate_strings( column, method );
} else
{
// Nothing to do
}
return args;
}
void destroy_symboltable () {
generate_globals();
generate_strings();
// free stack
stack_destroy (sts);
free (sts);
// free params type check list
istack_destroy(paramstack);
free(paramstack);
// free return call check list
list_destroy(returncheck);
free(returncheck);
// free operator stack
istack_destroy (inststack);
free (inststack);
// free global stack
istack_destroy (globstack);
free (globstack);
// free string stack
istack_destroy (strstack);
free (strstack);
// close output file
fclose(fp);
}
TEST(vector_map, operator_insert)
{
test_operator_insert<int>(generate_ints(100));
test_operator_insert<std::string>(generate_strings(100));
}
TEST(vector_map, lookup)
{
test_lookup<int>(generate_ints(100));
test_lookup<std::string>(generate_strings(100));
}
TEST(vector_map, copy_constructor)
{
test_copy<int>(generate_ints(100));
test_copy<std::string>(generate_strings(100));
}
TEST(vector_map, assignment)
{
test_assignment<int>(generate_ints(100));
test_assignment<std::string>(generate_strings(100));
}
TEST(vector_map, swap)
{
test_swap<int>(generate_ints(100));
test_swap<std::string>(generate_strings(100));
}
TEST(vector_map, clear)
{
test_clear<int>(generate_ints(100));
test_clear<std::string>(generate_strings(100));
}
auto len = lengthdist(benchmark_rng_engine());
*it = std::pair<std::string, std::size_t>(random_string(len, genchar), i);
++it;
}
}
std::vector<std::pair<std::string, std::size_t>> generate_strings(std::size_t n) {
std::vector<std::pair<std::string, std::size_t>> storage;
storage.reserve(n);
generate_random_strings(n, std::back_inserter(storage));
storage.shrink_to_fit();
return storage;
}
const std::pair<std::string, std::size_t>& target_string(std::size_t n, const std::vector<std::pair<std::string, std::size_t>>& strings) {
static std::unordered_map<std::size_t, std::size_t> targets;
auto it = targets.find(n);
if (it != targets.cend()) {
return strings[it->second];
}
std::uniform_int_distribution<std::size_t> dist(0, n);
std::size_t targetindex = dist(benchmark_rng_engine());
targets.insert(it, { n, targetindex });
const std::pair<std::string, std::size_t>& target = strings[targetindex];
return target;
}
const std::vector<std::pair<std::string, std::size_t>> generated_strings = generate_strings(50000);
TEST(vector_set, insert)
{
test_insert<int>(generate_ints(100));
test_insert<std::string>(generate_strings(100));
}
