1 // Copyright (c) 1995-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 /**

    17  @file

    18  @internalComponent - Internal Symbian test code

    19 */

    20 

    21 #include "TFBS.H"

    22 #include "../sfbs/UTILS.H"

    23 #include "../sfbs/fbshelper.h"

    24 #include <shapeinfo.h>

    25 #include <graphics/openfontrasterizer.h>

    26 #include <graphics/openfontconstants.h>

    27 #include "fbsdefs.h"

    28 #include "fbsmessage.h"

    29 

    30 TInt buffer[2];

    31 

    32 _LIT(KFBSERVFontFileDir, "\\resource\\fonts\\");

    33 _LIT(KTypefaceName, "DejaVu Sans Condensed");

    34 

    35 // TLS Handle for TestFlushCallback test, from tfbsserver.mmp

    36 const TInt KTlsHandle = 0x10273364;

    37 

    38 

    39 #ifdef __WINS__

    40 template<class C> XTCallCounter<C>::XTCallCounter(CTGraphicsBase& aTestBase)

    41 	: iTestBase(aTestBase), iVFCallsOutsideFBServ(0)

    42 	{}

    43 

    44 template<class C> void XTCallCounter<C>::ExecuteShellcode(TInt aFromFunction)

    45 	{

    46 	const TUint32 KFBServId = 0x10003A16;

    47 	const TUint32 KTFbsServerId = 0x10273364;

    48 	TSecureId id = RProcess().SecureId();

    49 	if (id != KFBServId)

    50 		{

    51 		User::LockedInc(iVFCallsOutsideFBServ);

    52 		if (id == KTFbsServerId)

    53 			{

    54 			TBuf<128> name;

    55 			XVtableInjector<C>::GetVirtualFunctionName(aFromFunction, name);

    56 			iTestBase.INFO_PRINTF2(_L("Virtual function call to %S from outside FBServ"), &name);

    57 			}

    58 		}

    59 	}

    60 #endif

    61 

    62 

    63 void CTFbs::DeleteScanLineBuffer()

    64 	{

    65 	delete iFbs->iScanLineBuffer;

    66 	iFbs->iScanLineBuffer = 0;

    67 	};

    68 

    69 CTFbs::CTFbs(CTestStep* aStep):

    70 	CTGraphicsBase(aStep),

    71 	iHandle(0),

    72 	iFbs(NULL),

    73 	iTs(NULL),

    74 	iHeap(NULL),

    75 	iFs(NULL),

    76 	iResourceCount(0),

    77 	iAllocs(0)

    78 #ifdef __WINS__

    79 	, iFontCallCounter(*this), iOpenFontCallCounter(*this)

    80 #endif

    81 	{

    82 	}

    83 

    84 void CTFbs::ConstructL()

    85 	{

    86 	ExpandCleanupStackL();

    87 	

    88 	TestConstruction();

    89 	AllocScanLineBuf();

    90 	

    91 	INFO_PRINTF1(_L("FBSERV testing"));

    92 	}

    93 	

    94 CTFbs::~CTFbs()

    95 	{

    96 	delete iTs;

    97 	}

    98 

    99 void CTFbs::RunTestCaseL(TInt aCurTestCase)

   100 	{

   101 	((CTFbsStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

   102 	switch(aCurTestCase)

   103 		{

   104 	case 1:

   105 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0555"));

   106 		TestConnection();

   107 		break;

   108 	case 2:

   109 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0558"));

   110 		TestInvalidFiles();

   111 		break;

   112 	case 3:

   113 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0556"));

   114 		TestFlushCallBack();

   115 		break;

   116 	case 4:

   117 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0568"));

   118 		TestMultiThread();

   119 		break;

   120 	case 5:

   121 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0559"));

   122 		TestGetFont();

   123 		break;

   124 	case 6:

   125 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0560"));

   126 		TestFontStore();

   127 		break;

   128 	case 7:

   129 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-PREQ807_1_Load_all_fonts-0001"));

   130 		TestAllFontsLoaded();

   131 		break;

   132 	case 8:

   133 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0561"));

   134 		TestFontNameAlias();

   135 		break;

   136 	case 9:

   137 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0557"));

   138 		TestAddFontFile();

   139 		break;

   140 	case 10:

   141 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0562"));

   142 		TestBufferedFont();

   143 		break;

   144 	case 11:

   145 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0563"));

   146 		TestMultipleFont();

   147 		break;

   148 	case 12:

   149 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0564"));

   150 		TestCreateBitmap();

   151 		break;

   152 	case 13:

   153 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0565"));

   154 		TestLoadBitmap();

   155 		break;

   156 	case 14:

   157 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0566"));

   158 		TestQueryBitmap();

   159 		TRAPD(errCode, TestRomBitmapL());

   160 		if(errCode==KErrNone)

   161 			{

   162 			TestHeapCompression();

   163 			}

   164 		break;

   165 	case 15:

   166 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0570"));

   167 		TestDefaultLanguageForMetrics();		

   168 		break;

   169 	case 16:

   170 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-CTFbs-TestDuplicateFontFileEntries-0001"));

   171 		TestDuplicateFontFileEntries();

   172 		break;

   173 	//COMMENTED OUT FOR NOW BECAUSE DEF084095 FIX MAKES THIS TEST REDUNDANT

   174 	/*case 17:

   175 		TestShapeHeaderMemoryLeakAtClientDeath();

   176 		break;*/

   177 	case 17:

   178 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0506"));

   179 		TestBitmapHandleImmutable();

   180 		break;

   181 	case 18:

   182 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0507"));

   183 		TestBitmapBeginEnd();

   184 		break;

   185 	case 19:

   186 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0508"));

   187 		TestSingletonServer();

   188 		break;

   189 	case 21:

   190 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0620"));

   191 		TestFontSessionCacheLookupL();

   192 		break;

   193 	case 22:

   194 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0650"));

   195 		TestInvalidHandlesInIpcCallsL();

   196 		break;

   197 	case 23:

   198 		// this one should always be the last test, since it checks the final virtual function call count

   199 		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0619"));

   200 		TestNoVFCallsToGlobalObjects();

   201 		break;

   202 	case 24:

   203 		((CTFbsStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

   204 		((CTFbsStep*)iStep)->CloseTMSGraphicsStep();

   205 		TestComplete();		

   206 		break;

   207 		}

   208 	((CTFbsStep*)iStep)->RecordTestResultL();

   209 	}

   210 

   211 CFbsFontEx* CTFbs::SelectFont()

   212 	{

   213 	CFbsFontEx* font=NULL;

   214 	TInt ret=iTs->GetNearestFontToDesignHeightInPixels((CFont*&)font, TFontSpec(KTypefaceName, 15));

   215 	TEST(ret==KErrNone);

   216 #ifdef __WINS__

   217 	CBitmapFont* bitmapFont = font->Address();

   218 	iFontCallCounter.iInjector.InjectShellcode(bitmapFont, &iFontCallCounter);

   219 	if (bitmapFont->IsOpenFont())

   220 		{

   221 		iOpenFontCallCounter.iInjector.InjectShellcode(bitmapFont->OpenFont(), &iOpenFontCallCounter);

   222 		}

   223 #endif

   224 	TEST(font->MaxCharWidthInPixels()>0);

   225 	TEST(font->MaxNormalCharWidthInPixels()>0);

   226 	return(font);

   227 	}

   228 

   229 CFbsFontEx* CTFbs::SelectOpenTypeFont()

   230 	{

   231 	CFbsFontEx* font=NULL;

   232 	TFontSpec fsp;

   233 	fsp.iTypeface.iName=_L("Series 60 Sans");

   234 	fsp.iHeight=15;

   235 	TInt ret=iTs->GetNearestFontToDesignHeightInPixels((CFont*&)font,fsp);

   236 	TEST(ret==KErrNone);

   237 #ifdef __WINS__

   238 	CBitmapFont* bitmapFont = font->Address();

   239 	iFontCallCounter.iInjector.InjectShellcode(bitmapFont, &iFontCallCounter);

   240 	if (bitmapFont->IsOpenFont())

   241 		{

   242 		iOpenFontCallCounter.iInjector.InjectShellcode(bitmapFont->OpenFont(), &iOpenFontCallCounter);

   243 		}

   244 #endif

   245 	TEST(font->MaxCharWidthInPixels()>0);

   246 	TEST(font->MaxNormalCharWidthInPixels()>0);

   247 	return(font);

   248 	}

   249 

   250 void CTFbs::TestConstruction()

   251 	{

   252 	CFbsBitmap bmp;

   253 	iTestBitmapName = KTestBitmapOnZ;

   254 	TInt ret=bmp.Load(iTestBitmapName,ETfbs,NULL);

   255 	if (ret != KErrNone)

   256 		User::Panic(_L("Could not load bitmap"),ret);

   257 	bmp.Reset();

   258 

   259 	iFbs = RFbsSession::GetSession();

   260 	TRAP(ret,iTs = (CFbsTypefaceStore*)CFbsTypefaceStore::NewL(NULL));

   261 	TEST(iTs != NULL);

   262 	CFbsFontEx* font = SelectFont();

   263 	iTs->ReleaseFont(font);

   264 	}

   265 	

   266 /**

   267 	@SYMTestCaseID

   268 	GRAPHICS-FBSERV-0555

   269 

   270 	@SYMTestCaseDesc

   271 	Tests the connections to the FbsSession

   272 

   273 	@SYMTestActions

   274 	Allocates a 100 RFbsSession objects and

   275 	connects to the server and checks if

   276 	all connections succeeded. Frees the memory

   277 	and checks the heap memory.

   278 	

   279 	@SYMTestExpectedResults

   280 	Test should pass

   281 */

   282 void CTFbs::TestConnection()

   283 	{

   284 	INFO_PRINTF1(_L("class RFbsSession"));

   285 	__UHEAP_MARK;

   286 	const TInt numconnects=100;

   287 	RFbsSession* connections=(RFbsSession*)User::Alloc(sizeof(RFbsSession)*numconnects);

   288 	TEST(connections!=NULL);

   289 	TInt count=0;

   290 	for(;count<numconnects;count++)

   291 		new(&connections[count]) RFbsSession;

   292 	TEST(iFbs->ResourceCount()==0);

   293 	for(count=0;count<numconnects;count++)

   294 		{

   295 		TInt ret=connections[count].Connect();

   296 		if(ret!=KErrNone)

   297 			break;

   298 		}

   299 	INFO_PRINTF2(_L("    %d connections created.\n"),count);

   300 	TEST(iFbs->ResourceCount()==0);

   301 	for(TInt count2=0;count2<count;count2++)

   302 		connections[count2].Disconnect();

   303 	TEST(iFbs->ResourceCount()==0);

   304 	User::Free(connections);

   305 	User::Heap().Check();

   306 	__UHEAP_MARKEND;

   307 	}

   308 

   309 /**

   310 	@SYMTestCaseID

   311 	GRAPHICS-FBSERV-0556

   312 

   313 	@SYMTestCaseDesc

   314 	Tests if the flush callback function

   315 	is called properly.

   316 

   317 	@SYMTestActions

   318 	Sets the flush callback, fills the cache with different

   319 	fonts until the cache is full.

   320 	Create one more font which forces an eviction of a font

   321 	in the cache.

   322 	Check call back is called.

   323 	Reset the flush callback, create another new font,

   324 	check that the callback was not called.

   325 	Check for memory and resource leaks.

   326 	

   327 	@SYMTestExpectedResults

   328 	Callback function should be called once at end of loop.

   329 */

   330 void CTFbs::TestFlushCallBack()

   331 	{

   332 	INFO_PRINTF1(_L("Test Flush CallBack"));

   333 

   334 	__UHEAP_MARK;

   335 	CFbsTypefaceStore* tfs=NULL;

   336 	TRAPD(ret,tfs=CFbsTypefaceStore::NewL(NULL));

   337 	TEST(ret==KErrNone);

   338 	TEST(tfs!=NULL);

   339 

   340 	UserSvr::DllSetTls(KTlsHandle, this);

   341 	INFO_PRINTF1(_L("Testing Flush CallBack mechanism..."));

   342 	iFbs->SetCallBack(TCallBack(FlushCallBack, NULL));

   343 	CFbsFontEx* font=NULL;

   344 

   345 	// Fill up the fontcache so that on the final iteration, the first 

   346 	// font is evicted, thereby destroying it server-side and executing the 

   347 	// callback.

   348 	iFlushCallbackReceived = EFalse;

   349 	TInt fontSize = 10;

   350 	for (TInt fontEntries = 0; fontEntries < KMaxFontCacheEntries+1; fontEntries++)

   351 		{

   352 		ret=tfs->GetNearestFontToDesignHeightInTwips((CFont*&)font, TFontSpec(KTypefaceName, fontSize));

   353 		TEST(ret==KErrNone);

   354 		iResourceCount++;

   355 		CheckResourceCount();

   356 		tfs->ReleaseFont(font);

   357 		fontSize += 15;

   358 		}

   359 	TEST(iFlushCallbackReceived);

   360 

   361 	// Now check callback is correctly reset and callback function is not executed

   362 	// when another font is evicted from the cache.

   363 	// Resource count wont increase as although a new font is being created, another

   364 	// will be evicted from the cache.

   365 	iFlushCallbackReceived = EFalse;

   366 	iFbs->ResetCallBack();

   367 	ret=tfs->GetNearestFontToDesignHeightInTwips((CFont*&)font, TFontSpec(KTypefaceName, fontSize));

   368 	TEST(ret==KErrNone);

   369 	tfs->ReleaseFont(font);

   370 	TEST(!iFlushCallbackReceived);

   371 	CheckResourceCount();

   372 

   373 	UserSvr::DllFreeTls(KTlsHandle);

   374 	delete tfs;

   375 	iResourceCount = 0;

   376 	CheckResourceCount();

   377 	__UHEAP_MARKEND;

   378 	}

   379 

   380 TInt CTFbs::FlushCallBack(TAny* /*aPtr*/)

   381 	{

   382 	CTFbs* tfbs = static_cast<CTFbs*>(UserSvr::DllTls(KTlsHandle));

   383 	tfbs->INFO_PRINTF1(_L("    ...Flush CallBack called successfully"));

   384 	tfbs->iFlushCallbackReceived = ETrue;

   385 	--tfbs->iResourceCount;

   386 	return(0);

   387 	}

   388 

   389 

   390 #ifdef __WINS__

   391 _LIT(KCTFbsTestFont,"z:\\resource\\fonts\\eon14.gdr");

   392 #else

   393 _LIT(KCTFbsTestFont,"z:\\resource\\fonts\\eon.gdr");

   394 #endif

   395 

   396 /**

   397 	@SYMTestCaseID

   398 	GRAPHICS-FBSERV-0557

   399 

   400 	@SYMTestCaseDesc

   401 	Tests adding of a font file

   402 	to the font store

   403 

   404 	@SYMTestActions

   405 	Creates a type face store and adds

   406 	font files to it. Checks if adding

   407 	the files succeeded. Removes the files

   408 	from the store. Checks if succeeded.

   409 	

   410 	@SYMTestExpectedResults

   411 	Test should pass

   412 */

   413 void CTFbs::TestAddFontFile()

   414 	{

   415 	INFO_PRINTF1(_L("Test Add File"));

   416 	__UHEAP_MARK;

   417 	CFbsTypefaceStore* tfs=NULL;

   418 	TRAPD(ret,tfs=CFbsTypefaceStore::NewL(NULL));

   419 	TEST(ret==KErrNone);

   420 	TEST(tfs!=NULL);

   421 	TInt id1=0;

   422 	TInt id2=0;

   423 	TInt id3=0;

   424 	TInt id4=0;

   425 	ret=tfs->AddFile(KCTFbsTestFont,id1);

   426 	TEST(ret==KErrNone);

   427 	TEST(id1!=0);

   428 	ret=tfs->AddFile(KCTFbsTestFont,id2);

   429 	TEST(ret==KErrNone);

   430 	TEST(id2==id1);

   431 	ret=tfs->AddFile(KCTFbsTestFont,id3);

   432 	TEST(ret==KErrNone);

   433 	TEST(id3==id2);

   434 	tfs->RemoveFile(id1);

   435 	tfs->RemoveFile(id2);

   436 	tfs->RemoveFile(id3);

   437 	ret=tfs->AddFile(KCTFbsTestFont,id4);

   438 	TEST(ret==KErrNone);

   439 	TEST(id4==id1);

   440 	tfs->RemoveFile(id4);

   441 	delete tfs;

   442 	__UHEAP_MARKEND;

   443 	

   444 	//test the sequence AddFile, GetNearestFont, ReleaseFont, RemoveFile

   445 	CFbsTypefaceStore* tfs1=NULL;

   446     TRAPD(ret1,tfs1=CFbsTypefaceStore::NewL(NULL));

   447     TEST(ret1==KErrNone);

   448     TEST(tfs1!=NULL);

   449     TInt id5=0;

   450     ret1=tfs1->AddFile(_L("z:\\resource\\fonts\\DejaVuSerifCondensed.ttf"),id5);

   451     TEST(ret1==KErrNone);

   452     TEST(id5!=0);

   453     

   454     TInt id6=0;

   455     ret1=tfs1->AddFile(_L("z:\\resource\\fonts\\DejaVuSansCondensed.ttf"), id6);

   456     TEST(ret1==KErrNone);

   457     TEST(id6!=0);    

   458     

   459     TFontSpec fsp1;

   460     fsp1.iTypeface.iName=_L("DejaVu Serif Condensed");

   461     fsp1.iHeight=15;

   462     CFont* font1;

   463     ret1=tfs1->GetNearestFontToDesignHeightInTwips((CFont*&)font1,fsp1);

   464     TEST(ret1==KErrNone);

   465     

   466     TFontSpec fsp2;

   467     fsp2.iTypeface.iName=_L("DejaVu Serif Condensed");

   468     fsp2.iHeight=30;

   469     CFont *font2;

   470     ret1=tfs1->GetNearestFontToDesignHeightInTwips((CFont*&)font2,fsp2);

   471     TEST(ret1==KErrNone);

   472 

   473     TFontSpec fsp3;

   474     fsp3.iTypeface.iName=_L("DejaVu Sans Condensed");

   475     fsp3.iHeight=20;

   476     CFont *font3;

   477     ret1=tfs1->GetNearestFontToDesignHeightInTwips((CFont*&)font3,fsp3);

   478     TEST(ret1==KErrNone);

   479 

   480     TFontSpec fsp4;

   481     fsp4.iTypeface.iName=_L("DejaVu Serif Condensed");

   482     fsp4.iHeight=35;

   483     CFont *font4;

   484     ret1=tfs1->GetNearestFontToDesignHeightInTwips((CFont*&)font4,fsp4);

   485     TEST(ret1==KErrNone);

   486     

   487     if (font1)

   488         tfs1->ReleaseFont(font1);

   489     if (font2)

   490         tfs1->ReleaseFont(font2);

   491     if (font4)

   492         tfs1->ReleaseFont(font4);

   493  

   494     if (id6)

   495         tfs1->RemoveFile(id6);

   496     if (id5)

   497         tfs1->RemoveFile(id5);

   498     delete tfs1;

   499 	}

   500 

   501 /**

   502 	@SYMTestCaseID

   503 	GRAPHICS-FBSERV-0558

   504 

   505 	@SYMTestCaseDesc

   506 	Tries to add and load a nonexisting 

   507 	file to the FbsTypeFaceStore and checks

   508 	if it fails.

   509 	

   510 	@SYMTestActions

   511 	

   512 	@SYMTestExpectedResults

   513 	Test should pass

   514 */

   515 void CTFbs::TestInvalidFiles()

   516 	{

   517 	INFO_PRINTF1(_L("Test Invalid Files"));

   518 	__UHEAP_MARK;

   519 	CFbsTypefaceStore* tfs=NULL;

   520 	TRAPD(ret,tfs=CFbsTypefaceStore::NewL(NULL));

   521 	TEST(ret==KErrNone);

   522 	TEST(tfs!=NULL);

   523 	TInt id=0;

   524 	ret=tfs->AddFile(_L("\\nonexist.gdr"),id);

   525 	TEST(ret!=KErrNone);

   526 	delete tfs;

   527 	CFbsBitmapEx bmp;

   528 	ret=bmp.Load(_L("\\nonexist.mbm"),0);

   529 	TEST(ret!=KErrNone);

   530 	User::Heap().Check();

   531 	__UHEAP_MARKEND;

   532 	}

   533 

   534 /**

   535 	@SYMTestCaseID

   536 	GRAPHICS-FBSERV-0559

   537 

   538 	@SYMTestCaseDesc

   539 	Gets a font and tests all its properties. 

   540 

   541 	@SYMTestActions

   542 	Tests the char width, text width, handles, verifies

   543 	the resource count and the heap for memory leaks

   544 	CharWidthInPixels() and TextWidthInPixels() may return 

   545 	different values depending on the hardware used.

   546 	Therefore, when comparing these values for the same character,

   547 	allow a margin of 1 pixel difference.

   548 	

   549 	@SYMTestExpectedResults

   550 	Test should pass

   551 */

   552 void CTFbs::TestGetFont()

   553 	{

   554 	INFO_PRINTF1(_L("Test Get Font"));

   555 	CFbsFontEx* font=SelectFont();

   556 	iResourceCount++;

   557 	TEST(font->Handle()!=0);

   558 	CheckResourceCount();

   559 	TUid uid;

   560 	uid=KCFbsFontUid;

   561 	TEST(font->TypeUid()==uid);

   562 	TInt w=font->TextWidthInPixels(_L(" "));

   563 	TEST(w>0);

   564 	// Now test the same use case with context

   565 	CFont::TMeasureTextInput param;

   566 	param.iStartInputChar = 34;

   567 	TInt wContext=font->TextWidthInPixels(_L("->This text will not be measured<- "),&param);

   568 	TEST(wContext==w);

   569 	// End of first use case with context

   570 		

   571 	TInt x=font->TextCount(_L("          "),10);

   572 	TEST(10/w==x);

   573 	TInt y,z;

   574 	y=font->TextCount(_L("   "),10,z);

   575 	TEST(y==x);

   576 	TInt cwidth=font->CharWidthInPixels('i');

   577 	TInt twidth=font->TextWidthInPixels(_L("i"));

   578 	TInt charTextdiff = cwidth - twidth;

   579 	TEST(1>=charTextdiff && -1<=charTextdiff);

   580 	TInt twidthContext=font->TextWidthInPixels(_L("->This text will not be measured<-i"),&param);

   581 	TEST(twidth==twidthContext);

   582 	cwidth=font->CharWidthInPixels('p');

   583 	twidth=font->TextWidthInPixels(_L("p"));

   584 	charTextdiff = cwidth - twidth;

   585 	TEST(1>=charTextdiff && -1<=charTextdiff);

   586 	twidthContext=font->TextWidthInPixels(_L("->This text will not be measured<-p"),&param);

   587 	TEST(twidth==twidthContext);

   588 	cwidth=font->CharWidthInPixels('W');

   589 	twidth=font->TextWidthInPixels(_L("W"));

   590 	charTextdiff = cwidth - twidth;

   591 	TEST(1>=charTextdiff && -1<=charTextdiff);

   592 	twidthContext=font->TextWidthInPixels(_L("->This text will not be measured<-W"),&param);

   593 	TEST(twidth==twidthContext);

   594 	cwidth=font->CharWidthInPixels(' ');

   595 	twidth=font->TextWidthInPixels(_L(" "));

   596 	charTextdiff = cwidth - twidth;

   597 	TEST(1>=charTextdiff && -1<=charTextdiff);

   598 	SCharWidth chwid;

   599 	font->TextWidthInPixels(_L(" "),chwid);

   600 	TEST(chwid.iMove==w);

   601 	TEST(chwid.iWidth+chwid.iLeftAdjust+chwid.iRightAdjust==chwid.iMove);

   602 	font->TextWidthInPixels(_L("->This text will not be measured<- "),&param,chwid);

   603 	TEST(chwid.iMove==w);

   604 	TEST(chwid.iWidth+chwid.iLeftAdjust+chwid.iRightAdjust==chwid.iMove);

   605 

   606 	// Now do all these tests with an OpenType font where the width with context is different from the

   607 	// width without context

   608 	// NOTE:	These tests are performed for WINS and WINSCW only because we are using a TrueType font, and the bounds of 

   609 	// 			the text returned is different for different hardware devices, including different h4's	and hence 

   610 	//			cannot be measured.

   611 	#if defined __WINS__ || defined __WINSCW__

   612 	CFbsFontEx* openFont = SelectOpenTypeFont();

   613 	iResourceCount++;

   614 	TEST(font->Handle()!=0);

   615 	CheckResourceCount();

   616 	uid=KCFbsFontUid;

   617 	TEST(font->TypeUid()==uid);

   618 	cwidth=openFont->CharWidthInPixels('.');

   619 	twidth=openFont->TextWidthInPixels(_L("."));

   620 	charTextdiff = cwidth - twidth;

   621 	TEST(1>=charTextdiff && -1<=charTextdiff);

   622 	param.iStartInputChar = 1;

   623 	twidthContext=openFont->TextWidthInPixels(_L("\x0915."),&param);

   624 	TEST(twidth!=twidthContext);

   625 	cwidth=openFont->CharWidthInPixels(',');

   626 	twidth=openFont->TextWidthInPixels(_L(","));

   627 	charTextdiff = cwidth - twidth;

   628 	TEST(1>=charTextdiff && -1<=charTextdiff);

   629 	twidthContext=openFont->TextWidthInPixels(_L("\x0915,"),&param);

   630 	TEST(cwidth!=twidthContext);

   631 	TEST(twidth!=twidthContext);

   632 	openFont->TextWidthInPixels(_L("\x0915."),&param,chwid);

   633 	TEST(chwid.iMove!=cwidth);

   634 	#endif

   635 

   636 	CFbsFontEx* font2=SelectFont(); // Don't increment iResourceCount as the font is already in the cache

   637 	CheckResourceCount();

   638 	iTs->ReleaseFont(font2);

   639 	RFbsSession* fbsalt=RFbsSession::GetSession();

   640 	CFbsFontEx* font3=new CFbsFontEx;

   641 	font3->Duplicate(font->Handle());

   642 	iResourceCount++;

   643 	TEST(font3->Handle());

   644 	CheckResourceCount();

   645 	TEST(fbsalt->ResourceCount()==iResourceCount);

   646 	iTs->ReleaseFont(font);

   647 	iResourceCount--;

   648 	TEST(w==font3->TextWidthInPixels(_L(" ")));

   649 	CheckResourceCount();

   650 	TEST(fbsalt->ResourceCount()==iResourceCount);

   651 	font3->Reset();

   652 	User::Free(font3);

   653 	iResourceCount--;

   654 	CheckResourceCount();

   655 	TEST(fbsalt->ResourceCount()==iResourceCount);

   656 	User::Heap().Check();

   657 	}

   658 

   659 /**

   660 	@SYMTestCaseID

   661 	GRAPHICS-FBSERV-0560

   662 

   663 	@SYMTestCaseDesc

   664 	Tests the font store.

   665 

   666 	@SYMTestActions

   667 	Allocates an array of pointers which is

   668 	used to store the font height. It tests

   669 	the font height and gets the nearest font

   670 	available. The heap is checked for 

   671 	memory leaks.	

   672 	

   673 	@SYMTestExpectedResults

   674 	Test should pass

   675 */

   676 void CTFbs::TestFontStore()

   677 	{

   678 	INFO_PRINTF1(_L("Test Font Store"));

   679 	CFbsFontEx* font=NULL;

   680 	TFontSpec fs;

   681 	TInt typefaces=iTs->NumTypefaces();

   682 	TTypefaceSupport info;

   683 	for(TInt count=0;count<typefaces;count++)

   684 		{

   685 		iTs->TypefaceSupport(info,count);

   686 		INFO_PRINTF1(_L("    "));

   687 	    TBuf<KMaxTypefaceNameLength> tname;

   688 		tname.Copy(info.iTypeface.iName);

   689 		INFO_PRINTF1(tname);

   690 		INFO_PRINTF1(_L("\n"));

   691 		TInt* heightarray=(TInt*)User::Alloc(info.iNumHeights*sizeof(TInt));

   692 		TInt index=0;

   693 		for(;index<info.iNumHeights;index++)

   694 			heightarray[index]=iTs->FontHeightInTwips(count,index);

   695 		for(index=1;index<info.iNumHeights;index++)

   696 			TEST(heightarray[index]>heightarray[index-1]);

   697 		for(index=0;index<info.iNumHeights;index++)

   698 			heightarray[index]=iTs->FontHeightInPixels(count,index);

   699 		for(index=1;index<info.iNumHeights;index++)

   700 			TEST(heightarray[index]>=heightarray[index-1]);

   701 		delete [] heightarray;

   702 		for(index=0;index<info.iNumHeights;index++)

   703 			{

   704 			TInt height=iTs->FontHeightInTwips(count,index);

   705 			fs.iTypeface=info.iTypeface;

   706 			fs.iHeight=height;

   707 			TInt ret=iTs->GetNearestFontToDesignHeightInTwips((CFont*&)font,fs);

   708 			TEST(ret==KErrNone);

   709 			TEST(font->Handle());

   710 			iTs->ReleaseFont(font);

   711 

   712 			height=iTs->FontHeightInPixels(count,index);

   713 			fs.iTypeface=info.iTypeface;

   714 			fs.iHeight=height;

   715 			ret=iTs->GetNearestFontToDesignHeightInPixels((CFont*&)font,fs);

   716 			TEST(ret==KErrNone);

   717 			TEST(font->Handle());

   718 			iTs->ReleaseFont(font);

   719 			}

   720 		}

   721 	iResourceCount = iFbs->ResourceCount(); // Allow for fonts left in the typeface store cache

   722 	User::Heap().Check();

   723 	}

   724 

   725 /**

   726 	@SYMTestCaseID

   727 	GRAPHICS-FBSERV-0561

   728 

   729 	@SYMTestCaseDesc

   730 	Tests the font name alias

   731 

   732 	@SYMTestActions

   733 	Creates three different font name alias with a 

   734 	mixture of caps and small letters. Checks the font

   735 	name aliases using the different names.

   736 	

   737 	@SYMTestExpectedResults

   738 	Test should pass

   739 */

   740 void CTFbs::TestFontNameAlias()

   741 	{

   742 	INFO_PRINTF1(_L("Test Font Name Alias"));

   743 

   744 	TInt size = 20;

   745 	_LIT(KFontAlias0,"Font alias 0");

   746 	_LIT(KFontAlias1,"Font alias 1");

   747 	_LIT(KFontAlias2,"FOnT AlIaS 0");//Alias name in mixture of caps & small letters for KFontAlias0

   748 

   749     TBuf<KMaxTypefaceNameLength> defaultName;

   750     TBuf<KMaxTypefaceNameLength> fontName[3];

   751 

   752 	CFbsFontEx* font = NULL;

   753 	TFontSpec fs(KNullDesC,200);

   754 	TInt ret = iTs->GetNearestFontToDesignHeightInTwips((CFont*&)font,fs);

   755 	TEST(ret == KErrNone);

   756 	TEST(font->Handle());

   757 	fs = font->FontSpecInTwips();

   758 	defaultName = fs.iTypeface.iName;

   759 	iTs->ReleaseFont(font);

   760 

   761 	TTypefaceSupport info;

   762 	for (TInt index = 0, nameIndex = 0; nameIndex < 3; index++)

   763 		{

   764 		iTs->TypefaceSupport(info,index);

   765 		if (info.iTypeface.iName != defaultName)

   766 			fontName[nameIndex++] = info.iTypeface.iName;

   767 		}

   768 

   769 	TRAP(ret,iTs->SetFontNameAliasL(KFontAlias0,fontName[0]));

   770 	TEST(ret == KErrNone);

   771 	CheckFontNameAlias(KFontAlias0,fontName[0],size);

   772 	//Testing if it works even if the alias name passed differs in case

   773 	CheckFontNameAlias(KFontAlias2,fontName[0],size);

   774 

   775 	TRAP(ret,iTs->SetFontNameAliasL(KFontAlias1,fontName[1]));

   776 	TEST(ret == KErrNone);

   777 	CheckFontNameAlias(KFontAlias0,fontName[0],size);

   778 	CheckFontNameAlias(KFontAlias1,fontName[1],size);

   779 

   780 	TRAP(ret,iTs->SetFontNameAliasL(KFontAlias0,fontName[2]));

   781 	TEST(ret == KErrNone);

   782 	CheckFontNameAlias(KFontAlias0,fontName[2],size);

   783 	CheckFontNameAlias(KFontAlias1,fontName[1],size);

   784 

   785 	TRAP(ret,iTs->SetFontNameAliasL(KFontAlias1,KNullDesC));

   786 	TEST(ret == KErrNone);

   787 	CheckFontNameAlias(KFontAlias0,fontName[2],size);

   788 	CheckFontNameAlias(KFontAlias1,defaultName,size);

   789 

   790 	TRAP(ret,iTs->SetFontNameAliasL(KFontAlias0,KNullDesC));

   791 	TEST(ret == KErrNone);

   792 	CheckFontNameAlias(KFontAlias0,defaultName,size);

   793 	CheckFontNameAlias(KFontAlias1,defaultName,size);

   794 	iResourceCount--; // Allow for a cache eviction because the last check fills the cache

   795 

   796 	CheckResourceCount();

   797 	User::Heap().Check();

   798 	}

   799 

   800 void CTFbs::CheckFontNameAlias(const TDesC& aFontAlias, const TDesC& aFontName, TInt& aSize)

   801 	{

   802 	CFbsFontEx* font = NULL;

   803 	TFontSpec fs(aFontAlias,aSize);

   804 	aSize += 20;

   805 

   806 	TInt ret = iTs->GetNearestFontToDesignHeightInTwips((CFont*&)font,fs);

   807 	TEST(ret == KErrNone);

   808 	TEST(font->Handle());

   809 

   810 	TFontSpec checkFS = font->FontSpecInTwips();

   811 	TEST(checkFS.iTypeface.iName == aFontName);

   812 

   813 	iTs->ReleaseFont(font);

   814 	}

   815 

   816 /**

   817 	@SYMTestCaseID

   818 	GRAPHICS-FBSERV-0562

   819 

   820 	@SYMTestCaseDesc

   821 	Tests the width of a font stored in a buffer

   822 	

   823 	@SYMTestActions

   824 	Gets how much of the specified descriptor can be 

   825 	displayed for a specified font without 

   826 	exceeding the specified width.

   827 	

   828 	@SYMTestExpectedResults

   829 	Test should pass

   830 */

   831 void CTFbs::TestBufferedFont()

   832 	{

   833 	INFO_PRINTF1(_L("Test Buffered Font"));

   834 	CFbsFontEx* font=SelectFont();

   835 	TBuf<1280> largebuf;

   836 	TInt count=0;

   837 	for(;count<1280;count++)

   838 		largebuf.Append(32);

   839 	TInt width,lcount,rcount,lwidth,rwidth;

   840 	width=font->TextWidthInPixels(largebuf);

   841 	for(count=0;count<1280;count+=500)

   842 		{

   843 		lcount=font->TextCount(largebuf.Left(count),100000);

   844 		TEST(lcount==count);

   845 		rcount=font->TextCount(largebuf.Right(1280-count),100000);

   846 		TEST(rcount==1280-count);

   847 		lwidth=font->TextWidthInPixels(largebuf.Left(count));

   848 		rwidth=font->TextWidthInPixels(largebuf.Right(1280-count));

   849 		TEST(rwidth+lwidth==width);

   850 		}

   851 	iTs->ReleaseFont(font);

   852 	CheckResourceCount();

   853 	User::Heap().Check();

   854 	}

   855 

   856 /**

   857 	@SYMTestCaseID

   858 	GRAPHICS-FBSERV-0563

   859 

   860 	@SYMTestCaseDesc

   861 	Tests having multiple fonts allocated

   862 	and deallocated

   863 

   864 	@SYMTestActions

   865 	Gets multiple font. Releases the hold of a 

   866 	typeface store client on a specified font.

   867 	Decrements the access-count for the specified 

   868 	font by one. If this reduces the access-count 

   869 	to zero then the font is no longer needed by any 

   870 	client, and is deleted from the typeface store list.

   871 	

   872 	@SYMTestExpectedResults

   873 	Test should pass

   874 */

   875 void CTFbs::TestMultipleFont()

   876 	{

   877 	INFO_PRINTF1(_L("Test Multiple Font"));

   878 	const TInt numfonts=100;

   879 	CFbsFontEx* fonts[numfonts];

   880 	TInt count=0;

   881 	for(;count<numfonts;count++)

   882 		fonts[count]=SelectFont();

   883 	for(count=0;count<numfonts;count++)

   884 		iTs->ReleaseFont(fonts[count]);

   885 	INFO_PRINTF2(_L("    %d font handles created.\n"),numfonts);

   886 	CheckResourceCount();

   887 	User::Heap().Check();

   888 	}

   889 

   890 /**

   891 	@SYMTestCaseID

   892 	GRAPHICS-FBSERV-0564

   893 

   894 	@SYMTestCaseDesc

   895 	Tests creation of unique bitmaps with

   896 	no handles already to them. Also tests

   897 	and verifies defects DEF069571 and DEF076347.

   898 	

   899 	@SYMDEF DEF069571 DEF076347

   900 	

   901 	@SYMTestActions

   902 	Test creation of original bitmaps. Destroys 

   903 	existing bitmap and creates a new one. Tests

   904 	creation of bitmap by duplicating an already

   905 	existing bitmap. Tests creation of different 

   906 	sized bitmaps and resizes them.

   907 	

   908 	@SYMTestExpectedResults

   909 	Test should pass

   910 */

   911 void CTFbs::TestCreateBitmap()

   912 	{

   913 	INFO_PRINTF1(_L("Test Create Bitmap"));

   914 	__UHEAP_MARK;

   915 

   916 	CFbsBitmapEx bmp1;

   917 	CFbsBitmapEx bmp2;

   918 

   919 	// Test creation of original bitmaps (ie handles are unique)

   920 	TInt ret=bmp1.Create(TSize(0,0),EGray2);

   921 	TEST(ret==KErrNone);

   922 	iResourceCount++;

   923 	CheckResourceCount();

   924 

   925 	ret=bmp2.Load(iTestBitmapName,ETfbs);

   926 	TEST(ret==KErrNone);

   927 	iResourceCount++;

   928 	TEST(bmp2.Handle()!=bmp1.Handle());

   929 	CheckResourceCount();

   930 

   931 	ret=bmp2.Create(TSize(0,0),EGray2); // Destroys existing and creates new

   932 	TEST(ret==KErrNone);

   933 	TEST(bmp2.Handle()!=bmp1.Handle());

   934 	CheckResourceCount();

   935 	bmp2.Reset();

   936 	iResourceCount--;

   937 	CheckResourceCount();

   938 

   939 	// Test creation by duplication

   940 	RFbsSession* fbsalt=RFbsSession::GetSession();

   941 	CFbsBitmapEx bmp3;

   942 

   943 	ret=bmp3.Duplicate(bmp1.Handle());

   944 	TEST(ret==KErrNone);

   945 	iResourceCount++;

   946 	CheckResourceCount();

   947 	TEST(fbsalt->ResourceCount()==iResourceCount);

   948 	TEST((TInt)bmp1.BitmapAddress());

   949 	CBitwiseBitmap* bmp3add=bmp3.BitmapAddress();

   950 	CBitwiseBitmap* bmp1add=bmp1.BitmapAddress();

   951 	TEST(bmp3add==bmp1add);

   952 	TEST(bmp3.Handle()==bmp1.Handle());

   953 	bmp3.Reset();

   954 	iResourceCount--;

   955 	CheckResourceCount();

   956 	TEST(fbsalt->ResourceCount()==iResourceCount);

   957 	bmp1.Reset();

   958 	iResourceCount--;

   959 	CheckResourceCount();

   960 	TEST(fbsalt->ResourceCount()==iResourceCount);

   961 	

   962 	//Testing the DEF069571

   963 	

   964 	CFbsBitmapEx bmp0;

   965 	//Test creation of large bitmaps (>65536)

   966 	TInt ret0=bmp0.Create(TSize(65536,1),EGray256);

   967 	bmp0.Reset();

   968 	

   969 	//Testcode for DEF076347

   970 	CFbsBitmapEx bmp01;

   971 	TInt ret01=bmp01.Create(TSize(65536,1),EColor16MU);

   972 	TInt ret02=bmp01.SetDisplayMode(EColor16MA);

   973 	bmp01.Reset();

   974 	

   975 	

   976 

   977 	// Test creation of different sizes and resizing them

   978 	DoResizeBitmap(EGray2);

   979 	DoResizeBitmap(EGray4);

   980 	DoResizeBitmap(EGray16);

   981 	DoResizeBitmap(EGray256);

   982 	DoResizeBitmap(EColor16);

   983 	DoResizeBitmap(EColor256);

   984 	DoResizeBitmap(EColor4K);

   985 	DoResizeBitmap(EColor64K);

   986 	DoResizeBitmap(EColor16M);

   987 

   988 	User::Heap().Check();

   989 	__UHEAP_MARKEND;

   990 	}

   991 

   992 void CTFbs::DoResizeBitmap(TDisplayMode aDispMode)

   993 	{

   994 	const TInt numNewSizes = 5;

   995 	const TSize newSizes[numNewSizes] = { TSize(0,0), TSize(1,1), TSize(17,20), TSize(32,32), TSize(32,1025) };

   996 	const TInt numTwipsSizes = 4;

   997 	const TSize twipsSizes[numTwipsSizes] = { TSize(100,100), TSize(1440,1440), TSize(1000000,1000000), TSize(0,0) };

   998 

   999 	__UHEAP_MARK;

  1000 

  1001 	CFbsBitmapEx bmp;

  1002 

  1003 	TInt count;

  1004 	for(count = 0; count < numNewSizes; count++)

  1005 		{

  1006 		TSize size = newSizes[count];

  1007 		TInt ret = bmp.Create(size,aDispMode);

  1008 		TEST(ret == KErrNone);

  1009 		TEST(bmp.Handle() != 0);

  1010 		TEST(bmp.SizeInPixels() == size);

  1011 		TEST(bmp.DisplayMode() == aDispMode);

  1012 		}

  1013 

  1014 	for(count = 0; count < numNewSizes; count++)

  1015 		{

  1016 		TInt ret = bmp.Create(TSize(0,0),aDispMode);

  1017 		TSize size = newSizes[count];

  1018 		ret = bmp.Resize(size);

  1019 		TEST(ret == KErrNone);

  1020 		TEST(bmp.SizeInPixels() == size);

  1021 		}

  1022 

  1023 	for(count = 0; count < numTwipsSizes; count++)

  1024 		{

  1025 		TSize size = twipsSizes[count];

  1026 		bmp.SetSizeInTwips(size);

  1027 		TEST(bmp.SizeInTwips() == size);

  1028 		}

  1029 

  1030 	bmp.Reset();

  1031 	CheckResourceCount();

  1032 

  1033 	User::Heap().Check();

  1034 	DeleteScanLineBuffer();

  1035 	__UHEAP_MARKEND;

  1036 	}

  1037 

  1038 /**

  1039 	@SYMTestCaseID

  1040 	GRAPHICS-FBSERV-0565

  1041 

  1042 	@SYMTestCaseDesc

  1043 	Tests loading of bitmaps

  1044 

  1045 	@SYMTestActions

  1046 	Loads a specific bitmap from a multi-bitmap 

  1047 	file. Retrieves the bitmap addresses for the

  1048 	bitmap and check if they are valid.

  1049 	

  1050 	@SYMTestExpectedResults

  1051 	Test should pass

  1052 */

  1053 void CTFbs::TestLoadBitmap()

  1054 	{

  1055 	INFO_PRINTF1(_L("Test Load Bitmap"));

  1056 	__UHEAP_MARK;

  1057 	CFbsBitmapEx bmp1;

  1058 	CFbsBitmapEx bmp2;

  1059 	CFbsBitmapEx bmp3;

  1060 	CFbsBitmapEx bmp4;

  1061 	CFbsBitmapEx bmp5;

  1062 	TInt ret=bmp1.Load(iTestBitmapName,ETfbs);

  1063 	TEST(ret==KErrNone);

  1064 	iResourceCount++;

  1065 	TEST(bmp1.Handle()!=0);

  1066 	ret=bmp2.Load(iTestBitmapName,ETfbs);

  1067 	TEST(ret==KErrNone);

  1068 	iResourceCount++;

  1069 	CBitwiseBitmap* bmp1add=bmp1.BitmapAddress();

  1070 	TEST((TInt)bmp1add);

  1071 	CBitwiseBitmap* bmp2add=bmp2.BitmapAddress();

  1072 	TEST(bmp1add==bmp2add);

  1073 	TEST(bmp1.Handle()==bmp2.Handle());

  1074 	ret=bmp3.Load(iTestBitmapName,ETblank);

  1075 	TEST(ret==KErrNone);

  1076 	iResourceCount++;

  1077 	TEST(bmp1.Handle()!=bmp3.Handle());

  1078 	bmp2.Reset();

  1079 	iResourceCount--;

  1080 	ret=bmp4.Load(iTestBitmapName,ETfbs);

  1081 	TEST(ret==KErrNone);

  1082 	iResourceCount++;

  1083 	CBitwiseBitmap* bmp4add=bmp4.BitmapAddress();

  1084 	TEST(bmp1add==bmp4add);

  1085 	TEST(bmp4.Handle()==bmp1.Handle());

  1086 	ret=bmp5.Load(iTestBitmapName,ETblank);

  1087 	TEST(ret==KErrNone);

  1088 	iResourceCount++;

  1089 	CBitwiseBitmap* bmp3add=bmp3.BitmapAddress();

  1090 	CBitwiseBitmap* bmp5add=bmp5.BitmapAddress();

  1091 	TEST((TInt)bmp3add);

  1092 	TEST(bmp3add==bmp5add);

  1093 	TEST(bmp5.Handle()==bmp3.Handle());

  1094 	CheckResourceCount();

  1095 	bmp3.Reset();

  1096 	iResourceCount--;

  1097 	bmp4.Reset();

  1098 	iResourceCount--;

  1099 	bmp5.Reset();

  1100 	iResourceCount--;

  1101 	ret=bmp2.Load(iTestBitmapName,ETfbs);

  1102 	TEST(ret==KErrNone);

  1103 	iResourceCount++;

  1104 	bmp2add=bmp2.BitmapAddress();

  1105 	TEST(bmp1add==bmp2add);

  1106 	TEST(bmp1.Handle()==bmp2.Handle());

  1107 	CheckResourceCount();

  1108 	bmp1.Reset();

  1109 	iResourceCount--;

  1110 	bmp2.Reset();

  1111 	iResourceCount--;

  1112 	CheckResourceCount();

  1113 

  1114 	ret=bmp1.Load(iTestBitmapName,ETfbs,EFalse);

  1115 	TEST(ret==KErrNone);

  1116 	ret=bmp2.Load(iTestBitmapName,ETfbs,ETrue);

  1117 	TEST(ret==KErrNone);

  1118 	ret=bmp3.Load(iTestBitmapName,ETfbs,ETrue);

  1119 	TEST(ret==KErrNone);

  1120 	ret=bmp4.Load(iTestBitmapName,ETfbs,EFalse);

  1121 	TEST(ret==KErrNone);

  1122 	ret=bmp5.Load(iTestBitmapName,ETfbs,ETrue);

  1123 	TEST(ret==KErrNone);

  1124 	bmp1add=bmp1.BitmapAddress();

  1125 	bmp2add=bmp2.BitmapAddress();

  1126 	bmp3add=bmp3.BitmapAddress();

  1127 	bmp4add=bmp4.BitmapAddress();

  1128 	bmp5add=bmp5.BitmapAddress();

  1129 	TEST(bmp1add!=bmp2add);

  1130 	TEST(bmp1add!=bmp3add);

  1131 	TEST(bmp1add!=bmp4add);

  1132 	TEST(bmp1add!=bmp5add);

  1133 	TEST(bmp2add==bmp3add);

  1134 	TEST(bmp2add!=bmp4add);