| 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 | #include <typeinfo> |
|---|
| 12 | |
|---|
| 13 | // Test taken from 5.2.8.2 |
|---|
| 14 | // When typeid is applied to a glvalue expression whose type is a polymorphic |
|---|
| 15 | // class type, (10.3), the result refers to a std::type_info object |
|---|
| 16 | // representing the type of the most derived object (1.8) (that is, the |
|---|
| 17 | // dynamic type) to which the glvalue refers. If the glvalue expression is |
|---|
| 18 | // obtained by applying the unary * operator to a pointer(68) and the pointer |
|---|
| 19 | // is a null pointer value (4.10), the typeid expression throws the |
|---|
| 20 | // std::bad_typeid exception (18.7.3). |
|---|
| 21 | // |
|---|
| 22 | // 68) If p is an expression of pointer type, then *p, (*p), *(p), |
|---|
| 23 | // ((*p)), *((p)), and so on all meet this requirement. |
|---|
| 24 | bool bad_typeid_test () { |
|---|
| 25 | class A { virtual void f() {}}; |
|---|
| 26 | class B { virtual void g() {}}; |
|---|
| 27 | |
|---|
| 28 | B *bp = NULL; |
|---|
| 29 | try {bool b = typeid(*bp) == typeid (A); ((void)b); } |
|---|
| 30 | catch ( const std::bad_typeid &) { return true; } |
|---|
| 31 | return false; |
|---|
| 32 | } |
|---|
| 33 | |
|---|
| 34 | |
|---|
| 35 | // The value of a failed cast to pointer type is the null pointer value of |
|---|
| 36 | // the required result type. A failed cast to reference type throws |
|---|
| 37 | // std::bad_cast (18.7.2). |
|---|
| 38 | bool bad_cast_test () { |
|---|
| 39 | class A { virtual void f() {}}; |
|---|
| 40 | class B { virtual void g() {}}; |
|---|
| 41 | class D : public virtual A, private B {}; |
|---|
| 42 | |
|---|
| 43 | D d; |
|---|
| 44 | B *bp = (B*)&d; // cast needed to break protection |
|---|
| 45 | try { D &dr = dynamic_cast<D&> (*bp); ((void)dr); } |
|---|
| 46 | catch ( const std::bad_cast & ) { return true; } |
|---|
| 47 | return false; |
|---|
| 48 | } |
|---|
| 49 | |
|---|
| 50 | int main ( ) { |
|---|
| 51 | int ret_val = 0; |
|---|
| 52 | |
|---|
| 53 | if ( !bad_typeid_test ()) { |
|---|
| 54 | ret_val = 1; |
|---|
| 55 | } |
|---|
| 56 | |
|---|
| 57 | if ( !bad_cast_test ()) { |
|---|
| 58 | ret_val = 2; |
|---|
| 59 | } |
|---|
| 60 | |
|---|
| 61 | return ret_val; |
|---|
| 62 | } |
|---|
| 63 | |
|---|
