imported from "final" folder

.pio/libdeps/esp01_1m/FastLED/tests/test_str.cpp

@@ -0,0 +1,198 @@
+
+// g++ --std=c++11 test.cpp
+
+#include "test.h"
+
+#include "test.h"
+#include "fl/str.h"
+#include "fl/vector.h"
+#include "crgb.h"
+#include <sstream>
+
+#include "fl/namespace.h"
+
+using namespace fl;
+
+TEST_CASE("Str basic operations") {
+    SUBCASE("Construction and assignment") {
+        Str s1;
+        CHECK(s1.size() == 0);
+        CHECK(s1.c_str()[0] == '\0');
+
+        Str s2("hello");
+        CHECK(s2.size() == 5);
+        CHECK(strcmp(s2.c_str(), "hello") == 0);
+
+        Str s3 = s2;
+        CHECK(s3.size() == 5);
+        CHECK(strcmp(s3.c_str(), "hello") == 0);
+
+        s1 = "world";
+        CHECK(s1.size() == 5);
+        CHECK(strcmp(s1.c_str(), "world") == 0);
+    }
+
+    SUBCASE("Comparison operators") {
+        Str s1("hello");
+        Str s2("hello");
+        Str s3("world");
+
+        CHECK(s1 == s2);
+        CHECK(s1 != s3);
+    }
+
+    SUBCASE("Indexing") {
+        Str s("hello");
+        CHECK(s[0] == 'h');
+        CHECK(s[4] == 'o');
+        CHECK(s[5] == '\0');  // Null terminator
+    }
+
+    SUBCASE("Append") {
+        Str s("hello");
+        s.append(" world");
+        CHECK(s.size() == 11);
+        CHECK(strcmp(s.c_str(), "hello world") == 0);
+    }
+
+    SUBCASE("CRGB to Str") {
+        CRGB c(255, 0, 0);
+        Str s = c.toString();
+        CHECK_EQ(s, "CRGB(255,0,0)");
+    }
+
+    SUBCASE("Copy-on-write behavior") {
+        Str s1("hello");
+        Str s2 = s1;
+        s2.append(" world");
+        CHECK(strcmp(s1.c_str(), "hello") == 0);
+        CHECK(strcmp(s2.c_str(), "hello world") == 0);
+    }
+}
+
+
+TEST_CASE("Str::reserve") {
+    Str s;
+    s.reserve(10);
+    CHECK(s.size() == 0);
+    CHECK(s.capacity() >= 10);
+
+    s.reserve(5);
+    CHECK(s.size() == 0);
+    CHECK(s.capacity() >= 10);
+
+    s.reserve(500);
+    CHECK(s.size() == 0);
+    CHECK(s.capacity() >= 500);
+    // s << "hello";
+    s.append("hello");
+    CHECK(s.size() == 5);
+    CHECK_EQ(s, "hello");
+}
+
+TEST_CASE("Str with fl::FixedVector") {
+    fl::FixedVector<Str, 10> vec;
+    vec.push_back(Str("hello"));
+    vec.push_back(Str("world"));
+
+    CHECK(vec.size() == 2);
+    CHECK(strcmp(vec[0].c_str(), "hello") == 0);
+    CHECK(strcmp(vec[1].c_str(), "world") == 0);
+}
+
+TEST_CASE("Str with long strings") {
+    const char* long_string = "This is a very long string that exceeds the inline buffer size and should be allocated on the heap";
+    Str s(long_string);
+    CHECK(s.size() == strlen(long_string));
+    CHECK(strcmp(s.c_str(), long_string) == 0);
+
+    Str s2 = s;
+    CHECK(s2.size() == strlen(long_string));
+    CHECK(strcmp(s2.c_str(), long_string) == 0);
+
+    s2.append(" with some additional text");
+    CHECK(strcmp(s.c_str(), long_string) == 0);  // Original string should remain unchanged
+}
+
+TEST_CASE("Str overflowing inline data") {
+    SUBCASE("Construction with long string") {
+        std::string long_string(FASTLED_STR_INLINED_SIZE + 10, 'a');  // Create a string longer than the inline buffer
+        Str s(long_string.c_str());
+        CHECK(s.size() == long_string.length());
+        CHECK(strcmp(s.c_str(), long_string.c_str()) == 0);
+    }
+
+    SUBCASE("Appending to overflow") {
+        Str s("Short string");
+        std::string append_string(FASTLED_STR_INLINED_SIZE, 'b');  // String to append that will cause overflow
+        s.append(append_string.c_str());
+        CHECK(s.size() == strlen("Short string") + append_string.length());
+        CHECK(s[0] == 'S');
+        CHECK(s[s.size() - 1] == 'b');
+    }
+
+    SUBCASE("Copy on write with long string") {
+        std::string long_string(FASTLED_STR_INLINED_SIZE + 20, 'c');
+        Str s1(long_string.c_str());
+        Str s2 = s1;
+        CHECK(s1.size() == s2.size());
+        CHECK(strcmp(s1.c_str(), s2.c_str()) == 0);
+
+        s2.append("extra");
+        CHECK(s1.size() == long_string.length());
+        CHECK(s2.size() == long_string.length() + 5);
+        CHECK(strcmp(s1.c_str(), long_string.c_str()) == 0);
+        CHECK(s2[s2.size() - 1] == 'a');
+    }
+}
+
+TEST_CASE("String concatenation operators") {
+    SUBCASE("String literal + fl::to_string") {
+        // Test the specific case mentioned in the user query
+        fl::string val = "string" + fl::to_string(5);
+        CHECK(strcmp(val.c_str(), "string5") == 0);
+    }
+
+    SUBCASE("fl::to_string + string literal") {
+        fl::string val = fl::to_string(10) + " is a number";
+        CHECK(strcmp(val.c_str(), "10 is a number") == 0);
+    }
+
+    SUBCASE("String literal + fl::string") {
+        fl::string str = "world";
+        fl::string result = "Hello " + str;
+        CHECK(strcmp(result.c_str(), "Hello world") == 0);
+    }
+
+    SUBCASE("fl::string + string literal") {
+        fl::string str = "Hello";
+        fl::string result = str + " world";
+        CHECK(strcmp(result.c_str(), "Hello world") == 0);
+    }
+
+    SUBCASE("fl::string + fl::string") {
+        fl::string str1 = "Hello";
+        fl::string str2 = "World";
+        fl::string result = str1 + " " + str2;
+        CHECK(strcmp(result.c_str(), "Hello World") == 0);
+    }
+
+    SUBCASE("Complex concatenation") {
+        fl::string result = "Value: " + fl::to_string(42) + " and " + fl::to_string(3.14f);
+        // Check that it contains the expected parts rather than exact match
+        CHECK(result.find("Value: ") != fl::string::npos);
+        CHECK(result.find("42") != fl::string::npos);
+        CHECK(result.find("and") != fl::string::npos);
+        CHECK(result.find("3.14") != fl::string::npos);
+    }
+
+    SUBCASE("Number + string literal") {
+        fl::string result = fl::to_string(100) + " percent";
+        CHECK(strcmp(result.c_str(), "100 percent") == 0);
+    }
+
+    SUBCASE("String literal + number") {
+        fl::string result = "Count: " + fl::to_string(7);
+        CHECK(strcmp(result.c_str(), "Count: 7") == 0);
+    }
+}