// 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 "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-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);

			TInt count = rgn.Count();

			test( (count > 4) && (count <= 9) );

			}

		}

	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()<gran[index]);

		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,rgn3,tmp_rgn;

	TRect bounds, rgn1Bounds;

	TUint index;

	// Test RRegion (always has a dynamic buffer).

	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);

		rgn1Bounds = rgn1.BoundingRect();

		rgn2.Copy(rgn1);

		rgn2.Offset(3,5);

		rgn3.Copy(rgn1);

		rgn3.Offset(5,7);

		rgn3.Union(rgn2);

		test(rgn3.Count()==17);

		bounds=rgn1.BoundingRect();

		rgn1.Union(rgn2);

		bounds.Resize(3,5);

		test(rgn1.BoundingRect()==bounds);

		rgn1Bounds.Shrink(3,5);

		rgn1Bounds.Resize(8,12);

		test(rgn3.BoundingRect()==rgn1Bounds);

		}

	rgn1.Close();

	rgn2.Close();

	rgn3.Close();