xo-flatstring: + README + docs + test coverage

utest/flatstring.test.cpp

@@ -0,0 +1,131 @@
+/** @file flatstring.utest.cpp **/
+
+#include "xo/stringliteral/stringliteral.hpp"
+#include "xo/indentlog/scope.hpp"
+#include "xo/indentlog/print/tag.hpp"
+#include <catch2/catch.hpp>
+//#include <iostream>
+
+namespace xo {
+    using namespace std;
+
+    namespace ut {
+        template <typename String>
+        void
+        flatstring_runtime_tests(const String & str, const char * text) {
+            INFO(tostr(XTAG(str), XTAG(text)));
+
+            REQUIRE(str.fixed_capacity == strlen(text)+1);
+            REQUIRE(str.capacity() == strlen(text));
+            REQUIRE(str.size() == strlen(text));
+            REQUIRE(str.length() == strlen(text));
+            REQUIRE(strcmp(str.c_str(), text) == 0);
+            REQUIRE(strcmp(str, text) == 0);
+
+            /* verify range iteration visits contents in order */
+            {
+                size_t i = 0;
+                for (char ch : str) {
+                    INFO(XTAG(i));
+
+                    CHECK(ch == text[i]);
+
+                    ++i;
+                }
+            }
+        }
+
+        /* using macro here because template argument depends on size of literal C string,
+         * and we can't use such a string as a template argument.
+         *
+         * static_asserts: using these to verify that constexpr methods are being computed
+         * at compile time.
+         *
+         * 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};                              \
+            static_assert(name[0]==text[0]);                              \
+            static_assert(name.at(0)==text[0]);                           \
+            static_assert(name.empty() == true || name.empty() == false); \
+            static_assert(name.capacity() >= 0);                          \
+            static_assert(name.begin() != nullptr);                       \
+            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.size() >= 0);                              \
+            static_assert(name.c_str() != nullptr);                       \
+            static_assert((name <=> name) == 0);                          \
+            static_assert(name == name);                                  \
+            static_assert(name >= name);                                  \
+            static_assert(name <= name);                                  \
+            static_assert(!(name != name));                               \
+            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);                             \
+            static_assert(string_view(name) == string_view(name));        \
+
+
+
+        TEST_CASE("flatstring", "[flatstring][compile-time]") {
+            constexpr bool c_debug_flag = false;
+
+            // can get bits from /dev/random by uncommenting the 2nd line below
+            //uint64_t seed = xxx;
+            //rng::Seed<xoshio256ss> seed;
+
+            //auto rng = xo::rng::xoshiro256ss(seed);
+
+            scope log(XO_DEBUG2(c_debug_flag, "TEST_CASE.flatstring"));
+            //log && log("(A)", xtag("foo", foo));
+
+            /* 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!");
+
+            static_assert(s1 != s2);
+            static_assert(s2 != s3);
+            static_assert(s3 != s4);
+            static_assert(s4 != s5);
+            static_assert(s12 != s13);
+
+            static_assert(s1 < s2);
+            static_assert(s2 < s3);
+            static_assert(s3 < s4);
+            static_assert(s4 < s5);
+            static_assert(s12 < s13);
+
+            static_assert(s2 > s1);
+            static_assert(s3 > s2);
+            static_assert(s4 > s3);
+            static_assert(s5 > s4);
+            static_assert(s13 > s12);
+        } /*TEST_CASE(flatstring)*/
+
+    } /*namespace ut*/
+} /*namespace xo*/
+
+/** end flatstring.utest.cpp **/