mirror of
https://github.com/red0124/ssp.git
synced 2025-12-14 21:59:55 +01:00
update all unit tests, fix bug with unterminated escape, updated multiline parsing, refactored some code, removed unused code
This commit is contained in:
@@ -1,9 +1,9 @@
|
||||
test_sources = files([
|
||||
'test_main.cpp',
|
||||
#'test_splitter.cpp',
|
||||
#'test_converter.cpp',
|
||||
'test_splitter.cpp',
|
||||
'test_converter.cpp',
|
||||
'test_parser.cpp',
|
||||
#'test_extractions.cpp',
|
||||
'test_extractions.cpp',
|
||||
])
|
||||
|
||||
doctest_proj = subproject('doctest')
|
||||
|
||||
@@ -14,10 +14,10 @@ TEST_CASE("converter test split") {
|
||||
{"x", {"x"}, ","}} // clang-format on
|
||||
) {
|
||||
auto split = c.split(s, delim);
|
||||
CHECK(split.size() == expected.size());
|
||||
CHECK_EQ(split.size(), expected.size());
|
||||
for (size_t i = 0; i < split.size(); ++i) {
|
||||
auto s = std::string(split[i].first, split[i].second);
|
||||
CHECK(s == expected[i]);
|
||||
CHECK_EQ(s, expected[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -28,68 +28,68 @@ TEST_CASE("converter test valid conversions") {
|
||||
{
|
||||
auto tup = c.convert<int>("5");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == 5);
|
||||
CHECK_EQ(tup, 5);
|
||||
}
|
||||
{
|
||||
auto tup = c.convert<int, void>("5,junk");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == 5);
|
||||
CHECK_EQ(tup, 5);
|
||||
}
|
||||
{
|
||||
auto tup = c.convert<void, int>("junk,5");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == 5);
|
||||
CHECK_EQ(tup, 5);
|
||||
}
|
||||
{
|
||||
auto tup = c.convert<int, void, void>("5\njunk\njunk", "\n");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == 5);
|
||||
CHECK_EQ(tup, 5);
|
||||
}
|
||||
{
|
||||
auto tup = c.convert<void, int, void>("junk 5 junk", " ");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == 5);
|
||||
CHECK_EQ(tup, 5);
|
||||
}
|
||||
{
|
||||
auto tup = c.convert<void, void, int>("junk\tjunk\t5", "\t");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == 5);
|
||||
CHECK_EQ(tup, 5);
|
||||
}
|
||||
{
|
||||
auto tup =
|
||||
c.convert<void, void, std::optional<int>>("junk\tjunk\t5", "\t");
|
||||
REQUIRE(c.valid());
|
||||
REQUIRE(tup.has_value());
|
||||
CHECK(tup == 5);
|
||||
CHECK_EQ(tup, 5);
|
||||
}
|
||||
{
|
||||
auto tup = c.convert<int, double, void>("5,6.6,junk");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == std::make_tuple(5, 6.6));
|
||||
CHECK_EQ(tup, std::make_tuple(5, 6.6));
|
||||
}
|
||||
{
|
||||
auto tup = c.convert<int, void, double>("5,junk,6.6");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == std::make_tuple(5, 6.6));
|
||||
CHECK_EQ(tup, std::make_tuple(5, 6.6));
|
||||
}
|
||||
{
|
||||
auto tup = c.convert<void, int, double>("junk;5;6.6", ";");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == std::make_tuple(5, 6.6));
|
||||
CHECK_EQ(tup, std::make_tuple(5, 6.6));
|
||||
}
|
||||
{
|
||||
auto tup =
|
||||
c.convert<void, std::optional<int>, double>("junk;5;6.6", ";");
|
||||
REQUIRE(c.valid());
|
||||
REQUIRE(std::get<0>(tup).has_value());
|
||||
CHECK(tup == std::make_tuple(5, 6.6));
|
||||
CHECK_EQ(tup, std::make_tuple(5, 6.6));
|
||||
}
|
||||
{
|
||||
auto tup =
|
||||
c.convert<void, std::optional<int>, double>("junk;5.4;6.6", ";");
|
||||
REQUIRE(c.valid());
|
||||
REQUIRE(!std::get<0>(tup).has_value());
|
||||
CHECK(tup == std::make_tuple(std::optional<int>{}, 6.6));
|
||||
REQUIRE_FALSE(std::get<0>(tup).has_value());
|
||||
CHECK_EQ(tup, std::make_tuple(std::optional<int>{}, 6.6));
|
||||
}
|
||||
{
|
||||
auto tup =
|
||||
@@ -97,7 +97,7 @@ TEST_CASE("converter test valid conversions") {
|
||||
";");
|
||||
REQUIRE(c.valid());
|
||||
REQUIRE(std::holds_alternative<int>(std::get<0>(tup)));
|
||||
CHECK(tup == std::make_tuple(std::variant<int, double>{5}, 6.6));
|
||||
CHECK_EQ(tup, std::make_tuple(std::variant<int, double>{5}, 6.6));
|
||||
}
|
||||
{
|
||||
auto tup =
|
||||
@@ -105,7 +105,7 @@ TEST_CASE("converter test valid conversions") {
|
||||
";");
|
||||
REQUIRE(c.valid());
|
||||
REQUIRE(std::holds_alternative<double>(std::get<0>(tup)));
|
||||
CHECK(tup == std::make_tuple(std::variant<int, double>{5.5}, 6.6));
|
||||
CHECK_EQ(tup, std::make_tuple(std::variant<int, double>{5.5}, 6.6));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -113,64 +113,64 @@ TEST_CASE("converter test invalid conversions") {
|
||||
ss::converter c;
|
||||
|
||||
c.convert<int>("");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<int>("10", "");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<int, void>("");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<int, void>(",junk");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<void, int>("junk,");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<int>("x");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<int, void>("x");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<int, void>("x,junk");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<void, int>("junk,x");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<void, std::variant<int, double>, double>("junk;.5.5;6", ";");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
}
|
||||
|
||||
TEST_CASE("converter test ss:ax restriction (all except)") {
|
||||
ss::converter c;
|
||||
|
||||
c.convert<ss::ax<int, 0>>("0");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<ss::ax<int, 0, 1, 2>>("1");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<void, char, ss::ax<int, 0, 1, 2>>("junk,c,1");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<ss::ax<int, 1>, char>("1,c");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
{
|
||||
int tup = c.convert<ss::ax<int, 1>>("3");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == 3);
|
||||
CHECK_EQ(tup, 3);
|
||||
}
|
||||
{
|
||||
std::tuple<char, int> tup = c.convert<char, ss::ax<int, 1>>("c,3");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == std::make_tuple('c', 3));
|
||||
CHECK_EQ(tup, std::make_tuple('c', 3));
|
||||
}
|
||||
{
|
||||
std::tuple<int, char> tup = c.convert<ss::ax<int, 1>, char>("3,c");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == std::make_tuple(3, 'c'));
|
||||
CHECK_EQ(tup, std::make_tuple(3, 'c'));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -178,33 +178,33 @@ TEST_CASE("converter test ss:nx restriction (none except)") {
|
||||
ss::converter c;
|
||||
|
||||
c.convert<ss::nx<int, 1>>("3");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<char, ss::nx<int, 1, 2, 69>>("c,3");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<ss::nx<int, 1>, char>("3,c");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
{
|
||||
auto tup = c.convert<ss::nx<int, 3>>("3");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == 3);
|
||||
CHECK_EQ(tup, 3);
|
||||
}
|
||||
{
|
||||
auto tup = c.convert<ss::nx<int, 0, 1, 2>>("2");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == 2);
|
||||
CHECK_EQ(tup, 2);
|
||||
}
|
||||
{
|
||||
auto tup = c.convert<char, void, ss::nx<int, 0, 1, 2>>("c,junk,1");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == std::make_tuple('c', 1));
|
||||
CHECK_EQ(tup, std::make_tuple('c', 1));
|
||||
}
|
||||
{
|
||||
auto tup = c.convert<ss::nx<int, 1>, char>("1,c");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == std::make_tuple(1, 'c'));
|
||||
CHECK_EQ(tup, std::make_tuple(1, 'c'));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -212,33 +212,33 @@ TEST_CASE("converter test ss:ir restriction (in range)") {
|
||||
ss::converter c;
|
||||
|
||||
c.convert<ss::ir<int, 0, 2>>("3");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<char, ss::ir<int, 4, 69>>("c,3");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<ss::ir<int, 1, 2>, char>("3,c");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
{
|
||||
auto tup = c.convert<ss::ir<int, 1, 5>>("3");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == 3);
|
||||
CHECK_EQ(tup, 3);
|
||||
}
|
||||
{
|
||||
auto tup = c.convert<ss::ir<int, 0, 2>>("2");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == 2);
|
||||
CHECK_EQ(tup, 2);
|
||||
}
|
||||
{
|
||||
auto tup = c.convert<char, void, ss::ir<int, 0, 1>>("c,junk,1");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == std::make_tuple('c', 1));
|
||||
CHECK_EQ(tup, std::make_tuple('c', 1));
|
||||
}
|
||||
{
|
||||
auto tup = c.convert<ss::ir<int, 1, 20>, char>("1,c");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == std::make_tuple(1, 'c'));
|
||||
CHECK_EQ(tup, std::make_tuple(1, 'c'));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -246,33 +246,33 @@ TEST_CASE("converter test ss:oor restriction (out of range)") {
|
||||
ss::converter c;
|
||||
|
||||
c.convert<ss::oor<int, 1, 5>>("3");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<ss::oor<int, 0, 2>>("2");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<char, ss::oor<int, 0, 1>, void>("c,1,junk");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<ss::oor<int, 1, 20>, char>("1,c");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
{
|
||||
auto tup = c.convert<ss::oor<int, 0, 2>>("3");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == 3);
|
||||
CHECK_EQ(tup, 3);
|
||||
}
|
||||
|
||||
{
|
||||
auto tup = c.convert<char, void, ss::oor<int, 4, 69>>("c,junk,3");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == std::make_tuple('c', 3));
|
||||
CHECK_EQ(tup, std::make_tuple('c', 3));
|
||||
}
|
||||
|
||||
{
|
||||
auto tup = c.convert<ss::oor<int, 1, 2>, char>("3,c");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == std::make_tuple(3, 'c'));
|
||||
CHECK_EQ(tup, std::make_tuple(3, 'c'));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -293,34 +293,34 @@ TEST_CASE("converter test ss:ne restriction (not empty)") {
|
||||
ss::converter c;
|
||||
|
||||
c.convert<ss::ne<std::string>>("");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<int, ss::ne<std::string>>("3,");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<ss::ne<std::string>, int>(",3");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<void, ss::ne<std::string>, int>("junk,,3");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<ss::ne<std::vector<int>>>("");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
{
|
||||
auto tup = c.convert<ss::ne<std::string>>("s");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == "s");
|
||||
CHECK_EQ(tup, "s");
|
||||
}
|
||||
{
|
||||
auto tup = c.convert<std::optional<int>, ss::ne<std::string>>("1,s");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == std::make_tuple(1, "s"));
|
||||
CHECK_EQ(tup, std::make_tuple(1, "s"));
|
||||
}
|
||||
{
|
||||
auto tup = c.convert<ss::ne<std::vector<int>>>("{1 2 3}");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == extracted_vector);
|
||||
CHECK_EQ(tup, extracted_vector);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -329,65 +329,65 @@ TEST_CASE(
|
||||
ss::converter c;
|
||||
|
||||
c.convert<ss::lt<int, 3>>("3");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<ss::lt<int, 2>>("3");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<ss::gt<int, 3>>("3");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<ss::gt<int, 4>>("3");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<ss::lte<int, 2>>("3");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
c.convert<ss::gte<int, 4>>("3");
|
||||
REQUIRE(!c.valid());
|
||||
REQUIRE_FALSE(c.valid());
|
||||
|
||||
{
|
||||
auto tup = c.convert<ss::lt<int, 4>>("3");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == 3);
|
||||
CHECK_EQ(tup, 3);
|
||||
}
|
||||
|
||||
{
|
||||
auto tup = c.convert<ss::gt<int, 2>>("3");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == 3);
|
||||
CHECK_EQ(tup, 3);
|
||||
}
|
||||
|
||||
{
|
||||
auto tup = c.convert<ss::lte<int, 4>>("3");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == 3);
|
||||
CHECK_EQ(tup, 3);
|
||||
}
|
||||
|
||||
{
|
||||
auto tup = c.convert<ss::lte<int, 3>>("3");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == 3);
|
||||
CHECK_EQ(tup, 3);
|
||||
}
|
||||
|
||||
{
|
||||
auto tup = c.convert<ss::gte<int, 2>>("3");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == 3);
|
||||
CHECK_EQ(tup, 3);
|
||||
}
|
||||
|
||||
{
|
||||
auto tup = c.convert<ss::gte<int, 3>>("3");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == 3);
|
||||
CHECK_EQ(tup, 3);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("converter test error mode") {
|
||||
ss::converter<ss::string_error> c;
|
||||
c.convert<int>("junk");
|
||||
CHECK(!c.valid());
|
||||
CHECK(!c.error_msg().empty());
|
||||
CHECK_FALSE(c.valid());
|
||||
CHECK_FALSE(c.error_msg().empty());
|
||||
}
|
||||
|
||||
TEST_CASE("converter test converter with quotes spacing and escaping") {
|
||||
@@ -397,7 +397,7 @@ TEST_CASE("converter test converter with quotes spacing and escaping") {
|
||||
auto tup = c.convert<std::string, std::string, std::string>(
|
||||
R"("just","some","strings")");
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == std::make_tuple("\"just\"", "\"some\"", "\"strings\""));
|
||||
CHECK_EQ(tup, std::make_tuple("\"just\"", "\"some\"", "\"strings\""));
|
||||
}
|
||||
|
||||
{
|
||||
@@ -406,7 +406,7 @@ TEST_CASE("converter test converter with quotes spacing and escaping") {
|
||||
auto tup = c.convert<std::string, std::string, double, char>(
|
||||
buff(R"("just",some,"12.3","a")"));
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == std::make_tuple("just", "some", 12.3, 'a'));
|
||||
CHECK_EQ(tup, std::make_tuple("just", "some", 12.3, 'a'));
|
||||
}
|
||||
|
||||
{
|
||||
@@ -415,7 +415,7 @@ TEST_CASE("converter test converter with quotes spacing and escaping") {
|
||||
auto tup = c.convert<std::string, std::string, double, char>(
|
||||
buff(R"( just , some , 12.3 ,a )"));
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == std::make_tuple("just", "some", 12.3, 'a'));
|
||||
CHECK_EQ(tup, std::make_tuple("just", "some", 12.3, 'a'));
|
||||
}
|
||||
|
||||
{
|
||||
@@ -424,7 +424,7 @@ TEST_CASE("converter test converter with quotes spacing and escaping") {
|
||||
auto tup =
|
||||
c.convert<std::string, std::string>(buff(R"(ju\,st,strings)"));
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == std::make_tuple("ju,st", "strings"));
|
||||
CHECK_EQ(tup, std::make_tuple("ju,st", "strings"));
|
||||
}
|
||||
|
||||
{
|
||||
@@ -433,7 +433,7 @@ TEST_CASE("converter test converter with quotes spacing and escaping") {
|
||||
auto tup = c.convert<std::string, std::string, double, std::string>(
|
||||
buff(R"( ju\,st , "so,me" , 12.34 , "str""ings")"));
|
||||
REQUIRE(c.valid());
|
||||
CHECK(tup == std::make_tuple("ju,st", "so,me", 12.34, "str\"ings"));
|
||||
CHECK_EQ(tup, std::make_tuple("ju,st", "so,me", 12.34, "str\"ings"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -446,17 +446,44 @@ TEST_CASE("converter test invalid split conversions") {
|
||||
// mismatched quote
|
||||
auto tup = c.convert<std::string, std::string, double, char>(
|
||||
buff(R"( "just , some , "12.3","a" )"));
|
||||
CHECK(!c.valid());
|
||||
CHECK(!c.unterminated_quote());
|
||||
CHECK(!c.error_msg().empty());
|
||||
CHECK_FALSE(c.valid());
|
||||
CHECK_FALSE(c.unterminated_quote());
|
||||
CHECK_FALSE(c.error_msg().empty());
|
||||
}
|
||||
|
||||
{
|
||||
// unterminated quote
|
||||
auto tup = c.convert<std::string, std::string, double, std::string>(
|
||||
buff(R"( ju\,st , "so,me" , 12.34 , "str""ings)"));
|
||||
CHECK(!c.valid());
|
||||
CHECK_FALSE(c.valid());
|
||||
CHECK(c.unterminated_quote());
|
||||
CHECK(!c.error_msg().empty());
|
||||
CHECK_FALSE(c.error_msg().empty());
|
||||
}
|
||||
|
||||
{
|
||||
// unterminated escape
|
||||
auto tup = c.convert<std::string, std::string, double, std::string>(
|
||||
buff(R"(just,some,2,strings\)"));
|
||||
CHECK_FALSE(c.valid());
|
||||
CHECK_FALSE(c.unterminated_quote());
|
||||
CHECK_FALSE(c.error_msg().empty());
|
||||
}
|
||||
|
||||
{
|
||||
// unterminated escape while quoting
|
||||
auto tup = c.convert<std::string, std::string, double, std::string>(
|
||||
buff(R"(just,some,2,"strings\)"));
|
||||
CHECK_FALSE(c.valid());
|
||||
CHECK_FALSE(c.unterminated_quote());
|
||||
CHECK_FALSE(c.error_msg().empty());
|
||||
}
|
||||
|
||||
{
|
||||
// unterminated escaped quote
|
||||
auto tup = c.convert<std::string, std::string, double, std::string>(
|
||||
buff(R"(just,some,2,"strings\")"));
|
||||
CHECK_FALSE(c.valid());
|
||||
CHECK(c.unterminated_quote());
|
||||
CHECK_FALSE(c.error_msg().empty());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,7 +8,7 @@
|
||||
std::string s = #input; \
|
||||
auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size()); \
|
||||
REQUIRE(t.has_value()); \
|
||||
CHECK(std::abs(t.value() - type(input)) < eps); \
|
||||
CHECK_LT(std::abs(t.value() - type(input)), eps); \
|
||||
} \
|
||||
{ \
|
||||
/* check negative too */ \
|
||||
@@ -16,7 +16,7 @@
|
||||
auto s = std::string("-") + #input; \
|
||||
auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size()); \
|
||||
REQUIRE(t.has_value()); \
|
||||
CHECK(std::abs(t.value() - type(-input)) < eps); \
|
||||
CHECK_LT(std::abs(t.value() - type(-input)), eps); \
|
||||
}
|
||||
|
||||
TEST_CASE("testing extract functions for floating point values") {
|
||||
@@ -41,7 +41,7 @@ TEST_CASE("testing extract functions for floating point values") {
|
||||
std::string s = #input; \
|
||||
auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size()); \
|
||||
REQUIRE(t.has_value()); \
|
||||
CHECK(t.value() == type(input)); \
|
||||
CHECK_EQ(t.value(), type(input)); \
|
||||
} \
|
||||
{ \
|
||||
/* check negative too */ \
|
||||
@@ -49,7 +49,7 @@ TEST_CASE("testing extract functions for floating point values") {
|
||||
auto s = std::string("-") + #input; \
|
||||
auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size()); \
|
||||
REQUIRE(t.has_value()); \
|
||||
CHECK(t.value() == type(-input)); \
|
||||
CHECK_EQ(t.value(), type(-input)); \
|
||||
} \
|
||||
}
|
||||
|
||||
@@ -74,7 +74,7 @@ TEST_CASE("extract test functions for decimal values") {
|
||||
{ \
|
||||
std::string s = input; \
|
||||
auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size()); \
|
||||
CHECK(!t.has_value()); \
|
||||
CHECK_FALSE(t.has_value()); \
|
||||
}
|
||||
|
||||
TEST_CASE("extract test functions for numbers with invalid inputs") {
|
||||
@@ -106,7 +106,7 @@ TEST_CASE("extract test functions for numbers with invalid inputs") {
|
||||
} \
|
||||
} \
|
||||
t = ss::to_num<type>(s.c_str(), s.c_str() + s.size()); \
|
||||
CHECK(!t.has_value()); \
|
||||
CHECK_FALSE(t.has_value()); \
|
||||
} \
|
||||
{ \
|
||||
std::string s = std::to_string(std::numeric_limits<type>::min()); \
|
||||
@@ -122,7 +122,7 @@ TEST_CASE("extract test functions for numbers with invalid inputs") {
|
||||
} \
|
||||
} \
|
||||
t = ss::to_num<type>(s.c_str(), s.c_str() + s.size()); \
|
||||
CHECK(!t.has_value()); \
|
||||
CHECK_FALSE(t.has_value()); \
|
||||
}
|
||||
|
||||
TEST_CASE("extract test functions for numbers with out of range inputs") {
|
||||
@@ -143,12 +143,12 @@ TEST_CASE("extract test functions for boolean values") {
|
||||
{false, "false"}}) {
|
||||
bool v;
|
||||
REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
|
||||
CHECK(v == b);
|
||||
CHECK_EQ(v, b);
|
||||
}
|
||||
|
||||
for (const std::string& s : {"2", "tru", "truee", "xxx", ""}) {
|
||||
bool v;
|
||||
REQUIRE(!ss::extract(s.c_str(), s.c_str() + s.size(), v));
|
||||
CHECK_FALSE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -157,12 +157,12 @@ TEST_CASE("extract test functions for char values") {
|
||||
{std::pair<char, std::string>{'a', "a"}, {'x', "x"}, {' ', " "}}) {
|
||||
char v;
|
||||
REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
|
||||
CHECK(v == c);
|
||||
CHECK_EQ(v, c);
|
||||
}
|
||||
|
||||
for (const std::string& s : {"aa", "xxx", ""}) {
|
||||
char v;
|
||||
REQUIRE(!ss::extract(s.c_str(), s.c_str() + s.size(), v));
|
||||
CHECK_FALSE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -174,7 +174,7 @@ TEST_CASE("extract test functions for std::optional") {
|
||||
std::optional<int> v;
|
||||
REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
|
||||
REQUIRE(v.has_value());
|
||||
CHECK(*v == i);
|
||||
CHECK_EQ(*v, i);
|
||||
}
|
||||
|
||||
for (const auto& [c, s] :
|
||||
@@ -184,19 +184,19 @@ TEST_CASE("extract test functions for std::optional") {
|
||||
std::optional<char> v;
|
||||
REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
|
||||
REQUIRE(v.has_value());
|
||||
CHECK(*v == c);
|
||||
CHECK_EQ(*v, c);
|
||||
}
|
||||
|
||||
for (const std::string& s : {"aa", "xxx", ""}) {
|
||||
std::optional<int> v;
|
||||
REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
|
||||
REQUIRE(!v.has_value());
|
||||
CHECK_FALSE(v.has_value());
|
||||
}
|
||||
|
||||
for (const std::string& s : {"aa", "xxx", ""}) {
|
||||
std::optional<char> v;
|
||||
REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
|
||||
REQUIRE(!v.has_value());
|
||||
CHECK_FALSE(v.has_value());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -204,7 +204,7 @@ TEST_CASE("extract test functions for std::optional") {
|
||||
{ \
|
||||
auto ptr = std::get_if<type>(&var); \
|
||||
REQUIRE(ptr); \
|
||||
REQUIRE(el == *ptr); \
|
||||
REQUIRE_EQ(el, *ptr); \
|
||||
}
|
||||
|
||||
#define CHECK_NOT_VARIANT(var, type) CHECK(!std::holds_alternative<type>(var));
|
||||
@@ -288,21 +288,21 @@ TEST_CASE("extract test functions for std::variant") {
|
||||
}
|
||||
{
|
||||
std::variant<int, double> var;
|
||||
REQUIRE(!ss::extract(s.c_str(), s.c_str() + s.size(), var));
|
||||
REQUIRE_FALSE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
|
||||
|
||||
REQUIRE_VARIANT(var, int{}, int);
|
||||
CHECK_NOT_VARIANT(var, double);
|
||||
}
|
||||
{
|
||||
std::variant<double, int> var;
|
||||
REQUIRE(!ss::extract(s.c_str(), s.c_str() + s.size(), var));
|
||||
REQUIRE_FALSE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
|
||||
|
||||
REQUIRE_VARIANT(var, double{}, double);
|
||||
CHECK_NOT_VARIANT(var, int);
|
||||
}
|
||||
{
|
||||
std::variant<int> var;
|
||||
REQUIRE(!ss::extract(s.c_str(), s.c_str() + s.size(), var));
|
||||
REQUIRE_FALSE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
|
||||
|
||||
REQUIRE_VARIANT(var, int{}, int);
|
||||
}
|
||||
|
||||
@@ -33,6 +33,11 @@ struct buffer {
|
||||
}
|
||||
}
|
||||
|
||||
char* append_overwrite_last(const char* data, size_t size) {
|
||||
data_[strlen(data_) - size] = '\0';
|
||||
return append(data);
|
||||
}
|
||||
|
||||
~buffer() {
|
||||
if (data_) {
|
||||
delete[] data_;
|
||||
|
||||
@@ -72,6 +72,7 @@ TEST_CASE("parser test various cases") {
|
||||
{
|
||||
ss::parser p{f.name, ","};
|
||||
std::vector<X> i;
|
||||
std::vector<X> expected = {std::begin(data) + 1, std::end(data)};
|
||||
|
||||
p.ignore_next();
|
||||
while (!p.eof()) {
|
||||
@@ -80,7 +81,7 @@ TEST_CASE("parser test various cases") {
|
||||
i.emplace_back(ss::to_object<X>(a));
|
||||
}
|
||||
|
||||
CHECK_EQ(i, data);
|
||||
CHECK_EQ(i, expected);
|
||||
}
|
||||
|
||||
{
|
||||
@@ -129,10 +130,17 @@ TEST_CASE("parser test various cases") {
|
||||
i.push_back(a);
|
||||
}
|
||||
}
|
||||
std::vector<X> expected = data;
|
||||
std::remove_if(expected.begin(), expected.end(),
|
||||
[](const X& x) { return x.i == excluded; });
|
||||
CHECK_EQ(i, data);
|
||||
|
||||
std::vector<X> expected;
|
||||
for (auto& x : data) {
|
||||
if (x.i != excluded) {
|
||||
expected.push_back(x);
|
||||
}
|
||||
}
|
||||
|
||||
std::copy_if(data.begin(), data.end(), expected.begin(),
|
||||
[](const X& x) { return x.i != excluded; });
|
||||
CHECK_EQ(i, expected);
|
||||
}
|
||||
|
||||
{
|
||||
@@ -146,7 +154,7 @@ TEST_CASE("parser test various cases") {
|
||||
}
|
||||
}
|
||||
std::vector<X> expected = {{3, 4, "y"}};
|
||||
CHECK_EQ(i, data);
|
||||
CHECK_EQ(i, expected);
|
||||
}
|
||||
|
||||
{
|
||||
@@ -203,7 +211,7 @@ TEST_CASE("parser test composite conversion") {
|
||||
p.try_next<int, int, double>(fail)
|
||||
.or_else<test_struct>(fail)
|
||||
.or_else<int, char, double>(
|
||||
[](auto&& data) { CHECK(data == expectedData); })
|
||||
[](auto&& data) { CHECK_EQ(data, expectedData); })
|
||||
.on_error(fail)
|
||||
.or_else<test_tuple>(fail)
|
||||
.values();
|
||||
@@ -222,7 +230,7 @@ TEST_CASE("parser test composite conversion") {
|
||||
|
||||
auto [d1, d2, d3, d4] =
|
||||
p.try_next<int, int, double>([](auto& i1, auto i2, double d) {
|
||||
CHECK(std::tie(i1, i2, d) == expectedData);
|
||||
CHECK_EQ(std::tie(i1, i2, d), expectedData);
|
||||
})
|
||||
.on_error(fail)
|
||||
.or_object<test_struct, int, double, char>(fail)
|
||||
@@ -237,7 +245,7 @@ TEST_CASE("parser test composite conversion") {
|
||||
REQUIRE_FALSE(d2);
|
||||
REQUIRE_FALSE(d3);
|
||||
REQUIRE_FALSE(d4);
|
||||
CHECK_EQ(*d1 ,expectedData);
|
||||
CHECK_EQ(*d1, expectedData);
|
||||
}
|
||||
|
||||
{
|
||||
@@ -265,7 +273,7 @@ TEST_CASE("parser test composite conversion") {
|
||||
|
||||
auto [d1, d2] =
|
||||
p.try_next<int, double>([](auto& i, auto& d) {
|
||||
REQUIRE(std::tie(i, d) == std::tuple{10, 11.1});
|
||||
REQUIRE_EQ(std::tie(i, d), std::tuple{10, 11.1});
|
||||
})
|
||||
.or_else<int, double>([](auto&, auto&) { FAIL(""); })
|
||||
.values();
|
||||
@@ -551,7 +559,7 @@ std::string no_escape(std::string& s) {
|
||||
return s;
|
||||
}
|
||||
|
||||
TEST_CASE("parser test csv on multiple lines with escapes xxx") {
|
||||
TEST_CASE("parser test csv on multiple lines with escapes") {
|
||||
unique_file_name f;
|
||||
std::vector<X> data = {{1, 2, "x\\\nx\\\nx"}, {5, 6, "z\\\nz\\\nz"},
|
||||
{7, 8, "u"}, {3, 4, "y\\\ny\\\ny"},
|
||||
@@ -571,7 +579,6 @@ TEST_CASE("parser test csv on multiple lines with escapes xxx") {
|
||||
while (!p.eof()) {
|
||||
auto a = p.get_next<int, double, std::string>();
|
||||
i.emplace_back(ss::to_object<X>(a));
|
||||
// std::cout << i.back().s << std::endl;
|
||||
}
|
||||
|
||||
CHECK_EQ(i, data);
|
||||
@@ -583,15 +590,15 @@ TEST_CASE("parser test csv on multiple lines with escapes xxx") {
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("parser test csv on multiple lines with quotes and escapes yyy") {
|
||||
TEST_CASE("parser test csv on multiple lines with quotes and escapes") {
|
||||
unique_file_name f;
|
||||
{
|
||||
std::ofstream out{f.name};
|
||||
// out << "1,2,\"just\\\n\nstrings\"" << std::endl;
|
||||
out << "3,4,\"j\\\ns\n\\\nx\\\ny\ng\"" << std::endl;
|
||||
// out << "5,6,\"just\\\n\\\n\n\nstrings" << std::endl;
|
||||
// out << "7,8,\"just strings\"" << std::endl;
|
||||
// out << "9,10,just strings" << std::endl;
|
||||
out << "1,2,\"just\\\n\nstrings\"" << std::endl;
|
||||
out << "3,4,\"just\nsome\\\n\n\\\nstrings\"" << std::endl;
|
||||
out << "5,6,\"just\\\n\\\n\n\nstrings" << std::endl;
|
||||
out << "7,8,\"just strings\"" << std::endl;
|
||||
out << "9,10,just strings" << std::endl;
|
||||
}
|
||||
|
||||
ss::parser<ss::multiline, ss::escape<'\\'>, ss::quote<'"'>> p{f.name};
|
||||
@@ -611,28 +618,26 @@ TEST_CASE("parser test csv on multiple lines with quotes and escapes yyy") {
|
||||
CHECK_EQ(i, data);
|
||||
}
|
||||
|
||||
/*
|
||||
TEST_CASE("parser test multiline restricted") {
|
||||
unique_file_name f;
|
||||
{
|
||||
std::ofstream out{f.name};
|
||||
//out << "1,2,\"just\n\nstrings\"" << std::endl;
|
||||
//out << "3,4,\"ju\n\n\nnk\"" << std::endl;
|
||||
//out << "5,6,just\\\n\\\nstrings" << std::endl;
|
||||
//out << "7,8,ju\\\n\\\n\\\nnk" << std::endl;
|
||||
//out << "9,10,\"just\\\n\nstrings\"" << std::endl;
|
||||
out << "1,2,\"just\n\nstrings\"" << std::endl;
|
||||
out << "3,4,\"ju\n\n\nnk\"" << std::endl;
|
||||
out << "5,6,just\\\n\\\nstrings" << std::endl;
|
||||
out << "7,8,ju\\\n\\\n\\\nnk" << std::endl;
|
||||
out << "9,10,\"just\\\n\nstrings\"" << std::endl;
|
||||
out << "11,12,\"ju\\\n|\n\n\n\n\nk\"" << std::endl;
|
||||
// out << "13,14,\"ju\\\n\\\n15,16\"\\\n\\\\\n\nnk\"" << std::endl;
|
||||
// out << "17,18,\"ju\\\n\\\n\\\n\\\\\n\nnk\"" << std::endl;
|
||||
out << "13,14,\"ju\\\n\\\n15,16\"\\\n\\\\\n\nnk\"" << std::endl;
|
||||
out << "17,18,\"ju\\\n\\\n\\\n\\\\\n\nnk\"" << std::endl;
|
||||
out << "19,20,just strings" << std::endl;
|
||||
}
|
||||
|
||||
ss::parser<ss::multiline_restricted<120>, ss::quote<'"'>, ss::escape<'\\'>>
|
||||
ss::parser<ss::multiline_restricted<2>, ss::quote<'"'>, ss::escape<'\\'>>
|
||||
p{f.name, ","};
|
||||
std::vector<X> i;
|
||||
|
||||
while (!p.eof()) {
|
||||
std::cout << "==========================" << std::endl;
|
||||
auto a = p.get_next<int, double, std::string>();
|
||||
if (p.valid()) {
|
||||
i.emplace_back(ss::to_object<X>(a));
|
||||
@@ -643,6 +648,5 @@ TEST_CASE("parser test multiline restricted") {
|
||||
{5, 6, "just\n\nstrings"},
|
||||
{9, 10, "just\n\nstrings"},
|
||||
{19, 20, "just strings"}};
|
||||
CHECK(std::equal(i.begin(), i.end(), data.begin()));
|
||||
CHECK_EQ(i, data);
|
||||
}
|
||||
*/
|
||||
|
||||
@@ -193,7 +193,7 @@ void test_combinations(matches_type& matches, std::vector<std::string> delims) {
|
||||
for (size_t i = 0; i < lines.size(); ++i) {
|
||||
auto vec = s.split(buff(lines[i].c_str()), delim);
|
||||
CHECK(s.valid());
|
||||
CHECK(words(vec) == expectations[i]);
|
||||
CHECK_EQ(words(vec), expectations[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -506,25 +506,25 @@ TEST_CASE("splitter test error mode") {
|
||||
// empty delimiter
|
||||
ss::splitter<ss::string_error> s;
|
||||
s.split(buff("just,some,strings"), "");
|
||||
CHECK(!s.valid());
|
||||
CHECK(!s.unterminated_quote());
|
||||
CHECK(!s.error_msg().empty());
|
||||
CHECK_FALSE(s.valid());
|
||||
CHECK_FALSE(s.unterminated_quote());
|
||||
CHECK_FALSE(s.error_msg().empty());
|
||||
}
|
||||
|
||||
{
|
||||
// unterminated quote
|
||||
ss::splitter<ss::string_error, ss::quote<'"'>> s;
|
||||
s.split(buff("\"just"));
|
||||
CHECK(!s.valid());
|
||||
CHECK_FALSE(s.valid());
|
||||
CHECK(s.unterminated_quote());
|
||||
CHECK(!s.error_msg().empty());
|
||||
CHECK_FALSE(s.error_msg().empty());
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Splitter>
|
||||
auto expect_unterminated_quote(Splitter& s, const std::string& line) {
|
||||
auto vec = s.split(buff(line.c_str()));
|
||||
CHECK(!s.valid());
|
||||
CHECK_FALSE(s.valid());
|
||||
CHECK(s.unterminated_quote());
|
||||
return vec;
|
||||
}
|
||||
@@ -538,100 +538,135 @@ public:
|
||||
auto resplit(char* new_line, size_t new_line_size) {
|
||||
return splitter.resplit(new_line, new_line_size);
|
||||
}
|
||||
|
||||
size_t size_shifted() {
|
||||
return splitter.size_shifted();
|
||||
}
|
||||
};
|
||||
} /* ss */
|
||||
|
||||
TEST_CASE("splitter test resplit unterminated quote") {
|
||||
|
||||
{
|
||||
ss::converter<ss::quote<'"'>> c;
|
||||
ss::converter<ss::quote<'"'>, ss::multiline, ss::escape<'\\'>> c;
|
||||
auto& s = c.splitter;
|
||||
auto vec = expect_unterminated_quote(s, R"("x)");
|
||||
CHECK_EQ(vec.size(), 1);
|
||||
REQUIRE(s.unterminated_quote());
|
||||
|
||||
{
|
||||
auto new_line =
|
||||
buff.append_overwrite_last(R"(a\x)", c.size_shifted());
|
||||
|
||||
vec = c.resplit(new_line, strlen(new_line));
|
||||
CHECK(s.unterminated_quote());
|
||||
CHECK_EQ(vec.size(), 1);
|
||||
}
|
||||
|
||||
{
|
||||
auto new_line =
|
||||
buff.append_overwrite_last(R"(")", c.size_shifted());
|
||||
|
||||
vec = c.resplit(new_line, strlen(new_line));
|
||||
REQUIRE(s.valid());
|
||||
CHECK_FALSE(s.unterminated_quote());
|
||||
REQUIRE_EQ(vec.size(), 1);
|
||||
CHECK_EQ(words(vec)[0], "xax");
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
ss::converter<ss::quote<'"'>, ss::multiline> c;
|
||||
auto& s = c.splitter;
|
||||
auto vec = expect_unterminated_quote(s, "\"just");
|
||||
CHECK(vec.size() == 1);
|
||||
CHECK_EQ(vec.size(), 1);
|
||||
|
||||
auto new_line = buff.append(R"(",strings)");
|
||||
vec = c.resplit(new_line, strlen(new_line));
|
||||
CHECK(s.valid());
|
||||
CHECK(!s.unterminated_quote());
|
||||
CHECK_FALSE(s.unterminated_quote());
|
||||
std::vector<std::string> expected{"just", "strings"};
|
||||
CHECK(words(vec) == expected);
|
||||
CHECK_EQ(words(vec), expected);
|
||||
}
|
||||
|
||||
{
|
||||
ss::converter<ss::quote<'"'>> c;
|
||||
ss::converter<ss::quote<'"'>, ss::multiline> c;
|
||||
auto& s = c.splitter;
|
||||
auto vec = expect_unterminated_quote(s, "just,some,\"random");
|
||||
std::vector<std::string> expected{"just", "some", "just,some,\""};
|
||||
CHECK(words(vec) == expected);
|
||||
CHECK_EQ(words(vec), expected);
|
||||
|
||||
auto new_line = buff.append(R"(",strings)");
|
||||
vec = c.resplit(new_line, strlen(new_line));
|
||||
CHECK(s.valid());
|
||||
CHECK(!s.unterminated_quote());
|
||||
CHECK_FALSE(s.unterminated_quote());
|
||||
expected = {"just", "some", "random", "strings"};
|
||||
CHECK(words(vec) == expected);
|
||||
CHECK_EQ(words(vec), expected);
|
||||
}
|
||||
|
||||
{
|
||||
ss::converter<ss::quote<'"'>> c;
|
||||
ss::converter<ss::quote<'"'>, ss::multiline> c;
|
||||
auto& s = c.splitter;
|
||||
auto vec = expect_unterminated_quote(s, R"("just","some","ran"")");
|
||||
std::vector<std::string> expected{"just", "some", R"("just","some",")"};
|
||||
CHECK(words(vec) == expected);
|
||||
CHECK_EQ(words(vec), expected);
|
||||
|
||||
buff.data_[strlen(buff.data_) - c.splitter.escaped_] = '\0';
|
||||
auto new_line = buff.append(R"(,dom","strings")");
|
||||
auto new_line =
|
||||
buff.append_overwrite_last(R"(,dom","strings")", c.size_shifted());
|
||||
vec = c.resplit(new_line, strlen(new_line));
|
||||
CHECK(s.valid());
|
||||
CHECK(!s.unterminated_quote());
|
||||
CHECK_FALSE(s.unterminated_quote());
|
||||
expected = {"just", "some", "ran\",dom", "strings"};
|
||||
CHECK(words(vec) == expected);
|
||||
CHECK_EQ(words(vec), expected);
|
||||
}
|
||||
|
||||
{
|
||||
ss::converter<ss::quote<'"'>> c;
|
||||
ss::converter<ss::quote<'"'>, ss::multiline> c;
|
||||
auto& s = c.splitter;
|
||||
auto vec = expect_unterminated_quote(s, R"("just","some","ran)");
|
||||
std::vector<std::string> expected{"just", "some", R"("just","some",")"};
|
||||
CHECK(words(vec) == expected);
|
||||
CHECK_EQ(words(vec), expected);
|
||||
REQUIRE(s.unterminated_quote());
|
||||
|
||||
{
|
||||
auto new_line = buff.append(R"(,dom)");
|
||||
vec = c.resplit(new_line, strlen(new_line));
|
||||
CHECK(!s.valid());
|
||||
CHECK_FALSE(s.valid());
|
||||
CHECK(s.unterminated_quote());
|
||||
CHECK(words(vec) == expected);
|
||||
CHECK_EQ(words(vec), expected);
|
||||
}
|
||||
|
||||
{
|
||||
auto new_line = buff.append(R"(",strings)");
|
||||
vec = c.resplit(new_line, strlen(new_line));
|
||||
CHECK(s.valid());
|
||||
CHECK(!s.unterminated_quote());
|
||||
CHECK_FALSE(s.unterminated_quote());
|
||||
expected = {"just", "some", "ran,dom", "strings"};
|
||||
CHECK(words(vec) == expected);
|
||||
CHECK_EQ(words(vec), expected);
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
ss::converter<ss::quote<'"'>, ss::escape<'\\'>> c;
|
||||
ss::converter<ss::quote<'"'>, ss::escape<'\\'>, ss::multiline> c;
|
||||
auto& s = c.splitter;
|
||||
auto vec = expect_unterminated_quote(s, R"("just\"some","ra)");
|
||||
std::vector<std::string> expected{"just\"some"};
|
||||
auto w = words(vec);
|
||||
w.pop_back();
|
||||
CHECK(w == expected);
|
||||
CHECK_EQ(w, expected);
|
||||
REQUIRE(s.unterminated_quote());
|
||||
{
|
||||
auto new_line = buff.append(R"(n,dom",str\"ings)");
|
||||
vec = c.resplit(new_line, strlen(new_line));
|
||||
CHECK(s.valid());
|
||||
CHECK(!s.unterminated_quote());
|
||||
CHECK_FALSE(s.unterminated_quote());
|
||||
expected = {"just\"some", "ran,dom", "str\"ings"};
|
||||
CHECK(words(vec) == expected);
|
||||
CHECK_EQ(words(vec), expected);
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
ss::converter<ss::quote<'"'>, ss::escape<'\\'>> c;
|
||||
ss::converter<ss::quote<'"'>, ss::escape<'\\'>, ss::multiline> c;
|
||||
auto& s = c.splitter;
|
||||
auto vec =
|
||||
expect_unterminated_quote(s, "3,4,"
|
||||
@@ -640,89 +675,97 @@ TEST_CASE("splitter test resplit unterminated quote") {
|
||||
std::vector<std::string> expected{"3", "4"};
|
||||
auto w = words(vec);
|
||||
w.pop_back();
|
||||
CHECK(w == expected);
|
||||
CHECK_EQ(w, expected);
|
||||
REQUIRE(s.unterminated_quote());
|
||||
{
|
||||
buff.data_[strlen(buff.data_) - c.splitter.escaped_] = '\0';
|
||||
auto new_line = buff.append("\nx5strings\"");
|
||||
auto new_line =
|
||||
buff.append_overwrite_last("\nx5strings\"", c.size_shifted());
|
||||
vec = c.resplit(new_line, strlen(new_line));
|
||||
CHECK(s.valid());
|
||||
CHECK(!s.unterminated_quote());
|
||||
CHECK_FALSE(s.unterminated_quote());
|
||||
expected = {"3", "4", "just0\n1\n22\n33333x\n4\nx5strings"};
|
||||
CHECK(words(vec) == expected);
|
||||
CHECK_EQ(words(vec), expected);
|
||||
}
|
||||
}
|
||||
{
|
||||
ss::converter<ss::quote<'"'>, ss::escape<'\\'>> c;
|
||||
ss::converter<ss::quote<'"'>, ss::escape<'\\'>, ss::multiline> c;
|
||||
auto& s = c.splitter;
|
||||
auto vec = expect_unterminated_quote(s, R"("just\"some","ra"")");
|
||||
std::vector<std::string> expected{"just\"some"};
|
||||
auto w = words(vec);
|
||||
w.pop_back();
|
||||
CHECK(w == expected);
|
||||
CHECK_EQ(w, expected);
|
||||
REQUIRE(s.unterminated_quote());
|
||||
{
|
||||
buff.data_[strlen(buff.data_) - c.splitter.escaped_] = '\0';
|
||||
auto new_line = buff.append(R"(n,dom",str\"ings)");
|
||||
auto new_line = buff.append_overwrite_last(R"(n,dom",str\"ings)",
|
||||
c.size_shifted());
|
||||
vec = c.resplit(new_line, strlen(new_line));
|
||||
CHECK(s.valid());
|
||||
CHECK(!s.unterminated_quote());
|
||||
CHECK_FALSE(s.unterminated_quote());
|
||||
expected = {"just\"some", "ra\"n,dom", "str\"ings"};
|
||||
CHECK(words(vec) == expected);
|
||||
CHECK_EQ(words(vec), expected);
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
ss::converter<ss::quote<'"'>, ss::escape<'\\'>> c;
|
||||
ss::converter<ss::quote<'"'>, ss::escape<'\\'>, ss::multiline> c;
|
||||
auto& s = c.splitter;
|
||||
auto vec = expect_unterminated_quote(s, R"("just\"some","r\a\a\\\a\")");
|
||||
std::vector<std::string> expected{"just\"some"};
|
||||
auto w = words(vec);
|
||||
w.pop_back();
|
||||
CHECK(w == expected);
|
||||
CHECK_EQ(w, expected);
|
||||
REQUIRE(s.unterminated_quote());
|
||||
{
|
||||
buff.data_[strlen(buff.data_) - c.splitter.escaped_] = '\0';
|
||||
auto new_line = buff.append(R"(n,dom",str\"ings)");
|
||||
auto new_line = buff.append_overwrite_last(R"(n,dom",str\"ings)",
|
||||
c.size_shifted());
|
||||
vec = c.resplit(new_line, strlen(new_line));
|
||||
CHECK(s.valid());
|
||||
CHECK(!s.unterminated_quote());
|
||||
CHECK_FALSE(s.unterminated_quote());
|
||||
expected = {"just\"some", "raa\\a\"n,dom", "str\"ings"};
|
||||
CHECK(words(vec) == expected);
|
||||
CHECK_EQ(words(vec), expected);
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
ss::converter<ss::quote<'"'>, ss::trim<' '>> c;
|
||||
ss::converter<ss::quote<'"'>, ss::trim<' '>, ss::multiline> c;
|
||||
auto& s = c.splitter;
|
||||
auto vec = expect_unterminated_quote(s, R"( "just" ,some, "ra )");
|
||||
std::vector<std::string> expected{"just", "some"};
|
||||
auto w = words(vec);
|
||||
w.pop_back();
|
||||
CHECK(w == expected);
|
||||
CHECK_EQ(w, expected);
|
||||
REQUIRE(s.unterminated_quote());
|
||||
{
|
||||
auto new_line = buff.append(R"( n,dom" , strings )");
|
||||
vec = c.resplit(new_line, strlen(new_line));
|
||||
CHECK(s.valid());
|
||||
CHECK(!s.unterminated_quote());
|
||||
CHECK_FALSE(s.unterminated_quote());
|
||||
expected = {"just", "some", "ra n,dom", "strings"};
|
||||
CHECK(words(vec) == expected);
|
||||
CHECK_EQ(words(vec), expected);
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
ss::converter<ss::quote<'"'>, ss::trim<' '>, ss::escape<'\\'>> c;
|
||||
ss::converter<ss::quote<'"'>, ss::trim<' '>, ss::escape<'\\'>,
|
||||
ss::multiline>
|
||||
c;
|
||||
auto& s = c.splitter;
|
||||
auto vec = expect_unterminated_quote(s, R"( "ju\"st" ,some, "ra \")");
|
||||
std::vector<std::string> expected{"ju\"st", "some"};
|
||||
auto w = words(vec);
|
||||
w.pop_back();
|
||||
CHECK(w == expected);
|
||||
CHECK_EQ(w, expected);
|
||||
REQUIRE(s.unterminated_quote());
|
||||
{
|
||||
buff.data_[strlen(buff.data_) - c.splitter.escaped_] = '\0';
|
||||
auto new_line = buff.append(R"( n,dom" , strings )");
|
||||
auto new_line =
|
||||
buff.append_overwrite_last(R"( n,dom" , strings )",
|
||||
c.size_shifted());
|
||||
vec = c.resplit(new_line, strlen(new_line));
|
||||
CHECK(s.valid());
|
||||
CHECK(!s.unterminated_quote());
|
||||
CHECK_FALSE(s.unterminated_quote());
|
||||
expected = {"ju\"st", "some", "ra \" n,dom", "strings"};
|
||||
CHECK(words(vec) == expected);
|
||||
CHECK_EQ(words(vec), expected);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -735,28 +778,40 @@ TEST_CASE("splitter test invalid splits") {
|
||||
|
||||
// empty delimiter
|
||||
s.split(buff("some,random,strings"), "");
|
||||
CHECK(!s.valid());
|
||||
CHECK(!s.unterminated_quote());
|
||||
CHECK(!s.error_msg().empty());
|
||||
CHECK_FALSE(s.valid());
|
||||
CHECK_FALSE(s.unterminated_quote());
|
||||
CHECK_FALSE(s.error_msg().empty());
|
||||
|
||||
// mismatched delimiter
|
||||
s.split(buff(R"(some,"random,"strings")"));
|
||||
CHECK(!s.valid());
|
||||
CHECK(!s.unterminated_quote());
|
||||
CHECK(!s.error_msg().empty());
|
||||
CHECK_FALSE(s.valid());
|
||||
CHECK_FALSE(s.unterminated_quote());
|
||||
CHECK_FALSE(s.error_msg().empty());
|
||||
|
||||
// unterminated escape
|
||||
s.split(buff(R"(some,random,strings\)"));
|
||||
CHECK_FALSE(s.valid());
|
||||
CHECK_FALSE(s.unterminated_quote());
|
||||
CHECK_FALSE(s.error_msg().empty());
|
||||
|
||||
// unterminated escape
|
||||
s.split(buff(R"(some,random,"strings\)"));
|
||||
CHECK_FALSE(s.valid());
|
||||
CHECK_FALSE(s.unterminated_quote());
|
||||
CHECK_FALSE(s.error_msg().empty());
|
||||
|
||||
// unterminated quote
|
||||
s.split(buff("some,random,\"strings"));
|
||||
CHECK(!s.valid());
|
||||
CHECK_FALSE(s.valid());
|
||||
CHECK(s.unterminated_quote());
|
||||
CHECK(!s.error_msg().empty());
|
||||
CHECK_FALSE(s.error_msg().empty());
|
||||
|
||||
// invalid resplit
|
||||
char new_line[] = "some";
|
||||
auto a = c.resplit(new_line, strlen(new_line));
|
||||
CHECK(!s.valid());
|
||||
CHECK(!s.unterminated_quote());
|
||||
CHECK(!s.error_msg().empty());
|
||||
CHECK_FALSE(s.valid());
|
||||
CHECK_FALSE(s.unterminated_quote());
|
||||
CHECK_FALSE(s.error_msg().empty());
|
||||
}
|
||||
|
||||
TEST_CASE("splitter test with trim_left") {
|
||||
|
||||
Reference in New Issue
Block a user