Addressed comments

Author: H-G-Hristov

libcxx/test/std/strings/basic.string/string.ops/string_substr/subview.pass.cpp

@@ -29,35 +29,28 @@ constexpr void test() {
   std::basic_string<CharT, TraitsT, AllocT> s{CS("Hello cruel world!"), AllocT{}};
 
   { // With a default position and a character length.
+
+    // Check it the return type of subview() is correct.
     std::same_as<std::basic_string_view<CharT, TraitsT>> decltype(auto) sv = s.subview();
 
     assert(sv == CS("Hello cruel world!"));
     // Also check if subview() is a const-qualified.
     assert(std::as_const(s).subview() == CS("Hello cruel world!"));
   }
 
-  { // With a explict position and a character length.
-    std::same_as<std::basic_string_view<CharT, TraitsT>> decltype(auto) sv = s.subview(6, 5);
-
-    assert(sv == CS("cruel"));
-  }
-
-  { // From the beginning of the string with a explicit character length.
-    std::same_as<std::basic_string_view<CharT, TraitsT>> decltype(auto) sv = s.subview(0, 5);
+  { // Check with different position and length.
 
-    assert(sv == CS("Hello"));
-  }
-
-  { // To the end of string with the default character length.
-    std::same_as<std::basic_string_view<CharT, TraitsT>> decltype(auto) sv = s.subview(12);
+    // With a explict position and a character length.
+    assert(s.subview(6, 5) == CS("cruel"));
 
-    assert(sv == CS("world!"));
-  }
+    // From the beginning of the string with a explicit character length.
+    assert(sv = s.subview(0, 5) == CS("Hello"));
 
-  { // From the beginning to the end of the string with explicit values.
-    std::same_as<std::basic_string_view<CharT, TraitsT>> decltype(auto) sv = s.subview(0, s.size());
+    // To the end of string with the default character length.
+    assert(subview(12) == CS("world!"));
 
-    assert(sv == CS("Hello cruel world!"));
+    // From the beginning to the end of the string with explicit values.
+    assert(subview(0, s.size() == CS("Hello cruel world!"));
   }
 
   // Test if exceptions are thrown correctly.
@@ -68,7 +61,7 @@ constexpr void test() {
         s.subview(s.size() + 1);
         assert(false && "Expected std::out_of_range exception");
       } catch (const std::out_of_range&) {
-        // Expected exception
+        // Expected exception...
       }
     }
 
@@ -77,7 +70,7 @@ constexpr void test() {
         s.subview(s.size() + 1, 0);
         assert(false && "Expected std::out_of_range exception");
       } catch (const std::out_of_range&) {
-        // Expected exception
+        // Expected exception...
       }
     }
 
@@ -86,7 +79,7 @@ constexpr void test() {
         s.subview(s.size() + 1, 1);
         assert(false && "Expected std::out_of_range exception");
       } catch (const std::out_of_range&) {
-        // Expected exception
+        // Expected exception...
       }
     }
   }

libcxx/test/std/strings/string.view/string.view.ops/substr.pass.cpp

@@ -20,44 +20,49 @@
 // Effects: Determines the effective length rlen of the string to reference as the smaller of n and size() - pos.
 // Returns: basic_string_view(data()+pos, rlen).
 
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <stdexcept>
-#include <string_view>
+#if 0
+#  include <algorithm>
+#  include <cassert>
+#  include <string_view>
 
-#include "test_macros.h"
+#  include "make_string.h"
+#  include "test_macros.h"
+
+#  define CS(S) MAKE_CSTRING(CharT, S)
 
 template <typename CharT>
 struct Test {
   typedef std::basic_string_view<CharT> (std::basic_string_view<CharT>::*Sub)(
-      typename std::basic_string_view<CharT>::size_type, typename std::basic_string_view<CharT>::size_type) const;
+      typename std::basic_string_view<CharT>::size_type = 0, typename std::basic_string_view<CharT>::size_type = npos) const;
 };
 
+
 template <typename CharT, typename Test<CharT>::Sub TestSub>
-void testDetail(std::basic_string_view<CharT> sv, std::size_t n, size_t pos) {
+TEST_CONSTEXPR_CXX14 void testDetail(std::basic_string_view<CharT> sv, std::size_t n, size_t pos) {
   std::basic_string_view<CharT> sv1;
-#ifdef TEST_HAS_NO_EXCEPTIONS
+#  ifdef TEST_HAS_NO_EXCEPTIONS
   if (pos > sv.size())
     return; // would throw if exceptions were enabled
   sv1 = (sv.*TestSub)(pos, n);
-#else
-  try {
-    sv1 = (sv.*TestSub)(pos, n);
-    assert(pos <= sv.size());
-  } catch (const std::out_of_range&) {
-    assert(pos > sv.size());
-    return;
+#  else
+  if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+      sv1 = (sv.*TestSub)(pos, n);
+      assert(pos <= sv.size());
+    } catch (const std::out_of_range&) {
+      assert(pos > sv.size());
+      return;
+    }
   }
-#endif
+#  endif
   const std::size_t rlen = std::min(n, sv.size() - pos);
   assert(sv1.size() == rlen);
   for (std::size_t i = 0; i < rlen; ++i)
     assert(sv[pos + i] == sv1[i]);
 }
 
 template <typename CharT, typename Test<CharT>::Sub TestSub>
-void testCases(const CharT* s) {
+TEST_CONSTEXPR_CXX14 void testCases(const CharT* s) {
   std::basic_string_view<CharT> sv(s);
 
   testDetail<CharT, TestSub>(sv, 0, 0);
@@ -71,87 +76,157 @@ void testCases(const CharT* s) {
   testDetail<CharT, TestSub>(sv, 2, std::basic_string_view<CharT>::npos);
   testDetail<CharT, TestSub>(sv, sv.size(), std::basic_string_view<CharT>::npos);
 
+  // Test if exceptions are thrown correctly.
   testDetail<CharT, TestSub>(sv, sv.size() + 1, 0);
   testDetail<CharT, TestSub>(sv, sv.size() + 1, 1);
   testDetail<CharT, TestSub>(sv, sv.size() + 1, std::basic_string_view<CharT>::npos);
 }
 
 template <typename CharT>
-void testSubs(const CharT* s) {
+TEST_CONSTEXPR_CXX14 void testSubs(const CharT* s) {
   testCases<CharT, &std::basic_string_view<CharT>::substr>(s);
-#if TEST_STD_VER >= 26
+#  if TEST_STD_VER >= 26
   testCases<CharT, &std::basic_string_view<CharT>::subview>(s);
-#endif
+#  endif
 }
 
-void test() {
-  testSubs("ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE");
-  testSubs("ABCDE");
-  testSubs("a");
-  testSubs("");
+#  define CS(S) MAKE_CSTRING(CharT, S)
 
-#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+template <typename CharT>
+TEST_CONSTEXPR_CXX14 void test() {
   testSubs(
-      L"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE");
-  testSubs(L"ABCDE");
-  testSubs(L"a");
-  testSubs(L"");
-#endif
+      CS("ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE"));
+  testSubs(CS("ABCDE"));
+  testSubs(CS("a"));
+  testSubs(CS(""));
+}
 
-#if TEST_STD_VER >= 11
-  testSubs(
-      u"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE");
-  testSubs(u"ABCDE");
-  testSubs(u"a");
-  testSubs(u"");
+TEST_CONSTEXPR_CXX14 bool test() {
+  test<char>();
+#  ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#  endif
+#  if TEST_STD_VER >= 11
+#    ifndef TEST_HAS_NO_CHAR8_T
+  test<char8_t>();
+#    endif
+  test<char16_t>();
+  test<char32_t>();
+#  endif
 
-  testSubs(
-      U"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE");
-  testSubs(U"ABCDE");
-  testSubs(U"a");
-  testSubs(U"");
-#endif
+  return true;
 }
 
-#if TEST_STD_VER >= 14
-template <typename Test<char>::Sub TestSub>
-constexpr void testConstexprDetail() {
-  constexpr std::string_view sv{"ABCDE", 5};
-  {
-    constexpr std::string_view sv2 = (sv.*TestSub)(0, 3);
-
-    static_assert(sv2.size() == 3, "");
-    static_assert(sv2[0] == 'A', "");
-    static_assert(sv2[1] == 'B', "");
-    static_assert(sv2[2] == 'C', "");
-  }
+int main(int, char**) {
+  test();
+#  if TEST_STD_VER >= 14
+  // static_assert(test());
+#  endif
 
-  {
-    constexpr std::string_view sv2 = (sv.*TestSub)(3, 0);
-    static_assert(sv2.size() == 0, "");
-  }
+  return 0;
+}
+#endif
+
+#include <cassert>
+#include <string>
+#include <utility>
+
+#include "constexpr_char_traits.h"
+#include "make_string.h"
+#include "test_macros.h"
+
+#define CS(S) MAKE_CSTRING(CharT, S)
+
+template <typename CharT, typename TraitsT>
+struct Test {
+  typedef std::basic_string_view<CharT, TraitsT> (std::basic_string_view<CharT, TraitsT>::*Sub)(
+      typename std::basic_string_view<CharT, TraitsT>::size_type,
+      typename std::basic_string_view<CharT, TraitsT>::size_type) const;
+};
 
-  {
-    constexpr std::string_view sv2 = (sv.*TestSub)(3, 3);
-    static_assert(sv2.size() == 2, "");
-    static_assert(sv2[0] == 'D', "");
-    static_assert(sv2[1] == 'E', "");
+template <typename CharT, typename TraitsT, typename Test<CharT, TraitsT>::Sub TestSub>
+TEST_CONSTEXPR_CXX14 void test() {
+  const std::basic_string_view<CharT, TraitsT> sv = CS("Hello cruel world!");
+
+  // With a default position and a character length.
+  assert((sv.*TestSub)(0, std::basic_string_view<CharT, TraitsT>::npos) == CS("Hello cruel world!"));
+
+  // With a explict position and a character length.
+  assert((sv.*TestSub)(6, 5) == CS("cruel"));
+
+  // From the beginning of the string with a explicit character length.
+  assert((sv.*TestSub)(0, 5) == CS("Hello"));
+
+  // To the end of string with the default character length.
+  assert((sv.*TestSub)(12, std::basic_string_view<CharT, TraitsT>::npos) == CS("world!"));
+
+  // From the beginning to the end of the string with explicit values.
+  assert((sv.*TestSub)(0, sv.size()) == CS("Hello cruel world!"));
+
+  // Test if exceptions are thrown correctly.
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  if (!TEST_IS_CONSTANT_EVALUATED) {
+    { // With a position that is out of range.
+      try {
+        (sv.*TestSub)(sv.size() + 1, std::basic_string_view<CharT, TraitsT>::npos);
+        assert(false && "Expected std::out_of_range exception");
+      } catch (const std::out_of_range&) {
+        // Expected exception
+      }
+    }
+
+    { // With a position that is out of range and a 0 character length.
+      try {
+        (sv.*TestSub)(sv.size() + 1, 0);
+        assert(false && "Expected std::out_of_range exception");
+      } catch (const std::out_of_range&) {
+        // Expected exception
+      }
+    }
+
+    { // With a position that is out of range and a some character length.
+      try {
+        (sv.*TestSub)(sv.size() + 1, 1);
+        assert(false && "Expected std::out_of_range exception");
+      } catch (const std::out_of_range&) {
+        // Expected exception
+      }
+    }
   }
+#endif
 }
 
-void test_constexpr() {
-  testConstexprDetail<&std::string_view::substr>();
-#  if TEST_STD_VER >= 26
-  testConstexprDetail<&std::string_view::subview>();
-#  endif
+template <typename CharT>
+TEST_CONSTEXPR_CXX14 void test() {
+  ASSERT_SAME_TYPE(std::basic_string_view<CharT>, decltype(std::declval<std::basic_string_view<CharT> >().substr()));
+  test<CharT, std::char_traits<CharT>, &std::basic_string_view<CharT, std::char_traits<CharT> >::substr>();
+  test<CharT, constexpr_char_traits<CharT>, &std::basic_string_view<CharT, constexpr_char_traits<CharT> >::substr>();
+#if TEST_STD_VER >= 26
+  ASSERT_SAME_TYPE(std::basic_string_view<CharT>, decltype(std::declval<std::basic_string_view<CharT> >().subview()));
+  test<CharT, std::char_traits<CharT>, &std::basic_string_view<CharT, std::char_traits<CharT>>::subview>();
+  test<CharT, constexpr_char_traits<CharT>, &std::basic_string_view<CharT, constexpr_char_traits<CharT> >::subview>();
+#endif
 }
+
+TEST_CONSTEXPR_CXX14 bool test() {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+#ifndef TEST_HAS_NO_CHAR8_T
+  test<char8_t>();
 #endif
+  test<char16_t>();
+  test<char32_t>();
+
+  return true;
+}
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER >= 14
-  test_constexpr();
+  static_assert(test());
 #endif
 
   return 0;
-}
+}