From 487fa01673a1d13331b7173e9e6812e72dd4361e Mon Sep 17 00:00:00 2001 From: Jeffrey Yasskin Date: Mon, 27 Apr 2009 20:32:07 +0000 Subject: [PATCH] Add tests for WeakVH and AssertingVH. These pointed out that the overloads for the comparison operators were not only unnecessary in the presence of the implicit conversion; they caused ambiguous overload errors. So I deleted them. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@70243 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Support/ValueHandle.h | 44 +------ unittests/Support/ValueHandleTest.cpp | 181 ++++++++++++++++++++++++++ 2 files changed, 183 insertions(+), 42 deletions(-) create mode 100644 unittests/Support/ValueHandleTest.cpp diff --git a/include/llvm/Support/ValueHandle.h b/include/llvm/Support/ValueHandle.h index a594e3a2764..d003b0263c6 100644 --- a/include/llvm/Support/ValueHandle.h +++ b/include/llvm/Support/ValueHandle.h @@ -39,7 +39,7 @@ public: class ValueHandleBase { friend class Value; protected: - /// HandleBaseKind - This indicates what base class the handle actually is. + /// HandleBaseKind - This indicates what sub class the handle actually is. /// This is to avoid having a vtable for the light-weight handle pointers. The /// fully generally Callback version does have a vtable. enum HandleBaseKind { @@ -87,20 +87,7 @@ public: Value *operator->() const { return getValPtr(); } Value &operator*() const { return *getValPtr(); } - - bool operator==(const Value *RHS) const { return VP == RHS; } - bool operator==(const ValueHandleBase &RHS) const { return VP == RHS.VP; } - bool operator!=(const Value *RHS) const { return VP != RHS; } - bool operator!=(const ValueHandleBase &RHS) const { return VP != RHS.VP; } - bool operator<(const Value *RHS) const { return VP < RHS; } - bool operator<(const ValueHandleBase &RHS) const { return VP < RHS.VP; } - bool operator>(const Value *RHS) const { return VP > RHS; } - bool operator>(const ValueHandleBase &RHS) const { return VP > RHS.VP; } - bool operator<=(const Value *RHS) const { return VP <= RHS; } - bool operator<=(const ValueHandleBase &RHS) const { return VP <= RHS.VP; } - bool operator>=(const Value *RHS) const { return VP >= RHS; } - bool operator>=(const ValueHandleBase &RHS) const { return VP >= RHS.VP; } - + protected: Value *getValPtr() const { return VP; } private: @@ -198,33 +185,6 @@ public: ValueTy *operator->() const { return getValPtr(); } ValueTy &operator*() const { return *getValPtr(); } - - // Duplicate these from the base class so that they work when assertions are - // off. - bool operator==(const Value *RHS) const { return getValPtr() == RHS; } - bool operator!=(const Value *RHS) const { return getValPtr() != RHS; } - bool operator<(const Value *RHS) const { return getValPtr() < RHS; } - bool operator>(const Value *RHS) const { return getValPtr() > RHS; } - bool operator<=(const Value *RHS) const { return getValPtr() <= RHS; } - bool operator>=(const Value *RHS) const { return getValPtr() >= RHS; } - bool operator==(const AssertingVH &RHS) const { - return getValPtr() == RHS.getValPtr(); - } - bool operator!=(const AssertingVH &RHS) const { - return getValPtr() != RHS.getValPtr(); - } - bool operator<(const AssertingVH &RHS) const { - return getValPtr() < RHS.getValPtr(); - } - bool operator>(const AssertingVH &RHS) const { - return getValPtr() > RHS.getValPtr(); - } - bool operator<=(const AssertingVH &RHS) const { - return getValPtr() <= RHS.getValPtr(); - } - bool operator>=(const AssertingVH &RHS) const { - return getValPtr() >= RHS.getValPtr(); - } }; } // End llvm namespace diff --git a/unittests/Support/ValueHandleTest.cpp b/unittests/Support/ValueHandleTest.cpp new file mode 100644 index 00000000000..7980758f9fd --- /dev/null +++ b/unittests/Support/ValueHandleTest.cpp @@ -0,0 +1,181 @@ +//===- llvm/unittest/Support/ValueHandleTest.cpp - ValueHandle tests --------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "llvm/Support/ValueHandle.h" + +#include "llvm/Constants.h" +#include "llvm/Instructions.h" + +#include "gtest/gtest.h" + +#include + +using namespace llvm; + +namespace { + +class ValueHandle : public testing::Test { +protected: + Constant *ConstantV; + std::auto_ptr BitcastV; + + ValueHandle() : ConstantV(ConstantInt::get(Type::Int32Ty, 0)), + BitcastV(new BitCastInst(ConstantV, Type::Int32Ty)) { + } +}; + +TEST_F(ValueHandle, WeakVH_BasicOperation) { + WeakVH WVH(BitcastV.get()); + EXPECT_EQ(BitcastV.get(), WVH); + WVH = ConstantV; + EXPECT_EQ(ConstantV, WVH); + + // Make sure I can call a method on the underlying Value. It + // doesn't matter which method. + EXPECT_EQ(Type::Int32Ty, WVH->getType()); + EXPECT_EQ(Type::Int32Ty, (*WVH).getType()); +} + +TEST_F(ValueHandle, WeakVH_Comparisons) { + WeakVH BitcastWVH(BitcastV.get()); + WeakVH ConstantWVH(ConstantV); + + EXPECT_TRUE(BitcastWVH == BitcastWVH); + EXPECT_TRUE(BitcastV.get() == BitcastWVH); + EXPECT_TRUE(BitcastWVH == BitcastV.get()); + EXPECT_FALSE(BitcastWVH == ConstantWVH); + + EXPECT_TRUE(BitcastWVH != ConstantWVH); + EXPECT_TRUE(BitcastV.get() != ConstantWVH); + EXPECT_TRUE(BitcastWVH != ConstantV); + EXPECT_FALSE(BitcastWVH != BitcastWVH); + + // Cast to Value* so comparisons work. + Value *BV = BitcastV.get(); + Value *CV = ConstantV; + EXPECT_EQ(BV < CV, BitcastWVH < ConstantWVH); + EXPECT_EQ(BV <= CV, BitcastWVH <= ConstantWVH); + EXPECT_EQ(BV > CV, BitcastWVH > ConstantWVH); + EXPECT_EQ(BV >= CV, BitcastWVH >= ConstantWVH); + + EXPECT_EQ(BV < CV, BitcastV.get() < ConstantWVH); + EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantWVH); + EXPECT_EQ(BV > CV, BitcastV.get() > ConstantWVH); + EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantWVH); + + EXPECT_EQ(BV < CV, BitcastWVH < ConstantV); + EXPECT_EQ(BV <= CV, BitcastWVH <= ConstantV); + EXPECT_EQ(BV > CV, BitcastWVH > ConstantV); + EXPECT_EQ(BV >= CV, BitcastWVH >= ConstantV); +} + +TEST_F(ValueHandle, WeakVH_FollowsRAUW) { + WeakVH WVH(BitcastV.get()); + WeakVH WVH_Copy(WVH); + WeakVH WVH_Recreated(BitcastV.get()); + BitcastV->replaceAllUsesWith(ConstantV); + EXPECT_EQ(ConstantV, WVH); + EXPECT_EQ(ConstantV, WVH_Copy); + EXPECT_EQ(ConstantV, WVH_Recreated); +} + +TEST_F(ValueHandle, WeakVH_NullOnDeletion) { + WeakVH WVH(BitcastV.get()); + WeakVH WVH_Copy(WVH); + WeakVH WVH_Recreated(BitcastV.get()); + BitcastV.reset(); + Value *null_value = NULL; + EXPECT_EQ(null_value, WVH); + EXPECT_EQ(null_value, WVH_Copy); + EXPECT_EQ(null_value, WVH_Recreated); +} + + +TEST_F(ValueHandle, AssertingVH_BasicOperation) { + AssertingVH AVH(BitcastV.get()); + CastInst *implicit_to_exact_type = AVH; + implicit_to_exact_type = implicit_to_exact_type; // Avoid warning. + + AssertingVH GenericAVH(BitcastV.get()); + EXPECT_EQ(BitcastV.get(), GenericAVH); + GenericAVH = ConstantV; + EXPECT_EQ(ConstantV, GenericAVH); + + // Make sure I can call a method on the underlying CastInst. It + // doesn't matter which method. + EXPECT_FALSE(AVH->mayWriteToMemory()); + EXPECT_FALSE((*AVH).mayWriteToMemory()); +} + +TEST_F(ValueHandle, AssertingVH_Comparisons) { + AssertingVH BitcastAVH(BitcastV.get()); + AssertingVH ConstantAVH(ConstantV); + + EXPECT_TRUE(BitcastAVH == BitcastAVH); + EXPECT_TRUE(BitcastV.get() == BitcastAVH); + EXPECT_TRUE(BitcastAVH == BitcastV.get()); + EXPECT_FALSE(BitcastAVH == ConstantAVH); + + EXPECT_TRUE(BitcastAVH != ConstantAVH); + EXPECT_TRUE(BitcastV.get() != ConstantAVH); + EXPECT_TRUE(BitcastAVH != ConstantV); + EXPECT_FALSE(BitcastAVH != BitcastAVH); + + // Cast to Value* so comparisons work. + Value *BV = BitcastV.get(); + Value *CV = ConstantV; + EXPECT_EQ(BV < CV, BitcastAVH < ConstantAVH); + EXPECT_EQ(BV <= CV, BitcastAVH <= ConstantAVH); + EXPECT_EQ(BV > CV, BitcastAVH > ConstantAVH); + EXPECT_EQ(BV >= CV, BitcastAVH >= ConstantAVH); + + EXPECT_EQ(BV < CV, BitcastV.get() < ConstantAVH); + EXPECT_EQ(BV <= CV, BitcastV.get() <= ConstantAVH); + EXPECT_EQ(BV > CV, BitcastV.get() > ConstantAVH); + EXPECT_EQ(BV >= CV, BitcastV.get() >= ConstantAVH); + + EXPECT_EQ(BV < CV, BitcastAVH < ConstantV); + EXPECT_EQ(BV <= CV, BitcastAVH <= ConstantV); + EXPECT_EQ(BV > CV, BitcastAVH > ConstantV); + EXPECT_EQ(BV >= CV, BitcastAVH >= ConstantV); +} + +TEST_F(ValueHandle, AssertingVH_DoesNotFollowRAUW) { + AssertingVH AVH(BitcastV.get()); + BitcastV->replaceAllUsesWith(ConstantV); + EXPECT_EQ(BitcastV.get(), AVH); +} + +#ifdef NDEBUG + +TEST_F(ValueHandle, AssertingVH_ReducesToPointer) { + EXPECT_EQ(sizeof(CastInst *), sizeof(AssertingVH)); +} + +#else // !NDEBUG + +#ifdef GTEST_HAS_DEATH_TEST + +TEST_F(ValueHandle, AssertingVH_Asserts) { + AssertingVH AVH(BitcastV.get()); + EXPECT_DEATH({BitcastV.reset();}, + "An asserting value handle still pointed to this value!"); + AssertingVH Copy(AVH); + AVH = NULL; + EXPECT_DEATH({BitcastV.reset();}, + "An asserting value handle still pointed to this value!"); + Copy = NULL; + BitcastV.reset(); +} + +#endif // GTEST_HAS_DEATH_TEST + +#endif // NDEBUG + +}