String: Add a custom string type

Create a `cm::String` type that holds a view of a string buffer and
optionally shares ownership of the buffer.  Instances can either
borrow longer-lived storage (e.g. static storage of string literals)
or internally own a `std::string` instance.  In the latter case,
share ownership with copies and substrings.  Allocate a new internal
string only on operations that require mutation.

This will allow us to recover string sharing semantics that we
used to get from C++98 std::string copy-on-write implementations.
Such implementations are not allowed by C++11 so code our own in
a custom string type instead.

Source/CMakeLists.txt

@@ -568,6 +568,8 @@ set(SRCS
   cmSiteNameCommand.h
   cmSourceGroupCommand.cxx
   cmSourceGroupCommand.h
+  cmString.cxx
+  cmString.hxx
   cmStringReplaceHelper.cxx
   cmStringCommand.cxx
   cmStringCommand.h

Source/cmString.cxx

@@ -0,0 +1,131 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#define _SCL_SECURE_NO_WARNINGS
+
+#include "cmString.hxx"
+
+#include <memory>
+#include <ostream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+
+namespace cm {
+
+static std::string const empty_string_;
+
+void String::internally_mutate_to_stable_string()
+{
+  // We assume that only one thread mutates this instance at
+  // a time even if we point to a shared string buffer refernced
+  // by other threads.
+  *this = String(data(), size());
+}
+
+std::string const& String::str()
+{
+  if (!data()) {
+    // We view no string.
+    // This is stable for the lifetime of our current value.
+    return empty_string_;
+  }
+
+  if (string_ && data() == string_->data() && size() == string_->size()) {
+    // We view an entire string.
+    // This is stable for the lifetime of our current value.
+    return *string_;
+  }
+
+  // Mutate to hold a std::string that is stable for the lifetime
+  // of our current value.
+  this->internally_mutate_to_stable_string();
+  return *string_;
+}
+
+const char* String::c_str()
+{
+  const char* c = data();
+  if (c == nullptr) {
+    return c;
+  }
+
+  // We always point into a null-terminated string so it is safe to
+  // access one past the end.  If it is a null byte then we can use
+  // the pointer directly.
+  if (c[size()] == '\0') {
+    return c;
+  }
+
+  // Mutate to hold a std::string so we can get a null terminator.
+  this->internally_mutate_to_stable_string();
+  c = string_->c_str();
+  return c;
+}
+
+String& String::insert(size_type index, size_type count, char ch)
+{
+  std::string s;
+  s.reserve(size() + count);
+  s.assign(data(), size());
+  s.insert(index, count, ch);
+  return *this = std::move(s);
+}
+
+String& String::erase(size_type index, size_type count)
+{
+  if (index > size()) {
+    throw std::out_of_range("Index out of range in String::erase");
+  }
+  size_type const rcount = std::min(count, size() - index);
+  size_type const rindex = index + rcount;
+  std::string s;
+  s.reserve(size() - rcount);
+  s.assign(data(), index);
+  s.append(data() + rindex, size() - rindex);
+  return *this = std::move(s);
+}
+
+String String::substr(size_type pos, size_type count) const
+{
+  if (pos > size()) {
+    throw std::out_of_range("Index out of range in String::substr");
+  }
+  return String(*this, pos, count);
+}
+
+String::String(std::string&& s, Private)
+  : string_(std::make_shared<std::string>(std::move(s)))
+  , view_(string_->data(), string_->size())
+{
+}
+
+String::size_type String::copy(char* dest, size_type count,
+                               size_type pos) const
+{
+  return view_.copy(dest, count, pos);
+}
+
+std::ostream& operator<<(std::ostream& os, String const& s)
+{
+  return os.write(s.data(), s.size());
+}
+
+std::string& operator+=(std::string& self, String const& s)
+{
+  return self += s.view();
+}
+
+String IntoString<char*>::into_string(const char* s)
+{
+  if (!s) {
+    return String();
+  }
+  return std::string(s);
+}
+
+string_view AsStringView<String>::view(String const& s)
+{
+  return s.view();
+}
+
+} // namespace cm

Source/cmString.hxx

@@ -0,0 +1,683 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+#ifndef cmString_hxx
+#define cmString_hxx
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include "cm_string_view.hxx"
+
+#include <algorithm>
+#include <functional>
+#include <initializer_list>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <type_traits>
+
+namespace cm {
+
+class String;
+
+/**
+ * Trait to convert type T into a String.
+ * Implementations must derive from 'std::true_type'
+ * and define an 'into_string' member that accepts
+ * type T (by value or reference) and returns one of:
+ *
+ * - 'std::string' to construct an owned instance.
+ * - 'cm::string_view' to construct a borrowed or null instances.
+ *   The buffer from which the view is borrowed must outlive
+ *   all copies of the resulting String, e.g. static storage.
+ * - 'cm::String' for already-constructed instances.
+ */
+template <typename T>
+struct IntoString : std::false_type
+{
+};
+
+template <typename T>
+struct IntoString<T&> : IntoString<T>
+{
+};
+
+template <typename T>
+struct IntoString<T const> : IntoString<T>
+{
+};
+
+template <typename T>
+struct IntoString<T const*> : IntoString<T*>
+{
+};
+
+template <typename T, std::string::size_type N>
+struct IntoString<T const[N]> : IntoString<T[N]>
+{
+};
+
+template <>
+struct IntoString<char*> : std::true_type
+{
+  static String into_string(const char* s);
+};
+
+template <>
+struct IntoString<std::nullptr_t> : std::true_type
+{
+  static string_view into_string(std::nullptr_t) { return string_view(); }
+};
+
+template <std::string::size_type N>
+struct IntoString<char[N]> : std::true_type
+{
+  static std::string into_string(char const (&s)[N])
+  {
+    return std::string(s, N - 1);
+  }
+};
+
+template <>
+struct IntoString<std::string> : std::true_type
+{
+  static std::string into_string(std::string s) { return s; }
+};
+
+template <>
+struct IntoString<string_view> : std::true_type
+{
+  static std::string into_string(string_view s) { return std::string(s); }
+};
+
+template <>
+struct IntoString<char> : std::true_type
+{
+  static std::string into_string(char const& c) { return std::string(1, c); }
+};
+
+/**
+ * Trait to convert type T into a 'cm::string_view'.
+ * Implementations must derive from 'std::true_type' and
+ * define a 'view' member that accepts type T (by reference)
+ * and returns a 'cm::string_view'.
+ */
+template <typename T>
+struct AsStringView : std::false_type
+{
+};
+
+template <typename T>
+struct AsStringView<T&> : AsStringView<T>
+{
+};
+
+template <typename T>
+struct AsStringView<T const> : AsStringView<T>
+{
+};
+
+template <typename T>
+struct AsStringView<T const*> : AsStringView<T*>
+{
+};
+
+template <typename T, std::string::size_type N>
+struct AsStringView<T const[N]> : AsStringView<T[N]>
+{
+};
+
+template <>
+struct AsStringView<char*> : std::true_type
+{
+  static string_view view(const char* s) { return s; }
+};
+
+template <std::string::size_type N>
+struct AsStringView<char[N]> : std::true_type
+{
+  static string_view view(char const (&s)[N]) { return string_view(s, N - 1); }
+};
+
+template <>
+struct AsStringView<std::string> : std::true_type
+{
+  static string_view view(std::string const& s) { return s; }
+};
+
+template <>
+struct AsStringView<char> : std::true_type
+{
+  static string_view view(const char& s) { return string_view(&s, 1); }
+};
+
+template <>
+struct AsStringView<string_view> : std::true_type
+{
+  static string_view view(string_view const& s) { return s; }
+};
+
+template <>
+struct AsStringView<String> : std::true_type
+{
+  static string_view view(String const& s);
+};
+
+/**
+ * \class String
+ *
+ * A custom string type that holds a view of a string buffer
+ * and optionally shares ownership of the buffer.  Instances
+ * may have one of the following states:
+ *
+ * - null: views and owns nothing.
+ *   Conversion to 'bool' is 'false'.
+ *   'data()' and 'c_str()' return nullptr.
+ *   'size()' returns 0.
+ *   'str()' returns an empty string.
+ *
+ * - borrowed: views a string but does not own it.  This is used
+ *   to bind to static storage (e.g. string literals) or for
+ *   temporary instances that do not outlive the borrowed buffer.
+ *   Copies and substrings still borrow the original buffer.
+ *   Mutation allocates a new internal string and converts to
+ *   the 'owned' state.
+ *   Conversion to 'bool' is 'true'.
+ *   'c_str()' may internally mutate to the 'owned' state.
+ *   'str()' internally mutates to the 'owned' state.
+ *
+ * - owned: views an immutable 'std::string' instance owned internally.
+ *   Copies and substrings share ownership of the internal string.
+ *   Mutation allocates a new internal string.
+ *   Conversion to 'bool' is 'true'.
+ */
+class String
+{
+  enum class Private
+  {
+  };
+
+public:
+  using traits_type = std::string::traits_type;
+  using value_type = string_view::value_type;
+  using pointer = string_view::pointer;
+  using const_pointer = string_view::const_pointer;
+  using reference = string_view::reference;
+  using const_reference = string_view::const_reference;
+  using const_iterator = string_view::const_iterator;
+  using iterator = string_view::const_iterator;
+  using const_reverse_iterator = string_view::const_reverse_iterator;
+  using reverse_iterator = string_view::const_reverse_iterator;
+  using difference_type = string_view::difference_type;
+  using size_type = string_view::size_type;
+
+  static size_type const npos = string_view::npos;
+
+  /** Construct a null string.  */
+  String() = default;
+
+  /** Construct from any type implementing the IntoString trait.  */
+  template <typename T,
+            typename = typename std::enable_if<IntoString<T>::value>::type>
+  String(T&& s)
+    : String(IntoString<T>::into_string(std::forward<T>(s)), Private())
+  {
+  }
+
+  /** Construct via std::string initializer list constructor.  */
+  String(std::initializer_list<char> il)
+    : String(std::string(il))
+  {
+  }
+
+  /** Construct by copying the specified buffer.  */
+  String(const char* d, size_type s)
+    : String(std::string(d, s))
+  {
+  }
+
+  /** Construct by copying from input iterator range.  */
+  template <typename InputIterator>
+  String(InputIterator first, InputIterator last)
+    : String(std::string(first, last))
+  {
+  }
+
+  /** Construct a string with 'n' copies of character 'c'.  */
+  String(size_type n, char c)
+    : String(std::string(n, c))
+  {
+  }
+
+  /** Construct from a substring of another String instance.
+      This shares ownership of the other string's buffer
+      but views only a substring.  */
+  String(String const& s, size_type pos, size_type count = npos)
+    : string_(s.string_)
+    , view_(s.data() + pos, std::min(count, s.size() - pos))
+  {
+  }
+
+  /** Construct by moving from another String instance.
+      The other instance is left as a null string.  */
+  String(String&& s) noexcept
+    : string_(std::move(s.string_))
+    , view_(s.view_)
+  {
+    s.view_ = string_view();
+  }
+
+  /** Construct by copying from another String instance.
+      This shares ownership of the other string's buffer.  */
+  String(String const&) noexcept = default;
+
+  ~String() = default;
+
+  /** Assign by moving from another String instance.
+      The other instance is left as a null string.  */
+  String& operator=(String&& s) noexcept
+  {
+    string_ = std::move(s.string_);
+    view_ = s.view_;
+    s.view_ = string_view();
+    return *this;
+  }
+
+  /** Assign by copying from another String instance.
+      This shares ownership of the other string's buffer.  */
+  String& operator=(String const&) noexcept = default;
+
+  /** Assign from any type implementing the IntoString trait.  */
+  template <typename T>
+  typename // NOLINT(*)
+    std::enable_if<IntoString<T>::value, String&>::type
+    operator=(T&& s)
+  {
+    *this = String(std::forward<T>(s));
+    return *this;
+  }
+
+  /** Assign via std::string initializer list constructor.  */
+  String& operator=(std::initializer_list<char> il)
+  {
+    *this = String(il);
+    return *this;
+  }
+
+  /** Return true if the instance is not a null string.  */
+  explicit operator bool() const noexcept { return data() != nullptr; }
+
+  /** Return a view of the string.  */
+  string_view view() const noexcept { return view_; }
+
+  /** Return true if the instance is an empty stringn or null string.  */
+  bool empty() const noexcept { return view_.empty(); }
+
+  /** Return a pointer to the start of the string.  */
+  const char* data() const noexcept { return view_.data(); }
+
+  /** Return the length of the string in bytes.  */
+  size_type size() const noexcept { return view_.size(); }
+  size_type length() const noexcept { return view_.length(); }
+
+  /** Return the character at the given position.
+      No bounds checking is performed.  */
+  char operator[](size_type pos) const noexcept { return view_[pos]; }
+
+  /** Return the character at the given position.
+      If the position is out of bounds, throws std::out_of_range.  */
+  char at(size_type pos) const { return view_.at(pos); }
+
+  char front() const noexcept { return view_.front(); }
+
+  char back() const noexcept { return view_.back(); }
+
+  /** Get a refernce to a normal std::string.  The reference
+      is valid until this instance is mutated or destroyed.  */
+  std::string const& str();
+
+  /** Get a pointer to a C-style null-terminated string
+      containing the same value as this instance.  The pointer
+      is valid until this instance is mutated, destroyed,
+      or str() is called.  */
+  const char* c_str();
+
+  const_iterator begin() const noexcept { return view_.begin(); }
+  const_iterator end() const noexcept { return view_.end(); }
+  const_iterator cbegin() const noexcept { return begin(); }
+  const_iterator cend() const noexcept { return end(); }
+
+  const_reverse_iterator rbegin() const noexcept { return view_.rbegin(); }
+  const_reverse_iterator rend() const noexcept { return view_.rend(); }
+  const_reverse_iterator crbegin() const noexcept { return rbegin(); }
+  const_reverse_iterator crend() const noexcept { return rend(); }
+
+  /** Append to the string using any type that implements the
+      AsStringView trait.  */
+  template <typename T>
+  typename std::enable_if<AsStringView<T>::value, String&>::type operator+=(
+    T&& s)
+  {
+    string_view v = AsStringView<T>::view(std::forward<T>(s));
+    std::string r;
+    r.reserve(size() + v.size());
+    r.assign(data(), size());
+    r.append(v.data(), v.size());
+    return *this = std::move(r);
+  }
+
+  /** Assign to an empty string.  */
+  void clear() { *this = String(string_view("", 0), Private()); }
+
+  /** Insert 'count' copies of 'ch' at position 'index'.  */
+  String& insert(size_type index, size_type count, char ch);
+
+  /** Erase 'count' characters starting at position 'index'.  */
+  String& erase(size_type index = 0, size_type count = npos);
+
+  void push_back(char ch)
+  {
+    std::string s;
+    s.reserve(size() + 1);
+    s.assign(data(), size());
+    s.push_back(ch);
+    *this = std::move(s);
+  }
+
+  void pop_back() { *this = String(*this, 0, size() - 1); }
+
+  template <typename T>
+  typename std::enable_if<AsStringView<T>::value, String&>::type replace(
+    size_type pos, size_type count, T&& s)
+  {
+    const_iterator first = begin() + pos;
+    const_iterator last = first + count;
+    return replace(first, last, std::forward<T>(s));
+  }
+
+  template <typename InputIterator>
+  String& replace(const_iterator first, const_iterator last,
+                  InputIterator first2, InputIterator last2)
+  {
+    std::string out;
+    out.append(view_.begin(), first);
+    out.append(first2, last2);
+    out.append(last, view_.end());
+    return *this = std::move(out);
+  }
+
+  template <typename T>
+  typename std::enable_if<AsStringView<T>::value, String&>::type replace(
+    const_iterator first, const_iterator last, T&& s)
+  {
+    string_view v = AsStringView<T>::view(std::forward<T>(s));
+    std::string out;
+    out.reserve((first - view_.begin()) + v.size() + (view_.end() - last));
+    out.append(view_.begin(), first);
+    out.append(v.data(), v.size());
+    out.append(last, view_.end());
+    return *this = std::move(out);
+  }
+
+  template <typename T>
+  typename std::enable_if<AsStringView<T>::value, String&>::type replace(
+    size_type pos, size_type count, T&& s, size_type pos2,
+    size_type count2 = npos)
+  {
+    string_view v = AsStringView<T>::view(std::forward<T>(s));
+    v = v.substr(pos2, count2);
+    return replace(pos, count, v);
+  }
+
+  String& replace(size_type pos, size_type count, size_type count2, char ch)
+  {
+    const_iterator first = begin() + pos;
+    const_iterator last = first + count;
+    return replace(first, last, count2, ch);
+  }
+
+  String& replace(const_iterator first, const_iterator last, size_type count2,
+                  char ch)
+  {
+    std::string out;
+    out.reserve((first - view_.begin()) + count2 + (view_.end() - last));
+    out.append(view_.begin(), first);
+    out.append(count2, ch);
+    out.append(last, view_.end());
+    return *this = std::move(out);
+  }
+
+  size_type copy(char* dest, size_type count, size_type pos = 0) const;
+
+  void resize(size_type count) { resize(count, char()); }
+
+  void resize(size_type count, char ch)
+  {
+    std::string s;
+    s.reserve(count);
+    if (count <= size()) {
+      s.assign(data(), count);
+    } else {
+      s.assign(data(), size());
+      s.resize(count, ch);
+    }
+    *this = std::move(s);
+  }
+
+  void swap(String& other)
+  {
+    std::swap(string_, other.string_);
+    std::swap(view_, other.view_);
+  }
+
+  /** Return a substring starting at position 'pos' and
+      consisting of at most 'count' characters.  */
+  String substr(size_type pos = 0, size_type count = npos) const;
+
+  template <typename T>
+  typename std::enable_if<AsStringView<T>::value, int>::type compare(
+    T&& s) const
+  {
+    return view_.compare(AsStringView<T>::view(std::forward<T>(s)));
+  }
+
+  int compare(size_type pos1, size_type count1, string_view v) const
+  {
+    return view_.compare(pos1, count1, v);
+  }
+
+  int compare(size_type pos1, size_type count1, string_view v, size_type pos2,
+              size_type count2) const
+  {
+    return view_.compare(pos1, count1, v, pos2, count2);
+  }
+
+  int compare(size_type pos1, size_type count1, const char* s) const
+  {
+    return view_.compare(pos1, count1, s);
+  }
+
+  int compare(size_type pos1, size_type count1, const char* s,
+              size_type count2) const
+  {
+    return view_.compare(pos1, count1, s, count2);
+  }
+
+  template <typename T>
+  typename std::enable_if<AsStringView<T>::value, size_type>::type find(
+    T&& s, size_type pos = 0) const
+  {
+    string_view v = AsStringView<T>::view(std::forward<T>(s));
+    return view_.find(v, pos);
+  }
+
+  size_type find(const char* s, size_type pos, size_type count) const
+  {
+    return view_.find(s, pos, count);
+  }
+
+  template <typename T>
+  typename std::enable_if<AsStringView<T>::value, size_type>::type rfind(
+    T&& s, size_type pos = npos) const
+  {
+    string_view v = AsStringView<T>::view(std::forward<T>(s));
+    return view_.rfind(v, pos);
+  }
+
+  size_type rfind(const char* s, size_type pos, size_type count) const
+  {
+    return view_.rfind(s, pos, count);
+  }
+
+  template <typename T>
+  typename std::enable_if<AsStringView<T>::value, size_type>::type
+  find_first_of(T&& s, size_type pos = 0) const
+  {
+    string_view v = AsStringView<T>::view(std::forward<T>(s));
+    return view_.find_first_of(v, pos);
+  }
+
+  size_type find_first_of(const char* s, size_type pos, size_type count) const
+  {
+    return view_.find_first_of(s, pos, count);
+  }
+
+  template <typename T>
+  typename std::enable_if<AsStringView<T>::value, size_type>::type
+  find_first_not_of(T&& s, size_type pos = 0) const
+  {
+    string_view v = AsStringView<T>::view(std::forward<T>(s));
+    return view_.find_first_not_of(v, pos);
+  }
+
+  size_type find_first_not_of(const char* s, size_type pos,
+                              size_type count) const
+  {
+    return view_.find_first_not_of(s, pos, count);
+  }
+
+  template <typename T>
+  typename std::enable_if<AsStringView<T>::value, size_type>::type
+  find_last_of(T&& s, size_type pos = npos) const
+  {
+    string_view v = AsStringView<T>::view(std::forward<T>(s));
+    return view_.find_last_of(v, pos);
+  }
+
+  size_type find_last_of(const char* s, size_type pos, size_type count) const
+  {
+    return view_.find_last_of(s, pos, count);
+  }
+
+  template <typename T>
+  typename std::enable_if<AsStringView<T>::value, size_type>::type
+  find_last_not_of(T&& s, size_type pos = npos) const
+  {
+    string_view v = AsStringView<T>::view(std::forward<T>(s));
+    return view_.find_last_not_of(v, pos);
+  }
+
+  size_type find_last_not_of(const char* s, size_type pos,
+                             size_type count) const
+  {
+    return view_.find_last_not_of(s, pos, count);
+  }
+
+private:
+  // Internal constructor to move from existing String.
+  String(String&& s, Private) noexcept
+    : String(std::move(s))
+  {
+  }
+
+  // Internal constructor for dynamically allocated string.
+  String(std::string&& s, Private);
+
+  // Internal constructor for view of statically allocated string.
+  String(string_view v, Private)
+    : string_()
+    , view_(v)
+  {
+  }
+
+  void internally_mutate_to_stable_string();
+
+  std::shared_ptr<std::string const> string_;
+  string_view view_;
+};
+
+template <typename L, typename R>
+typename std::enable_if<AsStringView<L>::value && AsStringView<R>::value,
+                        bool>::type
+operator==(L&& l, R&& r)
+{
+  return (AsStringView<L>::view(std::forward<L>(l)) ==
+          AsStringView<R>::view(std::forward<R>(r)));
+}
+
+template <typename L, typename R>
+typename std::enable_if<AsStringView<L>::value && AsStringView<R>::value,
+                        bool>::type
+operator!=(L&& l, R&& r)
+{
+  return (AsStringView<L>::view(std::forward<L>(l)) !=
+          AsStringView<R>::view(std::forward<R>(r)));
+}
+
+template <typename L, typename R>
+typename std::enable_if<AsStringView<L>::value && AsStringView<R>::value,
+                        bool>::type
+operator<(L&& l, R&& r)
+{
+  return (AsStringView<L>::view(std::forward<L>(l)) <
+          AsStringView<R>::view(std::forward<R>(r)));
+}
+
+template <typename L, typename R>
+typename std::enable_if<AsStringView<L>::value && AsStringView<R>::value,
+                        bool>::type
+operator<=(L&& l, R&& r)
+{
+  return (AsStringView<L>::view(std::forward<L>(l)) <=
+          AsStringView<R>::view(std::forward<R>(r)));
+}
+
+template <typename L, typename R>
+typename std::enable_if<AsStringView<L>::value && AsStringView<R>::value,
+                        bool>::type
+operator>(L&& l, R&& r)
+{
+  return (AsStringView<L>::view(std::forward<L>(l)) >
+          AsStringView<R>::view(std::forward<R>(r)));
+}
+
+template <typename L, typename R>
+typename std::enable_if<AsStringView<L>::value && AsStringView<R>::value,
+                        bool>::type
+operator>=(L&& l, R&& r)
+{
+  return (AsStringView<L>::view(std::forward<L>(l)) >=
+          AsStringView<R>::view(std::forward<R>(r)));
+}
+
+std::ostream& operator<<(std::ostream& os, String const& s);
+std::string& operator+=(std::string& self, String const& s);
+
+} // namespace cm
+
+namespace std {
+
+template <>
+struct hash<cm::String>
+{
+  typedef cm::String argument_type;
+  typedef size_t result_type;
+
+  result_type operator()(argument_type const& s) const noexcept
+  {
+    result_type const h(std::hash<cm::string_view>{}(s.view()));
+    return h;
+  }
+};
+}
+
+#endif

Tests/CMakeLib/CMakeLists.txt

@@ -7,6 +7,7 @@ include_directories(
 set(CMakeLib_TESTS
   testGeneratedFileStream.cxx
   testRST.cxx
+  testString.cxx
   testSystemTools.cxx
   testUTF8.cxx
   testXMLParser.cxx

Tests/CMakeLib/testString.cxx

@@ -0,0 +1,1110 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+
+#include "cmString.hxx"
+
+#include "cm_string_view.hxx"
+
+#include <cstring>
+#include <iostream>
+#include <iterator>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+#define ASSERT_TRUE(x)                                                        \
+  if (!(x)) {                                                                 \
+    std::cout << "ASSERT_TRUE(" #x ") failed on line " << __LINE__ << "\n";   \
+    return 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.c_str() == nullptr);
+  ASSERT_TRUE(str.str().empty());
+  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.c_str() == nullptr);
+  ASSERT_TRUE(str.str().empty());
+  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.c_str() == nullptr);
+  ASSERT_TRUE(str.str().empty());
+  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.c_str() != charArray);
+  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.c_str() != &charArray[1]);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  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);
+  return true;
+}
+
+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);
+  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);
+  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);
+  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);
+  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);
+  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_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);
+
+  // 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);
+
+  // str() internally mutates.
+  ASSERT_TRUE(substr.str() == "bc");
+  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_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);
+
+    // str() does not need to internally mutate after c_str() did so
+    ASSERT_TRUE(substr.str() == "ab");
+    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);
+
+    // str() internally mutates.
+    ASSERT_TRUE(substr.str() == "ab");
+    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);
+  }
+
+  return true;
+}
+
+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;
+}
+
+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 (!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 (!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_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_AtEndOwned()) {
+    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;
+  }
+  return 0;
+}