18.exception.cpp

Go to the documentation of this file.

 
#ifdef __SUNPRO_CC
    // working around a SunPro/SunOS 5.8 bug (PR #26255)
#  include <time.h>
#endif   // __SUNPRO_CC
 
#include <exception>      // for bad_exception, exception
#include <ios>            // for ios_base::failure
#include <new>            // for bad_alloc
#include <stdexcept>      // for exception classes
#include <typeinfo>       // for bad_cast, bad_typeid
 
#include <csignal>        // for signal(), SIGABRT
#include <cstdio>         // for size_t, sprintf()
#include <cstring>        // for strcmp(), strlen()
 
#include <rw/_error.h>    // for _RWSTD_ERROR_XXX constants
 
 
#ifndef _RWSTD_NO_SETRLIMIT
# include <sys/resource.h>   // for setrlimit()
#endif   // _RWSTD_NO_SETRLIMIT
 
#include <rw_driver.h>
 
 
#ifdef _RWSTD_OS_LINUX
   // use siglongjmp() and sigsetjmp() on Linux to avoid
   // http://sourceware.org/bugzilla/show_bug.cgi?id=2351
 
#  ifndef _RWSTD_NO_PURE_C_HEADERS
#    include <csetjmp>    // for jmp_buf
 
// when using "pure C headers" on Linux (i.e., with EDG eccp)
// declare POSIX functions that aren't otherwise required or
// expected to be declared by strictly conforming standard
// C/C++ headers
 
extern "C" {
 
typedef std::jmp_buf sigjmp_buf;
 
// Linux/glibc-specific:
int __sigsetjmp (sigjmp_buf, int);
 
#    define sigsetjmp(env, savemask)   __sigsetjmp (env, savemask)
 
void siglongjmp (sigjmp_buf, int);
 
}   // extern "C"
 
#    define RW_JMP_BUF             std::jmp_buf
#    define RW_SETJMP(env)         sigsetjmp (env, 0)
#    define RW_LONGJMP(env, val)   siglongjmp (env, val)
 
#  else   // if defined _RWSTD_NO_PURE_C_HEADERS
#    include <setjmp.h>    // for siglongjmp(), sigsetjmp()
 
#    define RW_JMP_BUF             jmp_buf
#    define RW_SETJMP(env)         sigsetjmp (env, 0)
#    define RW_LONGJMP(env, val)   siglongjmp (env, val)
#  endif   // _RWSTD_NO_PURE_C_HEADERS
 
#else   // if !defined (_RWSTD_OS_LINUX)
#  include <csetjmp>    // for longjmp(), setjmp()
 
#  define RW_JMP_BUF             std::jmp_buf
#  ifdef setjmp
#    define RW_SETJMP(env)       setjmp (env)
#  else
#    define RW_SETJMP(env)       std::setjmp (env)
#  endif
#  define RW_LONGJMP(env, val)   std::longjmp (env, val)
#endif   // _RWSTD_OS_LINUX
 
 
// check header <exception> synopsis
static void
test_synopsis ()
{
    // check header <exception> synopsis
    rw_info (0, 0, __LINE__, "header <exception> synopsis");
 
    // verify that classes are declared
    std::exception *pex = (std::exception*)0;
 
    // verify that bad_exception publicly derives from exception
    pex = (std::bad_exception*)0;
    _RWSTD_UNUSED (pex);
 
    // check handler types
    void (*phandler)() = (std::unexpected_handler)0;
    phandler = (std::terminate_handler)0;
 
    // check unexpected and terminate
    phandler = &std::unexpected;
    phandler = &std::terminate;
    _RWSTD_UNUSED (phandler);
 
    // check set_{unexpected,terminate}
    std::unexpected_handler (*pset)(std::unexpected_handler) _PTR_THROWS (());
 
    pset = &std::set_unexpected;
    pset = &std::set_terminate;
    _RWSTD_UNUSED (pset);
 
    // check uncaught_exception()
    // see http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#70
    // for exception specification details
    bool (*pue)() _PTR_THROWS (()) = &std::uncaught_exception;
    _RWSTD_UNUSED (pue);
}
 
 
// defined at global scope rather than as locals
// to work around an MSVC 6.0 bug (see PR #26305)
static bool dtor_virtual = false;
static bool what_virtual = false;
 
// check the signatures of class exception and bad_exception members
static void
test_signatures ()
{
// verify that a member function is accessible and has the appropriate
// signature, including return type and exception specification
#define MEMFUN(result, T, name, arg_list) do {                   \
        result (T::*pf) arg_list _PTR_THROWS (()) = &T::name;    \
        _RWSTD_UNUSED (pf);                                      \
    } while (0)
 
    rw_info (0, 0, __LINE__, "std::exception member function signatures");
 
    // verify 18.6.1 [lib.exception]
 
    // verify that a public default and copy ctors exist
    std::exception e1;
    std::exception e2 (e1);
 
    MEMFUN (std::exception&, std::exception, operator=,
            (const std::exception&));
    MEMFUN (const char*, std::exception, what, () const);
 
    struct test_exception_virtuals: std::exception {
 
        ~test_exception_virtuals () _THROWS (()) {
            dtor_virtual = true;
        }
        const char* what () const _THROWS (()) {
            what_virtual = true;
 
            // working around an MSVC 6.0 bug (PR #26330)
            typedef std::exception Base;
            return Base::what ();
        }
    };
 
    std::exception *pe = new test_exception_virtuals;
 
    // verify that destructor and what() are virtual
    pe->what ();
    rw_assert (what_virtual, 0, __LINE__,
               "std::exception::what() not virtual");
 
    delete pe;
    rw_assert (dtor_virtual, 0, __LINE__,
               "std::exception::~exception() not virtual");
 
 
    rw_info (0, 0, __LINE__, "std::bad_exception member function signatures");
 
    // verify 18.6.2.1 [lib.bad.exception]
    // verify that a public default and copy ctors exist
    std::bad_exception be1;
    std::bad_exception be2 (be1);
 
    MEMFUN (std::bad_exception&, std::bad_exception, operator=,
            (const std::bad_exception&));
    MEMFUN (const char*, std::bad_exception, what, () const);
 
    dtor_virtual = false;
    what_virtual = false;
 
    struct test_bad_exception_virtuals: std::bad_exception {
 
        ~test_bad_exception_virtuals () _THROWS (()) {
            dtor_virtual = true;
        }
        const char* what () const _THROWS (()) {
            what_virtual = true;
 
            // working around an MSVC 6.0 bug (PR #26330)
            typedef std::bad_exception Base;
            return Base::what ();
        }
    };
 
    pe = new test_bad_exception_virtuals;
 
    // verify that destructor and what() are virtual
    pe->what ();
    rw_assert (what_virtual, 0, __LINE__,
               "std::bad_exception::what() not virtual");
 
    delete pe;
    rw_assert (dtor_virtual, 0, __LINE__,
               "std::bad_exception::~bad_exception() not virtual");
}
 
 
// test globals (to make the accessible in signal and other handlers)
std::unexpected_handler puh;                 // previous unexpected_handler
std::terminate_handler  pth;                 // previous terminate_handler
int                     expect_abort;        // SIGABRT expected if 1
int                     expect_terminate;    // terminate expected if 1
int                     expect_unexpected;   // unexpected expected if 1
int                     expect_throw_proc;   // throw_proc expected if 1
RW_JMP_BUF              jmpenv;
 
 
// called in response to abort() (called from std::terminate())
extern "C" {
 
static void
SIGABRT_handler (int signo)
{
    rw_assert (1 == expect_abort && SIGABRT == signo, 0, __LINE__,
               "SIGABRT unexpected");
 
    // reestablish handler
    std::signal (SIGABRT, SIGABRT_handler);
 
    expect_abort = -1;
 
    RW_LONGJMP (jmpenv, 1);
}
 
}   // extern "C"
 
 
static void
test_terminate_handler ()
{
    rw_assert (1 == expect_terminate, 0, __LINE__,
               "std::terminate() unexpected");
 
    expect_terminate = -1;
 
    // establish a handler for SIGABRT (raised from abort())
    std::signal (SIGABRT, SIGABRT_handler);
 
    // invoke default terminate handler
    pth ();
 
    // shouldn't be reached
    rw_assert (false, 0, __LINE__,
               "std::terminate() not called or returned");
 
    RW_LONGJMP (jmpenv, -1);
}
 
 
static void
test_unexpected_handler ()
{
    rw_assert (1 == expect_unexpected, 0, __LINE__,
               "std::unexpected() unexpected");
 
    expect_unexpected = -1;
 
    // establish a handler for SIGABRT (raised from abort())
    std::signal (SIGABRT, SIGABRT_handler);
 
    expect_abort     = 1;
    expect_terminate = 1;
 
    // throw an exception outside of any try block
    // useless conditional used to prevent warnings
    if (expect_abort)
        throw 1;
 
    // shouldn't be reached
    rw_assert (false, 0, __LINE__,
               "std::terminate() not called or returned");
 
    RW_LONGJMP (jmpenv, -1);
}
 
 
// test the effects of 18.6
static void
test_effects ()
{
    // verify 18.6.1, p8: what() returns an implementation-defined NTBS
    std::exception e1;
    const char *what = e1.what ();
    rw_assert (what && 1 <= 1 + std::strlen (what), 0, __LINE__,
               "std::exception::what() != 0");
 
    std::exception e2 (e1);
    what = e2.what ();
    rw_assert (what && 1 <= 1 + std::strlen (what), 0, __LINE__,
               "std::exception::what() != 0");
 
    // verify 18.6.2.1, p5: what() returns an implementation-defined NTBS
    std::bad_exception e3;
    what = e3.what ();
    rw_assert (what && 1 <= 1 + std::strlen (what), 0, __LINE__,
               "std::bad_exception::what() != 0");
 
    std::exception e4 (e3);
    what = e4.what ();
    rw_assert (what && 1 <= 1 + std::strlen (what), 0, __LINE__,
               "std::bad_exception::what()");
 
#if    !defined (_RWSTD_NO_EXCEPTIONS) \
    && !defined (_RWSTD_NO_EXCEPTION_SPECIFICATION)
 
    struct S {
        static void foo () throw (double) {
            throw 1;
        }
    };
 
    rw_info (0, 0, __LINE__, "std::set_unexpected()");
    rw_info (0, 0, __LINE__, "std::set_terminate()");
 
    // determine the address of the default
    // handlers and replace them with our own
    puh = std::set_unexpected (test_unexpected_handler);
    pth = std::set_terminate  (test_terminate_handler);
 
    // invoke a function that throws an exception
    // that is not in its exception specification
    expect_unexpected = 1;
 
    try {
        S::foo ();
    }
    catch (...) {
        rw_assert (0,  0, __LINE__, "incompatible exception propagated");
    }
 
    RW_LONGJMP (jmpenv, -1);
 
#else
 
    // prevent failures due to functionality not implemented in compiler
    expect_abort = -1;
    expect_terminate = -1;
    expect_unexpected = -1;
 
#endif   // _RWSTD_NO_EXCEPTIONS && ...
}
 
 
struct UncaughtExceptionCheck {
    bool *presult_;
 
    ~UncaughtExceptionCheck () {
        *presult_ = std::uncaught_exception ();
    }
};
 
static void
test_uncaught_exception ()
{
    rw_info (0, 0, __LINE__, "std::uncaught_exception()");
 
    bool expect;
    bool uncaught = std::uncaught_exception ();
 
#if    !defined (_RWSTD_NO_STD_UNCAUGHT_EXCEPTION)   \
    || !defined (_RWSTD_NO_GLOBAL_UNCAUGHT_EXCEPTION)
 
    expect = false;
 
#else
 
#  ifndef _RWSTD_NO_EXCEPTIONS
 
    expect = true;
 
#  else   // if defined (_RWSTD_NO_EXCEPTIONS)
 
    expect = false;
 
#  endif   // _RWSTD_NO_EXCEPTIONS)
 
#endif
 
    rw_assert (uncaught == expect, 0, __LINE__,
               "std::uncaught_exception() == %d, got %d", expect, uncaught);
 
#ifndef _RWSTD_NO_EXCEPTIONS
 
    expect = true;
 
    try {
        UncaughtExceptionCheck chk;
 
        chk.presult_ = &uncaught;
 
        // silence (bogus) EDG eccp unused variable remark 550
        _RWSTD_UNUSED (chk);
 
        throw 0;
    }
    catch (...) {
    }
 
#else   // if defined (_RWSTD_NO_EXCEPTIONS)
 
    expect = false;
 
    {
        UncaughtExceptionCheck chk;
 
        chk.presult_ = &uncaught;
    }
 
#endif   // _RWSTD_NO_EXCEPTIONS
 
    rw_assert (uncaught == expect, 0, __LINE__,
               "std::uncaught_exception() == %d, got %d", expect, uncaught);
}
 
 
// original throw proc
static void (*const pthrow_proc_save)(int, char*) = _RW::__rw_throw_proc;
 
// replaces the original throw proc
static void
test_throw_proc (int id, char *s)
{
    rw_assert (id == expect_throw_proc,  0, __LINE__,
               "throw_proc expected %d, got %d (\"%s\")",
               expect_throw_proc, id, s);
 
    _RW::__rw_free_what_buf (s);
 
    // signal that we were successfully called and with what value
    expect_throw_proc = -id;
}
 
 
// exercise __rw::__rw_throw() and __rw::__rw_throw_proc()
static void
test_rw_throw ()
{
#ifndef _RWSTD_NO_EXCEPTIONS
 
    rw_info (0, 0, __LINE__, "__rw::__rw_throw()");
 
    // exception format strings
    static const char* strings[] = { _RWSTD_ERROR_STRINGS };
 
    // exception id's: strings [i + 1] corresponds to expect [i]
    static const int expect[] = {
        _RWSTD_ERROR_FIRST + 1,   // _RWSTD_ERROR_EXCEPTION
        _RWSTD_ERROR_FIRST + 2,   // _RWSTD_ERROR_BAD_EXCEPTION
        _RWSTD_ERROR_FIRST + 3,   // _RWSTD_ERROR_BAD_ALLOC
        _RWSTD_ERROR_FIRST + 4,   // _RWSTD_ERROR_BAD_CAST
        _RWSTD_ERROR_LOGIC_ERROR,
        _RWSTD_ERROR_DOMAIN_ERROR,
        _RWSTD_ERROR_INVALID_ARGUMENT,
        _RWSTD_ERROR_LENGTH_ERROR,
        _RWSTD_ERROR_OUT_OF_RANGE,
        _RWSTD_ERROR_RUNTIME_ERROR,
        _RWSTD_ERROR_RANGE_ERROR,
        _RWSTD_ERROR_OVERFLOW_ERROR,
        _RWSTD_ERROR_UNDERFLOW_ERROR,
 
        _RWSTD_ERROR_FAILBIT_SET,
        _RWSTD_ERROR_BADBIT_SET,
        _RWSTD_ERROR_EOFBIT_SET,
        _RWSTD_ERROR_IOSTATE_BIT_SET
    };
 
    const char* const ex_names[] = {
        "std::exception",
        "std::bad_exception",
        "std::bad_alloc",
        "std::bad_cast",
        "std::logic_error",
        "std::domain_error",
        "std::invalid_argument",
        "std::length_error",
        "std::out_of_range",
        "std::runtime_error",
        "std::range_error",
        "std::overflow_error",
        "std::underflow_error",
 
        "std::ios_base::failbit_set",
        "std::ios_base::badbit_set",
        "std::ios_base::eofbit_set",
        "std::ios_base::failure"
    };
 
    const char empty[] = "";
 
    // raise each exception by its id, check that
    // an exception object of the correct type is thrown
    for (unsigned i = 0; i != sizeof expect / sizeof *expect; ++i) {
 
        rw_info (0, 0, __LINE__, "%s", ex_names [i]);
 
        int caught = -1;
 
        // set up a new throw proc (prevent exceptions)
        _RW::__rw_throw_proc = test_throw_proc;
 
        // no exception should be thrown at this point
        expect_throw_proc = expect [i];
 
        const char format[] = _RWSTD_FILE_LINE;
        const char func[]   = "void test_rwt_hrow (Test&)";
 
        _RW::__rw_throw (expect [i], format, func, empty, empty, empty);
 
        rw_assert (expect [i] == -expect_throw_proc, 0, __LINE__,
                   "%d. throw_proc (%d, ...) not called", i, expect [i]);
 
        try {
            // reestablish original throw proc
            _RW::__rw_throw_proc = pthrow_proc_save;
 
            // expect an exception
            _RW::__rw_throw (expect [i], format, func, empty, empty, empty);
 
            rw_assert (false, 0, __LINE__,
                       "%d. __rw::__rw_throw(%d, ...) returned",
                       i, expect [i]);
        }
        catch (std::domain_error &ex) {
            rw_assert (!!ex.what (),  0, __LINE__,
                       "domain_error::what() != 0");
            caught = _RWSTD_ERROR_DOMAIN_ERROR;
        }
        catch (std::invalid_argument &ex) {
            rw_assert (!!ex.what (),  0, __LINE__,
                       "invalid_argument::what() != 0");
            caught = _RWSTD_ERROR_INVALID_ARGUMENT;
        }
        catch (std::length_error &ex) {
            rw_assert (!!ex.what (),  0, __LINE__,
                       "length_error::what() != 0");
            caught = _RWSTD_ERROR_LENGTH_ERROR;
        }
        catch (std::out_of_range &ex) {
            rw_assert (!!ex.what (),  0, __LINE__,
                       "out_of_range::what() != 0");
            caught = _RWSTD_ERROR_OUT_OF_RANGE;
        }
        catch (std::range_error &ex) {
            rw_assert (!!ex.what (),  0, __LINE__,
                       "range_error::what() != 0");
            caught = _RWSTD_ERROR_RANGE_ERROR;
        }
        catch (std::overflow_error &ex) {
            rw_assert (!!ex.what (),  0, __LINE__,
                       "overflow_error::what() != 0");
            caught = _RWSTD_ERROR_OVERFLOW_ERROR;
        }
        catch (std::underflow_error &ex) {
            rw_assert (!!ex.what (),  0, __LINE__,
                       "underflow_error::what() != 0");
            caught = _RWSTD_ERROR_UNDERFLOW_ERROR;
        }
        catch (std::logic_error &ex) {
            rw_assert (!!ex.what (),  0, __LINE__,
                       "logic_error::what() != 0");
            caught = _RWSTD_ERROR_LOGIC_ERROR;
        }
        catch (std::runtime_error &ex) {
            rw_assert (!!ex.what (),  0, __LINE__,
                       "runtime_error::what() != 0");
            caught = _RWSTD_ERROR_RUNTIME_ERROR;
        }
        catch (std::bad_alloc &ex) {
            rw_assert (!!ex.what (),  0, __LINE__,
                       "bad_alloc::what() != 0");
            caught = _RWSTD_ERROR_FIRST + 3;   // _RWSTD_BAD_ALLOC
        }
        catch (std::bad_exception &ex) {
            rw_assert (!!ex.what (),  0, __LINE__,
                       "bad_exception::what() != 0");
            caught = _RWSTD_ERROR_FIRST + 2;   // _RWSTD_ERROR_BAD_EXCEPTION
        }
        catch (std::bad_cast &ex) {
            rw_assert (!!ex.what (),  0, __LINE__,
                       "bad_cast::what() != 0");
            caught = _RWSTD_ERROR_FIRST + 4;   // _RWSTD_ERROR_BAD_CAST;
        }
 
#ifdef _RWSTD_ERROR_BAD_TYPEID
 
        catch (std::bad_typeid &ex) {
            rw_assert (!!ex.what (),  0, __LINE__,
                       "bad_typeid::what() != 0");
            caught = _RWSTD_ERROR_BAD_TYPEID;
        }
 
#endif   // _RWSTD_ERROR_BAD_TYPEID;
 
#ifndef _RWSTD_NO_EXT_FAILURE
 
        catch (std::ios_base::failbit_set &ex) {
            rw_assert (!!ex.what (),  0, __LINE__,
                       "ios_base::failbit_set::what() != 0");
            caught = _RWSTD_ERROR_FAILBIT_SET;
        }
        catch (std::ios_base::badbit_set &ex) {
            rw_assert (!!ex.what (),  0, __LINE__,
                       "ios_base::badbit_set::what() != 0");
            caught = _RWSTD_ERROR_BADBIT_SET;
        }
        catch (std::ios_base::eofbit_set &ex) {
            rw_assert (!!ex.what (),  0, __LINE__,
                       "ios_base::eofbit_set::what() != 0");
            caught = _RWSTD_ERROR_EOFBIT_SET;
        }
 
#endif   // _RWSTD_NO_EXT_FAILURE
 
        catch (std::ios_base::failure &ex) {
            rw_assert (!!ex.what (),  0, __LINE__,
                       "ios_base::failure::what() != 0");
            caught = _RWSTD_ERROR_IOSTATE_BIT_SET;
        }
        catch (std::exception &ex) {
            rw_assert (!!ex.what (),  0, __LINE__,
                       "exception::what() != 0");
            caught = _RWSTD_ERROR_FIRST + 1;   // _RWSTD_ERROR_EXCEPTION
        }
        catch (...) {
            caught = -1;
        }
 
        rw_assert (expect [i] == caught,  0, __LINE__,
                   "%d. expected %d, caught %d", i, expect [i], caught);
    }
 
 
    // reestablish original throw proc
    _RW::__rw_throw_proc = pthrow_proc_save;
 
    char str    [1024];
    char result [2 * sizeof str];
 
    rw_info (0, 0, __LINE__,
             "exercising throwing standard exception objects "
             "constructed with string arguments up to %zu "
             "characters long (not including context info)",
             sizeof str);
 
    // exercise the ability or __rw_throw() to correctly format
    // strings of arbitrary length, also verify that format string
    // macros are used to format the what() strings as expected
    for (unsigned j = 0; j != sizeof str - 1; ++j) {
 
        // exclude exception, bad_alloc, bad_cast, and bad_exception
        // they are typically generated by the compiler and their
        // what() strings are implementation-specific
        size_t en = j % ((sizeof expect / sizeof *expect) - 5);
 
        // null-terminate str
        str [j] = '\0';
 
        std::sprintf (result, strings [en + 5], __FILE__, str,
                      empty, empty, empty);
        
        try {
            // expect an exception
            _RW::__rw_throw (expect [en + 4], __FILE__, str,
                             empty, empty, empty);
 
            rw_assert (false, 0, __LINE__,
                       "%d. __rw::__rw_throw (%d, ...) returned",
                       j, expect [en + 4]);
        }
        catch (std::exception &e) {
            rw_assert (e.what () && 0 == std::strcmp (e.what (), result),
                       0, __LINE__,
                       "%u. \"%s\" != \"%s\" [%u]",
                       j, e.what (), result, en + 3);
        }
 
        // append a decimal digit
        str [j] = '0' + j % 10;
    }
 
#endif   // _RWSTD_NO_EXCEPTIONS
}
 
 
static void
throwing_unexpected_handler ()
{
    // throw an exception that can't otherwise be possibly thrown
    // to induce std::bad_exception to be rethrown by the langauage
    // runtime library
 
    struct PrivateStruct { };
 
    // prevent assertions from the installed SIGABRT handler
    // and terminate_handler in case they are invoked as a
    // result of throwing the exception below
    expect_terminate = 1;
    expect_abort     = 1;
 
    throw PrivateStruct ();
}
 
 
enum RuntimeExceptionId {
    E_bad_alloc, E_bad_cast, E_bad_exception, E_bad_typeid, E_error
};
 
 
// helper classes used by the bad_cast test
// defined at namespace scope rather than at local scope
// to work around an Intel C++ 10.0 ICE (see STDCXX-475)
struct Base { virtual ~Base () { } };
struct Derived1: Base { };
struct Derived2: Base { };
 
 
// induce the language runtime into throwing an exception
// returns e if exception cannot bee thrown
static RuntimeExceptionId
induce_exception (RuntimeExceptionId reid, const char *name)
{
    const char *why = 0;
 
    switch (reid) {
 
    case E_bad_alloc: {   
 
#ifndef _RWSTD_NO_NEW_THROWS
 
#  ifndef _RWSTD_NO_SETRLIMIT
 
#    if !defined (__HP_aCC)
 
        // work around an HP aCC 5.xx (IPF) bug (PR #29014)
 
        // retrieve the current resource limits
        struct rlimit rl = { 0, 0 };
        if (getrlimit (RLIMIT_DATA, &rl))
            return E_error;
 
        // set the soft limit, leave hard limit unchanged
        rl.rlim_cur = 0;
        rw_warn (0 == setrlimit (RLIMIT_DATA, &rl), 0, __LINE__,
                 "setrlimit (RLIMIT_DATA, ...) failed: %m");
 
        try {
 
#    endif   // __HP_aCC
#  endif   // _RWSTD_NO_SETRLIMIT
 
            // try to allocate a huge amount of memory to induce bad_alloc
            const std::size_t huge_amount = _RWSTD_SIZE_MAX - 4096;
 
            void * const p = ::operator new (huge_amount);
 
            ::operator delete (p);
 
#  ifndef _RWSTD_NO_SETRLIMIT
#    if !defined (__HP_aCC)
 
        }
        catch (...) {
 
            // reset the soft limit back to the value of the hard limit
            rl.rlim_cur = rl.rlim_max;
            rw_warn (0 == setrlimit (RLIMIT_DATA, &rl), 0, __LINE__,
                     "setrlimit (RLIMIT_DATA, ...) failed: %m");
 
            // rethrow bad_alloc
            throw;
        }
 
#    endif   // __HP_aCC
 
        return E_error;
 
#  endif   // _RWSTD_NO_SETRLIMIT
 
#else   // if defined (_RWSTD_NO_NEW_THROWS)
 
        why = "_RWSTD_NO_NEW_THROWS is #defined";
 
        break;   // unable to induce bad_alloc
 
#endif   // NO_NEW_THROWS
 
    }
 
    case E_bad_cast: {   
 
#ifndef _RWSTD_NO_DYNAMIC_CAST
 
        Derived1 b;
        Base &a = b;
 
        // induce bad_cast
        dynamic_cast<Derived2&>(a);
 
        return E_error;
 
#else   // if defined (_RWSTD_NO_DYNAMIC_CAST)
 
        why = "_RWSTD_NO_DYNAMIC_CAST is #defined";
 
        break;   // unable to induce bad_cast
 
#endif   // _RWSTD_NO_DYNAMIC_CAST
    }
 
    case E_bad_exception: {   
 
#ifndef _RWSTD_NO_EXCEPTION_SPECIFICATION
 
        std::set_unexpected (throwing_unexpected_handler);
 
        struct S {
            // induce bad_exception
            S () throw (std::bad_exception) { throw 0; }
        } s;
 
        _RWSTD_UNUSED (s);
        return E_error;
 
#else   // if defined (_RWSTD_NO_EXCEPTION_SPECIFICATION)
 
        why = "_RWSTD_NO_EXCEPTION_SPECIFICATION is #defined";
 
        break;   // unable to induce bad_exception
 
#endif   // _RWSTD_NO_EXCEPTION_SPECIFICATION
 
    }
 
    case E_bad_typeid: {   
 
#if    !defined (_RWSTD_NO_GLOBAL_BAD_TYPEID) \
    || !defined (_RWSTD_NO_STD_BAD_TYPEID)
 
        struct S { virtual ~S () { } } *s = 0;
 
        // induce bad_typeid
        typeid (*s);
 
        return E_error;
 
#else   // if _RWSTD_NO_GLOBAL_BAD_TYPEID && _RWSTD_NO_STD_BAD_TYPEID
 
        why = "both _RWSTD_NO_GLOBAL_BAD_TYPEID and _RWSTD_NO_STD_BAD_TYPEID "
            "are #defined";
 
        break;   // unable to induce bad_typeid
 
#endif   // NO_BAD_TYPEID
 
    }
 
    default:
        break;
    }
 
    rw_warn (0, 0, __LINE__, "unable to induce std::%s: %s\n", name, why);
 
    return reid;
}
 
 
static const RuntimeExceptionId
rt_exceptions[] = {
    E_bad_alloc, E_bad_cast, E_bad_exception, E_bad_typeid,
    E_error
};
 
static const char* const
rt_exception_names[] = {
    "bad_alloc", "bad_cast", "bad_exception", "bad_typeid"
};
 
static int
opt_rt_exception [E_error];
 
 
static void
test_runtime ()
{
#ifndef _RWSTD_NO_EXCEPTIONS
 
    rw_info (0, 0, __LINE__, "runtime support for exceptions");
 
 
    // using static to avoid gcc 3.x warning: variable 
    // might be clobbered by `longjmp' or `vfork'
 
    for (static unsigned i = 0; E_error != rt_exceptions [i]; ++i) {
 
        const RuntimeExceptionId ex_id   = rt_exceptions [i];
        const char* const        ex_name = rt_exception_names [i];
 
        if (0 == rw_note (0 <= opt_rt_exception [i],
                          0, __LINE__,
                          "std::%s test disabled", ex_name))
            continue;
 
        rw_info (0, 0, __LINE__, "std::%s", ex_name);
 
        static int ex0;
        static int ex1;
 
        ex0 = ex1 = 0;
 
        try {
            try {
                // jump back here if the induced exception causes
                // a call to terminate() and/or raises SIGABRT
                if (0 == RW_SETJMP (jmpenv)) {
 
                    // try to induce the standard exception
                    if (ex_id == induce_exception (ex_id, ex_name)) {
                        ex0 = -1;
                        ex1 = -1;
                    }
                }
                else {
                    rw_assert (false, 0, __LINE__,
                               "inducing std::%s caused a call "
                               "to std::terminate()", ex_name);
                    // prevent additional assertions
                    ex0 = -1;
                }
            }
            catch (std::exception&) {
                // so far so good, rethrow and try to catch again
                ex0 = 0;
                throw;
            }
            catch (...) {
                // failure to catch a standard exception using std::exception
                // most likely indication of class exception having been
                // defined in a different namespace by the C++ Standard
                // library than by the language support library (compiler
                // runtime)
                ex0 = -2;
                throw;
            }
        }
        catch (std::bad_alloc&)     { ex1 = E_bad_alloc; }
        catch (std::bad_cast&)      { ex1 = E_bad_cast;  }
        catch (std::bad_exception&) { ex1 = E_bad_exception; }
        catch (std::bad_typeid&)    { ex1 = E_bad_typeid; }
        catch (...)                 { ex1 = -2; }
 
        rw_assert (-1 == ex0 || 0 == ex0, 0, __LINE__,
                   "std::%s thrown, std::exception not caught",
                   ex_name);
 
        rw_assert (-1 == ex1 || rt_exceptions [i] == ex1, 0, __LINE__,
                   "std::%s thrown, unknown exception caught",
                   ex_name);
    }
 
#endif   // _RWSTD_NO_EXCEPTIONS
}
 
 
static int opt_synopsis;     // for --<toggle>-synopis
static int opt_signatures;   // for --<toggle>-signatures
static int opt_uncaught;     // for --<toggle>-uncaught_exception
static int opt_effects;      // for --<toggle>-effects
static int opt_rw_throw;     // for --<toggle>-rw_throw
static int opt_runtime;      // for --<toggle>-runtime
 
static int
run_test (int, char**)
{
    if (rw_note (0 <= opt_synopsis, 0, __LINE__,
                 "test of <exception> synopsis disabled"))
        test_synopsis ();
 
    // check the signatures of class exception and bad_exception members
    if (rw_note (0 <= opt_signatures, 0, __LINE__,
                 "test of function signatures disabled"))
        test_signatures ();
 
    // exercise std::uncaught_exception() before running any other tests
    // since some of them might affect the correct behavior of the function
    // (if they violate such constraints as returning from a call to
    // std::terminate())
    if (rw_note (0 <= opt_uncaught, 0, __LINE__,
                 "test of uncaught_exception() disabled"))
        test_uncaught_exception ();
 
    // exercise __rw::__rw_throw() and __rw::__rw_throw_proc()
    if (rw_note (0 <= opt_rw_throw, 0, __LINE__,
                 "test of __rw_throw() disabled"))
        test_rw_throw ();
 
    // exercise the cooperation between the C++ standard library and
    // the runtime support library when throwing standard exceptions
    if (rw_note (0 <= opt_runtime, 0, __LINE__,
                 "test of runtime support disabled"))
        test_runtime ();
 
    // exercise the effects last to defer potential problems
    // due to the tests returning (jumping) out of the handlers
    if (rw_note (0 <= opt_effects, 0, __LINE__,
                 "test of effects disabled")) {
        // test the effects of 18.6
        if (0 == RW_SETJMP (jmpenv)) {
            test_effects ();
        }
 
        // verify that test worked as expected (each handler sets
        // its own expect_xxx variable to -1 after it's been called)
        rw_error (-1 == expect_abort, 0, __LINE__,
              "abort() was called unexpectedly");
 
        rw_error (-1 == expect_terminate, 0, __LINE__,
                  "terminate() was called unexpectedly");
 
        rw_error (-1 == expect_unexpected, 0, __LINE__,
                  "unexpected() was called unexpectedly");
    }
 
    return 0;
}
 
 
int main (int argc, char *argv[])
{
    return rw_test (argc, argv, __FILE__,
                    "lib.support.exception",
                    0 /* no comment */,
                    run_test,
                    "|-synopsis~ "
                    "|-signatures~ "
                    "|-uncaught_exception~ "
                    "|-effects~ "
                    "|-rw_throw~ "
                    "|-runtime~ "
                    "|-bad_alloc~ "
                    "|-bad_cast~ "
                    "|-bad_exception~ "
                    "|-bad_typeid~",
                    &opt_synopsis,
                    &opt_signatures,
                    &opt_uncaught,
                    &opt_effects,
                    &opt_rw_throw,
                    &opt_runtime,
                    opt_rt_exception + E_bad_alloc,
                    opt_rt_exception + E_bad_cast,
                    opt_rt_exception + E_bad_exception,
                    opt_rt_exception + E_bad_typeid,
                    0 /* sentinel */);
}