More tests added

Author: chitreshkakwani

src/shared_ptr.hpp

@@ -56,19 +56,19 @@ class shared_ptr: private shared_ptr_base
 public:
 
 	// FIXME: Should this be explicit ?
-	shared_ptr() : m_pData(0), m_pRefCount(0)
+	shared_ptr() : m_pointer(0), m_pRefCount(0)
 	{
 		m_pRefCount = new RefCount();
 		m_pRefCount->AddRef();
 	}
 
-	shared_ptr(T* ptr) : m_pData(ptr), m_pRefCount(0)
+	shared_ptr(T* ptr) : m_pointer(ptr), m_pRefCount(0)
 	{
 		m_pRefCount = new RefCount();
 		m_pRefCount->AddRef();
 	}
 
-	shared_ptr(const shared_ptr<T>& ptr) : m_pData(ptr.m_pData), m_pRefCount(ptr.m_pRefCount)
+	shared_ptr(const shared_ptr<T>& ptr) : m_pointer(ptr.m_pointer), m_pRefCount(ptr.m_pRefCount)
 	{
 		m_pRefCount->AddRef();
 	}
@@ -77,29 +77,29 @@ class shared_ptr: private shared_ptr_base
 	{
 		if(m_pRefCount->Release() == 0)
 		{
-			if(m_pData)
-				delete m_pData;
+			if(m_pointer)
+				delete m_pointer;
 			delete m_pRefCount;
 		}
 	}
 
-	bool isNull()
+	bool isNull() const
 	{
-		return m_pData == 0;
+		return m_pointer == 0;
 	}
 
-	bool operator!()
+	bool operator!() const
 	{
-		return m_pData == 0;
+		return m_pointer == 0;
 	}
 
 	void swap(shared_ptr<T>& rhs)
 	{
-		T* pData = rhs.m_pData;
+		T* pData = rhs.m_pointer;
 		RefCount* pRefCount = rhs.m_pRefCount;
-		rhs.m_pData = this->m_pData;
+		rhs.m_pointer = this->m_pointer;
 		rhs.m_pRefCount = this->m_pRefCount;
-		this->m_pData = pData;
+		this->m_pointer = pData;
 		this->m_pRefCount = pRefCount;
 	}
 
@@ -118,18 +118,18 @@ class shared_ptr: private shared_ptr_base
 
 	T& operator*()
 	{
-		return *m_pData;
+		return *m_pointer;
 	}
 
 	T* operator->()
 	{
-		return m_pData;
+		return m_pointer;
 	}
 
 
 private:
 
-	T* m_pData;
+	T* m_pointer;
 	RefCount* m_pRefCount;
 
 	template<class X>
@@ -150,13 +150,13 @@ class shared_ptr: private shared_ptr_base
 template<class T>
 inline bool operator==(const shared_ptr<T>& p1, const shared_ptr<T>& p2)
 {
-	return p1.m_pData == p2.m_pData;
+	return p1.m_pointer == p2.m_pointer;
 }
 
 template<class T>
 inline bool operator!=(const shared_ptr<T>& p1, const shared_ptr<T>& p2)
 {
-	return p1.m_pData != p2.m_pData;
+	return p1.m_pointer != p2.m_pointer;
 }
 
 

tests/shared_ptr_test.cpp

@@ -28,5 +28,22 @@ void SharedPtrTest::Test()
 
 	CPPUNIT_ASSERT(sp3.isNull() == true);
 	CPPUNIT_ASSERT(!sp3 == true);
+
+	// Comparison operators
+	CPPUNIT_ASSERT(sp1 == sp2);
+	CPPUNIT_ASSERT(!(sp1 != sp2));
+
+	// Derived classes
+	shared_ptr<Dummy> derived1(new DummyDerived());
+	
+	shared_ptr<Dummy> derived2(new Dummy());
+
+	CPPUNIT_ASSERT(derived1 != derived2);
+
+	derived1->m_data = 1;
+	derived2 = derived1;
+	
+	CPPUNIT_ASSERT(derived1->GetData() == 2);
+	CPPUNIT_ASSERT(derived2->GetData() == 2);
 }
 

tests/shared_ptr_test.h

@@ -35,15 +35,28 @@ class Dummy
 	{
 	}
 
-	~Dummy()
+	virtual ~Dummy()
 	{
 		if(m_pData)
 			delete m_pData;
 	}
 
+	virtual int GetData()
+	{
+		return m_data;
+	}
+
 	int* m_pData;
 	int m_data;
 };
 
+class DummyDerived : public Dummy
+{
+	virtual int GetData()
+	{
+		return m_data * 2;
+	}
+};
+
 #endif