Protect std::string tests under libcpp-no-exceptions

[rogfer01]

Summary

Skip tests that expect an exception be thrown and/or disable
unreachable catch handlers.

[mclow.lists]

We've been using a different pattern for this kind of tests (as we support more and more noexcept cases). Something like this (for the second change):

		template <class S>
		void
		test(const S& s, typename S::size_type pos, typename S::size_type n)
		{
			if (pos <= s.size())
			{
				S str = s.substr(pos, n);
				LIBCPP_ASSERT(str.__invariants());
				assert(pos <= s.size());
				typename S::size_type rlen = std::min(n, s.size() - pos);
				assert(str.size() == rlen);
				assert(S::traits_type::compare(s.data()+pos, str.data(), rlen) == 0);
			}
		#ifndef TEST_HAS_NO_EXCEPTIONS
			else
			{
				try
				{
					S str = s.substr(pos, n);
					assert(false);
				}
				catch (std::out_of_range&)
				{
					assert(pos > s.size());
				}
			}
		#endif
		}

I think that's much easier to read (and avoids duplication of the tests).

[rogfer01]

Restructure to minimize code duplication.

[rogfer01]

Ping?

[mclow.lists]

LGTM. Thanks.

libcxx/trunk/test/std/strings/basic.string/string.capacity/capacity.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 capacity() const;
 
 #include <string>
 #include <cassert>
 
 #include "test_allocator.h"
 #include "min_allocator.h"
 
+#include "test_macros.h"
+
 template <class S>
 void
 test(S s)
 {
     S::allocator_type::throw_after = 0;
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
+#endif
     {
         while (s.size() < s.capacity())
             s.push_back(typename S::value_type());
         assert(s.size() == s.capacity());
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (...)
     {
         assert(false);
     }
+#endif
     S::allocator_type::throw_after = INT_MAX;
 }
 
 int main()
 {
     {
     typedef std::basic_string<char, std::char_traits<char>, test_allocator<char> > S;
     S s;

libcxx/trunk/test/std/strings/basic.string/string.ops/string_substr/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 substr(size_type pos = 0, size_type n = npos) const;
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s, typename S::size_type pos, typename S::size_type n)
 {
-    try
+    if (pos <= s.size())
     {
         S str = s.substr(pos, n);
         LIBCPP_ASSERT(str.__invariants());
         assert(pos <= s.size());
         typename S::size_type rlen = std::min(n, s.size() - pos);
         assert(str.size() == rlen);
         assert(S::traits_type::compare(s.data()+pos, str.data(), rlen) == 0);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            S str = s.substr(pos, n);
+            assert(false);
+        }
         catch (std::out_of_range&)
         {
             assert(pos > s.size());
         }
     }
+#endif
+}
 
 int main()
 {
     {
     typedef std::string S;
     test(S(""), 0, 0);
     test(S(""), 1, 0);
     test(S("pniot"), 0, 0);