Initial commit

module/jni/libcxx/test/std/strings/basic.string/string.iterators/begin.pass.cpp

@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+// 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>
+
+//       iterator begin(); // constexpr since C++20
+// const_iterator begin() const; // constexpr since C++20
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S>
+TEST_CONSTEXPR_CXX20 void
+test(S s)
+{
+    const S& cs = s;
+    typename S::iterator b = s.begin();
+    typename S::const_iterator cb = cs.begin();
+    if (!s.empty())
+    {
+        assert(*b == s[0]);
+    }
+    assert(b == cb);
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  {
+    typedef std::string S;
+    test(S());
+    test(S("123"));
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    test(S());
+    test(S("123"));
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
+  return 0;
+}

module/jni/libcxx/test/std/strings/basic.string/string.iterators/cbegin.pass.cpp

@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// 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>
+
+// const_iterator cbegin() const; // constexpr since C++20
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S>
+TEST_CONSTEXPR_CXX20 void
+test(const S& s)
+{
+    typename S::const_iterator cb = s.cbegin();
+    if (!s.empty())
+    {
+        assert(*cb == s[0]);
+    }
+    assert(cb == s.begin());
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  {
+    typedef std::string S;
+    test(S());
+    test(S("123"));
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    test(S());
+    test(S("123"));
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
+  return 0;
+}

module/jni/libcxx/test/std/strings/basic.string/string.iterators/cend.pass.cpp

@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+// 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>
+
+// const_iterator cend() const; // constexpr since C++20
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S>
+TEST_CONSTEXPR_CXX20 void
+test(const S& s)
+{
+    typename S::const_iterator ce = s.cend();
+    assert(ce == s.end());
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  {
+    typedef std::string S;
+    test(S());
+    test(S("123"));
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    test(S());
+    test(S("123"));
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+  return 0;
+}

module/jni/libcxx/test/std/strings/basic.string/string.iterators/crbegin.pass.cpp

@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// 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>
+
+// const_reverse_iterator crbegin() const; // constexpr since C++20
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S>
+TEST_CONSTEXPR_CXX20 void
+test(const S& s)
+{
+    typename S::const_reverse_iterator cb = s.crbegin();
+    if (!s.empty())
+    {
+        assert(*cb == s.back());
+    }
+    assert(cb == s.rbegin());
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  {
+    typedef std::string S;
+    test(S());
+    test(S("123"));
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    test(S());
+    test(S("123"));
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
+  return 0;
+}

module/jni/libcxx/test/std/strings/basic.string/string.iterators/crend.pass.cpp

@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//
+// 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>
+
+// const_reverse_iterator crend() const; // constexpr since C++20
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S>
+TEST_CONSTEXPR_CXX20 void
+test(const S& s)
+{
+    typename S::const_reverse_iterator ce = s.crend();
+    assert(ce == s.rend());
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  {
+    typedef std::string S;
+    test(S());
+    test(S("123"));
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    test(S());
+    test(S("123"));
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
+  return 0;
+}

module/jni/libcxx/test/std/strings/basic.string/string.iterators/end.pass.cpp

@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// 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>
+
+//       iterator end(); // constexpr since C++20
+// const_iterator end() const; // constexpr since C++20
+
+#include <string>
+#include <cassert>
+#include <cstddef>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S>
+TEST_CONSTEXPR_CXX20 void
+test(S s)
+{
+    const S& cs = s;
+    typename S::iterator e = s.end();
+    typename S::const_iterator ce = cs.end();
+    if (s.empty())
+    {
+        assert(e == s.begin());
+        assert(ce == cs.begin());
+    }
+    assert(static_cast<std::size_t>(e - s.begin()) == s.size());
+    assert(static_cast<std::size_t>(ce - cs.begin()) == cs.size());
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  {
+    typedef std::string S;
+    test(S());
+    test(S("123"));
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    test(S());
+    test(S("123"));
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
+  return 0;
+}

module/jni/libcxx/test/std/strings/basic.string/string.iterators/iterator_concept_conformance.compile.pass.cpp

@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// iterator, const_iterator, reverse_iterator, const_reverse_iterator
+
+#include <string>
+
+#include <iterator>
+
+using iterator = std::string::iterator;
+using const_iterator = std::string::const_iterator;
+using reverse_iterator = std::string::reverse_iterator;
+using const_reverse_iterator = std::string::const_reverse_iterator;
+using value_type = char;
+
+static_assert(std::contiguous_iterator<iterator>);
+static_assert(std::indirectly_writable<iterator, value_type>);
+static_assert(std::sentinel_for<iterator, iterator>);
+static_assert(std::sentinel_for<iterator, const_iterator>);
+static_assert(!std::sentinel_for<iterator, reverse_iterator>);
+static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
+static_assert(std::sized_sentinel_for<iterator, iterator>);
+static_assert(std::sized_sentinel_for<iterator, const_iterator>);
+static_assert(!std::sized_sentinel_for<iterator, reverse_iterator>);
+static_assert(!std::sized_sentinel_for<iterator, const_reverse_iterator>);
+static_assert( std::indirectly_movable<iterator, iterator>);
+static_assert( std::indirectly_movable_storable<iterator, iterator>);
+static_assert(!std::indirectly_movable<iterator, const_iterator>);
+static_assert(!std::indirectly_movable_storable<iterator, const_iterator>);
+static_assert( std::indirectly_movable<iterator, reverse_iterator>);
+static_assert( std::indirectly_movable_storable<iterator, reverse_iterator>);
+static_assert(!std::indirectly_movable<iterator, const_reverse_iterator>);
+static_assert(!std::indirectly_movable_storable<iterator, const_reverse_iterator>);
+static_assert( std::indirectly_copyable<iterator, iterator>);
+static_assert( std::indirectly_copyable_storable<iterator, iterator>);
+static_assert(!std::indirectly_copyable<iterator, const_iterator>);
+static_assert(!std::indirectly_copyable_storable<iterator, const_iterator>);
+static_assert( std::indirectly_copyable<iterator, reverse_iterator>);
+static_assert( std::indirectly_copyable_storable<iterator, reverse_iterator>);
+static_assert(!std::indirectly_copyable<iterator, const_reverse_iterator>);
+static_assert(!std::indirectly_copyable_storable<iterator, const_reverse_iterator>);
+static_assert( std::indirectly_swappable<iterator, iterator>);
+
+static_assert(std::contiguous_iterator<const_iterator>);
+static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::sentinel_for<const_iterator, iterator>);
+static_assert(std::sentinel_for<const_iterator, const_iterator>);
+static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
+static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
+static_assert(std::sized_sentinel_for<const_iterator, iterator>);
+static_assert(std::sized_sentinel_for<const_iterator, const_iterator>);
+static_assert(!std::sized_sentinel_for<const_iterator, reverse_iterator>);
+static_assert(!std::sized_sentinel_for<const_iterator, const_reverse_iterator>);
+static_assert( std::indirectly_movable<const_iterator, iterator>);
+static_assert( std::indirectly_movable_storable<const_iterator, iterator>);
+static_assert(!std::indirectly_movable<const_iterator, const_iterator>);
+static_assert(!std::indirectly_movable_storable<const_iterator, const_iterator>);
+static_assert( std::indirectly_movable<const_iterator, reverse_iterator>);
+static_assert( std::indirectly_movable_storable<const_iterator, reverse_iterator>);
+static_assert(!std::indirectly_movable<const_iterator, const_reverse_iterator>);
+static_assert(!std::indirectly_movable_storable<const_iterator, const_reverse_iterator>);
+static_assert( std::indirectly_copyable<const_iterator, iterator>);
+static_assert( std::indirectly_copyable_storable<const_iterator, iterator>);
+static_assert(!std::indirectly_copyable<const_iterator, const_iterator>);
+static_assert(!std::indirectly_copyable_storable<const_iterator, const_iterator>);
+static_assert( std::indirectly_copyable<const_iterator, reverse_iterator>);
+static_assert( std::indirectly_copyable_storable<const_iterator, reverse_iterator>);
+static_assert(!std::indirectly_copyable<const_iterator, const_reverse_iterator>);
+static_assert(!std::indirectly_copyable_storable<const_iterator, const_reverse_iterator>);
+static_assert(!std::indirectly_swappable<const_iterator, const_iterator>);

module/jni/libcxx/test/std/strings/basic.string/string.iterators/iterators.pass.cpp

@@ -0,0 +1,85 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// <string>
+
+// iterator       begin(); // constexpr since C++20
+// iterator       end(); // constexpr since C++20
+// const_iterator begin()  const; // constexpr since C++20
+// const_iterator end()    const; // constexpr since C++20
+// const_iterator cbegin() const; // constexpr since C++20
+// const_iterator cend()   const; // constexpr since C++20
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+template<class C>
+TEST_CONSTEXPR_CXX20 void test()
+{
+    { // N3644 testing
+        typename C::iterator ii1{}, ii2{};
+        typename C::iterator ii4 = ii1;
+        typename C::const_iterator cii{};
+
+        assert ( ii1 == ii2 );
+        assert ( ii1 == ii4 );
+
+        assert (!(ii1 != ii2 ));
+
+        assert ( (ii1 == cii ));
+        assert ( (cii == ii1 ));
+        assert (!(ii1 != cii ));
+        assert (!(cii != ii1 ));
+        assert (!(ii1 <  cii ));
+        assert (!(cii <  ii1 ));
+        assert ( (ii1 <= cii ));
+        assert ( (cii <= ii1 ));
+        assert (!(ii1 >  cii ));
+        assert (!(cii >  ii1 ));
+        assert ( (ii1 >= cii ));
+        assert ( (cii >= ii1 ));
+        assert (cii - ii1 == 0);
+        assert (ii1 - cii == 0);
+    }
+    {
+        C a;
+        typename C::iterator i1 = a.begin();
+        typename C::iterator i2;
+        i2 = i1;
+        assert ( i1 == i2 );
+    }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+    test<std::string>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+    test<std::wstring>();
+#endif
+
+#ifndef TEST_HAS_NO_CHAR8_T
+    test<std::u8string>();
+#endif
+
+    test<std::u16string>();
+    test<std::u32string>();
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+#if TEST_STD_VER > 17
+    static_assert(test());
+#endif
+    return 0;
+}

module/jni/libcxx/test/std/strings/basic.string/string.iterators/rbegin.pass.cpp

@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+// 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>
+
+//       reverse_iterator rbegin(); // constexpr since C++20
+// const_reverse_iterator rbegin() const; // constexpr since C++20
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S>
+TEST_CONSTEXPR_CXX20 void
+test(S s)
+{
+    const S& cs = s;
+    typename S::reverse_iterator b = s.rbegin();
+    typename S::const_reverse_iterator cb = cs.rbegin();
+    if (!s.empty())
+    {
+        assert(*b == s.back());
+    }
+    assert(b == cb);
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  {
+    typedef std::string S;
+    test(S());
+    test(S("123"));
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    test(S());
+    test(S("123"));
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
+  return 0;
+}

module/jni/libcxx/test/std/strings/basic.string/string.iterators/rend.pass.cpp

@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// 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>
+
+//       reverse_iterator rend(); // constexpr since C++20
+// const_reverse_iterator rend() const; // constexpr since C++20
+
+#include <string>
+#include <cassert>
+#include <cstddef>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S>
+TEST_CONSTEXPR_CXX20 void
+test(S s)
+{
+    const S& cs = s;
+    typename S::reverse_iterator e = s.rend();
+    typename S::const_reverse_iterator ce = cs.rend();
+    if (s.empty())
+    {
+        assert(e == s.rbegin());
+        assert(ce == cs.rbegin());
+    }
+    assert(static_cast<std::size_t>(e - s.rbegin()) == s.size());
+    assert(static_cast<std::size_t>(ce - cs.rbegin()) == cs.size());
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  {
+    typedef std::string S;
+    test(S());
+    test(S("123"));
+  }
+#if TEST_STD_VER >= 11
+  {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    test(S());
+    test(S("123"));
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**)
+{
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
+  return 0;
+}