stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From vi...@apache.org
Subject svn commit: r645750 - in /stdcxx/trunk/tests: diagnostics/19.std.exceptions.cpp support/18.support.dynamic.cpp support/18.support.rtti.cpp
Date Tue, 08 Apr 2008 01:05:15 GMT
Author: vitek
Date: Mon Apr  7 18:05:14 2008
New Revision: 645750

URL: http://svn.apache.org/viewvc?rev=645750&view=rev
Log:

2008-04-07  Travis Vitek  <vitek@roguewave.com>

	* tests/support/18.support.dynamic.cpp: New test exercising
	functions and types for dynamic storage management.
	* tests/support/18.support.rtti.cpp: New test exercising
	types for dynamic type information support.
	* tests/diagnostics/19.std.exceptions.cpp: New test exercising
	standard exception types.

Added:
    stdcxx/trunk/tests/diagnostics/19.std.exceptions.cpp   (with props)
    stdcxx/trunk/tests/support/18.support.dynamic.cpp   (with props)
    stdcxx/trunk/tests/support/18.support.rtti.cpp   (with props)

Added: stdcxx/trunk/tests/diagnostics/19.std.exceptions.cpp
URL: http://svn.apache.org/viewvc/stdcxx/trunk/tests/diagnostics/19.std.exceptions.cpp?rev=645750&view=auto
==============================================================================
--- stdcxx/trunk/tests/diagnostics/19.std.exceptions.cpp (added)
+++ stdcxx/trunk/tests/diagnostics/19.std.exceptions.cpp Mon Apr  7 18:05:14 2008
@@ -0,0 +1,458 @@
+/***************************************************************************
+ *
+ * 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;
+
+        rw_assert (false, 0, __LINE__,
+                   "replacement ::operator new(std::size_t = %u) failed "
+                   "to throw when called directly from a program",
+                   sizeof long_str);
+    }
+    _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);
+}

Propchange: stdcxx/trunk/tests/diagnostics/19.std.exceptions.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: stdcxx/trunk/tests/diagnostics/19.std.exceptions.cpp
------------------------------------------------------------------------------
    svn:keywords = Id

Added: stdcxx/trunk/tests/support/18.support.dynamic.cpp
URL: http://svn.apache.org/viewvc/stdcxx/trunk/tests/support/18.support.dynamic.cpp?rev=645750&view=auto
==============================================================================
--- stdcxx/trunk/tests/support/18.support.dynamic.cpp (added)
+++ stdcxx/trunk/tests/support/18.support.dynamic.cpp Mon Apr  7 18:05:14 2008
@@ -0,0 +1,478 @@
+/***************************************************************************
+ *
+ * 18.support.dynamic.cpp - test exercising [lib.support.dynamic]
+ *
+ * $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 <new>
+#include <memory>
+#include <driver.h>
+
+#include <rw/_defs.h>
+#include <rw/_error.h>
+
+#include <cstdlib>   // for malloc() and free()
+#include <cstring>   // for strlen()
+
+
+#ifdef _MSC_VER
+   // verify that <new> et al can coexist with MSVC's <new.h>
+#  include <new.h>
+#endif
+
+/**************************************************************************/
+
+// detects recursive implementation of operator new (size_t, nothrow_t)
+static int recursive_new_nothrow = 0;
+static int recursive_delete_nothrow = 0;
+
+// MemoryAllocator is used to replace the global new and delete
+// in order to test conformance of of the other operators that
+// might be defined in <new>
+
+struct MemoryAllocator
+{
+    MemoryAllocator () {
+        init ();
+    }
+
+    void* operatorNew (std::size_t n) _THROWS ((std::bad_alloc)) {
+        _allocPtr = 0;
+        _newCalled = true;
+        _bytesRequested = n;
+        if (_failAlloc) {
+            _failAlloc = false;
+            _THROW (std::bad_alloc ());
+        }
+#if !defined (_RWSTD_NO_EXT_OPERATOR_NEW) && \
+     defined (_RWSTD_NO_OPERATOR_NEW_NOTHROW)
+
+        // test our implementation of
+        // ::operator new(size_t, const std::nothrow)
+        // this operator must not be implemented in terms
+        // of ::operator new(size_t) to prevent recursion
+
+        if (recursive_new_nothrow++)
+            _allocPtr = std::malloc (_bytesRequested);
+        else
+            _allocPtr = ::operator new (_bytesRequested, std::nothrow);
+
+        --recursive_new_nothrow;
+
+#else
+        _allocPtr = std::malloc (_bytesRequested);
+#endif
+        return _allocPtr;
+    }
+
+    void operatorDelete (void* ptr) _THROWS (()) {
+        _deallocPtr = ptr;
+#if !defined (_RWSTD_NO_EXT_OPERATOR_NEW) && \
+     defined (_RWSTD_NO_OPERATOR_NEW_NOTHROW)
+        // memory allocated by our nothrow operator new()
+        if (recursive_delete_nothrow++ || recursive_new_nothrow)
+            std::free (ptr);
+        else
+            ::operator delete (ptr, std::nothrow);
+
+        --recursive_delete_nothrow;
+#else
+        std::free (ptr);
+#endif
+        _deleteCalled = true;
+    }
+
+    void init () {
+        _newCalled = _deleteCalled = _failAlloc = false;
+        _bytesRequested = 0;
+        _deallocPtr = _allocPtr = 0;
+    }
+
+    bool newCalled () {
+        bool tmp = _newCalled;
+        _newCalled = 0;
+        return tmp;
+    }
+
+    bool deleteCalled () {
+        bool tmp = _deleteCalled;
+        _deleteCalled = 0;
+        return tmp;
+    }
+
+    std::size_t  _bytesRequested;
+    bool              _newCalled;
+    bool              _deleteCalled;
+    bool              _failAlloc;
+    void*             _allocPtr;
+    void*             _deallocPtr;
+};
+
+
+// static instance of memory allocator
+static MemoryAllocator alloc;
+
+/**************************************************************************/
+
+
+// replace the global operators with MemoryAllocator versions
+void* operator new (std::size_t size) _THROWS ((std::bad_alloc))
+{
+    return alloc.operatorNew (size);
+}
+
+void operator delete (void* p) _THROWS (())
+{
+    alloc.operatorDelete (p);
+}
+
+/**************************************************************************/
+
+
+#define TEST_OP_THROWS(expr,cond,tag)                \
+    _TRY {                                           \
+        alloc._failAlloc = true;                     \
+        expr;                                        \
+        rw_assert (cond, 0, __LINE__, tag);          \
+    }                                                \
+    _CATCH (std::bad_alloc) {                        \
+        RW_ASSERT (!cond, 0, __LINE__, tag);         \
+    }                                                \
+    _CATCH (...) {                                   \
+        rw_assert (!cond, 0, __LINE__, tag);         \
+    }                                                \
+    (void)0
+
+/**************************************************************************/
+
+
+// provide a handler for unexpected exceptions so that at least the
+//  test will log the event rather than just aborting
+void my_unexpected_handler ()
+{
+    rw_assert (false, 0, __LINE__, "caught an unexpected exception\n");
+}
+
+// used in exists_set_new_handler below
+void my_new_handler ()
+{
+}
+
+//  grab default throw procedure
+void (*default_throw_proc)(int, char*) = _RW::__rw_throw_proc;
+
+bool my_throw_proc_called = false;
+
+// my_throw_proc just sets a global flag to indicate
+// that it was called, and then dispatches the call
+// to the default throw procedure
+static void my_throw_proc (int id, char* what)
+{
+    my_throw_proc_called = true;
+    default_throw_proc (id, what);
+}
+
+/**************************************************************************/
+
+
+static
+int run_test (int, char* [])
+{
+    std::set_unexpected (&my_unexpected_handler);
+
+    if (1) {
+        // exists_std_nothrow
+        const std::nothrow_t* p = &std::nothrow;
+        rw_assert (p != 0, 0, __LINE__, "std::nothrow defined");
+    }
+
+    if (1) {
+        // exists_bad_alloc
+        std::bad_alloc ba1;         // default ctor
+        std::bad_alloc ba2 = ba1;   // copy ctor
+
+        std::exception* e = &ba1;   // derived from exception
+        (void) &e;
+        ba1 = ba2;                  // assignment operator
+
+        // verify that a member function is accessible and has the
+        // appropriate signature, including return type and exception
+        // specification
+
+        std::bad_alloc& (std::bad_alloc::*p_op_assign)
+                (const std::bad_alloc&) _PTR_THROWS (())
+            = &std::bad_alloc::operator=;
+        _RWSTD_UNUSED (p_op_assign);
+
+        const char*
+        (std::bad_alloc::*p_what_fn)() const _PTR_THROWS (())
+             = &std::bad_alloc::what;
+        _RWSTD_UNUSED (p_what_fn);
+
+        const char* s = ba1.what ();
+        rw_assert (s && 0 != std::strlen (s), 0, __LINE__,
+                   "std::bad_alloc::what() returned bad string");
+    }
+
+    if (1) {
+        // set_new_handler
+        typedef void (*new_handler_t) ();
+
+        new_handler_t (*f) (new_handler_t) _PTR_THROWS (());
+        f = &std::set_new_handler;
+
+        rw_assert (f != 0, 0, __LINE__,
+                   "std::set_new_handler() defined");
+
+        new_handler_t original_handler
+            = std::set_new_handler (my_new_handler);
+
+#if !defined (__EDG__) || __EDG_VERSION__ > 245 || defined (__DECCXX)
+
+        // EDG eccp 2.45 standalone demo is known to fail
+        rw_assert (original_handler == 0, 0, __LINE__,
+                   "std::set_new_handler() unexpectedly returned "
+                   "installed handler");
+
+#define _RWSTD_NO_EXT_OPERATOR_NEW
+
+#endif   // !__EDG__ || __EDG_VERSION__ > 245 || __DECCXX
+
+        new_handler_t replacement_handler
+            = std::set_new_handler (original_handler);
+        rw_assert (my_new_handler == replacement_handler, 0, __LINE__,
+                   "std::set_new_handler() failed to return previously "
+                   "installed handler");
+    }
+
+    // test all operators that we have provided definitions for
+    // in <new>; exercises the operators by setting the
+    // replacement allocator to fail, and asserting that an
+    // exception is thrown or not as appropriate for the operator
+    if (1) {
+        // operator new throws
+        void* ptr = 0;
+        _RWSTD_UNUSED (ptr);
+
+        alloc.init ();      // reset the allocator
+
+#ifdef _RWSTD_NO_OPERATOR_NEW_NOTHROW
+
+        // verify that the nothrow version of operator new provided
+        // by our library doesn't call the ordinary operator new
+        // (if it did it would cause recursion if a replacement operator
+        // new were to be implemented in terms of the nothrow version)
+
+        // also verify that it returns 0 on failure
+
+        // force a failure by requesting too large a block of storage
+        // size_t (~0) alone isn't good enough since it causes annoying
+        // dialog boxes to be popped up by the MSVCRTD, the MSVC runtime
+        TEST_OP_THROWS ((ptr = operator new (~0U - 4096U, std::nothrow)),
+                        (ptr == 0),
+                        "operator new(size_t, nothrow_t) returns 0");
+
+        rw_assert (!alloc.newCalled (), 0, __LINE__,
+                   "operator new called by operator new(size_t, nothrow)");
+
+#endif // defined _RWSTD_NO_OPERATOR_NEW_NOTHROW
+
+#if defined (_RWSTD_NO_OPERATOR_DELETE_NOTHROW) && \
+   !defined (_RWSTD_NO_PLACEMENT_DELETE)
+
+        // verify that the nothrow version of operator delete provided
+        // by our library prevents exceptions from propagating
+        TEST_OP_THROWS ((operator delete (0, std::nothrow)), true,
+                        "operator delete(void*, nothrow_t) doesn't throw");
+
+        // verify that the nothrow version of operator delete provided
+        // by our library doesn't call the ordinary operator delete
+        // (if it did it might cause recursion if a replacement operator
+        // delete were to be implemented in terms of the nothrow version)
+        rw_assert (!alloc.deleteCalled (), 0, __LINE__,
+                   "operator delete(void*) called by "
+                   "operator delete(void*, nothrow_t)");
+
+#endif   // _RWSTD_NO_OPERATOR_DELETE_NOTHROW && _RWSTD_NO_PLACEMENT_DELETE
+
+#ifdef _RWSTD_NO_OPERATOR_NEW_ARRAY
+
+        // verify that the array form of operator new throws bad_alloc on
+        // failure
+        TEST_OP_THROWS ((operator new[] (1)), false,
+                        "operator new[] (size_t) throws bad_alloc");
+
+        // verify that the array form of operator new provided by our
+        // library calls the ordinary operator new
+        rw_assert (alloc.newCalled (), 0, __LINE__,
+                   "operator new called by operator new[](size_t)");
+
+#endif // defined _RWSTD_NO_OPERATOR_NEW_ARRAY
+
+#ifdef _RWSTD_NO_OPERATOR_NEW_ARRAY_NOTHROW
+
+        TEST_OP_THROWS ((ptr = operator new[](1, std::nothrow)),
+                        (ptr == 0),
+                        "operator new[] (size_t, nothrow_t) returns 0");
+
+        rw_assert (alloc.newCalled (), 0, __LINE__,
+                   "operator new(size_t) called by "
+                   "operator new[](size_t, nothrow_t)");
+
+#endif // defined _RWSTD_NO_OPERATOR_NEW_ARRAY_NOTHROW
+
+#ifdef _RWSTD_NO_OPERATOR_DELETE_ARRAY
+
+        TEST_OP_THROWS ((operator delete[] (0)), true,
+                        "operator delete[] (void*) doesn't throw");
+
+        rw_assert (alloc.deleteCalled (), 0, __LINE__,
+                   "operator delete called by operator delete[](void*)");
+
+#endif // defined _RWSTD_NO_OPERATOR_DELETE_ARRAY
+
+#if defined (_RWSTD_NO_OPERATOR_DELETE_ARRAY_NOTHROW) && \
+   !defined ( _RWSTD_NO_PLACEMENT_DELETE)
+
+        TEST_OP_THROWS ((operator delete[] (0, std::nothrow)), true,
+                        "operator delete[] (void*, nothrow_t) doesn't "
+                        "throw");
+
+        rw_assert (alloc.deleteCalled (), 0, __LINE__,
+                   "operator delete(void*) called by "
+                   "operator delete[](void*, nothrow_t)");
+
+#endif // _RWSTD_NO_OPERATOR_DELETE_ARRAY_NOTHROW &&
+        // !_RWSTD_NO_PLACEMENT_DELETE
+
+        // verify that the nothrow form of operator new provided by our
+        // library isn't recursively implemented in terms of the ordinary
+        // operator new
+        rw_assert (0 == recursive_new_nothrow, 0, __LINE__,
+                   "operator new (size_t, nothrow_t) causes recursion");
+
+        rw_assert (0 == recursive_delete_nothrow, 0, __LINE__,
+                   "operator delete (void*, nothrow_t) causes recursion");
+    }
+
+    // __rw_allocate() is like ::operator new() except that it calls
+    // __rw_throw() on failure (which may throw std::bad_alloc).
+    //  This test checks that __rw_throw() is called,
+    //  that it properly calls __rw_throw_proc(), and that bad_alloc
+    //  is thrown. We'll use the replaced ::operator new() to
+    //  control when a memory allocation request will fail.
+
+#ifndef _RWSTD_NO_REPLACEABLE_NEW_DELETE
+
+    const bool test_rw_allocate = true;
+
+#else   // if defined (_RWSTD_NO_REPLACEABLE_NEW_DELETE)
+
+    // avoid tests that depend on the replacement operators new
+    // and delete on platforms like AIX or Win32 where they cannot
+    // be reliably replaced
+    const bool test_rw_allocate = false;
+
+#endif   // _RWSTD_NO_REPLACEABLE_NEW_DELETE
+
+    if (test_rw_allocate) {
+
+        alloc.init ();      // reset the allocator
+
+        _RW::__rw_throw_proc = my_throw_proc; // set the throw func
+        my_throw_proc_called = false;
+
+        for (std::size_t i = 0; i < 10; ++i) {
+
+            char* ptr = 0;
+
+            const bool doFail = !!(i % 2);    // prevent MSVC warning 4800
+            if (doFail)
+                alloc._failAlloc = true;
+
+            try {
+                // allocation
+                alloc._bytesRequested = ~i;   // reset
+
+                ptr = _RWSTD_STATIC_CAST (char*, _RW::__rw_allocate (i));
+                rw_assert (alloc._bytesRequested == i, 0, __LINE__,
+                           "__rw_allocate (%u) requested %u bytes",
+                           i, alloc._bytesRequested);
+
+                rw_assert (alloc.newCalled (), 0, __LINE__,
+                           "operator new() called");
+                rw_assert (!doFail,  0, __LINE__,
+                           "allocation succeeded");
+                rw_assert (my_throw_proc_called == false,
+                           0, __LINE__,
+                           "my_throw_proc called");
+
+                // deallocation
+                _RW::__rw_deallocate (ptr, i);
+
+                rw_assert (alloc.deleteCalled (),
+                           0, __LINE__,
+                           "operator delete() called");
+                rw_assert (alloc._deallocPtr == ptr,
+                           0, __LINE__,
+                           "allocated memory deallocated");
+
+            }
+            catch (std::bad_alloc) {
+                rw_assert (doFail, 0, __LINE__,
+                           "expected bad_alloc exception");
+
+                rw_assert (my_throw_proc_called == true, 0, __LINE__,
+                           "my_throw_proc called");
+            }
+            catch (...) {
+                rw_assert (false, 0, __LINE__,
+                           "expected std::bad_alloc exception");
+            }
+
+            my_throw_proc_called = false;
+        }
+    }
+    else {
+        rw_warn (false, 0, __LINE__,
+                 "__rw::__rw_allocate() not exercised: "
+                 "_RWSTD_NO_REPLACEABLE_NEW_DELETE #defined");
+    }
+
+    return 0;
+}
+
+/**************************************************************************/
+
+
+int main (int argc, char* argv [])
+{
+    return rw_test (argc, argv, __FILE__,
+                    "lib.support.dynamic",
+                    0 /* no comment */,
+                    run_test,
+                    "",
+                    (void*)0);
+}

Propchange: stdcxx/trunk/tests/support/18.support.dynamic.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: stdcxx/trunk/tests/support/18.support.dynamic.cpp
------------------------------------------------------------------------------
    svn:keywords = Id

Added: stdcxx/trunk/tests/support/18.support.rtti.cpp
URL: http://svn.apache.org/viewvc/stdcxx/trunk/tests/support/18.support.rtti.cpp?rev=645750&view=auto
==============================================================================
--- stdcxx/trunk/tests/support/18.support.rtti.cpp (added)
+++ stdcxx/trunk/tests/support/18.support.rtti.cpp Mon Apr  7 18:05:14 2008
@@ -0,0 +1,439 @@
+/***************************************************************************
+ *
+ * 18.support.rtti.cpp - test exercising 18.5 [lib.support.rtti]
+ *
+ * $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 <rw/_defs.h> 
+#if defined (__IBMCPP__) && !defined (_RWSTD_NO_IMPLICIT_INCLUSION)
+// Disable implicit inclusion to work around 
+// a limitation in IBM's VisualAge 5.0.2.0 (see PR#26959) 
+
+#  define _RWSTD_NO_IMPLICIT_INCLUSION 
+#endif 
+
+/**************************************************************************/
+
+
+// verifies that typeid is correctly declared for MSVC (see PR #25603)
+void foo ()
+{
+    _THROW (0);   // must appear before #include <typeinfo>
+}
+
+/**************************************************************************/
+
+
+#include <typeinfo>
+#include <driver.h>
+#include <valcmp.h>
+
+// polymorphic classes (10.3, p1) used in tests below
+struct B { virtual ~B () { } };
+struct D1: B { };
+struct D2: B { };
+
+/**************************************************************************/
+
+static int
+run_test (int, char* [])
+{
+    if (1) {
+        // exercise 18.5, the synopsis of <typeinfo>
+
+        std::type_info  *ti = 0;
+        std::bad_cast   *bc = 0;
+        std::bad_typeid *bt = 0;
+
+        _RWSTD_UNUSED (ti);
+        _RWSTD_UNUSED (bc);
+        _RWSTD_UNUSED (bt);
+    }
+
+    if (1) {
+        // exercise 18.5.1, class type_info interface
+
+        // 18.5.1, p2
+        bool (std::type_info::*p_op_eq)(const std::type_info&) const =
+            &std::type_info::operator==;
+
+        // 18.5.1, p3
+        bool (std::type_info::*p_op_neq)(const std::type_info&) const =
+            &std::type_info::operator!=;
+
+        // 18.5.1, p5
+        bool (std::type_info::*p_before)(const std::type_info&) const =
+            &std::type_info::before;
+
+        // 18.5.1, p7
+        const char* (std::type_info::*p_name)() const = &std::type_info::name;
+
+        _RWSTD_UNUSED (p_op_eq);
+        _RWSTD_UNUSED (p_op_neq);
+        _RWSTD_UNUSED (p_before);
+        _RWSTD_UNUSED (p_name);
+    }
+
+    if (1) {
+        // exercise 18.5.1, class type_info functionality
+        D1 d1;
+        D2 d2;
+
+        const std::type_info &ti_D1 = typeid (D1);
+        const std::type_info &ti_D2 = typeid (D2);
+
+        const std::type_info &ti_d1 = typeid (d1);
+        const std::type_info &ti_d2 = typeid (d2);
+
+
+        const char *D1_name = ti_D1.name () ? ti_D1.name () : "(D1 null)";
+        const char *D2_name = ti_D2.name () ? ti_D2.name () : "(D2 null)";
+        const char *d1_name = ti_d1.name () ? ti_d1.name () : "(d1 null)";
+        const char *d2_name = ti_d2.name () ? ti_d2.name () : "(d2 null)";
+
+        // 18.5.1, p2
+        rw_assert (ti_D1 == ti_D1, 0, __LINE__,
+                   "std::type_info::operator==(): \"%s\" != \"%s\"",
+                   D1_name, D1_name);
+        rw_assert (ti_D1 == ti_d1, 0, __LINE__,
+                   "std::type_info::operator==(): \"%s\" != \"%s\"",
+                   D1_name, d1_name);
+        rw_assert (!(ti_D1 == ti_D2), 0, __LINE__,
+                   "std::type_info::operator==(): \"%s\" == \"%s\"",
+                   D1_name, D2_name);
+        rw_assert (ti_d1 == ti_d1, 0, __LINE__,
+                   "std::type_info::operator==(): \"%s\" != \"%s\"",
+                   d1_name, d1_name);
+        rw_assert (ti_d1 == ti_D1, 0, __LINE__,
+                   "std::type_info::operator==(): \"%s\" != \"%s\"",
+                   d1_name, D1_name);
+        rw_assert (!(ti_d1 == ti_d2), 0, __LINE__,
+                   "std::type_info::operator==(): \"%s\" == \"%s\"",
+                   d1_name, d2_name);
+
+        // 18.5.1, p3
+        rw_assert (ti_D1 != ti_D2, 0, __LINE__,
+                   "std::type_info::operator!=(): \"%s\" == \"%s\"",
+                   D1_name, D2_name);
+        rw_assert (ti_D1 != ti_d2, 0, __LINE__,
+                   "std::type_info::operator!=(): \"%s\" == \"%s\"",
+                   D1_name, d2_name);
+        rw_assert (!(ti_D1 != ti_D1), 0, __LINE__,
+                   "std::type_info::operator!=(): \"%s\" != \"%s\"",
+                   D1_name, D1_name);
+        rw_assert (ti_d1 != ti_d2, 0, __LINE__,
+                   "std::type_info::operator!=(): \"%s\" == \"%s\"",
+                   d1_name, d2_name);
+        rw_assert (ti_d1 != ti_D2, 0, __LINE__,
+                   "std::type_info::operator!=(): \"%s\" == \"%s\"",
+                   d1_name, D2_name);
+        rw_assert (!(ti_d1 != ti_d1), 0, __LINE__,
+                   "std::type_info::operator!=(): \"%s\" != \"%s\"",
+                   d1_name, d1_name);
+
+        // 18.5.1, p5
+        rw_assert (!ti_D1.before (ti_D1) && !ti_D2.before (ti_D2),
+                   0, __LINE__, "std::type_info::before ()");
+        rw_assert (ti_D1.before (ti_D2) || ti_D2.before (ti_D1),
+                   0, __LINE__, "std::type_info::before ()");
+        rw_assert (ti_d1.before (ti_d2) || ti_d2.before (ti_d1),
+                   0, __LINE__, "std::type_info::before ()");
+        rw_assert (!ti_d1.before (ti_d1) && !ti_d2.before (ti_d2),
+                   0, __LINE__, "std::type_info::before ()");
+
+        // 18.5.1, p7
+        rw_assert (0 == rw_strncmp (D1_name, d1_name), 0, __LINE__,
+                   "std::type_info::name (): \"%s\" != \"%s\"",
+                   D1_name, d1_name);
+        rw_assert (0 != rw_strncmp (D1_name, D2_name), 0, __LINE__,
+                   "std::type_info::name (): \"%s\" == \"%s\"",
+                   D1_name, D2_name);
+        rw_assert (0 == rw_strncmp (D2_name, d2_name), 0, __LINE__,
+                   "std::type_info::name (): \"%s\" != \"%s\"",
+                   D2_name, d2_name);
+        rw_assert (0 != rw_strncmp (d1_name, d2_name), 0, __LINE__,
+                   "std::type_info::name (): \"%s\" == \"%s\"",
+                   d1_name, d2_name);
+    }
+
+    if (1) {
+        // exercise 18.5.2, class bad_cast interface
+
+        // std::bad_cast must publicly derive from std::exception
+        const std::bad_cast  *pbc = 0;
+        const std::exception *pe  = pbc;
+
+        // 18.5.2, p2
+        std::bad_cast bc;
+
+        // 18.5.2, p4 - copy ctor
+        std::bad_cast bc2 (bc);
+
+        // 18.5.2, p4 - assignment
+        std::bad_cast& (std::bad_cast::*p_op_assign)(const std::bad_cast&) 
+            _PTR_THROWS (()) = &std::bad_cast::operator=;
+
+        // 18.5.2, p5
+        const char* (std::bad_cast::*p_what)() const _PTR_THROWS (()) =
+            &std::bad_cast::what;
+
+        _RWSTD_UNUSED (pbc);
+        _RWSTD_UNUSED (pe);
+        _RWSTD_UNUSED (bc);
+        _RWSTD_UNUSED (bc2);
+        _RWSTD_UNUSED (p_op_assign);
+        _RWSTD_UNUSED (p_what);
+    }
+
+    if (1) {
+        // exercise 18.5.2, class bad_cast functionality
+
+#ifndef _RWSTD_NO_EXCEPTIONS
+#  ifndef _RWSTD_NO_DYNAMIC_CAST
+
+        const char *caught = "no exception";
+
+        D1 d1;
+        B &b = d1;
+
+        try {
+            D2 &d2 = dynamic_cast<D2&>(b);
+
+            _RWSTD_UNUSED (d2);
+        }
+        catch (const std::bad_cast &bc) {
+            caught = "std::bad_cast";
+
+            // 18.5.2, p2
+            std::bad_cast bc2;
+
+            // 18.5.2, p4 - copy ctor
+            std::bad_cast bc3 (bc);
+
+            const char* const bc_what  = bc.what ();
+            const char*       bc2_what = bc2.what ();
+            const char* const bc3_what = bc3.what ();
+
+            if (0 == bc2_what)
+                rw_assert (false, 0, __LINE__, "bad_cast().what() != 0");
+
+            if (0 == bc3_what)
+                rw_assert (false, 0, __LINE__,
+                           "bad_cast::what() != 0 failed "
+                           "for a copy of a caught exception object");
+
+            if (bc2_what && bc3_what)
+                rw_warn (0 == rw_strncmp (bc2_what, bc3_what),
+                         0, __LINE__,
+                         "bad_cast::bad_cast (const bad_cast&): "
+                         "\"%s\" != \"%s\"", bc_what, bc3_what);
+
+            // 18.5.2, p4 - assignment
+            bc2 = bc;
+
+            bc2_what = bc2.what ();
+
+            if (0 == bc_what)
+                rw_assert (false, 0, __LINE__,
+                           "bad_cast::what() != 0 failed "
+                           "for a caught exception object");
+
+            if (0 == bc2_what)
+                rw_assert (false, 0, __LINE__,
+                           "bad_cast::what() != 0 failed "
+                           "for an assigned exception object");
+
+            if (bc_what && bc2_what)
+                rw_warn (0 == rw_strncmp (bc_what, bc2_what),
+                         0, __LINE__,
+                         "bad_cast::operator=(const bad_cast&): "
+                         "\"%s\" != \"%s\"", bc_what, bc2_what);
+
+            // 18.5.2, p5
+            if (bc_what)
+                rw_assert (0 == rw_strncmp (bc.what (), bc.what ()),
+                           0, __LINE__, 
+                           "bad_cast::what() const: \"%s\" != \"%s\"",
+                           bc.what (), bc.what ());
+        }
+        catch (const std::exception&) {
+            caught = "std::exception";
+        }
+        catch (...) {
+            caught = "unknown exception";
+        }
+
+#if    !defined (_RWSTD_NO_STD_BAD_CAST) \
+    || !defined (_RWSTD_NO_RUNTIME_IN_STD)
+
+       const char expect[] = "std::bad_cast";
+
+#else
+
+       const char expect[] = "std::bad_cast (alias for ::bad_cast)";
+
+#endif   // !NO_STD_BAD_CAST || !NO_RUNTIME_IN_STD
+
+        rw_assert (0 == rw_strncmp (caught, "std::bad_cast"),
+                   0, __LINE__,
+                   "dynamic_cast<>() threw %s, expected %s; this suggests "
+                   "that bad_cast might be defined in the wrong namespace",
+                   caught, expect);
+
+        _RWSTD_UNUSED (d1);
+        _RWSTD_UNUSED (b);
+
+#  endif   // _RWSTD_NO_DYNAMIC_CAST
+#endif   // _RWSTD_NO_EXCEPTIONS
+    }
+
+    if (1) {
+        // exercise 18.5.3, class bad_typeid interface
+
+        // std::bad_cast must publicly derive from std::exception
+        const std::bad_typeid *pbt = 0;
+        const std::exception  *pe  = pbt;
+
+        // 18.5.2, p2
+        std::bad_typeid bt;
+
+        // 18.5.2, p4 - copy ctor
+        std::bad_typeid bt2 (bt);
+
+        // 18.5.2, p4 - assignment
+        std::bad_typeid& (std::bad_typeid::*p_op_assign)(const std::bad_typeid&)
+            _PTR_THROWS (()) = &std::bad_typeid::operator=;
+
+        // 18.5.2, p5
+        const char* (std::bad_typeid::*p_what)() const _PTR_THROWS (()) =
+            &std::bad_typeid::what;
+
+        _RWSTD_UNUSED (pbt);
+        _RWSTD_UNUSED (pe);
+        _RWSTD_UNUSED (bt);
+        _RWSTD_UNUSED (bt2);
+        _RWSTD_UNUSED (p_op_assign);
+        _RWSTD_UNUSED (p_what);
+    }
+
+    if (1) {
+        // exercise 18.5.3, class bad_typeid functionality
+
+#ifndef _RWSTD_NO_EXCEPTIONS
+
+        const char *caught = "no exception";
+
+        try {
+
+#if !defined (__GNUG__) || __GNUG__ > 2
+
+            B *b = 0;
+
+            // 5.2.8, p2 - typeid(0) throws std::bad_typeid
+            const std::type_info &ti = typeid (*b);
+
+            _RWSTD_UNUSED (b);
+            _RWSTD_UNUSED (ti);
+
+#else
+
+            // working around a gcc 2.x bug
+            caught = "SIGSEGV (program dumps core)";
+
+#endif   // gcc < 3.0
+
+        }
+        catch (const std::bad_typeid &bt) {
+            caught = "std::bad_typeid";
+
+            // 18.5.2, p2
+            std::bad_typeid bt2;
+
+            // 18.5.2, p4 - copy ctor
+            std::bad_typeid bt3 (bt);
+
+            // verify that what() returns the same string
+            // after copy construction
+            rw_warn (0 == rw_strncmp (bt.what (), bt3.what ()),
+                     0, __LINE__,
+                     "std::bad_typeid::bad_typeid (const bad_typeid&): "
+                     "\"%s\" != \"%s\"", bt.what (), bt3.what ());
+
+            // 18.5.2, p4 - assignment
+            bt2 = bt;
+
+            // verify that what() returns the same string
+            // after assignment
+            rw_warn (0 == rw_strncmp (bt.what (), bt2.what ()),
+                     0, __LINE__,
+                     "std::bad_typeid::operator=(const bad_typeid&): "
+                     "\"%s\" != \"%s\"", bt.what (), bt2.what ());
+
+            // 18.5.2, p5
+            rw_assert (0 == rw_strncmp (bt.what (), bt.what ()),
+                       0, __LINE__,
+                       "std::bad_typeid::what() const: "
+                       "\"%s\" != \"%s\"", bt.what (), bt.what ());
+        }
+        catch (const std::exception&) {
+            caught = "std::exception";
+        }
+        catch (...) {
+            caught = "unknown exception";
+        }
+
+#if    !defined (_RWSTD_NO_STD_BAD_TYPEID) \
+    || !defined (_RWSTD_NO_RUNTIME_IN_STD)
+
+       const char expect[] = "std::bad_typeid";
+
+#else
+
+       const char expect[] = "std::bad_typeid (alias for ::bad_typeid)";
+
+#endif   // !NO_STD_BAD_TYPEID || !NO_RUNTIME_IN_STD
+
+
+        rw_assert (0 == rw_strncmp (caught, "std::bad_typeid"),
+                   0, __LINE__,
+                   "typeid ((T*)0) threw %s, expected %s; this suggests "
+                   "that bad_typeid might be defined in the wrong namespace",
+                   caught, expect);
+
+#endif   // _RWSTD_NO_EXCEPTIONS
+    }
+
+    return 0;
+}
+
+int main (int argc, char* argv [])
+{
+    return rw_test (argc, argv, __FILE__,
+                    "lib.support.rtti",
+                    0 /* no comment */,
+                    run_test,
+                    "",
+                    (void*)0);
+}

Propchange: stdcxx/trunk/tests/support/18.support.rtti.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: stdcxx/trunk/tests/support/18.support.rtti.cpp
------------------------------------------------------------------------------
    svn:keywords = Id



Mime
View raw message