xo-flatstring: bugfixes + utest expansion
This commit is contained in:
parent
0ca71b16b9
commit
1d18f11678
3 changed files with 467 additions and 46 deletions
|
|
@ -3,13 +3,236 @@
|
|||
#include "xo/flatstring/flatstring.hpp"
|
||||
#include "xo/indentlog/scope.hpp"
|
||||
#include "xo/indentlog/print/tag.hpp"
|
||||
#include "xo/indentlog/print/hex.hpp"
|
||||
#include <catch2/catch.hpp>
|
||||
#include <type_traits>
|
||||
//#include <iostream>
|
||||
|
||||
namespace xo {
|
||||
using namespace std;
|
||||
|
||||
namespace ut {
|
||||
template <typename String>
|
||||
void
|
||||
flatstring_iter_tests(const String & str, const char * text) {
|
||||
size_t n = ::strlen(text);
|
||||
|
||||
REQUIRE(str.size() == n);
|
||||
|
||||
/* verify range iteration visits contents in order */
|
||||
{
|
||||
size_t i = 0;
|
||||
for (char ch : str) {
|
||||
INFO(XTAG(i));
|
||||
|
||||
CHECK(ch == text[i]);
|
||||
|
||||
++i;
|
||||
}
|
||||
|
||||
REQUIRE(i == n);
|
||||
}
|
||||
|
||||
String str_copy;
|
||||
|
||||
REQUIRE(str_copy.capacity() == str.capacity());
|
||||
REQUIRE(str_copy.empty());
|
||||
|
||||
/* verify const iteration visits string elements in order */
|
||||
{
|
||||
str_copy = str;
|
||||
REQUIRE(str_copy == str);
|
||||
|
||||
size_t i = 0;
|
||||
|
||||
for (auto ix = str_copy.cbegin(), end_ix = str_copy.cend(); ix != end_ix; ++ix) {
|
||||
INFO(XTAG(i));
|
||||
|
||||
char ch = *ix;
|
||||
|
||||
CHECK(ch == text[i]);
|
||||
|
||||
++i;
|
||||
}
|
||||
|
||||
REQUIRE(i == n);
|
||||
}
|
||||
|
||||
/* verify string overwrite through iterator */
|
||||
{
|
||||
size_t i = 0;
|
||||
|
||||
for (auto ix = str_copy.begin(), end_ix = str_copy.end(); ix != end_ix; ++ix) {
|
||||
INFO(XTAG(i));
|
||||
|
||||
*ix = ('a' + i);
|
||||
|
||||
++i;
|
||||
}
|
||||
|
||||
REQUIRE(i == n);
|
||||
|
||||
for (i = 0; i < n; ++i) {
|
||||
CHECK(str_copy[i] == ('a' + i));
|
||||
}
|
||||
}
|
||||
|
||||
/* verify reverse iteration visits string elements in reverse order */
|
||||
{
|
||||
str_copy = str;
|
||||
REQUIRE(str_copy == str);
|
||||
|
||||
size_t i = 0;
|
||||
|
||||
for (auto ix = str_copy.rbegin(), end_ix = str_copy.rend(); ix != end_ix; ++ix) {
|
||||
INFO(XTAG(i));
|
||||
|
||||
char ch = *ix;
|
||||
|
||||
CHECK(ch == text[n-1-i]);
|
||||
|
||||
++i;
|
||||
}
|
||||
|
||||
REQUIRE(i == n);
|
||||
}
|
||||
|
||||
/* verify string overwrite through reverse iterator */
|
||||
{
|
||||
str_copy = str;
|
||||
REQUIRE(str_copy == str);
|
||||
|
||||
size_t i = 0;
|
||||
|
||||
for (auto ix = str_copy.rbegin(), end_ix = str_copy.rend(); ix != end_ix; ++ix) {
|
||||
INFO(XTAG(i));
|
||||
|
||||
*ix = ('a' + i);
|
||||
|
||||
++i;
|
||||
}
|
||||
|
||||
REQUIRE(i == n);
|
||||
|
||||
for (i = 0; i< n; ++i) {
|
||||
CHECK(str_copy[n-1-i] == ('a' + i));
|
||||
}
|
||||
}
|
||||
|
||||
/* verify const reverse iteration visits string elements in reverse order */
|
||||
{
|
||||
str_copy = str;
|
||||
REQUIRE(str_copy == str);
|
||||
|
||||
size_t i = 0;
|
||||
|
||||
for (auto ix = str_copy.crbegin(), end_ix = str_copy.crend(); ix != end_ix; ++ix) {
|
||||
INFO(XTAG(i));
|
||||
|
||||
char ch = *ix;
|
||||
|
||||
CHECK(ch == text[n-1-i]);
|
||||
|
||||
++i;
|
||||
}
|
||||
|
||||
REQUIRE(i == n);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename String1, typename String2>
|
||||
void
|
||||
flatstring_assign_tests(const String1 & str, const char * text,
|
||||
const String2 & str2, const char * text2) {
|
||||
INFO(tostr(XTAG(str), XTAG(text), XTAG(text2)));
|
||||
|
||||
String1 str_copy;
|
||||
|
||||
str_copy.assign(str.c_str());
|
||||
REQUIRE(str_copy == str);
|
||||
|
||||
/* verify assignment from C-style string **/
|
||||
{
|
||||
str_copy.assign(text2);
|
||||
|
||||
INFO(tostr(XTAG(str_copy), XTAG(text2)));
|
||||
|
||||
REQUIRE(::strncmp(str_copy.c_str(), text2,
|
||||
std::min(::strlen(text2)+1, str_copy.capacity())) == 0);
|
||||
}
|
||||
|
||||
/* verify assignment from prefix of C-style string */
|
||||
for (size_t prefix = 0, n_prefix = ::strlen(text2); prefix < n_prefix; ++prefix)
|
||||
{
|
||||
str_copy.assign(str);
|
||||
|
||||
REQUIRE(str_copy == str);
|
||||
|
||||
str_copy.assign(text2, prefix);
|
||||
|
||||
INFO(tostr(XTAG(prefix), XTAG(str_copy), XTAG(text2)));
|
||||
|
||||
if (prefix == 0) {
|
||||
REQUIRE(str_copy.empty());
|
||||
} else {
|
||||
REQUIRE(str_copy.size() == std::min(prefix, str_copy.capacity()));
|
||||
REQUIRE(::strncmp(str_copy.c_str(), text2,
|
||||
std::min(prefix, str_copy.capacity())) == 0);
|
||||
}
|
||||
}
|
||||
|
||||
/* verify assignment from substring */
|
||||
String2 text2_copy;
|
||||
text2_copy.assign(text2);
|
||||
|
||||
INFO(tostr(XTAG(text2_copy)));
|
||||
|
||||
for (size_t i = 0, n = text2_copy.size(); i < n; ++i) {
|
||||
/* deliberately letting j extend beyond the end of text2_copy */
|
||||
for (size_t j = i; j < n+10; ++j) {
|
||||
INFO(tostr(XTAG(n), XTAG(i), XTAG(j)));
|
||||
|
||||
str_copy.assign(str);
|
||||
|
||||
REQUIRE(str_copy == str);
|
||||
|
||||
str_copy.assign(text2_copy, i, j-i);
|
||||
|
||||
INFO(tostr(XTAG(str_copy.fixed_capacity), XTAG(str_copy)));
|
||||
|
||||
REQUIRE(str_copy.size() == std::min(j-i,
|
||||
std::min(text2_copy.size()-i,
|
||||
str_copy.capacity())));
|
||||
REQUIRE(::strncmp(str_copy.c_str(), text2_copy.c_str() + i,
|
||||
std::min(j-i, str_copy.capacity())) == 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template <typename String1, typename String2>
|
||||
void
|
||||
flatstring_concat_tests(const String1 & str, const char * text,
|
||||
const String2 & str2, const char * text2)
|
||||
{
|
||||
flatstring<String1::fixed_capacity + String2::fixed_capacity - 1> concat;
|
||||
|
||||
REQUIRE(concat.empty());
|
||||
|
||||
/* forcing concat to occur at runtime */
|
||||
{
|
||||
concat = flatstring_concat(str, str2);
|
||||
auto req_str = string(text) + string(text2);
|
||||
|
||||
REQUIRE(::strcmp(concat.c_str(), req_str.c_str()) == 0);
|
||||
}
|
||||
{
|
||||
concat = flatstring_concat(str2, str);
|
||||
auto req_str = string(text2) + string(text);
|
||||
|
||||
REQUIRE(::strcmp(concat.c_str(), req_str.c_str()) == 0);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename String>
|
||||
void
|
||||
flatstring_runtime_tests(const String & str, const char * text) {
|
||||
|
|
@ -22,16 +245,48 @@ namespace xo {
|
|||
REQUIRE(strcmp(str.c_str(), text) == 0);
|
||||
REQUIRE(strcmp(str, text) == 0);
|
||||
|
||||
/* verify range iteration visits contents in order */
|
||||
String str2 = str;
|
||||
|
||||
{
|
||||
string str3{str.str()};
|
||||
|
||||
REQUIRE(::strcmp(str3.c_str(), str.c_str()) == 0);
|
||||
}
|
||||
|
||||
REQUIRE(string_view(str2) == string_view(str));
|
||||
|
||||
{
|
||||
auto cmp = (str2 <=> str);
|
||||
REQUIRE(cmp == strong_ordering::equal);
|
||||
}
|
||||
|
||||
{
|
||||
bool cmp = (str2 == str);
|
||||
INFO(xtag("cmp", cmp));
|
||||
REQUIRE(str2 == str);
|
||||
|
||||
bool cmp2 = (str2 != str);
|
||||
REQUIRE(cmp2 != cmp);
|
||||
}
|
||||
|
||||
str2.clear();
|
||||
REQUIRE(str2.empty());
|
||||
|
||||
str2.assign(100, ' ');
|
||||
REQUIRE(str2.size() == str2.capacity());
|
||||
|
||||
/* verify entirely ' ' */
|
||||
{
|
||||
size_t i = 0;
|
||||
for (char ch : str) {
|
||||
for (char ch : str2) {
|
||||
INFO(XTAG(i));
|
||||
|
||||
CHECK(ch == text[i]);
|
||||
CHECK(ch == ' ');
|
||||
|
||||
++i;
|
||||
}
|
||||
|
||||
REQUIRE(i == str2.size());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -44,8 +299,9 @@ namespace xo {
|
|||
* REQUIRE() calls to do verification that relies on non-constexpr calls such as
|
||||
* strlen(), strcmp()
|
||||
*/
|
||||
# define LITERAL_TEST_BODY(name, text) \
|
||||
constexpr flatstring name{text}; \
|
||||
# define LITERAL_TEST_BODY(name, name2, text, text2) \
|
||||
constexpr flatstring name{text}; \
|
||||
constexpr flatstring name2{text2}; \
|
||||
static_assert(name[0]==text[0]); \
|
||||
static_assert(name.at(0)==text[0]); \
|
||||
static_assert(name.empty() == true || name.empty() == false); \
|
||||
|
|
@ -54,10 +310,10 @@ namespace xo {
|
|||
static_assert(name.end() != nullptr); \
|
||||
static_assert(name.cbegin() != nullptr); \
|
||||
static_assert(name.cend() != nullptr); \
|
||||
static_assert(name.rbegin() != nullptr); \
|
||||
static_assert(name.rend() != nullptr); \
|
||||
static_assert(name.crbegin() != nullptr); \
|
||||
static_assert(name.crend() != nullptr); \
|
||||
static_assert(name.crbegin()._has_pointer()); \
|
||||
static_assert(name.crend()._has_pointer()); \
|
||||
/*static_assert(name.rbegin() != nullptr);*/ \
|
||||
/*static_assert(!name.rend());*/ \
|
||||
static_assert(name.size() >= 0); \
|
||||
static_assert(name.c_str() != nullptr); \
|
||||
static_assert((name <=> name) == 0); \
|
||||
|
|
@ -68,14 +324,11 @@ namespace xo {
|
|||
static_assert(!(name > name)); \
|
||||
static_assert(!(name < name)); \
|
||||
flatstring_runtime_tests(name, text); \
|
||||
REQUIRE(name.fixed_capacity == strlen(text)+1); \
|
||||
REQUIRE(name.capacity() == strlen(text)); \
|
||||
REQUIRE(name.size() == strlen(text)); \
|
||||
REQUIRE(name.length() == strlen(text)); \
|
||||
REQUIRE(strcmp(name.c_str(), text) == 0); \
|
||||
REQUIRE(strcmp(name, text) == 0); \
|
||||
flatstring_iter_tests(name, text); \
|
||||
flatstring_assign_tests(name, text, name2, text2); \
|
||||
flatstring_concat_tests(name, text, name2, text2); \
|
||||
static_assert(string_view(name) == string_view(name)); \
|
||||
|
||||
/* end LITERAL_TEST_BODY */
|
||||
|
||||
|
||||
TEST_CASE("flatstring", "[flatstring][compile-time]") {
|
||||
|
|
@ -92,19 +345,21 @@ namespace xo {
|
|||
|
||||
/* mostly compile-time tests here */
|
||||
|
||||
LITERAL_TEST_BODY(s1, "h");
|
||||
LITERAL_TEST_BODY(s2, "he");
|
||||
LITERAL_TEST_BODY(s3, "hel");
|
||||
LITERAL_TEST_BODY(s4, "hell");
|
||||
LITERAL_TEST_BODY(s5, "hello");
|
||||
LITERAL_TEST_BODY(s6, "hello,");
|
||||
LITERAL_TEST_BODY(s7, "hello, ");
|
||||
LITERAL_TEST_BODY(s8, "hello, w");
|
||||
LITERAL_TEST_BODY(s9, "hello, wo");
|
||||
LITERAL_TEST_BODY(s10, "hello, wor");
|
||||
LITERAL_TEST_BODY(s11, "hello, worl");
|
||||
LITERAL_TEST_BODY(s12, "hello, world");
|
||||
LITERAL_TEST_BODY(s13, "hello, world!");
|
||||
LITERAL_TEST_BODY(s1, t1, "h", "abracadabra!");
|
||||
LITERAL_TEST_BODY(s2, t2, "he", "bracadabra!");
|
||||
LITERAL_TEST_BODY(s3, t3, "hel", "racadabra!");
|
||||
LITERAL_TEST_BODY(s4, t4, "hell", "acadabra!");
|
||||
LITERAL_TEST_BODY(s5, t5, "hello", "cadabra!");
|
||||
LITERAL_TEST_BODY(s6, t6, "hello,", "adabra!");
|
||||
LITERAL_TEST_BODY(s7, t7, "hello, ", "dabra!");
|
||||
LITERAL_TEST_BODY(s8, t8, "hello, w", "abra!");
|
||||
LITERAL_TEST_BODY(s9, t9, "hello, wo", "bra!");
|
||||
LITERAL_TEST_BODY(s10, t10, "hello, wor", "ra!");
|
||||
LITERAL_TEST_BODY(s11, t11, "hello, worl", "a!");
|
||||
LITERAL_TEST_BODY(s12, t12, "hello, world", "!");
|
||||
LITERAL_TEST_BODY(s13, t13, "hello, world!", "");
|
||||
|
||||
static_assert(s1 == s1);
|
||||
|
||||
static_assert(s1 != s2);
|
||||
static_assert(s2 != s3);
|
||||
|
|
@ -123,6 +378,26 @@ namespace xo {
|
|||
static_assert(s4 > s3);
|
||||
static_assert(s5 > s4);
|
||||
static_assert(s13 > s12);
|
||||
|
||||
/* concat */
|
||||
static_assert(flatstring_concat(s1,t1) == flatstring("habracadabra!"));
|
||||
|
||||
/* clear */
|
||||
auto s13_copy = s13;
|
||||
s13_copy.clear();
|
||||
|
||||
REQUIRE(s13_copy.empty());
|
||||
|
||||
constexpr auto s13_copy2 = s13;
|
||||
|
||||
static_assert(s13_copy2.size() == s13.size());
|
||||
|
||||
//cerr << "s13=[" << s13 << "] s13_copy2=[" << s13_copy2 << "]" << endl;
|
||||
//cerr << xtag("s13", hex_view(s13.c_str(), s13.c_str() + s13.capacity(), true)) << endl;
|
||||
//cerr << xtag("s13_copy2", hex_view(s13_copy2.c_str(), s13_copy2.c_str() + s13_copy2.capacity(), true)) << endl;
|
||||
|
||||
REQUIRE(s13_copy2 == s13);
|
||||
|
||||
} /*TEST_CASE(flatstring)*/
|
||||
|
||||
} /*namespace ut*/
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue