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 <hal.h>

    17 #include <bautils.h>

    18 #include <bitdraw.h>

    19 #include <s32mem.h>

    20 #include "TDefect.h"

    21 #include <graphics/bitmap.inl>

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

    23 

    24 _LIT(KRamBitmapOnZ, "z:\\system\\data\\16RAM.mbm");

    25 _LIT(KRamCBitmapOnZ, "z:\\system\\data\\16RAMC.mbm");

    26 

    27 _LIT(KRamBitmap, "c:\\16RAM.mbm");

    28 _LIT(KRamCBitmap, "c:\\16RAMC.mbm");

    29 

    30 _LIT(KZeroSizeMbmRam, "c:\\ZeroSizeRam.mbm");

    31 _LIT(KZeroSizeMbmZ, "z:\\system\\data\\ZeroSizeRam.mbm");

    32 

    33 _LIT(KRomBitmap, "z:\\system\\data\\16ROM.mbm");

    34 _LIT(KRomCBitmap, "z:\\system\\data\\16ROMC.mbm");

    35 

    36 _LIT(KRomRsc_RomMbm, "z:\\system\\data\\RomRsc_RomMbm.rsc");

    37 _LIT(KRomRsc_RomMbm2, "z:\\system\\data\\RomRsc_RomMbm2.rsc");

    38 _LIT(KRamRsc_RamMbmOnZ, "z:\\system\\data\\RamRsc_RamMbm.rsc");

    39 _LIT(KRamRsc_RamMbm2OnZ, "z:\\system\\data\\RamRsc_RamMbm2.rsc");

    40 _LIT(KRamRsc_RamMbm, "c:\\RamRsc_RamMbm.rsc");

    41 _LIT(KRamRsc_RamMbm2, "c:\\RamRsc_RamMbm2.rsc");

    42 _LIT(KRscFileHeader, "z:\\system\\data\\RscHeader2.bin");

    43 _LIT(KRscFileData, "z:\\system\\data\\DummyRscFile.rsc");

    44 _LIT(KRomRsc_RamMbm, "z:\\system\\data\\RomRsc_RamMbm.rsc");

    45 _LIT(KRamRsc_RomMbmOnZ, "z:\\system\\data\\RamRsc_RomMbm.rsc");

    46 _LIT(KRamRsc_RomMbm, "c:\\RamRsc_RomMbm.rsc");

    47 _LIT(KRamRsc_RomMbm2OnZ, "z:\\system\\data\\RamRsc_RomMbm2.rsc");

    48 _LIT(KRamRsc_RomMbm2, "c:\\RamRsc_RomMbm2.rsc");

    49 _LIT(KRomRsc_RamMbm2, "z:\\system\\data\\RomRsc_RamMbm2.rsc");

    50 

    51 _LIT(KComprRamBitmap16, "z:\\system\\data\\paint16ramc.mbm");

    52 _LIT(KComprRomBitmap16, "z:\\system\\data\\paint16romc.mbm");

    53 _LIT(KComprRamBitmap24, "z:\\system\\data\\paint24ramc.mbm");

    54 _LIT(KComprRomBitmap24, "z:\\system\\data\\paint24romc.mbm");

    55 

    56 _LIT(KComprRamBitmap8, "z:\\system\\data\\8ramc.mbm");

    57 _LIT(KComprRomBitmap8, "z:\\system\\data\\8romc.mbm");

    58 _LIT(KComprRamBitmap12, "z:\\system\\data\\12ramc.mbm");

    59 _LIT(KComprRomBitmap12, "z:\\system\\data\\12romc.mbm");

    60 

    61 _LIT(KTestBmp, "z:\\system\\data\\BmCTest.mbm");

    62 

    63 _LIT(KBitBltSrcBmp, "z:\\system\\data\\BitBltSrc.mbm");

    64 _LIT(KBitBltMaskedBmp, "z:\\system\\data\\BitBltMasked.mbm");

    65 

    66 _LIT(KBmpCompr12, "z:\\system\\data\\compr12_2.mbm");

    67 _LIT(KBmpCompr16, "z:\\system\\data\\compr16_2.mbm");

    68 _LIT(KBmpZCompr12, "z:\\system\\data\\racompr12_2.mbm");

    69 _LIT(KBmpZCompr16, "z:\\system\\data\\racompr16_2.mbm");

    70 _LIT(KBmpCCompr12, "c:\\racompr12_2.mbm");

    71 _LIT(KBmpCCompr16, "c:\\racompr16_2.mbm");

    72 

    73 _LIT(KBmp16_1, "c:\\Mbm16_1.mbm");

    74 _LIT(KBmp16_2, "c:\\Mbm16_2.mbm");

    75 _LIT(KBmp16_3, "c:\\Mbm16_3.mbm");

    76 

    77 _LIT(KRam24BitmapOnZ, "z:\\system\\data\\24RAM.mbm");

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

    79 

    80 _LIT(KRam24Bitmap, "c:\\24RAM.mbm");

    81 _LIT(KRamC24Bitmap, "c:\\24RAMC.mbm");

    82 

    83 _LIT(KRom24Bitmap, "z:\\system\\data\\24ROM.mbm");

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

    85 

    86 //Note: Do not name functions with Defect numbers, instead give a meaningful name.

    87 

    88 //

    89 //

    90 //Note: Some display modes will be scaled - see 

    91 //CTDefect::CreateScreenDeviceL(TDisplayMode aDisplayMode, TAllowScaling aScaling),

    92 //SetScalingFactor() call

    93 

    94 //

    95 //

    96 //If we have to handle RAM located file with an embedded ROM mbm file section - 

    97 //KRomMBMInRamRSC should be ETrue.

    98 //If it is not allowed to do that - KRomMBMInRamRSC should be EFalse.

    99 //#pragma warning(disable : 4127)   //conditional expression is constant

   100 //Constant KRomMBMInRamRSc removed temporarily due to invalid test scenario

   101 //LOCAL_D const TBool KRomMBMInRamRSC = EFalse;

   102 

   103 //

   104 //

   105 

   106 //

   107 //

   108 //Globals

   109 LOCAL_D RFs		TheFs;

   110 //Delay time in microseconds, used at the end of some test methods

   111 const TInt		KDelayTime = 1;//1500000;

   112 

   113 //

   114 //

   115 //Create/Destroy test environment global functions

   116 

   117 //Delete "aFullName" file.

   118 LOCAL_C void DeleteDataFile(const TDesC& aFullName)

   119 	{

   120 	RFs fsSession;

   121 	TInt err = fsSession.Connect();

   122 	if(err == KErrNone)

   123 		{

   124 		TEntry entry;

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

   126 			{

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

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

   129 			if(err != KErrNone) 

   130 				{

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

   132 				}

   133 			err = fsSession.Delete(aFullName);

   134 			if(err != KErrNone) 

   135 				{

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

   137 				}

   138 			}

   139 		fsSession.Close();

   140 		}

   141 	else

   142 		{

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

   144 		}

   145 	}

   146 

   147 //Copy test bitmaps from Z: to C: drive. RFs::Connect() had to be called already 

   148 //on "TheFs" object.

   149 LOCAL_C void CopyDataFiles()

   150 	{

   151 	BaflUtils::CopyFile(TheFs, KRamBitmapOnZ, KRamBitmap);

   152 	BaflUtils::CopyFile(TheFs, KRamCBitmapOnZ, KRamCBitmap);

   153 	BaflUtils::CopyFile(TheFs, KRamRsc_RamMbmOnZ, KRamRsc_RamMbm);

   154 	BaflUtils::CopyFile(TheFs, KRamRsc_RamMbm2OnZ, KRamRsc_RamMbm2);

   155 	BaflUtils::CopyFile(TheFs, KRamRsc_RomMbmOnZ, KRamRsc_RomMbm);

   156 	BaflUtils::CopyFile(TheFs, KRamRsc_RomMbm2OnZ, KRamRsc_RomMbm2);

   157 	BaflUtils::CopyFile(TheFs, KZeroSizeMbmZ, KZeroSizeMbmRam);

   158 	BaflUtils::CopyFile(TheFs, KBmpZCompr12, KBmpCCompr12);

   159 	BaflUtils::CopyFile(TheFs, KBmpZCompr16, KBmpCCompr16);

   160 	BaflUtils::CopyFile(TheFs, KRamBitmap, KBmp16_1);

   161 	BaflUtils::CopyFile(TheFs, KRamBitmap, KBmp16_2);

   162 	BaflUtils::CopyFile(TheFs, KRamBitmap, KBmp16_3);

   163 	BaflUtils::CopyFile(TheFs, KRam24BitmapOnZ, KRam24Bitmap);

   164 	BaflUtils::CopyFile(TheFs, KRamC24BitmapOnZ, KRamC24Bitmap);

   165 	}

   166 

   167 //Delete data files used by the test

   168 LOCAL_C void DeleteDataFiles()

   169 	{

   170 	DeleteDataFile(KRamBitmap);

   171 	DeleteDataFile(KRamCBitmap);

   172 	DeleteDataFile(KRamRsc_RamMbm);

   173 	DeleteDataFile(KRamRsc_RamMbm2);

   174 	DeleteDataFile(KRamRsc_RomMbm);

   175 	DeleteDataFile(KRamRsc_RomMbm2);

   176 	DeleteDataFile(KRam24Bitmap);

   177 	DeleteDataFile(KRamC24Bitmap);

   178 	DeleteDataFile(_L("c:\\temp.mbm"));

   179 	DeleteDataFile(_L("c:\\temp2.mbm"));

   180 	DeleteDataFile(KZeroSizeMbmRam );

   181 	DeleteDataFile(KBmpCCompr12);

   182 	DeleteDataFile(KBmpCCompr16);

   183 	DeleteDataFile(KBmp16_1);

   184 	DeleteDataFile(KBmp16_2);

   185 	DeleteDataFile(KBmp16_3);

   186 	}

   187 

   188 //

   189 //

   190 //Global functions

   191 

   192 //Return file size in bytes of "aFileName" file.

   193 LOCAL_C TInt FileSizeL(const TDesC& aFileName)

   194 	{

   195 	RFile file;

   196 	User::LeaveIfError(file.Open(TheFs, aFileName, EFileRead));

   197 	CleanupClosePushL(file);

   198 	TInt size = 0;

   199 	User::LeaveIfError(file.Size(size));

   200 	CleanupStack::PopAndDestroy(&file);

   201 	return size;

   202 	}

   203 

   204 //Creates CFbsBitGcBitmap instance and loads it with bitmap N#0 from "aFileName" file.

   205 //CFbsBitGcBitmap instance will be pushed in the cleanup stack.

   206 CFbsBitGcBitmap* LoadBitmapLC(const TDesC& aFileName)

   207 	{

   208 	CFbsBitGcBitmap* bmp = new (ELeave) CFbsBitGcBitmap;

   209 	CleanupStack::PushL(bmp);

   210 	User::LeaveIfError(bmp->Load(aFileName, 0));

   211 	return bmp;

   212 	}

   213 

   214 //Creates "SIZE" CFbsBitGcBitmap instance and loads them with bitmap N#0 from "aBmpFiles" 

   215 //files. CFbsBitGcBitmap instances will be pushed in the cleanup stack.

   216 template <TInt SIZE> void LoadBitmapsLC(CFbsBitGcBitmap* (*aBmp)[SIZE], TPtrC aBmpFiles[])

   217 	{

   218 	for(TInt ii=0;ii<SIZE;ii++)

   219 		{

   220 		(*aBmp)[ii] = LoadBitmapLC(aBmpFiles[ii]);

   221 		}

   222 	}

   223 

   224 //Displays "aBmp" array of bitmaps.

   225 template <TInt SIZE> void DisplayBitmaps(CFbsBitGcBitmap* (*aBmp)[SIZE], 

   226 										 CFbsScreenDevice* aDevice, 

   227 										 CFbsBitGc* aGc)

   228 	{

   229 	for(TInt ii=0;ii<SIZE;ii++)

   230 		{

   231 		TSize size = (*aBmp)[ii]->SizeInPixels();

   232 		aGc->Clear();

   233 		aGc->DrawBitmap(TRect(size), (*aBmp)[ii]);

   234 		aDevice->Update();

   235 		User::After(KDelayTime);

   236 		}

   237 	}

   238 

   239 //Destroys "aBmp" array of bitmaps.

   240 template <TInt SIZE> void DestroyBitmaps(CFbsBitGcBitmap* (*aBmp)[SIZE])

   241 	{

   242 	for(TInt ii=(SIZE-1);ii>-1;ii--)

   243 		{

   244 		CleanupStack::PopAndDestroy((*aBmp)[ii]);

   245 		}

   246 	}

   247 

   248 //Compares 2 bitmaps from "aBmp" array.

   249 //The first bitmap index is aBmp1, the second bitmap index is aBmp2.

   250 //The function compares bitmaps line by line and asserts their pixel values.

   251 template <TInt SIZE, TInt MAXLEN> void CompareBitmaps(CFbsBitGcBitmap* (*aBmp)[SIZE], 

   252 													  TDisplayMode aDispMode,

   253 													  TInt aBmp1, 

   254 													  TInt aBmp2,

   255 													  CTGraphicsBase *aTest)

   256 	{

   257 	TUint8 line1[MAXLEN];

   258 	TUint8 line2[MAXLEN];

   259 	TPtr8 p1(line1, MAXLEN, MAXLEN);

   260 	TPtr8 p2(line2, MAXLEN, MAXLEN);

   261 	TSize size1 = (*aBmp)[aBmp1]->SizeInPixels();

   262 	TSize size2 = (*aBmp)[aBmp2]->SizeInPixels();

   263 	TInt minHeight = Min(size1.iHeight, size2.iHeight);

   264 	TInt minWidth = Min(size1.iWidth, size2.iWidth);

   265 	for(TInt ii=0;ii<minHeight;ii++)

   266 		{

   267 		(*aBmp)[aBmp1]->GetScanLine(p1, TPoint(0,ii), minWidth, aDispMode);

   268 		(*aBmp)[aBmp2]->GetScanLine(p2, TPoint(0,ii), minWidth, aDispMode);

   269 		aTest->TEST(p1.Length() == p2.Length());

   270 		for(TInt j=0;j<p1.Length();j++)

   271 			{

   272 			aTest->TEST(line1[j] == line2[j]);

   273 			}

   274 		}

   275 	}

   276 

   277 //Compares the Alpha Channel Values of the First Pixel in the two bitmaps.

   278 //The pixel value is obtained from DataAddress().

   279 TBool CompareFirstPixelAlphaChannel(CFbsBitmap* aBmp1, CFbsBitmap* aBmp2)

   280 	{

   281 	return ( (*aBmp1->DataAddress() & 0xff000000) == (*aBmp2->DataAddress() & 0xff000000) );

   282 	}

   283 

   284 //

   285 //

   286 

   287 CTDefect::CTDefect(CTestStep* aStep) :

   288 	CTGraphicsBase(aStep), 

   289 	iDevice(NULL),

   290 	iBmpDevice(NULL),

   291 	iGc(NULL),

   292 	iBitmap(NULL),

   293 	iSize(0, 0),

   294 	iCurrentMode(ENone)

   295 	{

   296 	}

   297 

   298 CTDefect::~CTDefect()

   299 	{

   300 	DestroyFont();

   301 	DeleteBitmap();

   302 	DeleteGraphicsContext();

   303 	DeleteBitmapDevice();

   304 	DeleteScreenDevice();

   305 	}

   306 

   307 void CTDefect::ConstructL()

   308 	{

   309 	INFO_PRINTF1(_L("Create screen device"));

   310 	CreateScreenDeviceL();

   311 

   312 	TUint32* romAddress = NULL;

   313 	if(!CFbsBitmap::IsFileInRom(KRomBitmap, romAddress)) //check any rom bitmap

   314 		{

   315 		INFO_PRINTF2(_L("Skipping tests of ROM bitmaps since file \"%S\" is reported to not be a ROM bitmap."),

   316 				&KRomBitmap);

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

   318 		iSkipRomBitmapTests = ETrue;

   319 		}

   320 	}

   321 

   322 void CTDefect::CreateScreenDeviceL(TAllowScaling aScaling)

   323 	{

   324 	DeleteGraphicsContext();

   325 	DeleteScreenDevice();

   326 	TDisplayMode mode[] = {EColor256, EColor4K, EColor16M, EColor16MU, EColor64K, 

   327 						   EGray256, EGray16, EGray4, EGray2, EColor16, EColor16MA, EColor16MAP};

   328 	TInt ii;

   329 	TInt err = KErrNotSupported;

   330 	for(ii=0;(ii<TInt(sizeof(mode)/sizeof(mode[0]))) && (err == KErrNotSupported);++ii)

   331 		{

   332 		err = CreateScreenDeviceL(mode[ii], aScaling);

   333 		}

   334 	if (err==KErrNone)

   335 		{

   336 		_LIT(KLog,"Sucessfully created screen device %S");

   337 		INFO_PRINTF2(KLog,&ColorModeName(mode[ii]));

   338 		}

   339 	TEST(err == KErrNone);

   340 	}

   341 

   342 TInt CTDefect::CreateScreenDeviceL(TDisplayMode aDisplayMode, TAllowScaling aScaling)

   343 	{

   344 	DeleteGraphicsContext();

   345 	DeleteScreenDevice();

   346 	TRAPD(err, iDevice=CFbsScreenDevice::NewL(KNullDesC,aDisplayMode));

   347 	if(err == KErrNotSupported)

   348 		{

   349 		return err;

   350 		}

   351 	if (err!=KErrNone)

   352 		{

   353 		_LIT(KLog,"Failed to create screen device %S return value %d");

   354 		INFO_PRINTF3(KLog,&ColorModeName(aDisplayMode),err);

   355 		}

   356 	else

   357 		{

   358 		_LIT(KLog,"Created Screen Device  iDevice=0x%x");

   359 		INFO_PRINTF2(KLog,iDevice);

   360 		}

   361 	TEST(err == KErrNone);

   362 	err = iDevice->CreateContext((CGraphicsContext*&)iGc);

   363 	TEST(err == KErrNone);

   364 	if(aScaling == EScalingAllowed)

   365 		{

   366 		iDevice->SetScalingFactor(TPoint(31, 11), 2, 2, 1, 1);

   367 		iGc->Activate(iDevice);

   368 		}

   369 	iGc->SetUserDisplayMode(aDisplayMode);

   370 	iDevice->ChangeScreenDevice(NULL);

   371 	iDevice->SetAutoUpdate(EFalse);

   372 	iSize = iDevice->SizeInPixels();

   373 	iCurrentMode = aDisplayMode;

   374 	return err;

   375 	}

   376 

   377 void CTDefect::RunTestCaseL(TInt aCurTestCase)

   378 	{

   379 	((CTDefectStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

   380 	switch(aCurTestCase)

   381 		{

   382 	case 1:

   383 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0045"));

   384 		INFO_PRINTF1(_L("DEF014364"));

   385 		DEF014364L();

   386 		INFO_PRINTF1(_L("Cleared DEF014364\n"));

   387 		break;

   388 	case 2:

   389 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0046"));

   390 		INFO_PRINTF1(_L("DEF017758"));

   391 		DEF017758();

   392 		INFO_PRINTF1(_L("Cleared DEF017758\n"));

   393 		break;

   394 	case 3:

   395 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0047"));

   396 		INFO_PRINTF1(_L("16 bpp bitmap comperssion"));

   397 		BitmapCompressionL(E16BppBmpType);

   398 		break;

   399 	case 4:

   400 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0047"));

   401 		INFO_PRINTF1(_L("24 bpp bitmap comperssion"));

   402 		BitmapCompressionL(E24BppBmpType);

   403 		break;

   404 	case 5:

   405 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0048"));

   406 		INFO_PRINTF1(_L("New RSC file format"));

   407 		NewRscFormatL();

   408 		break;

   409 	case 6:

   410 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0049"));

   411 		INFO_PRINTF1(_L("INC031920 - 16 bpp bitmaps"));

   412 		INC031920L(E16BppBmpType, ETrue);

   413 		INC031920L(E16BppBmpType, EFalse);

   414 		break;

   415 	case 7:

   416 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0049"));

   417 		INFO_PRINTF1(_L("INC031920 - 24 bpp bitmaps"));

   418 		INC031920L(E24BppBmpType, ETrue);

   419 		INC031920L(E24BppBmpType, EFalse);

   420 		break;

   421 	case 8:

   422 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0050"));

   423 		INFO_PRINTF1(_L("8 bit bitmap compression - ROM"));

   424 		Test8bitBmpComressionL();

   425 		break;

   426 	case 9:

   427 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0051"));

   428 		INFO_PRINTF1(_L("12 bit bitmap compression - ROM"));

   429 		Test12bitBmpComressionL();

   430 		break;

   431 	case 10:

   432 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0044"));

   433 		INFO_PRINTF1(_L("ZeroSizeBitmap"));

   434 		ZeroSizeBitmap();

   435 		break;

   436 	case 11:

   437 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0052"));

   438 		INFO_PRINTF1(_L("DEF034134"));

   439 		DEF034134L();

   440 		break;

   441 	case 12:

   442 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0053"));

   443 		INFO_PRINTF1(_L("Test tiling occurs correctly"));

   444 		TestTilingHorizontalAndVerticalL();

   445 		break;

   446 	case 13:

   447 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0054"));

   448 		INFO_PRINTF1(_L("Borderline cases for DrawPie"));

   449 		DrawPieBorderlineCasesL();

   450 		break;

   451 	case 14:

   452 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0055"));

   453 		INFO_PRINTF1(_L("INC037380"));

   454 		INC037380L();

   455 		break;

   456 	case 15:

   457 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0056"));

   458 		INFO_PRINTF1(_L("INC037474"));

   459 		INC037474L();

   460 		break;

   461 	case 16:

   462 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0058"));

   463 		INFO_PRINTF1(_L("CFbsBitmap::SetDisplayMode() test"));

   464 		TestSettingDisplayModeL();

   465 		break;

   466 	case 17:

   467 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0059"));

   468 		INFO_PRINTF1(_L("CFbsBitmap::SetDisplayMode() test 2"));

   469 		TestSettingDisplayMode2L();

   470 		break;

   471 	case 18:

   472 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0060"));

   473 		INFO_PRINTF1(_L("CFbsBitmap::SwappingWidthAndHeight() test"));

   474 		TestSwappingWidthAndHeightL();

   475 		break;

   476 	case 19:

   477 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0057"));

   478 		INFO_PRINTF1(_L("INC037370"));

   479 		INC037370L();

   480 		break;

   481 	case 20:

   482 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0061"));

   483 		INFO_PRINTF1(_L("DEF038774"));

   484 		DEF038774L();

   485 		break;

   486 	case 21:

   487 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0062"));

   488 		INFO_PRINTF1(_L("INC070043L"));

   489 		INC070043L();		

   490 		break;

   491 	case 22:

   492 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0043"));

   493 		INFO_PRINTF1(_L("OOM test"));

   494 		TestOom();	

   495 		break;

   496 	case 23:

   497 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0063"));

   498 		INFO_PRINTF1(_L("Bitmaps Swapping Test"));

   499 		BitmapsSwappingTest();

   500 		break;

   501 	case 24:

   502 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0064"));

   503 		INFO_PRINTF1(_L("INC093055"));

   504 		INC093055L();

   505 		break;

   506 	case 25:

   507 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0016"));

   508 		INFO_PRINTF1(_L("PDEF103809"));

   509 		PDEF103809L();

   510 		break;

   511 	case 26:

   512 /**

   513 @SYMTestCaseID		GRAPHICS-BITGDI-0018

   514 

   515 @SYMDEF             DEF104856

   516 

   517 @SYMTestCaseDesc    Test that the bitmap and mask are drawn correctly testing

   518 	CFbsBitGc::DoBitBltMaskedFlicker in order to test the DEF104856 fix

   519 	introduced in CFbsBitGc::DoBitBltMaskedFlicker method

   520 

   521 @SYMTestPriority    High

   522 

   523 @SYMTestStatus      Implemented

   524 

   525 @SYMTestActions     Create compressed EColor64K bitmap and mask and draw bitmap calling

   526 	CFbsBitGc::BitBltMasked with an offscreen bitmap device

   527 

   528 @SYMTestExpectedResults The resulting bitmap is not altered or corrupted by the code module

   529 **/

   530 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0018"));

   531 		INFO_PRINTF1(_L("BitBltMasked Flicker Test - DEF104856"));

   532 		TestDoBltMaskedL(EColor64K, EColor64K, EColor64K, TSize(16,16), EFalse, ETrue);

   533 		break;

   534 	case 27:

   535 /**

   536 @SYMTestCaseID		GRAPHICS-BITGDI-0019

   537 

   538 @SYMDEF             DEF104856

   539 

   540 @SYMTestCaseDesc    Test that the bitmap and mask are drawn correctly testing

   541 	CFbsBitGc::DoBitBltMaskedNonFlicker in order to test the DEF104856 fix

   542 	introduced in CFbsBitGc::DoBitBltMaskedNonFlicker method

   543 

   544 @SYMTestPriority    High

   545 

   546 @SYMTestStatus      Implemented

   547 

   548 @SYMTestActions     Create compressed EColor64K bitmap and mask and draw bitmap calling

   549 	CFbsBitGc::BitBltMasked with a screen device and brush style EVerticalHatchBrush

   550 

   551 @SYMTestExpectedResults The resulting bitmap is not altered or corrupted by the code module

   552 **/

   553 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0019"));

   554 		INFO_PRINTF1(_L("BitBltMasked non Flicker Test - DEF104856"));

   555 		TestDoBltMaskedL(EColor64K, EColor64K, EColor64K, TSize(16,16), ETrue, ETrue);

   556 		break;

   557 	case 28:

   558 /**

   559 @SYMTestCaseID		GRAPHICS-BITGDI-0092

   560  

   561 @SYMDEF             DEF108338

   562 

   563 @SYMTestCaseDesc    Test that the bitmap is drawn correctly by testing

   564 					that the correct area of the mask is used for masking.

   565 					CFbsBitGc::DoBitBltMaskedFlicker is called in this case.

   566 

   567 @SYMTestPriority    High

   568 

   569 @SYMTestStatus      Implemented

   570 

   571 @SYMTestActions     Create compressed EColor64K bitmap and EGray2 mask and draw bitmap calling

   572 					CFbsBitGc::BitBltMasked with a screen device. The drawing is done in a loop

   573 					to simulate the scrolling effect as in a browser.

   574 

   575 @SYMTestExpectedResults All the stripes should pass the integrity check.

   576 **/

   577 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0092"));

   578 		INFO_PRINTF1(_L("BitBltMasked Flicker - DEF108338"));

   579 		TestDoBltMaskedL(EColor64K, EGray2, EColor16MU, TSize(96,96), EFalse, EFalse);

   580 		break;

   581 	case 29:

   582 /**

   583 @SYMTestCaseID		GRAPHICS-BITGDI-0093

   584 

   585 @SYMDEF             DEF108338

   586 

   587 @SYMTestCaseDesc    Test that the bitmap is drawn correctly by testing

   588 					that the correct area of the mask is used for masking.

   589 					CFbsBitGc::DoBitBltMaskedNonFlicker is called in this case.

   590 

   591 @SYMTestPriority    High

   592 

   593 @SYMTestStatus      Implemented

   594 

   595 @SYMTestActions     Create compressed EColor64K bitmap and EGray2 mask and draw bitmap calling

   596 					CFbsBitGc::BitBltMasked with a screen device. The drawing is done in a loop

   597 					to simulate the scrolling effect as in a browser.

   598 

   599 @SYMTestExpectedResults All the stripes should pass the integrity check.

   600 **/

   601 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0093"));

   602 		INFO_PRINTF1(_L("BitBltMasked Non Flicker - DEF108338"));

   603 		//skip the test if the screen does not have a fast blit interface.

   604 		if(CFbsDrawDevice::DisplayMode16M() == ENone)

   605 			{

   606 			INFO_PRINTF1(_L("Test skipped - The screen does not have a fast blit interface!"));

   607 			break;

   608 			}

   609 		TestDoBltMaskedL(EColor64K, EGray2, EColor16MU, TSize(96,96), ETrue, EFalse);

   610 		break;

   611 	case 30:

   612 /**

   613 @SYMTestCaseID		GRAPHICS-BITGDI-0020

   614 

   615 @SYMDEF             DEF103736

   616 

   617 @SYMTestCaseDesc   	Test to check that EColor16MAP mode correctly draws bitmaps when using a EColor16MAP mask

   618 

   619 @SYMTestPriority    Normal

   620 

   621 @SYMTestStatus      Implemented

   622 

   623 @SYMTestActions     Create compressed EColor16MAP bitmap and mask and draw bitmap calling

   624 					CFbsBitGc::BitBltMasked with an offscreen bitmap device

   625 

   626 @SYMTestExpectedResults The resulting bitmap is not altered or corrupted by the code module

   627 **/

   628 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0020"));

   629 		INFO_PRINTF1(_L("BitBltMasked non Flicker Test ECOLOR16MAP - DEF103736"));

   630 		TestDoBltMaskedL(EColor16MAP, EColor16MAP, EColor16MAP, TSize(16,16), EFalse, ETrue);

   631 		break;

   632 	case 31:

   633 /**

   634 @SYMTestCaseID		GRAPHICS-BITGDI-0094

   635 

   636 @SYMDEF             PDEF108863

   637 

   638 @SYMTestCaseDesc    Test that CFbsBitGc::DoBitBltAlpha() function behaves correctly

   639                     when source is EColor16MU, mask is EGray256, both source and mask are compressed

   640                     and the screen driver has no MFastBlit interface.

   641 

   642 @SYMTestPriority    High

   643 

   644 @SYMTestStatus      Implemented

   645 

   646 @SYMTestActions     Create compressed EColor16MU bitmap and EGray256 mask and draw bitmap calling

   647                     CFbsBitGc::BitBltMasked with a screen device. Where screen driver has no MFastBlit interface.

   648 

   649 @SYMTestExpectedResults All the stripes should pass the integrity check.

   650 **/

   651 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0094"));

   652 		INFO_PRINTF1(_L("PDEF108863 - DoBitBltAlpha for EColor16MU source, EGray256 mask and no MFastBlit interface"));

   653 		TestDoBltMaskedL(EColor16MU, EGray256, EColor16MA, TSize(96,96), EFalse, EFalse);

   654 		break;

   655 	case 32:

   656 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0095"));

   657 		INFO_PRINTF1(_L("PDEF110934 - DoBitBltMasked for mask height is less/greater than the bitmap height")); 

   658 		TestDoBitBltMaskedSizeL();

   659 		break;

   660 	case 33: 

   661 /** 

   662 @SYMTestCaseID      GRAPHICS-BITGDI-0096

   663 

   664 @SYMDEF             PDEF114309

   665 

   666 @SYMTestCaseDesc    Test to check that EColor16MU mode correctly BitBltMasks when source and mask are of EColor16MA

   667 

   668 @SYMTestPriority    Normal

   669 

   670 @SYMTestStatus      Implemented

   671 

   672 @SYMTestActions     Create source, mask and destination bitmaps of EColor16MA, EColor16MA and EColor16MU respectively

   673                     Call BitBltMaksed on the destination device and check the output

   674 

   675 @SYMTestExpectedResults The resulting bitmap contents should match the calculated value

   676 **/

   677 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0096"));

   678         INFO_PRINTF1(_L("BitBltMasked for EColor16MU with source and mask of EColor16MA - PDEF114309"));

   679         TestBitBltMaskedEColor16MUL();

   680         break;

   681 	case 34:

   682 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0102"));

   683 		INFO_PRINTF1(_L("Externalize()/Internalize() of CFbsBitGcExtraData in CFbsBitmap - DEF120360"));

   684 		ExternalizeInternalizeCFbsBitGCExtraData();

   685 		break;

   686 	case 35:

   687 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0086"));

   688         INFO_PRINTF1(_L("Test BitBlt with 16MU source & target copies rather than overwrites alpha channel - DEF121299"));

   689         TestBitBltOperationsOn16muUndefinedByteL();

   690         break;

   691 	case 36:

   692 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0107"));

   693 		INFO_PRINTF1(_L("Test DrawBitmap() with clipping and scaling - DEF126160"));

   694 		TestClippedScaledBitmapL();

   695 		break;

   696 	case 37:

   697 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0109"));

   698 		INFO_PRINTF1(_L("Test TestDrawBitmapTwipsNotSet() - DEF128522"));

   699 		TestDrawBitmapTwipsNotSet();

   700 		break;

   701 	case 38:

   702 		((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0119"));

   703 		INFO_PRINTF1(_L("Test DrawBitmapMasked() with compressed bitmaps"));

   704 		TestDrawBitmapMaskedL();

   705 		break;    

   706 	case 39:

   707 		((CTDefectStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

   708 		((CTDefectStep*)iStep)->CloseTMSGraphicsStep();

   709 		TestComplete();		

   710 		break;				

   711 		}

   712 	((CTDefectStep*)iStep)->RecordTestResultL();

   713 	}

   714 

   715 void CTDefect::TestBitBltMaskedEColor16MUL() 

   716     { 

   717     TInt width = 128; 

   718     TInt height = 178; 

   719  

   720     TSize size(width, height); 

   721     TInt transpFactor = 100; 

   722  

   723     // Create a destination bitmap of EColro16MU and fill some color in it 

   724     CFbsBitmap* destBitmap = new CFbsBitmap(); 

   725     CleanupStack::PushL(destBitmap); 

   726     User::LeaveIfError(destBitmap->Create(size, EColor16MU)); 

   727     CFbsBitmapDevice* destDev = CFbsBitmapDevice::NewL(destBitmap); 

   728     CleanupStack::PushL(destDev); 

   729     CFbsBitGc* destGc = NULL; 

   730     User::LeaveIfError(destDev->CreateContext(destGc)); 

   731     CleanupStack::PushL(destGc); 

   732  

   733     destGc->SetPenStyle(CGraphicsContext::ENullPen); 

   734     destGc->SetBrushStyle(CGraphicsContext::ESolidBrush); 

   735     destGc->SetBrushColor(KRgbRed); 

   736     destGc->DrawRect(TRect(TPoint(), size)); 

   737  

   738     // Create a source bitmap fill it with some color and then draw it with some color with transparency on it 

   739     CFbsBitmap* srcBitmap = new (ELeave) CFbsBitmap; 

   740     CleanupStack::PushL(srcBitmap); 

   741     User::LeaveIfError(srcBitmap->Create(size, EColor16MA)); 

   742     CFbsBitmapDevice* srcDev = CFbsBitmapDevice::NewL(srcBitmap); 

   743     CleanupStack::PushL(srcDev); 

   744     CFbsBitGc* srcGc = NULL; 

   745     User::LeaveIfError(srcDev->CreateContext(srcGc)); 

   746     CleanupStack::PushL(srcGc); 

   747  

   748     srcGc->SetPenStyle(CGraphicsContext::ENullPen); 

   749     srcGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha); 

   750     srcGc->SetBrushStyle(CGraphicsContext::ESolidBrush); 

   751     srcGc->SetBrushColor(TRgb(0xff,0xff,0xff,transpFactor)); 

   752     srcGc->DrawRect(TRect(TPoint(), size)); 

   753  

   754     // Create a mask bitmap and fill with TRgb(30,30,30) 

   755     CFbsBitmap* maskBitmap = new (ELeave) CFbsBitmap; 

   756     CleanupStack::PushL(maskBitmap); 

   757     User::LeaveIfError(maskBitmap->Create(size, EColor16MA)); 

   758     CFbsBitmapDevice* maskDev = CFbsBitmapDevice::NewL(maskBitmap); 

   759     CleanupStack::PushL(maskDev); 

   760     CFbsBitGc* maskGc = NULL; 

   761     User::LeaveIfError(maskDev->CreateContext(maskGc)); 

   762     CleanupStack::PushL(maskGc); 

   763  

   764     maskGc->SetPenStyle(CGraphicsContext::ENullPen); 

   765     maskGc->SetBrushStyle(CGraphicsContext::ESolidBrush); 

   766     maskGc->SetBrushColor(TRgb( 30, 30, 30 )); 

   767     maskGc->DrawRect(size); 

   768  

   769     // Then call BitBltMaksed() on it 

   770     destGc->SetDrawMode(CGraphicsContext::EDrawModePEN); 

   771     destGc->SetBrushStyle(CGraphicsContext::ENullBrush); 

   772     destGc->BitBltMasked(TPoint(), srcBitmap, TRect(size), maskBitmap, ETrue); 

   773  

   774     // These are the values that we gave for source bitmaps 

   775     TUint32 srcPixel = 0x64FFFFFF;  // i,e TRgb(0xff,0xff,0xff,transpFactor) 

   776     TUint8 srcMask = 0x64;          // transpFactor 

   777     TUint32 destPixel = 0xFFFFFFFF; // White becasue nothing has drawn on it 

   778  

   779     // When we draw source bitmap with transparency, it actually alpha blends  

   780     // with the above parameters 

   781     srcPixel = AlphaBlendWithDestAlphaFF(srcPixel, srcMask, destPixel); 

   782  

   783     // For displaymode which has alpha, mask is inverted i,e 255-30 = 225 or 0xE1 

   784     srcMask = 0xE1;                 // mask bitmap's TRgb( 30, 30, 30 ) 

   785     destPixel = 0xFFFF0000;         // KRgbRed of destination bitmap 

   786     destPixel = AlphaBlendWithDestAlphaFF(srcPixel, srcMask, destPixel); 

   787  

   788     // Function to check the contents of the destination bitmap,  

   789     // if the INC111510 fix is not applied then this function will fail 

   790     CheckBitmapContents(destDev, width, height, destPixel); 

   791  

   792     CleanupStack::PopAndDestroy(9, destBitmap);  

   793     } 

   794  

   795 // This function is for alpha blending when the destination alpha is FF 

   796 TUint32 CTDefect::AlphaBlendWithDestAlphaFF(const TUint32 aSrcPixel, const TUint8 aMask, TUint32 aDestPixel) 

   797     { 

   798     if(aMask) 

   799         { 

   800         if(aMask == 0xFF) 

   801             return 0xff000000|aSrcPixel; 

   802          

   803         // This is the formula used for alpha blending 

   804         // (a)  (mask * src + (255 - mask) * dest) / 255           This is the ideal formula 

   805         // (b)  ((mask * (src - dest)) >> 8) + dest                A faster approximation to (a) 

   806         // (c)  ((mask * (256 + src - dest) >> 8) + dest - mask    Equivalent to (b) but can be used on multiple colors at a time 

   807          

   808         const TUint32 s_rb = aSrcPixel & 0x00FF00FF; 

   809         const TUint32 d_rb = aDestPixel & 0x00FF00FF; 

   810         const TUint32 mask2 = aMask | (aMask << 16); 

   811         const TUint32 rb = ((((aMask * ((0x01000100 + s_rb) - d_rb)) >> 8) + d_rb) - mask2) & 0x00FF00FF; 

   812  

   813         const TInt s_g = (aSrcPixel & 0xFF00) >> 8; 

   814         const TInt d_g = (aDestPixel & 0xFF00) >> 8; 

   815         const TInt g = ((aMask * (s_g - d_g)) >> 8) + d_g; 

   816  

   817         return(rb | (g<<8) | 0xff000000); 

   818         } 

   819  

   820     return aDestPixel; 

   821     } 

   822  

   823 // This function is to check each pixel of the given bitmap 

   824 void CTDefect::CheckBitmapContents(CFbsDevice* aDevice, TInt aWidth, TInt aHeight, TUint32 aExpectedValue) 

   825     { 

   826     TRgb color; 

   827     for(TInt y = 0; y < aHeight; ++y) 

   828         { 

   829         for(TInt x = 0; x < aWidth; ++x) 

   830             { 

   831             aDevice->GetPixel(color, TPoint(x, y)); 

   832             if(aExpectedValue != color.Internal()) 

   833                 { 

   834                 TEST(EFalse); 

   835                 return; 

   836                 } 

   837             } 

   838         } 

   839     }

   840 

   841 /**

   842   @SYMTestCaseID GRAPHICS-BITGDI-0043

   843  

   844   @SYMDEF INC042156L             

   845 

   846   @SYMTestCaseDesc Out of memory test

   847    

   848   @SYMTestPriority High

   849 

   850   @SYMTestStatus Implemented

   851 

   852   @SYMTestActions Sets the next heap allocation to fail before attempting various bitmaps operations

   853  

   854   @SYMTestExpectedResults Allocation  should fail gracefullly

   855 */

   856 void CTDefect::TestOom()

   857 	{

   858 	TInt err, tryCount = 0;

   859 

   860 	INFO_PRINTF1(_L("INC042156L"));

   861 

   862 	do

   863 		{

   864 		User::__DbgSetAllocFail(RHeap::EUser, RHeap::EFailNext, ++tryCount);

   865 		User::__DbgMarkStart(RHeap::EUser);

   866 		{

   867 		TRAP(err, INC042156L());

   868 		}

   869 		User::__DbgMarkEnd(RHeap::EUser, 0);

   870 		} 

   871 	while(err == KErrNoMemory);

   872 

   873 	if(err == KErrNone)

   874 		{

   875 		// Reset

   876 		User::__DbgSetAllocFail(RHeap::EUser,RHeap::ENone,1);

   877 		}

   878 	else

   879 		{

   880 		TEST(err == KErrNone);

   881 		}

   882 

   883 	INFO_PRINTF2(_L("- server succeeded at heap failure rate of %i"), tryCount);

   884 	User::After(3000000);

   885 	}

   886 

   887 

   888 /**

   889   @SYMTestCaseID GRAPHICS-BITGDI-0044

   890  

   891   @SYMDEF             

   892 

   893   @SYMTestCaseDesc tests that CBitwiseBitmap::SizeOfByteDataCompressed, SizeOfTwelveBitDataCompressed, SizeOfSixteenBitDataCompressed & 

   894   SizeOfTwentyFourBitDataCompressed can handle zero size bitmaps 

   895    

   896   @SYMTestPriority High

   897 

   898   @SYMTestStatus Implemented

   899 

   900   @SYMTestActions Loads a zerosize bitmap the compresses it

   901  

   902   @SYMTestExpectedResults Test should perform graphics operations succesfully. 

   903 */

   904 void CTDefect::ZeroSizeBitmap()

   905 {

   906 	DeleteBitmap();

   907 	iBitmap = new (ELeave) CFbsBitmap;

   908 	

   909 	TInt err = iBitmap->Load(KZeroSizeMbmRam);

   910 	TEST(err == KErrCorrupt);

   911 	if(err != KErrCorrupt)

   912 		{

   913 		err =iBitmap->Compress();

   914 		TEST(err == KErrNone);	

   915 		}

   916 }

   917 

   918 /**

   919   @SYMTestCaseID GRAPHICS-BITGDI-0045

   920  

   921   @SYMDEF DEF014364            

   922 

   923   @SYMTestCaseDesc Tests opening of a corrupt bitmap and resizing to (0,0)

   924    

   925   @SYMTestPriority High

   926 

   927   @SYMTestStatus Implemented

   928 

   929   @SYMTestActions tries to open a corrupt bitmap then attempts to resize a new bitmap to (0,0) size

   930  

   931   @SYMTestExpectedResults Test should perform graphics operations succesfully. 

   932 */

   933 void CTDefect::DEF014364L()

   934 	{

   935 	DeleteBitmap();

   936 	iBitmap = new (ELeave) CFbsBitmap;

   937 	TInt err = iBitmap->Load(_L("z:\\system\\data\\Corrupt000.wbmp"));

   938 	//It should not be possible to open corrupted bitmap file.

   939 	if (err!=KErrNotSupported)

   940 		{

   941 		_LIT(KLog,"Corrupt bitmap Corrupt000.wbmp gave wrong error code when opening  err=%d");

   942 		INFO_PRINTF2(KLog,err);

   943 		}

   944 	TEST(err == KErrNotSupported);

   945 	err = iBitmap->Create(TSize(20, 20), iCurrentMode);

   946 	if (err!=KErrNone)

   947 		{

   948 		_LIT(KLog,"Failed to create bitmap  err=%d");

   949 		INFO_PRINTF2(KLog,err);

   950 		}

   951 	TEST(err == KErrNone);

   952 	DeleteBitmapDevice();

   953 	TRAP(err, iBmpDevice = CFbsBitmapDevice::NewL(iBitmap));

   954 	if (err!=KErrNone)

   955 		{

   956 		_LIT(KLog,"Failed to create bitmap device  err=%d");

   957 		INFO_PRINTF2(KLog,err);

   958 		}

   959 	TEST(err == KErrNone);

   960 	//It should not be possible to resize bitmap device to (0, 0) size.

   961 	//Yes it should, setting size to 0,0 is necessary to maintain

   962 	//6.1 application compatibility with 7.0s.

   963 	err = iBmpDevice->Resize(TSize(0, 0));

   964 	if (err!=KErrNone)

   965 		{

   966 		_LIT(KLog,"Failed to resize bitmap  err=%d");

   967 		INFO_PRINTF2(KLog,err);

   968 		}

   969 	TEST(err == KErrNone);

   970 	//It should be possible to resize bitmap to (0, 0) size.

   971 	err = iBitmap->Resize(TSize(0, 0));

   972 	if (err!=KErrNone)

   973 		{

   974 		_LIT(KLog,"Failed to resize bitmap2  err=%d");

   975 		INFO_PRINTF2(KLog,err);

   976 		}

   977 	TEST(err == KErrNone);

   978 	//The next call should not fail with "Divide by Zero" exception on WINS platform.

   979 	iGc->DrawBitmap(TRect(0, 0, 10, 10), iBitmap, TRect(0, 0, 10, 10));

   980 	}

   981 

   982 //DEF023605 - Panic when bmp file is opened using Paint.

   983 void CTDefect::DEF023605L()

   984 	{

   985 	DeleteBitmap();

   986 	iBitmap = new (ELeave) CFbsBitmap;

   987 	TInt err = iBitmap->Create(iSize, iCurrentMode);

   988 	TEST(err == KErrNone);

   989 	//It should not be possible to resize bitmap to (max_int, ...) size.

   990 	err = iBitmap->Resize(TSize(0x7FFFFFFF, 16));

   991 	TEST(err == KErrNone);

   992 	}

   993 

   994 /**

   995   @SYMTestCaseID GRAPHICS-BITGDI-0046

   996  

   997   @SYMDEF DEF017758             

   998 

   999   @SYMTestCaseDesc Memory leak detected on target when using DirectScreenAccess

  1000    

  1001   @SYMTestPriority High

  1002 

  1003   @SYMTestStatus Implemented

  1004 

  1005   @SYMTestActions 

  1006   

  1007   	//

  1008 	//The statement between __UHEAP_MARK and __UHEAP_END can cause memory leak!

  1009 	//Obviously we have some kind of first time memory allocation when the

  1010 	//method is called for the first time. Exactly the same method is called from

  1011 	//CFbsScreenDevice::ConstructL() method.

  1012 	//

  1013 	//To see the problem:

  1014 	//1. Comment HAL::Get() call into E32Main().

  1015 	//2. Build ARM4 UDEB version of TDefect and make sure it is used into rom image build

  1016 	//3. Build textshell rom image:

  1017 	//   buildrom assabet textshell_70s graphics_70s.iby graphicstests_70s.iby

  1018 	//4. Run TDefect app on the assabet.

  1019 	//   You will see a memory leak. If you uncomment HAL::Get() call into E32Main() and repeat 

  1020 	//   steps 1..4 - everything is OK.

  1021 	//PS: If you don't want to build all graphics test app, you may have to comment

  1022 	//    some IBY file includes into graphicstests_70s.iby file.

  1023 	//    If there is a memory leak - the test will still report status "OK", but you

  1024 	//    can see the memory leak message on the assabet. That's happening because 

  1025 	//    the memory leak appears after the last __UHEAP_MARKEND macro in E32Main().

  1026 	//

  1027  

  1028   @SYMTestExpectedResults Test should perform graphics operations succesfully. 

  1029 */

  1030 void CTDefect::DEF017758()

  1031 	{

  1032 	TRAPD(err, DEF017758L());

  1033 	TEST(err == KErrNone);

  1034 	}

  1035 

  1036 void CTDefect::DEF017758L()

  1037 	{

  1038 	RDebug::Print(_L("Getting video memory address\r\n"));

  1039 	RDebug::Print(_L("Start\r\n"));

  1040 	TInt address = 0;

  1041 

  1042 	__UHEAP_MARK;

  1043 	User::LeaveIfError(HAL::Get(KDefaultScreenNo, HALData::EDisplayMemoryAddress, address));

  1044 	__UHEAP_MARKEND;

  1045 	RDebug::Print(_L("End\n"));

  1046 	}

  1047 

  1048 /**

  1049   @SYMTestCaseID GRAPHICS-BITGDI-0047

  1050  

  1051   @SYMDEF             

  1052 

  1053   @SYMTestCaseDesc The main purpose of this method is to test RAM/ROM bitmap compression.

  1054    

  1055   @SYMTestPriority High

  1056 

  1057   @SYMTestStatus Implemented

  1058 

  1059   @SYMTestActions 

  1060 

  1061 	 - loads and displays ROM compressed bitmap.

  1062 	 - loads and displays ROM bitmap - no compression.

  1063 	 - loads and displays RAM compressed bitmap.

  1064 	 - loads and displays RAM bitmap - no compression.

  1065 	 - loads, compress and displays RAM bitmap.

  1066 	 - stretches, moves and resizes RAM compressed bitmap.

  1067 	 - compares byte by byte compressed and uncompressed bitmap images.

  1068 	 Note: if you want to have better visibility of the bitmaps shown on

  1069 	 the screen - change "KDelayTime" constant to be 1500000.

  1070 	 @param  TBitmapType aBitmapType - tested bitmaps type - 16 bpp, 24 bpp, ...

  1071 	 @return None

  1072  

  1073   @SYMTestExpectedResults Test should perform graphics operations succesfully. 

  1074 */

  1075 void CTDefect::BitmapCompressionL(TBitmapType aBitmapType)

  1076 	{

  1077 	CreateScreenDeviceL();

  1078 	CreateFontL();

  1079 

  1080 	TRect rc(10, 20, 610, 220);

  1081 	TBuf<100> text;

  1082 	TInt mbm_offset = 0;

  1083 	TInt err;

  1084 	TPtrC BitmapTypeName[ELastBmpType] = {_L("16 bpp"), _L("24 bpp")};

  1085 	typedef enum {ERAMFileType, ERAMCFileType, EROMFileType, EROMCFileType, ELastBmpFileType} TBitmapFileType;

  1086 	TPtrC BitmapFile[ELastBmpFileType][ELastBmpType] = 

  1087 		{

  1088 		{KRamBitmap(), KRam24Bitmap()},

  1089 		{KRamCBitmap(), KRamC24Bitmap()},

  1090 		{KRomBitmap(), KRom24Bitmap()},

  1091 		{KRomCBitmap(), KRomC24Bitmap()}

  1092 		};

  1093 

  1094 	if(!iSkipRomBitmapTests)

  1095 		{

  1096 		//ROM compressed bitmap.

  1097 		text = BitmapTypeName[aBitmapType];

  1098 		text += _L(" ROM compressed bitmap.");

  1099 		DisplayBitmapL(BitmapFile[EROMCFileType][aBitmapType], 0, mbm_offset, text, rc);

  1100 	

  1101 		//ROM bitmap - no compression.

  1102 		text = BitmapTypeName[aBitmapType];

  1103 		text += _L(" ROM bitmap - no compression.");

  1104 		DisplayBitmapL(BitmapFile[EROMFileType][aBitmapType], 0, mbm_offset, text, rc);

  1105 		}

  1106 

  1107 	//RAM compressed bitmap.

  1108 	text = BitmapTypeName[aBitmapType];

  1109 	text += _L(" RAM compressed bitmap.");

  1110 	DisplayBitmapL(BitmapFile[ERAMCFileType][aBitmapType], 0, mbm_offset, text, rc);

  1111 

  1112 	//RAM bitmap - no compression.

  1113 	text = BitmapTypeName[aBitmapType];

  1114 	text += _L(" RAM bitmap - no compression.");

  1115 	DisplayBitmapL(BitmapFile[ERAMFileType][aBitmapType], 0, mbm_offset, text, rc);

  1116 

  1117 	//RAM bitmap - no compression. Compress it!

  1118 	err = iBitmap->Compress();

  1119 	TEST(err == KErrNone);

  1120 	TEST(iBitmap->IsCompressedInRAM());

  1121 	text = BitmapTypeName[aBitmapType];

  1122 	text += _L(" RAM bitmap - compressed now.");

  1123 	DisplayBitmap(text, rc);

  1124 	err = iBitmap->Save(_L("c:\\temp.mbm"));

  1125 	TEST(err == KErrNone);

  1126 

  1127 	//RAM compressed bitmap - stretch the bitmap.

  1128 	text = BitmapTypeName[aBitmapType];

  1129 	text += _L(" RAM compressed bitmap - stretch the bitmap.");

  1130 	TRect rc2(10, 20, 410, 150);

  1131 	DisplayBitmap(text, rc2);

  1132 

  1133 	//RAM compressed bitmap - move the bitmap.

  1134 	text = BitmapTypeName[aBitmapType];

  1135 	text += _L(" RAM compressed bitmap - move the bitmap.");