--- a/persistentstorage/store/TSTRM/t_storswizzle.cpp	Mon Sep 27 11:59:56 2010 +0100
+++ b/persistentstorage/store/TSTRM/t_storswizzle.cpp	Tue Oct 19 16:26:13 2010 +0100
@@ -26,7 +26,7 @@
 	{
 	if(!aValue)
 		{
-		RDebug::Print(_L("*** Boolean expression evaluated to false.\r\n"));
+		TheTest.Printf(_L("*** Expression evaluated to false.\r\n"));
 		TheTest(EFalse, aLine);
 		}
 	}
@@ -34,7 +34,7 @@
 	{
 	if(aValue != aExpected)
 		{
-		RDebug::Print(_L("*** Expected error: %d, got: %d.\r\n"), aExpected, aValue);
+		TheTest.Printf(_L("*** Expected error: %d, got: %d.\r\n"), aExpected, aValue);
 		TheTest(EFalse, aLine);
 		}
 	}
@@ -89,6 +89,46 @@
 	iHeight = a;
 	}
 
+class TRectangleExternalizer : public MExternalizer<TRectangle>
+	{
+public:
+	virtual void ExternalizeL(const TRectangle& aObject, RWriteStream& aStream) const;
+	};
+
+void TRectangleExternalizer::ExternalizeL(const TRectangle& aObject, RWriteStream& aStream) const
+	{
+	aStream << aObject;
+	}
+
+class TRectangleInternalizer : public MInternalizer<TRectangle>
+	{
+public:
+	virtual void InternalizeL(TRectangle& aObject, RReadStream& aStream) const;
+	};
+
+void TRectangleInternalizer::InternalizeL(TRectangle& aObject, RReadStream& aStream) const
+	{
+	aStream >> aObject;
+	}
+
+void RectangleExternalizeL(const TAny* aPtr, RWriteStream& aStream)
+	{
+	TRectangle* rcPtr = (TRectangle*)aPtr;
+	rcPtr->ExternalizeL(aStream);
+	}
+
+class TStreamRefExternalizer : public MExternalizer<TStreamRef>
+	{
+public:
+	virtual void ExternalizeL(const TStreamRef& aObject, RWriteStream& aStream) const;
+	};
+
+void TStreamRefExternalizer::ExternalizeL(const TStreamRef& aObject, RWriteStream& aStream) const
+	{
+	TExternalizeFunction func = aObject.Function();
+	(*func)(aObject.Ptr(), aStream);
+	}
+
 ///////////////////////////////////////////////////////////////////////////////////////
 
 /**
@@ -105,6 +145,20 @@
 	const TInt KWidth = 10;
 	const TInt KHeight = 20;
 	TRectangle r1(KWidth, KHeight);
+
+	const TInt KWidth2 = 6;
+	const TInt KHeight2 = 17;
+	TRectangle r2(KWidth2, KHeight2);
+	
+	const TInt KWidth3 = 19;
+	const TInt KHeight3 = 5;
+	TRectangle r3(KWidth3, KHeight3);
+
+	const TInt KWidth4 = 22;
+	const TInt KHeight4 = 19;
+	TRectangle r4(KWidth4, KHeight4);
+	
+	//Externalize r1 using RStoreWriteStream directly 
 	RStoreWriteStream wstrm1;
 	TStreamId strmId1 = wstrm1.CreateLC(*bufStore);
 	TSwizzleC<TRectangle> swizzle1(&r1);
@@ -112,28 +166,91 @@
 	wstrm1 << *swizzle1;
 	wstrm1.CommitL();
 	CleanupStack::PopAndDestroy(&wstrm1);
+
+	//Externalize r2 using TRectangleExternalizer 
+	RStoreWriteStream wstrm2;
+	TStreamId strmId2 = wstrm2.CreateLC(*bufStore);
+	TSwizzleC<TRectangle> swizzle2(&r2);
+	TEST((const void*)swizzle2 == (const void*)&r2);
+	TRectangleExternalizer rcExternalizer2;
+	rcExternalizer2(*swizzle2, wstrm2);
+	wstrm2.CommitL();
+	CleanupStack::PopAndDestroy(&wstrm2);
+
+	//Externalize r3 using TExternalizer<TRectangle> 
+	RStoreWriteStream wstrm3;
+	TStreamId strmId3 = wstrm3.CreateLC(*bufStore);
+	TSwizzleC<TRectangle> swizzle3(&r3);
+	TEST((const void*)swizzle3 == (const void*)&r3);
+	TExternalizer<TRectangle> rcExternalizer3;
+	rcExternalizer3(*swizzle3, wstrm3);
+	wstrm3.CommitL();
+	CleanupStack::PopAndDestroy(&wstrm3);
 	
-	TRectangle r2;
+	//Externalize r4 using TSwizzleC::ExternalizeL()
+	TStreamRefExternalizer rcExternalizer4;
+	RStoreWriteStream wstrm4(rcExternalizer4);
+	TStreamId strmId4 = wstrm4.CreateLC(*bufStore);
+	TSwizzleC<TRectangle> swizzle4(&r4);
+	TEST((const void*)swizzle4 == (const void*)&r4);
+	swizzle4.ExternalizeL(wstrm4);
+	wstrm4.CommitL();
+	CleanupStack::PopAndDestroy(&wstrm4);
+	
+	//Internalize r1 using RStoreReadStream directly 
+	TRectangle r1in;
 	RStoreReadStream rstrm1;
 	rstrm1.OpenLC(*bufStore, strmId1);
-	rstrm1 >> r2;
+	rstrm1 >> r1in;
 	CleanupStack::PopAndDestroy(&rstrm1);
-	
-	TEST(r1 == r2);
+	TEST(r1 == r1in);
+
+	//Internalize r2 using TRectangleInternalizer
+	TRectangle r2in;
+	TSwizzle<TRectangle> swizzle2in(&r2in);
+	RStoreReadStream rstrm2;
+	rstrm2.OpenLC(*bufStore, strmId2);
+	TRectangleInternalizer rcInternalizer2;
+	rcInternalizer2(*swizzle2in, rstrm2);
+	CleanupStack::PopAndDestroy(&rstrm2);
+	TEST(r2 == r2in);
+	TEST(*swizzle2 == *swizzle2in);
+
+	//Internalize r3 using TInternalizer<TRectangle>
+	TRectangle r3in;
+	TSwizzle<TRectangle> swizzle3in(&r3in);
+	RStoreReadStream rstrm3;
+	rstrm3.OpenLC(*bufStore, strmId3);
+	TInternalizer<TRectangle> rcInternalizer3;
+	rcInternalizer3(*swizzle3in, rstrm3);
+	CleanupStack::PopAndDestroy(&rstrm3);
+	TEST(r3 == r3in);
+	TEST(*swizzle3 == *swizzle3in);
+
+	//Internalize r4
+	TSwizzle<TRectangle> swizzle4in(strmId4);
+	TEST(swizzle4in.IsId());
+	RStoreReadStream rstrm4;
+	rstrm4.OpenLC(*bufStore, swizzle4in.AsId());
+	TRectangle r4in;
+	rstrm4 >> r4in;
+	CleanupStack::PopAndDestroy(&rstrm4);
+	TEST(r4 == r4in);
 	
 	CleanupStack::PopAndDestroy(bufStore);
-	
-	TSwizzleC<TRectangle> swizzle2(swizzle1);
-	TEST(swizzle1->iWidth == swizzle2->iWidth);
-	TEST(swizzle1->iHeight == swizzle2->iHeight);
-	TEST(swizzle1.AsPtr()->iHeight == swizzle2.AsPtr()->iHeight);
+
+	//TSwizzleC copy constructor test
+	TSwizzleC<TRectangle> swizzle1copy(swizzle1);
+	TEST(swizzle1->iWidth == swizzle1copy->iWidth);
+	TEST(swizzle1->iHeight == swizzle1copy->iHeight);
+	TEST(swizzle1.AsPtr()->iHeight == swizzle1copy.AsPtr()->iHeight);
 
-	
-	TSwizzleC<TRectangle> swizzle3;
-	swizzle3 = &r2;
-	TEST(swizzle1->iWidth == swizzle3->iWidth);
-	TEST(swizzle1->iHeight == swizzle3->iHeight);
-	TEST(swizzle1.AsPtr()->iHeight == swizzle3.AsPtr()->iHeight);
+	//TSwizzleC assignment operator test
+	TSwizzleC<TRectangle> swizzle1assign;
+	swizzle1assign = &r1in;
+	TEST(swizzle1->iWidth == swizzle1assign->iWidth);
+	TEST(swizzle1->iHeight == swizzle1assign->iHeight);
+	TEST(swizzle1.AsPtr()->iHeight == swizzle1assign.AsPtr()->iHeight);
 	}
 
 /**