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

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