| /*************************************************************************** |
| * |
| * 19.std.exceptions.cpp - test exercising [lib.std.exceptions] |
| * |
| * $Id$ |
| * |
| *************************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed |
| * with this work for additional information regarding copyright |
| * ownership. The ASF licenses this file to you under the Apache |
| * License, Version 2.0 (the "License"); you may not use this file |
| * except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| * implied. See the License for the specific language governing |
| * permissions and limitations under the License. |
| * |
| * Copyright 2001-2008 Rogue Wave Software. |
| * |
| **************************************************************************/ |
| |
| #include <stdexcept> |
| |
| /**************************************************************************/ |
| |
| |
| template <class Exception> |
| int test_ex_spec (Exception*, const char *str) |
| { |
| #ifndef _RWSTD_NO_EXCEPTIONS |
| |
| try { |
| // also tests that exception objects can be constructed |
| // from a const char* argument w/o <string> having been |
| // explicitly #included first |
| Exception e (str); |
| (void)&e; |
| } |
| catch (...) { |
| return 1; |
| } |
| |
| #else // if defined (_RWSTD_NO_EXCEPTIONS); |
| |
| _RWSTD_UNUSED (str); |
| |
| #endif // _RWSTD_NO_EXCEPTIONS |
| |
| return 0; |
| } |
| |
| /**************************************************************************/ |
| |
| #include <string> |
| |
| /**************************************************************************/ |
| |
| |
| // helpers to verify that each exception's ctor is explicit |
| // not defined since they must not be referenced if test is successful |
| void is_explicit (const std::logic_error&); |
| void is_explicit (const std::domain_error&); |
| void is_explicit (const std::invalid_argument&); |
| void is_explicit (const std::length_error&); |
| void is_explicit (const std::out_of_range&); |
| void is_explicit (const std::runtime_error&); |
| void is_explicit (const std::range_error&); |
| void is_explicit (const std::overflow_error&); |
| void is_explicit (const std::underflow_error&); |
| |
| struct bogus_exception |
| { |
| // also verifies that std::string is declared |
| bogus_exception (const std::string&) { } |
| bogus_exception (const char*) { } |
| }; |
| |
| // calls to the overoaded is_explicit (std::string ()) must resolve |
| // to this function since there must be no implicit conversion from |
| // std::string to any of the exception classes |
| void is_explicit (const bogus_exception&) { } |
| |
| // exercise the ability to construct exception objects w/o |
| // explicitly #including <string> first; std::string must still |
| // be declared (but not necessarily defined) |
| |
| #if !defined (_RWSTD_NO_NAMESPACE) && !defined (_RWSTD_NO_HONOR_STD) |
| // declare a global function with the same name as exception |
| # define TEST_NAMESPACE_DEF(T) void T () |
| #else |
| # define TEST_NAMESPACE_DEF(ignore) (void)0 |
| #endif // !_RWSTD_NO_NAMESPACE && !_RWSTD_NO_HONOR_STD |
| |
| |
| #ifndef _RWSTD_NO_PTR_EXCEPTION_SPEC |
| # define _PTR_THROWS(spec) _THROWS (spec) |
| #else // if defined (_RWSTD_NO_PTR_EXCEPTION_SPEC) |
| // throw specs on pointers to functions not implemented... |
| # define _PTR_THROWS(ignore) |
| #endif // _RWSTD_NO_PTR_EXCEPTION_SPEC |
| |
| |
| // verify that each name is declared in namespace std |
| // w/o polluting the global namespace |
| #define TEST_DEF(T) \ |
| typedef std::T T ## _type; \ |
| TEST_NAMESPACE_DEF (T); \ |
| /* construct an object */ \ |
| std::T obj_ ## T ("std::" _RWSTD_STR (T)); \ |
| /* assign the address of object to std::exception* */ \ |
| e = &obj_ ## T; \ |
| /* verify that assignment can't throw */ \ |
| std::T& (std::T::*p_assign_ ## T)(const std::T&) \ |
| _PTR_THROWS(()) = &std::T::operator=; \ |
| _RWSTD_UNUSED (p_assign_ ## T); \ |
| /* verify that what() can't throw */ \ |
| const char* (std::T::*p_what_ ## T)() const \ |
| _PTR_THROWS(()) = &std::T::what; \ |
| _RWSTD_UNUSED (p_what_ ## T); \ |
| /* verify ctor postcondition */ \ |
| result = result << 1 | cmp (obj_ ## T.what (), \ |
| "std::" _RWSTD_STR (T)) |
| |
| |
| int cmp (const char *s1, const char *s2) |
| { |
| for (; *s1 && *s1 == *s2; ++s1, ++s2); |
| return *s2 - *s1; |
| } |
| |
| |
| // returns 0 on success; on failure returns a bitmap with one bit set |
| // for every exception that failed its ctor postcondition |
| static int test_exception_defs () |
| { |
| int result = 0; |
| |
| // used below to verify public inheritance from std::exception |
| std::exception *e = 0; |
| |
| TEST_DEF (logic_error); |
| TEST_DEF (domain_error); |
| TEST_DEF (invalid_argument); |
| TEST_DEF (length_error); |
| TEST_DEF (out_of_range); |
| TEST_DEF (runtime_error); |
| TEST_DEF (range_error); |
| TEST_DEF (overflow_error); |
| TEST_DEF (underflow_error); |
| |
| _RWSTD_UNUSED (e); |
| |
| #ifndef _RWSTD_NO_EXPLICIT |
| |
| // verify that each exceptions converting ctor is explicit |
| // use a pointer since std::string need not be a complete class |
| const char s[40] = ""; |
| const std::string *ps = _RWSTD_REINTERPRET_CAST (const std::string*, s); |
| is_explicit (*ps); |
| |
| // verify that each exceptions converting ctor from const char* |
| // (if one exists) is also explicit |
| is_explicit (s); |
| |
| #endif // _RWSTD_NO_EXPLICIT |
| |
| return result; |
| } |
| |
| #undef _PTR_THROWS |
| |
| /**************************************************************************/ |
| |
| #include <rw_new.h> |
| #include <driver.h> |
| #include <cstddef> |
| |
| /**************************************************************************/ |
| |
| |
| template <class Exception> |
| int test_throw (Exception*, const char *str) |
| { |
| #ifndef _RWSTD_NO_EXCEPTIONS |
| |
| ////////////////////////////////////////////////////////////////// |
| |
| try { |
| throw Exception (str); |
| } |
| catch (const Exception &e) { |
| // caught by const reference |
| rw_assert (e.what () && !cmp (e.what (), str), |
| 0, __LINE__, |
| "caught by const reference; %s::what() == %#s", |
| str, str); |
| } |
| catch (...) { |
| rw_assert (false, 0, __LINE__, |
| "threw %s, caught an unknown exception", str); |
| } |
| |
| ////////////////////////////////////////////////////////////////// |
| |
| try { |
| throw Exception (str); |
| } |
| catch (Exception e) { |
| // caught by value |
| rw_assert (e.what () && !cmp (e.what (), str), |
| 0, __LINE__, |
| "caught by value; %s::what() == %#s", |
| str, str); |
| } |
| catch (...) { |
| rw_assert (false, 0, __LINE__, |
| "threw %s, caught an unknown exception", str); |
| } |
| |
| ////////////////////////////////////////////////////////////////// |
| |
| const Exception ex (str); |
| |
| try { |
| throw ex; |
| } |
| catch (Exception e) { |
| // caught copy by value |
| rw_assert (e.what () && !cmp (e.what (), str), |
| 0, __LINE__, |
| "caught copy by value; %s::what() == %#s", |
| str, str); |
| } |
| catch (...) { |
| rw_assert (false, 0, __LINE__, |
| "threw %s, caught an unknown exception", str); |
| } |
| |
| ////////////////////////////////////////////////////////////////// |
| |
| try { |
| throw ex; |
| } |
| catch (std::exception &e) { |
| // caught by non-const reference to a base class |
| rw_assert (e.what () && !cmp (e.what (), str), |
| 0, __LINE__, |
| "caught by non-const reference to base; %s::what() == %#s", |
| str, str); |
| } |
| catch (...) { |
| rw_assert (false, 0, __LINE__, |
| "threw %s, caught an unknown exception", str); |
| } |
| |
| ////////////////////////////////////////////////////////////////// |
| |
| try { |
| try { |
| throw Exception (str); |
| } |
| catch (...) { |
| // rethrown |
| throw; |
| } |
| } |
| catch (Exception e) { |
| // rethrown object caught by value |
| rw_assert (e.what () && !cmp (e.what (), str), |
| 0, __LINE__, |
| "caught rethrown by value; %s::what() == %#s", str, str); |
| } |
| catch (...) { |
| rw_assert (false, 0, __LINE__, |
| "threw %s, caught an unknown exception", str); |
| } |
| |
| ////////////////////////////////////////////////////////////////// |
| |
| try { |
| try { |
| throw Exception (str); |
| } |
| catch (Exception e) { |
| rw_assert (e.what () && !cmp (e.what (), str), |
| 0, __LINE__, |
| "caught by value; %s::what() == %#s", |
| str, str); |
| |
| // rethrown by value |
| throw e; |
| } |
| } |
| catch (Exception e) { |
| // rethrown object caught by value |
| rw_assert (e.what () && !cmp (e.what (), str), |
| 0, __LINE__, |
| "caught rethrown copy by value; %s::what() == %#s", |
| str, str); |
| } |
| catch (...) { |
| rw_assert (false, 0, __LINE__, |
| "threw %s, caught an unknown exception", str); |
| } |
| |
| #else // if defined (_RWSTD_NO_EXCEPTIONS); |
| |
| _RWSTD_UNUSED (t); |
| _RWSTD_UNUSED (str); |
| |
| #endif // _RWSTD_NO_EXCEPTIONS |
| |
| return 0; |
| } |
| |
| /**************************************************************************/ |
| |
| |
| static int |
| run_test (int, char* []) |
| { |
| // verify that exception's (and its derivatives') ctor is explicit |
| is_explicit (std::string ()); |
| |
| const char* const names[] = { |
| "logic_error", "domain_error", "invalid_argument", "length_error", |
| "out_of_range", "runtime_error", "range_error", "overflow_error", |
| "underflow_error" |
| }; |
| |
| // if set, each bit corresponds to a failed exception assertion |
| const int failures = test_exception_defs (); |
| |
| for (unsigned i = 0; i != sizeof names / sizeof *names; ++i) { |
| rw_assert (!(failures & (1 << i)), 0, __LINE__, |
| "std::%s::%s (const std::string&) postcondition", |
| names [i]); |
| } |
| |
| |
| // have replacement operator new throw an exception |
| rwt_free_store* const pst = rwt_get_free_store (0); |
| *pst->throw_at_calls_ [0] = pst->new_calls_ [0] + 1; |
| |
| // create a very long string to guarantee that exception ctors |
| // try to dynamically allocate storage even if it otherwise |
| // use some clever scheme to avoid doing so |
| char long_str [0x10000]; |
| for (unsigned i = 0; i != sizeof long_str - 1; ++i) |
| long_str [i] = '*'; |
| |
| long_str [sizeof long_str - 1] = '\0'; |
| |
| int new_throws = 0; |
| |
| _TRY { |
| // see if replacement operator new throws an exception |
| // when called directly from the program |
| void *p = ::operator new (sizeof long_str); |
| ::operator delete (p); |
| new_throws = 0; |
| |
| #ifdef _RWSTD_NO_REPLACEABLE_NEW_DELETE |
| |
| // MSVC and VAC++ don't reliably replace operators |
| // new and delete across shared librray boundaries |
| |
| rw_warn (false, 0, __LINE__, |
| "replacement ::operator new(std::size_t = %u) failed " |
| "to throw when called directly from a program: this " |
| "is an expected failure on this platform", |
| sizeof long_str); |
| |
| #else // if !defined (_RWSTD_NO_REPLACEABLE_NEW_DELETE) |
| |
| rw_assert (false, 0, __LINE__, |
| "replacement ::operator new(std::size_t = %u) " |
| "unexpectdly failed to throw when called directly " |
| "from a program", |
| sizeof long_str); |
| |
| #endif // _RWSTD_NO_REPLACEABLE_NEW_DELETE |
| |
| } |
| _CATCH (...) { |
| new_throws = 1; |
| } |
| |
| *pst->throw_at_calls_ [0] = pst->new_calls_ [0] + 1; |
| |
| _TRY { |
| // see if replacement operator new throws an exception |
| // when called indirectly, i.e., from the library binary |
| void* const p = _RW::__rw_allocate (sizeof long_str, 0); |
| _RW::__rw_deallocate (p, 0); |
| new_throws = 0; |
| |
| #ifdef _RWSTD_NO_REPLACEABLE_NEW_DELETE |
| |
| // MSVC and VAC++ don't reliably replace operators |
| // new and delete across shared librray boundaries |
| |
| rw_warn (false, 0, __LINE__, |
| "replacement ::operator new(std::size_t = %u) failed " |
| "to throw when called from the library: this is an " |
| "expected failure on this platform", |
| sizeof long_str); |
| |
| #else // if !defined (_RWSTD_NO_REPLACEABLE_NEW_DELETE) |
| |
| rw_assert (false, 0, __LINE__, |
| "replacement ::operator new(std::size_t = %u) " |
| "unexpectdly failed to throw when called from " |
| "the library", |
| sizeof long_str); |
| |
| #endif // _RWSTD_NO_REPLACEABLE_NEW_DELETE |
| |
| } |
| _CATCH (...) { |
| new_throws = 1; |
| } |
| |
| // exercise exception specification on class ctors |
| // and the ability to throw and catch exception objects |
| #define TEST_EX_SPEC(T) do { \ |
| /* do not induce an exception from replacement operator new */ \ |
| *pst->throw_at_calls_ [0] = std::size_t (-1); \ |
| *pst->throw_at_calls_ [1] = std::size_t (-1); \ |
| /* verify that exception objects can be thrown, caught, and rethrown */\ |
| test_throw ((std:: T*)0, "std::" #T); \ |
| /* induce an exception from replacement operator new */ \ |
| *pst->throw_at_calls_ [0] = pst->new_calls_ [0] + 1; \ |
| *pst->throw_at_calls_ [1] = pst->new_calls_ [1] + 1; \ |
| /* verify that each exception ctor propagates the exception thrown */ \ |
| /* from operator new(); failure wil cause a call to terminate() */ \ |
| /* tests are expected to silently fail if (0 == new_throws) holds */ \ |
| const int threw = test_ex_spec ((std::T*)0, long_str); \ |
| rw_assert (threw == new_throws, 0, __LINE__, \ |
| "attempthing to construct a std::" #T " %s an exception", \ |
| new_throws ? "failed to rethrow" : "unexpectedly threw"); \ |
| } while (0) |
| |
| TEST_EX_SPEC (logic_error); |
| TEST_EX_SPEC (domain_error); |
| TEST_EX_SPEC (invalid_argument); |
| TEST_EX_SPEC (length_error); |
| TEST_EX_SPEC (out_of_range); |
| TEST_EX_SPEC (runtime_error); |
| TEST_EX_SPEC (range_error); |
| TEST_EX_SPEC (overflow_error); |
| TEST_EX_SPEC (underflow_error); |
| |
| return 0; |
| } |
| |
| /**************************************************************************/ |
| |
| |
| int main (int argc, char* argv []) |
| { |
| return rw_test (argc, argv, __FILE__, |
| "lib.std.exceptions", |
| 0 /* no comment */, |
| run_test, |
| "", |
| (void*)0); |
| } |
