1 //===---------- llvm/unittest/Support/Casting.cpp - Casting tests ---------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "llvm/Support/Casting.h" 11 #include "llvm/Support/Debug.h" 12 #include "llvm/Support/raw_ostream.h" 13 14 #include "gtest/gtest.h" 15 #include <cstdlib> 16 17 namespace llvm { 18 19 // set up two example classes 20 // with conversion facility 21 // 22 struct bar { 23 bar() {} 24 struct foo *baz(); 25 struct foo *caz(); 26 struct foo *daz(); 27 struct foo *naz(); 28 private: 29 bar(const bar &); 30 }; 31 struct foo { 32 void ext() const; 33 /* static bool classof(const bar *X) { 34 cerr << "Classof: " << X << "\n"; 35 return true; 36 }*/ 37 }; 38 39 template <> struct isa_impl<foo, bar> { 40 static inline bool doit(const bar &Val) { 41 dbgs() << "Classof: " << &Val << "\n"; 42 return true; 43 } 44 }; 45 46 foo *bar::baz() { 47 return cast<foo>(this); 48 } 49 50 foo *bar::caz() { 51 return cast_or_null<foo>(this); 52 } 53 54 foo *bar::daz() { 55 return dyn_cast<foo>(this); 56 } 57 58 foo *bar::naz() { 59 return dyn_cast_or_null<foo>(this); 60 } 61 62 63 bar *fub(); 64 } // End llvm namespace 65 66 using namespace llvm; 67 68 namespace { 69 70 const foo *null_foo = NULL; 71 72 bar B; 73 extern bar &B1; 74 bar &B1 = B; 75 extern const bar *B2; 76 // test various configurations of const 77 const bar &B3 = B1; 78 const bar *const B4 = B2; 79 80 TEST(CastingTest, isa) { 81 EXPECT_TRUE(isa<foo>(B1)); 82 EXPECT_TRUE(isa<foo>(B2)); 83 EXPECT_TRUE(isa<foo>(B3)); 84 EXPECT_TRUE(isa<foo>(B4)); 85 } 86 87 TEST(CastingTest, cast) { 88 foo &F1 = cast<foo>(B1); 89 EXPECT_NE(&F1, null_foo); 90 const foo *F3 = cast<foo>(B2); 91 EXPECT_NE(F3, null_foo); 92 const foo *F4 = cast<foo>(B2); 93 EXPECT_NE(F4, null_foo); 94 const foo &F5 = cast<foo>(B3); 95 EXPECT_NE(&F5, null_foo); 96 const foo *F6 = cast<foo>(B4); 97 EXPECT_NE(F6, null_foo); 98 // Can't pass null pointer to cast<>. 99 // foo *F7 = cast<foo>(fub()); 100 // EXPECT_EQ(F7, null_foo); 101 foo *F8 = B1.baz(); 102 EXPECT_NE(F8, null_foo); 103 } 104 105 TEST(CastingTest, cast_or_null) { 106 const foo *F11 = cast_or_null<foo>(B2); 107 EXPECT_NE(F11, null_foo); 108 const foo *F12 = cast_or_null<foo>(B2); 109 EXPECT_NE(F12, null_foo); 110 const foo *F13 = cast_or_null<foo>(B4); 111 EXPECT_NE(F13, null_foo); 112 const foo *F14 = cast_or_null<foo>(fub()); // Shouldn't print. 113 EXPECT_EQ(F14, null_foo); 114 foo *F15 = B1.caz(); 115 EXPECT_NE(F15, null_foo); 116 } 117 118 TEST(CastingTest, dyn_cast) { 119 const foo *F1 = dyn_cast<foo>(B2); 120 EXPECT_NE(F1, null_foo); 121 const foo *F2 = dyn_cast<foo>(B2); 122 EXPECT_NE(F2, null_foo); 123 const foo *F3 = dyn_cast<foo>(B4); 124 EXPECT_NE(F3, null_foo); 125 // Can't pass null pointer to dyn_cast<>. 126 // foo *F4 = dyn_cast<foo>(fub()); 127 // EXPECT_EQ(F4, null_foo); 128 foo *F5 = B1.daz(); 129 EXPECT_NE(F5, null_foo); 130 } 131 132 TEST(CastingTest, dyn_cast_or_null) { 133 const foo *F1 = dyn_cast_or_null<foo>(B2); 134 EXPECT_NE(F1, null_foo); 135 const foo *F2 = dyn_cast_or_null<foo>(B2); 136 EXPECT_NE(F2, null_foo); 137 const foo *F3 = dyn_cast_or_null<foo>(B4); 138 EXPECT_NE(F3, null_foo); 139 foo *F4 = dyn_cast_or_null<foo>(fub()); 140 EXPECT_EQ(F4, null_foo); 141 foo *F5 = B1.naz(); 142 EXPECT_NE(F5, null_foo); 143 } 144 145 // These lines are errors... 146 //foo *F20 = cast<foo>(B2); // Yields const foo* 147 //foo &F21 = cast<foo>(B3); // Yields const foo& 148 //foo *F22 = cast<foo>(B4); // Yields const foo* 149 //foo &F23 = cast_or_null<foo>(B1); 150 //const foo &F24 = cast_or_null<foo>(B3); 151 152 const bar *B2 = &B; 153 } // anonymous namespace 154 155 bar *llvm::fub() { return 0; } 156
