test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // UNSUPPORTED: libcpp-no-exceptions
  11
  12 // This test fails due to a stack overflow
  13 // XFAIL: LIBCXX-WINDOWS-FIXME
  14
  15 // <exception>
  16
  17 // class nested_exception;
  18
  19 // template <class E> void rethrow_if_nested(const E& e);
  20
  21 #include <exception>
  22 #include <cstdlib>
  23 #include <cassert>
  24
  25 #include "test_macros.h"
  26
  27 class A
  28 {
  29     int data_;
  30 public:
  31     explicit A(int data) : data_(data) {}
  32     virtual ~A() TEST_NOEXCEPT {}
  33
  34     friend bool operator==(const A& x, const A& y) {return x.data_ == y.data_;}
  35 };
  36
  37 class B
  38     : public std::nested_exception,
  39       public A
  40 {
  41 public:
  42     explicit B(int data) : A(data) {}
  43     B(const B& b) : A(b) {}
  44 };
  45
  46 class C
  47 {
  48 public:
  49         virtual ~C() {}
  50         C * operator&() const { assert(false); return nullptr; } // should not be called
  51 };
  52
  53 class D : private std::nested_exception {};
  54
  55
  56 class E1 : public std::nested_exception {};
  57 class E2 : public std::nested_exception {};
  58 class E : public E1, public E2 {};
  59
  60 int main()
  61 {
  62     {
  63         try
  64         {
  65             A a(3);  // not a polymorphic type --> no effect
  66             std::rethrow_if_nested(a);
  67             assert(true);
  68         }
  69         catch (...)
  70         {
  71             assert(false);
  72         }
  73     }
  74     {
  75         try
  76         {
  77             D s;  // inaccessible base class --> no effect
  78             std::rethrow_if_nested(s);
  79             assert(true);
  80         }
  81         catch (...)
  82         {
  83             assert(false);
  84         }
  85     }
  86     {
  87         try
  88         {
  89             E s;  // ambiguous base class --> no effect
  90             std::rethrow_if_nested(s);
  91             assert(true);
  92         }
  93         catch (...)
  94         {
  95             assert(false);
  96         }
  97     }
  98     {
  99         try
 100         {
 101             throw B(5);
 102         }
 103         catch (const B& b)
 104         {
 105             try
 106             {
 107                 throw b;
 108             }
 109             catch (const A& a)
 110             {
 111                 try
 112                 {
 113                     std::rethrow_if_nested(a);
 114                     assert(false);
 115                 }
 116                 catch (const B& b2)
 117                 {
 118                     assert(b2 == B(5));
 119                 }
 120             }
 121         }
 122     }
 123     {
 124         try
 125         {
 126             std::rethrow_if_nested(C());
 127             assert(true);
 128         }
 129         catch (...)
 130         {
 131             assert(false);
 132         }
 133     }
 134
 135 }