You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1350 lines
35 KiB
1350 lines
35 KiB
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
file Copyright.txt or https://cmake.org/licensing for details. */
|
|
|
|
#include <cstddef>
|
|
#include <cstring>
|
|
#include <iostream>
|
|
#include <iterator>
|
|
#include <sstream>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <type_traits>
|
|
#include <utility>
|
|
|
|
#include <cm/string_view>
|
|
|
|
#include "cm_static_string_view.hxx"
|
|
|
|
#include "cmString.hxx"
|
|
|
|
#define ASSERT_TRUE(x) \
|
|
do { \
|
|
if (!(x)) { \
|
|
std::cout << "ASSERT_TRUE(" #x ") failed on line " << __LINE__ << "\n"; \
|
|
return false; \
|
|
} \
|
|
} while (false)
|
|
|
|
static bool testConstructDefault()
|
|
{
|
|
std::cout << "testConstructDefault()\n";
|
|
cm::String str;
|
|
cm::String const& str_const = str;
|
|
ASSERT_TRUE(bool(str_const) == false);
|
|
ASSERT_TRUE(str_const.data() == nullptr);
|
|
ASSERT_TRUE(str_const.size() == 0);
|
|
ASSERT_TRUE(str_const.empty());
|
|
ASSERT_TRUE(str_const.is_stable());
|
|
ASSERT_TRUE(str.c_str() == nullptr);
|
|
ASSERT_TRUE(str.str().empty());
|
|
ASSERT_TRUE(str.is_stable());
|
|
return true;
|
|
}
|
|
|
|
static bool testFromNullPtr(cm::String str)
|
|
{
|
|
cm::String const& str_const = str;
|
|
ASSERT_TRUE(bool(str_const) == false);
|
|
ASSERT_TRUE(str_const.data() == nullptr);
|
|
ASSERT_TRUE(str_const.size() == 0);
|
|
ASSERT_TRUE(str_const.empty());
|
|
ASSERT_TRUE(str_const.is_stable());
|
|
ASSERT_TRUE(str.c_str() == nullptr);
|
|
ASSERT_TRUE(str.str().empty());
|
|
ASSERT_TRUE(str.is_stable());
|
|
return true;
|
|
}
|
|
|
|
static bool testConstructFromNullPtr()
|
|
{
|
|
std::cout << "testConstructFromNullPtr()\n";
|
|
return testFromNullPtr(nullptr);
|
|
}
|
|
|
|
static bool testAssignFromNullPtr()
|
|
{
|
|
std::cout << "testAssignFromNullPtr()\n";
|
|
cm::String str;
|
|
str = nullptr;
|
|
return testFromNullPtr(str);
|
|
}
|
|
|
|
static bool testFromCStrNull(cm::String str)
|
|
{
|
|
cm::String const& str_const = str;
|
|
ASSERT_TRUE(bool(str_const) == false);
|
|
ASSERT_TRUE(str_const.data() == nullptr);
|
|
ASSERT_TRUE(str_const.size() == 0);
|
|
ASSERT_TRUE(str_const.empty());
|
|
ASSERT_TRUE(str_const.is_stable());
|
|
ASSERT_TRUE(str.c_str() == nullptr);
|
|
ASSERT_TRUE(str.str().empty());
|
|
ASSERT_TRUE(str.is_stable());
|
|
return true;
|
|
}
|
|
|
|
static bool testConstructFromCStrNull()
|
|
{
|
|
std::cout << "testConstructFromCStrNull()\n";
|
|
const char* null = nullptr;
|
|
return testFromCStrNull(null);
|
|
}
|
|
|
|
static bool testAssignFromCStrNull()
|
|
{
|
|
std::cout << "testAssignFromCStrNull()\n";
|
|
const char* null = nullptr;
|
|
cm::String str;
|
|
str = null;
|
|
return testFromCStrNull(str);
|
|
}
|
|
|
|
static char const charArray[] = "abc";
|
|
|
|
static bool testFromCharArray(cm::String str)
|
|
{
|
|
cm::String const& str_const = str;
|
|
ASSERT_TRUE(str_const.data() != charArray);
|
|
ASSERT_TRUE(str_const.size() == sizeof(charArray) - 1);
|
|
ASSERT_TRUE(str_const.is_stable());
|
|
ASSERT_TRUE(str.c_str() != charArray);
|
|
ASSERT_TRUE(str.is_stable());
|
|
cm::String substr = str.substr(1);
|
|
cm::String const& substr_const = substr;
|
|
ASSERT_TRUE(substr_const.data() != &charArray[1]);
|
|
ASSERT_TRUE(substr_const.size() == 2);
|
|
ASSERT_TRUE(!substr_const.is_stable());
|
|
ASSERT_TRUE(substr.c_str() != &charArray[1]);
|
|
ASSERT_TRUE(!substr.is_stable());
|
|
return true;
|
|
}
|
|
|
|
static bool testConstructFromCharArray()
|
|
{
|
|
std::cout << "testConstructFromCharArray()\n";
|
|
return testFromCharArray(charArray);
|
|
}
|
|
|
|
static bool testAssignFromCharArray()
|
|
{
|
|
std::cout << "testAssignFromCharArray()\n";
|
|
cm::String str;
|
|
str = charArray;
|
|
return testFromCharArray(str);
|
|
}
|
|
|
|
static const char* cstr = "abc";
|
|
|
|
static bool testFromCStr(cm::String const& str)
|
|
{
|
|
ASSERT_TRUE(str.data() != cstr);
|
|
ASSERT_TRUE(str.size() == 3);
|
|
ASSERT_TRUE(std::strncmp(str.data(), cstr, 3) == 0);
|
|
ASSERT_TRUE(str.is_stable());
|
|
return true;
|
|
}
|
|
|
|
static bool testConstructFromCStr()
|
|
{
|
|
std::cout << "testConstructFromCStr()\n";
|
|
return testFromCStr(cstr);
|
|
}
|
|
|
|
static bool testAssignFromCStr()
|
|
{
|
|
std::cout << "testAssignFromCStr()\n";
|
|
cm::String str;
|
|
str = cstr;
|
|
return testFromCStr(str);
|
|
}
|
|
|
|
static const std::string stdstr = "abc";
|
|
|
|
static bool testFromStdString(cm::String const& str)
|
|
{
|
|
#if defined(_GLIBCXX_USE_CXX11_ABI) && _GLIBCXX_USE_CXX11_ABI
|
|
// It would be nice to check this everywhere, but several platforms
|
|
// still use a CoW implementation even in C++11.
|
|
ASSERT_TRUE(str.data() != stdstr.data());
|
|
#endif
|
|
ASSERT_TRUE(str.size() == 3);
|
|
ASSERT_TRUE(std::strncmp(str.data(), stdstr.data(), 3) == 0);
|
|
ASSERT_TRUE(str.is_stable());
|
|
return true;
|
|
}
|
|
|
|
static bool testConstructFromStdString()
|
|
{
|
|
std::cout << "testConstructFromStdString()\n";
|
|
return testFromStdString(stdstr);
|
|
}
|
|
|
|
static bool testAssignFromStdString()
|
|
{
|
|
std::cout << "testAssignFromStdString()\n";
|
|
cm::String str;
|
|
str = stdstr;
|
|
return testFromStdString(str);
|
|
}
|
|
|
|
static bool testConstructFromView()
|
|
{
|
|
std::cout << "testConstructFromView()\n";
|
|
cm::string_view view = cstr;
|
|
return testFromCStr(view);
|
|
}
|
|
|
|
static bool testAssignFromView()
|
|
{
|
|
std::cout << "testAssignFromView()\n";
|
|
cm::string_view view = cstr;
|
|
cm::String str;
|
|
str = view;
|
|
return testFromCStr(str);
|
|
}
|
|
|
|
static bool testFromChar(cm::String const& str)
|
|
{
|
|
ASSERT_TRUE(str.size() == 1);
|
|
ASSERT_TRUE(std::strncmp(str.data(), "a", 1) == 0);
|
|
ASSERT_TRUE(str.is_stable());
|
|
return true;
|
|
}
|
|
|
|
static bool testConstructFromChar()
|
|
{
|
|
std::cout << "testConstructFromChar()\n";
|
|
return testFromChar('a');
|
|
}
|
|
|
|
static bool testAssignFromChar()
|
|
{
|
|
std::cout << "testAssignFromChar()\n";
|
|
cm::String str;
|
|
str = 'a';
|
|
return testFromChar(str);
|
|
}
|
|
|
|
static bool testConstructFromInitList()
|
|
{
|
|
std::cout << "testConstructFromInitList()\n";
|
|
cm::String const str{ 'a', 'b', 'c' };
|
|
ASSERT_TRUE(str.size() == 3);
|
|
ASSERT_TRUE(std::strncmp(str.data(), "abc", 3) == 0);
|
|
ASSERT_TRUE(str.is_stable());
|
|
return true;
|
|
}
|
|
|
|
static bool testAssignFromInitList()
|
|
{
|
|
std::cout << "testAssignFromInitList()\n";
|
|
cm::String str;
|
|
str = { 'a', 'b', 'c' };
|
|
ASSERT_TRUE(str.size() == 3);
|
|
ASSERT_TRUE(std::strncmp(str.data(), "abc", 3) == 0);
|
|
ASSERT_TRUE(str.is_stable());
|
|
return true;
|
|
}
|
|
|
|
static bool testConstructFromBuffer()
|
|
{
|
|
std::cout << "testConstructFromBuffer()\n";
|
|
cm::String const str(cstr, 3);
|
|
return testFromCStr(str);
|
|
}
|
|
|
|
static bool testConstructFromInputIterator()
|
|
{
|
|
std::cout << "testConstructFromInputIterator()\n";
|
|
cm::String const str(cstr, cstr + 3);
|
|
ASSERT_TRUE(str.data() != cstr);
|
|
ASSERT_TRUE(str.size() == 3);
|
|
ASSERT_TRUE(std::strncmp(str.data(), cstr, 3) == 0);
|
|
ASSERT_TRUE(str.is_stable());
|
|
return true;
|
|
}
|
|
|
|
static bool testConstructFromN()
|
|
{
|
|
std::cout << "testConstructFromN()\n";
|
|
cm::String const str(3, 'a');
|
|
ASSERT_TRUE(str.size() == 3);
|
|
ASSERT_TRUE(std::strncmp(str.data(), "aaa", 3) == 0);
|
|
ASSERT_TRUE(str.is_stable());
|
|
return true;
|
|
}
|
|
|
|
static const auto staticStringView = "abc"_s;
|
|
|
|
static bool testFromStaticStringView(cm::String str)
|
|
{
|
|
cm::String const& str_const = str;
|
|
ASSERT_TRUE(str_const.data() == staticStringView.data());
|
|
ASSERT_TRUE(str_const.size() == staticStringView.size());
|
|
ASSERT_TRUE(!str_const.is_stable());
|
|
ASSERT_TRUE(str.c_str() == staticStringView);
|
|
ASSERT_TRUE(!str.is_stable());
|
|
cm::String substr = str.substr(1);
|
|
cm::String const& substr_const = substr;
|
|
ASSERT_TRUE(substr_const.data() == &staticStringView[1]);
|
|
ASSERT_TRUE(substr_const.size() == 2);
|
|
ASSERT_TRUE(!substr_const.is_stable());
|
|
ASSERT_TRUE(substr.c_str() == &staticStringView[1]);
|
|
ASSERT_TRUE(!substr.is_stable());
|
|
return true;
|
|
}
|
|
|
|
static bool testConstructFromStaticStringView()
|
|
{
|
|
std::cout << "testConstructFromStaticStringView()\n";
|
|
return testFromStaticStringView(staticStringView);
|
|
}
|
|
|
|
static bool testAssignFromStaticStringView()
|
|
{
|
|
std::cout << "testAssignFromStaticStringView()\n";
|
|
cm::String str;
|
|
str = staticStringView;
|
|
return testFromStaticStringView(str);
|
|
}
|
|
|
|
static bool testConstructCopy()
|
|
{
|
|
std::cout << "testConstructCopy()\n";
|
|
cm::String s1 = std::string("abc");
|
|
cm::String s2 = s1;
|
|
ASSERT_TRUE(s1.data() == s2.data());
|
|
ASSERT_TRUE(s1.size() == 3);
|
|
ASSERT_TRUE(s2.size() == 3);
|
|
ASSERT_TRUE(std::strncmp(s2.data(), "abc", 3) == 0);
|
|
ASSERT_TRUE(s1.is_stable());
|
|
ASSERT_TRUE(s2.is_stable());
|
|
return true;
|
|
}
|
|
|
|
static bool testConstructMove()
|
|
{
|
|
std::cout << "testConstructMove()\n";
|
|
cm::String s1 = std::string("abc");
|
|
cm::String s2 = std::move(s1);
|
|
ASSERT_TRUE(s1.data() == nullptr);
|
|
ASSERT_TRUE(s1.size() == 0);
|
|
ASSERT_TRUE(s2.size() == 3);
|
|
ASSERT_TRUE(std::strncmp(s2.data(), "abc", 3) == 0);
|
|
ASSERT_TRUE(s1.is_stable());
|
|
ASSERT_TRUE(s2.is_stable());
|
|
return true;
|
|
}
|
|
|
|
static bool testAssignCopy()
|
|
{
|
|
std::cout << "testAssignCopy()\n";
|
|
cm::String s1 = std::string("abc");
|
|
cm::String s2;
|
|
s2 = s1;
|
|
ASSERT_TRUE(s1.data() == s2.data());
|
|
ASSERT_TRUE(s1.size() == 3);
|
|
ASSERT_TRUE(s2.size() == 3);
|
|
ASSERT_TRUE(std::strncmp(s2.data(), "abc", 3) == 0);
|
|
ASSERT_TRUE(s1.is_stable());
|
|
ASSERT_TRUE(s2.is_stable());
|
|
return true;
|
|
}
|
|
|
|
static bool testAssignMove()
|
|
{
|
|
std::cout << "testAssignMove()\n";
|
|
cm::String s1 = std::string("abc");
|
|
cm::String s2;
|
|
s2 = std::move(s1);
|
|
ASSERT_TRUE(s1.data() == nullptr);
|
|
ASSERT_TRUE(s1.size() == 0);
|
|
ASSERT_TRUE(s2.size() == 3);
|
|
ASSERT_TRUE(std::strncmp(s2.data(), "abc", 3) == 0);
|
|
ASSERT_TRUE(s1.is_stable());
|
|
ASSERT_TRUE(s2.is_stable());
|
|
return true;
|
|
}
|
|
|
|
static bool testOperatorBool()
|
|
{
|
|
std::cout << "testOperatorBool()\n";
|
|
cm::String str;
|
|
ASSERT_TRUE(!str);
|
|
str = "";
|
|
ASSERT_TRUE(str);
|
|
str = static_cast<const char*>(nullptr);
|
|
ASSERT_TRUE(!str);
|
|
str = std::string();
|
|
ASSERT_TRUE(str);
|
|
str = nullptr;
|
|
ASSERT_TRUE(!str);
|
|
return true;
|
|
}
|
|
|
|
static bool testOperatorIndex()
|
|
{
|
|
std::cout << "testOperatorIndex()\n";
|
|
cm::String str = "abc";
|
|
ASSERT_TRUE(str[0] == 'a');
|
|
ASSERT_TRUE(str[1] == 'b');
|
|
ASSERT_TRUE(str[2] == 'c');
|
|
return true;
|
|
}
|
|
|
|
static bool testOperatorPlusEqual()
|
|
{
|
|
std::cout << "testOperatorPlusEqual()\n";
|
|
cm::String str = "a";
|
|
str += "b";
|
|
{
|
|
const char* c = "c";
|
|
str += c;
|
|
}
|
|
str += 'd';
|
|
str += std::string("e");
|
|
str += cm::string_view("f", 1);
|
|
str += cm::String("g");
|
|
ASSERT_TRUE(str.size() == 7);
|
|
ASSERT_TRUE(std::strncmp(str.data(), "abcdefg", 7) == 0);
|
|
ASSERT_TRUE(str.is_stable());
|
|
return true;
|
|
}
|
|
|
|
static bool testOperatorCompare()
|
|
{
|
|
std::cout << "testOperatorCompare()\n";
|
|
cm::String str = "b";
|
|
{
|
|
ASSERT_TRUE(str == "b");
|
|
ASSERT_TRUE("b" == str);
|
|
ASSERT_TRUE(str != "a");
|
|
ASSERT_TRUE("a" != str);
|
|
ASSERT_TRUE(str < "c");
|
|
ASSERT_TRUE("a" < str);
|
|
ASSERT_TRUE(str > "a");
|
|
ASSERT_TRUE("c" > str);
|
|
ASSERT_TRUE(str <= "b");
|
|
ASSERT_TRUE("b" <= str);
|
|
ASSERT_TRUE(str >= "b");
|
|
ASSERT_TRUE("b" >= str);
|
|
}
|
|
{
|
|
const char* a = "a";
|
|
const char* b = "b";
|
|
const char* c = "c";
|
|
ASSERT_TRUE(str == b);
|
|
ASSERT_TRUE(b == str);
|
|
ASSERT_TRUE(str != a);
|
|
ASSERT_TRUE(a != str);
|
|
ASSERT_TRUE(str < c);
|
|
ASSERT_TRUE(a < str);
|
|
ASSERT_TRUE(str > a);
|
|
ASSERT_TRUE(c > str);
|
|
ASSERT_TRUE(str <= b);
|
|
ASSERT_TRUE(b <= str);
|
|
ASSERT_TRUE(str >= b);
|
|
ASSERT_TRUE(b >= str);
|
|
}
|
|
{
|
|
ASSERT_TRUE(str == 'b');
|
|
ASSERT_TRUE('b' == str);
|
|
ASSERT_TRUE(str != 'a');
|
|
ASSERT_TRUE('a' != str);
|
|
ASSERT_TRUE(str < 'c');
|
|
ASSERT_TRUE('a' < str);
|
|
ASSERT_TRUE(str > 'a');
|
|
ASSERT_TRUE('c' > str);
|
|
ASSERT_TRUE(str <= 'b');
|
|
ASSERT_TRUE('b' <= str);
|
|
ASSERT_TRUE(str >= 'b');
|
|
ASSERT_TRUE('b' >= str);
|
|
}
|
|
{
|
|
std::string const a = "a";
|
|
std::string const b = "b";
|
|
std::string const c = "c";
|
|
ASSERT_TRUE(str == b);
|
|
ASSERT_TRUE(b == str);
|
|
ASSERT_TRUE(str != a);
|
|
ASSERT_TRUE(a != str);
|
|
ASSERT_TRUE(str < c);
|
|
ASSERT_TRUE(a < str);
|
|
ASSERT_TRUE(str > a);
|
|
ASSERT_TRUE(c > str);
|
|
ASSERT_TRUE(str <= b);
|
|
ASSERT_TRUE(b <= str);
|
|
ASSERT_TRUE(str >= b);
|
|
ASSERT_TRUE(b >= str);
|
|
}
|
|
{
|
|
cm::string_view const a("a", 1);
|
|
cm::string_view const b("b", 1);
|
|
cm::string_view const c("c", 1);
|
|
ASSERT_TRUE(str == b);
|
|
ASSERT_TRUE(b == str);
|
|
ASSERT_TRUE(str != a);
|
|
ASSERT_TRUE(a != str);
|
|
ASSERT_TRUE(str < c);
|
|
ASSERT_TRUE(a < str);
|
|
ASSERT_TRUE(str > a);
|
|
ASSERT_TRUE(c > str);
|
|
ASSERT_TRUE(str <= b);
|
|
ASSERT_TRUE(b <= str);
|
|
ASSERT_TRUE(str >= b);
|
|
ASSERT_TRUE(b >= str);
|
|
}
|
|
{
|
|
cm::String const a("a");
|
|
cm::String const b("b");
|
|
cm::String const c("c");
|
|
ASSERT_TRUE(str == b);
|
|
ASSERT_TRUE(b == str);
|
|
ASSERT_TRUE(str != a);
|
|
ASSERT_TRUE(a != str);
|
|
ASSERT_TRUE(str < c);
|
|
ASSERT_TRUE(a < str);
|
|
ASSERT_TRUE(str > a);
|
|
ASSERT_TRUE(c > str);
|
|
ASSERT_TRUE(str <= b);
|
|
ASSERT_TRUE(b <= str);
|
|
ASSERT_TRUE(str >= b);
|
|
ASSERT_TRUE(b >= str);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool testOperatorStream()
|
|
{
|
|
std::cout << "testOperatorStream()\n";
|
|
std::ostringstream ss;
|
|
ss << "a" << cm::String("b") << 'c';
|
|
ASSERT_TRUE(ss.str() == "abc");
|
|
return true;
|
|
}
|
|
|
|
static bool testOperatorStdStringPlusEqual()
|
|
{
|
|
std::cout << "testOperatorStdStringPlusEqual()\n";
|
|
std::string s = "a";
|
|
s += cm::String("b");
|
|
ASSERT_TRUE(s == "ab");
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_borrow()
|
|
{
|
|
std::cout << "testMethod_borrow()\n";
|
|
std::string s = "abc";
|
|
cm::String str = cm::String::borrow(s);
|
|
ASSERT_TRUE(str.data() == s.data());
|
|
ASSERT_TRUE(str.size() == s.size());
|
|
ASSERT_TRUE(str == s);
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_view()
|
|
{
|
|
std::cout << "testMethod_view()\n";
|
|
cm::String str;
|
|
ASSERT_TRUE(str.view().data() == nullptr);
|
|
ASSERT_TRUE(str.view().size() == 0);
|
|
str = charArray;
|
|
ASSERT_TRUE(str.view().data() != charArray);
|
|
ASSERT_TRUE(str.view().size() == sizeof(charArray) - 1);
|
|
str = std::string("abc");
|
|
ASSERT_TRUE(str.view().size() == 3);
|
|
ASSERT_TRUE(strncmp(str.view().data(), "abc", 3) == 0);
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_empty()
|
|
{
|
|
std::cout << "testMethod_empty()\n";
|
|
cm::String str;
|
|
ASSERT_TRUE(str.empty());
|
|
str = "";
|
|
ASSERT_TRUE(str.empty());
|
|
str = "abc";
|
|
ASSERT_TRUE(!str.empty());
|
|
str = std::string();
|
|
ASSERT_TRUE(str.empty());
|
|
str = std::string("abc");
|
|
ASSERT_TRUE(!str.empty());
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_length()
|
|
{
|
|
std::cout << "testMethod_length()\n";
|
|
cm::String str;
|
|
ASSERT_TRUE(str.length() == 0);
|
|
str = "";
|
|
ASSERT_TRUE(str.length() == 0);
|
|
str = "abc";
|
|
ASSERT_TRUE(str.length() == 3);
|
|
str = std::string();
|
|
ASSERT_TRUE(str.length() == 0);
|
|
str = std::string("abc");
|
|
ASSERT_TRUE(str.length() == 3);
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_at()
|
|
{
|
|
std::cout << "testMethod_at()\n";
|
|
cm::String str = "abc";
|
|
ASSERT_TRUE(str.at(0) == 'a');
|
|
ASSERT_TRUE(str.at(1) == 'b');
|
|
ASSERT_TRUE(str.at(2) == 'c');
|
|
bool except_out_of_range = false;
|
|
try {
|
|
str.at(3);
|
|
} catch (std::out_of_range&) {
|
|
except_out_of_range = true;
|
|
}
|
|
ASSERT_TRUE(except_out_of_range);
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_front_back()
|
|
{
|
|
std::cout << "testMethod_front_back()\n";
|
|
cm::String str = "abc";
|
|
ASSERT_TRUE(str.front() == 'a');
|
|
ASSERT_TRUE(str.back() == 'c');
|
|
return true;
|
|
}
|
|
|
|
static bool testMethodIterators()
|
|
{
|
|
std::cout << "testMethodIterators()\n";
|
|
cm::String str = "abc";
|
|
ASSERT_TRUE(*str.begin() == 'a');
|
|
ASSERT_TRUE(*(str.end() - 1) == 'c');
|
|
ASSERT_TRUE(str.end() - str.begin() == 3);
|
|
ASSERT_TRUE(*str.cbegin() == 'a');
|
|
ASSERT_TRUE(*(str.cend() - 1) == 'c');
|
|
ASSERT_TRUE(str.cend() - str.cbegin() == 3);
|
|
ASSERT_TRUE(*str.rbegin() == 'c');
|
|
ASSERT_TRUE(*(str.rend() - 1) == 'a');
|
|
ASSERT_TRUE(str.rend() - str.rbegin() == 3);
|
|
ASSERT_TRUE(*str.crbegin() == 'c');
|
|
ASSERT_TRUE(*(str.crend() - 1) == 'a');
|
|
ASSERT_TRUE(str.crend() - str.crbegin() == 3);
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_clear()
|
|
{
|
|
std::cout << "testMethod_clear()\n";
|
|
cm::String str = "abc";
|
|
ASSERT_TRUE(!str.empty());
|
|
str.clear();
|
|
ASSERT_TRUE(str.empty());
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_insert()
|
|
{
|
|
std::cout << "testMethod_insert()\n";
|
|
cm::String str = "abc";
|
|
str.insert(1, 2, 'd').insert(0, 1, '_');
|
|
ASSERT_TRUE(str.size() == 6);
|
|
ASSERT_TRUE(std::strncmp(str.data(), "_addbc", 6) == 0);
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_erase()
|
|
{
|
|
std::cout << "testMethod_erase()\n";
|
|
cm::String str = "abcdefg";
|
|
str.erase(5).erase(1, 2);
|
|
ASSERT_TRUE(str.size() == 3);
|
|
ASSERT_TRUE(std::strncmp(str.data(), "ade", 3) == 0);
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_push_back()
|
|
{
|
|
std::cout << "testMethod_push_back()\n";
|
|
cm::String str = "abc";
|
|
str.push_back('d');
|
|
ASSERT_TRUE(str == "abcd");
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_pop_back()
|
|
{
|
|
std::cout << "testMethod_pop_back()\n";
|
|
cm::String str = "abc";
|
|
str.pop_back();
|
|
ASSERT_TRUE(str == "ab");
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_replace()
|
|
{
|
|
std::cout << "testMethod_replace()\n";
|
|
{
|
|
cm::String str = "abcd";
|
|
const char* bc = "bc";
|
|
ASSERT_TRUE(str.replace(1, 2, "BC") == "aBCd");
|
|
ASSERT_TRUE(str.replace(1, 2, bc) == "abcd");
|
|
ASSERT_TRUE(str.replace(1, 2, 'x') == "axd");
|
|
ASSERT_TRUE(str.replace(1, 1, std::string("bc")) == "abcd");
|
|
ASSERT_TRUE(str.replace(1, 2, cm::string_view("BC", 2)) == "aBCd");
|
|
ASSERT_TRUE(str.replace(1, 2, cm::String("bc")) == "abcd");
|
|
}
|
|
{
|
|
cm::String str = "abcd";
|
|
const char* bc = "bc";
|
|
ASSERT_TRUE(str.replace(str.begin() + 1, str.begin() + 3, "BC") == "aBCd");
|
|
ASSERT_TRUE(str.replace(str.begin() + 1, str.begin() + 3, bc) == "abcd");
|
|
ASSERT_TRUE(str.replace(str.begin() + 1, str.begin() + 3, 'x') == "axd");
|
|
ASSERT_TRUE(str.replace(str.begin() + 1, str.begin() + 2,
|
|
std::string("bc")) == "abcd");
|
|
ASSERT_TRUE(str.replace(str.begin() + 1, str.begin() + 3,
|
|
cm::string_view("BC", 2)) == "aBCd");
|
|
ASSERT_TRUE(str.replace(str.begin() + 1, str.begin() + 3,
|
|
cm::String("bc")) == "abcd");
|
|
}
|
|
{
|
|
cm::String str = "abcd";
|
|
const char* bc = "_bc";
|
|
ASSERT_TRUE(str.replace(1, 2, "_BC_", 1, 2) == "aBCd");
|
|
ASSERT_TRUE(str.replace(1, 2, bc, 1) == "abcd");
|
|
ASSERT_TRUE(str.replace(1, 2, 'x', 0) == "axd");
|
|
ASSERT_TRUE(str.replace(1, 1, std::string("_bc_"), 1, 2) == "abcd");
|
|
ASSERT_TRUE(str.replace(1, 2, cm::string_view("_BC", 3), 1) == "aBCd");
|
|
ASSERT_TRUE(str.replace(1, 2, cm::String("_bc_"), 1, 2) == "abcd");
|
|
}
|
|
{
|
|
cm::String str = "abcd";
|
|
const char* bc = "_bc_";
|
|
ASSERT_TRUE(str.replace(1, 2, 2, 'x') == "axxd");
|
|
ASSERT_TRUE(str.replace(str.begin() + 1, str.begin() + 3, 2, 'y') ==
|
|
"ayyd");
|
|
ASSERT_TRUE(
|
|
str.replace(str.begin() + 1, str.begin() + 3, bc + 1, bc + 3) == "abcd");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_copy()
|
|
{
|
|
std::cout << "testMethod_copy()\n";
|
|
cm::String str = "abc";
|
|
char dest[2];
|
|
cm::String::size_type n = str.copy(dest, 2, 1);
|
|
ASSERT_TRUE(n == 2);
|
|
ASSERT_TRUE(std::strncmp(dest, "bc", 2) == 0);
|
|
n = str.copy(dest, 2);
|
|
ASSERT_TRUE(n == 2);
|
|
ASSERT_TRUE(std::strncmp(dest, "ab", 2) == 0);
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_resize()
|
|
{
|
|
std::cout << "testMethod_resize()\n";
|
|
cm::String str = "abc";
|
|
str.resize(3);
|
|
ASSERT_TRUE(str == "abc");
|
|
str.resize(2);
|
|
ASSERT_TRUE(str == "ab");
|
|
str.resize(3, 'c');
|
|
ASSERT_TRUE(str == "abc");
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_swap()
|
|
{
|
|
std::cout << "testMethod_swap()\n";
|
|
cm::String str1 = std::string("1");
|
|
cm::String str2 = std::string("2");
|
|
str1.swap(str2);
|
|
ASSERT_TRUE(str1 == "2");
|
|
ASSERT_TRUE(str2 == "1");
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_substr_AtEnd(cm::String str)
|
|
{
|
|
cm::String substr = str.substr(1);
|
|
ASSERT_TRUE(substr.data() == str.data() + 1);
|
|
ASSERT_TRUE(substr.size() == 2);
|
|
ASSERT_TRUE(!substr.is_stable());
|
|
|
|
// c_str() at the end of the buffer does not internally mutate.
|
|
ASSERT_TRUE(std::strcmp(substr.c_str(), "bc") == 0);
|
|
ASSERT_TRUE(substr.c_str() == str.data() + 1);
|
|
ASSERT_TRUE(substr.data() == str.data() + 1);
|
|
ASSERT_TRUE(substr.size() == 2);
|
|
ASSERT_TRUE(!substr.is_stable());
|
|
|
|
// str() internally mutates.
|
|
ASSERT_TRUE(substr.str() == "bc");
|
|
ASSERT_TRUE(substr.is_stable());
|
|
ASSERT_TRUE(substr.data() != str.data() + 1);
|
|
ASSERT_TRUE(substr.size() == 2);
|
|
ASSERT_TRUE(substr.c_str() != str.data() + 1);
|
|
ASSERT_TRUE(std::strcmp(substr.c_str(), "bc") == 0);
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_substr_AtEndBorrowed()
|
|
{
|
|
std::cout << "testMethod_substr_AtEndBorrowed()\n";
|
|
return testMethod_substr_AtEnd("abc"_s);
|
|
}
|
|
|
|
static bool testMethod_substr_AtEndOwned()
|
|
{
|
|
std::cout << "testMethod_substr_AtEndOwned()\n";
|
|
return testMethod_substr_AtEnd(std::string("abc"));
|
|
}
|
|
|
|
static bool testMethod_substr_AtStart(cm::String str)
|
|
{
|
|
{
|
|
cm::String substr = str.substr(0, 2);
|
|
ASSERT_TRUE(substr.data() == str.data());
|
|
ASSERT_TRUE(substr.size() == 2);
|
|
|
|
// c_str() not at the end of the buffer internally mutates.
|
|
const char* substr_c = substr.c_str();
|
|
ASSERT_TRUE(std::strcmp(substr_c, "ab") == 0);
|
|
ASSERT_TRUE(substr_c != str.data());
|
|
ASSERT_TRUE(substr.data() != str.data());
|
|
ASSERT_TRUE(substr.size() == 2);
|
|
ASSERT_TRUE(substr.is_stable());
|
|
|
|
// str() does not need to internally mutate after c_str() did so
|
|
ASSERT_TRUE(substr.str() == "ab");
|
|
ASSERT_TRUE(substr.is_stable());
|
|
ASSERT_TRUE(substr.data() == substr_c);
|
|
ASSERT_TRUE(substr.size() == 2);
|
|
ASSERT_TRUE(substr.c_str() == substr_c);
|
|
}
|
|
|
|
{
|
|
cm::String substr = str.substr(0, 2);
|
|
ASSERT_TRUE(substr.data() == str.data());
|
|
ASSERT_TRUE(substr.size() == 2);
|
|
ASSERT_TRUE(!substr.is_stable());
|
|
|
|
// str() internally mutates.
|
|
ASSERT_TRUE(substr.str() == "ab");
|
|
ASSERT_TRUE(substr.is_stable());
|
|
ASSERT_TRUE(substr.data() != str.data());
|
|
ASSERT_TRUE(substr.size() == 2);
|
|
ASSERT_TRUE(substr.c_str() != str.data());
|
|
|
|
// c_str() does not internally after str() did so
|
|
const char* substr_c = substr.c_str();
|
|
ASSERT_TRUE(std::strcmp(substr_c, "ab") == 0);
|
|
ASSERT_TRUE(substr_c == substr.data());
|
|
ASSERT_TRUE(substr.size() == 2);
|
|
ASSERT_TRUE(substr.is_stable());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_substr_AtStartBorrowed()
|
|
{
|
|
std::cout << "testMethod_substr_AtStartBorrowed()\n";
|
|
return testMethod_substr_AtStart("abc"_s);
|
|
}
|
|
|
|
static bool testMethod_substr_AtStartOwned()
|
|
{
|
|
std::cout << "testMethod_substr_AtStartOwned()\n";
|
|
return testMethod_substr_AtStart(std::string("abc"));
|
|
}
|
|
|
|
static bool testMethod_compare()
|
|
{
|
|
std::cout << "testMethod_compare()\n";
|
|
cm::String str = "b";
|
|
ASSERT_TRUE(str.compare("a") > 0);
|
|
ASSERT_TRUE(str.compare("b") == 0);
|
|
ASSERT_TRUE(str.compare("c") < 0);
|
|
{
|
|
const char* a = "a";
|
|
const char* b = "b";
|
|
const char* c = "c";
|
|
ASSERT_TRUE(str.compare(a) > 0);
|
|
ASSERT_TRUE(str.compare(b) == 0);
|
|
ASSERT_TRUE(str.compare(c) < 0);
|
|
}
|
|
ASSERT_TRUE(str.compare('a') > 0);
|
|
ASSERT_TRUE(str.compare('b') == 0);
|
|
ASSERT_TRUE(str.compare('c') < 0);
|
|
ASSERT_TRUE(str.compare(std::string("a")) > 0);
|
|
ASSERT_TRUE(str.compare(std::string("b")) == 0);
|
|
ASSERT_TRUE(str.compare(std::string("c")) < 0);
|
|
ASSERT_TRUE(str.compare(cm::string_view("a_", 1)) > 0);
|
|
ASSERT_TRUE(str.compare(cm::string_view("b_", 1)) == 0);
|
|
ASSERT_TRUE(str.compare(cm::string_view("c_", 1)) < 0);
|
|
ASSERT_TRUE(str.compare(cm::String("a")) > 0);
|
|
ASSERT_TRUE(str.compare(cm::String("b")) == 0);
|
|
ASSERT_TRUE(str.compare(cm::String("c")) < 0);
|
|
ASSERT_TRUE(str.compare(0, 1, cm::string_view("a", 1)) > 0);
|
|
ASSERT_TRUE(str.compare(1, 0, cm::string_view("", 0)) == 0);
|
|
ASSERT_TRUE(str.compare(0, 1, cm::string_view("ac", 2), 1, 1) < 0);
|
|
ASSERT_TRUE(str.compare(1, 0, "") == 0);
|
|
ASSERT_TRUE(str.compare(1, 0, "_", 0) == 0);
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_find()
|
|
{
|
|
std::cout << "testMethod_find()\n";
|
|
cm::String str = "abcabc";
|
|
ASSERT_TRUE(str.find("a") == 0);
|
|
ASSERT_TRUE(str.find("a", 1) == 3);
|
|
{
|
|
const char* a = "a";
|
|
ASSERT_TRUE(str.find(a) == 0);
|
|
ASSERT_TRUE(str.find(a, 1) == 3);
|
|
}
|
|
ASSERT_TRUE(str.find('a') == 0);
|
|
ASSERT_TRUE(str.find('a', 1) == 3);
|
|
ASSERT_TRUE(str.find(std::string("a")) == 0);
|
|
ASSERT_TRUE(str.find(std::string("a"), 1) == 3);
|
|
ASSERT_TRUE(str.find(cm::string_view("a_", 1)) == 0);
|
|
ASSERT_TRUE(str.find(cm::string_view("a_", 1), 1) == 3);
|
|
ASSERT_TRUE(str.find(cm::String("a")) == 0);
|
|
ASSERT_TRUE(str.find(cm::String("a"), 1) == 3);
|
|
ASSERT_TRUE(str.find("ab_", 1, 2) == 3);
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_rfind()
|
|
{
|
|
std::cout << "testMethod_rfind()\n";
|
|
cm::String str = "abcabc";
|
|
ASSERT_TRUE(str.rfind("a") == 3);
|
|
ASSERT_TRUE(str.rfind("a", 1) == 0);
|
|
{
|
|
const char* a = "a";
|
|
ASSERT_TRUE(str.rfind(a) == 3);
|
|
ASSERT_TRUE(str.rfind(a, 1) == 0);
|
|
}
|
|
ASSERT_TRUE(str.rfind('a') == 3);
|
|
ASSERT_TRUE(str.rfind('a', 1) == 0);
|
|
ASSERT_TRUE(str.rfind(std::string("a")) == 3);
|
|
ASSERT_TRUE(str.rfind(std::string("a"), 1) == 0);
|
|
ASSERT_TRUE(str.rfind(cm::string_view("a_", 1)) == 3);
|
|
ASSERT_TRUE(str.rfind(cm::string_view("a_", 1), 1) == 0);
|
|
ASSERT_TRUE(str.rfind(cm::String("a")) == 3);
|
|
ASSERT_TRUE(str.rfind(cm::String("a"), 1) == 0);
|
|
ASSERT_TRUE(str.rfind("ab_", 1, 2) == 0);
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_find_first_of()
|
|
{
|
|
std::cout << "testMethod_find_first_of()\n";
|
|
cm::String str = "abcabc";
|
|
ASSERT_TRUE(str.find_first_of("_a") == 0);
|
|
ASSERT_TRUE(str.find_first_of("_a", 1) == 3);
|
|
{
|
|
const char* a = "_a";
|
|
ASSERT_TRUE(str.find_first_of(a) == 0);
|
|
ASSERT_TRUE(str.find_first_of(a, 1) == 3);
|
|
}
|
|
ASSERT_TRUE(str.find_first_of('a') == 0);
|
|
ASSERT_TRUE(str.find_first_of('a', 1) == 3);
|
|
ASSERT_TRUE(str.find_first_of(std::string("_a")) == 0);
|
|
ASSERT_TRUE(str.find_first_of(std::string("_a"), 1) == 3);
|
|
ASSERT_TRUE(str.find_first_of(cm::string_view("ba_", 1)) == 1);
|
|
ASSERT_TRUE(str.find_first_of(cm::string_view("ba_", 1), 2) == 4);
|
|
ASSERT_TRUE(str.find_first_of(cm::String("ab")) == 0);
|
|
ASSERT_TRUE(str.find_first_of(cm::String("ab"), 2) == 3);
|
|
ASSERT_TRUE(str.find_first_of("_ab", 1, 2) == 3);
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_find_first_not_of()
|
|
{
|
|
std::cout << "testMethod_find_first_not_of()\n";
|
|
cm::String str = "abcabc";
|
|
ASSERT_TRUE(str.find_first_not_of("_a") == 1);
|
|
ASSERT_TRUE(str.find_first_not_of("_a", 2) == 2);
|
|
{
|
|
const char* a = "_a";
|
|
ASSERT_TRUE(str.find_first_not_of(a) == 1);
|
|
ASSERT_TRUE(str.find_first_not_of(a, 2) == 2);
|
|
}
|
|
ASSERT_TRUE(str.find_first_not_of('a') == 1);
|
|
ASSERT_TRUE(str.find_first_not_of('a', 2) == 2);
|
|
ASSERT_TRUE(str.find_first_not_of(std::string("_a")) == 1);
|
|
ASSERT_TRUE(str.find_first_not_of(std::string("_a"), 2) == 2);
|
|
ASSERT_TRUE(str.find_first_not_of(cm::string_view("ba_", 1)) == 0);
|
|
ASSERT_TRUE(str.find_first_not_of(cm::string_view("ba_", 1), 1) == 2);
|
|
ASSERT_TRUE(str.find_first_not_of(cm::String("_a")) == 1);
|
|
ASSERT_TRUE(str.find_first_not_of(cm::String("_a"), 2) == 2);
|
|
ASSERT_TRUE(str.find_first_not_of("_bca", 1, 3) == 3);
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_find_last_of()
|
|
{
|
|
std::cout << "testMethod_find_last_of()\n";
|
|
cm::String str = "abcabc";
|
|
ASSERT_TRUE(str.find_last_of("_a") == 3);
|
|
ASSERT_TRUE(str.find_last_of("_a", 1) == 0);
|
|
{
|
|
const char* a = "_a";
|
|
ASSERT_TRUE(str.find_last_of(a) == 3);
|
|
ASSERT_TRUE(str.find_last_of(a, 1) == 0);
|
|
}
|
|
ASSERT_TRUE(str.find_last_of('a') == 3);
|
|
ASSERT_TRUE(str.find_last_of('a', 1) == 0);
|
|
ASSERT_TRUE(str.find_last_of(std::string("_a")) == 3);
|
|
ASSERT_TRUE(str.find_last_of(std::string("_a"), 1) == 0);
|
|
ASSERT_TRUE(str.find_last_of(cm::string_view("ba_", 1)) == 4);
|
|
ASSERT_TRUE(str.find_last_of(cm::string_view("ba_", 1), 2) == 1);
|
|
ASSERT_TRUE(str.find_last_of(cm::String("ab")) == 4);
|
|
ASSERT_TRUE(str.find_last_of(cm::String("ab"), 2) == 1);
|
|
ASSERT_TRUE(str.find_last_of("_ab", 1, 2) == 0);
|
|
return true;
|
|
}
|
|
|
|
static bool testMethod_find_last_not_of()
|
|
{
|
|
std::cout << "testMethod_find_last_not_of()\n";
|
|
cm::String str = "abcabc";
|
|
ASSERT_TRUE(str.find_last_not_of("_a") == 5);
|
|
ASSERT_TRUE(str.find_last_not_of("_a", 1) == 1);
|
|
{
|
|
const char* a = "_a";
|
|
ASSERT_TRUE(str.find_last_not_of(a) == 5);
|
|
ASSERT_TRUE(str.find_last_not_of(a, 1) == 1);
|
|
}
|
|
ASSERT_TRUE(str.find_last_not_of('a') == 5);
|
|
ASSERT_TRUE(str.find_last_not_of('a', 1) == 1);
|
|
ASSERT_TRUE(str.find_last_not_of(std::string("_a")) == 5);
|
|
ASSERT_TRUE(str.find_last_not_of(std::string("_a"), 1) == 1);
|
|
ASSERT_TRUE(str.find_last_not_of(cm::string_view("cb_", 1)) == 4);
|
|
ASSERT_TRUE(str.find_last_not_of(cm::string_view("cb_", 1), 2) == 1);
|
|
ASSERT_TRUE(str.find_last_not_of(cm::String("_a")) == 5);
|
|
ASSERT_TRUE(str.find_last_not_of(cm::String("_a"), 1) == 1);
|
|
ASSERT_TRUE(str.find_last_not_of("cb_", 2, 2) == 0);
|
|
return true;
|
|
}
|
|
|
|
static bool testAddition()
|
|
{
|
|
std::cout << "testAddition()\n";
|
|
{
|
|
ASSERT_TRUE(cm::String("a") + "b" == "ab");
|
|
ASSERT_TRUE("ab" == "a" + cm::String("b"));
|
|
ASSERT_TRUE("a" + cm::String("b") + "c" == "abc");
|
|
ASSERT_TRUE("abc" == "a" + cm::String("b") + "c");
|
|
ASSERT_TRUE("a" + (cm::String("b") + "c") + "d" == "abcd");
|
|
ASSERT_TRUE("abcd" == "a" + (cm::String("b") + "c") + "d");
|
|
}
|
|
{
|
|
ASSERT_TRUE(cm::String("a"_s) + "b"_s == "ab"_s);
|
|
ASSERT_TRUE("ab"_s == "a"_s + cm::String("b"_s));
|
|
ASSERT_TRUE("a"_s + cm::String("b"_s) + "c"_s == "abc"_s);
|
|
ASSERT_TRUE("abc"_s == "a"_s + cm::String("b"_s) + "c"_s);
|
|
ASSERT_TRUE("a"_s + (cm::String("b"_s) + "c"_s) + "d"_s == "abcd"_s);
|
|
ASSERT_TRUE("abcd"_s == "a"_s + (cm::String("b"_s) + "c"_s) + "d"_s);
|
|
}
|
|
{
|
|
const char* a = "a";
|
|
const char* b = "b";
|
|
const char* ab = "ab";
|
|
ASSERT_TRUE(cm::String(a) + b == ab);
|
|
ASSERT_TRUE(ab == a + cm::String(b));
|
|
const char* c = "c";
|
|
const char* abc = "abc";
|
|
ASSERT_TRUE(a + cm::String(b) + c == abc);
|
|
ASSERT_TRUE(abc == a + cm::String(b) + c);
|
|
const char* d = "d";
|
|
const char* abcd = "abcd";
|
|
ASSERT_TRUE(a + (cm::String(b) + c) + d == abcd);
|
|
ASSERT_TRUE(abcd == a + (cm::String(b) + c) + d);
|
|
}
|
|
{
|
|
ASSERT_TRUE(cm::String('a') + 'b' == "ab");
|
|
ASSERT_TRUE("ab" == 'a' + cm::String('b'));
|
|
ASSERT_TRUE('a' + cm::String('b') + 'c' == "abc");
|
|
ASSERT_TRUE("abc" == 'a' + cm::String('b') + 'c');
|
|
ASSERT_TRUE('a' + (cm::String('b') + 'c') + 'd' == "abcd");
|
|
ASSERT_TRUE("abcd" == 'a' + (cm::String('b') + 'c') + 'd');
|
|
}
|
|
{
|
|
std::string a = "a";
|
|
std::string b = "b";
|
|
std::string ab = "ab";
|
|
ASSERT_TRUE(cm::String(a) + b == ab);
|
|
ASSERT_TRUE(ab == a + cm::String(b));
|
|
std::string c = "c";
|
|
std::string abc = "abc";
|
|
ASSERT_TRUE(a + cm::String(b) + c == abc);
|
|
ASSERT_TRUE(abc == a + cm::String(b) + c);
|
|
std::string d = "d";
|
|
std::string abcd = "abcd";
|
|
ASSERT_TRUE(a + (cm::String(b) + c) + d == abcd);
|
|
ASSERT_TRUE(abcd == a + (cm::String(b) + c) + d);
|
|
}
|
|
{
|
|
cm::string_view a("a", 1);
|
|
cm::string_view b("b", 1);
|
|
cm::string_view ab("ab", 2);
|
|
ASSERT_TRUE(cm::String(a) + b == ab);
|
|
ASSERT_TRUE(ab == a + cm::String(b));
|
|
cm::string_view c("c", 1);
|
|
cm::string_view abc("abc", 3);
|
|
ASSERT_TRUE(a + cm::String(b) + c == abc);
|
|
ASSERT_TRUE(abc == a + cm::String(b) + c);
|
|
cm::string_view d("d", 1);
|
|
cm::string_view abcd("abcd", 4);
|
|
ASSERT_TRUE(a + (cm::String(b) + c) + d == abcd);
|
|
ASSERT_TRUE(abcd == a + (cm::String(b) + c) + d);
|
|
}
|
|
{
|
|
cm::String a = "a";
|
|
cm::String b = "b";
|
|
cm::String ab = "ab";
|
|
ASSERT_TRUE(a + b == ab);
|
|
ASSERT_TRUE(ab == a + b);
|
|
cm::String c = "c";
|
|
cm::String abc = "abc";
|
|
ASSERT_TRUE(a + cm::String(b) + c == abc);
|
|
ASSERT_TRUE(abc == a + cm::String(b) + c);
|
|
cm::String d = "d";
|
|
cm::String abcd = "abcd";
|
|
ASSERT_TRUE(a + (cm::String(b) + c) + d == abcd);
|
|
ASSERT_TRUE(abcd == a + (cm::String(b) + c) + d);
|
|
}
|
|
{
|
|
cm::String str;
|
|
str += "a" + cm::String("b") + 'c';
|
|
ASSERT_TRUE(str == "abc");
|
|
ASSERT_TRUE(str.is_stable());
|
|
}
|
|
{
|
|
std::string s;
|
|
s += "a" + cm::String("b") + 'c';
|
|
ASSERT_TRUE(s == "abc");
|
|
}
|
|
{
|
|
std::ostringstream ss;
|
|
ss << ("a" + cm::String("b") + 'c');
|
|
ASSERT_TRUE(ss.str() == "abc");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool testStability()
|
|
{
|
|
std::cout << "testStability()\n";
|
|
cm::String str = "abc"_s;
|
|
ASSERT_TRUE(!str.is_stable());
|
|
ASSERT_TRUE(str.str_if_stable() == nullptr);
|
|
str.stabilize();
|
|
ASSERT_TRUE(str.is_stable());
|
|
std::string const* str_if_stable = str.str_if_stable();
|
|
ASSERT_TRUE(str_if_stable != nullptr);
|
|
ASSERT_TRUE(*str_if_stable == "abc");
|
|
str.stabilize();
|
|
ASSERT_TRUE(str.is_stable());
|
|
ASSERT_TRUE(str.str_if_stable() == str_if_stable);
|
|
return true;
|
|
}
|
|
|
|
int testString(int /*unused*/, char* /*unused*/ [])
|
|
{
|
|
if (!testConstructDefault()) {
|
|
return 1;
|
|
}
|
|
if (!testConstructFromNullPtr()) {
|
|
return 1;
|
|
}
|
|
if (!testConstructFromCStrNull()) {
|
|
return 1;
|
|
}
|
|
if (!testConstructFromCharArray()) {
|
|
return 1;
|
|
}
|
|
if (!testConstructFromCStr()) {
|
|
return 1;
|
|
}
|
|
if (!testConstructFromStdString()) {
|
|
return 1;
|
|
}
|
|
if (!testConstructFromView()) {
|
|
return 1;
|
|
}
|
|
if (!testConstructFromChar()) {
|
|
return 1;
|
|
}
|
|
if (!testConstructFromInitList()) {
|
|
return 1;
|
|
}
|
|
if (!testConstructFromBuffer()) {
|
|
return 1;
|
|
}
|
|
if (!testConstructFromInputIterator()) {
|
|
return 1;
|
|
}
|
|
if (!testConstructFromN()) {
|
|
return 1;
|
|
}
|
|
if (!testConstructFromStaticStringView()) {
|
|
return 1;
|
|
}
|
|
if (!testConstructCopy()) {
|
|
return 1;
|
|
}
|
|
if (!testConstructMove()) {
|
|
return 1;
|
|
}
|
|
if (!testAssignCopy()) {
|
|
return 1;
|
|
}
|
|
if (!testAssignMove()) {
|
|
return 1;
|
|
}
|
|
if (!testAssignFromChar()) {
|
|
return 1;
|
|
}
|
|
if (!testAssignFromView()) {
|
|
return 1;
|
|
}
|
|
if (!testAssignFromStdString()) {
|
|
return 1;
|
|
}
|
|
if (!testAssignFromCStr()) {
|
|
return 1;
|
|
}
|
|
if (!testAssignFromCharArray()) {
|
|
return 1;
|
|
}
|
|
if (!testAssignFromCStrNull()) {
|
|
return 1;
|
|
}
|
|
if (!testAssignFromNullPtr()) {
|
|
return 1;
|
|
}
|
|
if (!testAssignFromInitList()) {
|
|
return 1;
|
|
}
|
|
if (!testAssignFromStaticStringView()) {
|
|
return 1;
|
|
}
|
|
if (!testOperatorBool()) {
|
|
return 1;
|
|
}
|
|
if (!testOperatorIndex()) {
|
|
return 1;
|
|
}
|
|
if (!testOperatorPlusEqual()) {
|
|
return 1;
|
|
}
|
|
if (!testOperatorCompare()) {
|
|
return 1;
|
|
}
|
|
if (!testOperatorStream()) {
|
|
return 1;
|
|
}
|
|
if (!testOperatorStdStringPlusEqual()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_borrow()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_view()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_empty()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_length()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_at()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_front_back()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_clear()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_insert()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_erase()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_push_back()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_pop_back()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_replace()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_copy()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_resize()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_swap()) {
|
|
return 1;
|
|
}
|
|
if (!testMethodIterators()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_substr_AtEndBorrowed()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_substr_AtEndOwned()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_substr_AtStartBorrowed()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_substr_AtStartOwned()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_compare()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_find()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_rfind()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_find_first_of()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_find_first_not_of()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_find_last_of()) {
|
|
return 1;
|
|
}
|
|
if (!testMethod_find_last_not_of()) {
|
|
return 1;
|
|
}
|
|
if (!testAddition()) {
|
|
return 1;
|
|
}
|
|
if (!testStability()) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|