[libc++] Add test for bug that had been introduced in D98573 and fixed in D119633

[ldionne]

If you revert D119633, this test starts failing. It looks like we forgot to add a test when we made D98573, but I think it might be because the motivation for making the change was not fixing this bug, it was implementing constexpr string.

[philnik]

In D135297#3837655, @ldionne wrote:

If you revert D119633, this test starts failing. It looks like we forgot to add a test when we made D98573, but I think it might be because the motivation for making the change was not fixing this bug, it was implementing constexpr string.

I was indeed not aware that the patch fixed a bug. LGTM % comments.

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.infinite_recursion.pass.cpp

27–29

94

[ldionne]

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.infinite_recursion.pass.cpp

94

Changed to char_traits::move.

[ldionne]

Apply review comments and fix C++03/C++11 CI.

[ldionne]

Fix C++03.

[ldionne]

Rebase onto main

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.infinite_recursion.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// Make sure basic_string::insert does not cause infinite recursion.
+// This is a regression test for a bug that had been introduced in D98573.
+
+#include <algorithm>
+#include <cassert>
+#include <string>
+
+struct char_ascii {
+    char char_;
+
+    char_ascii() = default;
+    char_ascii(char ch) : char_(ch) {
+        assert(ch <= 0x7f);
+    }
+};
+
+namespace std {
+    template <>
+    struct char_traits<char_ascii> {
+        using char_type = char_ascii;
+        using int_type = typename std::char_traits<char>::int_type;
+        using off_type = typename std::char_traits<char>::off_type;
+        using pos_type = typename std::char_traits<char>::pos_type;
+        using state_type = typename std::char_traits<char>::state_type;
+
+        static constexpr void assign(char_type& r, char_type const& a) noexcept {
+            r = a;
+        }
+
+        static char_type* assign(char_type* p, std::size_t count, char_type a) {
+            std::fill(p, p + count, a);
+            return p;
+        }
+
+        static constexpr bool eq(char_type a, char_type b) noexcept {
+            return a.char_ == b.char_;
+        }
+
+        static constexpr bool lt(char_type a, char_type b) noexcept {
+            return a.char_ < b.char_;
+        }
+
+        static constexpr std::size_t length(char_type const* s) {
+            std::size_t n = 0;
+            if (s) {
+                while (s->char_)
+                    ++n;
+            }
+            return n;
+        }
+
+        static constexpr const char_type* find(char_type const* p, std::size_t count, char_type const& ch) {
+            while (count > 0) {
+                if (p->char_ == ch.char_) {
+                    return p;
+                } else {
+                    ++p;
+                    --count;
+                }
+            }
+            return nullptr;
+        }
+
+        static constexpr int compare(char_type const* s1, char_type const* s2, std::size_t count) {
+            for (std::size_t i = 0; i < count; ++i) {
+                if (s1->char_ < s2->char_)
+                    return -1;
+                else if (s2->char_ < s1->char_)
+                    return 1;
+            }
+            return 0;
+        }
+
+        static char_type* move(char_type* dest, char_type const* src, std::size_t count) {
+            if (src <= dest && dest < src + count) {
+                std::copy_backward(src, src + count, dest + count);
+            } else {
+                std::copy(src, src + count, dest);
+            }
+            return dest;
+        }
+
+        static char_type* copy(char_type* dest, char_type const* src, std::size_t count) {
+            return move(dest, src, count);
+        }
+    };
+}
+
+int main(int, char**) {
+    std::basic_string<char_ascii> str;
+
+    char_ascii ch = {'A'};
+    str.insert(str.begin(), &ch, &ch + 1);
+    assert(str.size() == 1);
+    assert(str[0].char_ == 'A');
+    return 0;
+}