ado/ssp
1
1
Fork 0
mirror of https://github.com/red0124/ssp.git synced 2025-06-08 13:12:32 +02:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: ado:b660310acf132e828b69a496f053523d451367b9
Branches Tags
ado:master
ado:bugfix/ci_fixes
ado:dev
ado:improvement/performance_update
ado:v1.8.0
ado:v1.7.2
ado:v1.7.1
ado:v1.7.0
ado:v1.6.2
ado:v1.6.1
ado:v1.6.0
ado:v1.5.0
ado:v1.4.3
ado:v1.4.2
ado:v1.4.1
ado:v1.4.0
ado:v1.3.0
ado:v1.2.0
ado:v1.1.0
ado:v1.0.0
..
compare: ado:0ebbee1174be4e07c10012c76cff2fb33f10af63
Branches Tags
ado:bugfix/ci_fixes
ado:master
ado:dev
ado:improvement/performance_update
ado:v1.8.0
ado:v1.7.2
ado:v1.7.1
ado:v1.7.0
ado:v1.6.2
ado:v1.6.1
ado:v1.6.0
ado:v1.5.0
ado:v1.4.3
ado:v1.4.2
ado:v1.4.1
ado:v1.4.0
ado:v1.3.0
ado:v1.2.0
ado:v1.1.0
ado:v1.0.0

No commits in common. "b660310acf132e828b69a496f053523d451367b9" and "0ebbee1174be4e07c10012c76cff2fb33f10af63" have entirely different histories.
b660310acf ... 0ebbee1174

9 changed files with 226 additions and 329 deletions
Show Stats Expand all files Collapse all files

11
include/ss/common.hpp
View File

@ -29,7 +29,7 @@ inline void assert_throw_on_error_not_defined() {
} }
inline void* strict_realloc(void* ptr, size_t size) { inline void* strict_realloc(void* ptr, size_t size) {
ptr = std::realloc(ptr, size); ptr = realloc(ptr, size);
if (!ptr) { if (!ptr) {
throw std::bad_alloc{}; throw std::bad_alloc{};
} }
@ -62,17 +62,18 @@ ssize_t get_line_file(char** lineptr, size_t* n, FILE* fp) {
(*lineptr)[0] = '\0'; (*lineptr)[0] = '\0';
size_t line_used = 0; size_t line_used = 0;
while (std::fgets(buff, sizeof(buff), fp) != nullptr) { while (fgets(buff, sizeof(buff), fp) != nullptr) {
line_used = std::strlen(*lineptr); line_used = strlen(*lineptr);
size_t buff_used = std::strlen(buff); size_t buff_used = strlen(buff);
if (*n <= buff_used + line_used) { if (*n <= buff_used + line_used) {
size_t new_n = *n * 2; size_t new_n = *n * 2;
*lineptr = static_cast<char*>(strict_realloc(*lineptr, new_n)); *lineptr = static_cast<char*>(strict_realloc(*lineptr, new_n));
*n = new_n; *n = new_n;
} }
std::memcpy(*lineptr + line_used, buff, buff_used); memcpy(*lineptr + line_used, buff, buff_used);
line_used += buff_used; line_used += buff_used;
(*lineptr)[line_used] = '\0'; (*lineptr)[line_used] = '\0';

55
include/ss/extract.hpp
View File

@ -77,38 +77,6 @@ std::enable_if_t<std::is_floating_point_v<T>, std::optional<T>> to_num(
#endif #endif
////////////////
// numeric_wrapper
////////////////
template <typename T>
struct numeric_wrapper {
using type = T;
numeric_wrapper() = default;
numeric_wrapper(numeric_wrapper&&) = default;
numeric_wrapper(const numeric_wrapper&) = default;
numeric_wrapper& operator=(numeric_wrapper&&) = default;
numeric_wrapper& operator=(const numeric_wrapper&) = default;
numeric_wrapper(T other) : value{other} {
}
operator T() {
return value;
}
operator T() const {
return value;
}
T value;
};
using int8 = numeric_wrapper<int8_t>;
using uint8 = numeric_wrapper<uint8_t>;
template <typename T> template <typename T>
std::enable_if_t<std::is_integral_v<T>, std::optional<T>> to_num( std::enable_if_t<std::is_integral_v<T>, std::optional<T>> to_num(
const char* const begin, const char* const end) { const char* const begin, const char* const end) {
@ -121,18 +89,6 @@ std::enable_if_t<std::is_integral_v<T>, std::optional<T>> to_num(
return ret; return ret;
} }
template <typename T>
std::enable_if_t<is_instance_of_v<numeric_wrapper, T>, std::optional<T>> to_num(
const char* const begin, const char* const end) {
T ret;
auto [ptr, ec] = std::from_chars(begin, end, ret.value);
if (ec != std::errc() || ptr != end) {
return std::nullopt;
}
return ret;
}
//////////////// ////////////////
// extract // extract
//////////////// ////////////////
@ -147,8 +103,7 @@ struct unsupported_type {
template <typename T> template <typename T>
std::enable_if_t<!std::is_integral_v<T> && !std::is_floating_point_v<T> && std::enable_if_t<!std::is_integral_v<T> && !std::is_floating_point_v<T> &&
!is_instance_of_v<std::optional, T> && !is_instance_of_v<std::optional, T> &&
!is_instance_of_v<std::variant, T> && !is_instance_of_v<std::variant, T>,
!is_instance_of_v<numeric_wrapper, T>,
bool> bool>
extract(const char*, const char*, T&) { extract(const char*, const char*, T&) {
static_assert(error::unsupported_type<T>::value, static_assert(error::unsupported_type<T>::value,
@ -157,9 +112,7 @@ extract(const char*, const char*, T&) {
} }
template <typename T> template <typename T>
std::enable_if_t<std::is_integral_v<T> || std::is_floating_point_v<T> || std::enable_if_t<std::is_integral_v<T> || std::is_floating_point_v<T>, bool>
is_instance_of_v<numeric_wrapper, T>,
bool>
extract(const char* begin, const char* end, T& value) { extract(const char* begin, const char* end, T& value) {
auto optional_value = to_num<T>(begin, end); auto optional_value = to_num<T>(begin, end);
if (!optional_value) { if (!optional_value) {
@ -216,9 +169,9 @@ inline bool extract(const char* begin, const char* end, bool& value) {
} }
} else { } else {
size_t size = end - begin; size_t size = end - begin;
if (size == 4 && std::strncmp(begin, "true", size) == 0) { if (size == 4 && strncmp(begin, "true", size) == 0) {
value = true; value = true;
} else if (size == 5 && std::strncmp(begin, "false", size) == 0) { } else if (size == 5 && strncmp(begin, "false", size) == 0) {
value = false; value = false;
} else { } else {
return false; return false;

12
include/ss/parser.hpp
View File

@ -675,7 +675,7 @@ private:
struct reader { struct reader {
reader(const std::string& file_name_, const std::string& delim) reader(const std::string& file_name_, const std::string& delim)
: delim_{delim}, file_{std::fopen(file_name_.c_str(), "rb")} { : delim_{delim}, file_{fopen(file_name_.c_str(), "rb")} {
} }
reader(const char* const buffer, size_t csv_data_size, reader(const char* const buffer, size_t csv_data_size,
@ -736,12 +736,12 @@ private:
} }
~reader() { ~reader() {
std::free(buffer_); free(buffer_);
std::free(next_line_buffer_); free(next_line_buffer_);
std::free(helper_buffer_); free(helper_buffer_);
if (file_) { if (file_) {
std::fclose(file_); fclose(file_);
} }
} }
@ -800,7 +800,7 @@ private:
if (file_) { if (file_) {
ssize = get_line_file(&next_line_buffer_, ssize = get_line_file(&next_line_buffer_,
&next_line_buffer_size_, file_); &next_line_buffer_size_, file_);
curr_char_ = std::ftell(file_); curr_char_ = ftell(file_);
} else { } else {
ssize = get_line_buffer(&next_line_buffer_, ssize = get_line_buffer(&next_line_buffer_,
&next_line_buffer_size_, &next_line_buffer_size_,

2
include/ss/splitter.hpp
View File

@ -199,7 +199,7 @@ private:
}; };
bool match(const char* const curr, const std::string& delim) { bool match(const char* const curr, const std::string& delim) {
return std::strncmp(curr, delim.c_str(), delim.size()) == 0; return strncmp(curr, delim.c_str(), delim.size()) == 0;
}; };
size_t delimiter_size(char) { size_t delimiter_size(char) {

80
ssp.hpp
View File

@ -641,7 +641,7 @@ inline void assert_throw_on_error_not_defined() {
} }
inline void* strict_realloc(void* ptr, size_t size) { inline void* strict_realloc(void* ptr, size_t size) {
ptr = std::realloc(ptr, size); ptr = realloc(ptr, size);
if (!ptr) { if (!ptr) {
throw std::bad_alloc{}; throw std::bad_alloc{};
} }
@ -674,17 +674,18 @@ ssize_t get_line_file(char** lineptr, size_t* n, FILE* fp) {
(*lineptr)[0] = '\0'; (*lineptr)[0] = '\0';
size_t line_used = 0; size_t line_used = 0;
while (std::fgets(buff, sizeof(buff), fp) != nullptr) { while (fgets(buff, sizeof(buff), fp) != nullptr) {
line_used = std::strlen(*lineptr); line_used = strlen(*lineptr);
size_t buff_used = std::strlen(buff); size_t buff_used = strlen(buff);
if (*n <= buff_used + line_used) { if (*n <= buff_used + line_used) {
size_t new_n = *n * 2; size_t new_n = *n * 2;
*lineptr = static_cast<char*>(strict_realloc(*lineptr, new_n)); *lineptr = static_cast<char*>(strict_realloc(*lineptr, new_n));
*n = new_n; *n = new_n;
} }
std::memcpy(*lineptr + line_used, buff, buff_used); memcpy(*lineptr + line_used, buff, buff_used);
line_used += buff_used; line_used += buff_used;
(*lineptr)[line_used] = '\0'; (*lineptr)[line_used] = '\0';
@ -1182,7 +1183,7 @@ private:
}; };
bool match(const char* const curr, const std::string& delim) { bool match(const char* const curr, const std::string& delim) {
return std::strncmp(curr, delim.c_str(), delim.size()) == 0; return strncmp(curr, delim.c_str(), delim.size()) == 0;
}; };
size_t delimiter_size(char) { size_t delimiter_size(char) {
@ -1530,38 +1531,6 @@ std::enable_if_t<std::is_floating_point_v<T>, std::optional<T>> to_num(
#endif #endif
////////////////
// numeric_wrapper
////////////////
template <typename T>
struct numeric_wrapper {
using type = T;
numeric_wrapper() = default;
numeric_wrapper(numeric_wrapper&&) = default;
numeric_wrapper(const numeric_wrapper&) = default;
numeric_wrapper& operator=(numeric_wrapper&&) = default;
numeric_wrapper& operator=(const numeric_wrapper&) = default;
numeric_wrapper(T other) : value{other} {
}
operator T() {
return value;
}
operator T() const {
return value;
}
T value;
};
using int8 = numeric_wrapper<int8_t>;
using uint8 = numeric_wrapper<uint8_t>;
template <typename T> template <typename T>
std::enable_if_t<std::is_integral_v<T>, std::optional<T>> to_num( std::enable_if_t<std::is_integral_v<T>, std::optional<T>> to_num(
const char* const begin, const char* const end) { const char* const begin, const char* const end) {
@ -1574,18 +1543,6 @@ std::enable_if_t<std::is_integral_v<T>, std::optional<T>> to_num(
return ret; return ret;
} }
template <typename T>
std::enable_if_t<is_instance_of_v<numeric_wrapper, T>, std::optional<T>> to_num(
const char* const begin, const char* const end) {
T ret;
auto [ptr, ec] = std::from_chars(begin, end, ret.value);
if (ec != std::errc() || ptr != end) {
return std::nullopt;
}
return ret;
}
//////////////// ////////////////
// extract // extract
//////////////// ////////////////
@ -1600,8 +1557,7 @@ struct unsupported_type {
template <typename T> template <typename T>
std::enable_if_t<!std::is_integral_v<T> && !std::is_floating_point_v<T> && std::enable_if_t<!std::is_integral_v<T> && !std::is_floating_point_v<T> &&
!is_instance_of_v<std::optional, T> && !is_instance_of_v<std::optional, T> &&
!is_instance_of_v<std::variant, T> && !is_instance_of_v<std::variant, T>,
!is_instance_of_v<numeric_wrapper, T>,
bool> bool>
extract(const char*, const char*, T&) { extract(const char*, const char*, T&) {
static_assert(error::unsupported_type<T>::value, static_assert(error::unsupported_type<T>::value,
@ -1610,9 +1566,7 @@ extract(const char*, const char*, T&) {
} }
template <typename T> template <typename T>
std::enable_if_t<std::is_integral_v<T> || std::is_floating_point_v<T> || std::enable_if_t<std::is_integral_v<T> || std::is_floating_point_v<T>, bool>
is_instance_of_v<numeric_wrapper, T>,
bool>
extract(const char* begin, const char* end, T& value) { extract(const char* begin, const char* end, T& value) {
auto optional_value = to_num<T>(begin, end); auto optional_value = to_num<T>(begin, end);
if (!optional_value) { if (!optional_value) {
@ -1669,9 +1623,9 @@ inline bool extract(const char* begin, const char* end, bool& value) {
} }
} else { } else {
size_t size = end - begin; size_t size = end - begin;
if (size == 4 && std::strncmp(begin, "true", size) == 0) { if (size == 4 && strncmp(begin, "true", size) == 0) {
value = true; value = true;
} else if (size == 5 && std::strncmp(begin, "false", size) == 0) { } else if (size == 5 && strncmp(begin, "false", size) == 0) {
value = false; value = false;
} else { } else {
return false; return false;
@ -2851,7 +2805,7 @@ private:
struct reader { struct reader {
reader(const std::string& file_name_, const std::string& delim) reader(const std::string& file_name_, const std::string& delim)
: delim_{delim}, file_{std::fopen(file_name_.c_str(), "rb")} { : delim_{delim}, file_{fopen(file_name_.c_str(), "rb")} {
} }
reader(const char* const buffer, size_t csv_data_size, reader(const char* const buffer, size_t csv_data_size,
@ -2912,12 +2866,12 @@ private:
} }
~reader() { ~reader() {
std::free(buffer_); free(buffer_);
std::free(next_line_buffer_); free(next_line_buffer_);
std::free(helper_buffer_); free(helper_buffer_);
if (file_) { if (file_) {
std::fclose(file_); fclose(file_);
} }
} }
@ -2976,7 +2930,7 @@ private:
if (file_) { if (file_) {
ssize = get_line_file(&next_line_buffer_, ssize = get_line_file(&next_line_buffer_,
&next_line_buffer_size_, file_); &next_line_buffer_size_, file_);
curr_char_ = std::ftell(file_); curr_char_ = ftell(file_);
} else { } else {
ssize = get_line_buffer(&next_line_buffer_, ssize = get_line_buffer(&next_line_buffer_,
&next_line_buffer_size_, &next_line_buffer_size_,

201
test/test_converter.cpp
View File

@ -46,88 +46,90 @@ TEST_CASE("converter test split with exceptions") {
} }
} }
TEST_CASE_TEMPLATE("converter test valid conversions", T, int, ss::uint8) { TEST_CASE("converter test valid conversions") {
ss::converter c; ss::converter c;
{ {
auto tup = c.convert<T>("5"); auto tup = c.convert<int>("5");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, 5); CHECK_EQ(tup, 5);
} }
{ {
auto tup = c.convert<T, void>("5,junk"); auto tup = c.convert<int, void>("5,junk");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, 5); CHECK_EQ(tup, 5);
} }
{ {
auto tup = c.convert<void, T>("junk,5"); auto tup = c.convert<void, int>("junk,5");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, 5); CHECK_EQ(tup, 5);
} }
{ {
auto tup = c.convert<T, void, void>("5\njunk\njunk", "\n"); auto tup = c.convert<int, void, void>("5\njunk\njunk", "\n");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, 5); CHECK_EQ(tup, 5);
} }
{ {
auto tup = c.convert<void, T, void>("junk 5 junk", " "); auto tup = c.convert<void, int, void>("junk 5 junk", " ");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, 5); CHECK_EQ(tup, 5);
} }
{ {
auto tup = c.convert<void, void, T>("junk\tjunk\t5", "\t"); auto tup = c.convert<void, void, int>("junk\tjunk\t5", "\t");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, 5); CHECK_EQ(tup, 5);
} }
{ {
auto tup = auto tup =
c.convert<void, void, std::optional<T>>("junk\tjunk\t5", "\t"); c.convert<void, void, std::optional<int>>("junk\tjunk\t5", "\t");
REQUIRE(c.valid()); REQUIRE(c.valid());
REQUIRE(tup.has_value()); REQUIRE(tup.has_value());
CHECK_EQ(tup, 5); CHECK_EQ(tup, 5);
} }
{ {
auto tup = c.convert<T, double, void>("5,6.6,junk"); auto tup = c.convert<int, double, void>("5,6.6,junk");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, std::make_tuple(5, 6.6)); CHECK_EQ(tup, std::make_tuple(5, 6.6));
} }
{ {
auto tup = c.convert<T, void, double>("5,junk,6.6"); auto tup = c.convert<int, void, double>("5,junk,6.6");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, std::make_tuple(5, 6.6)); CHECK_EQ(tup, std::make_tuple(5, 6.6));
} }
{ {
auto tup = c.convert<void, T, double>("junk;5;6.6", ";"); auto tup = c.convert<void, int, double>("junk;5;6.6", ";");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, std::make_tuple(5, 6.6)); CHECK_EQ(tup, std::make_tuple(5, 6.6));
} }
{ {
auto tup = c.convert<void, std::optional<T>, double>("junk;5;6.6", ";"); auto tup =
c.convert<void, std::optional<int>, double>("junk;5;6.6", ";");
REQUIRE(c.valid()); REQUIRE(c.valid());
REQUIRE(std::get<0>(tup).has_value()); REQUIRE(std::get<0>(tup).has_value());
CHECK_EQ(tup, std::make_tuple(5, 6.6)); CHECK_EQ(tup, std::make_tuple(5, 6.6));
} }
{ {
auto tup = auto tup =
c.convert<void, std::optional<T>, double>("junk;5.4;6.6", ";"); c.convert<void, std::optional<int>, double>("junk;5.4;6.6", ";");
REQUIRE(c.valid()); REQUIRE(c.valid());
REQUIRE_FALSE(std::get<0>(tup).has_value()); REQUIRE_FALSE(std::get<0>(tup).has_value());
CHECK_EQ(tup, std::make_tuple(std::optional<T>{}, 6.6)); CHECK_EQ(tup, std::make_tuple(std::optional<int>{}, 6.6));
} }
{ {
auto tup = auto tup =
c.convert<void, std::variant<T, double>, double>("junk;5;6.6", ";"); c.convert<void, std::variant<int, double>, double>("junk;5;6.6",
";");
REQUIRE(c.valid()); REQUIRE(c.valid());
REQUIRE(std::holds_alternative<T>(std::get<0>(tup))); REQUIRE(std::holds_alternative<int>(std::get<0>(tup)));
CHECK_EQ(tup, std::make_tuple(std::variant<T, double>{5}, 6.6)); CHECK_EQ(tup, std::make_tuple(std::variant<int, double>{5}, 6.6));
} }
{ {
auto tup = auto tup =
c.convert<void, std::variant<T, double>, double>("junk;5.5;6.6", c.convert<void, std::variant<int, double>, double>("junk;5.5;6.6",
";"); ";");
REQUIRE(c.valid()); REQUIRE(c.valid());
REQUIRE(std::holds_alternative<double>(std::get<0>(tup))); REQUIRE(std::holds_alternative<double>(std::get<0>(tup)));
CHECK_EQ(tup, std::make_tuple(std::variant<T, double>{5.5}, 6.6)); CHECK_EQ(tup, std::make_tuple(std::variant<int, double>{5.5}, 6.6));
} }
{ {
auto tup = c.convert<void, std::string_view, double, auto tup = c.convert<void, std::string_view, double,
@ -138,12 +140,11 @@ TEST_CASE_TEMPLATE("converter test valid conversions", T, int, ss::uint8) {
} }
} }
TEST_CASE_TEMPLATE("converter test valid conversions with exceptions", T, int, TEST_CASE("converter test valid conversions with exceptions") {
ss::uint8) {
ss::converter<ss::throw_on_error> c; ss::converter<ss::throw_on_error> c;
try { try {
auto tup = c.convert<T>("5"); auto tup = c.convert<int>("5");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, 5); CHECK_EQ(tup, 5);
} catch (ss::exception& e) { } catch (ss::exception& e) {
@ -151,7 +152,7 @@ TEST_CASE_TEMPLATE("converter test valid conversions with exceptions", T, int,
} }
try { try {
auto tup = c.convert<T, void>("5,junk"); auto tup = c.convert<int, void>("5,junk");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, 5); CHECK_EQ(tup, 5);
} catch (ss::exception& e) { } catch (ss::exception& e) {
@ -159,7 +160,7 @@ TEST_CASE_TEMPLATE("converter test valid conversions with exceptions", T, int,
} }
try { try {
auto tup = c.convert<void, T>("junk,5"); auto tup = c.convert<void, int>("junk,5");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, 5); CHECK_EQ(tup, 5);
} catch (ss::exception& e) { } catch (ss::exception& e) {
@ -167,7 +168,7 @@ TEST_CASE_TEMPLATE("converter test valid conversions with exceptions", T, int,
} }
try { try {
auto tup = c.convert<T, void, void>("5\njunk\njunk", "\n"); auto tup = c.convert<int, void, void>("5\njunk\njunk", "\n");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, 5); CHECK_EQ(tup, 5);
} catch (ss::exception& e) { } catch (ss::exception& e) {
@ -175,7 +176,7 @@ TEST_CASE_TEMPLATE("converter test valid conversions with exceptions", T, int,
} }
try { try {
auto tup = c.convert<void, T, void>("junk 5 junk", " "); auto tup = c.convert<void, int, void>("junk 5 junk", " ");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, 5); CHECK_EQ(tup, 5);
} catch (ss::exception& e) { } catch (ss::exception& e) {
@ -183,7 +184,7 @@ TEST_CASE_TEMPLATE("converter test valid conversions with exceptions", T, int,
} }
try { try {
auto tup = c.convert<void, void, T>("junk\tjunk\t5", "\t"); auto tup = c.convert<void, void, int>("junk\tjunk\t5", "\t");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, 5); CHECK_EQ(tup, 5);
} catch (ss::exception& e) { } catch (ss::exception& e) {
@ -192,7 +193,7 @@ TEST_CASE_TEMPLATE("converter test valid conversions with exceptions", T, int,
try { try {
auto tup = auto tup =
c.convert<void, void, std::optional<T>>("junk\tjunk\t5", "\t"); c.convert<void, void, std::optional<int>>("junk\tjunk\t5", "\t");
REQUIRE(c.valid()); REQUIRE(c.valid());
REQUIRE(tup.has_value()); REQUIRE(tup.has_value());
CHECK_EQ(tup, 5); CHECK_EQ(tup, 5);
@ -201,7 +202,7 @@ TEST_CASE_TEMPLATE("converter test valid conversions with exceptions", T, int,
} }
try { try {
auto tup = c.convert<T, double, void>("5,6.6,junk"); auto tup = c.convert<int, double, void>("5,6.6,junk");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, std::make_tuple(5, 6.6)); CHECK_EQ(tup, std::make_tuple(5, 6.6));
} catch (ss::exception& e) { } catch (ss::exception& e) {
@ -209,7 +210,7 @@ TEST_CASE_TEMPLATE("converter test valid conversions with exceptions", T, int,
} }
try { try {
auto tup = c.convert<T, void, double>("5,junk,6.6"); auto tup = c.convert<int, void, double>("5,junk,6.6");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, std::make_tuple(5, 6.6)); CHECK_EQ(tup, std::make_tuple(5, 6.6));
} catch (ss::exception& e) { } catch (ss::exception& e) {
@ -217,7 +218,7 @@ TEST_CASE_TEMPLATE("converter test valid conversions with exceptions", T, int,
} }
try { try {
auto tup = c.convert<void, T, double>("junk;5;6.6", ";"); auto tup = c.convert<void, int, double>("junk;5;6.6", ";");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, std::make_tuple(5, 6.6)); CHECK_EQ(tup, std::make_tuple(5, 6.6));
} catch (ss::exception& e) { } catch (ss::exception& e) {
@ -225,7 +226,8 @@ TEST_CASE_TEMPLATE("converter test valid conversions with exceptions", T, int,
} }
try { try {
auto tup = c.convert<void, std::optional<T>, double>("junk;5;6.6", ";"); auto tup =
c.convert<void, std::optional<int>, double>("junk;5;6.6", ";");
REQUIRE(c.valid()); REQUIRE(c.valid());
REQUIRE(std::get<0>(tup).has_value()); REQUIRE(std::get<0>(tup).has_value());
CHECK_EQ(tup, std::make_tuple(5, 6.6)); CHECK_EQ(tup, std::make_tuple(5, 6.6));
@ -235,31 +237,32 @@ TEST_CASE_TEMPLATE("converter test valid conversions with exceptions", T, int,
try { try {
auto tup = auto tup =
c.convert<void, std::optional<T>, double>("junk;5.4;6.6", ";"); c.convert<void, std::optional<int>, double>("junk;5.4;6.6", ";");
REQUIRE(c.valid()); REQUIRE(c.valid());
REQUIRE_FALSE(std::get<0>(tup).has_value()); REQUIRE_FALSE(std::get<0>(tup).has_value());
CHECK_EQ(tup, std::make_tuple(std::optional<T>{}, 6.6)); CHECK_EQ(tup, std::make_tuple(std::optional<int>{}, 6.6));
} catch (ss::exception& e) { } catch (ss::exception& e) {
FAIL(std::string{e.what()}); FAIL(std::string{e.what()});
} }
try { try {
auto tup = auto tup =
c.convert<void, std::variant<T, double>, double>("junk;5;6.6", ";"); c.convert<void, std::variant<int, double>, double>("junk;5;6.6",
";");
REQUIRE(c.valid()); REQUIRE(c.valid());
REQUIRE(std::holds_alternative<T>(std::get<0>(tup))); REQUIRE(std::holds_alternative<int>(std::get<0>(tup)));
CHECK_EQ(tup, std::make_tuple(std::variant<T, double>{5}, 6.6)); CHECK_EQ(tup, std::make_tuple(std::variant<int, double>{5}, 6.6));
} catch (ss::exception& e) { } catch (ss::exception& e) {
FAIL(std::string{e.what()}); FAIL(std::string{e.what()});
} }
try { try {
auto tup = auto tup =
c.convert<void, std::variant<T, double>, double>("junk;5.5;6.6", c.convert<void, std::variant<int, double>, double>("junk;5.5;6.6",
";"); ";");
REQUIRE(c.valid()); REQUIRE(c.valid());
REQUIRE(std::holds_alternative<double>(std::get<0>(tup))); REQUIRE(std::holds_alternative<double>(std::get<0>(tup)));
CHECK_EQ(tup, std::make_tuple(std::variant<T, double>{5.5}, 6.6)); CHECK_EQ(tup, std::make_tuple(std::variant<int, double>{5.5}, 6.6));
} catch (ss::exception& e) { } catch (ss::exception& e) {
FAIL(std::string{e.what()}); FAIL(std::string{e.what()});
} }
@ -275,114 +278,110 @@ TEST_CASE_TEMPLATE("converter test valid conversions with exceptions", T, int,
} }
} }
TEST_CASE_TEMPLATE("converter test invalid conversions", T, int, ss::uint8) { TEST_CASE("converter test invalid conversions") {
ss::converter c; ss::converter c;
c.convert<T>(""); c.convert<int>("");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<T>("1", ""); c.convert<int>("1", "");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<T>("10", ""); c.convert<int>("10", "");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<T, void>(""); c.convert<int, void>("");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<T, void>(",junk"); c.convert<int, void>(",junk");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<void, T>("junk,"); c.convert<void, int>("junk,");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<T>("x"); c.convert<int>("x");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<T, void>("x"); c.convert<int, void>("x");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<T, void>("x,junk"); c.convert<int, void>("x,junk");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<void, T>("junk,x"); c.convert<void, int>("junk,x");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<void, std::variant<T, double>, double>("junk;.5.5;6", ";"); c.convert<void, std::variant<int, double>, double>("junk;.5.5;6", ";");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
} }
TEST_CASE_TEMPLATE("converter test invalid conversions with exceptions", T, int, TEST_CASE("converter test invalid conversions with exceptions") {
ss::uint8) {
ss::converter<ss::throw_on_error> c; ss::converter<ss::throw_on_error> c;
REQUIRE_EXCEPTION(c.convert<T>("")); REQUIRE_EXCEPTION(c.convert<int>(""));
REQUIRE_EXCEPTION(c.convert<T>("1", "")); REQUIRE_EXCEPTION(c.convert<int>("1", ""));
REQUIRE_EXCEPTION(c.convert<T>("10", "")); REQUIRE_EXCEPTION(c.convert<int>("10", ""));
REQUIRE_EXCEPTION(c.convert<T, void>("")); REQUIRE_EXCEPTION(c.convert<int, void>(""));
REQUIRE_EXCEPTION(c.convert<T, void>(",junk")); REQUIRE_EXCEPTION(c.convert<int, void>(",junk"));
REQUIRE_EXCEPTION(c.convert<void, T>("junk,")); REQUIRE_EXCEPTION(c.convert<void, int>("junk,"));
REQUIRE_EXCEPTION(c.convert<T>("x")); REQUIRE_EXCEPTION(c.convert<int>("x"));
REQUIRE_EXCEPTION(c.convert<T, void>("x")); REQUIRE_EXCEPTION(c.convert<int, void>("x"));
REQUIRE_EXCEPTION(c.convert<T, void>("x,junk")); REQUIRE_EXCEPTION(c.convert<int, void>("x,junk"));
REQUIRE_EXCEPTION(c.convert<void, T>("junk,x")); REQUIRE_EXCEPTION(c.convert<void, int>("junk,x"));
REQUIRE_EXCEPTION( REQUIRE_EXCEPTION(
c.convert<void, std::variant<T, double>, double>("junk;.5.5;6", ";")); c.convert<void, std::variant<int, double>, double>("junk;.5.5;6", ";"));
} }
TEST_CASE_TEMPLATE("converter test ss:ax restriction (all except)", T, int, TEST_CASE("converter test ss:ax restriction (all except)") {
ss::uint8) {
ss::converter c; ss::converter c;
c.convert<ss::ax<T, 0>>("0"); c.convert<ss::ax<int, 0>>("0");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<ss::ax<T, 0, 1, 2>>("1"); c.convert<ss::ax<int, 0, 1, 2>>("1");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<void, char, ss::ax<T, 0, 1, 2>>("junk,c,1"); c.convert<void, char, ss::ax<int, 0, 1, 2>>("junk,c,1");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<ss::ax<T, 1>, char>("1,c"); c.convert<ss::ax<int, 1>, char>("1,c");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
{ {
T tup = c.convert<ss::ax<T, 1>>("3"); int tup = c.convert<ss::ax<int, 1>>("3");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, 3); CHECK_EQ(tup, 3);
} }
{ {
std::tuple<char, T> tup = c.convert<char, ss::ax<T, 1>>("c,3"); std::tuple<char, int> tup = c.convert<char, ss::ax<int, 1>>("c,3");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, std::make_tuple('c', 3)); CHECK_EQ(tup, std::make_tuple('c', 3));
} }
{ {
std::tuple<T, char> tup = c.convert<ss::ax<T, 1>, char>("3,c"); std::tuple<int, char> tup = c.convert<ss::ax<int, 1>, char>("3,c");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, std::make_tuple(3, 'c')); CHECK_EQ(tup, std::make_tuple(3, 'c'));
} }
} }
TEST_CASE_TEMPLATE( TEST_CASE("converter test ss:ax restriction (all except) with exceptions") {
"converter test ss:ax restriction (all except) with exceptions", T, int,
ss::uint8) {
ss::converter<ss::throw_on_error> c; ss::converter<ss::throw_on_error> c;
REQUIRE_EXCEPTION(c.convert<ss::ax<T, 0>>("0")); REQUIRE_EXCEPTION(c.convert<ss::ax<int, 0>>("0"));
REQUIRE_EXCEPTION(c.convert<ss::ax<T, 0, 1, 2>>("1")); REQUIRE_EXCEPTION(c.convert<ss::ax<int, 0, 1, 2>>("1"));
REQUIRE_EXCEPTION(c.convert<void, char, ss::ax<T, 0, 1, 2>>("junk,c,1")); REQUIRE_EXCEPTION(c.convert<void, char, ss::ax<int, 0, 1, 2>>("junk,c,1"));
REQUIRE_EXCEPTION(c.convert<ss::ax<T, 1>, char>("1,c")); REQUIRE_EXCEPTION(c.convert<ss::ax<int, 1>, char>("1,c"));
try { try {
{ {
T tup = c.convert<ss::ax<T, 1>>("3"); int tup = c.convert<ss::ax<int, 1>>("3");
CHECK_EQ(tup, 3); CHECK_EQ(tup, 3);
} }
{ {
std::tuple<char, T> tup = c.convert<char, ss::ax<T, 1>>("c,3"); std::tuple<char, int> tup = c.convert<char, ss::ax<int, 1>>("c,3");
CHECK_EQ(tup, std::make_tuple('c', 3)); CHECK_EQ(tup, std::make_tuple('c', 3));
} }
{ {
std::tuple<T, char> tup = c.convert<ss::ax<T, 1>, char>("3,c"); std::tuple<int, char> tup = c.convert<ss::ax<int, 1>, char>("3,c");
CHECK_EQ(tup, std::make_tuple(3, 'c')); CHECK_EQ(tup, std::make_tuple(3, 'c'));
} }
} catch (ss::exception& e) { } catch (ss::exception& e) {
@ -457,68 +456,65 @@ TEST_CASE("converter test ss:nx restriction (none except) with exceptions") {
} }
} }
TEST_CASE_TEMPLATE("converter test ss:ir restriction (in range)", T, int, TEST_CASE("converter test ss:ir restriction (in range)") {
ss::uint8) {
ss::converter c; ss::converter c;
c.convert<ss::ir<T, 0, 2>>("3"); c.convert<ss::ir<int, 0, 2>>("3");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<char, ss::ir<T, 4, 69>>("c,3"); c.convert<char, ss::ir<int, 4, 69>>("c,3");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<ss::ir<T, 1, 2>, char>("3,c"); c.convert<ss::ir<int, 1, 2>, char>("3,c");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
{ {
auto tup = c.convert<ss::ir<T, 1, 5>>("3"); auto tup = c.convert<ss::ir<int, 1, 5>>("3");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, 3); CHECK_EQ(tup, 3);
} }
{ {
auto tup = c.convert<ss::ir<T, 0, 2>>("2"); auto tup = c.convert<ss::ir<int, 0, 2>>("2");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, 2); CHECK_EQ(tup, 2);
} }
{ {
auto tup = c.convert<char, void, ss::ir<T, 0, 1>>("c,junk,1"); auto tup = c.convert<char, void, ss::ir<int, 0, 1>>("c,junk,1");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, std::make_tuple('c', 1)); CHECK_EQ(tup, std::make_tuple('c', 1));
} }
{ {
auto tup = c.convert<ss::ir<T, 1, 20>, char>("1,c"); auto tup = c.convert<ss::ir<int, 1, 20>, char>("1,c");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, std::make_tuple(1, 'c')); CHECK_EQ(tup, std::make_tuple(1, 'c'));
} }
} }
TEST_CASE_TEMPLATE( TEST_CASE("converter test ss:ir restriction (in range) with exceptions") {
"converter test ss:ir restriction (in range) with exceptions", T, int,
ss::uint8) {
ss::converter<ss::throw_on_error> c; ss::converter<ss::throw_on_error> c;
REQUIRE_EXCEPTION(c.convert<ss::ir<T, 0, 2>>("3")); REQUIRE_EXCEPTION(c.convert<ss::ir<int, 0, 2>>("3"));
REQUIRE_EXCEPTION(c.convert<char, ss::ir<T, 4, 69>>("c,3")); REQUIRE_EXCEPTION(c.convert<char, ss::ir<int, 4, 69>>("c,3"));
REQUIRE_EXCEPTION(c.convert<ss::ir<T, 1, 2>, char>("3,c")); REQUIRE_EXCEPTION(c.convert<ss::ir<int, 1, 2>, char>("3,c"));
try { try {
{ {
auto tup = c.convert<ss::ir<T, 1, 5>>("3"); auto tup = c.convert<ss::ir<int, 1, 5>>("3");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, 3); CHECK_EQ(tup, 3);
} }
{ {
auto tup = c.convert<ss::ir<T, 0, 2>>("2"); auto tup = c.convert<ss::ir<int, 0, 2>>("2");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, 2); CHECK_EQ(tup, 2);
} }
{ {
auto tup = c.convert<char, void, ss::ir<T, 0, 1>>("c,junk,1"); auto tup = c.convert<char, void, ss::ir<int, 0, 1>>("c,junk,1");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, std::make_tuple('c', 1)); CHECK_EQ(tup, std::make_tuple('c', 1));
} }
{ {
auto tup = c.convert<ss::ir<T, 1, 20>, char>("1,c"); auto tup = c.convert<ss::ir<int, 1, 20>, char>("1,c");
REQUIRE(c.valid()); REQUIRE(c.valid());
CHECK_EQ(tup, std::make_tuple(1, 'c')); CHECK_EQ(tup, std::make_tuple(1, 'c'));
} }
@ -982,3 +978,4 @@ TEST_CASE("converter test invalid split conversions with exceptions") {
buff(R"(just,some,2,"strings\")"))); buff(R"(just,some,2,"strings\")")));
CHECK(c.unterminated_quote()); CHECK(c.unterminated_quote());
} }

168
test/test_extractions.cpp
View File

@ -2,16 +2,6 @@
#include <algorithm> #include <algorithm>
#include <ss/extract.hpp> #include <ss/extract.hpp>
template <typename T>
struct std::numeric_limits<ss::numeric_wrapper<T>>
: public std::numeric_limits<T> {};
template <typename T>
struct std::is_signed<ss::numeric_wrapper<T>> : public std::is_signed<T> {};
template <typename T>
struct std::is_unsigned<ss::numeric_wrapper<T>> : public std::is_unsigned<T> {};
TEST_CASE("testing extract functions for floating point values") { TEST_CASE("testing extract functions for floating point values") {
CHECK_FLOATING_CONVERSION(123.456, float); CHECK_FLOATING_CONVERSION(123.456, float);
CHECK_FLOATING_CONVERSION(123.456, double); CHECK_FLOATING_CONVERSION(123.456, double);
@ -32,18 +22,18 @@ TEST_CASE("testing extract functions for floating point values") {
#define CHECK_DECIMAL_CONVERSION(input, type) \ #define CHECK_DECIMAL_CONVERSION(input, type) \
{ \ { \
std::string s = #input; \ std::string s = #input; \
type value; \ auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size()); \
bool valid = ss::extract(s.c_str(), s.c_str() + s.size(), value); \ REQUIRE(t.has_value()); \
REQUIRE(valid); \ CHECK_EQ(t.value(), type(input)); \
CHECK_EQ(value, type(input)); \
} \ } \
{ \
/* check negative too */ \ /* check negative too */ \
if (std::is_signed_v<type>) { \ if (std::is_signed_v<type>) { \
std::string s = std::string("-") + #input; \ auto s = std::string("-") + #input; \
type value; \ auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size()); \
bool valid = ss::extract(s.c_str(), s.c_str() + s.size(), value); \ REQUIRE(t.has_value()); \
REQUIRE(valid); \ CHECK_EQ(t.value(), type(-input)); \
CHECK_EQ(value, type(-input)); \ } \
} }
using us = unsigned short; using us = unsigned short;
@ -53,8 +43,6 @@ using ll = long long;
using ull = unsigned long long; using ull = unsigned long long;
TEST_CASE("extract test functions for decimal values") { TEST_CASE("extract test functions for decimal values") {
CHECK_DECIMAL_CONVERSION(12, ss::int8);
CHECK_DECIMAL_CONVERSION(12, ss::uint8);
CHECK_DECIMAL_CONVERSION(1234, short); CHECK_DECIMAL_CONVERSION(1234, short);
CHECK_DECIMAL_CONVERSION(1234, us); CHECK_DECIMAL_CONVERSION(1234, us);
CHECK_DECIMAL_CONVERSION(1234, int); CHECK_DECIMAL_CONVERSION(1234, int);
@ -66,9 +54,6 @@ TEST_CASE("extract test functions for decimal values") {
} }
TEST_CASE("extract test functions for numbers with invalid inputs") { TEST_CASE("extract test functions for numbers with invalid inputs") {
// negative unsigned value for numeric_wrapper
CHECK_INVALID_CONVERSION("-12", ss::uint8);
// negative unsigned value // negative unsigned value
CHECK_INVALID_CONVERSION("-1234", ul); CHECK_INVALID_CONVERSION("-1234", ul);
@ -85,38 +70,46 @@ TEST_CASE("extract test functions for numbers with invalid inputs") {
CHECK_INVALID_CONVERSION("", int); CHECK_INVALID_CONVERSION("", int);
} }
TEST_CASE_TEMPLATE( #define CHECK_OUT_OF_RANGE_CONVERSION(type) \
"extract test functions for numbers with out of range inputs", T, short, us, { \
int, ui, long, ul, ll, ull, ss::uint8) { std::string s = std::to_string(std::numeric_limits<type>::max()); \
{ auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size()); \
std::string s = std::to_string(std::numeric_limits<T>::max()); CHECK(t.has_value()); \
auto t = ss::to_num<T>(s.c_str(), s.c_str() + s.size()); for (auto& i : s) { \
CHECK(t.has_value()); if (i != '9' && i != '.') { \
for (auto& i : s) { i = '9'; \
if (i != '9' && i != '.') { break; \
i = '9'; } \
break; } \
} t = ss::to_num<type>(s.c_str(), s.c_str() + s.size()); \
} CHECK_FALSE(t.has_value()); \
t = ss::to_num<T>(s.c_str(), s.c_str() + s.size()); } \
CHECK_FALSE(t.has_value()); { \
} std::string s = std::to_string(std::numeric_limits<type>::min()); \
{ auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size()); \
std::string s = std::to_string(std::numeric_limits<T>::min()); CHECK(t.has_value()); \
auto t = ss::to_num<T>(s.c_str(), s.c_str() + s.size()); for (auto& i : s) { \
CHECK(t.has_value()); if (std::is_signed_v<type> && i != '9' && i != '.') { \
for (auto& i : s) { i = '9'; \
if (std::is_signed_v<T> && i != '9' && i != '.') { break; \
i = '9'; } else if (std::is_unsigned_v<type>) { \
break; s = "-1"; \
} else if (std::is_unsigned_v<T>) { break; \
s = "-1"; } \
break; } \
} t = ss::to_num<type>(s.c_str(), s.c_str() + s.size()); \
} CHECK_FALSE(t.has_value()); \
t = ss::to_num<T>(s.c_str(), s.c_str() + s.size());
CHECK_FALSE(t.has_value());
} }
TEST_CASE("extract test functions for numbers with out of range inputs") {
CHECK_OUT_OF_RANGE_CONVERSION(short);
CHECK_OUT_OF_RANGE_CONVERSION(us);
CHECK_OUT_OF_RANGE_CONVERSION(int);
CHECK_OUT_OF_RANGE_CONVERSION(ui);
CHECK_OUT_OF_RANGE_CONVERSION(long);
CHECK_OUT_OF_RANGE_CONVERSION(ul);
CHECK_OUT_OF_RANGE_CONVERSION(ll);
CHECK_OUT_OF_RANGE_CONVERSION(ull);
} }
TEST_CASE("extract test functions for boolean values") { TEST_CASE("extract test functions for boolean values") {
@ -149,12 +142,12 @@ TEST_CASE("extract test functions for char values") {
} }
} }
TEST_CASE_TEMPLATE("extract test functions for std::optional", T, int, TEST_CASE("extract test functions for std::optional") {
ss::int8) { for (const auto& [i, s] :
for (const auto& [i, s] : {std::pair<std::optional<T>, std::string>{1, "1"}, {std::pair<std::optional<int>, std::string>{1, "1"},
{69, "69"}, {69, "69"},
{-4, "-4"}}) { {-4, "-4"}}) {
std::optional<T> v; std::optional<int> v;
REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), v)); REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
REQUIRE(v.has_value()); REQUIRE(v.has_value());
CHECK_EQ(*v, i); CHECK_EQ(*v, i);
@ -171,7 +164,7 @@ TEST_CASE_TEMPLATE("extract test functions for std::optional", T, int,
} }
for (const std::string s : {"aa", "xxx", ""}) { for (const std::string s : {"aa", "xxx", ""}) {
std::optional<T> v; std::optional<int> v;
REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), v)); REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
CHECK_FALSE(v.has_value()); CHECK_FALSE(v.has_value());
} }
@ -183,57 +176,56 @@ TEST_CASE_TEMPLATE("extract test functions for std::optional", T, int,
} }
} }
TEST_CASE_TEMPLATE("extract test functions for std::variant", T, int, TEST_CASE("extract test functions for std::variant") {
ss::uint8) {
{ {
std::string s = "22"; std::string s = "22";
{ {
std::variant<T, double, std::string> var; std::variant<int, double, std::string> var;
REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var)); REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
CHECK_NOT_VARIANT(var, double); CHECK_NOT_VARIANT(var, double);
CHECK_NOT_VARIANT(var, std::string); CHECK_NOT_VARIANT(var, std::string);
REQUIRE_VARIANT(var, 22, T); REQUIRE_VARIANT(var, 22, int);
} }
{ {
std::variant<double, T, std::string> var; std::variant<double, int, std::string> var;
REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var)); REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
CHECK_NOT_VARIANT(var, T); CHECK_NOT_VARIANT(var, int);
CHECK_NOT_VARIANT(var, std::string); CHECK_NOT_VARIANT(var, std::string);
REQUIRE_VARIANT(var, 22, double); REQUIRE_VARIANT(var, 22, double);
} }
{ {
std::variant<std::string, double, T> var; std::variant<std::string, double, int> var;
REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var)); REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
CHECK_NOT_VARIANT(var, T); CHECK_NOT_VARIANT(var, int);
CHECK_NOT_VARIANT(var, double); CHECK_NOT_VARIANT(var, double);
REQUIRE_VARIANT(var, "22", std::string); REQUIRE_VARIANT(var, "22", std::string);
} }
{ {
std::variant<T> var; std::variant<int> var;
REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var)); REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
REQUIRE_VARIANT(var, 22, T); REQUIRE_VARIANT(var, 22, int);
} }
} }
{ {
std::string s = "22.2"; std::string s = "22.2";
{ {
std::variant<T, double, std::string> var; std::variant<int, double, std::string> var;
REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var)); REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
CHECK_NOT_VARIANT(var, T); CHECK_NOT_VARIANT(var, int);
CHECK_NOT_VARIANT(var, std::string); CHECK_NOT_VARIANT(var, std::string);
REQUIRE_VARIANT(var, 22.2, double); REQUIRE_VARIANT(var, 22.2, double);
} }
{ {
std::variant<double, T, std::string> var; std::variant<double, int, std::string> var;
REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var)); REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
CHECK_NOT_VARIANT(var, T); CHECK_NOT_VARIANT(var, int);
CHECK_NOT_VARIANT(var, std::string); CHECK_NOT_VARIANT(var, std::string);
REQUIRE_VARIANT(var, 22.2, double); REQUIRE_VARIANT(var, 22.2, double);
} }
{ {
std::variant<std::string, double, T> var; std::variant<std::string, double, int> var;
REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var)); REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
CHECK_NOT_VARIANT(var, T); CHECK_NOT_VARIANT(var, int);
CHECK_NOT_VARIANT(var, double); CHECK_NOT_VARIANT(var, double);
REQUIRE_VARIANT(var, "22.2", std::string); REQUIRE_VARIANT(var, "22.2", std::string);
} }
@ -241,45 +233,45 @@ TEST_CASE_TEMPLATE("extract test functions for std::variant", T, int,
{ {
std::string s = "2.2.2"; std::string s = "2.2.2";
{ {
std::variant<T, double, std::string> var; std::variant<int, double, std::string> var;
REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var)); REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
CHECK_NOT_VARIANT(var, T); CHECK_NOT_VARIANT(var, int);
CHECK_NOT_VARIANT(var, double); CHECK_NOT_VARIANT(var, double);
REQUIRE_VARIANT(var, "2.2.2", std::string); REQUIRE_VARIANT(var, "2.2.2", std::string);
} }
{ {
std::variant<double, std::string, T> var; std::variant<double, std::string, int> var;
REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var)); REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
CHECK_NOT_VARIANT(var, T); CHECK_NOT_VARIANT(var, int);
CHECK_NOT_VARIANT(var, double); CHECK_NOT_VARIANT(var, double);
REQUIRE_VARIANT(var, "2.2.2", std::string); REQUIRE_VARIANT(var, "2.2.2", std::string);
} }
{ {
std::variant<std::string, double, T> var; std::variant<std::string, double, int> var;
REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var)); REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
CHECK_NOT_VARIANT(var, T); CHECK_NOT_VARIANT(var, int);
CHECK_NOT_VARIANT(var, double); CHECK_NOT_VARIANT(var, double);
REQUIRE_VARIANT(var, "2.2.2", std::string); REQUIRE_VARIANT(var, "2.2.2", std::string);
} }
{ {
std::variant<T, double> var; std::variant<int, double> var;
REQUIRE_FALSE(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, T{}, T); REQUIRE_VARIANT(var, int{}, int);
CHECK_NOT_VARIANT(var, double); CHECK_NOT_VARIANT(var, double);
} }
{ {
std::variant<double, T> var; std::variant<double, int> var;
REQUIRE_FALSE(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); REQUIRE_VARIANT(var, double{}, double);
CHECK_NOT_VARIANT(var, T); CHECK_NOT_VARIANT(var, int);
} }
{ {
std::variant<T> var; std::variant<int> var;
REQUIRE_FALSE(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, T{}, T); REQUIRE_VARIANT(var, int{}, int);
} }
} }
} }

8
test/test_helpers.hpp
View File

@ -62,12 +62,12 @@ struct buffer {
[[maybe_unused]] inline buffer buff; [[maybe_unused]] inline buffer buff;
[[maybe_unused]] std::string time_now_rand() { [[maybe_unused]] std::string time_now_rand() {
std::srand(std::time(nullptr)); srand(time(nullptr));
std::stringstream ss; std::stringstream ss;
auto t = std::time(nullptr); auto t = std::time(nullptr);
auto tm = *std::localtime(&t); auto tm = *std::localtime(&t);
ss << std::put_time(&tm, "%d%m%Y%H%M%S"); ss << std::put_time(&tm, "%d%m%Y%H%M%S");
std::srand(std::time(nullptr)); srand(time(nullptr));
return ss.str() + std::to_string(rand()); return ss.str() + std::to_string(rand());
} }
@ -78,8 +78,8 @@ struct unique_file_name {
unique_file_name(const std::string& test) { unique_file_name(const std::string& test) {
do { do {
name = "ssp_test_" + test + "_" + std::to_string(i++) + "_" + name = "ssp_test_" + test + "_" + std::to_string(i++) +
time_now_rand() + "_file.csv"; "_" + time_now_rand() + "_file.csv";
} while (std::filesystem::exists(name)); } while (std::filesystem::exists(name));
} }

6
test/test_parser1_1.cpp
View File

@ -77,9 +77,9 @@ TEST_CASE_TEMPLATE("test position method", T, ParserOptionCombinations) {
if (!buff.empty()) { if (!buff.empty()) {
return buff[n]; return buff[n];
} else { } else {
auto file = std::fopen(f.name.c_str(), "r"); auto file = fopen(f.name.c_str(), "r");
std::fseek(file, n, SEEK_SET); fseek(file, n, SEEK_SET);
return static_cast<char>(std::fgetc(file)); return static_cast<char>(fgetc(file));
} }
}; };