Tests/CMakeLib/testStringAlgorithms.cxx - third_party/cmake - Git at Google

 /* 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 <iostream>
 #include <sstream>
 #include <string>
 #include <utility>
 #include <vector>

 #include <cm/string_view>

 #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 cmTrimWhitespace
   {
     std::string base = "base";
     std::string spaces = "  \f\f\n\n\r\r\t\t\v\v";
     assert_string(cmTrimWhitespace(spaces + base), base,
                   "cmTrimWhitespace front");
     assert_string(cmTrimWhitespace(base + spaces), base,
                   "cmTrimWhitespace back");
     assert_string(cmTrimWhitespace(spaces + base + spaces), base,
                   "cmTrimWhitespace front and back");
   }

   // ----------------------------------------------------------------------
   // Test cmRemoveQuotes
   {
     auto test = [&assert_string](cm::string_view source,
                                  cm::string_view expected,
                                  cm::string_view title) {
       assert_string(cmRemoveQuotes(source), expected, title);
     };

     test("", "", "cmRemoveQuotes empty");
     test("\"", "\"", "cmRemoveQuotes single quote");
     test("\"\"", "", "cmRemoveQuotes double quote");
     test("\"a", "\"a", "cmRemoveQuotes quote char");
     test("\"ab", "\"ab", "cmRemoveQuotes quote char char");
     test("a\"", "a\"", "cmRemoveQuotes char quote");
     test("ab\"", "ab\"", "cmRemoveQuotes char char quote");
     test("a", "a", "cmRemoveQuotes single char");
     test("ab", "ab", "cmRemoveQuotes two chars");
     test("abc", "abc", "cmRemoveQuotes three chars");
     test("\"abc\"", "abc", "cmRemoveQuotes quoted chars");
     test("\"\"abc\"\"", "\"abc\"", "cmRemoveQuotes quoted quoted chars");
   }

   // ----------------------------------------------------------------------
   // Test cmEscapeQuotes
   {
     assert_string(cmEscapeQuotes("plain"), "plain", "cmEscapeQuotes plain");
     std::string base = "\"base\"\"";
     std::string result = "\\\"base\\\"\\\"";
     assert_string(cmEscapeQuotes(base), result, "cmEscapeQuotes escaped");
   }

   // ----------------------------------------------------------------------
   // 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 cmTokenize
   {
     typedef std::vector<std::string> VT;
     assert_ok(cmTokenize("", ";") == VT{ "" }, "cmTokenize empty");
     assert_ok(cmTokenize(";", ";") == VT{ "" }, "cmTokenize sep");
     assert_ok(cmTokenize("abc", ";") == VT{ "abc" }, "cmTokenize item");
     assert_ok(cmTokenize("abc;", ";") == VT{ "abc" }, "cmTokenize item sep");
     assert_ok(cmTokenize(";abc", ";") == VT{ "abc" }, "cmTokenize sep item");
     assert_ok(cmTokenize("abc;;efg", ";") == VT{ "abc", "efg" },
               "cmTokenize item sep sep item");
     assert_ok(cmTokenize("a1;a2;a3;a4", ";") == VT{ "a1", "a2", "a3", "a4" },
               "cmTokenize multiple items");
   }

   // ----------------------------------------------------------------------
   // 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");
   }
   {
     std::string val;
     std::string expect;
     val.reserve(50 * cmStrLen("cmStrCat move ") + 1);
     auto data = val.data();
     auto capacity = val.capacity();
     bool moved = true;
     for (int i = 0; i < 100; i++) {
       if (i % 2 == 0) {
         val = cmStrCat(std::move(val), "move ");
         expect += "move ";
       } else {
         val = cmStrCat("cmStrCat ", std::move(val));
         expect = "cmStrCat " + std::move(expect);
       }
       if (val.data() != data || val.capacity() != capacity) {
         moved = false;
       }
     }
     assert_ok(moved, "cmStrCat move");
     assert_string(val, expect, "cmStrCat move");
   }

   // ----------------------------------------------------------------------
   // 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");
   }

   // ----------------------------------------------------------------------
   // Test cmStrToLong
   {
     long value;
     assert_ok(cmStrToLong("1", &value) && value == 1,
               "cmStrToLong parses a positive decimal integer.");
     assert_ok(cmStrToLong(" 1", &value) && value == 1,
               "cmStrToLong parses a decimal integer after whitespace.");

     assert_ok(cmStrToLong("-1", &value) && value == -1,
               "cmStrToLong parses a negative decimal integer.");
     assert_ok(
       cmStrToLong(" -1", &value) && value == -1,
       "cmStrToLong parses a negative decimal integer after whitespace.");

     assert_ok(!cmStrToLong("1x", &value),
               "cmStrToLong rejects trailing content.");
   }

   // ----------------------------------------------------------------------
   // Test cmStrToULong
   {
     unsigned long value;
     assert_ok(cmStrToULong("1", &value) && value == 1,
               "cmStrToULong parses a decimal integer.");
     assert_ok(cmStrToULong(" 1", &value) && value == 1,
               "cmStrToULong parses a decimal integer after whitespace.");
     assert_ok(!cmStrToULong("-1", &value),
               "cmStrToULong rejects a negative number.");
     assert_ok(!cmStrToULong(" -1", &value),
               "cmStrToULong rejects a negative number after whitespace.");
     assert_ok(!cmStrToULong("1x", &value),
               "cmStrToULong rejects trailing content.");
   }

   // ----------------------------------------------------------------------
   // Test cmStrToLongLong
   {
     long long value;
     assert_ok(cmStrToLongLong("1", &value) && value == 1,
               "cmStrToLongLong parses a positive decimal integer.");
     assert_ok(cmStrToLongLong(" 1", &value) && value == 1,
               "cmStrToLongLong parses a decimal integer after whitespace.");

     assert_ok(cmStrToLongLong("-1", &value) && value == -1,
               "cmStrToLongLong parses a negative decimal integer.");
     assert_ok(
       cmStrToLongLong(" -1", &value) && value == -1,
       "cmStrToLongLong parses a negative decimal integer after whitespace.");

     assert_ok(!cmStrToLongLong("1x", &value),
               "cmStrToLongLong rejects trailing content.");
   }

   // ----------------------------------------------------------------------
   // Test cmStrToULongLong
   {
     unsigned long long value;
     assert_ok(cmStrToULongLong("1", &value) && value == 1,
               "cmStrToULongLong parses a decimal integer.");
     assert_ok(cmStrToULongLong(" 1", &value) && value == 1,
               "cmStrToULongLong parses a decimal integer after whitespace.");
     assert_ok(!cmStrToULongLong("-1", &value),
               "cmStrToULongLong rejects a negative number.");
     assert_ok(!cmStrToULongLong(" -1", &value),
               "cmStrToULongLong rejects a negative number after whitespace.");
     assert_ok(!cmStrToULongLong("1x", &value),
               "cmStrToULongLong rejects trailing content.");
   }

   // ----------------------------------------------------------------------
   // Test cmStrLen
   {
     constexpr auto len = cmStrLen("Hello world!");
     assert_ok(len == 12,
               "cmStrLen returns length of non-empty literal string");
     assert_ok(cmStrLen("") == 0,
               "cmStrLen returns length of empty literal string");
   }

   return failed;
 }
	/* 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 <iostream>
	#include <sstream>
	#include <string>
	#include <utility>
	#include <vector>

	#include <cm/string_view>

	#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 cmTrimWhitespace
	{
	std::string base = "base";
	std::string spaces = " \f\f\n\n\r\r\t\t\v\v";
	assert_string(cmTrimWhitespace(spaces + base), base,
	"cmTrimWhitespace front");
	assert_string(cmTrimWhitespace(base + spaces), base,
	"cmTrimWhitespace back");
	assert_string(cmTrimWhitespace(spaces + base + spaces), base,
	"cmTrimWhitespace front and back");
	}

	// ----------------------------------------------------------------------
	// Test cmRemoveQuotes
	{
	auto test = [&assert_string](cm::string_view source,
	cm::string_view expected,
	cm::string_view title) {
	assert_string(cmRemoveQuotes(source), expected, title);
	};

	test("", "", "cmRemoveQuotes empty");
	test("\"", "\"", "cmRemoveQuotes single quote");
	test("\"\"", "", "cmRemoveQuotes double quote");
	test("\"a", "\"a", "cmRemoveQuotes quote char");
	test("\"ab", "\"ab", "cmRemoveQuotes quote char char");
	test("a\"", "a\"", "cmRemoveQuotes char quote");
	test("ab\"", "ab\"", "cmRemoveQuotes char char quote");
	test("a", "a", "cmRemoveQuotes single char");
	test("ab", "ab", "cmRemoveQuotes two chars");
	test("abc", "abc", "cmRemoveQuotes three chars");
	test("\"abc\"", "abc", "cmRemoveQuotes quoted chars");
	test("\"\"abc\"\"", "\"abc\"", "cmRemoveQuotes quoted quoted chars");
	}

	// ----------------------------------------------------------------------
	// Test cmEscapeQuotes
	{
	assert_string(cmEscapeQuotes("plain"), "plain", "cmEscapeQuotes plain");
	std::string base = "\"base\"\"";
	std::string result = "\\\"base\\\"\\\"";
	assert_string(cmEscapeQuotes(base), result, "cmEscapeQuotes escaped");
	}

	// ----------------------------------------------------------------------
	// 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 cmTokenize
	{
	typedef std::vector<std::string> VT;
	assert_ok(cmTokenize("", ";") == VT{ "" }, "cmTokenize empty");
	assert_ok(cmTokenize(";", ";") == VT{ "" }, "cmTokenize sep");
	assert_ok(cmTokenize("abc", ";") == VT{ "abc" }, "cmTokenize item");
	assert_ok(cmTokenize("abc;", ";") == VT{ "abc" }, "cmTokenize item sep");
	assert_ok(cmTokenize(";abc", ";") == VT{ "abc" }, "cmTokenize sep item");
	assert_ok(cmTokenize("abc;;efg", ";") == VT{ "abc", "efg" },
	"cmTokenize item sep sep item");
	assert_ok(cmTokenize("a1;a2;a3;a4", ";") == VT{ "a1", "a2", "a3", "a4" },
	"cmTokenize multiple items");
	}

	// ----------------------------------------------------------------------
	// 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");
	}
	{
	std::string val;
	std::string expect;
	val.reserve(50 * cmStrLen("cmStrCat move ") + 1);
	auto data = val.data();
	auto capacity = val.capacity();
	bool moved = true;
	for (int i = 0; i < 100; i++) {
	if (i % 2 == 0) {
	val = cmStrCat(std::move(val), "move ");
	expect += "move ";
	} else {
	val = cmStrCat("cmStrCat ", std::move(val));
	expect = "cmStrCat " + std::move(expect);
	}
	if (val.data() != data \|\| val.capacity() != capacity) {
	moved = false;
	}
	}
	assert_ok(moved, "cmStrCat move");
	assert_string(val, expect, "cmStrCat move");
	}

	// ----------------------------------------------------------------------
	// 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");
	}

	// ----------------------------------------------------------------------
	// Test cmStrToLong
	{
	long value;
	assert_ok(cmStrToLong("1", &value) && value == 1,
	"cmStrToLong parses a positive decimal integer.");
	assert_ok(cmStrToLong(" 1", &value) && value == 1,
	"cmStrToLong parses a decimal integer after whitespace.");

	assert_ok(cmStrToLong("-1", &value) && value == -1,
	"cmStrToLong parses a negative decimal integer.");
	assert_ok(
	cmStrToLong(" -1", &value) && value == -1,
	"cmStrToLong parses a negative decimal integer after whitespace.");

	assert_ok(!cmStrToLong("1x", &value),
	"cmStrToLong rejects trailing content.");
	}

	// ----------------------------------------------------------------------
	// Test cmStrToULong
	{
	unsigned long value;
	assert_ok(cmStrToULong("1", &value) && value == 1,
	"cmStrToULong parses a decimal integer.");
	assert_ok(cmStrToULong(" 1", &value) && value == 1,
	"cmStrToULong parses a decimal integer after whitespace.");
	assert_ok(!cmStrToULong("-1", &value),
	"cmStrToULong rejects a negative number.");
	assert_ok(!cmStrToULong(" -1", &value),
	"cmStrToULong rejects a negative number after whitespace.");
	assert_ok(!cmStrToULong("1x", &value),
	"cmStrToULong rejects trailing content.");
	}

	// ----------------------------------------------------------------------
	// Test cmStrToLongLong
	{
	long long value;
	assert_ok(cmStrToLongLong("1", &value) && value == 1,
	"cmStrToLongLong parses a positive decimal integer.");
	assert_ok(cmStrToLongLong(" 1", &value) && value == 1,
	"cmStrToLongLong parses a decimal integer after whitespace.");

	assert_ok(cmStrToLongLong("-1", &value) && value == -1,
	"cmStrToLongLong parses a negative decimal integer.");
	assert_ok(
	cmStrToLongLong(" -1", &value) && value == -1,
	"cmStrToLongLong parses a negative decimal integer after whitespace.");

	assert_ok(!cmStrToLongLong("1x", &value),
	"cmStrToLongLong rejects trailing content.");
	}

	// ----------------------------------------------------------------------
	// Test cmStrToULongLong
	{
	unsigned long long value;
	assert_ok(cmStrToULongLong("1", &value) && value == 1,
	"cmStrToULongLong parses a decimal integer.");
	assert_ok(cmStrToULongLong(" 1", &value) && value == 1,
	"cmStrToULongLong parses a decimal integer after whitespace.");
	assert_ok(!cmStrToULongLong("-1", &value),
	"cmStrToULongLong rejects a negative number.");
	assert_ok(!cmStrToULongLong(" -1", &value),
	"cmStrToULongLong rejects a negative number after whitespace.");
	assert_ok(!cmStrToULongLong("1x", &value),
	"cmStrToULongLong rejects trailing content.");
	}

	// ----------------------------------------------------------------------
	// Test cmStrLen
	{
	constexpr auto len = cmStrLen("Hello world!");
	assert_ok(len == 12,
	"cmStrLen returns length of non-empty literal string");
	assert_ok(cmStrLen("") == 0,
	"cmStrLen returns length of empty literal string");
	}

	return failed;
	}