more tests and other changes

- ported complete suite of boost::any tests
- improved reference casting
- added swap in SOO version

Foundation/testsuite/src/AnyTest.cpp

@@ -70,6 +70,156 @@ AnyTest::~AnyTest()
 }
 
 
+void AnyTest::testDefaultCtor()
+{
+	const Any value;
+	
+	assert (value.empty());
+	assert (0 == AnyCast<int>(&value));
+	assert (value.type() == typeid(void));
+}
+
+
+void AnyTest::testConvertingCtor()
+{
+	std::string text = "test message";
+	Any value = text;
+	
+	assert (!value.empty());
+	assert (value.type() == typeid(std::string));
+	assert (0 == AnyCast<int>(&value));
+	assert (0 != AnyCast<std::string>(&value));
+	assert (AnyCast<std::string>(value) == text);
+	assert (AnyCast<std::string>(&value) != &text);
+}
+
+
+void AnyTest::testCopyCtor()
+{
+	std::string text = "test message";
+	Any original = text, copy = original;
+	
+	assert (!copy.empty());
+	assert (original.type() == copy.type());
+	assert (AnyCast<std::string>(original) == AnyCast<std::string>(copy));
+	assert (text == AnyCast<std::string>(copy));
+	assert(AnyCast<std::string>(&original) != AnyCast<std::string>(&copy));
+}
+
+
+void AnyTest::testCopyAssign()
+{
+	std::string text = "test message";
+	Any original = text, copy;
+	Any* assignResult = &(copy = original);
+	
+	assert(!copy.empty());
+	assert(original.type() == copy.type());
+	assert(AnyCast<std::string>(original) == AnyCast<std::string>(copy));
+	assert(text == AnyCast<std::string>(copy));
+	assert(AnyCast<std::string>(&original) != AnyCast<std::string>(&copy));
+	assert(assignResult == &copy);
+}
+
+
+void AnyTest::testConvertingAssign()
+{
+	std::string text = "test message";
+	Any value;
+	Any* assignResult = &(value = text);
+	
+	assert (!value.empty());
+	assert(value.type() == typeid(std::string));
+	assert(0 == AnyCast<int>(&value));
+	assert(0 != AnyCast<std::string>(&value));
+	assert(AnyCast<std::string>(value) == text);
+	assert(AnyCast<std::string>(&value) != &text);
+	assert(assignResult == &value);
+}
+
+
+void AnyTest::testCastToReference()
+{
+	Any a(137);
+	const Any b(a);
+	
+	int&                ra    = AnyCast<int &>(a);
+	int const&          ra_c  = AnyCast<int const &>(a);
+	int volatile&       ra_v  = AnyCast<int volatile &>(a);
+	int const volatile& ra_cv = AnyCast<int const volatile&>(a);
+	
+	// cv references to same obj
+	assert (&ra == &ra_c && &ra == &ra_v && &ra == &ra_cv);
+	
+	int const &          rb_c  = AnyCast<int const &>(b);
+	int const volatile & rb_cv = AnyCast<int const volatile &>(b);
+
+	assert (&rb_c == &rb_cv); // cv references to copied const obj
+	assert (&ra != &rb_c); // copies hold different objects
+	
+	++ra;
+	int incremented = AnyCast<int>(a);
+	assert (incremented == 138); // increment by reference changes value
+
+	try
+	{
+		AnyCast<char &>(a);
+		failmsg ("AnyCast to incorrect reference type");
+	}
+	catch (BadCastException&) { }
+
+	try
+	{
+		AnyCast<const char &>(b),
+		failmsg ("AnyCast to incorrect const reference type");
+	}
+	catch (BadCastException&) { }
+}
+
+
+void AnyTest::testBadCast()
+{
+	std::string text = "test message";
+	Any value = text;
+	
+	try
+	{
+		AnyCast<const char *>(value);
+		fail ("must throw");
+	}
+	catch (BadCastException&) { }
+}
+
+
+void AnyTest::testSwap()
+{
+	std::string text = "test message";
+	Any original = text, swapped;
+	std::string* originalPtr = AnyCast<std::string>(&original);
+	Any* swapResult = &original.swap(swapped);
+	
+	assert (original.empty());
+	assert (!swapped.empty());
+	assert (swapped.type() == typeid(std::string));
+	assert (text == AnyCast<std::string>(swapped));
+	assert (0 != originalPtr);
+	assert (originalPtr == AnyCast<std::string>(&swapped));
+	assert (swapResult == &original);
+}
+
+
+void AnyTest::testEmptyCopy()
+{
+	const Any null;
+	Any copied = null, assigned;
+	assigned = null;
+	
+	assert (null.empty());
+	assert (copied.empty());
+	assert (assigned.empty());
+}
+
+
 void AnyTest::testInt()
 {
 	Any e;
@@ -119,8 +269,13 @@ void AnyTest::testVector()
 	Any a = tmp;
 	assert (a.type() == typeid(std::vector<int>));
 	std::vector<int> tmp2 = AnyCast<std::vector<int> >(a);
+	assert (tmp2.size() == 3);
 	const std::vector<int>& vecCRef = RefAnyCast<std::vector<int> >(a);
 	std::vector<int>& vecRef = RefAnyCast<std::vector<int> >(a);
+	
+	assert (vecRef[0] == 1);
+	assert (vecRef[1] == 2);
+	assert (vecRef[2] == 3);
 	vecRef[0] = 0;
 	assert (vecRef[0] == vecCRef[0]);
 }
@@ -140,6 +295,15 @@ CppUnit::Test* AnyTest::suite()
 {
 	CppUnit::TestSuite* pSuite = new CppUnit::TestSuite("AnyTest");
 
+	CppUnit_addTest(pSuite, AnyTest, testConvertingCtor);
+	CppUnit_addTest(pSuite, AnyTest, testDefaultCtor);
+	CppUnit_addTest(pSuite, AnyTest, testCopyCtor);
+	CppUnit_addTest(pSuite, AnyTest, testCopyAssign);
+	CppUnit_addTest(pSuite, AnyTest, testConvertingAssign);
+	CppUnit_addTest(pSuite, AnyTest, testBadCast);
+	CppUnit_addTest(pSuite, AnyTest, testSwap);
+	CppUnit_addTest(pSuite, AnyTest, testEmptyCopy);
+	CppUnit_addTest(pSuite, AnyTest, testCastToReference);
 	CppUnit_addTest(pSuite, AnyTest, testInt);
 	CppUnit_addTest(pSuite, AnyTest, testComplexType);
 	CppUnit_addTest(pSuite, AnyTest, testVector);