initial commit

2011-01-24 14:16:14 -08:00
commit 279ceb25dd
@@ -0,0 +1,655 @@
+#include <vector>
+#include <list>
+#include <map>
+
+#include "UnitTest++/src/UnitTest++.h"
+
+#include "ptr.h"
+
+// a simple class that reference counts itself
+class RefCounter
+{
+	public:
+		RefCounter() { s_instances++; }
+		virtual ~RefCounter() { s_instances--; }
+
+		virtual signed Get(signed x) { return x; }
+
+		static signed s_instances;
+};
+
+signed RefCounter::s_instances = 0;
+
+// and a derived class off of RefCounter (for testing list of base pointers)
+class RefCounterDerived: public RefCounter
+{
+	public:
+		virtual signed Get(signed x) { return x*2; }
+};
+
+
+// a test fixture we need for setup/teardown of each test
+struct InstanceFixture
+{
+	InstanceFixture()
+	{
+		RefCounter::s_instances = 0;
+	}
+	~InstanceFixture()
+	{
+		// empty
+	}
+};
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,AutoDeletion)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+	{
+		ptr<RefCounter> a(new RefCounter);
+		CHECK_EQUAL(1,RefCounter::s_instances);
+	}
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,AssignZeroForDeletion)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+	ptr<RefCounter> a = new RefCounter;
+	CHECK_EQUAL(1,RefCounter::s_instances);
+	a = 0;
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,ArrayAutoDeletion)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+	{
+		array_ptr<RefCounter> a(new RefCounter[20]);
+		CHECK_EQUAL(20,RefCounter::s_instances);
+	}
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,ArrayAssignZeroForDeletion)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+	array_ptr<RefCounter> a = new RefCounter[20];
+	CHECK_EQUAL(20,RefCounter::s_instances);
+	a = 0;
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,AssignNewPointerForDeletion)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+	ptr<RefCounter> a = new RefCounter;
+	CHECK_EQUAL(1,RefCounter::s_instances);
+	a = new RefCounter;
+	CHECK_EQUAL(1,RefCounter::s_instances);
+	a = 0;
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,ArrayAssignNewPointerForDeletion)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+	array_ptr<RefCounter> a = new RefCounter[37];
+	CHECK_EQUAL(37,RefCounter::s_instances);
+	a = new RefCounter[10];
+	CHECK_EQUAL(10,RefCounter::s_instances);
+	a = 0;
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,CopyToAnotherSmartPointer)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+	ptr<RefCounter> a = new RefCounter;
+	CHECK_EQUAL(1,RefCounter::s_instances);
+	ptr<RefCounter> b(a);
+	CHECK_EQUAL(1,RefCounter::s_instances);
+	a = 0;
+	CHECK_EQUAL(1,RefCounter::s_instances);
+	b = 0;
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,ArrayCopyToAnotherSmartPointer)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+	array_ptr<RefCounter> a = new RefCounter[3];
+	CHECK_EQUAL(3,RefCounter::s_instances);
+	array_ptr<RefCounter> b(a);
+	CHECK_EQUAL(3,RefCounter::s_instances);
+	a = 0;
+	CHECK_EQUAL(3,RefCounter::s_instances);
+	b = 0;
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,StlVector)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+	
+	std::vector< ptr<RefCounter> > va,vb;
+	{
+		{
+			std::vector< ptr<RefCounter> > vc;
+			vc.push_back(new RefCounter);
+			CHECK_EQUAL(1,RefCounter::s_instances);
+			vc.push_back(new RefCounter);
+			CHECK_EQUAL(2,RefCounter::s_instances);
+			vc.push_back(new RefCounter);
+			CHECK_EQUAL(3,RefCounter::s_instances);
+			vb = vc;
+			CHECK_EQUAL(3,RefCounter::s_instances);
+		}
+		CHECK_EQUAL(3,RefCounter::s_instances);
+		va.push_back(vb[0]);
+		CHECK_EQUAL(3,RefCounter::s_instances);
+		vb.clear();
+		CHECK_EQUAL(1,RefCounter::s_instances);
+	}
+	CHECK_EQUAL(1,RefCounter::s_instances);
+	va.clear();
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,ArrayStlVector)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+	
+	std::vector< array_ptr<RefCounter> > va,vb;
+	{
+		{
+			std::vector< array_ptr<RefCounter> > vc;
+			vc.push_back(new RefCounter[5]);
+			CHECK_EQUAL(5,RefCounter::s_instances);
+			vc.push_back(new RefCounter[3]);
+			CHECK_EQUAL(8,RefCounter::s_instances);
+			vc.push_back(new RefCounter[7]);
+			CHECK_EQUAL(15,RefCounter::s_instances);
+			vb = vc;
+			CHECK_EQUAL(15,RefCounter::s_instances);
+		}
+		CHECK_EQUAL(15,RefCounter::s_instances);
+		va.push_back(vb[0]);
+		CHECK_EQUAL(15,RefCounter::s_instances);
+		vb.clear();
+		CHECK_EQUAL(5,RefCounter::s_instances);
+	}
+	CHECK_EQUAL(5,RefCounter::s_instances);
+	va.clear();
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,StlList)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+	
+	std::list< ptr<RefCounter> > la,lb;
+	{
+		{
+			std::list< ptr<RefCounter> > lc;
+			lc.push_back(new RefCounter);
+			CHECK_EQUAL(1,RefCounter::s_instances);
+			lc.push_back(new RefCounter);
+			CHECK_EQUAL(2,RefCounter::s_instances);
+			lc.push_back(new RefCounter);
+			CHECK_EQUAL(3,RefCounter::s_instances);
+			lb = lc;
+			CHECK_EQUAL(3,RefCounter::s_instances);
+		}
+		CHECK_EQUAL(3,RefCounter::s_instances);
+		la.push_back(lb.front());
+		CHECK_EQUAL(3,RefCounter::s_instances);
+		lb.clear();
+		CHECK_EQUAL(1,RefCounter::s_instances);
+	}
+	CHECK_EQUAL(1,RefCounter::s_instances);
+	la.clear();
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,ArrayStlList)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+	
+	std::list< array_ptr<RefCounter> > la,lb;
+	{
+		{
+			std::list< array_ptr<RefCounter> > lc;
+			lc.push_back(new RefCounter[7]);
+			CHECK_EQUAL(7,RefCounter::s_instances);
+			lc.push_back(new RefCounter[8]);
+			CHECK_EQUAL(15,RefCounter::s_instances);
+			lc.push_back(new RefCounter[80]);
+			CHECK_EQUAL(95,RefCounter::s_instances);
+			lb = lc;
+			CHECK_EQUAL(95,RefCounter::s_instances);
+		}
+		CHECK_EQUAL(95,RefCounter::s_instances);
+		la.push_back(lb.front());
+		CHECK_EQUAL(95,RefCounter::s_instances);
+		lb.clear();
+		CHECK_EQUAL(7,RefCounter::s_instances);
+	}
+	CHECK_EQUAL(7,RefCounter::s_instances);
+	la.clear();
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,EqualityOperators)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+
+	RefCounter* xa = new RefCounter;
+	RefCounter* xb = new RefCounter;
+	ptr<RefCounter> pa,pb;
+	if ( xa < xb )
+	{
+		pa = xa;
+		pb = xb;
+	}
+	else
+	{
+		pa = xb;
+		pb = xa;
+	}
+	CHECK_EQUAL(2,RefCounter::s_instances);
+
+	CHECK(pa<pb);
+	CHECK(pb>pa);
+	CHECK(pa<=pa);
+	CHECK(pb>=pb);
+	CHECK(pa<=pa);
+	CHECK(pb>=pb);
+	CHECK(pa==pa);
+	CHECK(pb==pb);
+	CHECK(pa!=pb);
+
+	pa = 0;
+	CHECK_EQUAL(1,RefCounter::s_instances);
+	pb = 0;
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,ArrayEqualityOperators)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+
+	RefCounter* xa = new RefCounter[4];
+	RefCounter* xb = new RefCounter[6];
+	array_ptr<RefCounter> pa,pb;
+	if ( xa < xb )
+	{
+		pa = xa;
+		pb = xb;
+	}
+	else
+	{
+		pa = xb;
+		pb = xa;
+	}
+	CHECK_EQUAL(10,RefCounter::s_instances);
+
+	CHECK(pa<pb);
+	CHECK(pb>pa);
+	CHECK(pa<=pa);
+	CHECK(pb>=pb);
+	CHECK(pa<=pa);
+	CHECK(pb>=pb);
+	CHECK(pa==pa);
+	CHECK(pb==pb);
+	CHECK(pa!=pb);
+
+	pa = 0;
+	CHECK_EQUAL(6,RefCounter::s_instances);
+	pb = 0;
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,AccessPointer)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+
+	ptr<RefCounter> a = new RefCounter;
+	CHECK_EQUAL(1,RefCounter::s_instances);
+
+	CHECK_EQUAL(5,(*a).Get(5));
+	CHECK_EQUAL(5,a->Get(5));
+
+	a = 0;
+
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,ArrayAccessPointer)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+
+	array_ptr<RefCounter> a = new RefCounter[6];
+	CHECK_EQUAL(6,RefCounter::s_instances);
+
+	CHECK_EQUAL(5,(*a).Get(5));
+	CHECK_EQUAL(5,a->Get(5));
+	CHECK_EQUAL(5,a[0].Get(5));
+
+	a = 0;
+
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,BasicInheritance)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+
+	ptr<RefCounter> a = new RefCounterDerived;
+	CHECK_EQUAL(1,RefCounter::s_instances);
+
+	CHECK_EQUAL(10,(*a).Get(5));
+	CHECK_EQUAL(10,a->Get(5));
+
+	a = 0;
+
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,ArrayBasicInheritance)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+
+	array_ptr<RefCounter> a = new RefCounterDerived[2];
+	CHECK_EQUAL(2,RefCounter::s_instances);
+
+	CHECK_EQUAL(10,(*a).Get(5));
+	CHECK_EQUAL(10,a->Get(5));
+
+	a = 0;
+
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,ListOfBasePointers)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+
+	std::vector< ptr<RefCounter> > v;
+
+	v.push_back(new RefCounter);
+	CHECK_EQUAL(1,RefCounter::s_instances);
+
+	v.push_back(new RefCounterDerived);
+	CHECK_EQUAL(2,RefCounter::s_instances);
+
+	v.clear();
+
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,ArrayListOfBasePointers)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+
+	std::vector< array_ptr<RefCounter> > v;
+
+	v.push_back(new RefCounter[5]);
+	CHECK_EQUAL(5,RefCounter::s_instances);
+
+	v.push_back(new RefCounterDerived[2]);
+	CHECK_EQUAL(7,RefCounter::s_instances);
+
+	v.clear();
+
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,CopyInvalidPointers)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+
+	ptr<RefCounter> a;
+	CHECK_EQUAL(0,RefCounter::s_instances);
+	CHECK(!a.valid());
+	ptr<RefCounter> b(a);
+	CHECK(!a.valid());
+	CHECK(!b.valid());
+	CHECK_EQUAL(0,RefCounter::s_instances);
+	b = new RefCounter;
+	CHECK(!a.valid());
+	CHECK(b.valid());
+	CHECK_EQUAL(1,RefCounter::s_instances);
+	b = a;
+	CHECK(!a.valid());
+	CHECK(!b.valid());
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,ArrayCopyInvalidPointers)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+
+	array_ptr<RefCounter> a;
+	CHECK_EQUAL(0,RefCounter::s_instances);
+	CHECK(!a.valid());
+	array_ptr<RefCounter> b(a);
+	CHECK(!a.valid());
+	CHECK(!b.valid());
+	CHECK_EQUAL(0,RefCounter::s_instances);
+	b = new RefCounter[3];
+	CHECK(!a.valid());
+	CHECK(b.valid());
+	CHECK_EQUAL(3,RefCounter::s_instances);
+	b = a;
+	CHECK(!a.valid());
+	CHECK(!b.valid());
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,BoolValidityCheck)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+
+	{
+		ptr<RefCounter> a, b(new RefCounter), c;
+		CHECK_EQUAL(1,RefCounter::s_instances);
+		CHECK(!a);
+		CHECK(!a.valid());
+		CHECK(!c);
+		CHECK(!c.valid());
+		CHECK(b);
+		CHECK(b.valid());
+		CHECK(a || b || c);
+		a = b;
+		CHECK_EQUAL(1,RefCounter::s_instances);
+		CHECK(a);
+		CHECK(a.valid());
+		CHECK(b);
+		CHECK(b.valid());
+		CHECK(a || b);
+		CHECK(a && b);
+		b = 0;
+		CHECK_EQUAL(1,RefCounter::s_instances);
+		CHECK(a);
+		CHECK(a.valid());
+		CHECK(!b);
+		CHECK(!b.valid());
+
+		c = new RefCounterDerived;
+		CHECK_EQUAL(2,RefCounter::s_instances);
+		CHECK(c);
+		CHECK(c.valid());
+	}
+
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,ArrayBoolValidityCheck)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+
+	{
+		array_ptr<RefCounter> a, b(new RefCounter[1]), c;
+		CHECK_EQUAL(1,RefCounter::s_instances);
+		CHECK(!a);
+		CHECK(!a.valid());
+		CHECK(!c);
+		CHECK(!c.valid());
+		CHECK(b);
+		CHECK(b.valid());
+		CHECK(a || b || c);
+		a = b;
+		CHECK_EQUAL(1,RefCounter::s_instances);
+		CHECK(a);
+		CHECK(a.valid());
+		CHECK(b);
+		CHECK(b.valid());
+		CHECK(a || b);
+		CHECK(a && b);
+		b = 0;
+		CHECK_EQUAL(1,RefCounter::s_instances);
+		CHECK(a);
+		CHECK(a.valid());
+		CHECK(!b);
+		CHECK(!b.valid());
+
+		c = new RefCounterDerived[1];
+		CHECK_EQUAL(2,RefCounter::s_instances);
+		CHECK(c);
+		CHECK(c.valid());
+	}
+
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,MapMadness)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+	{
+		std::map< ptr<RefCounter>, ptr<RefCounter> > m,m1,m2,m3,m4;
+		CHECK_EQUAL(0,RefCounter::s_instances);
+
+		for (int i=0;i<1000;++i)
+		{
+			m[ new RefCounter ] = new RefCounterDerived;
+			CHECK_EQUAL((i+1)*2,RefCounter::s_instances);
+		}
+
+		m1 = m2 = m3 = m4 = m;
+		CHECK_EQUAL(2000,RefCounter::s_instances);
+		m.clear();
+		CHECK_EQUAL(2000,RefCounter::s_instances);
+		m2.clear();
+		CHECK_EQUAL(2000,RefCounter::s_instances);
+		m3.clear();
+		CHECK_EQUAL(2000,RefCounter::s_instances);
+		m4.clear();
+		CHECK_EQUAL(2000,RefCounter::s_instances);
+	}
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,ArrayMapMadness)
+{
+	CHECK_EQUAL(0,RefCounter::s_instances);
+	{
+		std::map< array_ptr<RefCounter>, array_ptr<RefCounter> > m,m1,m2,m3,m4;
+		CHECK_EQUAL(0,RefCounter::s_instances);
+
+		for (int i=0;i<1000;++i)
+		{
+			m[ new RefCounter[2] ] = new RefCounterDerived[2];
+			CHECK_EQUAL((i+1)*4,RefCounter::s_instances);
+		}
+
+		m1 = m2 = m3 = m4 = m;
+		CHECK_EQUAL(4000,RefCounter::s_instances);
+		m.clear();
+		CHECK_EQUAL(4000,RefCounter::s_instances);
+		m2.clear();
+		CHECK_EQUAL(4000,RefCounter::s_instances);
+		m3.clear();
+		CHECK_EQUAL(4000,RefCounter::s_instances);
+		m4.clear();
+		CHECK_EQUAL(4000,RefCounter::s_instances);
+	}
+	CHECK_EQUAL(0,RefCounter::s_instances);
+}
+
+///////////////////////////////////
+
+TEST_FIXTURE(InstanceFixture,ArrayIndexing)
+{
+	int* p = new int[10];
+	for (int i=0;i<10;++i)
+	{
+		p[i] = i;
+	}
+	array_ptr<int> q = p;
+	for (int i=0;i<10;++i)
+	{
+		CHECK_EQUAL(i,q[i]);
+		CHECK_EQUAL(&(p[i]),&(q[i]));
+	}
+}
+
+///////////////////////////////////
+
+
+int main(int argc, char** argv)
+{
+	return UnitTest::RunAllTests();
+}
+