ado/ssp
1
1
Fork 0
mirror of https://github.com/red0124/ssp.git synced 2025-12-14 21:59:55 +01:00
Code Issues Packages Projects Releases Wiki Activity

update all unit tests, fix bug with unterminated escape, updated multiline parsing, refactored some code, removed unused code

Browse Source
This commit is contained in:
ado
2021-02-21 02:49:23 +01:00
parent 2dbc21780f
commit 1af0e75788
9 changed files with 422 additions and 281 deletions
Download Patch File Download Diff File Expand all files Collapse all files

195
test/test_splitter.cpp
View File

@@ -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") {