// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// which accompanies this distribution, and is available

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32test\buffer\t_graph.cpp

// Overview:

// Test the TPoint, TSize, TRect class.

// API Information:

// TPoint, TSize, TRect.

// Details:

// - Initialize some two-dimensional points in Cartesian co-ordinates with various 

// positive, negative values. Add and subtract different initialized points and 

// check that results are as expected.

// - Create some two-dimensional sizes, set with various positive, negative values. 

// Add and subtract different initialized sizes and check that results are as expected.

// - Initialize some rectangles in different positions, set various widths, heights and 

// sizes and verify that values are assigned as specified. 

// - Move the rectangle by adding two-dimensional point offset, some x, y offset and check 

// that it is as expected.

// - Resize, shrink, grow, rectangles by adding, subtracting some horizontal, vertical 

// offset and verify that it is as expected.

// - Get the minimal rectangles which bounds one rectangle and the specified rectangles, 

// assign it to the rectangles and check that it is as expected.

// - Assign some rectangles with different positions and test whether the rectangle is 

// empty, overlaps as expected.

// - Get the area of intersection between one rectangle and the specified rectangle, 

// assign it to the rectangle and verify that the assigned rectangle is not empty.

// - Create some rectangles, check that the rectangle's width and height have positive

// values, the rectangle is normalized, whether a point is located within the rectangle 

// and is empty.

// - Create some rectangles, get the points at the centre of the rectangles and check that 

// it is as expected.

// - Create  some three-dimensional points in Cartesian co-ordinates with various 

// positive, negative values. Add and subtract different initialized points and 

// check that results 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_GRAPH"));

class TestTPoint

	{

public:

	TestTPoint(TInt x1,TInt y1,TInt x2,TInt y2,TInt x3,TInt y3,TInt x4,TInt y4);

	void TestSet();

	void TestAdd();

	void TestSub();

	void TestUnaryMinus();

private:

	TInt iX1;

	TInt iY1;

	TInt iX2;

	TInt iY2;

	TInt iX3;

	TInt iY3;

	TInt iX4;

	TInt iY4;

	};

class TestTSize

	{

public:

	TestTSize(TInt wid1,TInt hgt1,TInt wid2,TInt hgt2,TInt wid3,TInt hgt3,TInt wid4,TInt hgt4);

	void TestSet();

	void TestAdd();

	void TestSub();

	void TestUnaryMinus();

private:

	TInt iWidth1;

	TInt iHeight1;

	TInt iWidth2;

	TInt iHeight2;

	TInt iWidth3;

	TInt iHeight3;

	TInt iWidth4;

	TInt iHeight4;

	};

class TestTRect

	{

public:

	TestTRect(TInt tlx1,TInt tly1,TInt brx1,TInt bry1,

			  TInt tlx2,TInt tly2,TInt brx2,TInt bry2,

			  TInt tlx3,TInt tly3,TInt brx3,TInt bry3);

	void TestSet();

	void TestMove();

	void TestResize();

	void TestShrink();

	void TestGrow();

	void TestBoundingRect();

	void TestIsEmpty();

	void TestIntersects();

	void TestIntersection();

	void TestNormalize();

	void TestContains();

	void TestCenter();

private:

	TInt iTlx1;

	TInt iTly1;

	TInt iBrx1;

	TInt iBry1;

	TInt iTlx2;

	TInt iTly2;

	TInt iBrx2;

	TInt iBry2;

	TInt iTlx3;

	TInt iTly3;

	TInt iBrx3;

	TInt iBry3;

	};

class TestTPoint3D

	{

public:

	TestTPoint3D(TInt x1,TInt y1,TInt z1,TInt x2,TInt y2,TInt z2,TInt x3,TInt y3,TInt z3,TInt x4,TInt y4,TInt z4);

	void TestSet();

	void TestAdd();

	void TestSub();

	void TestUnaryMinus();

private:

	TInt iX1;

	TInt iY1;

	TInt iZ1;

	TInt iX2;

	TInt iY2;

	TInt iZ2;

	TInt iX3;

	TInt iY3;

	TInt iZ3;

	TInt iX4;

	TInt iY4;

	TInt iZ4;

	};

//////////////////////////////////////////////////////////////////////////////

// Point test code															//

//////////////////////////////////////////////////////////////////////////////

TestTPoint::TestTPoint(TInt x1,TInt y1,TInt x2,TInt y2,TInt x3,TInt y3,TInt x4,TInt y4)

	{

	iX1=x1;

	iY1=y1;

	iX2=x2;

	iY2=y2;

	iX3=x3;

	iY3=y3;

	iX4=x4;

	iY4=y4;

	}

void TestTPoint::TestSet()

	{

	TSize s1(iX3,iY3);

	TPoint p1(iX1,iY1);

	TPoint p2(iX2,iY2);

	TPoint p3;

	TPoint p4;

	test(p1.iX==iX1 && p1.iY==iY1);

	test(p2.iX==iX2 && p2.iY==iY2);

	test(p4.iX==0 && p4.iY==0);

	p3.iX=iX3;

	p3.iY=iY3;

	test(p3.iX==iX3 && p3.iY==iY3);

	test(p3.AsSize()==s1);

	p4.SetXY(iX4,iY4);

	test(p4.iX==iX4 && p4.iY==iY4);

	p1=p4;

	test(p1==p4);

	test(p1.iX==p4.iX && p1.iY==p4.iY);

	p3=p2;

	test(p3==p2);

	test(p3.iX==p2.iX && p3.iY==p2.iY);

	p1=p4;

	p1.iX++;

	test(p1!=p4);

	p1=p4;

	p1.iY++;

	test(p1!=p4);

	}

void TestTPoint::TestAdd()

	{

	TSize s1(iX3,iY3);

	TPoint p1(iX1,iY1);

	TPoint p2(iX2,iY2);

	TPoint p3(iX3,iY3);

	TPoint p4(iX4,iY4);

	TPoint px;

	p1+=p2;

	test(p1.iX==(p2.iX+iX1) && p1.iY==(p2.iY+iY1));

	px=p3=p1+p2;

	test(p3.iX==(p1.iX+p2.iX) && p3.iY==(p1.iY+p2.iY));

	test(p3==(p1+p2));

	test(px==p3);

	px=p4+=p1;

	test(p4.iX==(p1.iX+iX4) && p4.iY==(p1.iY+iY4));

	test(px==p4);

	px=p1;

	p1+=s1;

	test(p1.iX==(px.iX+s1.iWidth) && p1.iY==(px.iY+s1.iHeight));

	p2=px+s1;

	test(p2==p1);

	}

void TestTPoint::TestSub()

	{

	TSize s1(iX3,iY3);

	TPoint p1(iX1,iY1);

	TPoint p2(iX2,iY2);

	TPoint p3(iX3,iY3);

	TPoint p4(iX4,iY4);

	TPoint px;

	p1-=p2;

	test(p1.iX==(iX1-p2.iX) && p1.iY==(iY1-p2.iY));

	px=p3=p1-p2;

	test(p3.iX==(p1.iX-p2.iX) && p3.iY==(p1.iY-p2.iY));

	test(p3==(p1-p2));

	test(px==p3);

	px=p4-=p1;

	test(p4.iX==(iX4-p1.iX) && p4.iY==(iY4-p1.iY));

	test(px==p4);

	px=p1;

	p1-=s1;

	test(p1.iX==(px.iX-s1.iWidth) && p1.iY==(px.iY-s1.iHeight));

	p2=px-s1;

	test(p2==p1);

	}

void TestTPoint::TestUnaryMinus()

	{

	TPoint p1(iX1,iY1);

	TPoint p2(iX2,iY2);

	TPoint p3(iX3,iY3);

	TPoint p4(iX4,iY4);

	TPoint p=-p1;

	test (p==TPoint(-iX1,-iY1));

	p=-p2;

	test (p==TPoint(-iX2,-iY2));

	p=-p3;

	test (p==TPoint(-iX3,-iY3));

	p=-p4;

	test (p==TPoint(-iX4,-iY4));

	}

//////////////////////////////////////////////////////////////////////////////

// Size test code															//

//////////////////////////////////////////////////////////////////////////////

TestTSize::TestTSize(TInt x1,TInt y1,TInt x2,TInt y2,TInt x3,TInt y3,TInt x4,TInt y4)

	{

	iWidth1=x1;

	iHeight1=y1;

	iWidth2=x2;

	iHeight2=y2;

	iWidth3=x3;

	iHeight3=y3;

	iWidth4=x4;

	iHeight4=y4;

	}

void TestTSize::TestSet()

	{

	TPoint p1(iWidth3,iHeight3);

	TSize s1(iWidth1,iHeight1);

	TSize s2(iWidth2,iHeight2);

	TSize s3;

	TSize s4;

	test(s1.iWidth==iWidth1 && s1.iHeight==iHeight1);

	test(s2.iWidth==iWidth2 && s2.iHeight==iHeight2);

	test(s4.iWidth==0 && s4.iHeight==0);

	s3.iWidth=iWidth3;

	s3.iHeight=iHeight3;

	test(s3.iWidth==iWidth3 && s3.iHeight==iHeight3);

	test(s3.AsPoint()==p1);

	s4.SetSize(iWidth4,iHeight4);

	test(s4.iWidth==iWidth4 && s4.iHeight==iHeight4);

	s1=s4;

	test(s1==s4);

	test(s1.iWidth==s4.iWidth && s1.iHeight==s4.iHeight);

	s3=s2;

	test(s3==s2);

	test(s3.iWidth==s2.iWidth && s3.iHeight==s2.iHeight);

	s1=s4;

	s1.iWidth++;

	test(s1!=s4);

	s1=s4;

	s1.iHeight++;

	test(s1!=s4);

	}

void TestTSize::TestAdd()

	{

	TPoint p1(iWidth3,iHeight3);

	TSize s1(iWidth1,iHeight1);

	TSize s2(iWidth2,iHeight2);

	TSize s3(iWidth3,iHeight3);

	TSize s4(iWidth4,iHeight4);

	TSize sx;

	s1+=s2;

	test(s1.iWidth==(s2.iWidth+iWidth1) && s1.iHeight==(s2.iHeight+iHeight1));

	sx=s3=s1+s2;

	test(s3.iWidth==(s1.iWidth+s2.iWidth) && s3.iHeight==(s1.iHeight+s2.iHeight));

	test(s3==(s1+s2));

	test(sx==s3);

	sx=s4+=s1;

	test(s4.iWidth==(s1.iWidth+iWidth4) && s4.iHeight==(s1.iHeight+iHeight4));

	test(sx==s4);

	sx=s1;

	s1+=p1;

	test(s1.iWidth==(sx.iWidth+p1.iX) && s1.iHeight==(sx.iHeight+p1.iY));

	s2=sx+p1;

	test(s1==s2);

	}

void TestTSize::TestSub()

	{

	TPoint p1(iWidth3,iHeight3);

	TSize s1(iWidth1,iHeight1);

	TSize s2(iWidth2,iHeight2);

	TSize s3(iWidth3,iHeight3);

	TSize s4(iWidth4,iHeight4);

	TSize sx;

	s1-=s2;

	test(s1.iWidth==(iWidth1-s2.iWidth) && s1.iHeight==(iHeight1-s2.iHeight));

	sx=s3=s1-s2;

	test(s3.iWidth==(s1.iWidth-s2.iWidth) && s3.iHeight==(s1.iHeight-s2.iHeight));

	test(s3==(s1-s2));

	test(sx==s3);

	sx=s4-=s1;

	test(s4.iWidth==(iWidth4-s1.iWidth) && s4.iHeight==(iHeight4-s1.iHeight));

	test(sx==s4);

	sx=s1;

	s1-=p1;

	test(s1.iWidth==(sx.iWidth-p1.iX) && s1.iHeight==(sx.iHeight-p1.iY));

	s2=sx-p1;

	test(s1==s2);

	}

void TestTSize::TestUnaryMinus()

	{

	TSize s1(iWidth1,iHeight1);

	TSize s2(iWidth2,iHeight2);

	TSize s3(iWidth3,iHeight3);

	TSize s4(iWidth4,iHeight4);

	TSize s=-s1;

	test (s==TSize(-iWidth1,-iHeight1));

	s=-s2;

	test (s==TSize(-iWidth2,-iHeight2));

	s=-s3;

	test (s==TSize(-iWidth3,-iHeight3));

	s=-s4;

	test (s==TSize(-iWidth4,-iHeight4));

	}

//////////////////////////////////////////////////////////////////////////////

// Rectangle test code														//

//////////////////////////////////////////////////////////////////////////////

TestTRect::TestTRect(TInt tlx1,TInt tly1,TInt brx1,TInt bry1,

			  				 TInt tlx2,TInt tly2,TInt brx2,TInt bry2,

			  				 TInt tlx3,TInt tly3,TInt brx3,TInt bry3)

	{

	iTlx1=tlx1;

	iTly1=tly1;

	iBrx1=brx1;

	iBry1=bry1;

	iTlx2=tlx2;

	iTly2=tly2;

	iBrx2=brx2;

	iBry2=bry2;

	iTlx3=tlx3;

	iTly3=tly3;

	iBrx3=brx3;

	iBry3=bry3;

	}

void TestTRect::TestSet()

	{

	TSize s1(iTlx3,iTly3);

	TPoint pTl(iTlx2,iTly2);

	TPoint pBr(iBrx2,iBry2);

	TRect r1(iTlx1,iTly1,iBrx1,iBry1);

	TRect r2(pTl,pBr);

	TRect r3;

	TRect r4(pTl,s1);

	test(r1.iTl.iX==iTlx1 && r1.iTl.iY==iTly1 && r1.iBr.iX==iBrx1 && r1.iBr.iY==iBry1);

	test(r2.iTl.iX==iTlx2 && r2.iTl.iY==iTly2 && r2.iBr.iX==iBrx2 && r2.iBr.iY==iBry2);

	test(r2.iTl==pTl && r2.iBr==pBr);

	test(r3.iTl.iX==0 && r3.iTl.iY==0 && r3.iBr.iX==0 && r3.iBr.iY==0);

	test(r4.iTl==pTl && r4.iBr.iX==(pTl.iX+s1.iWidth) && r4.iBr.iY==(pTl.iY+s1.iHeight));

	r3.iTl.iX=iTlx3;

	r3.iTl.iY=iTly3;

	r3.iBr.iX=iBrx3;

	r3.iBr.iY=iBry3;

	test(r3.iTl.iX==iTlx3 && r3.iTl.iY==iTly3 && r3.iBr.iX==iBrx3 && r3.iBr.iY==iBry3);

	r1.SetRect(iTlx2,iTly2,iBrx2,iBry2);

	test(r1==r2);

	r2=r3;

	test(r2==r3);

	pTl.SetXY(iTlx3,iTly3);

	pBr.SetXY(iBrx3,iBry3);

	r1.SetRect(pTl,pBr);

	test(r1.iTl.iX==iTlx3 && r1.iTl.iY==iTly3 && r1.iBr.iX==iBrx3 && r1.iBr.iY==iBry3);

	pTl.SetXY(iTlx2,iTly2);

	r1.SetRect(pTl,s1);

	test(r1==r4);

	r4.iTl.iX++;

	test(r1!=r4);

	r4.iTl.iX--;

	test(r1==r4);

	r4.iTl.iY++;

	test(r1!=r4);

	r4.iTl.iY--;

	test(r1==r4);

	r4.iBr.iX++;

	test(r1!=r4);

	r4.iBr.iX--;

	test(r1==r4);

	r4.iBr.iY++;

	test(r1!=r4);

	r4=TRect(0,0,0,0);

	r4.SetWidth(r1.Size().iWidth);

	test(r1.Size().iWidth==r4.Size().iWidth);

	test(r4.Size().iHeight==0);

	r4.SetHeight(r1.Size().iHeight);

	test(r1.Size().iHeight==r4.Size().iHeight);

	test(r1.Size().iWidth==r4.Size().iWidth);

	r4=TRect(0,0,0,0);

	r4.SetSize(r1.Size());

	test(r1.Size()==r4.Size());

	}

void TestTRect::TestMove()

	{

	TPoint offs(iTlx2,iTly2);

	TRect r1(iTlx1,iTly1,iBrx1,iBry1);

	TRect rCheck,rTest;

	rCheck=r1;

	rCheck.iTl+=offs;

	rCheck.iBr+=offs;

	rTest=r1;

	rTest.Move(offs);

	test(rTest==rCheck);

	rTest=r1;

	rTest.Move(offs.iX,offs.iY);

	test(rTest==rCheck);

	}

void TestTRect::TestResize()

	{

	TSize resize(iTlx1,iTly1);

	TRect rTest(iTlx2,iTly2,iBrx2,iBry2);

	TRect rCheck;

	rCheck=rTest;

	rTest.Resize(resize);

	rCheck.iBr+=resize;

	test(rTest==rCheck);

	}

void TestTRect::TestShrink()

	{

	TSize shrink(iTlx3,iTly3);

	TRect r2(iTlx2,iTly2,iBrx2,iBry2);

	TRect rCheck,rTest;

	rCheck=r2;

	rCheck.iTl+=shrink;

	rCheck.iBr-=shrink;

	rTest=r2;

	rTest.Shrink(shrink);

	test(rTest==rCheck);

	rTest=r2;

	rTest.Shrink(shrink.iWidth,shrink.iHeight);

	test(rTest==rCheck);

	}