1 //===------ unittests/ExtensibleRTTITest.cpp - Extensible RTTI Tests ------===// 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 #include "llvm/Support/ExtensibleRTTI.h" 10 #include "llvm/Support/Casting.h" 11 12 #include "gtest/gtest.h" 13 14 using namespace llvm; 15 16 namespace { 17 18 class MyBaseType : public RTTIExtends<MyBaseType, RTTIRoot> { 19 public: 20 static char ID; 21 }; 22 23 class MyDerivedType : public RTTIExtends<MyDerivedType, MyBaseType> { 24 public: 25 static char ID; 26 }; 27 28 class MyOtherDerivedType : public RTTIExtends<MyOtherDerivedType, MyBaseType> { 29 public: 30 static char ID; 31 }; 32 33 class MyDeeperDerivedType 34 : public RTTIExtends<MyDeeperDerivedType, MyDerivedType> { 35 public: 36 static char ID; 37 }; 38 39 class MyMultipleInheritanceType 40 : public RTTIExtends<MyMultipleInheritanceType, MyDerivedType, 41 MyOtherDerivedType> { 42 public: 43 static char ID; 44 }; 45 46 class MyTypeWithConstructor 47 : public RTTIExtends<MyTypeWithConstructor, MyBaseType> { 48 public: 49 static char ID; 50 51 MyTypeWithConstructor(int) {} 52 }; 53 54 class MyDerivedTypeWithConstructor 55 : public RTTIExtends<MyDerivedTypeWithConstructor, MyTypeWithConstructor> { 56 public: 57 static char ID; 58 59 MyDerivedTypeWithConstructor(int x) : RTTIExtends(x) {} 60 }; 61 62 char MyBaseType::ID = 0; 63 char MyDerivedType::ID = 0; 64 char MyOtherDerivedType::ID = 0; 65 char MyDeeperDerivedType::ID = 0; 66 char MyMultipleInheritanceType::ID = 0; 67 char MyTypeWithConstructor::ID = 0; 68 char MyDerivedTypeWithConstructor::ID = 0; 69 70 TEST(ExtensibleRTTI, isa) { 71 MyBaseType B; 72 MyDerivedType D; 73 MyDeeperDerivedType DD; 74 MyMultipleInheritanceType MI; 75 76 EXPECT_TRUE(isa<MyBaseType>(B)); 77 EXPECT_FALSE(isa<MyDerivedType>(B)); 78 EXPECT_FALSE(isa<MyOtherDerivedType>(B)); 79 EXPECT_FALSE(isa<MyDeeperDerivedType>(B)); 80 81 EXPECT_TRUE(isa<MyBaseType>(D)); 82 EXPECT_TRUE(isa<MyDerivedType>(D)); 83 EXPECT_FALSE(isa<MyOtherDerivedType>(D)); 84 EXPECT_FALSE(isa<MyDeeperDerivedType>(D)); 85 86 EXPECT_TRUE(isa<MyBaseType>(DD)); 87 EXPECT_TRUE(isa<MyDerivedType>(DD)); 88 EXPECT_FALSE(isa<MyOtherDerivedType>(DD)); 89 EXPECT_TRUE(isa<MyDeeperDerivedType>(DD)); 90 91 EXPECT_TRUE(isa<MyBaseType>(MI)); 92 EXPECT_TRUE(isa<MyDerivedType>(MI)); 93 EXPECT_TRUE(isa<MyOtherDerivedType>(MI)); 94 EXPECT_FALSE(isa<MyDeeperDerivedType>(MI)); 95 EXPECT_TRUE(isa<MyMultipleInheritanceType>(MI)); 96 } 97 98 TEST(ExtensibleRTTI, cast) { 99 MyMultipleInheritanceType MI; 100 MyDerivedType &D = MI; 101 MyOtherDerivedType &OD = MI; 102 MyBaseType &B = D; 103 104 EXPECT_EQ(&cast<MyBaseType>(D), &B); 105 EXPECT_EQ(&cast<MyDerivedType>(MI), &D); 106 EXPECT_EQ(&cast<MyOtherDerivedType>(MI), &OD); 107 EXPECT_EQ(&cast<MyMultipleInheritanceType>(MI), &MI); 108 } 109 110 TEST(ExtensibleRTTI, dyn_cast) { 111 MyMultipleInheritanceType MI; 112 MyDerivedType &D = MI; 113 MyOtherDerivedType &OD = MI; 114 MyBaseType &BD = D; 115 MyBaseType &BOD = OD; 116 117 EXPECT_EQ(dyn_cast<MyBaseType>(&BD), &BD); 118 EXPECT_EQ(dyn_cast<MyDerivedType>(&BD), &D); 119 120 EXPECT_EQ(dyn_cast<MyBaseType>(&BOD), &BOD); 121 EXPECT_EQ(dyn_cast<MyOtherDerivedType>(&BOD), &OD); 122 123 EXPECT_EQ(dyn_cast<MyBaseType>(&D), &BD); 124 EXPECT_EQ(dyn_cast<MyDerivedType>(&D), &D); 125 EXPECT_EQ(dyn_cast<MyMultipleInheritanceType>(&D), &MI); 126 127 EXPECT_EQ(dyn_cast<MyBaseType>(&OD), &BOD); 128 EXPECT_EQ(dyn_cast<MyOtherDerivedType>(&OD), &OD); 129 EXPECT_EQ(dyn_cast<MyMultipleInheritanceType>(&OD), &MI); 130 131 EXPECT_EQ(dyn_cast<MyDerivedType>(&MI), &D); 132 EXPECT_EQ(dyn_cast<MyMultipleInheritanceType>(&MI), &MI); 133 134 EXPECT_EQ(dyn_cast<MyDerivedType>(&MI), &D); 135 EXPECT_EQ(dyn_cast<MyOtherDerivedType>(&MI), &OD); 136 EXPECT_EQ(dyn_cast<MyMultipleInheritanceType>(&MI), &MI); 137 } 138 139 TEST(ExtensibleRTTI, multiple_inheritance_constructor) { 140 MyDerivedTypeWithConstructor V(42); 141 } 142 143 } // namespace 144