--- /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);
+ }
+
+