mirror of
https://github.com/red0124/ssp.git
synced 2025-01-22 20:55:18 +01:00
55d0a4e598
* Bugfix/odr violations (#47) * Make common non-member functions inline, remove unreachable line from get_line_buffer * [skip ci] Fix namespace comments * Resolve clang-tidy warnings (#48) * Resolve clang-tidy warnings, update single_header_generator.py * Update single header test, resolve additional clang-tidy warnings * Add header and raw_header methods, update header usage methods error handling, write new and update existing unit tests * Update parser error messages, fix parser tests * Add [[nodiscard]] where fitting, update unit tests (#49) * Add const where fitting, make splitter class members private, add #pragma once to ssp.hpp * Modify header parsing for empty headers, update old and add new tests for header parsing * Enable the parser to accept a header with one empty field, update unit tests * Fix test CMakeLists.txt typo
401 lines
13 KiB
C++
401 lines
13 KiB
C++
#include "test_parser1.hpp"
|
|
|
|
template <typename T, typename Tuple>
|
|
struct has_type;
|
|
|
|
template <typename T, typename... Us>
|
|
struct has_type<T, std::tuple<Us...>>
|
|
: std::disjunction<std::is_same<T, Us>...> {};
|
|
|
|
template <typename T, typename... Ts>
|
|
static void test_fields(const std::string file_name, const std::vector<X>& data,
|
|
const std::vector<std::string>& header,
|
|
const std::vector<std::string>& fields) {
|
|
constexpr auto buffer_mode = T::BufferMode::value;
|
|
using ErrorMode = typename T::ErrorMode;
|
|
using CaseType = std::tuple<Ts...>;
|
|
|
|
auto [p, _] = make_parser<buffer_mode, ErrorMode>(file_name, ",");
|
|
CHECK_FALSE(p.field_exists("Unknown"));
|
|
p.use_fields(fields);
|
|
|
|
CHECK_EQ_ARRAY(header, p.header());
|
|
CHECK_EQ(merge_header(p.header(), ","), p.raw_header());
|
|
std::vector<CaseType> i;
|
|
|
|
for (const auto& a : p.template iterate<CaseType>()) {
|
|
CHECK_EQ_ARRAY(header, p.header());
|
|
CHECK_EQ(merge_header(p.header(), ","), p.raw_header());
|
|
i.push_back(a);
|
|
}
|
|
|
|
CHECK_EQ(i.size(), data.size());
|
|
for (size_t j = 0; j < i.size(); ++j) {
|
|
if constexpr (has_type<int, CaseType>::value) {
|
|
CHECK_EQ(std::get<int>(i[j]), data[j].i);
|
|
}
|
|
if constexpr (has_type<double, CaseType>::value) {
|
|
CHECK_EQ(std::get<double>(i[j]), data[j].d);
|
|
}
|
|
if constexpr (has_type<std::string, CaseType>::value) {
|
|
CHECK_EQ(std::get<std::string>(i[j]), data[j].s);
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_CASE_TEMPLATE("test various cases with header", T,
|
|
ParserOptionCombinations) {
|
|
unique_file_name f{"various_cases_with_header"};
|
|
using str = std::string;
|
|
|
|
constexpr static auto Int = "Int";
|
|
constexpr static auto Dbl = "Double";
|
|
constexpr static auto Str = "String";
|
|
const std::vector<std::string> header{Int, Dbl, Str};
|
|
|
|
std::vector<X> data = {{1, 2, "x"}, {3, 4, "y"}, {5, 6, "z"},
|
|
{7, 8, "u"}, {9, 10, "v"}, {11, 12, "w"}};
|
|
|
|
make_and_write(f.name, data, header);
|
|
const auto& o = f.name;
|
|
const auto& d = data;
|
|
|
|
{
|
|
ss::parser<ss::string_error> p{f.name, ","};
|
|
std::vector<X> i;
|
|
|
|
for (const auto& a : p.iterate<int, double, std::string>()) {
|
|
CHECK_EQ(header, p.header());
|
|
CHECK_EQ(merge_header(p.header(), ","), p.raw_header());
|
|
i.emplace_back(ss::to_object<X>(a));
|
|
}
|
|
|
|
CHECK_NE(i, data);
|
|
}
|
|
|
|
{
|
|
ss::parser<ss::string_error> p{f.name, ","};
|
|
std::vector<X> i;
|
|
|
|
p.ignore_next();
|
|
for (const auto& a : p.iterate<int, double, std::string>()) {
|
|
CHECK_EQ(header, p.header());
|
|
CHECK_EQ(merge_header(p.header(), ","), p.raw_header());
|
|
i.emplace_back(ss::to_object<X>(a));
|
|
}
|
|
|
|
CHECK_EQ(i, data);
|
|
}
|
|
|
|
{
|
|
ss::parser<ss::string_error> p{f.name, ","};
|
|
CHECK_EQ(header, p.header());
|
|
CHECK_EQ(merge_header(p.header(), ","), p.raw_header());
|
|
|
|
p.use_fields(Int, Dbl);
|
|
CHECK_EQ(header, p.header());
|
|
CHECK_EQ(merge_header(p.header(), ","), p.raw_header());
|
|
|
|
{
|
|
auto [int_, double_] = p.get_next<int, double>();
|
|
CHECK_EQ(int_, data[0].i);
|
|
CHECK_EQ(double_, data[0].d);
|
|
}
|
|
|
|
p.use_fields(Dbl, Int);
|
|
CHECK_EQ(header, p.header());
|
|
CHECK_EQ(merge_header(p.header(), ","), p.raw_header());
|
|
|
|
{
|
|
auto [double_, int_] = p.get_next<double, int>();
|
|
CHECK_EQ(int_, data[1].i);
|
|
CHECK_EQ(double_, data[1].d);
|
|
}
|
|
|
|
p.use_fields(Str);
|
|
|
|
{
|
|
auto string_ = p.get_next<std::string>();
|
|
CHECK_EQ(string_, data[2].s);
|
|
}
|
|
|
|
p.use_fields(Str, Int, Dbl);
|
|
|
|
{
|
|
auto [string_, int_, double_] =
|
|
p.get_next<std::string, int, double>();
|
|
CHECK_EQ(double_, data[3].d);
|
|
CHECK_EQ(int_, data[3].i);
|
|
CHECK_EQ(string_, data[3].s);
|
|
}
|
|
}
|
|
|
|
/* python used to generate permutations
|
|
import itertools
|
|
|
|
header = {'str': 'Str',
|
|
'double': 'Dbl',
|
|
'int': 'Int'}
|
|
|
|
keys = ['str', 'int', 'double']
|
|
|
|
for r in range (1, 3):
|
|
combinations = list(itertools.permutations(keys, r = r))
|
|
|
|
for combination in combinations:
|
|
template_params = []
|
|
arg_params = []
|
|
for type in combination:
|
|
template_params.append(type)
|
|
arg_params.append(header[type])
|
|
call = 'testFields<' + ', '.join(template_params) + \
|
|
'>(o, d, header, {' + ', '.join(arg_params) + '});'
|
|
print(call)
|
|
*/
|
|
|
|
test_fields<T, str>(o, d, header, {Str});
|
|
test_fields<T, int>(o, d, header, {Int});
|
|
test_fields<T, double>(o, d, header, {Dbl});
|
|
test_fields<T, str, int>(o, d, header, {Str, Int});
|
|
test_fields<T, str, double>(o, d, header, {Str, Dbl});
|
|
test_fields<T, int, str>(o, d, header, {Int, Str});
|
|
test_fields<T, int, double>(o, d, header, {Int, Dbl});
|
|
test_fields<T, double, str>(o, d, header, {Dbl, Str});
|
|
test_fields<T, double, int>(o, d, header, {Dbl, Int});
|
|
test_fields<T, str, int, double>(o, d, header, {Str, Int, Dbl});
|
|
test_fields<T, str, double, int>(o, d, header, {Str, Dbl, Int});
|
|
test_fields<T, int, str, double>(o, d, header, {Int, Str, Dbl});
|
|
test_fields<T, int, double, str>(o, d, header, {Int, Dbl, Str});
|
|
test_fields<T, double, str, int>(o, d, header, {Dbl, Str, Int});
|
|
test_fields<T, double, int, str>(o, d, header, {Dbl, Int, Str});
|
|
}
|
|
|
|
template <typename T>
|
|
void test_invalid_fields(const std::vector<std::string>& lines,
|
|
const std::vector<std::string>& fields) {
|
|
constexpr auto buffer_mode = T::BufferMode::value;
|
|
using ErrorMode = typename T::ErrorMode;
|
|
|
|
auto check_header = [&lines](auto& p) {
|
|
if (lines.empty()) {
|
|
CHECK_EQ(p.header().size(), 1);
|
|
CHECK_EQ(p.header().at(0), "");
|
|
CHECK_EQ(merge_header(p.header(), ","), p.raw_header());
|
|
} else {
|
|
CHECK_EQ(lines[0], merge_header(p.header()));
|
|
CHECK_EQ(merge_header(p.header(), ","), p.raw_header());
|
|
}
|
|
CHECK(p.valid());
|
|
};
|
|
|
|
unique_file_name f{"invalid_fields"};
|
|
{
|
|
std::ofstream out{f.name};
|
|
for (const auto& line : lines) {
|
|
out << line << std::endl;
|
|
}
|
|
}
|
|
|
|
{
|
|
// No fields specified
|
|
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name, ",");
|
|
auto command = [&p = p] { p.use_fields(); };
|
|
expect_error_on_command(p, command);
|
|
check_header(p);
|
|
}
|
|
|
|
{
|
|
// Unknown field
|
|
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name, ",");
|
|
auto command = [&p = p] { p.use_fields("Unknown"); };
|
|
expect_error_on_command(p, command);
|
|
check_header(p);
|
|
}
|
|
|
|
{
|
|
// Field used multiple times
|
|
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name, ",");
|
|
auto command = [&p = p, &fields = fields] {
|
|
p.use_fields(fields.at(0), fields.at(0));
|
|
};
|
|
if (!fields.empty()) {
|
|
expect_error_on_command(p, command);
|
|
}
|
|
check_header(p);
|
|
}
|
|
|
|
{
|
|
// Mapping out of range
|
|
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name, ",");
|
|
auto command = [&p = p, &fields = fields] {
|
|
p.use_fields(fields.at(0));
|
|
std::ignore = p.template get_next<std::string, std::string>();
|
|
};
|
|
check_header(p);
|
|
|
|
if (!fields.empty()) {
|
|
expect_error_on_command(p, command);
|
|
}
|
|
check_header(p);
|
|
}
|
|
|
|
{
|
|
// Invalid header
|
|
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name, ",");
|
|
auto command = [&p = p, &fields = fields] { p.use_fields(fields); };
|
|
check_header(p);
|
|
|
|
if (!fields.empty()) {
|
|
// Pass if there are no duplicates, fail otherwise
|
|
if (std::unordered_set<std::string>{fields.begin(), fields.end()}
|
|
.size() != fields.size()) {
|
|
expect_error_on_command(p, command);
|
|
} else {
|
|
command();
|
|
CHECK(p.valid());
|
|
if (!p.valid()) {
|
|
if constexpr (T::StringError) {
|
|
std::cout << p.error_msg() << std::endl;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
check_header(p);
|
|
}
|
|
}
|
|
|
|
TEST_CASE_TEMPLATE("test invalid header fields usage", T,
|
|
ParserOptionCombinations) {
|
|
test_invalid_fields<T>({}, {});
|
|
|
|
test_invalid_fields<T>({"Int"}, {"Int"});
|
|
test_invalid_fields<T>({"Int", "1"}, {"Int"});
|
|
test_invalid_fields<T>({"Int", "1", "2"}, {"Int"});
|
|
|
|
test_invalid_fields<T>({"Int,String"}, {"Int", "String"});
|
|
test_invalid_fields<T>({"Int,String", "1,hi"}, {"Int", "String"});
|
|
test_invalid_fields<T>({"Int,String", "2,hello"}, {"Int", "String"});
|
|
|
|
test_invalid_fields<T>({"Int,String,Double"}, {"Int", "String", "Double"});
|
|
test_invalid_fields<T>({"Int,String,Double", "1,hi,2.34"},
|
|
{"Int", "String", "Double"});
|
|
test_invalid_fields<T>({"Int,String,Double", "1,hi,2.34", "2,hello,3.45"},
|
|
{"Int", "String", "Double"});
|
|
|
|
test_invalid_fields<T>({"Int,Int,Int"}, {"Int", "Int", "Int"});
|
|
test_invalid_fields<T>({"Int,Int,Int", "1,2,3"}, {"Int", "Int", "Int"});
|
|
|
|
test_invalid_fields<T>({"Int,String,Int"}, {"Int", "String", "Int"});
|
|
test_invalid_fields<T>({"Int,String,Int", "1,hi,3"},
|
|
{"Int", "String", "Int"});
|
|
}
|
|
|
|
TEST_CASE_TEMPLATE("test invalid rows with header", T,
|
|
ParserOptionCombinations) {
|
|
constexpr auto buffer_mode = T::BufferMode::value;
|
|
using ErrorMode = typename T::ErrorMode;
|
|
|
|
unique_file_name f{"invalid_rows_with_header"};
|
|
{
|
|
std::ofstream out{f.name};
|
|
out << "Int,String,Double" << std::endl;
|
|
out << "1,line1,2.34" << std::endl;
|
|
out << "2,line2" << std::endl;
|
|
out << "3,line3,67.8" << std::endl;
|
|
out << "4,line4,67.8,9" << std::endl;
|
|
out << "5,line5,9.10" << std::endl;
|
|
out << "six,line6,10.11" << std::endl;
|
|
}
|
|
|
|
std::vector<std::string> header = {"Int", "String", "Double"};
|
|
|
|
{
|
|
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name);
|
|
CHECK_EQ_ARRAY(header, p.header());
|
|
CHECK_EQ(merge_header(p.header()), p.raw_header());
|
|
|
|
p.use_fields("Int", "String", "Double");
|
|
using data = std::tuple<int, std::string, double>;
|
|
std::vector<data> i;
|
|
|
|
CHECK(p.valid());
|
|
|
|
while (!p.eof()) {
|
|
try {
|
|
const auto& t = p.template get_next<data>();
|
|
if (p.valid()) {
|
|
i.push_back(t);
|
|
}
|
|
} catch (const ss::exception&) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
std::vector<data> expected = {{1, "line1", 2.34},
|
|
{3, "line3", 67.8},
|
|
{5, "line5", 9.10}};
|
|
CHECK_EQ(i, expected);
|
|
CHECK_EQ_ARRAY(header, p.header());
|
|
CHECK_EQ(merge_header(p.header()), p.raw_header());
|
|
}
|
|
|
|
{
|
|
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name);
|
|
CHECK_EQ_ARRAY(header, p.header());
|
|
CHECK_EQ(merge_header(p.header()), p.raw_header());
|
|
|
|
p.use_fields("Double", "Int");
|
|
using data = std::tuple<double, int>;
|
|
std::vector<data> i;
|
|
|
|
CHECK(p.valid());
|
|
|
|
while (!p.eof()) {
|
|
try {
|
|
const auto& t = p.template get_next<data>();
|
|
if (p.valid()) {
|
|
i.push_back(t);
|
|
}
|
|
} catch (const ss::exception&) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
std::vector<data> expected = {{2.34, 1}, {67.8, 3}, {9.10, 5}};
|
|
CHECK_EQ(i, expected);
|
|
CHECK_EQ_ARRAY(header, p.header());
|
|
CHECK_EQ(merge_header(p.header()), p.raw_header());
|
|
}
|
|
|
|
{
|
|
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name);
|
|
CHECK_EQ_ARRAY(header, p.header());
|
|
CHECK_EQ(merge_header(p.header()), p.raw_header());
|
|
|
|
p.use_fields("String", "Double");
|
|
using data = std::tuple<std::string, double>;
|
|
std::vector<data> i;
|
|
|
|
CHECK(p.valid());
|
|
|
|
while (!p.eof()) {
|
|
try {
|
|
const auto& t = p.template get_next<data>();
|
|
if (p.valid()) {
|
|
i.push_back(t);
|
|
}
|
|
} catch (const ss::exception&) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
std::vector<data> expected = {{"line1", 2.34},
|
|
{"line3", 67.8},
|
|
{"line5", 9.10},
|
|
{"line6", 10.11}};
|
|
CHECK_EQ(i, expected);
|
|
CHECK_EQ_ARRAY(header, p.header());
|
|
CHECK_EQ(merge_header(p.header()), p.raw_header());
|
|
}
|
|
}
|