diff -r c55016431358 -r 0a7b44b10206 symport/e32test/buffer/t_regn.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/e32test/buffer/t_regn.cpp	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,820 @@
+// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// e32test\buffer\t_regn.cpp
+// Overview:
+// Test fixed and variable clipping regions.
+// API Information:
+// TRegionFix, RRegion .
+// Details:
+// - Construct some expandable clipping regions, add some rectangles, check the region 
+// matches the rectangles, clear the region, add some rectangles to the region and 
+// check the region matches the rectangles.
+// - Copy one region to another, using the Copy method and the copy constructor,
+// and check the region matches the rectangles.
+// - Create a some fixed clipping regions, add some rectangles, check the region
+// matches the rectangles, clear the region, add some rectangles, and check the
+// region matches the rectangles.
+// - Copy one fixed region to another, using the Copy method and the copy constructor,
+// and check the region matches the rectangles.
+// - Test TRegionFix creation and error handling using Clear, Count, AddRect, CheckError
+// and Tidy methods
+// - Test adding rectangles, via AddRect, to an RRegion object. Verify the results 
+// via the Count, BoundingRect and IsEmpty methods.
+// - Test subtracting rectangles, via SubRect, from an RRegion object. Verify the 
+// results via the Count, BoundingRect and SubRegion methods.
+// - Test subtracting regions, via AddRect and SubRegion, from an RRegion object. 
+// Verify the results via the Count, BoundingRect, Clear, Copy, and SubRect methods.
+// - Test the RRegion Tidy method. Verify the results via the Count, AddRect, 
+// BoundingRect and Clear methods.
+// - Test the RRegion CheckSpare method. Verify the results via the AddRect, Tidy,
+// Clear and SubRect methods.
+// - Test the RRegion Offset method. Verify the results via the AddRect, Move,
+// Clear, IsEmpty and RectangleList methods.
+// - Test the RRegion Intersection and Intersect methods. Verify the results via 
+// the AddRect, Count, IsEmpty and RectangleList methods.
+// - Test the RRegion Union method. Verify the results via the AddRect, Count,
+// Copy, Offset and BoundingRect methods.
+// - Test the RRegion ClipRect method. Verify the results via the AddRect, Count,
+// and BoundingRect methods.
+// - Test the RRegion and TRgionFix Contains methods. Verify the results via the 
+// AddRect method.
+// - Test the RRegion ForceError and CheckError methods. Verify the results via the 
+// AddRect, Copy, Count, SubRect, Clear and BoundingRect methods.
+// - Test the RRegion  and RRegionBuf sort method.
+// - Construct some regions with pre-allocated buffer (RRegionBuf), add some rectangles, 
+// get a pointer to the array of rectangles defining this region and check the 
+// rectangles are as expected.
+// Platforms/Drives/Compatibility:
+// All 
+// Assumptions/Requirement/Pre-requisites:
+// Failures and causes:
+// Base Port information:
+// 
+//
+
+#include <e32test.h>
+
+LOCAL_D RTest test(_L("T_REGN"));
+
+class TestRRegion
+	{
+public:
+	TestRRegion(TInt tlx, TInt tly, TInt brx, TInt bry);
+	void TestSet();
+	void TestRegionFix();
+	void TestAddRect();
+	void TestSubRect();
+	void TestSubRegion();
+	void TestTidy();
+	void TestSpare();
+	void TestOffset();
+	void TestIntersection();
+	void TestUnion();
+	void TestClipRect();
+	void TestContains();
+	void TestIntersects();
+	void TestErrors();
+	void doTestSort(RRegion &aRegion);
+	void TestSort();
+	void doTestRegionBuf(RRegion &aRegion);
+	void TestRegionBuf();
+private:
+	void DoTestSet(TRegion** rgn,TInt rgnArraySize);
+	void CheckRectRegion(const TRegion& region,const TRect& rect);
+private:
+	TRect rect[4];
+	TRect bounds;
+	TRect xrect;
+	};
+
+// Region test code
+TestRRegion::TestRRegion(TInt tlx, TInt tly, TInt brx, TInt bry)
+	{
+	rect[0]=TRect( tlx, tly, brx, bry);
+	rect[1]=TRect(-brx,-bry,-tlx,-tly);
+	rect[2]=TRect( tlx,-bry, brx,-tly);
+	rect[3]=TRect(-brx, tly,-tlx, bry);
+	bounds=TRect(-brx,-bry,brx,bry);
+	xrect=TRect(-(tlx/2+brx/2),-(tly/2+bry/2),tlx/2+brx/2,tly/2+bry/2);
+	}
+
+void TestRRegion::CheckRectRegion(const TRegion& region,const TRect& rect)
+// Check the region matches the rectangle
+	{
+	const TRect* rlist;
+
+	if (rect.IsEmpty())
+		test(region.Count()==0);
+	else
+		{
+		test(region.Count()==1);
+		rlist=region.RectangleList();
+		test(rlist[0]==rect);
+		test(region[0]==rect);
+		}
+	}
+
+void TestRRegion::DoTestSet(TRegion** rgn,TInt rgnArraySize)
+	{
+	TInt index; 
+	for(index=0;index<rgnArraySize;index++)
+		rgn[index]->AddRect(rect[index]);
+	for(index=0;index<rgnArraySize;index++)
+		CheckRectRegion(*rgn[index],rect[index]);
+	for(index=0;index<rgnArraySize;index++)
+		{
+		rgn[index]->Clear();
+		rgn[index]->AddRect(rect[index]);
+		}
+	for(index=0;index<rgnArraySize;index++)
+		CheckRectRegion(*rgn[index],rect[index]);
+	}
+
+void TestRRegion::TestSet()
+	{
+	TUint index; 
+
+	RRegion xrgn(rect[0]);
+	CheckRectRegion(xrgn,rect[0]);
+	xrgn.Close();
+//
+	RRegion rgn[5];
+	TRegion* prgn[5]={&rgn[0],&rgn[1],&rgn[2],&rgn[3],&rgn[4]};
+	DoTestSet(&prgn[0],(sizeof(rgn)/sizeof(rgn[0])));
+	for(index=0;index<(sizeof(rgn)/sizeof(rgn[0]));index++)
+		{
+		RRegion rgn1;
+		rgn1.Copy(rgn[index]);
+		CheckRectRegion(rgn1,rect[index]);
+		RRegion rgn2(rgn[index]);
+		CheckRectRegion(rgn2,rect[index]);
+		rgn[index].Close();
+		rgn1.Close();
+		}
+//
+	TRegionFix<5> rgnf[5];
+	TRegion* prgnf[5]={&rgnf[0],&rgnf[1],&rgnf[2],&rgnf[3],&rgnf[4]};
+	DoTestSet(&prgnf[0],(sizeof(rgnf)/sizeof(rgnf[0])));
+	for(index=0;index<(sizeof(rgn)/sizeof(rgn[0]));index++)
+		{
+		TRegionFix<5> rgn1;
+		rgn1.Copy(rgnf[index]);
+		CheckRectRegion(rgn1,rect[index]);
+		TRegionFix<5> rgn2(rgnf[index]);
+		CheckRectRegion(rgn2,rect[index]);
+		}
+	}
+
+void TestRRegion::TestRegionFix()
+//
+// Test TRegionFix creation and error handling
+//
+	{
+	TRegionFix<1> rgnf(rect[0]);
+	CheckRectRegion(rgnf,rect[0]);
+	rgnf.Clear();
+	test(rgnf.Count()==0);
+	rgnf.AddRect(TRect(0,0,2,2));
+	test(rgnf.CheckError()==FALSE);
+	rgnf.AddRect(TRect(2,2,4,4));	// Should cause error, rgnf can only hold 1 rectangle
+	test(rgnf.CheckError()==TRUE && rgnf.Count()==0);
+	rgnf.Clear();
+	test(rgnf.CheckError()==FALSE && rgnf.Count()==0);
+//
+	TRegionFix<10> rgnf2;
+	TInt index;
+	for(index=0;index<10;index++)
+		{
+		rgnf2.AddRect(TRect(index*4,0,index*4+2,10));
+		test(rgnf2.Count()==(index+1));
+		TRegionFix<10> rgnf4(rgnf2);	// Test copy constructor
+		TRegionFix<10> rgnf5;
+		rgnf5=rgnf2;					// Test assignment
+		test(rgnf4.Count()==(index+1));
+		for(TInt index2=0;index2<=index;index2++)
+			test(rgnf2[index2]==rgnf4[index2] && rgnf2[index2]==rgnf5[index2]);
+		}
+	rgnf2.AddRect(TRect(-10,-10,0,0));	// Should push it over the edge
+	test(rgnf2.CheckError()==TRUE && rgnf2.Count()==0);
+//
+	TRegionFix<5> rgnf3;
+	for(index=0;index<4;index++)
+		{
+		rgnf3.AddRect(TRect(index*4,index*4,index*4+8,index*4+8));
+		if (index==3)
+			test(rgnf3.CheckError()==TRUE);
+		else
+			{			
+			rgnf3.Tidy();
+			if (index>0)
+				test(rgnf3.Count()==(index+2));
+			}
+		}
+	}
+
+void TestRRegion::TestAddRect()
+	{
+	RRegion rgn;
+	TInt index,i;
+
+	if (!rect[0].IsEmpty())
+		{
+		for(index=0;index<4;index++)
+			{
+			for(i=0;i<=index;i++)
+				rgn.AddRect(rect[index]);
+			test(rgn.Count()==(index+1));
+			}
+		test(rgn.BoundingRect()==bounds);
+		if (!xrect.IsEmpty())
+			{
+			rgn.AddRect(xrect);
+			test(rgn.Count()==7);
+			}
+		}
+	rgn.AddRect(bounds);
+	test(rgn.Count()==1);
+	rgn.Close();
+	}
+
+void TestRRegion::TestSubRect()
+	{
+	TRect rect1(-rect[0].iBr.iX,-rect[0].iBr.iY,rect[0].iBr.iX,rect[0].iBr.iY);
+	RRegion rgn;
+	RRegion subRgn;
+	RRegion rgn2;
+	TInt index;
+
+	if (!rect[0].IsEmpty())
+		{
+		rgn.AddRect(rect1);
+		for(index=0;index<4;index++)
+			rgn.SubRect(rect[index],&subRgn);
+		if (rect[0].iTl.iX==0)	// Special case region, all rects join in the middle
+			{
+			test(rgn.Count()==0);
+			test(subRgn.Count()==4);
+			}
+		else
+			{
+			test(rgn.Count()==3);
+			test(subRgn.Count()==4);
+			test(rgn.BoundingRect()==subRgn.BoundingRect());
+			rgn.SubRect(xrect);
+			test(rgn.Count()==4);
+			rgn2.Copy(rgn);
+			subRgn.Clear();
+			rgn.SubRect(rgn.BoundingRect(),&subRgn);
+			test(rgn.Count()==0);
+			rgn2.SubRegion(subRgn,&rgn);
+			test(rgn2.Count()==0);
+			subRgn.SubRegion(rgn);
+			test(subRgn.Count()==0);
+			}
+		}
+	rgn.Close();
+	rgn2.Close();
+	subRgn.Close();
+	}
+
+void TestRRegion::TestSubRegion()
+	{
+	TRect rect1(-rect[0].iBr.iX,-rect[0].iBr.iY,rect[0].iBr.iX,rect[0].iBr.iY);
+	RRegion rgn,subRgn;
+	RRegion rgn2;
+	TInt index;
+
+	if (!rect[0].IsEmpty())
+		{
+		rgn.AddRect(rect1);
+		for(index=0;index<4;index++)
+			rgn2.AddRect(rect[index]);
+		rgn.SubRegion(rgn2,&subRgn);
+		if (rect[0].iTl.iX==0)	// Special case region, all rects join in the middle
+			{
+			test(rgn.Count()==0);
+			test(subRgn.Count()==4);
+			}
+		else
+			{
+			test(rgn.Count()==3);
+			test(subRgn.Count()==4);
+			test(rgn.BoundingRect()==subRgn.BoundingRect());
+			rgn2.Clear();
+			rgn2.AddRect(xrect);
+			rgn.SubRegion(rgn2);
+			test(rgn.Count()==4);
+			rgn2.Copy(rgn);
+			subRgn.Clear();
+			rgn.SubRect(rgn.BoundingRect(),&subRgn);
+			test(rgn.Count()==0);
+			rgn2.SubRegion(subRgn,&rgn);
+			test(rgn2.Count()==0);
+			subRgn.SubRegion(rgn);
+			test(subRgn.Count()==0);
+			}
+		}
+	rgn.Close();
+	rgn2.Close();
+	subRgn.Close();
+	}
+
+void TestRRegion::TestTidy()
+	{
+	RRegion rgn;
+	TInt loop;
+	TRect const rlist[8]={	// 8 Rectangles that form a square with the centre rectangle missing
+		TRect(10,10,20,20),
+		TRect(20,10,30,20),
+		TRect(30,10,40,20),
+
+		TRect(10,20,20,30),
+		TRect(30,20,40,30),
+
+		TRect(10,30,20,40),
+		TRect(20,30,30,40),
+		TRect(30,30,40,40)};
+	TRect const rect1(rlist[0].iTl.iX,rlist[0].iTl.iY,rlist[2].iBr.iX,rlist[2].iBr.iY);
+	TRect const rect2(rlist[0].iTl.iX,rlist[0].iTl.iY,rlist[7].iBr.iX,rlist[7].iBr.iY);
+
+// Add 3 adjoining rectangles and tidy them
+	for(loop=0;loop<3;loop++)
+		rgn.AddRect(rlist[loop]);
+	test(rgn.Count()==3);
+	rgn.Tidy();
+	test(rgn.Count()==1);
+	test(rgn[0]==rect1);
+// Same again but add the adjoining rectangles in reverse order
+	rgn.Clear();
+	for(loop=2;loop>=0;loop--)
+		rgn.AddRect(rlist[loop]);
+	test(rgn.Count()==3);
+	rgn.Tidy();
+	test(rgn.Count()==1);
+	test(rgn[0]==rect1);
+// Now add 8 rectangles that should tidy down to 4
+	rgn.Clear();
+	for(loop=0;loop<8;loop++)
+		rgn.AddRect(rlist[loop]);
+	test(rgn.Count()==8);
+	rgn.Tidy();
+	test(rgn.Count()==4);
+	test(rgn.BoundingRect()==rect2);
+// ...and in reverse
+	rgn.Clear();
+	for(loop=7;loop>=0;loop--)
+		rgn.AddRect(rlist[loop]);
+	test(rgn.Count()==8);
+	rgn.Tidy();
+	test(rgn.Count()==4);
+	test(rgn.BoundingRect()==rect2);
+	rgn.Close();
+	}
+
+void TestRRegion::TestSpare()
+	{
+	TInt gran[5]={1,2,4,20,100};
+	RRegion rgn[5]={gran[0],gran[1],gran[2],gran[3],gran[4]};
+    TUint index;
+	TInt loop,spare;
+	TRect rect1(0,0,1,1);
+	TRect rect;
+
+	for(index=0;index<(sizeof(rgn)/sizeof(rgn[0]));index++)
+		{
+		test(rgn[index].CheckSpare()==0);
+		rgn[index].AddRect(rect1);
+		test(rgn[index].CheckSpare()==(gran[index]-1));
+		rgn[index].Tidy();
+		test(rgn[index].CheckSpare()==0);
+		rgn[index].Clear();
+		test(rgn[index].CheckSpare()==0);
+		}
+	for(index=0;index<(sizeof(rgn)/sizeof(rgn[0]));index++)
+		{
+		spare=0;
+		for(loop=0;loop<30;loop++)
+			{
+			rect.iTl.iX=rect.iTl.iY=loop;
+			rect.iBr.iX=rect.iBr.iY=loop+1;
+			rgn[index].AddRect(rect);
+			if (spare==0)
+				spare=gran[index];
+			spare--;
+			test(rgn[index].CheckSpare()==spare);
+			}
+		do
+			{
+			loop--;
+			rect.iTl.iX=rect.iTl.iY=loop;
+			rect.iBr.iX=rect.iBr.iY=loop+1;
+			rgn[index].SubRect(rect);
+			spare++;
+			test(rgn[index].CheckSpare()==spare);
+			} while(loop>0);
+		}
+	for(index=0;index<(sizeof(rgn)/sizeof(rgn[0]));index++)
+		rgn[index].Close();
+	}
+
+void TestRRegion::TestOffset()
+	{
+	RRegion rgn;
+	const TRect* rlist;
+	TRect r;
+	TUint index;
+
+	for(index=0;index<(sizeof(rect)/sizeof(rect[0]));index++)
+		{
+		rgn.Clear();
+		rgn.AddRect(rect[index]);
+		r=rect[index];
+		r.Move(1,1);
+		rgn.Offset(1,1);
+		if (rect[index].IsEmpty())
+			test(rgn.Count()==0);
+		else
+			{
+			test(rgn.Count()==1);
+			rlist=rgn.RectangleList();
+			test(rlist[0]==r);
+			}
+		}
+	rgn.Close();
+	}
+
+void TestRRegion::TestIntersection()
+	{
+	RRegion rgn1,rgn2,tmp_rgn;
+	const TRect* rlist;
+	TUint index;
+
+	rgn1.AddRect(xrect);
+	rgn2.Copy(rgn1);
+	if (!rgn1.IsEmpty())
+		{
+		for(index=0;index<(sizeof(rect)/sizeof(rect[0]));index++)
+			tmp_rgn.AddRect(rect[index]);
+		rgn2.Intersection(rgn1,tmp_rgn);
+		test(rgn2.Count()==4);
+		rlist=rgn2.RectangleList();
+		for(index=0;index<(TUint)rgn2.Count();index++)
+			{
+			test(rlist[index].iTl.iX==xrect.iTl.iX || rlist[index].iTl.iX==rect[0].iTl.iX);
+			test(rlist[index].iTl.iY==xrect.iTl.iY || rlist[index].iTl.iY==rect[0].iTl.iY);
+			test(rlist[index].iBr.iX==xrect.iBr.iX || rlist[index].iBr.iX==(-rect[0].iTl.iX));
+			test(rlist[index].iBr.iY==xrect.iBr.iY || rlist[index].iBr.iY==(-rect[0].iTl.iY));
+			}
+		rgn1.Intersect(tmp_rgn);
+		test(rgn1.Count()==4);
+		rlist=rgn1.RectangleList();
+		for(index=0;index<(TUint)rgn1.Count();index++)
+			{
+			test(rlist[index].iTl.iX==xrect.iTl.iX || rlist[index].iTl.iX==rect[0].iTl.iX);
+			test(rlist[index].iTl.iY==xrect.iTl.iY || rlist[index].iTl.iY==rect[0].iTl.iY);
+			test(rlist[index].iBr.iX==xrect.iBr.iX || rlist[index].iBr.iX==(-rect[0].iTl.iX));
+			test(rlist[index].iBr.iY==xrect.iBr.iY || rlist[index].iBr.iY==(-rect[0].iTl.iY));
+			}
+		}
+	rgn1.Close();
+	rgn2.Close();
+	tmp_rgn.Close();
+	}
+
+void TestRRegion::TestUnion()
+	{
+	RRegion rgn1,rgn2,tmp_rgn;
+	TRect bounds;
+	TUint index;
+
+	rgn1.AddRect(xrect);
+	if (!rgn1.IsEmpty())
+		{
+		for(index=0;index<(sizeof(rect)/sizeof(rect[0]));index++)
+			tmp_rgn.AddRect(rect[index]);
+		test(tmp_rgn.Count()==4);
+		rgn1.Union(tmp_rgn);
+		test(rgn1.Count()==7);
+		rgn2.Copy(rgn1);
+		rgn2.Offset(3,5);
+		bounds=rgn1.BoundingRect();
+		rgn1.Union(rgn2);
+		bounds.Resize(3,5);
+		test(rgn1.BoundingRect()==bounds);
+		}
+	rgn1.Close();
+	rgn2.Close();
+	tmp_rgn.Close();
+	}
+
+void TestRRegion::TestClipRect()
+	{
+	RRegion rgn1(xrect);
+	if (!rgn1.IsEmpty())
+		{
+		TUint index;
+		for(index=0;index<(sizeof(rect)/sizeof(rect[0]));index++)
+			rgn1.AddRect(rect[index]);
+		TRect clip=rgn1.BoundingRect();
+		rgn1.ClipRect(clip);
+		test(clip==rgn1.BoundingRect());
+		clip.iTl.iX>>=1;
+		clip.iTl.iY>>=1;
+		clip.iBr.iX>>=1;
+		clip.iBr.iY>>=1;
+		rgn1.ClipRect(clip);
+		test(clip==rgn1.BoundingRect());
+		clip.iTl.iX=clip.iBr.iX;
+		rgn1.ClipRect(clip);
+		test(rgn1.Count()==0);
+		}
+	rgn1.Close();
+	}
+
+void TestRRegion::TestContains()
+	{
+	RRegion rgn;
+	rgn.AddRect(TRect(10,10,20,20));
+	rgn.AddRect(TRect(10,20,50,30));
+	test(rgn.Contains(TPoint(10,10)));
+	test(rgn.Contains(TPoint(49,29)));
+	test(rgn.Contains(TPoint(15,15)));
+	test(rgn.Contains(TPoint(31,22)));
+	test(rgn.Contains(TPoint(50,30))==EFalse);
+	test(rgn.Contains(TPoint(-100,-30))==EFalse);
+	test(rgn.Contains(TPoint(200,20))==EFalse);
+	test(rgn.Contains(TPoint(15,30000))==EFalse);
+	rgn.Close();
+	TRegionFix<1> rgn2(TRect(20,20,25,25));
+	test(rgn2.Contains(TPoint(20,20)));
+	test(rgn2.Contains(TPoint(22,23)));
+ 	test(rgn2.Contains(TPoint(0,0))==EFalse);
+	test(rgn2.Contains(TPoint(25,25))==EFalse);
+	test(rgn2.Contains(TPoint(30,30))==EFalse);
+	}
+
+void TestRRegion::TestIntersects()
+	{
+	RRegion rgn;
+	rgn.AddRect(TRect(10,10,20,20));
+	rgn.AddRect(TRect(10,20,50,30));
+	test(rgn.Intersects(TRect(10,10,20,20)));
+	test(rgn.Intersects(TRect(5,5,15,15)));
+	test(rgn.Intersects(TRect(10,20,50,30)));
+	test(rgn.Intersects(TRect(10,10,20,20)));
+	test(rgn.Intersects(TRect(40,10,60,30)));
+	test(rgn.Intersects(TRect(0,0,10,10))==EFalse);
+	test(rgn.Intersects(TRect(30,10,40,20))==EFalse);
+	rgn.Close();
+	TRegionFix<1> rgn2(TRect(20,20,30,30));
+	test(rgn2.Intersects(TRect(20,20,30,30)));
+	test(rgn2.Intersects(TRect(15,25,25,35)));
+	test(rgn2.Intersects(TRect(25,15,35,25)));
+	test(rgn2.Intersects(TRect(15,15,25,25)));
+	test(rgn2.Intersects(TRect(25,25,35,35)));
+	test(rgn2.Intersects(TRect(10,20,20,30))==EFalse);
+	test(rgn2.Intersects(TRect(30,20,40,30))==EFalse);
+	test(rgn2.Intersects(TRect(20,10,30,20))==EFalse);
+	test(rgn2.Intersects(TRect(20,30,30,40))==EFalse);
+	// empty rectangles
+	test(rgn2.Intersects(TRect(30,30,20,20))==EFalse);
+	TRegionFix<1> rgn3(TRect(30,30,20,20));
+	test(rgn3.Intersects(TRect(30,30,20,20))==EFalse);
+	test(rgn3.Intersects(TRect(20,20,30,30))==EFalse);
+	}
+
+void TestRRegion::TestErrors()
+	{
+	RRegion rgnErr,rgnErr2;
+	RRegion rgn;
+	TRect rect(1,2,3,4),rect2;
+	const TRect* rList;
+	TPoint pnt;
+
+	rgnErr.ForceError();
+	rgn.AddRect(rect);
+	rgnErr.Copy(rgn);
+	test(rgnErr.CheckError()==EFalse);
+	test(rgnErr.Count()==1);
+
+	rgnErr.ForceError();
+	test(rgnErr.CheckError()==TRUE);
+	rgnErr.AddRect(rect);
+	rgnErr.AddRect(TRect(2,3,4,5));
+	test(rgnErr.CheckError()==TRUE);
+	rgnErr.SubRect(rect);
+	test(rgnErr.CheckError()==TRUE);
+	rgn.Copy(rgnErr);
+	test(rgn.CheckError()==TRUE);
+	rgnErr.Offset(1,2);
+	rgnErr.Offset(pnt);
+	test(rgnErr.CheckError()==TRUE);
+
+	rgn.Union(rgnErr);
+	test(rgn.CheckError()==TRUE);
+	rgnErr.AddRect(rect);
+	test(rgnErr.CheckError()==TRUE);
+	rgn.Clear();
+	rgn.AddRect(rect);
+	rgnErr.Union(rgn);
+	test(rgnErr.CheckError()==TRUE);
+	rgn.Clear();
+	test(rgn.CheckError()==FALSE);
+
+	rgnErr2.Clear();
+	rgnErr2.AddRect(rect);
+	rgn.Intersection(rgnErr,rgnErr2);
+	test(rgn.CheckError()==TRUE);
+	rgn.Clear();
+	rgn.Intersection(rgnErr2,rgnErr);
+	test(rgn.CheckError()==TRUE);
+	rgnErr2.ForceError();
+	rgn.Clear();
+	rgn.Intersection(rgnErr2,rgnErr);
+	test(rgn.CheckError()==TRUE);
+	rgn.Clear();
+	rgn.AddRect(rect);
+	rgn.Intersect(rgnErr);
+	test(rgn.CheckError()==TRUE);
+	rgn.Clear();
+	rgn.AddRect(rect);
+	rgnErr.Intersect(rgn);
+	test(rgnErr.CheckError()==TRUE);
+	test(rgn.CheckError()==FALSE);
+
+	test(rgnErr.IsEmpty()==FALSE);
+
+	rgn.Clear();
+	rgn.AddRect(rect);
+	rgn.SubRegion(rgnErr);
+	test(rgn.CheckError()==TRUE);
+	test(rgnErr.CheckError()==TRUE);
+
+	rgnErr.ClipRect(rect);
+	test(rgnErr.CheckError()==TRUE);
+	rgnErr.Tidy();
+	test(rgnErr.CheckError()==TRUE);
+	rect2=rgnErr.BoundingRect();
+	test(rect2.iTl.iX==0 && rect2.iBr.iY==0);
+
+	test(rgnErr.Count()==0);
+	rList=rgnErr.RectangleList();
+	rgn.Close();
+	rgnErr.Close();
+	rgnErr2.Close();
+	}
+
+void TestRRegion::doTestSort(RRegion &rgn)
+	{
+	TInt loop,loop2;
+	TRect const rlist[8]={	// 8 Rectangles that form a square with the centre rectangle missing
+		TRect(20,30,30,40),
+		TRect(20,10,30,20),
+		TRect(10,20,20,30),
+		TRect(30,20,40,30),
+		TRect(10,30,20,40),
+		TRect(30,30,40,40),
+		TRect(10,10,20,20),
+		TRect(30,10,40,20)};
+	TRect sorted[8];
+	TRect const* plist;
+	TRect tmp;
+
+// Work out wot the sorted list should be
+	for(loop=0;loop<8;loop++)
+		sorted[loop]=rlist[loop];
+	for(loop=0;loop<8;loop++)
+		{
+restart:
+		for(loop2=loop+1;loop2<8;loop2++)
+			{
+			if (sorted[loop2].iTl.iY>sorted[loop].iTl.iY)
+				continue;
+			if (sorted[loop2].iTl.iY==sorted[loop].iTl.iY && sorted[loop2].iTl.iX>sorted[loop].iTl.iX)
+				continue;
+			tmp=sorted[loop];
+			sorted[loop]=sorted[loop2];
+			sorted[loop2]=tmp;
+			goto restart;
+			}	
+		}
+	for(loop=0;loop<8;loop++)
+		rgn.AddRect(rlist[loop]);
+	rgn.Sort();
+	plist=rgn.RectangleList();
+	for(loop=0;loop<8;loop++)
+		test(plist[loop]==sorted[loop]);
+	rgn.Close();
+	}
+
+void TestRRegion::TestSort()
+	{
+	RRegion rgn;
+	doTestSort(rgn);
+	RRegionBuf<1> rgnBuf;
+	doTestSort(rgnBuf);
+	}
+
+void TestRRegion::doTestRegionBuf(RRegion &aRegion)
+	{
+	for(TInt index=0;index<8;index++)
+		{
+		aRegion.AddRect(TRect(index*2,index*2,index*2+2,index*2+2));
+		test(aRegion.Count()==(index+1));
+		const TRect *pr=aRegion.RectangleList();
+		for(TInt index2=0;index2<=index;index2++)
+			test(pr[index2]==TRect(index2*2,index2*2,index2*2+2,index2*2+2));
+		}
+	aRegion.Close();
+	}
+
+void TestRRegion::TestRegionBuf()
+	{
+	RRegionBuf<1> rgn(TRect(1,2,3,4));
+	test(rgn[0]==TRect(1,2,3,4));
+	RRegionBuf<1> rgn1;
+	doTestRegionBuf(rgn1);
+	RRegionBuf<2> rgn2;
+	doTestRegionBuf(rgn2);
+	RRegionBuf<5> rgn5;
+	doTestRegionBuf(rgn5);
+	RRegionBuf<10> rgn10;
+	doTestRegionBuf(rgn10);
+	}
+
+// Top level test code
+LOCAL_C void test_region(TestRRegion t)
+	{
+	test.Start(_L("Setting values"));
+	t.TestSet();
+	test.Next(_L("TRegionFix"));
+	t.TestRegionFix();
+	test.Next(_L("AddRect"));
+	t.TestAddRect();
+	test.Next(_L("SubRect"));
+	t.TestSubRect();
+	test.Next(_L("SubRegion"));
+	t.TestSubRegion();
+	test.Next(_L("Tidy"));
+	t.TestTidy();
+	test.Next(_L("Spare"));
+	t.TestSpare();
+	test.Next(_L("Offset"));
+	t.TestOffset();
+	test.Next(_L("Intersection"));
+	t.TestIntersection();
+	test.Next(_L("Union"));
+	t.TestUnion();
+	test.Next(_L("Clip rect"));
+	t.TestClipRect();
+	test.Next(_L("Contains"));
+	t.TestContains();
+	test.Next(_L("Intersects"));
+	t.TestIntersects();
+	test.Next(_L("Errors"));
+	t.TestErrors();
+	test.Next(_L("Sort"));
+	t.TestSort();
+	test.Next(_L("RegionBuf"));
+	t.TestRegionBuf();
+	test.End();
+	}
+
+GLDEF_C TInt E32Main()
+//
+// Main
+//
+    {
+
+	test.Title();
+	__UHEAP_MARK;
+	TestRRegion t1(10,20,30,40);
+	TestRRegion t2(0,0,1,1);
+	TestRRegion t3(1,1,1,1);
+	TestRRegion t4(1000000,2000000,3000000,4000000);
+
+	test.Start(_L("class RRegion 1"));
+	test_region(t1);
+	test.Next(_L("class RRegion 2"));
+	test_region(t2);
+	test.Next(_L("class RRegion 3"));
+	test_region(t3);
+	test.Next(_L("class RRegion 4"));
+	test_region(t4);
+	test.End();
+	__UHEAP_MARKEND;
+	return(0);
+    }
+
+