ado/ssp
1
1
Fork 0
mirror of https://github.com/red0124/ssp.git synced 2025-01-23 13:05:20 +01:00
Code Issues Packages Projects Releases Wiki Activity

Update the remainder of the unit tests to handle throw_on_error, make parser not set error if all lines are empty

Browse Source
This commit is contained in:
ado 2023-08-05 19:58:00 +02:00
parent 2e1c4c97ec
commit 7d44d503d9
2 changed files with 63 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/ss/parser.hpp
View File

@ -38,10 +38,6 @@ public:
: file_name_{file_name}, reader_{file_name_, delim} { : file_name_{file_name}, reader_{file_name_, delim} {
if (reader_.file_) { if (reader_.file_) {
read_line(); read_line();
if (eof_) {
handle_error_eof_reached();
return;
}
if constexpr (ignore_header) { if constexpr (ignore_header) {
ignore_next(); ignore_next();
} else { } else {

118
test/test_parser.cpp
View File

@ -9,9 +9,6 @@
#include <unordered_map> #include <unordered_map>
#include <unordered_set> #include <unordered_set>
// TODO remove
#include <iostream>
namespace { namespace {
[[maybe_unused]] void replace_all(std::string& s, const std::string& from, [[maybe_unused]] void replace_all(std::string& s, const std::string& from,
const std::string& to) { const std::string& to) {
@ -51,13 +48,13 @@ void update_if_crlf(std::string& s) {
struct X { struct X {
constexpr static auto delim = ","; constexpr static auto delim = ",";
constexpr static auto make_empty = "_EMPTY_"; constexpr static auto empty = "_EMPTY_";
int i; int i;
double d; double d;
std::string s; std::string s;
std::string to_string() const { std::string to_string() const {
if (s == make_empty) { if (s == empty) {
return ""; return "";
} }
@ -1050,17 +1047,18 @@ static inline void check_size(size_t size1, size_t size2) {
CHECK_EQ(size1, size2); CHECK_EQ(size1, size2);
} }
template <typename... Ts> template <typename Setup, typename... Ts>
static void test_fields(const std::string file_name, const std::vector<X>& data, static void test_fields_impl(const std::string file_name,
const std::vector<std::string>& fields) { const std::vector<X>& data,
const std::vector<std::string>& fields) {
using CaseType = std::tuple<Ts...>; using CaseType = std::tuple<Ts...>;
ss::parser p{file_name, ","}; ss::parser<Setup> p{file_name, ","};
CHECK_FALSE(p.field_exists("Unknown")); CHECK_FALSE(p.field_exists("Unknown"));
p.use_fields(fields); p.use_fields(fields);
std::vector<CaseType> i; std::vector<CaseType> i;
for (const auto& a : p.iterate<CaseType>()) { for (const auto& a : p.template iterate<CaseType>()) {
i.push_back(a); i.push_back(a);
} }
@ -1078,6 +1076,16 @@ static void test_fields(const std::string file_name, const std::vector<X>& data,
} }
} }
template <typename... Ts>
static void test_fields(const std::string file_name, const std::vector<X>& data,
const std::vector<std::string>& fields) {
test_fields_impl<ss::setup<>, Ts...>(file_name, data, fields);
test_fields_impl<ss::setup<ss::string_error>, Ts...>(file_name, data,
fields);
test_fields_impl<ss::setup<ss::throw_on_error>, Ts...>(file_name, data,
fields);
}
TEST_CASE("parser test various cases with header") { TEST_CASE("parser test various cases with header") {
unique_file_name f{"test_parser"}; unique_file_name f{"test_parser"};
constexpr static auto Int = "Int"; constexpr static auto Int = "Int";
@ -1280,22 +1288,23 @@ TEST_CASE("parser test invalid header fields usage") {
{"Int", "String", "Double"}); {"Int", "String", "Double"});
} }
static inline void test_ignore_empty(const std::vector<X>& data) { template <typename... Ts>
void test_ignore_empty_impl(const std::vector<X>& data) {
unique_file_name f{"test_parser"}; unique_file_name f{"test_parser"};
make_and_write(f.name, data); make_and_write(f.name, data);
std::vector<X> expected; std::vector<X> expected;
for (const auto& d : data) { for (const auto& d : data) {
if (d.s != X::make_empty) { if (d.s != X::empty) {
expected.push_back(d); expected.push_back(d);
} }
} }
{ {
ss::parser<ss::string_error, ss::ignore_empty> p{f.name, ","}; ss::parser<ss::ignore_empty, Ts...> p{f.name, ","};
std::vector<X> i; std::vector<X> i;
for (const auto& a : p.iterate<X>()) { for (const auto& a : p.template iterate<X>()) {
i.push_back(a); i.push_back(a);
} }
@ -1303,71 +1312,70 @@ static inline void test_ignore_empty(const std::vector<X>& data) {
} }
{ {
ss::parser<ss::string_error> p{f.name, ","}; ss::parser<Ts...> p{f.name, ","};
std::vector<X> i; std::vector<X> i;
size_t n = 0; size_t n = 0;
for (const auto& a : p.iterate<X>()) { while (!p.eof()) {
if (data.at(n).s == X::make_empty) { try {
CHECK_FALSE(p.valid()); ++n;
const auto& a = p.template get_next<X>();
if (data.at(n - 1).s == X::empty) {
CHECK_FALSE(p.valid());
continue;
}
i.push_back(a);
} catch (...) {
CHECK_EQ(data.at(n - 1).s, X::empty);
} }
i.push_back(a);
++n;
} }
if (data != expected) { CHECK_EQ(i, expected);
CHECK_NE(i, expected);
}
} }
} }
template <typename... Ts>
void test_ignore_empty(const std::vector<X>& data) {
test_ignore_empty_impl(data);
test_ignore_empty_impl<ss::string_error>(data);
test_ignore_empty_impl<ss::throw_on_error>(data);
}
TEST_CASE("parser test various cases with empty lines") { TEST_CASE("parser test various cases with empty lines") {
test_ignore_empty({{1, 2, "x"}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, "w"}}); test_ignore_empty({{1, 2, "x"}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, "w"}});
test_ignore_empty( test_ignore_empty(
{{1, 2, X::make_empty}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, "w"}}); {{1, 2, X::empty}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, "w"}});
test_ignore_empty( test_ignore_empty(
{{1, 2, "x"}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, X::make_empty}}); {{1, 2, "x"}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, X::empty}});
test_ignore_empty( test_ignore_empty(
{{1, 2, "x"}, {5, 6, X::make_empty}, {9, 10, "v"}, {11, 12, "w"}}); {{1, 2, "x"}, {5, 6, X::empty}, {9, 10, "v"}, {11, 12, "w"}});
test_ignore_empty({{1, 2, X::make_empty}, test_ignore_empty(
{5, 6, X::make_empty}, {{1, 2, X::empty}, {5, 6, X::empty}, {9, 10, "v"}, {11, 12, "w"}});
{9, 10, "v"},
{11, 12, "w"}});
test_ignore_empty({{1, 2, X::make_empty}, test_ignore_empty(
{3, 4, "y"}, {{1, 2, X::empty}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, X::empty}});
{9, 10, "v"},
{11, 12, X::make_empty}});
test_ignore_empty({{1, 2, "x"}, test_ignore_empty(
{3, 4, "y"}, {{1, 2, "x"}, {3, 4, "y"}, {9, 10, X::empty}, {11, 12, X::empty}});
{9, 10, X::make_empty},
{11, 12, X::make_empty}});
test_ignore_empty({{1, 2, X::make_empty}, test_ignore_empty(
{3, 4, "y"}, {{1, 2, X::empty}, {3, 4, "y"}, {9, 10, X::empty}, {11, 12, X::empty}});
{9, 10, X::make_empty},
{11, 12, X::make_empty}});
test_ignore_empty({{1, 2, X::make_empty}, test_ignore_empty({{1, 2, X::empty},
{3, 4, X::make_empty}, {3, 4, X::empty},
{9, 10, X::make_empty}, {9, 10, X::empty},
{11, 12, X::make_empty}}); {11, 12, X::empty}});
test_ignore_empty({{1, 2, "x"}, test_ignore_empty(
{3, 4, X::make_empty}, {{1, 2, "x"}, {3, 4, X::empty}, {9, 10, X::empty}, {11, 12, X::empty}});
{9, 10, X::make_empty},
{11, 12, X::make_empty}});
test_ignore_empty({{1, 2, X::make_empty}, test_ignore_empty(
{3, 4, X::make_empty}, {{1, 2, X::empty}, {3, 4, X::empty}, {9, 10, X::empty}, {11, 12, "w"}});
{9, 10, X::make_empty},
{11, 12, "w"}});
test_ignore_empty({{11, 12, X::make_empty}}); test_ignore_empty({{11, 12, X::empty}});
test_ignore_empty({}); test_ignore_empty({});
} }