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

add splitter, update converter and parser, update unit tests

Browse Source
This commit is contained in:
ado
2021-01-17 00:46:05 +01:00
parent cd264faa70
commit 69d6df12be
6 changed files with 478 additions and 273 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
test/makefile
View File

@@ -1,6 +1,6 @@
CXX=clang++-9
CXXFLAGS=-Wall -Wextra -std=c++17 -O0 -lstdc++fs
TESTS=test_converter
CXX=clang++
CXXFLAGS=-Wall -Wextra -std=c++17 -lstdc++fs
TESTS=test_parser test_converter test_extractions
all: $(TESTS)

BIN
test/test_converter
View File

Binary file not shown.

227
test/test_converter.cpp
View File

@@ -4,13 +4,29 @@
#include "doctest.h"
#include <algorithm>
/* TODO
TEST_CASE("testing quoting with escaping") {
std::vector<std::string> values{"10", "he\\\"llo", "\\\"",
"\\\"a,a\\\"", "3.33", "a\\\""};
class buffer {
constexpr static auto buff_size = 1024;
char data_[buff_size];
public:
char* operator()(const char* data) {
memset(data_, '\0', buff_size);
strcpy(data_, data);
return data_;
}
};
buffer buff;
TEST_CASE("testing splitter with escaping") {
std::vector<std::string> values{"10", "he\\\"llo",
"\\\"", "\\\"a\\,a\\\"",
"3.33", "a\\\""};
char buff[128];
// with quote
ss::converter c;
ss::splitter<ss::quote<'"'>, ss::escape<'\\'>> s;
std::string delim = ",";
for (size_t i = 0; i < values.size() * values.size(); ++i) {
std::string input1;
std::string input2;
@@ -22,44 +38,25 @@ TEST_CASE("testing quoting with escaping") {
input1.append("\"" + values[j] + "\"");
input2.append("\"" + values.at(values.size() - 1 - j) + "\"");
}
input1.push_back(',');
input2.push_back(',');
input1.append(delim);
input2.append(delim);
}
input1.pop_back();
input2.pop_back();
input1.append("\0\"");
input2.append("\0\"");
auto tup1 = c.convert<int, std::string, std::string, std::string,
double, std::string>(input1.c_str(), ",");
if (!c.valid()) {
FAIL("invalid: " + input1);
} else {
auto [a, b, c, d, e, f] = tup1;
CHECK(a == 10);
CHECK(b == "he\"llo");
CHECK(c == "\"");
CHECK(d == "\"a,a\"");
CHECK(e == 3.33);
CHECK(f == "a\"");
std::cout << a << ' ' << b << ' ' << c << ' ' << d << ' ' << e
<< ' ' << f << std::endl;
CHECK(tup1 ==
std::make_tuple(10, "he\"llo", "\"", "\"a,a\"", 3.33, "a\""));
}
memcpy(buff, input1.c_str(), input1.size() + 1);
auto tup1 = s.split(buff, delim);
CHECK(tup1.size() == 6);
auto tup2 = c.convert<std::string, double, std::string, std::string,
std::string, int>(input2.c_str(), ",");
if (!c.valid()) {
FAIL("invalid: " + input2);
} else {
CHECK(tup2 ==
std::make_tuple("a\"", 3.33, "\"a,a\"", "\"", "he\"llo", 10));
}
memcpy(buff, input2.c_str(), input2.size() + 1);
auto tup2 = s.split(buff, delim);
CHECK(tup2.size() == 6);
}
}
*/
/*
TEST_CASE("testing quoting without escaping") {
std::vector<std::string> values{"10", "hello", ",", "a,a", "3.33", "a"};
@@ -117,6 +114,7 @@ TEST_CASE("testing quoting without escaping") {
}
}
}
*/
TEST_CASE("testing split") {
ss::converter c;
@@ -124,13 +122,12 @@ TEST_CASE("testing split") {
// clang-format off
{std::tuple{"a,b,c,d", std::vector{"a", "b", "c", "d"}, ","},
{"", {}, " "},
{"a,b,c", {"a", "b", "c"}, ""},
{" x x x x | x ", {" x x x x ", " x "}, "|"},
{"a::b::c::d", {"a", "b", "c", "d"}, "::"},
{"x\t-\ty", {"x", "y"}, "\t-\t"},
{"x", {"x"}, ","}} // clang-format on
) {
auto split = c.split(s, delim);
auto split = c.split(buff(s), delim);
CHECK(split.size() == expected.size());
for (size_t i = 0; i < split.size(); ++i) {
auto s = std::string(split[i].first, split[i].second);
@@ -143,84 +140,85 @@ TEST_CASE("testing valid conversions") {
ss::converter c;
{
auto tup = c.convert<int>("5");
auto tup = c.convert<int>(buff("5"));
REQUIRE(c.valid());
CHECK(tup == 5);
}
{
auto tup = c.convert<int, void>("5,junk");
auto tup = c.convert<int, void>(buff("5,junk"));
REQUIRE(c.valid());
CHECK(tup == 5);
}
{
auto tup = c.convert<void, int>("junk,5");
auto tup = c.convert<void, int>(buff("junk,5"));
REQUIRE(c.valid());
CHECK(tup == 5);
}
{
auto tup = c.convert<int, void, void>("5\njunk\njunk", "\n");
auto tup = c.convert<int, void, void>(buff("5\njunk\njunk"), "\n");
REQUIRE(c.valid());
CHECK(tup == 5);
}
{
// TODO make \t -> ' '
auto tup = c.convert<void, int, void>("junk\t5\tjunk", "\t");
auto tup = c.convert<void, int, void>(buff("junk\t5\tjunk"), "\t");
REQUIRE(c.valid());
CHECK(tup == 5);
}
{
auto tup = c.convert<void, void, int>("junk\tjunk\t5", "\t");
auto tup = c.convert<void, void, int>(buff("junk\tjunk\t5"), "\t");
REQUIRE(c.valid());
CHECK(tup == 5);
}
{
auto tup =
c.convert<void, void, std::optional<int>>("junk\tjunk\t5", "\t");
c.convert<void, void, std::optional<int>>(buff("junk\tjunk\t5"),
"\t");
REQUIRE(c.valid());
REQUIRE(tup.has_value());
CHECK(tup == 5);
}
{
auto tup = c.convert<int, double, void>("5,6.6,junk");
auto tup = c.convert<int, double, void>(buff("5,6.6,junk"));
REQUIRE(c.valid());
CHECK(tup == std::tuple{5, 6.6});
}
{
auto tup = c.convert<int, void, double>("5,junk,6.6");
auto tup = c.convert<int, void, double>(buff("5,junk,6.6"));
REQUIRE(c.valid());
CHECK(tup == std::tuple{5, 6.6});
}
{
auto tup = c.convert<void, int, double>("junk;5;6.6", ";");
auto tup = c.convert<void, int, double>(buff("junk;5;6.6"), ";");
REQUIRE(c.valid());
CHECK(tup == std::tuple{5, 6.6});
}
{
auto tup =
c.convert<void, std::optional<int>, double>("junk;5;6.6", ";");
c.convert<void, std::optional<int>, double>(buff("junk;5;6.6"),
";");
REQUIRE(c.valid());
REQUIRE(std::get<0>(tup).has_value());
CHECK(tup == std::tuple{5, 6.6});
}
{
auto tup =
c.convert<void, std::optional<int>, double>("junk;5.4;6.6", ";");
c.convert<void, std::optional<int>, double>(buff("junk;5.4;6.6"),
";");
REQUIRE(c.valid());
REQUIRE(!std::get<0>(tup).has_value());
CHECK(tup == std::tuple{std::nullopt, 6.6});
}
{
auto tup =
c.convert<void, std::variant<int, double>, double>("junk;5;6.6",
";");
auto tup = c.convert<void, std::variant<int, double>,
double>(buff("junk;5;6.6"), ";");
REQUIRE(c.valid());
REQUIRE(std::holds_alternative<int>(std::get<0>(tup)));
CHECK(tup == std::tuple{std::variant<int, double>{5}, 6.6});
}
{
auto tup =
c.convert<void, std::variant<int, double>, double>("junk;5.5;6.6",
";");
auto tup = c.convert<void, std::variant<int, double>,
double>(buff("junk;5.5;6.6"), ";");
REQUIRE(c.valid());
REQUIRE(std::holds_alternative<double>(std::get<0>(tup)));
CHECK(tup == std::tuple{std::variant<int, double>{5.5}, 6.6});
@@ -230,60 +228,63 @@ TEST_CASE("testing valid conversions") {
TEST_CASE("testing invalid conversions") {
ss::converter c;
c.convert<int>("");
c.convert<int>(buff(""));
REQUIRE(!c.valid());
c.convert<int, void>("");
c.convert<int, void>(buff(""));
REQUIRE(!c.valid());
c.convert<int, void>(",junk");
c.convert<int, void>(buff(",junk"));
REQUIRE(!c.valid());
c.convert<void, int>("junk,");
c.convert<void, int>(buff("junk,"));
REQUIRE(!c.valid());
c.convert<int>("x");
c.convert<int>(buff("x"));
REQUIRE(!c.valid());
c.convert<int, void>("x");
c.convert<int, void>(buff("x"));
REQUIRE(!c.valid());
c.convert<int, void>("x,junk");
c.convert<int, void>(buff("x,junk"));
REQUIRE(!c.valid());
c.convert<void, int>("junk,x");
c.convert<void, int>(buff("junk,x"));
REQUIRE(!c.valid());
c.convert<void, std::variant<int, double>, double>("junk;.5.5;6", ";");
c.convert<void, std::variant<int, double>, double>(buff("junk;.5.5;6"),
";");
REQUIRE(!c.valid());
}
TEST_CASE("testing ss:ax restriction (all except)") {
ss::converter c;
c.convert<ss::ax<int, 0>>("0");
c.convert<ss::ax<int, 0>>(buff("0"));
REQUIRE(!c.valid());
c.convert<ss::ax<int, 0, 1, 2>>("1");
c.convert<ss::ax<int, 0, 1, 2>>(buff("1"));
REQUIRE(!c.valid());
c.convert<void, char, ss::ax<int, 0, 1, 2>>("junk,c,1");
c.convert<void, char, ss::ax<int, 0, 1, 2>>(buff("junk,c,1"));
REQUIRE(!c.valid());
c.convert<ss::ax<int, 1>, char>("1,c");
c.convert<ss::ax<int, 1>, char>(buff("1,c"));
REQUIRE(!c.valid());
{
int tup = c.convert<ss::ax<int, 1>>("3");
int tup = c.convert<ss::ax<int, 1>>(buff("3"));
REQUIRE(c.valid());
CHECK(tup == 3);
}
{
std::tuple<char, int> tup = c.convert<char, ss::ax<int, 1>>("c,3");
std::tuple<char, int> tup =
c.convert<char, ss::ax<int, 1>>(buff("c,3"));
REQUIRE(c.valid());
CHECK(tup == std::tuple{'c', 3});
}
{
std::tuple<int, char> tup = c.convert<ss::ax<int, 1>, char>("3,c");
std::tuple<int, char> tup =
c.convert<ss::ax<int, 1>, char>(buff("3,c"));
REQUIRE(c.valid());
CHECK(tup == std::tuple{3, 'c'});
}
@@ -292,32 +293,33 @@ TEST_CASE("testing ss:ax restriction (all except)") {
TEST_CASE("testing ss:nx restriction (none except)") {
ss::converter c;
c.convert<ss::nx<int, 1>>("3");
c.convert<ss::nx<int, 1>>(buff("3"));
REQUIRE(!c.valid());
c.convert<char, ss::nx<int, 1, 2, 69>>("c,3");
c.convert<char, ss::nx<int, 1, 2, 69>>(buff("c,3"));
REQUIRE(!c.valid());
c.convert<ss::nx<int, 1>, char>("3,c");
c.convert<ss::nx<int, 1>, char>(buff("3,c"));
REQUIRE(!c.valid());
{
auto tup = c.convert<ss::nx<int, 3>>("3");
auto tup = c.convert<ss::nx<int, 3>>(buff("3"));
REQUIRE(c.valid());
CHECK(tup == 3);
}
{
auto tup = c.convert<ss::nx<int, 0, 1, 2>>("2");
auto tup = c.convert<ss::nx<int, 0, 1, 2>>(buff("2"));
REQUIRE(c.valid());
CHECK(tup == 2);
}
{
auto tup = c.convert<char, void, ss::nx<int, 0, 1, 2>>("c,junk,1");
auto tup =
c.convert<char, void, ss::nx<int, 0, 1, 2>>(buff("c,junk,1"));
REQUIRE(c.valid());
CHECK(tup == std::tuple{'c', 1});
}
{
auto tup = c.convert<ss::nx<int, 1>, char>("1,c");
auto tup = c.convert<ss::nx<int, 1>, char>(buff("1,c"));
REQUIRE(c.valid());
CHECK(tup == std::tuple{1, 'c'});
}
@@ -326,32 +328,32 @@ TEST_CASE("testing ss:nx restriction (none except)") {
TEST_CASE("testing ss:ir restriction (in range)") {
ss::converter c;
c.convert<ss::ir<int, 0, 2>>("3");
c.convert<ss::ir<int, 0, 2>>(buff("3"));
REQUIRE(!c.valid());
c.convert<char, ss::ir<int, 4, 69>>("c,3");
c.convert<char, ss::ir<int, 4, 69>>(buff("c,3"));
REQUIRE(!c.valid());
c.convert<ss::ir<int, 1, 2>, char>("3,c");
c.convert<ss::ir<int, 1, 2>, char>(buff("3,c"));
REQUIRE(!c.valid());
{
auto tup = c.convert<ss::ir<int, 1, 5>>("3");
auto tup = c.convert<ss::ir<int, 1, 5>>(buff("3"));
REQUIRE(c.valid());
CHECK(tup == 3);
}
{
auto tup = c.convert<ss::ir<int, 0, 2>>("2");
auto tup = c.convert<ss::ir<int, 0, 2>>(buff("2"));
REQUIRE(c.valid());
CHECK(tup == 2);
}
{
auto tup = c.convert<char, void, ss::ir<int, 0, 1>>("c,junk,1");
auto tup = c.convert<char, void, ss::ir<int, 0, 1>>(buff("c,junk,1"));
REQUIRE(c.valid());
CHECK(tup == std::tuple{'c', 1});
}
{
auto tup = c.convert<ss::ir<int, 1, 20>, char>("1,c");
auto tup = c.convert<ss::ir<int, 1, 20>, char>(buff("1,c"));
REQUIRE(c.valid());
CHECK(tup == std::tuple{1, 'c'});
}
@@ -360,32 +362,32 @@ TEST_CASE("testing ss:ir restriction (in range)") {
TEST_CASE("testing ss:oor restriction (out of range)") {
ss::converter c;
c.convert<ss::oor<int, 1, 5>>("3");
c.convert<ss::oor<int, 1, 5>>(buff("3"));
REQUIRE(!c.valid());
c.convert<ss::oor<int, 0, 2>>("2");
c.convert<ss::oor<int, 0, 2>>(buff("2"));
REQUIRE(!c.valid());
c.convert<char, ss::oor<int, 0, 1>, void>("c,1,junk");
c.convert<char, ss::oor<int, 0, 1>, void>(buff("c,1,junk"));
REQUIRE(!c.valid());
c.convert<ss::oor<int, 1, 20>, char>("1,c");
c.convert<ss::oor<int, 1, 20>, char>(buff("1,c"));
REQUIRE(!c.valid());
{
auto tup = c.convert<ss::oor<int, 0, 2>>("3");
auto tup = c.convert<ss::oor<int, 0, 2>>(buff("3"));
REQUIRE(c.valid());
CHECK(tup == 3);
}
{
auto tup = c.convert<char, void, ss::oor<int, 4, 69>>("c,junk,3");
auto tup = c.convert<char, void, ss::oor<int, 4, 69>>(buff("c,junk,3"));
REQUIRE(c.valid());
CHECK(tup == std::tuple{'c', 3});
}
{
auto tup = c.convert<ss::oor<int, 1, 2>, char>("3,c");
auto tup = c.convert<ss::oor<int, 1, 2>, char>(buff("3,c"));
REQUIRE(c.valid());
CHECK(tup == std::tuple{3, 'c'});
}
@@ -407,33 +409,34 @@ inline bool ss::extract(const char* begin, const char* end,
TEST_CASE("testing ss:ne restriction (not empty)") {
ss::converter c;
c.convert<ss::ne<std::string>>("");
c.convert<ss::ne<std::string>>(buff(""));
REQUIRE(!c.valid());
c.convert<int, ss::ne<std::string>>("3,");
c.convert<int, ss::ne<std::string>>(buff("3,"));
REQUIRE(!c.valid());
c.convert<ss::ne<std::string>, int>(",3");
c.convert<ss::ne<std::string>, int>(buff(",3"));
REQUIRE(!c.valid());
c.convert<void, ss::ne<std::string>, int>("junk,,3");
c.convert<void, ss::ne<std::string>, int>(buff("junk,,3"));
REQUIRE(!c.valid());
c.convert<ss::ne<std::vector<int>>>("");
c.convert<ss::ne<std::vector<int>>>(buff(""));
REQUIRE(!c.valid());
{
auto tup = c.convert<ss::ne<std::string>>("s");
auto tup = c.convert<ss::ne<std::string>>(buff("s"));
REQUIRE(c.valid());
CHECK(tup == "s");
}
{
auto tup = c.convert<std::optional<int>, ss::ne<std::string>>("1,s");
auto tup =
c.convert<std::optional<int>, ss::ne<std::string>>(buff("1,s"));
REQUIRE(c.valid());
CHECK(tup == std::tuple{1, "s"});
}
{
auto tup = c.convert<ss::ne<std::vector<int>>>("{1 2 3}");
auto tup = c.convert<ss::ne<std::vector<int>>>(buff("{1 2 3}"));
REQUIRE(c.valid());
CHECK(tup == extracted_vector);
}
@@ -442,56 +445,56 @@ TEST_CASE("testing ss:ne restriction (not empty)") {
TEST_CASE("testing ss:lt ss::lte ss::gt ss::gte restriction (in range)") {
ss::converter c;
c.convert<ss::lt<int, 3>>("3");
c.convert<ss::lt<int, 3>>(buff("3"));
REQUIRE(!c.valid());
c.convert<ss::lt<int, 2>>("3");
c.convert<ss::lt<int, 2>>(buff("3"));
REQUIRE(!c.valid());
c.convert<ss::gt<int, 3>>("3");
c.convert<ss::gt<int, 3>>(buff("3"));
REQUIRE(!c.valid());
c.convert<ss::gt<int, 4>>("3");
c.convert<ss::gt<int, 4>>(buff("3"));
REQUIRE(!c.valid());
c.convert<ss::lte<int, 2>>("3");
c.convert<ss::lte<int, 2>>(buff("3"));
REQUIRE(!c.valid());
c.convert<ss::gte<int, 4>>("3");
c.convert<ss::gte<int, 4>>(buff("3"));
REQUIRE(!c.valid());
{
auto tup = c.convert<ss::lt<int, 4>>("3");
auto tup = c.convert<ss::lt<int, 4>>(buff("3"));
REQUIRE(c.valid());
CHECK(tup == 3);
}
{
auto tup = c.convert<ss::gt<int, 2>>("3");
auto tup = c.convert<ss::gt<int, 2>>(buff("3"));
REQUIRE(c.valid());
CHECK(tup == 3);
}
{
auto tup = c.convert<ss::lte<int, 4>>("3");
auto tup = c.convert<ss::lte<int, 4>>(buff("3"));
REQUIRE(c.valid());
CHECK(tup == 3);
}
{
auto tup = c.convert<ss::lte<int, 3>>("3");
auto tup = c.convert<ss::lte<int, 3>>(buff("3"));
REQUIRE(c.valid());
CHECK(tup == 3);
}
{
auto tup = c.convert<ss::gte<int, 2>>("3");
auto tup = c.convert<ss::gte<int, 2>>(buff("3"));
REQUIRE(c.valid());
CHECK(tup == 3);
}
{
auto tup = c.convert<ss::gte<int, 3>>("3");
auto tup = c.convert<ss::gte<int, 3>>(buff("3"));
REQUIRE(c.valid());
CHECK(tup == 3);
}
@@ -500,12 +503,12 @@ TEST_CASE("testing ss:lt ss::lte ss::gt ss::gte restriction (in range)") {
TEST_CASE("testing error mode") {
ss::converter c;
c.convert<int>("junk");
c.convert<int>(buff("junk"));
CHECK(!c.valid());
CHECK(c.error_msg().empty());
c.set_error_mode(ss::error_mode::error_string);
c.convert<int>("junk");
c.convert<int>(buff("junk"));
CHECK(!c.valid());
CHECK(!c.error_msg().empty());
}

1
test/test_parser.cpp
View File

@@ -56,6 +56,7 @@ TEST_CASE("testing parser") {
make_and_write(f.name, data);
{
ss::parser p{f.name, ","};
p.set_error_mode(ss::error_mode::error_string);
std::vector<X> i;
while (!p.eof()) {