1 // Copyright (c) 2003-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 <random.h>

    17 #include <s32file.h>

    18 #include <e32math.h>

    19 #include <hal.h>

    20 #include <s32mem.h>

    21 #include <graphics/gdi/gdiconsts.h>

    22 #include <e32cmn.h>

    23 #include "BITPANIC.H"

    24 #include "TDefect2.h"

    25 #include "fbsmessage.h"

    26 

    27 //===================================================================

    28 //In order to test multiple screens creation process on the Emulator, 

    29 //you have to extend your epoc.ini file with the following lines

    30 //_NewScreen_

    31 //ScreenWidth 640

    32 //ScreenHeight 480

    33 //===================================================================

    34 

    35 //

    36 //

    37 //Globals

    38 LOCAL_D RFs		FServSession;

    39 

    40 //

    41 //

    42 //Test file names

    43 _LIT(KArchiveFileName, "C:\\FbsBitGcArchive.dat");

    44 

    45 //

    46 //

    47 //Create/Destroy test environment global functions

    48 

    49 //Delete "aFullName" file.

    50 LOCAL_C void DeleteDataFile(const TDesC& aFullName)

    51 	{

    52 	RFs fsSession;

    53 	TInt err = fsSession.Connect();

    54 	if(err == KErrNone)

    55 		{

    56 		TEntry entry;

    57 		if(fsSession.Entry(aFullName, entry) == KErrNone)

    58 			{

    59 			RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName);

    60 			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);

    61 			if(err != KErrNone) 

    62 				{

    63 				RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);

    64 				}

    65 			err = fsSession.Delete(aFullName);

    66 			if(err != KErrNone) 

    67 				{

    68 				RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);

    69 				}

    70 			}

    71 		fsSession.Close();

    72 		}

    73 	else

    74 		{

    75 		RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);

    76 		}

    77 	}

    78 

    79 //

    80 CTDefect2::CTDefect2(CTestStep* aStep):

    81 	CTGraphicsBase(aStep),

    82 	iScrDev(NULL),

    83 	iGc(NULL),

    84 	iSize(0, 0),

    85 	iCurrentMode(ENone),

    86 	iBitmap(NULL),

    87 	iBmpDevice(NULL)

    88 	{

    89 	}

    90 

    91 CTDefect2::~CTDefect2()

    92 	{

    93 	DestroyFont();

    94 	DeleteBitmap();

    95 	DeleteGraphicsContext();

    96 	DeleteBitmapDevice();

    97 	DeleteScreenDevice();

    98 	}

    99 

   100 void CTDefect2::ConstructL()

   101 	{

   102 	User::LeaveIfError(::FServSession.Connect());

   103 	}

   104 

   105 void CTDefect2::RunTestCaseL(TInt aCurTestCase)

   106 	{

   107 	((CTDefect2Step*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

   108 	_LIT(KTest1,"SubTest %d: DEF039237");

   109 	_LIT(KTest2,"SubTest %d: DEF039331");

   110 	_LIT(KTest3,"SubTest %d: DEF039650");

   111 	_LIT(KTest4,"SubTest %d: CFbsBitmap::GetPixel() performance");

   112 	_LIT(KTest5,"SubTest %d: Rotate/Move text");

   113 	_LIT(KTest6,"SubTest %d: SwapWidthAndHeight");

   114 	_LIT(KTest7,"SubTest %d: Create multiple screens");

   115 	_LIT(KTest8,"SubTest %d: Clear with non-zero origin");

   116 	_LIT(KTest9,"SubTest %d: DEF115395: DrawBitmap & DrawBitmapMasked with a sourceRect out of the Bitmap bounds");

   117 	_LIT(KTest10,"SubTest %d: INC119063: General test CopyRect rewrite for low color depth (8,4,2, pixels per byte)");

   118 	_LIT(KTest11,"SubTest %d: INC120917: Dirty Mask Bitmap not remapped in BitBltMasked");

   119 	_LIT(KTest12,"SubTest %d: Zero-sized brush pattern bitmaps");

   120 	_LIT(KTest13,"SubTest %d: CopyRect with non-trivial alpha");

   121 	_LIT(KTest14,"SubTest %d: INC119063: CopyRect reading past end of bitmap data at unallocated pages");

   122 	_LIT(KTest15,"SubTest %d: INC128813 : CFbsBitGc::InternalizeL handle duplicate fail testing");

   123 	_LIT(KTest16,"SubTest %d: DEF132331 : CFbsScreenDevice PixelsToTwips conversions faulty with large inputs");

   124 	_LIT(KTest17,"SubTest %d: DEF137103: CFbsBitmapDevice::SetBits() should check bitmap size");

   125 	switch(aCurTestCase)

   126 		{

   127 	case 1:

   128 		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0066"));

   129 		INFO_PRINTF2(KTest1,aCurTestCase);

   130 		DEF039237L();

   131 		break;

   132 	case 2:

   133 		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0067"));

   134 		INFO_PRINTF2(KTest2,aCurTestCase);

   135 		DEF039331L();

   136 		break;

   137 	case 3:

   138 		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0068"));

   139 		INFO_PRINTF2(KTest3,aCurTestCase);

   140 		DEF039650L();

   141 		break;

   142 	case 4:

   143 		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0069"));

   144 		INFO_PRINTF2(KTest4,aCurTestCase);

   145 		GetPixelPerformance1L();

   146 		break;

   147 	case 5:

   148 		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0070"));

   149 		INFO_PRINTF2(KTest5,aCurTestCase);

   150 		RotateMoveTextL();

   151 		break;

   152 	case 6:

   153 		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0071"));

   154 		INFO_PRINTF2(KTest6,aCurTestCase);

   155 		SwapWidthAndHeightL();

   156 		break;

   157 	case 7:

   158 		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0072"));

   159 		INFO_PRINTF2(KTest7,aCurTestCase);

   160 		CreateScreenDeviceL();

   161 		break;

   162 	case 8:

   163 		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0073"));

   164 		INFO_PRINTF2(KTest8,aCurTestCase);

   165 		NonZeroOriginClearL();

   166 		break;

   167 	case 9:

   168 		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0097"));

   169 		INFO_PRINTF2(KTest9,aCurTestCase);

   170 		DEF115395L();

   171 		break;

   172 	case 10:

   173 		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0099"));

   174 		INFO_PRINTF2(KTest10,aCurTestCase);

   175 		ExerciseCopyRect();

   176 		break;

   177 	case 11:

   178 		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0101"));

   179 		INFO_PRINTF2(KTest11,aCurTestCase);

   180 		TestDirtyMaskBitmapL();

   181 		break;

   182 	case 12:

   183 		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0108"));

   184 		INFO_PRINTF2(KTest12,aCurTestCase);

   185 		ZeroSizedPatternBrushL();

   186 		break;

   187 	case 13:

   188 		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0113"));

   189 		INFO_PRINTF2(KTest13,aCurTestCase);

   190 		CopyRectAlphaL();

   191 		break;

   192 	case 14: 	

   193 		//Note: This test generates panic windows... you may need to put your test before it.

   194 		//They will be closed at the end of the test set, but they may get in the way of your next test, sorry.

   195 		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0098"));

   196 		INFO_PRINTF2(KTest14,aCurTestCase);

   197 		CopyRectReadOutsideBitmap();

   198 		break;

   199 	case 15:

   200 		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0110"));

   201 		INFO_PRINTF2(KTest15,aCurTestCase);

   202 		CFbsBitGcInternalizeLFailL();

   203 		break;

   204 	case 16:

   205 		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0111"));

   206 		INFO_PRINTF2(KTest16,aCurTestCase);

   207 		PixelsToTwipsConversionCheck();

   208 		break;

   209 	case 17:

   210 		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0112"));

   211 		INFO_PRINTF2(KTest17,aCurTestCase);

   212 		TestSetBitsL();

   213 		break;

   214 

   215     case 18:

   216         INFO_PRINTF1(_L("PDEF141192: test CFbsBitGc::DrawBitmapMasked()"));

   217         INFO_PRINTF1(_L("Test Red Channel"));

   218         TestMaskForSelectedValuesL(0);

   219         INFO_PRINTF1(_L("Test Green Channel"));

   220         TestMaskForSelectedValuesL(1);

   221         INFO_PRINTF1(_L("Test Blue Channel"));

   222         TestMaskForSelectedValuesL(2);

   223         break;

   224         

   225 	//Insert tests here

   226 

   227 	case 19:

   228 		((CTDefect2Step*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

   229 		((CTDefect2Step*)iStep)->CloseTMSGraphicsStep();

   230 		TestComplete();

   231 		break;

   232 		}

   233 	((CTDefect2Step*)iStep)->RecordTestResultL();

   234 	}

   235 

   236 /**

   237  * @SYMTestCaseID GRAPHICS-BITGDI-0101

   238  *

   239  * @SYMDEF INC120917

   240  *

   241  * @SYMTestCaseDesc If mask bitmap has been dirtied (by resize/compress) 

   242  * 						then bitbltmasked should not read old memory contents

   243  *

   244  * @SYMTestPriority Normal

   245  *

   246  * @SYMTestStatus Implemented

   247  *

   248  * @SYMTestActions Create image and mask bitmap with  pattern and blit them for reference

   249  * 					create duplicate handle 

   250  * 					resize the mask on duplicate

   251  * 					verify that blit produces same result for same area on larger mask 

   252  * 					and change pattern

   253  * 					blit using duplicate handle and source

   254  * 					blit using original handle and source

   255  * 						in defect scenario these results are different (original same as reference)

   256  * 						in fix scenario they should be same (different to reference)

   257  * 					revalidate original handle reblit and verify now correct

   258  * 

   259  * 					repeat above steps: 

   260  * 					(this proves duplicate change causes original flag, not just duplication)

   261  * 					resize the mask on duplicate

   262  * 					verify that blit produces same result for same area on larger mask 

   263  * 					and change pattern

   264  * 					blit using duplicate handle and source

   265  * 					blit using original handle and source

   266  * 						in defect scenario these results are different (original same as reference)

   267  * 						in fix scenario they should be same (different to reference)

   268  * 					revalidate original handle reblit and verify now correct

   269  */	

   270 void  CTDefect2::TestDirtyMaskBitmapL()

   271 	{

   272 	const TInt 	KWidth=120;

   273 	const TInt	KHeight=50;

   274 	const TInt	KBigger=50;

   275 	enum

   276 		{

   277 		EStepBefore=0,

   278 		EStepVerifyDupGrow,

   279 		EStepDupDiffAfterRefill,

   280 		EStepOriginalDiffAfterRefill,

   281 		EStepOriginalDiffAfterRefillAndGetAddress,

   282 		EStepDupDiffAfterRefill2,

   283 		EStepOriginalDiffAfterRefill2,

   284 		ENumSteps

   285 		};

   286 	TInt pushcount=0;

   287 	//set up the target

   288 	CFbsBitmap* targetBmp=new(ELeave) CFbsBitmap();

   289 	CleanupStack::PushL(targetBmp);pushcount++;	

   290 	User::LeaveIfError(targetBmp->Create(TSize(KWidth,KHeight*ENumSteps), EColor16MU));	

   291 	CFbsBitmapDevice* bmpDevice=CFbsBitmapDevice::NewL(targetBmp);

   292 	CleanupStack::PushL(bmpDevice);pushcount++;	

   293 	CBitmapContext* bmpContext;

   294 	User::LeaveIfError(bmpDevice->CreateBitmapContext(bmpContext));

   295 	CleanupStack::PushL(bmpContext);pushcount++;		

   296 	bmpContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

   297 	bmpContext->SetBrushColor(KRgbRed);	

   298 	bmpContext->Clear();

   299 	

   300 	//set up source and mask

   301 	CFbsBitmap* sourceBmp=new(ELeave) CFbsBitmap();

   302 	CleanupStack::PushL(sourceBmp);pushcount++;		

   303 	User::LeaveIfError(sourceBmp->Create(TSize(KWidth,KHeight), EColor16MU));

   304 	TUint32* sourceData=sourceBmp->DataAddress();

   305 	TInt 	 sourceLength=(sourceBmp->DataStride()>>2)*KHeight;

   306 	CFbsBitmap* maskBmp=new(ELeave) CFbsBitmap();

   307 	CleanupStack::PushL(maskBmp);pushcount++;		

   308 	User::LeaveIfError(maskBmp->Create(TSize(KWidth,KHeight), EGray2));

   309 	TUint32* maskDataStart=maskBmp->DataAddress();

   310 	TInt 	 maskLength=(maskBmp->DataStride()>>2)*KHeight;

   311 

   312 	TUint32* targetData=targetBmp->DataAddress();

   313 	TInt targetCopySize=((targetBmp->DataStride()+3)>>2)*KHeight;

   314 

   315 	TUint32 blueint=KRgbBlue.Color16MU();

   316 	for (TInt fillIndex=0;fillIndex<sourceLength;fillIndex++)

   317 		{

   318 		sourceData[fillIndex]=blueint;

   319 		}

   320 	TInt maskPattern=0x12345678;

   321 	for (TInt fillIndex=0;fillIndex<maskLength;fillIndex++)

   322 		{

   323 		maskDataStart[fillIndex]=maskPattern;

   324 		}

   325 	

   326 	//Initial result of blit operation

   327 	bmpContext->BitBltMasked(TPoint(0,KHeight*EStepBefore),sourceBmp,TSize(KWidth,KHeight),maskBmp,EFalse);

   328 	

   329 	//duplicate the mask handle

   330 	CFbsBitmap* maskBmpDup=new(ELeave) CFbsBitmap();

   331 	CleanupStack::PushL(maskBmpDup);pushcount++;	

   332 	maskBmpDup->Duplicate(maskBmp->Handle());

   333 	TUint32* maskDataDup=maskBmpDup->DataAddress();

   334 	TEST(maskDataDup==maskDataStart);	//not expected to fail

   335 	//resize duplicate handle bigger

   336 	maskBmpDup->Resize(TSize(KWidth+KBigger,KHeight));

   337 	maskDataDup=maskBmpDup->DataAddress();

   338 	TEST(maskDataDup!=maskDataStart);	//not expected to fail

   339 	

   340 	//At this point the duplicate handle is referencing a different address to the original handle.

   341 	//With the defect in place this remains uncorrected, 

   342 	//and is demonstrated by comparing the output contents of blitting using each of the handles. 

   343 	

   344 	//verify that the resizing of the mask preserved the original mask data, so the resize has no effect on small area blit

   345 	bmpContext->BitBltMasked(TPoint(0,KHeight*EStepVerifyDupGrow),sourceBmp,TSize(KWidth,KHeight),maskBmpDup,EFalse);

   346 	

   347 	//If this cmp fails: blit or resize is not working properly on the duplicate handle - not caused by this defect (very unexpected)

   348 	TEST(0==Mem::Compare((TUint8*)(targetData),targetCopySize*4,(TUint8*)(targetData+targetCopySize*EStepVerifyDupGrow),targetCopySize*4));

   349 	

   350 	//Change the mask using the address in the duplicate handle

   351 	//As we want to fill the whole mask with a known pattern we need to recalculate the mask size.

   352 	TInt newMaskLength=(maskBmpDup->DataStride()>>2)*KHeight;

   353 	maskPattern=0xAAAAAAAA;

   354 	for (TInt fillIndex=0;fillIndex<newMaskLength;fillIndex++)

   355 		{	

   356 		maskDataDup[fillIndex]=maskPattern;

   357 		}

   358 	

   359 	//compare the results of blitting using this new mask using each of the two handles to the same mask

   360 	bmpContext->BitBltMasked(TPoint(0,KHeight*EStepDupDiffAfterRefill),sourceBmp,TSize(KWidth,KHeight),maskBmpDup,EFalse);

   361 	//This blit should not crash, even if the defect is present because the previous sized bitmap should not be released until all references have been updated.

   362 

   363 	bmpContext->BitBltMasked(TPoint(0,KHeight*EStepOriginalDiffAfterRefill),sourceBmp,TSize(KWidth,KHeight),maskBmp,EFalse);

   364 

   365 	//If this cmp fails: data change had no effect for duplicate handle (very unexpected)

   366 	TEST(0!=Mem::Compare((TUint8*)(targetData),targetCopySize*4,(TUint8*)(targetData+targetCopySize*EStepDupDiffAfterRefill),targetCopySize*4));

   367 	

   368 	//Check that the result of both blits is the same.

   369 	//If this cmp fails: defect is demonstrated. This is the main defect demonstration test.

   370 	TEST(0==Mem::Compare((TUint8*)(targetData+targetCopySize*EStepDupDiffAfterRefill),targetCopySize*4,(TUint8*)(targetData+targetCopySize*EStepOriginalDiffAfterRefill),targetCopySize*4));

   371 	

   372 	//This revalidates the original handle, hiding the defect

   373 	TUint32* maskDataRevalid=maskBmp->DataAddress();

   374 	TEST(maskDataDup==maskDataRevalid);

   375 	

   376 	//This blit should not crash as the original handle has now been revalidated to point to allocated data. 

   377 	bmpContext->BitBltMasked(TPoint(0,KHeight*EStepOriginalDiffAfterRefillAndGetAddress),sourceBmp,TSize(KWidth,KHeight),maskBmp,EFalse);

   378 	//If this cmp fails: original was not revalidated by DataAddress - content is not same as duplicate

   379 	TEST(0==Mem::Compare((TUint8*)(targetData+targetCopySize*EStepDupDiffAfterRefill),targetCopySize*4,(TUint8*)(targetData+targetCopySize*EStepOriginalDiffAfterRefillAndGetAddress),targetCopySize*4));

   380 

   381 	//Extra testing... do we handle situation where the duplicated handle is changed more than once?

   382 

   383 	//Basically repeats the test sequence above.

   384 	

   385 	//Repeat the resize even bigger using duplicate handle

   386 	//resize duplicate handle bigger

   387 	maskBmpDup->Resize(TSize(KWidth+KBigger,KHeight+KBigger));

   388 	maskDataDup=maskBmpDup->DataAddress();

   389 	TEST(maskDataDup!=maskDataRevalid);

   390 	

   391 	//Change the mask using the address in the duplicate handle

   392 	//As we want to fill the whole mask with a known pattern we need to recalculate the mask size.

   393 	newMaskLength=(maskBmpDup->DataStride()>>2)*(KHeight+KBigger);

   394 	maskPattern=0x55555555;

   395 	for (TInt fillIndex=0;fillIndex<newMaskLength;fillIndex++)

   396 		{	

   397 		maskDataDup[fillIndex]=maskPattern;

   398 		}

   399 	

   400 	//compare the results of blitting using this new mask using each of the two handles to the same mask

   401 	

   402 	bmpContext->BitBltMasked(TPoint(0,KHeight*EStepDupDiffAfterRefill2),sourceBmp,TSize(KWidth,KHeight),maskBmpDup,EFalse);

   403 	//This blit should not crash, even if the defect is present because the previous sized bitmap should not be released until all references have been updated.

   404 	//If it does crash then this demonstrates the defect in that the original address is being used in error and has been freed and paged out

   405 	bmpContext->BitBltMasked(TPoint(0,KHeight*EStepOriginalDiffAfterRefill2),sourceBmp,TSize(KWidth,KHeight),maskBmp,EFalse);

   406 

   407 	//If this cmp fails: data change  had no effect for duplicate handle (very unexpected)

   408 	TEST(0!=Mem::Compare((TUint8*)(targetData+targetCopySize*EStepDupDiffAfterRefill),targetCopySize*4,(TUint8*)(targetData+targetCopySize*EStepDupDiffAfterRefill2),targetCopySize*4));

   409 

   410 	//Check that the result of both blits is the same.

   411 	//If this cmp fails: defect is demonstrated. This is the main defect demonstration test.

   412 	TEST(0==Mem::Compare((TUint8*)(targetData+targetCopySize*EStepDupDiffAfterRefill2),targetCopySize*4,(TUint8*)(targetData+targetCopySize*EStepOriginalDiffAfterRefill2),targetCopySize*4));

   413 	

   414 	

   415 	CleanupStack::PopAndDestroy(pushcount,targetBmp);

   416 	}

   417 

   418  /**

   419   * @SYMTestCaseID GRAPHICS-BITGDI-0097

   420   *

   421   * @SYMDEF DEF115395

   422   *

   423   * @SYMTestCaseDesc Robustness in the CFbsBitGc::DrawBitmap & CFbsBitGc::DrawBitmapMasked functions:

   424   * when a sourceRect is used to capture only a part of the bitmap,

   425   * we have to make sure that the sourceRect is not out of border of the image!

   426   * (if it's the case, we just draw nothing)

   427   *

   428   * @SYMTestPriority Normal

   429   *

   430   * @SYMTestStatus Implemented

   431   *

   432   * @SYMTestActions We create a 8x8 KRgbRed Bitmap and 8x8 Mask (color TRgb(30, 30, 30))

   433   * We try the 2 functions CFbsBitGc::DrawBitmap and CFbsBitGc::DrawBitmapMasked

   434   * with a out of bounds source rectangle on a white output image.

   435   * The output should stay all white.                

   436   *

   437   */  

   438 void CTDefect2::DEF115395L()

   439 	{

   440 	const TSize size=TSize(8, 8);

   441 	const TPoint origin=TPoint(0, 0);

   442 	const TPoint vector=TPoint(2, 2);

   443 	const TRect destRect=TRect(origin, size);

   444 	const TRect srcRect=TRect(origin-vector, size);

   445 	const TBool invertMask=EFalse;

   446 	const TRgb maskColor=TRgb(30, 30, 30);

   447 	TBool succeed=ETrue;

   448 

   449 	// Bitmap creation

   450 	CFbsBitmap* myBmp=new(ELeave) CFbsBitmap();

   451 	CleanupStack::PushL(myBmp);

   452 	User::LeaveIfError(myBmp->Create(size, EColor16MU));

   453 	CFbsBitmapDevice* bmpDevice=CFbsBitmapDevice::NewL(myBmp);

   454 	CleanupStack::PushL(bmpDevice);

   455 	CBitmapContext* bmpContext;

   456 	User::LeaveIfError(bmpDevice->CreateBitmapContext(bmpContext));

   457 	CleanupStack::PushL(bmpContext);

   458 	bmpContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

   459 	bmpContext->SetBrushColor(KRgbRed);

   460 	bmpContext->Clear();

   461 	CleanupStack::PopAndDestroy(2, bmpDevice); // bmpContext, bmpDevice

   462 

   463 	// Mask creation

   464 	CFbsBitmap* myMaskBmp=new(ELeave) CFbsBitmap();

   465 	CleanupStack::PushL(myMaskBmp);

   466 	User::LeaveIfError(myMaskBmp->Create(size, EGray256));

   467 	bmpDevice = CFbsBitmapDevice::NewL(myMaskBmp);

   468 	CleanupStack::PushL(bmpDevice);     

   469 	User::LeaveIfError(bmpDevice->CreateBitmapContext(bmpContext));

   470 	CleanupStack::PushL(bmpContext);

   471 	bmpContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

   472 	bmpContext->SetBrushColor(maskColor);

   473 	bmpContext->Clear();

   474 	CleanupStack::PopAndDestroy(2, bmpDevice); // bmpContext, bmpDevice

   475 

   476 	// Output Image

   477 	CFbsBitmap* outputImg=new(ELeave) CFbsBitmap();

   478 	CleanupStack::PushL(outputImg);

   479 	User::LeaveIfError(outputImg->Create(size, EColor16MU));

   480 	bmpDevice = CFbsBitmapDevice::NewL(outputImg);

   481 	CleanupStack::PushL(bmpDevice);

   482 	User::LeaveIfError(bmpDevice->CreateBitmapContext(bmpContext));

   483 	CleanupStack::PushL(bmpContext);

   484 	bmpContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

   485 	bmpContext->SetBrushColor(KRgbWhite);

   486 	bmpContext->Clear();

   487 

   488 	bmpContext->DrawBitmapMasked(destRect, myBmp, srcRect, myMaskBmp, invertMask);   

   489 	TRgb pixelColor;

   490 	TInt ii,jj;

   491 	for (ii=0;ii<=size.iWidth;ii++)

   492 		{

   493 		for (jj=0;jj<=size.iHeight;jj++)

   494 			{

   495 			outputImg->GetPixel(pixelColor, TPoint(ii,jj));

   496 			if (pixelColor!=KRgbWhite)

   497 				{

   498 				succeed=EFalse;

   499 				break;

   500 				}

   501 			}

   502 		if (!succeed)

   503 			{

   504 			break;

   505 			}

   506 		}

   507 

   508 	bmpContext->Clear();

   509 	bmpContext->DrawBitmap(destRect, myBmp, srcRect);

   510 	for (ii=0;ii<=size.iWidth;ii++)

   511 		{

   512 		for (jj=0;jj<=size.iHeight;jj++)

   513 			{

   514 			outputImg->GetPixel(pixelColor, TPoint(ii,jj));

   515 			if (pixelColor!=KRgbWhite)

   516 				{

   517 				succeed=EFalse;

   518 				break;

   519 				}

   520 			}

   521 		if (!succeed)

   522 			{

   523 			break;

   524 			}

   525 		}

   526 

   527 	TEST(succeed);

   528 	CleanupStack::PopAndDestroy(5);

   529 }

   530 

   531 /**  

   532    @SYMDEF PDEF141192, INC140310         

   533 

   534    @SYMTestCaseDesc Test that the alpha merge method CFbsBitGc::DrawBitmapMasked() works accurately.

   535                     

   536    @SYMTestPriority normal

   537 

   538    @SYMTestStatus Implemented

   539 

   540    @SYMTestActions Create an alpha capable bitmap and throw sample values at the merge function

   541  

   542    @SYMTestExpectedResults

   543    1a)     The merge resultant alpha values do not wrap through 256

   544    1b)     The merge resultant alpha values closely match an equivalent floating-point calculation

   545    2a)     The merge resultant colours do not wrap through 256

   546    2b)     The merge resultant colours do not exceed the resultant alpha if premultiplied output is expected

   547    2c)     The merge resultant colours closely match an equivalent floating-point calculation

   548    2d)     The other resultant colour values are not affected (stay black) 

   549    

   550    @param  aChannelControl which channel is controlled  (0=red, 1= green, 2=blue)

   551    

   552    The input tested format is EColor64K, but could easily be changesd to test other formats.

   553    The input mask is EGray256. If optimised internally, this could be changed to EGray16.

   554    The tested output format is EColor16MAP. This should not be changed. 

   555    

   556    This test is an optimised version of CTDefect2::TestMaskForAllCombinationL(TInt aChannelControl)

   557 */

   558 void CTDefect2::TestMaskForSelectedValuesL(TInt aChannelControl)

   559      {

   560      const TSize size=TSize(1, 1);

   561  

   562      // Bitmap creation

   563      CFbsBitmap* srcBmp=new(ELeave) CFbsBitmap();

   564      CleanupStack::PushL(srcBmp); 

   565      User::LeaveIfError(srcBmp->Create(size, EColor64K)); 

   566      CFbsBitmapDevice* sourceBmpDevice=CFbsBitmapDevice::NewL(srcBmp);

   567      CleanupStack::PushL(sourceBmpDevice);

   568      CBitmapContext* sourceBmpContext;

   569      User::LeaveIfError(sourceBmpDevice->CreateBitmapContext(sourceBmpContext));

   570      CleanupStack::PushL(sourceBmpContext);    

   571      sourceBmpContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

   572      sourceBmpContext->Clear();

   573      CleanupStack::PopAndDestroy(2, sourceBmpDevice); // sourceBmpContext, sourceBmpDevice

   574      

   575      // Mask creation

   576      CFbsBitmap* maskBmp=new(ELeave) CFbsBitmap();

   577      CleanupStack::PushL(maskBmp); 

   578      User::LeaveIfError(maskBmp->Create(size, EGray256)); 

   579      CFbsBitmapDevice* maskBmpDevice=CFbsBitmapDevice::NewL(maskBmp);

   580      CleanupStack::PushL(maskBmpDevice);

   581      CBitmapContext* maskBmpContext;

   582      User::LeaveIfError(maskBmpDevice->CreateBitmapContext(maskBmpContext));

   583      CleanupStack::PushL(maskBmpContext);    

   584      maskBmpContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

   585      maskBmpContext->Clear();

   586      CleanupStack::PopAndDestroy(2, maskBmpDevice); // maskBmpContext, maskBmpDevice

   587           

   588      // Target Bitmap

   589      CFbsBitmap* targetBmp=new(ELeave) CFbsBitmap();

   590      CleanupStack::PushL(targetBmp); 

   591      User::LeaveIfError(targetBmp->Create(size, EColor16MAP)); 

   592      CFbsBitmapDevice* targetBmpDevice=CFbsBitmapDevice::NewL(targetBmp);

   593      CleanupStack::PushL(targetBmpDevice);

   594      CBitmapContext* targetBmpContext;

   595      User::LeaveIfError(targetBmpDevice->CreateBitmapContext(targetBmpContext));

   596      CleanupStack::PushL(targetBmpContext);    

   597      targetBmpContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

   598      targetBmpContext->Clear();

   599      

   600      TSize screenSize = targetBmpDevice->SizeInPixels();

   601      

   602       TInt channelMask; 

   603       TInt channelMul;

   604 

   605       if (aChannelControl<1)

   606           {

   607           channelMask=0xFF0000;   

   608           }

   609       else

   610           {

   611           if(aChannelControl==1)

   612               {

   613               channelMask=0x00FF00;   

   614               }

   615           else

   616               {

   617               channelMask=0x0000FF;   

   618               }

   619           }

   620       channelMul=channelMask&0x01010101;

   621       TInt previousTargetMask = -1;

   622       const TInt otherMask=0xFFFFFF^channelMask;

   623          

   624       for (TInt targetMask=0;targetMask<256;targetMask++)

   625          {

   626          //bkgrdChannel is background channel input value. 

   627          for (TInt targetChannel=0;targetChannel<=targetMask;targetChannel++) 

   628              {

   629              if(targetChannel>(targetMask-10)) // Optimise the loop to test values specific for this defect

   630                  {

   631                  TInt failsPerPass=10;

   632 

   633                  //srcMask is the source mask/alpha

   634                  for (TInt srcMask=0;srcMask<256;srcMask++)

   635                      {  

   636                      if((srcMask<=10)||(srcMask>=250)) // Optimise the loop to test values specific for this defect

   637                          {

   638                          TReal step;

   639                          if (aChannelControl == 1)

   640                              {

   641                              step = 255.0/63;  // Only for blue channel for EColor64K source colour

   642                              }

   643                          else

   644                              {

   645                              step = 255.0/31;                     

   646                              }

   647                          TReal srcChannelReal = 0.0;

   648                          for (TInt srcChannel=0;srcChannel<256;srcChannel=(TInt)srcChannelReal)

   649                              {

   650                              if (targetMask != previousTargetMask)

   651                                  {

   652                                  //uncomment it to print log for each targetMask loop

   653                                  //INFO_PRINTF2(_L("Processing source colours for targetMask=%i"),targetMask);

   654                                  previousTargetMask = targetMask;

   655                                  }

   656                              srcChannelReal += step;

   657                             

   658                              //test blending of one-pixel bitmap

   659                              DoMaskTestL(srcChannel, srcMask, targetMask, targetChannel, aChannelControl, srcBmp, maskBmp, targetBmp, targetBmpContext);

   660 

   661                              TBuf8<4> readBuffer;

   662                              TUint* readPixel = (TUint*)readBuffer.Ptr();

   663                              targetBmp->GetScanLine(readBuffer, TPoint(0, 0), 1, EColor16MAP); 

   664                              

   665                              //channelPixelValue is the channel pixel value as generated from the library code under test

   666                              TUint channelPixelValue=((*readPixel)&channelMask)/channelMul;

   667                              //alphaPixelValue is the alpha pixel value as generated from the library code under test

   668                              TUint alphaPixelValue = (*readPixel)>>24; 

   669                              

   670                              //check if channelPixelValue and alphaPixelValue match the expected ones

   671                              CheckValues(alphaPixelValue, channelPixelValue, failsPerPass, targetMask, targetChannel, srcMask, srcChannel, otherMask, readPixel);

   672                              } 

   673                          }

   674                      }

   675                      if (failsPerPass<0) 

   676                          {       //note that this count may be out by 1... 

   677                          INFO_PRINTF2(_L("Additional %i errors not reported in this pass."),-failsPerPass); 

   678                          }                                    

   679                  }

   680              }

   681          }         

   682      CleanupStack::PopAndDestroy(5);      

   683      }

   684 

   685 void CTDefect2::CheckValues(TUint aAlphaPixelValue, TUint aChannelPixelValue, TInt& aFailsPerPass, TInt aTargetMask, TInt aTargetChannel, TInt aSrcMask, TInt aSrcChannel, TInt aOtherMask, TUint* aReadPixel)

   686    {

   687    const TReal KGross=1.95;

   688    TReal srcMultiplier;

   689    TReal alphaOutputValue;

   690    //source multiplier factor for alpha that can then be used to optimise non-multiplied input calculations.

   691    srcMultiplier=aSrcMask/255.0;

   692    //destination/background multiplier factor for alpha that can then be used to optimise non-multiplied input calculations.

   693    TReal destMultiplier=(aTargetMask/255.0)*(1.0-srcMultiplier);

   694    //alphaOutputValue is a floating-point calculation of the alpha output value using 255.0 as the scaling factor.

   695    alphaOutputValue=(srcMultiplier+destMultiplier)*255.0;

   696 

   697    //alphaDiff is the difference in alpha between pixel and float calcuation, i.e. the error. This can be less than 1 level of brightness, i.e. insignificant.

   698    TReal alphaDiff=0.0;                             

   699    alphaDiff=alphaOutputValue-aAlphaPixelValue;

   700    if (alphaDiff>KGross || alphaDiff<-KGross)

   701        {

   702        if (--aFailsPerPass>0)

   703            {

   704            LogColourEvent(aTargetMask,aTargetChannel,aSrcMask,-1,alphaOutputValue,aAlphaPixelValue,alphaDiff,_L("Big Alpha error: expected %f, got %f"),ETrue);                                     

   705            }                             

   706        }      

   707    //channelOutputValue is a floating-point calculation of the channel output value using 255.0 as the scaling factor.

   708    TReal channelOutputValue=aSrcChannel*srcMultiplier; 

   709    channelOutputValue+=aTargetChannel*(1.0-srcMultiplier);  

   710    

   711    if (aChannelPixelValue>aAlphaPixelValue)

   712        {

   713        if (--aFailsPerPass>0)  

   714            {

   715            LogColourEvent(aTargetMask,aTargetChannel,aSrcMask,aSrcChannel,aAlphaPixelValue,channelOutputValue,aChannelPixelValue,_L("Output multiplied colour exceeds alpha %f: expected %f got %f"),EFalse);                             

   716            INFO_PRINTF1(_L("channelPixelValue>alphaPixelValue"));                                 

   717            }               

   718        }  

   719 

   720    if((aOtherMask&(*aReadPixel))!=0)

   721        {

   722        if (--aFailsPerPass>0)  

   723            {

   724            LogColourEvent(aTargetMask,aTargetChannel,aSrcMask,aSrcChannel,aAlphaPixelValue,channelOutputValue,aChannelPixelValue,_L("Other colours damaged - NOT Zero"),EFalse);                             

   725            }               

   726        }  

   727        

   728    //channelDiff is the difference in channel between pixel and float calcuation, i.e. the error. This can be less than 1 level of brightness, i.e. insignificant.

   729     TReal channelDiff=channelOutputValue-aChannelPixelValue;

   730 

   731     if (channelDiff>KGross || channelDiff<-KGross)

   732         {

   733         if (--aFailsPerPass>0)

   734             {

   735             LogColourEvent(aTargetMask,aTargetChannel,aSrcMask,aSrcChannel,channelOutputValue,aChannelPixelValue,channelDiff,_L("Big Colour error: expected %f, got %f"),EFalse);      

   736             }                          

   737         }                                   

   738    }

   739 

   740 /**

   741 Test of Blending function DrawBitmapMasked(). 

   742 @param aSrcChannel source channel 

   743 @param aSrcMask source mask

   744 @param aTargetMask target mask

   745 @param aTargetChannel target channel

   746 @param aChannelControl which channel is controlled  (0=red, 1= green, 2=blue)

   747 @param aSrcBmp source bitmap

   748 @param aMaskBmp mask bitmap

   749 @param aTargetBmp target bitmap

   750 @param aTargetBmpContext gc for target bitmap 

   751 **/ 

   752 void CTDefect2::DoMaskTestL(TInt aSrcChannel, TInt aSrcMask, TInt aTargetMask, TInt aTargetChannel, TInt aChannelControl, 

   753        CFbsBitmap* aSrcBmp, CFbsBitmap* aMaskBmp, CFbsBitmap* aTargetBmp, CBitmapContext* aTargetBmpContext)

   754    {

   755    const TSize size=TSize(1, 1);

   756    const TRect destRect=TRect(size);  

   757    const TRect srcRect=TRect(size);

   758 

   759    const TInt scanLineLengthEColor16MAP = CFbsBitmap::ScanLineLength(1, EColor16MAP);

   760    HBufC8* targetBuffer = HBufC8::NewL(scanLineLengthEColor16MAP);

   761    CleanupStack::PushL(targetBuffer);

   762    TPtr8 targetDes = targetBuffer->Des();

   763    targetDes.SetLength(scanLineLengthEColor16MAP);

   764    TUint32* targetP = (TUint32*)targetDes.Ptr();

   765    TRgb targetColour(0, 0);

   766    if (aChannelControl<1)

   767        {

   768        targetColour.SetRed(aTargetChannel);                  

   769        }

   770    else

   771        {

   772        if (aChannelControl==1)

   773            {

   774            targetColour.SetGreen(aTargetChannel);                                        

   775            }

   776        else

   777            {

   778            targetColour.SetBlue(aTargetChannel);                                        

   779            }

   780        }

   781    targetColour.SetAlpha(aTargetMask);

   782    *targetP = targetColour.Internal();

   783    aTargetBmp->SetScanLine(targetDes, 0);

   784    

   785    const TInt scanLineLengthEGray256 = CFbsBitmap::ScanLineLength(1, EGray256);

   786    HBufC8* maskBuffer = HBufC8::NewL(scanLineLengthEGray256);

   787    CleanupStack::PushL(maskBuffer);

   788    TPtr8 maskDes = maskBuffer->Des();

   789    maskDes.SetLength(scanLineLengthEGray256);

   790    TUint8* maskP = (TUint8*)maskDes.Ptr();

   791    *maskP = aSrcMask;

   792    aMaskBmp->SetScanLine(maskDes, 0);

   793 

   794    const TInt scanLineLengthEColor64K = CFbsBitmap::ScanLineLength(1, EColor64K);

   795    HBufC8* srcBuffer = HBufC8::NewL(scanLineLengthEColor64K);

   796    CleanupStack::PushL(srcBuffer);

   797    TPtr8 srcDes = srcBuffer->Des();

   798    srcDes.SetLength(scanLineLengthEColor64K);

   799    TUint16* srcP = (TUint16*)srcDes.Ptr();

   800    TRgb srcColour(0);

   801    if (aChannelControl<1)

   802        {

   803        srcColour.SetRed(aSrcChannel);

   804        }

   805    else

   806        {

   807        if (aChannelControl==1)

   808            {

   809            srcColour.SetGreen(aSrcChannel);

   810            }

   811        else

   812            {

   813            srcColour.SetBlue(aSrcChannel);

   814            }

   815        }

   816    

   817    *srcP = srcColour.Color64K();

   818    aSrcBmp->SetScanLine(srcDes, 0);

   819    aTargetBmpContext->DrawBitmapMasked(destRect, aSrcBmp, srcRect, aMaskBmp, EFalse);

   820    

   821    CleanupStack::PopAndDestroy(3);                                        

   822    }

   823 

   824 /**  

   825   @SYMDEF PDEF141192, INC140310         

   826 

   827   @SYMTestCaseDesc Test that the alpha merge method CFbsBitGc::DrawBitmapMasked() works accurately.

   828                    

   829   @SYMTestPriority normal

   830 

   831   @SYMTestStatus Implemented

   832 

   833   @SYMTestActions Create an alpha capable bitmap and throw sample values at the merge function

   834 

   835   @SYMTestExpectedResults

   836   1a)     The merge resultant alpha values do not wrap through 256

   837   1b)     The merge resultant alpha values closely match an equivalent floating-point calculation

   838   2a)     The merge resultant colours do not wrap through 256

   839   2b)     The merge resultant colours do not exceed the resultant alpha if premultiplied output is expected

   840   2c)     The merge resultant colours closely match an equivalent floating-point calculation

   841   2d)     The other resultant colour values are not affected (stay black) 

   842   @param  aChannelControl which channel is controlled  (0=red, 1= green, 2=blue)

   843   

   844    The input tested format is EColor64K, but could easily be changesd to test other formats.

   845    The input mask is EGray256. If optimised internally, this could be changed to EGray16.

   846    The tested output format is EColor16MAP. This should not be changed. 

   847 

   848    This test takes up to 40 minutes to run per channel control. Therefore, it is only kept for local reference, not scheduled for ONB. 

   849    An optimised version CTDefect2::TestMaskForSelectedValuesL(TInt aChannelControl) is run instead for selected combinations of channel and mask values. 

   850 */

   851 void CTDefect2::TestMaskForAllCombinationL(TInt aChannelControl)

   852    {

   853    const TSize size=TSize(1, 1);

   854 

   855    // Bitmap creation

   856    CFbsBitmap* srcBmp=new(ELeave) CFbsBitmap();

   857    CleanupStack::PushL(srcBmp); 

   858    User::LeaveIfError(srcBmp->Create(size, EColor64K)); 

   859    CFbsBitmapDevice* sourceBmpDevice=CFbsBitmapDevice::NewL(srcBmp);

   860    CleanupStack::PushL(sourceBmpDevice);

   861    CBitmapContext* sourceBmpContext;

   862    User::LeaveIfError(sourceBmpDevice->CreateBitmapContext(sourceBmpContext));

   863    CleanupStack::PushL(sourceBmpContext);    

   864    sourceBmpContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

   865    sourceBmpContext->Clear();

   866    CleanupStack::PopAndDestroy(2, sourceBmpDevice); // sourceBmpContext, sourceBmpDevice

   867    

   868    // Mask creation

   869    CFbsBitmap* maskBmp=new(ELeave) CFbsBitmap();

   870    CleanupStack::PushL(maskBmp); 

   871    User::LeaveIfError(maskBmp->Create(size, EGray256)); 

   872    CFbsBitmapDevice* maskBmpDevice=CFbsBitmapDevice::NewL(maskBmp);

   873    CleanupStack::PushL(maskBmpDevice);

   874    CBitmapContext* maskBmpContext;

   875    User::LeaveIfError(maskBmpDevice->CreateBitmapContext(maskBmpContext));

   876    CleanupStack::PushL(maskBmpContext);    

   877    maskBmpContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

   878    maskBmpContext->Clear();

   879    CleanupStack::PopAndDestroy(2, maskBmpDevice); // maskBmpContext, maskBmpDevice

   880         

   881    // Target Bitmap

   882    CFbsBitmap* targetBmp=new(ELeave) CFbsBitmap();

   883    CleanupStack::PushL(targetBmp); 

   884    User::LeaveIfError(targetBmp->Create(size, EColor16MAP)); 

   885    CFbsBitmapDevice* targetBmpDevice=CFbsBitmapDevice::NewL(targetBmp);

   886    CleanupStack::PushL(targetBmpDevice);

   887    CBitmapContext* targetBmpContext;

   888    User::LeaveIfError(targetBmpDevice->CreateBitmapContext(targetBmpContext));

   889    CleanupStack::PushL(targetBmpContext);    

   890    targetBmpContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

   891    targetBmpContext->Clear();

   892    

   893    TSize screenSize = targetBmpDevice->SizeInPixels();

   894    

   895     TInt channelMask; 

   896     TInt channelMul;

   897 

   898     if (aChannelControl<1)

   899         {

   900         channelMask=0xFF0000;   

   901         }

   902     else

   903         {

   904         if(aChannelControl==1)

   905             {

   906             channelMask=0x00FF00;   

   907             }

   908         else

   909             {

   910             channelMask=0x0000FF;   

   911             }

   912         }

   913     channelMul=channelMask&0x01010101;

   914     TInt previousTargetMask = -1;

   915     const TInt otherMask=0xFFFFFF^channelMask;

   916        

   917     for (TInt targetMask=0;targetMask<256;targetMask++)

   918        {

   919        //bkgrdChannel is background channel input value. 

   920        for (TInt targetChannel=0;targetChannel<=targetMask;targetChannel++) 

   921            {

   922            TInt failsPerPass=10;

   923 

   924             //srcMask is the source mask/alpha

   925            for (TInt srcMask=0;srcMask<256;srcMask++)

   926                {  

   927                TReal step;

   928                if (aChannelControl == 1)

   929                    {

   930                    step = 255.0/63; // Only for blue channel for EColor64K source colour

   931                    }

   932                else

   933                    {

   934                    step = 255.0/31;                     

   935                    }

   936                TReal srcChannelReal = 0.0;

   937 

   938                for (TInt srcChannel=0;srcChannel<256;srcChannel=(TInt)srcChannelReal)

   939                    {

   940                    if (targetMask != previousTargetMask)

   941                        {

   942                        INFO_PRINTF2(_L("Processing source colours for targetMask=%i"),targetMask);

   943                        previousTargetMask = targetMask;

   944                        }

   945                    srcChannelReal += step;

   946                    

   947                    //test blending of one-pixel bitmap

   948                    DoMaskTestL(srcChannel, srcMask, targetMask, targetChannel, aChannelControl, srcBmp, maskBmp, targetBmp, targetBmpContext);

   949                    

   950                    TBuf8<4> readBuffer;

   951                    TUint* readPixel = (TUint*)readBuffer.Ptr();

   952                    targetBmp->GetScanLine(readBuffer, TPoint(0, 0), 1, EColor16MAP);                

   953 

   954                    //channelPixelValue is the channel pixel value as generated from the library code under test

   955                    TUint channelPixelValue=((*readPixel)&channelMask)/channelMul;

   956                    //alphaPixelValue is the alpha pixel value as generated from the library code under test

   957                    TUint alphaPixelValue = (*readPixel)>>24; 

   958                    

   959                    //check if channelPixelValue and alphaPixelValue match the expected ones

   960                    CheckValues(alphaPixelValue, channelPixelValue, failsPerPass, targetMask, targetChannel, srcMask, srcChannel, otherMask, readPixel);

   961                     

   962                if (failsPerPass<0) 

   963                    {       //note that this count may be out by 1... 

   964                    INFO_PRINTF2(_L("Additional %i errors not reported in this pass."),-failsPerPass); 

   965                    }                  

   966                } 

   967            } 

   968            }

   969        }         

   970    CleanupStack::PopAndDestroy(5);      

   971    }

   972 

   973 /**

   974 This function is used to write to the log file

   975 @param  aNonPreMulDestPixColor non pre multiplied destination pixel colour

   976 @param  aPreMulSrcPixelColor pre multiplied source pixel colour

   977 @param  aNonPreMulSrcPixelColor non pre multiplied source pixel colour

   978 @param  aVal1 it contains the value of the first variable of the message to be displayed

   979 @param  aVal2 it contains the value of the second variable of the message to be displayed

   980 @param  aVal3 it contains the value of the third variable of the message to be displayed

   981 @param  aMsg it contains the message to be printed to the log file

   982 @param  aErr if true then the test case fails, if false test passes. log is printed in both the case. TEST does not abort, just reports test case failure

   983 */

   984 void CTDefect2::LogColourEvent(TInt aPreMulDestPixColor,TInt aNonPreMulDestPixColor,TInt aPreMulSrcPixelColor,TInt aNonPreMulSrcPixelColor,TReal aVal1,TReal aVal2,TReal aVal3,TRefByValue<const TDesC> aMsg,TBool aErr)

   985    {

   986    TEST(aErr==EFalse); // if aErr=True, then the previous test step failed.

   987    INFO_PRINTF4(aMsg,aVal1,aVal2,aVal3);

   988    if (aNonPreMulSrcPixelColor<0)

   989        {

   990        INFO_PRINTF4(_L("Processing source colours for MDest=%i, CDest=%i, MSrc=%i"),aPreMulDestPixColor,aNonPreMulDestPixColor,aPreMulSrcPixelColor);

   991        }

   992    else

   993        {

   994        INFO_PRINTF5(_L("Processing colour set MDest=%i, CDest=%i, MSrc=%i, CSrc=%i"),aPreMulDestPixColor,aNonPreMulDestPixColor,aPreMulSrcPixelColor,aNonPreMulSrcPixelColor);

   995        }

   996    }

   997 

   998 class TFunctionThread

   999 	{

  1000 protected:

  1001 	TFunctionThread():iExitHow(ENotStarted)	

  1002 		{}

  1003 	TInt LaunchThreadFunction(const TDesC& aName);

  1004 private:

  1005 	static TInt TheThreadFunction(TAny*);

  1006 	virtual TInt	ThreadFunctionL()=0;

  1007 public:

  1008 	enum {

  1009 		ENotStarted,

  1010 		ERunning,	//should never see this

  1011 		EReturn,

  1012 		ELeave,

  1013 		EPanic,

  1014 		ETerminate,

  1015 		};

  1016 	TInt	iExitHow;

  1017 	TInt	iExitCode;	//Currently don't store the panic category string.

  1018 	};

  1019 

  1020 TInt TFunctionThread::LaunchThreadFunction(const TDesC& aName)

  1021 	{

  1022 	RThread thrd;

  1023 	TRequestStatus stat;

  1024 	enum { //8kb to 2mb

  1025 		KMinHeapSize=0x2000,

  1026 		KMaxHeapSize=0x200000

  1027 		};

  1028 	TInt created=thrd.Create(aName,TheThreadFunction,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,this);

  1029 	if (created<KErrNone)

  1030 		{

  1031 		iExitCode=created;

  1032 		return created;

  1033 		}

  1034 	thrd.SetPriority(EPriorityMuchMore);

  1035 	thrd.Logon(stat);

  1036 	User::SetJustInTime(EFalse);

  1037 	thrd.Resume();

  1038 	User::WaitForRequest(stat);

  1039 	if ( iExitHow!=ENotStarted || iExitHow==ERunning )

  1040 		{

  1041 		iExitCode=thrd.ExitReason();

  1042 		switch (thrd.ExitType())

  1043 			{

  1044 			case EExitKill:			iExitHow=EReturn;		break;

  1045 			case EExitPanic:		iExitHow=EPanic;		break;

  1046 			case EExitTerminate:	iExitHow=ETerminate;	break;

  1047 			default:

  1048 				ASSERT(EFalse);

  1049 			}

  1050 		}

  1051 	thrd.Close();

  1052 	User::SetJustInTime(ETrue);

  1053 	return KErrNone;

  1054 	}

  1055 

  1056 TInt TFunctionThread::TheThreadFunction(TAny* aThis)

  1057 	{

  1058 	TFunctionThread* thisThis=(TFunctionThread*)aThis;

  1059 	if (thisThis==NULL)

  1060 		{

  1061 		User::Panic(_L("NoThis"),0x1);

  1062 		}

  1063 	TInt leaveErr = RFbsSession::Connect();

  1064 	if (leaveErr != KErrNone)

  1065 		{

  1066 		thisThis->iExitHow = ELeave;

  1067 		thisThis->iExitCode = leaveErr;

  1068 		return leaveErr;

  1069 		}

  1070 	thisThis->iExitHow=thisThis->ERunning;

  1071 	CTrapCleanup* cleanup = CTrapCleanup::New();

  1072 	TInt returnErr=KErrNone;

  1073 	TRAP(leaveErr, returnErr = thisThis->ThreadFunctionL());

  1074 	if (leaveErr)

  1075 		{

  1076 		thisThis->iExitHow=ELeave;

  1077 		thisThis->iExitCode=leaveErr;

  1078 		delete cleanup;

  1079 		RFbsSession::Disconnect();

  1080 		return leaveErr;

  1081 		}

  1082 	else

  1083 		{

  1084 		thisThis->iExitHow=EReturn;

  1085 		thisThis->iExitCode=returnErr;

  1086 		delete cleanup;

  1087 		RFbsSession::Disconnect();

  1088 		return returnErr;

  1089 		}

  1090 	}

  1091 

  1092 /** This thread verifies whether a range of memory is accessible 

  1093   The range is read sequentially until it panics, or the range is completed.

  1094   It is useful to input a range of addresses where some are valid and some fail 

  1095   in order to demonstrate an edge against which an algorithm that performs illegal reads can subsequently be tested.

  1096   The FailOffset() returned index indicates the offset from the start at which the memory access caused a panic. 

  1097  **/

  1098 class TTestMemThread:public TFunctionThread

  1099 	{

  1100 public:

  1101 	TTestMemThread(TUint32* aStartAddress,TUint32* aEndAddress);

  1102 	TInt FailOffset();

  1103 private:

  1104 	virtual TInt	ThreadFunctionL();

  1105 private:

  1106 	TUint32* iStartAddress;

  1107 	TUint32* iEndAddress;

  1108 	volatile TUint32* iLastAddressTried;

  1109 	volatile TUint32  iCopyValueHere;

  1110 	

  1111 	};

  1112 

  1113 TTestMemThread::TTestMemThread(TUint32* aStartAddress,TUint32* aEndAddress):

  1114 	iStartAddress(aStartAddress),

  1115 	iEndAddress(aEndAddress),

  1116 	iLastAddressTried(NULL)

  1117 	{

  1118 	ASSERT(aStartAddress);

  1119 	ASSERT(aEndAddress);

  1120 	LaunchThreadFunction(_L("MemTest"));

  1121 	}

  1122 

  1123 /**

  1124  *	Returns the number of successful memory reads before a panic occurred

  1125  * 	Or various error codes if the test didn't run or didn't panic.

  1126  * 

  1127  **/

  1128 TInt TTestMemThread::FailOffset()

  1129 	{

  1130 	if (iExitHow==EReturn)

  1131 		{

  1132 		return KErrCompletion;

  1133 		}

  1134 	else