Tests: Add CMakeLib.testStringAlgorithms test

Tests/CMakeLib/CMakeLists.txt

@@ -10,6 +10,7 @@ set(CMakeLib_TESTS
   testRST.cxx
   testRange.cxx
   testString.cxx
+  testStringAlgorithms.cxx
   testSystemTools.cxx
   testUTF8.cxx
   testXMLParser.cxx

Tests/CMakeLib/testStringAlgorithms.cxx

@@ -0,0 +1,134 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+
+#include <cmConfigure.h> // IWYU pragma: keep
+
+#include "cm_string_view.hxx"
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "cmStringAlgorithms.h"
+
+int testStringAlgorithms(int /*unused*/, char* /*unused*/ [])
+{
+  int failed = 0;
+
+  auto assert_ok = [&failed](bool test, cm::string_view title) {
+    if (test) {
+      std::cout << "Passed: " << title << "\n";
+    } else {
+      std::cout << "Failed: " << title << "\n";
+      ++failed;
+    }
+  };
+
+  auto assert_string = [&failed](cm::string_view generated,
+                                 cm::string_view expected,
+                                 cm::string_view title) {
+    if (generated == expected) {
+      std::cout << "Passed: " << title << "\n";
+    } else {
+      std::cout << "Failed: " << title << "\n";
+      std::cout << "Expected: " << expected << "\n";
+      std::cout << "Got: " << generated << "\n";
+      ++failed;
+    }
+  };
+
+  // ----------------------------------------------------------------------
+  // Test cmJoin
+  {
+    typedef std::string ST;
+    typedef std::vector<std::string> VT;
+    assert_string(cmJoin(ST("abc"), ";"), "a;b;c", "cmJoin std::string");
+    assert_string(cmJoin(VT{}, ";"), "", "cmJoin std::vector empty");
+    assert_string(cmJoin(VT{ "a" }, ";"), "a", "cmJoin std::vector single");
+    assert_string(cmJoin(VT{ "a", "b", "c" }, ";"), "a;b;c",
+                  "cmJoin std::vector multiple");
+    assert_string(cmJoin(VT{ "a", "b", "c" }, "<=>"), "a<=>b<=>c",
+                  "cmJoin std::vector long sep");
+  }
+
+  // ----------------------------------------------------------------------
+  // Test cmStrCat
+  {
+    int ni = -1100;
+    unsigned int nui = 1100u;
+    long int nli = -12000l;
+    unsigned long int nuli = 12000ul;
+    long long int nlli = -130000ll;
+    unsigned long long int nulli = 130000ull;
+    std::string val =
+      cmStrCat("<test>", ni, ',', nui, ',', nli, ",", nuli, ", ", nlli,
+               std::string(", "), nulli, cm::string_view("</test>"));
+    std::string expect =
+      "<test>-1100,1100,-12000,12000, -130000, 130000</test>";
+    assert_string(val, expect, "cmStrCat strings and integers");
+  }
+  {
+    float const val = 1.5f;
+    float const div = 0.00001f;
+    float f = 0.0f;
+    std::istringstream(cmStrCat("", val)) >> f;
+    f -= val;
+    assert_ok((f < div) && (f > -div), "cmStrCat float");
+  }
+  {
+    double const val = 1.5;
+    double const div = 0.00001;
+    double d = 0.0;
+    std::istringstream(cmStrCat("", val)) >> d;
+    d -= val;
+    assert_ok((d < div) && (d > -div), "cmStrCat double");
+  }
+
+  // ----------------------------------------------------------------------
+  // Test cmWrap
+  {
+    typedef std::vector<std::string> VT;
+    assert_string(cmWrap("<", VT{}, ">", "; "), //
+                  "",                           //
+                  "cmWrap empty, string prefix and suffix");
+    assert_string(cmWrap("<", VT{ "abc" }, ">", "; "), //
+                  "<abc>",                             //
+                  "cmWrap single, string prefix and suffix");
+    assert_string(cmWrap("<", VT{ "a1", "a2", "a3" }, ">", "; "), //
+                  "<a1>; <a2>; <a3>",                             //
+                  "cmWrap multiple, string prefix and suffix");
+
+    assert_string(cmWrap('<', VT{}, '>', "; "), //
+                  "",                           //
+                  "cmWrap empty, char prefix and suffix");
+    assert_string(cmWrap('<', VT{ "abc" }, '>', "; "), //
+                  "<abc>",                             //
+                  "cmWrap single, char prefix and suffix");
+    assert_string(cmWrap('<', VT{ "a1", "a2", "a3" }, '>', "; "), //
+                  "<a1>; <a2>; <a3>",                             //
+                  "cmWrap multiple, char prefix and suffix");
+  }
+
+  // ----------------------------------------------------------------------
+  // Test cmHas(Literal)Prefix and cmHas(Literal)Suffix
+  {
+    std::string str("abc");
+    assert_ok(cmHasPrefix(str, 'a'), "cmHasPrefix char");
+    assert_ok(!cmHasPrefix(str, 'c'), "cmHasPrefix char not");
+    assert_ok(cmHasPrefix(str, "ab"), "cmHasPrefix string");
+    assert_ok(!cmHasPrefix(str, "bc"), "cmHasPrefix string not");
+    assert_ok(cmHasPrefix(str, str), "cmHasPrefix complete string");
+    assert_ok(cmHasLiteralPrefix(str, "ab"), "cmHasLiteralPrefix string");
+    assert_ok(!cmHasLiteralPrefix(str, "bc"), "cmHasLiteralPrefix string not");
+
+    assert_ok(cmHasSuffix(str, 'c'), "cmHasSuffix char");
+    assert_ok(!cmHasSuffix(str, 'a'), "cmHasSuffix char not");
+    assert_ok(cmHasSuffix(str, "bc"), "cmHasSuffix string");
+    assert_ok(!cmHasSuffix(str, "ab"), "cmHasSuffix string not");
+    assert_ok(cmHasSuffix(str, str), "cmHasSuffix complete string");
+    assert_ok(cmHasLiteralSuffix(str, "bc"), "cmHasLiteralSuffix string");
+    assert_ok(!cmHasLiteralSuffix(str, "ab"), "cmHasLiteralPrefix string not");
+  }
+
+  return failed;
+}