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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include <graphicsaccelerator.h>

    17 #include "TAccelerator.h"

    18 #include <graphics/fbsdefs.h>

    19 

    20 class TAcceleratedBitmapSpecTest : public TAcceleratedBitmapSpec

    21 	{

    22 // Provides public access to TAcceleratedBitmapSpec

    23 public:

    24 	inline TAcceleratedBitmapSpecTest() : TAcceleratedBitmapSpec() {}

    25 	inline TAcceleratedBitmapSpecTest(CFbsBitmap* aBitmap) : TAcceleratedBitmapSpec(aBitmap) {}

    26 	inline TAcceleratedBitmapSpecTest(RHardwareBitmap aBitmap) : TAcceleratedBitmapSpec(aBitmap) {}

    27 	// 

    28 	inline TInt GetInfo(TAcceleratedBitmapInfo& aInfo) const { return TAcceleratedBitmapSpec::GetInfo(aInfo); }

    29 	inline void Lock(TBitmapLockCount& aCount) { TAcceleratedBitmapSpec::Lock(aCount); }

    30 	inline void Lock(TBitmapLockCount& aCount,TAcceleratedBitmapInfo& aInfo) { TAcceleratedBitmapSpec::Lock(aCount,aInfo); }

    31 	inline void	Unlock(TBitmapLockCount& aCount)  { TAcceleratedBitmapSpec::Unlock(aCount); }

    32 	};

    33 

    34 const TInt KNumDisplayModes = 13;

    35 static struct 

    36 	{

    37 	TDisplayMode iMode;

    38 	TBool iEnabled;

    39 	TInt iPixelShift;

    40 	} TestDisplayModes[KNumDisplayModes] =	

    41    {  

    42 		{EGray2,EFalse,0},

    43 		{EGray4,EFalse,1},

    44 		{EGray16,EFalse,2},

    45 		{EGray256,EFalse,3},

    46 		{EColor16,EFalse,2},

    47 		{EColor256,EFalse,3},

    48 		{EColor64K,EFalse,4},

    49 		{EColor16M,EFalse,5},

    50 		{ERgb,EFalse,5},

    51 		{EColor4K,EFalse,4},

    52 		{EColor16MU,EFalse,5},

    53 		{EColor16MA,EFalse,5},

    54 		{EColor16MAP,EFalse,5}

    55 	};

    56 

    57 _LIT(KRam32BitmapOnZ, "z:\\system\\data\\32RAM.mbm");

    58 _LIT(KRamC24BitmapOnZ, "z:\\system\\data\\24RAMC.mbm");

    59 _LIT(KRomC24Bitmap, "z:\\system\\data\\24ROMC.mbm");

    60 

    61 //

    62 // CTestBitmap

    63 //

    64 

    65 TInt CTestBitmap::ConstructL(TDisplayMode aDisplayMode,TSize aSize,TBool aHWBitmap)

    66 	{

    67 	Reset();

    68 

    69 	iBitmap = new CFbsBitmap;

    70 	if(iBitmap==NULL)

    71 		User::Panic(_L("Bitmap not created"),KErrGeneral);

    72 

    73 	TInt ret;

    74 	if(aHWBitmap)

    75 		ret = iBitmap->CreateHardwareBitmap(aSize,aDisplayMode,TUid());

    76 	else

    77 		ret = iBitmap->Create(aSize,aDisplayMode);

    78 

    79 	if (ret == KErrNotSupported)

    80 		{

    81 		Reset();

    82 		return ret;

    83 		}

    84 

    85 	User::LeaveIfError(ret);

    86 

    87 	TRAPD(err,iDevice = CFbsBitmapDevice::NewL(iBitmap));

    88 	if(err)

    89 		User::Panic(_L("BitmapDevice not created"),err);

    90 

    91 	err = iDevice->CreateContext(iGc);

    92 	if(err)

    93 		User::Panic(_L("BitmapDevice not created"),err);

    94 

    95 	return KErrNone;

    96 	}

    97 

    98 void CTestBitmap::Reset()

    99 	{

   100 	delete iGc;

   101 	iGc = 0;

   102 	delete iDevice;

   103 	iDevice = 0;

   104 	delete iBitmap;

   105 	iBitmap = 0;

   106 	}

   107 

   108 CTestBitmap::~CTestBitmap()

   109 	{

   110 	Reset();

   111 	}

   112 

   113 TBool CTestBitmap::Compare(CTestBitmap* aBitmap2)

   114 	{	

   115 	TInt width=iBitmap->SizeInPixels().iWidth;

   116 	TInt pitch = iBitmap->DataStride();

   117 	TInt height=iBitmap->SizeInPixels().iHeight;

   118 

   119 	for(TInt yLoop=0;yLoop<height;yLoop++)

   120 		{

   121 		TInt offset=yLoop*pitch;

   122 		TUint8* data1 = ((TUint8*)iBitmap->DataAddress())+offset;

   123 		TUint8* data2 = ((TUint8*)aBitmap2->iBitmap->DataAddress())+offset;

   124 		TUint8* dataLimit = data1 + CFbsBitmap::ScanLineLength(width, iBitmap->DisplayMode());

   125 		while(data1<dataLimit)

   126 			{

   127 			if(*(data1++)!=*(data2++))

   128 				{

   129 				iBitmap->Save(_L("C:\\Compare1.mbm"));

   130 				aBitmap2->iBitmap->Save(_L("C:\\Compare2.mbm"));

   131 				return EFalse;

   132 				}

   133 			}

   134 		}

   135 	return(ETrue);

   136 	}

   137 

   138 //

   139 // CTAccelerator

   140 //

   141 

   142 CTAccelerator::CTAccelerator(CTestStep* aStep):

   143 	CTGraphicsBase(aStep), 

   144 	iRandomSeed(1),

   145 	iGraphicsAccelerator1(0),

   146 	iGraphicsAccelerator2(0),

   147 	iHwScreenDevice(0),

   148 	iScreenGc(0)

   149 	{

   150 	TInt i;

   151 	for(i=0;i<9;i++) 

   152 		iFixedRegion.AddRect(TRect(i*16,i*8,i*16+32,i*8+32));

   153 	for(i=0;i<9;i++) 

   154 		iFixedRegion.AddRect(TRect(183-(i*16),i*8,199-(i*16),i*8+32));

   155 

   156 	iDefaultRegion.AddRect(TRect(0,0,199,99));

   157 	INFO_PRINTF1(_L("Graphics Accelerator Testing"));

   158 	}

   159 

   160 void CTAccelerator::Cleanup()

   161 	{

   162 	delete iGraphicsAccelerator1;

   163 	iGraphicsAccelerator1 = 0;

   164 	delete iGraphicsAccelerator2;

   165 	iGraphicsAccelerator2 = 0;

   166 	if(iHwScreenDevice)

   167 		{

   168 		delete iHwScreenDevice;

   169 		iHwScreenDevice = 0;

   170 		}

   171 	if(iScreenGc)

   172 		{

   173 		delete iScreenGc;

   174 		iScreenGc = 0;

   175 		}

   176 	iBitmap1.Reset();

   177 	iBitmap2.Reset();

   178 	iBitmap3.Reset();

   179 	iBitmap4.Reset();

   180 	iBitmap5.Reset();

   181 	iBitmap6.Reset();

   182 	iBitmap7.Reset();

   183 	iTileBitmap.Reset();

   184 	iAlphaBitmap.Reset();

   185 	}

   186 

   187 TInt CTAccelerator::Random(TInt aMax)	// aMax <= 0xFFFF

   188 	{

   189 	iRandomSeed *= 69069;

   190 	TUint r = ((iRandomSeed>>16)*aMax)>>16;

   191 	return r;

   192 	}

   193 

   194 void CTAccelerator::RunTestCaseL(TInt aCurTestCase)

   195 	{

   196 	TInt i;

   197 	((CTAcceleratorStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

   198 	

   199 	switch(aCurTestCase)

   200 		{

   201 	case 1:

   202 		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0021"));

   203 		INFO_PRINTF1(_L("Testing TAcceleratedBitmapSpec with software bitmaps."));

   204 		for(i=0; i<KNumDisplayModes; i++)

   205 			if (TestDisplayModes[i].iEnabled)

   206 				{

   207 				TestAcceleratedBitmapSpecL(TestDisplayModes[i].iMode,EFalse);

   208 				}

   209 		break;

   210 	case 2:

   211 		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0022"));

   212 		INFO_PRINTF1(_L("Testing graphics operations with software bitmaps."));

   213 		for(i=0; i<KNumDisplayModes; i++)

   214 			if (TestDisplayModes[i].iEnabled)

   215 				{

   216 				TestGraphicsOperations(TestDisplayModes[i].iMode,EFalse);

   217 				}

   218 		break;

   219 	case 3:

   220 		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0021"));

   221 		INFO_PRINTF1(_L("Testing TAcceleratedBitmapSpec with hardware bitmaps."));

   222 		for(i=0; i<KNumDisplayModes; i++)

   223 			if (TestDisplayModes[i].iEnabled)

   224 				{

   225 				TestAcceleratedBitmapSpecL(TestDisplayModes[i].iMode,ETrue);

   226 				}

   227 		break;

   228 	case 4:

   229 		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0022"));

   230 		INFO_PRINTF1(_L("Testing graphics operations with hardware bitmaps."));

   231 		for(i=0; i<KNumDisplayModes; i++)

   232 			if (TestDisplayModes[i].iEnabled)

   233 				{

   234 				TestGraphicsOperations(TestDisplayModes[i].iMode,ETrue);

   235 				}

   236 		break;

   237 	case 5:

   238 		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0023"));

   239 		INFO_PRINTF1(_L("Testing graphics operations with hardware bitmap as screen."));

   240 		for(i=0; i<KNumDisplayModes; i++)

   241 			if (TestDisplayModes[i].iEnabled)	

   242 				{

   243 				TestGraphicsOperationsWithScreenL(TestDisplayModes[i].iMode,ETrue);

   244 				}

   245 		break;

   246 	case 6:

   247 

   248 /**

   249  @SYMTestCaseID          GRAPHICS-BITGDI-0112

   250 */

   251 		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0112"));

   252 		INFO_PRINTF1(_L("Testing passing of compressed info to accelerator"));

   253 		TestAcceleratorInfo();

   254 		break;

   255 	case 7:

   256 /**

   257  @SYMTestCaseID          GRAPHICS-BITGDI-0113

   258 */

   259 		((CTAcceleratorStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0113"));

   260 		INFO_PRINTF1(_L("Testing GetInfo() with an extended bitmap"));

   261 		TestAcceleratorInfoForExtendedBitmapL();

   262 		break;

   263 

   264 	case 8:

   265 		((CTAcceleratorStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

   266 		((CTAcceleratorStep*)iStep)->CloseTMSGraphicsStep();

   267 		TestComplete();

   268 		break;

   269 		}

   270 	((CTAcceleratorStep*)iStep)->RecordTestResultL();

   271  	}

   272 

   273 const TSize TestBitmapSize = TSize(199,99);

   274 TSize TestScreenSize;

   275 const TSize TestBitmapSize1 = TSize(165,53);

   276 

   277 

   278 /**

   279  @SYMTestCaseID          GRAPHICS-BITGDI-0021

   280  @SYMCreationDate        21/11/2008

   281  @SYMAuthor              douglashetherington

   282  @SYMTestStatus          3. Released

   283  @SYMTestPriority        High

   284  @SYMTestCaseDesc        Checks that TAcceleratedBitmapSpec does not change the underlaying bitmaps data

   285  @SYMTestExpectedResults The bitmap data is not changed

   286  @SYMTestActions         Creates a bitmap, puts it into a TAcceleratedBitmapSpec then checks the pixel data is unchanged

   287  @SYMDEF                 

   288 */

   289 void CTAccelerator::TestAcceleratedBitmapSpecL(TDisplayMode aDisplayMode,TBool aHWBitmap)

   290 	{

   291 	TInt ret=0; 

   292 	

   293 	INFO_PRINTF2(_L("  DisplayMode=%d"),aDisplayMode);

   294 

   295 	// Create bitmap

   296 	ret = iBitmap1.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap);

   297 	INFO_PRINTF2(_L(" TestAcceleratedBitmapSpecL ret=%d"),ret);

   298 	if(ret!=KErrNone)

   299 		{

   300 		WARN_PRINTF1(_L("  Not Supported."));

   301 		return;

   302 		}

   303 

   304 	TAcceleratedBitmapSpecTest bitmapSpec(iBitmap1.iBitmap);

   305 	TAcceleratedBitmapInfo info;

   306 

   307 	// Check correct size	

   308 	bitmapSpec.Lock(iBitmapLockCount);

   309 	User::LeaveIfError(bitmapSpec.GetInfo(info));

   310 	TEST(info.iSize==iBitmap1.iBitmap->SizeInPixels());

   311 	INFO_PRINTF3(_L("Test Display Modes , Expected iPixelShift : %d, Actual iPixelShift: %d"),TestDisplayModes[aDisplayMode-1].iPixelShift,info.iPixelShift);

   312 	TEST(info.iPixelShift == TestDisplayModes[aDisplayMode-1].iPixelShift);

   313 	bitmapSpec.Unlock(iBitmapLockCount);

   314 

   315 	TInt scanLineLength = iBitmap1.iBitmap->ScanLineLength(TestBitmapSize.iWidth,aDisplayMode);

   316 	HBufC8* scanLineBuffer = HBufC8::NewMaxLC(scanLineLength);

   317 	TPtr8 scanLine(scanLineBuffer->Des());

   318 

   319 	TInt y,x;

   320 

   321 	// fill bitmap with test data

   322 	for(y=info.iSize.iHeight-1; y>=0; y--)

   323 		{

   324 		TUint8* ptr = &(scanLine)[0];

   325 		TUint8* ptrLimit = ptr+scanLineLength;

   326 		x = 42;

   327 		while(ptr<ptrLimit)

   328 			*(ptr++) = (TUint8)(y^(x++));

   329 		iBitmap1.iBitmap->SetScanLine(scanLine,y);

   330 		}

   331 	

   332 	// use TAcceleratedBitmapSpec to check contents

   333 	bitmapSpec.Lock(iBitmapLockCount,info);

   334 	for(y=0; y<info.iSize.iHeight; y++)

   335 		{

   336 		TUint8* ptr = info.iAddress+y*info.iLinePitch;

   337 		TUint8* ptrLimit = ptr+scanLineLength;

   338 		x = 42;

   339 		while(ptr<ptrLimit)

   340 			if(*(ptr++) != (TUint8)(y^(x++)))

   341 				{

   342 				ERR_PRINTF2(_L("!!!  Failed at compare A, line %d"),y);

   343 				User::Leave(KErrGeneral);

   344 				}

   345 		}

   346 	bitmapSpec.Unlock(iBitmapLockCount);

   347 

   348 	// fill bitmap with test data (inverse of previous)

   349 	for(y=info.iSize.iHeight-1; y>=0; y--)

   350 		{

   351 		TUint8* ptr = &(scanLine)[0];

   352 		TUint8* ptrLimit = ptr+scanLineLength;

   353 		x = 42;

   354 		while(ptr<ptrLimit)

   355 			*(ptr++) = (TUint8)~(y^(x++));

   356 		iBitmap1.iBitmap->SetScanLine(scanLine,y);

   357 		}

   358 	

   359 	// use TAcceleratedBitmapSpec to check contents

   360 	bitmapSpec.Lock(iBitmapLockCount,info);

   361 	for(y=0; y<info.iSize.iHeight; y++)

   362 		{

   363 		TUint8* ptr = info.iAddress+y*info.iLinePitch;

   364 		TUint8* ptrLimit = ptr+scanLineLength;

   365 		x = 42;

   366 		while(ptr<ptrLimit)

   367 			if(*(ptr++) != (TUint8)~(y^(x++)))

   368 				{

   369 				ERR_PRINTF2(_L("!!!  Failed at compare B, line %d"),y);

   370 				User::Leave(KErrGeneral);

   371 				}

   372 		}

   373 	bitmapSpec.Unlock(iBitmapLockCount);

   374 

   375 	// End

   376 	CleanupStack::PopAndDestroy();	//scanLineBuffer

   377 

   378 	Cleanup();

   379 

   380 	INFO_PRINTF1(_L("  OK"));

   381 	}

   382 

   383 class CTestFbsDevice : public CFbsDevice

   384 	{

   385 public:

   386 	inline CGraphicsAccelerator* StealGraphicsAccelerator()

   387 		{ CGraphicsAccelerator* acc = iGraphicsAccelerator; iGraphicsAccelerator = 0; return acc; };

   388 	};

   389 

   390 

   391 /**

   392  @SYMTestCaseID          GRAPHICS-BITGDI-0022

   393  @SYMCreationDate        21/11/2008

   394  @SYMAuthor              douglashetherington

   395  @SYMTestStatus          3. Released

   396  @SYMTestPriority        High

   397  @SYMTestCaseDesc        Tests various basic graphic operations

   398  @SYMTestExpectedResults Tests should perform graphics operations succesfully.

   399  @SYMTestActions         Creates a number of bitmaps then uses them in various graphic operations

   400  @SYMDEF                 

   401 */

   402 void CTAccelerator::TestGraphicsOperations(TDisplayMode aDisplayMode,TBool aHWBitmap)

   403 	{

   404 	TInt ret=0;

   405 	

   406 	INFO_PRINTF2(_L("  DisplayMode=%d"),aDisplayMode);

   407 	TRAPD(errCode, ret = iBitmap1.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

   408 	if((ret!=KErrNone) || (errCode !=KErrNone) || (!iBitmap1.iDevice->GraphicsAccelerator()))

   409 		{

   410 		WARN_PRINTF1(_L("  Not Supported."));

   411 		return;

   412 		}

   413 

   414 	iGraphicsAccelerator1 = ((CTestFbsDevice*)iBitmap1.iDevice)->StealGraphicsAccelerator();

   415 	delete iGraphicsAccelerator1;

   416 	iGraphicsAccelerator1 = 0;

   417 	

   418 	if(!iSubRegion.IsEmpty())

   419 		iSubRegion.Clear();

   420 	iSubRegion.AddRect(iBitmap1.iBitmap->SizeInPixels());

   421 	iSubRegion.SubRegion(iFixedRegion);

   422 	iSubRegionPtr = &iSubRegion;

   423 	

   424 	TRAP(errCode, ret = iBitmap2.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

   425 	TEST(errCode== KErrNone);

   426 	if(ret!=KErrNone)

   427 		User::Panic(_L("Bitmap not created"),ret);

   428 

   429 	TRAP(errCode, ret = iBitmap3.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

   430 	TEST(errCode== KErrNone);

   431 	if(ret!=KErrNone)

   432 		User::Panic(_L("Bitmap not created"),ret);

   433 

   434 	iGraphicsAccelerator1 = ((CTestFbsDevice*)iBitmap3.iDevice)->StealGraphicsAccelerator();

   435 

   436 	TRAP(errCode, ret = iBitmap4.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

   437 	TEST(errCode== KErrNone);

   438 	if(ret!=KErrNone)

   439 		User::Panic(_L("Bitmap not created"),ret);

   440 

   441 	TRAP(errCode, ret = iBitmap5.ConstructL(aDisplayMode,TestBitmapSize1,aHWBitmap));

   442 	TEST(errCode== KErrNone);

   443 	if(ret!=KErrNone)

   444 		User::Panic(_L("Bitmap not created"),ret);

   445 

   446 	TRAP(errCode, ret = iBitmap6.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

   447 	TEST(errCode== KErrNone);

   448 	if(ret!=KErrNone)

   449 		User::Panic(_L("Bitmap not created"),ret);

   450 

   451 	TRAP(errCode, ret = iBitmap7.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

   452 	TEST(errCode== KErrNone);

   453 	if(ret!=KErrNone)

   454 		User::Panic(_L("Bitmap not created"),ret);

   455 	

   456 	TRAP(errCode, ret = iBitmap8.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap));

   457 	TEST(errCode== KErrNone);

   458 	if(ret!=KErrNone)

   459 		User::Panic(_L("Bitmap not created"),ret);

   460 

   461 	//BrushBitmap

   462     CFbsBitmap* iTile = new CFbsBitmap();

   463 	TEST(iTile!=NULL);

   464 	ret = iTile->Load(_L("z:\\system\\data\\tile.mbm"),0,aHWBitmap);

   465     TEST(ret==KErrNone);

   466 

   467 	TSize tileSize = iTile->SizeInPixels();

   468 	TDisplayMode tileDisplayMode = iTile->DisplayMode();

   469 

   470 	TRAP(errCode, ret = iTileBitmap.ConstructL(tileDisplayMode,tileSize,aHWBitmap));

   471 	TEST(errCode== KErrNone);

   472 	if(ret== KErrNotSupported)

   473 		{

   474 		WARN_PRINTF1(_L("  Not Supported."));

   475 		delete iTile;

   476 		iTile = NULL;

   477 		return;

   478 		}

   479 	iTileBitmap.iGc->BitBlt(TPoint(0,0),iTile);

   480 	delete iTile;

   481 	iTile = NULL;

   482 

   483 	//Alpha bitmap

   484 	TRAP(errCode, ret = iAlphaBitmap.ConstructL(EGray256,TestBitmapSize,aHWBitmap));

   485 	TEST(errCode== KErrNone);

   486 	if(ret!=KErrNone)

   487 		User::Panic(_L("Bitmap not created"),ret);

   488 

   489 	iGraphicsAccelerator2 = ((CTestFbsDevice*)iBitmap4.iDevice)->StealGraphicsAccelerator();

   490 

   491 	INFO_PRINTF1(_L("FilledRect"));

   492 	TestFilledRect();

   493 

   494 	resetColorBitmaps();

   495 

   496 	INFO_PRINTF1(_L("FilledRectWithPattern "));

   497 	TestFilledRectWithPattern();

   498 	

   499 	resetColorBitmaps();

   500 

   501 	INFO_PRINTF1(_L("InvertRect")); 

   502 	TestInvertRect();

   503 	

   504 	resetColorBitmaps();

   505 

   506 	INFO_PRINTF1(_L("FadeRect "));

   507 	TestFadeRect();

   508 	

   509 	resetColorBitmaps();

   510 

   511 	INFO_PRINTF1(_L("BitBlt "));

   512 	TestBitBlt();

   513 	

   514 	resetColorBitmaps();

   515 

   516 	INFO_PRINTF1(_L("BitBltMasked "));

   517 	TestBitBltMasked();

   518 	

   519 	resetColorBitmaps();

   520 

   521 	INFO_PRINTF1(_L("BitBltAlphaBitmap"));

   522 	TestBitBltAlphaBitmap();

   523 

   524 	resetColorBitmaps();

   525 	

   526 	INFO_PRINTF1(_L("AlphaBlendTwoBitmaps "));

   527 	TestAlphaBlendTwoBitmaps();

   528 	

   529 	resetColorBitmaps();

   530 	

   531 	INFO_PRINTF1(_L("AlphaBlendOneBitmap "));

   532 	TestAlphaBlendOneBitmap();

   533 	

   534 	resetColorBitmaps();

   535 

   536 	Cleanup();

   537 	}

   538 

   539 

   540 /**

   541  @SYMTestCaseID          GRAPHICS-BITGDI-0023

   542  @SYMCreationDate        21/11/2008

   543  @SYMAuthor              douglashetherington

   544  @SYMTestStatus          3. Released

   545  @SYMTestPriority        High

   546  @SYMTestCaseDesc        Tests various basic graphic operations draw directly to the screen device

   547  @SYMTestExpectedResults Tests should perform graphics operations succesfully.

   548  @SYMTestActions         Creates a number of bitmaps then uses them in various graphic operations drawing directly to the screen gc

   549  @SYMDEF                 

   550 */

   551 void CTAccelerator::TestGraphicsOperationsWithScreenL(TDisplayMode aDisplayMode,TBool aHWBitmap)

   552 	{

   553 	TInt ret;

   554 

   555 	INFO_PRINTF2(_L("  DisplayMode=%d."),aDisplayMode);

   556 

   557 	ret = iBitmap1.ConstructL(aDisplayMode,TestBitmapSize,aHWBitmap);

   558 	if((ret!=KErrNone) || (!iBitmap1.iDevice->GraphicsAccelerator()))

   559 		{

   560 		WARN_PRINTF1(_L("  Not Supported."));

   561 		return;

   562 		}

   563 

   564 	TRAPD(err,iHwScreenDevice = CFbsScreenDevice::NewL(_L(""),aDisplayMode));

   565 	if(err)

   566 		User::Panic(_L("BitmapDevice not created"),err);

   567 	iHwScreenDevice->ChangeScreenDevice(NULL);

   568 	err = iHwScreenDevice->CreateContext(iScreenGc);

   569 	if(err)

   570 		User::Panic(_L("BitmapDevice not created"),err);

   571 

   572 	TestScreenSize.SetSize(iHwScreenDevice->SizeInPixels().iWidth,iHwScreenDevice->SizeInPixels().iHeight);

   573 	iDefaultScreenRegion.AddRect(TestScreenSize);

   574 

   575 	iBitmap1.Reset();

   576 	iBitmap1.ConstructL(aDisplayMode,TestScreenSize,aHWBitmap);

   577 	iGraphicsAccelerator1 = ((CTestFbsDevice*)iBitmap1.iDevice)->StealGraphicsAccelerator();

   578 	delete iGraphicsAccelerator1;

   579 	iGraphicsAccelerator1 = 0;

   580 	

   581 	if(!iSubRegion.IsEmpty())

   582 		iSubRegion.Clear();

   583 	iSubRegion.AddRect(iBitmap1.iBitmap->SizeInPixels());

   584 	iSubRegion.SubRegion(iFixedRegion);

   585 	iSubRegionPtr = &iSubRegion;

   586 

   587 	ret = iBitmap2.ConstructL(aDisplayMode,TestScreenSize,aHWBitmap);

   588 	if(ret!=KErrNone)

   589 		User::Panic(_L("Bitmap not created"),ret);

   590 

   591 	ret = iBitmap3.ConstructL(aDisplayMode,TestScreenSize,aHWBitmap);

   592 	if(ret!=KErrNone)

   593 		User::Panic(_L("Bitmap not created"),ret);

   594 

   595 	iGraphicsAccelerator1 = ((CTestFbsDevice*)iBitmap3.iDevice)->StealGraphicsAccelerator();

   596 

   597 	ret = iBitmap4.ConstructL(aDisplayMode,TestScreenSize,aHWBitmap);

   598 	if(ret!=KErrNone)

   599 		User::Panic(_L("Bitmap not created"),ret);

   600 

   601 	ret = iBitmap5.ConstructL(aDisplayMode,TestBitmapSize1,aHWBitmap);

   602 	if(ret!=KErrNone)

   603 		User::Panic(_L("Bitmap not created"),ret);

   604 

   605 	ret = iBitmap6.ConstructL(aDisplayMode,TestScreenSize,aHWBitmap);

   606 	if(ret!=KErrNone)

   607 		User::Panic(_L("Bitmap not created"),ret);

   608 

   609 	ret = iBitmap7.ConstructL(aDisplayMode,TestScreenSize,aHWBitmap);

   610 	if(ret!=KErrNone)

   611 		User::Panic(_L("Bitmap not created"),ret);

   612 

   613 	//BrushBitmap

   614     CFbsBitmap* iTile = new CFbsBitmap();

   615 	TEST(iTile!=NULL);

   616 	ret = iTile->Load(_L("z:\\system\\data\\tile.mbm"),0,aHWBitmap);

   617     TEST(ret==KErrNone);

   618 

   619 	TSize tileSize = iTile->SizeInPixels();

   620 	TDisplayMode tileDisplayMode = iTile->DisplayMode();

   621 

   622 	ret= iTileBitmap.ConstructL(tileDisplayMode,tileSize,aHWBitmap);

   623 	if(ret == KErrNotSupported)

   624 		{

   625 		WARN_PRINTF1(_L("  Not Supported."));

   626 		delete iTile;

   627 		iTile = NULL;

   628 		return;

   629 		}

   630 	iTileBitmap.iGc->BitBlt(TPoint(0,0),iTile);

   631 	delete iTile;

   632 	iTile = NULL;

   633 

   634 	//Alpha bitmap

   635 	ret = iAlphaBitmap.ConstructL(EGray256,TestBitmapSize,aHWBitmap);

   636 	if(ret!=KErrNone)

   637 		User::Panic(_L("Bitmap not created"),ret);

   638 

   639 	iGraphicsAccelerator2 = ((CTestFbsDevice*)iBitmap4.iDevice)->StealGraphicsAccelerator();

   640 	resetColorBitmaps();

   641 

   642 	INFO_PRINTF1(_L("FilledRect in the screen"));

   643 	TestScreenFilledRect();

   644 

   645 	resetColorBitmaps();

   646 

   647 	INFO_PRINTF1(_L("FilledRectWithPattern in the screen"));

   648 	TestScreenFilledRectWithPattern();

   649 	

   650 	resetColorBitmaps();

   651 

   652 	INFO_PRINTF1(_L("InvertRect in the screen")); 

   653 	TestScreenInvertRect();

   654 	

   655 	resetColorBitmaps();

   656 

   657 	INFO_PRINTF1(_L("FadeRect in the screen"));

   658 	TestScreenFadeRect();

   659 	

   660 	resetColorBitmaps();

   661 

   662 	INFO_PRINTF1(_L("BitBlt in the screen"));

   663 	TestScreenBitBlt();

   664 	

   665 	resetColorBitmaps();

   666 

   667 	INFO_PRINTF1(_L("BitBltMasked in the screen"));

   668 	TestScreenBitBltMasked();

   669 	

   670 	resetColorBitmaps();

   671 

   672 	INFO_PRINTF1(_L("BitBltAlphaBitmap in the screen"));

   673 	TestScreenBitBltAlphaBitmap();

   674 

   675 	resetColorBitmaps();

   676 

   677 	INFO_PRINTF1(_L("AlphaBlendTwoBitmaps in the screen"));

   678 	TestScreenAlphaBlendTwoBitmaps();

   679 

   680 	resetColorBitmaps();

   681 	

   682 	

   683 	INFO_PRINTF1(_L("AlphaBlendOneBitmap in the screen"));

   684 	TestScreenAlphaBlendOneBitmap();

   685 

   686 	resetColorBitmaps();

   687 	

   688 	INFO_PRINTF1(_L("Rotating the screen"));

   689 	TestScreenRotation();

   690 

   691 	resetColorBitmaps();

   692 

   693 	INFO_PRINTF1(_L("Changing user display mode"));

   694 	TestUserDisplayMode();

   695 

   696 	resetColorBitmaps();

   697 

   698 	Cleanup();

   699 	}

   700 

   701 void CTAccelerator::TestAcceleratorInfo()

   702 	{

   703 	TInt errCode;

   704 	TInt ret=0;

   705 

   706 	iBitmap5.iBitmap=new CFbsBitmap();

   707 	TRAP(errCode, ret=iBitmap5.iBitmap->Load(KRam32BitmapOnZ,0));

   708 	TEST(errCode==KErrNone);

   709 	TEST(ret==KErrNone);

   710 	TAcceleratedBitmapSpec spec(iBitmap5.iBitmap);

   711 	TAcceleratedBitmapInfo info;

   712 	iBitmap5.iBitmap->LockHeap();

   713 	spec.GetInfo(info);

   714 	iBitmap5.iBitmap->UnlockHeap();

   715 	TEST(info.iLinePitch==iBitmap5.iBitmap->Header().iSizeInPixels.iWidth*iBitmap5.iBitmap->Header().iBitsPerPixel/8);

   716 

   717 	TRAP(errCode, ret=iBitmap5.iBitmap->Compress());

   718 	TEST(errCode==KErrNone);

   719 	TEST(ret==KErrNone);

   720 	iBitmap5.iBitmap->LockHeap();

   721 	spec.GetInfo(info);

   722 	iBitmap5.iBitmap->UnlockHeap();

   723 	TEST(info.iLinePitch==-iBitmap5.iBitmap->Header().iCompression);

   724 

   725 	TUint32* romAddress = NULL;

   726 	if(CFbsBitmap::IsFileInRom(KRomC24Bitmap, romAddress))

   727 		{

   728 		TRAP(errCode, ret=iBitmap5.iBitmap->Load(KRomC24Bitmap,0));

   729 		TEST(errCode==KErrNone);

   730 		TEST(ret==KErrNone);

   731 		iBitmap5.iBitmap->LockHeap();

   732 		spec.GetInfo(info);

   733 		iBitmap5.iBitmap->UnlockHeap();

   734 		TEST(info.iLinePitch==-iBitmap5.iBitmap->Header().iCompression);

   735 		}

   736 	else

   737 		{

   738 		INFO_PRINTF2(_L("Skipping ROM bitmap test since file \"%S\" is reported to not be a ROM bitmap."),

   739 				&KRomC24Bitmap);

   740 		INFO_PRINTF1(_L("This should only occur on non-XIP ROMs, e.g. NAND ROMs, where ROM bitmaps aren't supported."));

   741 		}

   742 

   743 	TRAP(errCode, ret=iBitmap5.iBitmap->LoadAndCompress(KRamC24BitmapOnZ,0));

   744 	TEST(errCode==KErrNone);

   745 	TEST(ret==KErrNone);

   746 	iBitmap5.iBitmap->LockHeap();

   747 	spec.GetInfo(info);

   748 	iBitmap5.iBitmap->UnlockHeap();

   749 	TEST(info.iLinePitch==-iBitmap5.iBitmap->Header().iCompression);

   750 

   751 	Cleanup();

   752 	}

   753 

   754 void CTAccelerator::TestAcceleratorInfoForExtendedBitmapL()

   755 	{	

   756 	const TSize KSizeInPixels(64,65);

   757 	const TDisplayMode KDisplayMode	= EColor64K;

   758 	const TUid KExtendedBitmapUid = {0x87654321};

   759 	const TUint8 KTestData[] = "Extended bitmap test data 123456";

   760 	const TInt KTestDataSize = sizeof(KTestData);

   761 	

   762 	CFbsBitmap* exBmp = new (ELeave) CFbsBitmap;

   763 	CleanupStack::PushL(exBmp);

   764 	TInt err = exBmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KExtendedBitmapUid, KTestData, KTestDataSize);

   765 	TEST(err == KErrNone);

   766 	

   767 	TAcceleratedBitmapSpec exSpec(exBmp);

   768 	TAcceleratedBitmapInfo info;

   769 	exBmp->LockHeap();

   770 	err = exSpec.GetInfo(info);

   771 	TEST(err == KErrNone);

   772 	exBmp->UnlockHeap();

   773 	

   774 	TEST(info.iDisplayMode == KDisplayMode);	

   775 	TEST(info.iSize == KSizeInPixels);

   776 	TEST(info.iLinePitch == -EProprietaryCompression);

   777 	TEST(info.iPixelShift == KExtendedBitmapUid.iUid);

   778 	TEST(info.iDataSize == KTestDataSize);

   779 	

   780 	CleanupStack::PopAndDestroy(exBmp);

   781 	}

   782 

   783 const TInt KNumTestFilledRect = 100;

   784 const TInt KNumTestInvertRect = 100;

   785 const TInt KNumTestBitBlt = 100;

   786 const TInt KNumTestFadeRect= 1000;

   787 const TInt KNumTestBitBltMasked= 100;

   788 const TInt KNumTestBitBltAlphaBitmap= 100;

   789 const TInt KNumTestAlphaBlendBitmaps= 100;

   790 

   791 void CTAccelerator::TestFilledRect()

   792 	{

   793 	TInt gopBufferSize = KNumTestFilledRect*sizeof(TGopFilledRect);

   794 	TUint8* gopBuffer = new TUint8[gopBufferSize];

   795 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

   796 

   797 	TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);

   798 	TRect rect;

   799 

   800 	iFixedRegionPtr = &iFixedRegion;

   801 

   802 	iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   803 	iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   804 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

   805 

   806 	iBitmap2.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   807 	iBitmap2.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   808 	iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);

   809 

   810 	TRgb white;

   811 	iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   812 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   813 	iBitmap3.iGc->SetBrushColor(white);

   814 	iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);

   815 

   816 	iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   817 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   818 	iBitmap4.iGc->SetBrushColor(white);

   819 	iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);

   820 

   821 	for(TInt n=0; n<100; n++)

   822 		{

   823 		rect.iTl.iX = Random(TestBitmapSize.iWidth+20)-10;

   824 		rect.iTl.iY = Random(TestBitmapSize.iHeight+20)-10;

   825 		rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth+20);

   826 		rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight+20);

   827 

   828 		

   829 		TRgb colorRect(Random(256),Random(256),Random(256));

   830 

   831 		iBitmap1.iGc->SetBrushColor(colorRect);

   832 		iBitmap1.iGc->DrawRect(rect);

   833 

   834 		iBitmap2.iGc->SetBrushColor(colorRect);

   835 		iBitmap2.iGc->DrawRect(rect);

   836 

   837 		TEST(iBitmap1.Compare(&iBitmap2));

   838 

   839 		rect.Intersection(bitmapRect);

   840 		if( (rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))

   841 			{

   842 			TGopFilledRect gop(rect,colorRect);

   843 			gopDes.Append((TUint8*)&gop,sizeof(gop));

   844 			TInt error = iGraphicsAccelerator1->Operation(gop);

   845 			if(error == KErrNotSupported)

   846 				{

   847 				delete gopBuffer;

   848 				WARN_PRINTF1(_L("  Not Supported."));

   849 				return;

   850 				}

   851 			}

   852 		iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());

   853 	

   854 		TEST(iBitmap2.Compare(&iBitmap3));

   855 		}

   856 

   857 	iGraphicsAccelerator2->Operation(gopDes);

   858 	iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());

   859 	TEST(iBitmap3.Compare(&iBitmap4));

   860 	delete gopBuffer;

   861 	}

   862 

   863 void CTAccelerator::TestFilledRectWithPattern()

   864 	{

   865 	TInt gopBufferSize = KNumTestInvertRect*sizeof(TGopFilledRectWithPattern);

   866 	TUint8* gopBuffer = new TUint8[gopBufferSize];

   867 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

   868 

   869 	TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);

   870 	TRect rect;

   871 

   872 	iFixedRegionPtr = &iFixedRegion;

   873 

   874 	iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   875 	iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   876 	iBitmap1.iGc->SetBrushStyle(CGraphicsContext::EPatternedBrush);

   877 	iBitmap1.iGc->UseBrushPattern(iTileBitmap.iBitmap);

   878 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

   879 	   

   880 	iBitmap2.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   881 	iBitmap2.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   882 	iBitmap2.iGc->SetBrushStyle(CGraphicsContext::EPatternedBrush);

   883 	iBitmap2.iGc->UseBrushPattern(iTileBitmap.iBitmap);

   884 	iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);

   885 

   886 	TRgb white;

   887 	iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   888 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   889 	iBitmap3.iGc->SetBrushColor(white);

   890 	iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);

   891 

   892 	iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   893 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   894 	iBitmap4.iGc->SetBrushColor(white);

   895 	iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);

   896 

   897 	TAcceleratedBitmapSpec patternBitmapSpec(iTileBitmap.iBitmap);

   898 	TGopFillPattern gopFillPattern;

   899 	gopFillPattern.iBitmap = patternBitmapSpec;

   900 

   901 	for(TInt n=0; n<100; n++)

   902 		{

   903 		rect.iTl.iX = Random(TestBitmapSize.iWidth);

   904 		rect.iTl.iY = Random(TestBitmapSize.iHeight);

   905 		rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth);

   906 		rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight);

   907 

   908 		TPoint brushOrigin(Random(TestBitmapSize.iWidth -5),Random(TestBitmapSize.iHeight-5));

   909 

   910 		iBitmap1.iGc->SetBrushOrigin(brushOrigin);

   911 		iBitmap1.iGc->DrawRect(rect);

   912 

   913 		iBitmap2.iGc->SetBrushOrigin(brushOrigin);

   914 		iBitmap2.iGc->DrawRect(rect);

   915 

   916 		TEST(iBitmap1.Compare(&iBitmap2));

   917 		

   918 		rect.Intersection(bitmapRect);

   919 		if( (rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))

   920 			{

   921 			gopFillPattern.iOrigin = brushOrigin;

   922 			TGopFilledRectWithPattern gop(rect,gopFillPattern);

   923 			gopDes.Append((TUint8*)&gop,sizeof(gop));

   924 			TInt error = iGraphicsAccelerator1->Operation(gop);

   925 			if(error == KErrNotSupported)

   926 				{

   927 				delete gopBuffer;

   928 				WARN_PRINTF1(_L("  Not Supported."));

   929 				return;

   930 				}

   931 			}

   932 		iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());

   933 		TEST(iBitmap2.Compare(&iBitmap3));

   934 		}

   935 	iGraphicsAccelerator2->Operation(gopDes);

   936 	iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());

   937 	TEST(iBitmap3.Compare(&iBitmap4));

   938 	iBitmap1.iGc->DiscardBrushPattern();

   939 	delete gopBuffer;

   940 	}

   941 

   942 void CTAccelerator::TestInvertRect()

   943 	{

   944 	TInt gopBufferSize = KNumTestInvertRect*sizeof(TGopInvertRect);

   945 	TUint8* gopBuffer = new TUint8[gopBufferSize];

   946 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

   947 

   948 	TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);

   949 	TRect rect;

   950 

   951 	iFixedRegionPtr = &iFixedRegion;

   952 

   953 	iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   954 	iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   955     iBitmap1.iGc->SetDrawMode(CGraphicsContext::EDrawModeNOTSCREEN);

   956 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

   957 

   958 	iBitmap2.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   959 	iBitmap2.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   960     iBitmap2.iGc->SetDrawMode(CGraphicsContext::EDrawModeNOTSCREEN);

   961 	iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);

   962 

   963 	TRgb white;

   964 	iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   965 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   966 	iBitmap3.iGc->SetBrushColor(white);

   967 	iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);

   968 

   969 	iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);

   970 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   971 	iBitmap4.iGc->SetBrushColor(white);

   972 	iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);

   973 

   974 	for(TInt n=0; n<100; n++)

   975 		{

   976 		rect.iTl.iX = Random(TestBitmapSize.iWidth+20)-10;

   977 		rect.iTl.iY = Random(TestBitmapSize.iHeight+20)-10;

   978 		rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth+20);

   979 		rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight+20);

   980 

   981 		iBitmap1.iGc->DrawRect(rect);

   982 		iBitmap2.iGc->DrawRect(rect);

   983 

   984 		TEST(iBitmap1.Compare(&iBitmap2));

   985 

   986 		rect.Intersection(bitmapRect);

   987 		if((rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))

   988 			{

   989 			TGopInvertRect gop(rect);

   990 			gopDes.Append((TUint8*)&gop,sizeof(gop));

   991 			TInt error = iGraphicsAccelerator1->Operation(gop);

   992 			if(error == KErrNotSupported)

   993 				{

   994 				delete gopBuffer;

   995 				WARN_PRINTF1(_L("  Not Supported."));

   996 				return;

   997 				}

   998 			}

   999 		iBitmap3.iGc->DrawRect(iBitmap3.iBitmap->SizeInPixels());

  1000 		TEST(iBitmap2.Compare(&iBitmap3));

  1001 		}

  1002 	iGraphicsAccelerator2->Operation(gopDes);

  1003 	iBitmap4.iGc->DrawRect(iBitmap4.iBitmap->SizeInPixels());

  1004 	TEST(iBitmap3.Compare(&iBitmap4));

  1005 	delete gopBuffer;

  1006 	}

  1007 

  1008 void CTAccelerator::TestFadeRect()

  1009 	{

  1010 	TInt gopBufferSize = KNumTestFadeRect*sizeof(TGopFadeRect);

  1011 	TUint8* gopBuffer = new TUint8[gopBufferSize];

  1012 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

  1013 

  1014 	TRect bitmapRect(0,0,TestBitmapSize.iWidth,TestBitmapSize.iHeight);

  1015     TRect rect;

  1016 	

  1017 	iFixedRegionPtr = &iFixedRegion;

  1018 

  1019 	iBitmap1.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1020 	iBitmap1.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1021     iBitmap1.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

  1022 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

  1023 

  1024 	iBitmap2.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1025 	iBitmap2.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1026     iBitmap2.iGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

  1027 	iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);

  1028 

  1029 	for(TInt n=0; n<100; n++)

  1030 		{

  1031 		rect.iTl.iX = Random(TestBitmapSize.iWidth);

  1032 		rect.iTl.iY = Random(TestBitmapSize.iHeight);

  1033 		rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize.iWidth);

  1034 		rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize.iHeight);

  1035 

  1036 		TUint8 blackMap = (TUint8)Random(256);

  1037 		TUint8 whiteMap = (TUint8)Random(256);

  1038 

  1039 		RRegion region(rect);

  1040 

  1041 		iBitmap1.iGc->SetFaded(ETrue);

  1042 		iBitmap1.iGc->SetFadingParameters(blackMap,whiteMap);

  1043 		iBitmap1.iGc->FadeArea((TRegion*)&region);

  1044 

  1045 		iBitmap2.iGc->SetFaded(ETrue);

  1046 		iBitmap2.iGc->SetFadingParameters(blackMap,whiteMap);

  1047 		iBitmap2.iGc->FadeArea((TRegion*)&region);

  1048 

  1049 		region.Close();

  1050 

  1051 		TEST(iBitmap1.Compare(&iBitmap2));

  1052 		

  1053 		TGopFadeParams fadeParams;

  1054 		fadeParams.iScale = whiteMap - blackMap + 1;

  1055 		fadeParams.iOffset = blackMap;

  1056 		rect.Intersection(bitmapRect);

  1057 

  1058 		if( (rect.iBr.iX>rect.iTl.iX) && (rect.iBr.iY>rect.iTl.iY))

  1059 			{

  1060 			TGopFadeRect gop(rect,fadeParams);

  1061 			gopDes.Append((TUint8*)&gop,sizeof(gop));

  1062 			TInt error = iGraphicsAccelerator1->Operation(gop);

  1063 			if(error == KErrNotSupported)

  1064 				{

  1065 				WARN_PRINTF1(_L("  Not Supported."));

  1066 				goto quitFade2;

  1067 				}

  1068 			}

  1069 		TEST(iBitmap2.Compare(&iBitmap3));

  1070 		}

  1071 

  1072 	iGraphicsAccelerator2->Operation(gopDes);

  1073 	TEST(iBitmap3.Compare(&iBitmap4));

  1074 quitFade2:

  1075 	delete gopBuffer;

  1076 	iBitmap1.iGc->SetFaded(EFalse);

  1077 	iBitmap2.iGc->SetFaded(EFalse);

  1078 	}

  1079 

  1080 void CTAccelerator::TestBitBlt()

  1081 	{

  1082 	TInt gopBufferSize = KNumTestBitBlt*sizeof(TGopBitBlt);

  1083 	TUint8* gopBuffer = new TUint8[gopBufferSize];

  1084 	TPtr8 gopDes = TPtr8(gopBuffer,0,gopBufferSize);

  1085 

  1086 	//dest bitmap has different size

  1087 	TRect bitmapRect1(0,0,TestBitmapSize1.iWidth,TestBitmapSize1.iHeight);

  1088 

  1089 	TRect rect;

  1090 	iFixedRegionPtr = &iFixedRegion;

  1091 

  1092 	iBitmap1.iGc->SetClippingRegion(iFixedRegionPtr);

  1093 	iBitmap2.iGc->SetClippingRegion(iFixedRegionPtr);

  1094 

  1095 	TRgb white;

  1096 	iBitmap3.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1097 	iBitmap3.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1098 	iBitmap3.iGc->SetBrushColor(white);

  1099 	iBitmap3.iGc->SetClippingRegion(iSubRegionPtr);

  1100 

  1101 	iBitmap4.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1102 	iBitmap4.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1103 	iBitmap4.iGc->SetBrushColor(white);

  1104 	iBitmap4.iGc->SetClippingRegion(iSubRegionPtr);

  1105 

  1106 	TRgb color1(Random(256),Random(256),Random(256));

  1107 

  1108 	iBitmap5.iGc->SetPenStyle(CGraphicsContext::ENullPen);

  1109 	iBitmap5.iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

  1110 	iBitmap5.iGc->SetBrushColor(color1);

  1111 	iBitmap5.iGc->DrawRect(bitmapRect1);

  1112 

  1113 

  1114 	for(TInt n=0; n<100; n++)

  1115 		{

  1116 		rect.iTl.iX = Random(TestBitmapSize1.iWidth);

  1117 		rect.iTl.iY = Random(TestBitmapSize1.iHeight);

  1118 		rect.iBr.iX = rect.iTl.iX+1+Random(TestBitmapSize1.iWidth);

  1119 		rect.iBr.iY = rect.iTl.iY+1+Random(TestBitmapSize1.iHeight);

  1120 

  1121         TPoint pointDest(Random(TestBitmapSize.iWidth),Random(TestBitmapSize.iHeight));

  1122 

  1123 		//bitblt with GC

  1124 		iBitmap1.iGc->BitBlt(pointDest,iBitmap5.iBitmap,rect);

  1125 		iBitmap2.iGc->BitBlt(pointDest,iBitmap5.iBitmap,rect);

  1126 

  1127 		TEST(iBitmap1.Compare(&iBitmap2));

  1128 

  1129 		rect.Intersection(bitmapRect1);

  1130 		TSize maxSize=TestBitmapSize-pointDest;

  1131 		if (rect.Width()>maxSize.iWidth)

  1132 			rect.iBr.iX=rect.iTl.iX+maxSize.iWidth;

  1133 		if (rect.Height()>maxSize.iHeight)

  1134 			rect.iBr.iY=rect.iTl.iY+maxSize.iHeight;

  1135 		if(rect.IsEmpty())