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

[rogfer01]

Summary

Skip tests that expect an exception be thrown.

[rogfer01]

test/std/input.output/iostreams.base/ios/basic.ios.members/copyfmt.pass.cpp

171–173 ↗

(On Diff #77503)

This is a bit unexpected. It looks like if the copyfmt, even if it throws, were able to copy part of the information. Is this reasonable?

[EricWF]

LGTM modulo inline comments. There are a couple of tests which don't explicitly assert if they throw or not. Please address those tests before committing.

test/std/input.output/iostreams.base/ios/basic.ios.members/set_rdbuf.pass.cpp

44 ↗

(On Diff #77503)

assert(false);

It's unrelated but it should be added.

test/std/input.output/iostreams.base/ios/iostate.flags/clear.pass.cpp

33 ↗

(On Diff #77503)

assert(false);

test/std/input.output/iostreams.base/ios/iostate.flags/setstate.pass.cpp

33 ↗

(On Diff #77503)

assert(false)

[rogfer01]

Add missing asserts as pointed out by @EricWF

libcxx/trunk/test/std/input.output/iostreams.base/ios/basic.ios.members/copyfmt.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.en_US.UTF-8
 // REQUIRES: locale.fr_FR.UTF-8
 
 // <ios>
 
 // template <class charT, class traits> class basic_ios
 
 // basic_ios& copyfmt(const basic_ios& rhs);
 
 #include <ios>
 #include <streambuf>
 #include <cassert>
 
 #include "platform_support.h" // locale name macros
 
+#include "test_macros.h"
+
 struct testbuf
     : public std::streambuf
 {
 };
 
 bool f1_called = false;
 bool f2_called = false;
 
int main()
     ios2.pword(0) = &d1;
     ios2.pword(1) = &d2;
     ios2.tie((std::ostream*)2);
     ios2.fill('2');
 
     ios1.copyfmt(ios1);
     assert(!f1_called);
 
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         ios1.copyfmt(ios2);
         assert(false);
     }
     catch (std::ios_base::failure&)
     {
     }
+#else
+    ios1.copyfmt(ios2);
+#endif
     assert(ios1.rdstate() == std::ios::eofbit);
     assert(ios1.rdbuf() == &sb1);
     assert(ios1.flags() == (std::ios::showpoint | std::ios::uppercase));
     assert(ios1.precision() == 2);
     assert(ios1.width() == 12);
     assert(ios1.getloc().name() == LOCALE_fr_FR_UTF_8);
     assert(ios1.exceptions() == std::ios::eofbit);
     assert(f1_called);

libcxx/trunk/test/std/input.output/iostreams.base/ios/basic.ios.members/set_rdbuf.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
 // <ios>
 
 // template <class charT, class traits> class basic_ios
 
 // void set_rdbuf(basic_streambuf<charT, traits>* sb);
 
 #include <ios>
 #include <streambuf>
 #include <cassert>
 
+#include "test_macros.h"
+
 struct testbuf
     : public std::streambuf
 {
 };
 
 struct testios
     : public std::ios
 {
     testios(std::streambuf* p) : std::ios(p) {}
     void set_rdbuf(std::streambuf* x) {std::ios::set_rdbuf(x);}
 };
 
 int main()
 {
     testbuf sb1;
     testbuf sb2;
     testios ios(&sb1);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         ios.setstate(std::ios::badbit);
         ios.exceptions(std::ios::badbit);
+        assert(false);
     }
     catch (...)
     {
     }
+#endif
     ios.set_rdbuf(&sb2);
     assert(ios.rdbuf() == &sb2);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
         ios.setstate(std::ios::badbit);
         ios.exceptions(std::ios::badbit);
     }
     catch (...)
     {
     }
+#endif
     ios.set_rdbuf(0);
     assert(ios.rdbuf() == 0);
 }

libcxx/trunk/test/std/input.output/iostreams.base/ios/iostate.flags/clear.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
 // <ios>
 
 // template <class charT, class traits> class basic_ios
 
 // void clear(iostate state = goodbit);
 
 #include <ios>
 #include <streambuf>
 #include <cassert>
 
+#include "test_macros.h"
+
 struct testbuf : public std::streambuf {};
 
 int main()
 {
     {
         std::ios ios(0);
         ios.clear();
         assert(ios.rdstate() == std::ios::badbit);
+#ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
             ios.exceptions(std::ios::badbit);
+            assert(false);
         }
         catch (...)
         {
         }
         try
         {
             ios.clear();
             assert(false);
         }
         catch (std::ios::failure&)
         {
             assert(ios.rdstate() == std::ios::badbit);
         }
         try
         {
             ios.clear(std::ios::eofbit);
             assert(false);
         }
         catch (std::ios::failure&)
         {
             assert(ios.rdstate() == (std::ios::eofbit | std::ios::badbit));
         }
+#endif
     }
     {
         testbuf sb;
         std::ios ios(&sb);
         ios.clear();
         assert(ios.rdstate() == std::ios::goodbit);
         ios.exceptions(std::ios::badbit);
         ios.clear();
         assert(ios.rdstate() == std::ios::goodbit);
         ios.clear(std::ios::eofbit);
         assert(ios.rdstate() == std::ios::eofbit);
     }
 }

libcxx/trunk/test/std/input.output/iostreams.base/ios/iostate.flags/exceptions_iostate.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
 // <ios>
 
 // template <class charT, class traits> class basic_ios
 
 // iostate exceptions() const;
 
 #include <ios>
 #include <streambuf>
 #include <cassert>
 
+#include "test_macros.h"
+
 struct testbuf : public std::streambuf {};
 
 int main()
 {
     {
         std::ios ios(0);
         assert(ios.exceptions() == std::ios::goodbit);
         ios.exceptions(std::ios::eofbit);
         assert(ios.exceptions() == std::ios::eofbit);
+#ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
             ios.exceptions(std::ios::badbit);
             assert(false);
         }
         catch (std::ios::failure&)
         {
         }
         assert(ios.exceptions() == std::ios::badbit);
+#endif
     }
     {
         testbuf sb;
         std::ios ios(&sb);
         assert(ios.exceptions() == std::ios::goodbit);
         ios.exceptions(std::ios::eofbit);
         assert(ios.exceptions() == std::ios::eofbit);
         ios.exceptions(std::ios::badbit);
         assert(ios.exceptions() == std::ios::badbit);
     }
 }

libcxx/trunk/test/std/input.output/iostreams.base/ios/iostate.flags/setstate.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
 // <ios>
 
 // template <class charT, class traits> class basic_ios
 
 // void setstate(iostate state);
 
 #include <ios>
 #include <streambuf>
 #include <cassert>
 
+#include "test_macros.h"
+
 struct testbuf : public std::streambuf {};
 
 int main()
 {
     {
         std::ios ios(0);
         ios.setstate(std::ios::goodbit);
         assert(ios.rdstate() == std::ios::badbit);
+#ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
             ios.exceptions(std::ios::badbit);
+            assert(false);
         }
         catch (...)
         {
         }
         try
         {
             ios.setstate(std::ios::goodbit);
             assert(false);
         }
         catch (std::ios::failure&)
         {
             assert(ios.rdstate() == std::ios::badbit);
         }
         try
         {
             ios.setstate(std::ios::eofbit);
             assert(false);
         }
         catch (std::ios::failure&)
         {
             assert(ios.rdstate() == (std::ios::eofbit | std::ios::badbit));
         }
+#endif
     }
     {
         testbuf sb;
         std::ios ios(&sb);
         ios.setstate(std::ios::goodbit);
         assert(ios.rdstate() == std::ios::goodbit);
         ios.setstate(std::ios::eofbit);
         assert(ios.rdstate() == std::ios::eofbit);
         ios.setstate(std::ios::failbit);
         assert(ios.rdstate() == (std::ios::eofbit | std::ios::failbit));
     }
 }