Protect exceptional path under libcpp-no-exceptions

[rogfer01]

Summary

This is another followup of D24562

These tests are of the form

try {
   action-that-may-throw
   assert(!exceptional-condition)
   assert(some-other-facts)
 } catch (relevant-exception) {
   assert(exceptional-condition)
 }

Under libcpp-no-exceptions there is still value in verifying
some-other-facts while avoiding the exceptional case. So for these tests
just conditionally check some-other-facts if exceptional-condition is
false. When exception are supported make sure that a true
exceptional-condition throws an exception

[rmaprath]

test/std/strings/basic.string/string.access/at.pass.cpp

57

For the cases where an exception should've been thrown, are we not entering the undefined domain at this point?

What if instead, we define two versions of the test() function? one containing the current code as-is, and the other only handles the cases where exceptions are not expected, and we modify the main() function below so that the correct test() case is invoked depending on the presence / absence of exceptions? It's a bit more cumbersome than the current setup, but I'm not totally happy about treading into the undefined domain (if my understanding above is correct).

[rogfer01]

test/std/strings/basic.string/string.access/at.pass.cpp

57

If I understand this test correctly, it checks for the at member function. While certainly binding a const reference might throw, here it is bound to a lvalue of the same type so no temporary construction should happen.

The original test checks both s.size() and cs.size(). Given that size is a const member function it probably does not matter given that cs and s are aliased, but see comment below.

61

This is redundant, maybe I should change the if condition to be if (pos < s.size())

[rmaprath]

test/std/strings/basic.string/string.access/at.pass.cpp

57

Right, so it's the at() method which is expected to throw in this case. What you are doing here is carefully avoiding the exception throwing code-path while keeping the remaining assertions intact. Makes sense.

I'll go over the rest of the test cases to double check. But I'm happy with this.

(You need to wait for approval from @EricWF or @mclow.lists to commit)

[mclow.lists]

This all looks ok to me - all mechanical changes.
I wonder if there's a better way to refactor these - there's all that duplicated code.

Does this look any better to you?
Replace:

try
{
    s.replace(pos1, n1, str, pos2);
    LIBCPP_ASSERT(s.__invariants());
    assert(pos1 <= old_size && pos2 <= str.size());
    assert(s == expected);
    typename S::size_type xlen = std::min(n1, old_size - pos1);
    typename S::size_type rlen = std::min(S::npos, str.size() - pos2);
    assert(s.size() == old_size - xlen + rlen);
}
catch (std::out_of_range&)
{
    assert(pos1 > old_size || pos2 > str.size());
    assert(s == s0);
}

with:

if(pos1 <= old_size && pos2 <= str.size())
{
    s.replace(pos1, n1, str, pos2);
    LIBCPP_ASSERT(s.__invariants());
    assert(s == expected);
    typename S::size_type xlen = std::min(n1, old_size - pos1);
    typename S::size_type rlen = std::min(S::npos, str.size() - pos2);
    assert(s.size() == old_size - xlen + rlen);
}
#ifndef TEST_HAS_NO_EXCEPTIONS
else
{
    try { s.replace(pos1, n1, str, pos2); }
    catch (std::out_of_range&)
    {
        assert(pos1 > old_size || pos2 > str.size());
        assert(s == s0);
    }
}
#endif

test/std/strings/basic.string/string.access/at.pass.cpp

58

I think you should just test s.size() here, not both s and cs. (the original code got it wrong, too)
The assert at L45 can be removed.

[rogfer01]

Update tests following Marshall's suggestion to avoid too much code duplication. Also add assert(false) after the throwing action to ensure that the expected exception is actually thrown.

[mclow.lists]

Thanks for making these changes; I think this looks much better than before.
Feature creep: A bunch of the local variables can be marked as const.

test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp

27

Nit. old_size should be const
(and in a few other places)

test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp

34

s0 should be const, too.

[rogfer01]

Const-ify variables.

test/std/strings/basic.string/string.access/at.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // const_reference at(size_type pos) const;
 //       reference at(size_type pos);
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
+#include "test_macros.h"
+
 template <class S>
 void
 test(S s, typename S::size_type pos)
 {
-    try
-    {
-        const S& cs = s;
+    if (pos < s.size())
+    {
         assert(s.at(pos) == s[pos]);
         assert(cs.at(pos) == cs[pos]);
-        assert(pos < cs.size());
+    }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.at(pos);
+            assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos >= s.size());
         }
+        try
+        {
+            cs.at(pos);
+            assert(false);
+        }
+        catch (std::out_of_range&)
+        {
+            assert(pos >= s.size());
+        }
+    }
+#endif
 }
 
 int main()
 {
     {
     typedef std::string S;
     test(S(), 0);
     test(S("123"), 0);
     test(S("123"), 1);
     test(S("123"), 2);
     test(S("123"), 3);
     }
 #if TEST_STD_VER >= 11
     {

test/std/strings/basic.string/string.capacity/reserve.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // void reserve(size_type res_arg=0);
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 

 }
 
 template <class S>
 void
 test(S s, typename S::size_type res_arg)
 {
     typename S::size_type old_cap = s.capacity();
     S s0 = s;
-    try
+    if (res_arg <= s.max_size())
     {
         s.reserve(res_arg);
-        assert(res_arg <= s.max_size());
         assert(s == s0);
         assert(s.capacity() >= res_arg);
         assert(s.capacity() >= s.size());
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.reserve(res_arg);
+            assert(false);
+        }
         catch (std::length_error&)
         {
             assert(res_arg > s.max_size());
         }
     }
+#endif
+}
 
 int main()
 {
     {
     typedef std::string S;
     {
     S s;
     test(s);

test/std/strings/basic.string/string.capacity/resize_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // void resize(size_type n);
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s, typename S::size_type n, S expected)
 {
-    try
+    if (n <= s.max_size())
     {
         s.resize(n);
         LIBCPP_ASSERT(s.__invariants());
-        assert(n <= s.max_size());
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.resize(n);
+            assert(false);
+        }
         catch (std::length_error&)
         {
             assert(n > s.max_size());
         }
     }
+#endif
+}
 
 int main()
 {
     {
     typedef std::string S;
     test(S(), 0, S());
     test(S(), 1, S(1, '\0'));
     test(S(), 10, S(10, '\0'));

test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // void resize(size_type n, charT c);
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s, typename S::size_type n, typename S::value_type c, S expected)
 {
-    try
+    if (n <= s.max_size())
     {
         s.resize(n, c);
         LIBCPP_ASSERT(s.__invariants());
-        assert(n <= s.max_size());
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.resize(n, c);
+            assert(false);
+        }
         catch (std::length_error&)
         {
             assert(n > s.max_size());
         }
     }
+#endif
+}
 
 int main()
 {
     {
     typedef std::string S;
     test(S(), 0, 'a', S());
     test(S(), 1, 'a', S("a"));
     test(S(), 10, 'a', S(10, 'a'));

test/std/strings/basic.string/string.cons/substr.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string(const basic_string<charT,traits,Allocator>& str,
 //              size_type pos, size_type n,
 //              const Allocator& a = Allocator());
 //
 // basic_string(const basic_string<charT,traits,Allocator>& str,
 //              size_type pos,

 #include "min_allocator.h"
 
 template <class S>
 void
 test(S str, unsigned pos)
 {
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
-    try
+
+    if (pos <= str.size())
     {
         S s2(str, pos);
         LIBCPP_ASSERT(s2.__invariants());
-        assert(pos <= str.size());
         unsigned rlen = str.size() - pos;
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == A());
         assert(s2.capacity() >= s2.size());
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            S s2(str, pos);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > str.size());
         }
     }
+#endif
+}
 
 template <class S>
 void
 test(S str, unsigned pos, unsigned n)
 {
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
-    try
+    if (pos <= str.size())
     {
         S s2(str, pos, n);
         LIBCPP_ASSERT(s2.__invariants());
-        assert(pos <= str.size());
         unsigned rlen = std::min<unsigned>(str.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == A());
         assert(s2.capacity() >= s2.size());
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            S s2(str, pos, n);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > str.size());
         }
     }
+#endif
+}
 
 template <class S>
 void
 test(S str, unsigned pos, unsigned n, const typename S::allocator_type& a)
 {
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
-    try
+
+    if (pos <= str.size())
     {
         S s2(str, pos, n, a);
         LIBCPP_ASSERT(s2.__invariants());
-        assert(pos <= str.size());
         unsigned rlen = std::min<unsigned>(str.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == a);
         assert(s2.capacity() >= s2.size());
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            S s2(str, pos, n, a);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > str.size());
         }
     }
+#endif
+}
 
 #if TEST_STD_VER >= 11
+#ifndef TEST_HAS_NO_EXCEPTIONS
 void test2583()
 {   // LWG #2583
     typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > StringA;
     std::vector<StringA, std::scoped_allocator_adaptor<test_allocator<StringA>>> vs;
     StringA s{"1234"};
     vs.emplace_back(s, 2);
 
     try { vs.emplace_back(s, 5); }
     catch (const std::out_of_range&) { return; }
     assert(false);
 }
 #endif
+#endif
 
 int main()
 {
     {
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 
     test(S(A(3)), 0);
#if TEST_STD_VER >= 11
     test(S("1", A()), 0, 0, A());
     test(S("1", A()), 0, 1, A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 0, A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 1, A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 10, A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890", A()), 50, 100, A());
     }
 
+#ifndef TEST_HAS_NO_EXCEPTIONS
     test2583();
 #endif
+#endif
 }

test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // template <class T>
 //    basic_string& append(const T& t, size_type pos, size_type n=npos); // C++17
 
 #include <string>
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(S s, SV sv, typename S::size_type pos, typename S::size_type n, S expected)
 {
-    try
+    if (pos <= sv.size())
     {
         s.append(sv, pos, n);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos <= sv.size());
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.append(sv, pos, n);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > sv.size());
         }
     }
+#endif
+}
 
 template <class S, class SV>
 void
 test_npos(S s, SV sv, typename S::size_type pos, S expected)
 {
-    try
+    if (pos <= sv.size())
     {
         s.append(sv, pos);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos <= sv.size());
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.append(sv, pos);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > sv.size());
         }
     }
+#endif
+}
 
 int main()
 {
     {
     typedef std::string S;
     typedef std::string_view SV;
     test(S(), SV(), 0, 0, S());
     test(S(), SV(), 1, 0, S());

test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&
 //   append(const basic_string<charT,traits>& str, size_type pos, size_type n = npos);
 //  the "= npos" was added for C++14
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s, S str, typename S::size_type pos, typename S::size_type n, S expected)
 {
-    try
+    if (pos <= str.size())
     {
         s.append(str, pos, n);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos <= str.size());
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.append(str, pos, n);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > str.size());
         }
     }
+#endif
+}
 
 template <class S>
 void
 test_npos(S s, S str, typename S::size_type pos, S expected)
 {
-    try
+    if (pos <= str.size())
     {
         s.append(str, pos);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos <= str.size());
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.append(str, pos);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > str.size());
         }
     }
+#endif
+}
 
 int main()
 {
     {
     typedef std::string S;
     test(S(), S(), 0, 0, S());
     test(S(), S(), 1, 0, S());
     test(S(), S("12345"), 0, 3, S("123"));

test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // template <class T>
 //    basic_string& assign(const T& t, size_type pos, size_type n=npos); // C++17
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(S s, SV sv, typename S::size_type pos, typename S::size_type n, S expected)
 {
-    try
+    if (pos <= sv.size())
     {
         s.assign(sv, pos, n);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos <= sv.size());
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.assign(sv, pos, n);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > sv.size());
         }
     }
+#endif
+}
 
 template <class S, class SV>
 void
 test_npos(S s, SV sv, typename S::size_type pos, S expected)
 {
-    try
+    if (pos <= sv.size())
     {
         s.assign(sv, pos);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos <= sv.size());
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.assign(sv, pos);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > sv.size());
         }
     }
+#endif
+}
 
 int main()
 {
     {
     typedef std::string S;
     typedef std::string_view SV;
     test(S(), SV(), 0, 0, S());
     test(S(), SV(), 1, 0, S());

test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&
 //   assign(const basic_string<charT,traits>& str, size_type pos, size_type n=npos);
 // the =npos was added for C++14
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s, S str, typename S::size_type pos, typename S::size_type n, S expected)
 {
-    try
+    if (pos <= str.size())
     {
         s.assign(str, pos, n);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos <= str.size());
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.assign(str, pos, n);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > str.size());
         }
     }
+#endif
+}
 
 template <class S>
 void
 test_npos(S s, S str, typename S::size_type pos, S expected)
 {
-    try
+    if (pos <= str.size())
     {
         s.assign(str, pos);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos <= str.size());
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.assign(str, pos);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > str.size());
         }
     }
+#endif
+}
 
 int main()
 {
     {
     typedef std::string S;
     test(S(), S(), 0, 0, S());
     test(S(), S(), 1, 0, S());
     test(S(), S("12345"), 0, 3, S("123"));

test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // size_type copy(charT* s, size_type n, size_type pos = 0) const;
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S str, typename S::value_type* s, typename S::size_type n,
      typename S::size_type pos)
 {
-    try
-    {
-        const S& cs = str;
+    if (pos <= cs.size())
+    {
         typename S::size_type r = cs.copy(s, n, pos);
-        assert(pos <= cs.size());
         typename S::size_type rlen = std::min(n, cs.size() - pos);
         assert(r == rlen);
         for (r = 0; r < rlen; ++r)
             assert(S::traits_type::eq(cs[pos+r], s[r]));
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            typename S::size_type r = cs.copy(s, n, pos);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > str.size());
         }
     }
+#endif
+}
 
 int main()
 {
     {
     typedef std::string S;
     char s[50];
     test(S(""), s, 0, 0);
     test(S(""), s, 0, 1);

test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&
 //   erase(size_type pos = 0, size_type n = npos);
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s, typename S::size_type pos, typename S::size_type n, S expected)
 {
-    typename S::size_type old_size = s.size();
+    const typename S::size_type old_size = s.size();
     S s0 = s;
-    try
+    if (pos <= old_size)
     {
         s.erase(pos, n);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos <= old_size);
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.erase(pos, n);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > old_size);
             assert(s == s0);
         }
     }
+#endif
+}
 
 template <class S>
 void
 test(S s, typename S::size_type pos, S expected)
 {
-    typename S::size_type old_size = s.size();
+    const typename S::size_type old_size = s.size();
     S s0 = s;
-    try
+    if (pos <= old_size)
     {
         s.erase(pos);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos <= old_size);
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.erase(pos);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > old_size);
             assert(s == s0);
         }
     }
+#endif
+}
 
 template <class S>
 void
 test(S s, S expected)
 {
     s.erase();
     LIBCPP_ASSERT(s.__invariants());
     assert(s == expected);

test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // template <class T>
 //    basic_string& assign(size_type pos1, const T& t, size_type pos2, size_type n=npos); // C++17
 //
 //  Mostly we're testing string_view here
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(S s, typename S::size_type pos1, SV sv, typename S::size_type pos2,
      typename S::size_type n, S expected)
 {
     static_assert((!std::is_same<S, SV>::value), "");
-    typename S::size_type old_size = s.size();
+    const typename S::size_type old_size = s.size();
     S s0 = s;
-    try
+    if (pos1 <= old_size && pos2 <= sv.size())
     {
         s.insert(pos1, sv, pos2, n);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos1 <= old_size && pos2 <= sv.size());
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.insert(pos1, sv, pos2, n);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos1 > old_size || pos2 > sv.size());
             assert(s == s0);
         }
     }
+#endif
+}
 
 template <class S, class SV>
 void
 test_npos(S s, typename S::size_type pos1, SV sv, typename S::size_type pos2, S expected)
 {
     static_assert((!std::is_same<S, SV>::value), "");
-    typename S::size_type old_size = s.size();
+    const typename S::size_type old_size = s.size();
     S s0 = s;
-    try
+    if (pos1 <= old_size && pos2 <= sv.size())
     {
         s.insert(pos1, sv, pos2);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos1 <= old_size && pos2 <= sv.size());
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.insert(pos1, sv, pos2);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos1 > old_size || pos2 > sv.size());
             assert(s == s0);
         }
     }
+#endif
+}
 
 
 template <class S, class SV>
 void test0()
 {
     test(S(""), 0, SV(""), 0, 0, S(""));
     test(S(""), 0, SV(""), 0, 1, S(""));
     test(S(""), 0, SV(""), 1, 0, S("can't happen"));

test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&
 //   insert(size_type pos, const charT* s);
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s, typename S::size_type pos, const typename S::value_type* str, S expected)
 {
-    typename S::size_type old_size = s.size();
+    const typename S::size_type old_size = s.size();
     S s0 = s;
-    try
+    if (pos <= old_size)
     {
         s.insert(pos, str);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos <= old_size);
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.insert(pos, str);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > old_size);
             assert(s == s0);
         }
     }
+#endif
+}
 
 int main()
 {
     {
     typedef std::string S;
     test(S(""), 0, "", S(""));
     test(S(""), 0, "12345", S("12345"));
     test(S(""), 0, "1234567890", S("1234567890"));

test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&
 //   insert(size_type pos, const charT* s, size_type n);
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s, typename S::size_type pos, const typename S::value_type* str,
      typename S::size_type n, S expected)
 {
-    typename S::size_type old_size = s.size();
+    const typename S::size_type old_size = s.size();
     S s0 = s;
-    try
+    if (pos <= old_size)
     {
         s.insert(pos, str, n);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos <= old_size);
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.insert(pos, str, n);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > old_size);
             assert(s == s0);
         }
     }
+#endif
+}
 
 int main()
 {
     {
     typedef std::string S;
     test(S(""), 0, "", 0, S(""));
     test(S(""), 0, "12345", 0, S(""));
     test(S(""), 0, "12345", 1, S("1"));

test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&
 //   insert(size_type pos, size_type n, charT c);
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s, typename S::size_type pos, typename S::size_type n,
      typename S::value_type str, S expected)
 {
-    typename S::size_type old_size = s.size();
+    const typename S::size_type old_size = s.size();
     S s0 = s;
-    try
+    if (pos <= old_size)
     {
         s.insert(pos, n, str);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos <= old_size);
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.insert(pos, n, str);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > old_size);
             assert(s == s0);
         }
     }
+#endif
+}
 
 int main()
 {
     {
     typedef std::string S;
     test(S(""), 0, 0, '1', S(""));
     test(S(""), 0, 5, '1', S("11111"));
     test(S(""), 0, 10, '1', S("1111111111"));

test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&
 //   insert(size_type pos1, const basic_string& str);
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s, typename S::size_type pos, S str, S expected)
 {
-    typename S::size_type old_size = s.size();
+    const typename S::size_type old_size = s.size();
     S s0 = s;
-    try
+    if (pos <= old_size)
     {
         s.insert(pos, str);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos <= old_size);
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.insert(pos, str);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > old_size);
             assert(s == s0);
         }
     }
+#endif
+}
 
 int main()
 {
     {
     typedef std::string S;
     test(S(""), 0, S(""), S(""));
     test(S(""), 0, S("12345"), S("12345"));
     test(S(""), 0, S("1234567890"), S("1234567890"));

test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&
 //   insert(size_type pos1, const basic_string<charT,traits,Allocator>& str,
 //          size_type pos2, size_type n=npos);
 // the "=npos" was added in C++14
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s, typename S::size_type pos1, S str, typename S::size_type pos2,
      typename S::size_type n, S expected)
 {
-    typename S::size_type old_size = s.size();
+    const typename S::size_type old_size = s.size();
     S s0 = s;
-    try
+    if (pos1 <= old_size && pos2 <= str.size())
     {
         s.insert(pos1, str, pos2, n);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos1 <= old_size && pos2 <= str.size());
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.insert(pos1, str, pos2, n);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos1 > old_size || pos2 > str.size());
             assert(s == s0);
         }
     }
+#endif
+}
 
 template <class S>
 void
 test_npos(S s, typename S::size_type pos1, S str, typename S::size_type pos2, S expected)
 {
-    typename S::size_type old_size = s.size();
+    const typename S::size_type old_size = s.size();
     S s0 = s;
-    try
+    if (pos1 <= old_size && pos2 <= str.size())
     {
         s.insert(pos1, str, pos2);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos1 <= old_size && pos2 <= str.size());
         assert(s == expected);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.insert(pos1, str, pos2);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos1 > old_size || pos2 > str.size());
             assert(s == s0);
         }
     }
+#endif
+}
 
 
 template <class S>
 void test0()
 {
     test(S(""), 0, S(""), 0, 0, S(""));
     test(S(""), 0, S(""), 0, 1, S(""));
     test(S(""), 0, S(""), 1, 0, S("can't happen"));

test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // template <class T>
 //    basic_string& replace(size_type pos1, size_type n1, const T& t, 
 //                          size_type pos2, size_type n=npos);
 //
 //  Mostly we're testing string_view here
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 void
 test(S s, typename S::size_type pos1, typename S::size_type n1,
      SV sv, typename S::size_type pos2, typename S::size_type n2,
      S expected)
 {
     static_assert((!std::is_same<S, SV>::value), "");
-    typename S::size_type old_size = s.size();
+    const typename S::size_type old_size = s.size();
     S s0 = s;
-    try
+    if (pos1 <= old_size && pos2 <= sv.size())
     {
         s.replace(pos1, n1, sv, pos2, n2);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos1 <= old_size && pos2 <= sv.size());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos1);
         typename S::size_type rlen = std::min(n2, sv.size() - pos2);
         assert(s.size() == old_size - xlen + rlen);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.replace(pos1, n1, sv, pos2, n2);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos1 > old_size || pos2 > sv.size());
             assert(s == s0);
         }
     }
+#endif
+}
 
 template <class S, class SV>
 void
 test_npos(S s, typename S::size_type pos1, typename S::size_type n1,
           SV sv, typename S::size_type pos2,
           S expected)
 {
     static_assert((!std::is_same<S, SV>::value), "");
-    typename S::size_type old_size = s.size();
+    const typename S::size_type old_size = s.size();
     S s0 = s;
-    try
+    if (pos1 <= old_size && pos2 <= sv.size())
     {
         s.replace(pos1, n1, sv, pos2);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos1 <= old_size && pos2 <= sv.size());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos1);
         typename S::size_type rlen = std::min(S::npos, sv.size() - pos2);
         assert(s.size() == old_size - xlen + rlen);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.replace(pos1, n1, sv, pos2);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos1 > old_size || pos2 > sv.size());
             assert(s == s0);
         }
     }
+#endif
+}
 
 
 template <class S, class SV>
 void test0()
 {
     test(S(""), 0, 0, SV(""), 0, 0, S(""));
     test(S(""), 0, 0, SV(""), 0, 1, S(""));
     test(S(""), 0, 0, SV(""), 1, 0, S("can't happen"));

test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&
 //   replace(size_type pos, size_type n1, const charT* s);
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s, typename S::size_type pos, typename S::size_type n1,
      const typename S::value_type* str, S expected)
 {
-    typename S::size_type old_size = s.size();
+    const typename S::size_type old_size = s.size();
     S s0 = s;
-    try
+    if (pos <= old_size)
     {
         s.replace(pos, n1, str);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos <= old_size);
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos);
         typename S::size_type rlen = S::traits_type::length(str);
         assert(s.size() == old_size - xlen + rlen);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.replace(pos, n1, str);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > old_size);
             assert(s == s0);
         }
     }
+#endif
+}
 
 template <class S>
 void test0()
 {
     test(S(""), 0, 0, "", S(""));
     test(S(""), 0, 0, "12345", S("12345"));
     test(S(""), 0, 0, "1234567890", S("1234567890"));
     test(S(""), 0, 0, "12345678901234567890", S("12345678901234567890"));

test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&
 //   replace(size_type pos, size_type n1, const charT* s, size_type n2);
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s, typename S::size_type pos, typename S::size_type n1,
      const typename S::value_type* str, typename S::size_type n2,
      S expected)
 {
-    typename S::size_type old_size = s.size();
+    const typename S::size_type old_size = s.size();
     S s0 = s;
-    try
+    if (pos <= old_size)
     {
         s.replace(pos, n1, str, n2);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos <= old_size);
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos);
         typename S::size_type rlen = n2;
         assert(s.size() == old_size - xlen + rlen);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.replace(pos, n1, str, n2);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > old_size);
             assert(s == s0);
         }
     }
+#endif
+}
 
 template <class S>
 void test0()
 {
     test(S(""), 0, 0, "", 0, S(""));
     test(S(""), 0, 0, "12345", 0, S(""));
     test(S(""), 0, 0, "12345", 1, S("1"));
     test(S(""), 0, 0, "12345", 2, S("12"));

test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&
 //   replace(size_type pos, size_type n1, size_type n2, charT c);
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s, typename S::size_type pos, typename S::size_type n1,
      typename S::size_type n2, typename S::value_type c,
      S expected)
 {
-    typename S::size_type old_size = s.size();
+    const typename S::size_type old_size = s.size();
     S s0 = s;
-    try
+    if (pos <= old_size)
     {
         s.replace(pos, n1, n2, c);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos <= old_size);
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos);
         typename S::size_type rlen = n2;
         assert(s.size() == old_size - xlen + rlen);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.replace(pos, n1, n2, c);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > old_size);
             assert(s == s0);
         }
     }
+#endif
+}
 
 template <class S>
 void test0()
 {
     test(S(""), 0, 0, 0, '2', S(""));
     test(S(""), 0, 0, 5, '2', S("22222"));
     test(S(""), 0, 0, 10, '2', S("2222222222"));
     test(S(""), 0, 0, 20, '2', S("22222222222222222222"));

test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&
 //   replace(size_type pos1, size_type n1, const basic_string<charT,traits,Allocator>& str);
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, S str, S expected)
 {
-    typename S::size_type old_size = s.size();
+    const typename S::size_type old_size = s.size();
     S s0 = s;
-    try
+    if (pos1 <= old_size)
     {
         s.replace(pos1, n1, str);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos1 <= old_size);
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos1);
         typename S::size_type rlen = str.size();
         assert(s.size() == old_size - xlen + rlen);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.replace(pos1, n1, str);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos1 > old_size);
             assert(s == s0);
         }
     }
+#endif
+}
 
 template <class S>
 void test0()
 {
     test(S(""), 0, 0, S(""), S(""));
     test(S(""), 0, 0, S("12345"), S("12345"));
     test(S(""), 0, 0, S("1234567890"), S("1234567890"));
     test(S(""), 0, 0, S("12345678901234567890"), S("12345678901234567890"));

test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // basic_string<charT,traits,Allocator>&
 //   replace(size_type pos1, size_type n1, const basic_string<charT,traits,Allocator>& str,
 //           size_type pos2, size_type n2=npos);
 //  the "=npos" was added in C++14
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s, typename S::size_type pos1, typename S::size_type n1,
      S str, typename S::size_type pos2, typename S::size_type n2,
      S expected)
 {
-    typename S::size_type old_size = s.size();
+    const typename S::size_type old_size = s.size();
     S s0 = s;
-    try
+    if (pos1 <= old_size && pos2 <= str.size())
     {
         s.replace(pos1, n1, str, pos2, n2);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos1 <= old_size && pos2 <= str.size());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos1);
         typename S::size_type rlen = std::min(n2, str.size() - pos2);
         assert(s.size() == old_size - xlen + rlen);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.replace(pos1, n1, str, pos2, n2);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos1 > old_size || pos2 > str.size());
             assert(s == s0);
         }
     }
+#endif
+}
 
 template <class S>
 void
 test_npos(S s, typename S::size_type pos1, typename S::size_type n1,
      S str, typename S::size_type pos2,
      S expected)
 {
-    typename S::size_type old_size = s.size();
+    const typename S::size_type old_size = s.size();
     S s0 = s;
-    try
+    if (pos1 <= old_size && pos2 <= str.size())
     {
         s.replace(pos1, n1, str, pos2);
         LIBCPP_ASSERT(s.__invariants());
-        assert(pos1 <= old_size && pos2 <= str.size());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos1);
         typename S::size_type rlen = std::min(S::npos, str.size() - pos2);
         assert(s.size() == old_size - xlen + rlen);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.replace(pos1, n1, str, pos2);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos1 > old_size || pos2 > str.size());
             assert(s == s0);
         }
     }
+#endif
+}
 
 
 template <class S>
 void test0()
 {
     test(S(""), 0, 0, S(""), 0, 0, S(""));
     test(S(""), 0, 0, S(""), 0, 1, S(""));
     test(S(""), 0, 0, S(""), 1, 0, S("can't happen"));

test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // template <typename T>
 //    int compare(size_type pos1, size_type n1, const T& t,
 //                size_type pos2, size_type n2=npos) const;
 //
 //  Mostly we're testing string_view here
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
+#include "test_macros.h"
+
 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 template <class S, class SV>
 void
 test(const S& s, typename S::size_type pos1, typename S::size_type n1,
      SV sv,      typename S::size_type pos2, typename S::size_type n2, int x)
 {
     static_assert((!std::is_same<S, SV>::value), "");
+    if (pos1 <= s.size() && pos2 <= sv.size())
+        assert(sign(s.compare(pos1, n1, sv, pos2, n2)) == sign(x));
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
         try
         {
-        assert(sign(s.compare(pos1, n1, sv, pos2, n2)) == sign(x));
-        assert(pos1 <= s.size());
-        assert(pos2 <= sv.size());
+            s.compare(pos1, n1, sv, pos2, n2);
+            assert(false);
         }
         catch (const std::out_of_range&)
         {
             assert(pos1 > s.size() || pos2 > sv.size());
         }
     }
+#endif
+}
 
 template <class S, class SV>
 void
 test_npos(const S& s, typename S::size_type pos1, typename S::size_type n1,
           SV sv,      typename S::size_type pos2, int x)
 {
     static_assert((!std::is_same<S, SV>::value), "");
+    if (pos1 <= s.size() && pos2 <= sv.size())
+        assert(sign(s.compare(pos1, n1, sv, pos2)) == sign(x));
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
         try
         {
-        assert(sign(s.compare(pos1, n1, sv, pos2)) == sign(x));
-        assert(pos1 <= s.size());
-        assert(pos2 <= sv.size());
+            s.compare(pos1, n1, sv, pos2);
+            assert(false);
         }
         catch (const std::out_of_range&)
         {
             assert(pos1 > s.size() || pos2 > sv.size());
         }
     }
+#endif
+}
 
 template <class S, class SV>
 void test0()
 {
     test(S(""), 0, 0, SV(""), 0, 0, 0);
     test(S(""), 0, 0, SV(""), 0, 1, 0);
     test(S(""), 0, 0, SV(""), 1, 0, 0);
     test(S(""), 0, 0, SV("abcde"), 0, 0, 0);

test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // int compare(size_type pos, size_type n1, const charT *s) const;
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
+#include "test_macros.h"
+
 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 template <class S>
 void
 test(const S& s, typename S::size_type pos1, typename S::size_type n1,
      const typename S::value_type* str, int x)
 {
+    if (pos1 <= s.size())
+        assert(sign(s.compare(pos1, n1, str)) == sign(x));
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
         try
         {
-        assert(sign(s.compare(pos1, n1, str)) == sign(x));
-        assert(pos1 <= s.size());
+            s.compare(pos1, n1, str);
+            assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos1 > s.size());
         }
     }
+#endif
+}
 
 template <class S>
 void test0()
 {
     test(S(""), 0, 0, "", 0);
     test(S(""), 0, 0, "abcde", -5);
     test(S(""), 0, 0, "abcdefghij", -10);
     test(S(""), 0, 0, "abcdefghijklmnopqrst", -20);

test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // int compare(size_type pos, size_type n1, const charT *s, size_type n2) const;
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
+#include "test_macros.h"
+
 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 template <class S>
 void
 test(const S& s, typename S::size_type pos, typename S::size_type n1,
      const typename S::value_type* str, typename S::size_type n2, int x)
 {
+    if (pos <= s.size())
+        assert(sign(s.compare(pos, n1, str, n2)) == sign(x));
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
         try
         {
-        assert(sign(s.compare(pos, n1, str, n2)) == sign(x));
-        assert(pos <= s.size());
+            s.compare(pos, n1, str, n2);
+            assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos > s.size());
         }
     }
+#endif
+}
 
 template <class S>
 void test0()
 {
     test(S(""), 0, 0, "", 0, 0);
     test(S(""), 0, 0, "abcde", 0, 0);
     test(S(""), 0, 0, "abcde", 1, -1);
     test(S(""), 0, 0, "abcde", 2, -2);

test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // int compare(size_type pos1, size_type n1, const basic_string& str) const;
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
+#include "test_macros.h"
+
 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 template <class S>
 void
 test(const S& s, typename S::size_type pos1, typename S::size_type n1,
      const S& str, int x)
 {
+    if (pos1 <= s.size())
+        assert(sign(s.compare(pos1, n1, str)) == sign(x));
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
         try
         {
-        assert(sign(s.compare(pos1, n1, str)) == sign(x));
-        assert(pos1 <= s.size());
+            s.compare(pos1, n1, str);
+            assert(false);
         }
         catch (std::out_of_range&)
         {
             assert(pos1 > s.size());
         }
     }
+#endif
+}
 
 template <class S>
 void test0()
 {
     test(S(""), 0, 0, S(""), 0);
     test(S(""), 0, 0, S("abcde"), -5);
     test(S(""), 0, 0, S("abcdefghij"), -10);
     test(S(""), 0, 0, S("abcdefghijklmnopqrst"), -20);

test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // <string>
 
 // int compare(size_type pos1, size_type n1, const basic_string& str,
 //             size_type pos2, size_type n2=npos) const;
 //  the "=npos" was added in C++14
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
+#include "test_macros.h"
+
 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 template <class S>
 void
 test(const S& s,   typename S::size_type pos1, typename S::size_type n1,
      const S& str, typename S::size_type pos2, typename S::size_type n2, int x)
 {
+    if (pos1 <= s.size() && pos2 <= str.size())
+        assert(sign(s.compare(pos1, n1, str, pos2, n2)) == sign(x));
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
         try
         {
-        assert(sign(s.compare(pos1, n1, str, pos2, n2)) == sign(x));
-        assert(pos1 <= s.size());
-        assert(pos2 <= str.size());
+            s.compare(pos1, n1, str, pos2, n2);
+            assert(false);
         }
         catch (const std::out_of_range&)
         {
             assert(pos1 > s.size() || pos2 > str.size());
         }
     }
+#endif
+}
 
 template <class S>
 void
 test_npos(const S& s,   typename S::size_type pos1, typename S::size_type n1,
           const S& str, typename S::size_type pos2, int x)
 {
+    if (pos1 <= s.size() && pos2 <= str.size())
+        assert(sign(s.compare(pos1, n1, str, pos2)) == sign(x));
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
         try
         {
-        assert(sign(s.compare(pos1, n1, str, pos2)) == sign(x));
-        assert(pos1 <= s.size());
-        assert(pos2 <= str.size());
+            s.compare(pos1, n1, str, pos2);
+            assert(false);
         }
         catch (const std::out_of_range&)
         {
             assert(pos1 > s.size() || pos2 > str.size());
         }
     }
+#endif
+}
 
 template <class S>
 void test0()
 {
     test(S(""), 0, 0, S(""), 0, 0, 0);
     test(S(""), 0, 0, S(""), 0, 1, 0);
     test(S(""), 0, 0, S(""), 1, 0, 0);
     test(S(""), 0, 0, S("abcde"), 0, 0, 0);