Protect locale tests under noexceptions

[rogfer01]

Summary

Skip tests that expect exceptions be thrown.

[mclow.lists]

This LGTM.

test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_err_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
 // <locale>
 
 // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
 
 // wstring_convert(const byte_string& byte_err,
 //                 const wide_string& wide_err = wide_string());
 
 #include <locale>
 #include <codecvt>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main()
 {
     typedef std::codecvt_utf8<wchar_t> Codecvt;
     typedef std::wstring_convert<Codecvt> Myconv;
 #if TEST_STD_VER > 11
     static_assert(!std::is_convertible<std::string, Myconv>::value, "");
     static_assert( std::is_constructible<Myconv, std::string>::value, "");
 #endif
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         Myconv myconv;
         try
         {
             myconv.to_bytes(L"\xDA83");
             assert(false);
         }
         catch (const std::range_error&)
         {
         }
         try
         {
             myconv.from_bytes('\xA5');
             assert(false);
         }
         catch (const std::range_error&)
         {
         }
     }
+#endif
     {
         Myconv myconv("byte error");
         std::string bs = myconv.to_bytes(L"\xDA83");
         assert(bs == "byte error");
+#ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
             myconv.from_bytes('\xA5');
             assert(false);
         }
         catch (const std::range_error&)
         {
         }
+#endif
     }
     {
         Myconv myconv("byte error", L"wide error");
         std::string bs = myconv.to_bytes(L"\xDA83");
         assert(bs == "byte error");
         std::wstring ws = myconv.from_bytes('\xA5');
         assert(ws == L"wide error");
     }
 }

test/std/localization/locales/locale.global.templates/use_facet.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
 // <locale>
 
 // template <class Facet> const Facet& use_facet(const locale& loc);
 
 #include <locale>
 #include <cassert>
 
+#include "test_macros.h"
+
 int facet_count = 0;
 
 struct my_facet
     : public std::locale::facet
 {
     static std::locale::id id;
 
     bool im_alive;
 
     my_facet() : im_alive(true) {++facet_count;}
     ~my_facet() {im_alive = false; --facet_count;}
 };
 
 std::locale::id my_facet::id;
 
 int main()
 {
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         const my_facet& f = std::use_facet<my_facet>(std::locale());
         ((void)f); // Prevent unused warning
         assert(false);
     }
     catch (std::bad_cast&)
     {
     }
+#endif
     const my_facet* fp = 0;
     {
         std::locale loc(std::locale(), new my_facet);
         const my_facet& f = std::use_facet<my_facet>(loc);
         assert(f.im_alive);
         fp = &f;
         assert(fp->im_alive);
         assert(facet_count == 1);
     }
     assert(facet_count == 0);
 }

test/std/localization/locales/locale/locale.cons/char_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
 // REQUIRES: locale.ru_RU.UTF-8
 // REQUIRES: locale.zh_CN.UTF-8
 
 // <locale>
 
 // explicit locale(const char* std_name);
 
 #include <locale>
 #include <new>
 #include <cassert>
 
 #include "count_new.hpp"
 #include "platform_support.h" // locale name macros
 
+#include "test_macros.h"
+
 
 void check(const std::locale& loc)
 {
     assert(std::has_facet<std::collate<char> >(loc));
     assert(std::has_facet<std::collate<wchar_t> >(loc));
 
     assert(std::has_facet<std::ctype<char> >(loc));
     assert(std::has_facet<std::ctype<wchar_t> >(loc));
int main()
         check(loc);
         std::locale loc2(LOCALE_ru_RU_UTF_8);
         check(loc2);
         assert(loc == loc2);
         std::locale loc3(LOCALE_zh_CN_UTF_8);
         check(loc3);
         assert(!(loc == loc3));
         assert(loc != loc3);
+#ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
             std::locale((const char*)0);
             assert(false);
         }
         catch (std::runtime_error&)
         {
         }
         try
         {
             std::locale("spazbot");
             assert(false);
         }
         catch (std::runtime_error&)
         {
         }
+#endif
         std::locale ok("");
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
 }

test/std/localization/locales/locale/locale.members/combine.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
 // <locale>
 
 // template <class Facet> locale combine(const locale& other) const;
 
 #include <locale>
 #include <stdexcept>
 #include <cassert>
 
 #include "count_new.hpp"
 
+#include "test_macros.h"
+
 void check(const std::locale& loc)
 {
     assert(std::has_facet<std::collate<char> >(loc));
     assert(std::has_facet<std::collate<wchar_t> >(loc));
 
     assert(std::has_facet<std::ctype<char> >(loc));
     assert(std::has_facet<std::ctype<wchar_t> >(loc));
     assert((std::has_facet<std::codecvt<char, char, std::mbstate_t> >(loc)));
int main()
         check(loc3);
         assert(loc3.name() == "*");
         assert((std::has_facet<my_facet>(loc3)));
         const my_facet& f = std::use_facet<my_facet>(loc3);
         assert(f.test() == 5);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
 }
+#ifndef TEST_HAS_NO_EXCEPTIONS
 {
     {
         std::locale loc;
         std::locale loc2;
         try
         {
             std::locale loc3 = loc.combine<my_facet>(loc2);
             assert(false);
         }
         catch (std::runtime_error&)
         {
         }
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
 }
+#endif
 }