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

 // All rights reserved.

 // This component and the accompanying materials are made available

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

 // which accompanies this distribution, and is available

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

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // This test is designed to run in environment with monotype font support.

 // To set up environment launch ityperast.cmd  from epoc32\winscw\, and 

 // then follow instruction on the screen.

 // 

 //

 #include "tglyphimagecache.h"

 #include <graphics/directgdiengine.h>

 #include <e32base.h>

 #include <VG/openvg.h>

 // The size of the target in pixels to use for these tests

 const TSize KGlyphCacheWindowSize(400, 400);

 enum TFontParam

 	{

 	ENormal, 

 	EUnderline = 0x1, 

 	EStrikeThrough = 0x2,

 	EBold = 0x4,

 	EUnderlineBold = 0x5, 

 	EItalic = 0x8,

 	EItalicStrikeThrough = 0xa,

 	};

 class TFontType

 	{

 public:

 	TInt iFontSize;

 	TFontParam iFontParam;

 	}; 

 LOCAL_C void CleanCache(TAny* aPtr)

 	{

 	MFontGlyphImageStorage* glyphImageStorage = reinterpret_cast<MFontGlyphImageStorage*> (aPtr);

 	glyphImageStorage->CleanGlyphImageCache();

 	}

 CTGlyphImageCache::CTGlyphImageCache()

 	{

 	SetTestStepName(KTGlyphImageCacheStep);

 	}

 CTGlyphImageCache::~CTGlyphImageCache()

 	{

 	}

 /**

 @SYMTestCaseID

 	GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0001

 @SYMPREQ 

 	PREQ39

 @SYMREQ

 	REQ9195

 	REQ9201 

 	REQ9202 

 	REQ9222 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestCaseDesc

 	Test requests Glyph Image elements from storage according their Glyph Key.

 @SYMTestStatus

 	Implemented

 @SYMTestPriority

 	High

 @SYMTestActions

 	Create Font Image Storage. In the cycle request aGlyph Image entry for a particular Glyph 

 	code and a font ID. 

 	Delete Glyph Storage.

 @SYMTestExpectedResults

 	GlyphImage function must succeed; foreground, shadow and outlined images (if applicable) must be created

 */

 void CTGlyphImageCache::TestRetrieveEntryL(MFontGlyphImageStorage* aGlyphStorage, TGlyphBitmapType aGlyphType)

 	{

 	if(!aGlyphStorage)

 		return;	

 	_LIT(KTestName, "GlyphCache_RetrieveEntry"); 

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestName);

 		}

 	TSize size(20, 30);

 	TInt bufferLength = size.iWidth * size.iHeight;

 	TUint8* buffer = (TUint8*)User::AllocL(bufferLength);

 	CleanupStack::PushL(buffer);

 	if(aGlyphType == EMonochromeGlyphBitmap)

 		{//to make decoding mechanizm work properly we need to fill the buffer

 		Mem::Fill(buffer, bufferLength, 0x1);

 		}

 	TInt fontListId[] = 

 		{

 		1, 5, 3, 5

 		};

 	TInt numFont = sizeof(fontListId) / sizeof(fontListId[0]);

 	TUint charCodeList[] =

 		{

 		1, 2, 3, 2, 3,

 		};

 	TInt numGlyphCode = sizeof(charCodeList) / sizeof(charCodeList[0]);

 	for(TInt jj = 0; jj < numFont; jj++)

 		{

 		TInt fontId = fontListId[jj];

 		for(TInt ii = 0; ii < numGlyphCode; ii++)

 			{

 			TChar glyphCode = TChar(charCodeList[ii]);

 			VGImage foregroundImg = VG_INVALID_HANDLE;

 			VGImage shadowImg = VG_INVALID_HANDLE;

 			VGImage outlineImg = VG_INVALID_HANDLE;

 			TBool res = aGlyphStorage->GlyphImage(fontId, glyphCode, aGlyphType, buffer, size, &foregroundImg, &shadowImg, &outlineImg);

 			TESTNOERROR(res);

 			if(res != KErrNone)

 				{

 				User::Leave(res); 

 				}

 			else

 				{

 				TEST(foregroundImg);

 				if(aGlyphType == EFourColourBlendGlyphBitmap)

 					{

 					TEST(shadowImg);

 					TEST(outlineImg);

 					}

 				}	

 			}

 		}

 	CleanupStack::PopAndDestroy(buffer);

 	}

 /**

 @SYMTestCaseID

 	GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0002

 @SYMPREQ 

 	PREQ39

 @SYMREQ

 	REQ9195

 	REQ9201 

 	REQ9202 

 	REQ9222 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestCaseDesc

 	Drawing monochrome, anti-aliased and four colour fonts with different styles  

 @SYMTestStatus

 	Implemented

 @SYMTestPriority

 	High

 @SYMTestActions

 	Text is output with different effects (strikethrough, underline) and orientation 

 	(horizontal, vertical up, vertical down) and at different sizes and positions.

 	Clip region is also specified.

 @SYMTestExpectedResults

 	Test and reference images must match

 */

 void CTGlyphImageCache::TestDrawGlyphL(MFontGlyphImageStorage* aGlyphStorage, TGlyphBitmapType aGlyphBitmapType, DrawTextDirection aDirection, DrawTextAdjustment aDrawAdjustment, TBool aClipText)

 	{	

 	_LIT(KTestNameTemplate, "DrawGlyph%S_Dir%d_Clip%d_Adjust%d"); 

 	TBuf<128> testName;

 	_LIT(KTextOutput, "Hello world! Hello world! Hello world! Hello world! Hello world! Hello world!");

 	switch(aGlyphBitmapType)

 		{

 	case EMonochromeGlyphBitmap:

 		_LIT(KMonochromeName, "Monochrome");

 		testName.Format(KTestNameTemplate, &KMonochromeName, aDirection, aClipText, aDrawAdjustment);

 		break;

 	case EAntiAliasedGlyphBitmap:

 		_LIT(KAntiAliasedName, "AntiAliased");

 		testName.Format(KTestNameTemplate, &KAntiAliasedName, aDirection, aClipText, aDrawAdjustment);

 		break;

 	case EFourColourBlendGlyphBitmap:

 		_LIT(KFourColourName, "FourColour");

 		testName.Format(KTestNameTemplate, &KFourColourName, aDirection, aClipText, aDrawAdjustment);

 		break;

 	default: 

 		User::Leave(KErrNotSupported);

 		break;	

 		}

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(testName);

 		}

 	ResetGc();

 	_LIT(KTestFontTypefaceName,"DejaVu Sans Condensed");

 	const TFontType fontType[] =

 		{

 		18, EStrikeThrough, 48, EUnderline, 16, EItalic, 78, EItalicStrikeThrough,

 		18, EStrikeThrough, 48, EUnderlineBold, 16, ENormal, 78, EStrikeThrough, 78, EBold, 

 		};

 	TPoint pt(5, 5);

 	TInt *coord = & (pt.iY);

 	TSize size = iGdiTarget->SizeInPixels();

 	TRect rect = size;

 	rect.Shrink(20, 5);

 	RRegion region(rect);

 	TRect rect1;

 	if(aDirection == EDrawTextHorizontal)

 		{

 		rect1 = TRect(size.iWidth / 2 - 40, 40, size.iWidth / 2 + 40, size.iHeight - 40);

 		}

 	else

 		{

 		rect1 = TRect(20, size.iHeight / 2 - 40, size.iWidth - 20, size.iHeight / 2 + 40);

 		}	

 	region.SubRect(rect1);

 	if(aDirection == EDrawTextVerticalUp || aDirection == EDrawTextVerticalDown)

 		{

 		if(aDirection == EDrawTextVerticalUp)

 			{

 			pt.iY = size.iHeight - 5;

 			}

 		coord = &(pt.iX);

 		}

 	TInt arraySize = sizeof(fontType) / sizeof(fontType[0]);

 	for(TInt ii = 0; ii < arraySize; ii++)

 		{

 		CFont *font = NULL;

 		TFontSpec fspec(KTestFontTypefaceName, fontType[ii].iFontSize);

 		fspec.iFontStyle.SetBitmapType(aGlyphBitmapType);

 		iGc->Reset();

 		if(aClipText)

 			{

 			iGc->SetClippingRegion(region);

 			}

 		if(aGlyphBitmapType == EFourColourBlendGlyphBitmap)

 			{

 			fspec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

 			fspec.iFontStyle.SetEffects(FontEffect::EOutline, ETrue);

 			fspec.iFontStyle.SetEffects(FontEffect::EDropShadow, ETrue);

 			TRgb shadowColor = TRgb(0, 0, 255);

 			iGc->SetTextShadowColor(shadowColor);

 			TEST(shadowColor == iGc->TextShadowColor());

 			iGc->SetBrushColor(TRgb(255, 0, 0));

 			TEST(TRgb(255, 0, 0) == iGc->BrushColor());

 			}

 		else

 			{

 			iGc->SetBrushStyle(DirectGdi::ENullBrush);

 			iGc->SetPenStyle(DirectGdi::ESolidPen);

 			}	

 		iGc->SetPenColor(TRgb(0, 255, 0));

 		if(fontType[ii].iFontParam & EItalic)

 			{

 			fspec.iFontStyle.SetPosture(EPostureItalic);

 			}

 		if(fontType[ii].iFontParam & EBold)

 			{

 			fspec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);

 			}

 		User::LeaveIfError(iFontStore->GetNearestFontToDesignHeightInPixels((CFont*&) font, fspec));

 		if(iUseDirectGdi)

 			{

 			if(ii == 2)

 				{

 				iGc->SetFontNoDuplicate(font);

 				(reinterpret_cast <CTestDirectGdiContext*> (iGc))->NoJustifyAutoUpdate();

 				}

 			else

 				{

 				iGc->SetFont(font);

 				iGc->SetFontNoDuplicate(font);//shoudn't have any impact

 				(reinterpret_cast <CTestDirectGdiContext*> (iGc))->SetJustifyAutoUpdate();

 				}	

 			}

 		else

 			{

 			iGc->SetFont(font);

 			iGc->SetFontNoDuplicate(font);//shoudn't have any impact

 			}	

 		TEST(iGc->HasFont());

 		TFontSpec fontSpec = font->FontSpecInTwips();

 		TGlyphBitmapType glyphBitmapType = fontSpec.iFontStyle.BitmapType();

 		TEST(glyphBitmapType == aGlyphBitmapType);	

 		if(fontType[ii].iFontParam & EUnderline)

 			{

 			iGc->SetUnderlineStyle(DirectGdi::EUnderlineOn);

 			}

 		else if(fontType[ii].iFontParam & EStrikeThrough)

 			{

 			iGc->SetStrikethroughStyle(DirectGdi::EStrikethroughOn);

 			}

 		if(EDrawTextVerticalDown != aDirection)

 			{

 			*coord += font->HeightInPixels() + 5;

 			}

 		if(aGlyphStorage && (ii == 0) && (arraySize > 1))

 			{

 			aGlyphStorage->CleanGlyphImageCache();

 			aGlyphStorage->EnforceOOMFailure(ETrue);

 			}

 		DrawText(KTextOutput, pt, aDirection, aDrawAdjustment, ii == 1);

 		if(aGlyphStorage)

 			{

 			aGlyphStorage->EnforceOOMFailure(EFalse);

 			}

 		if(EDrawTextVerticalDown == aDirection)

 			{

 			*coord += font->HeightInPixels() + 5;

 			}

 		if(fontType[ii].iFontParam == ENormal)

 			{

 			iGc->SetUnderlineStyle(DirectGdi::EUnderlineOff);

 			iGc->SetStrikethroughStyle(DirectGdi::EStrikethroughOff);

 			}

 		iGc->ResetFont();

 		iFontStore->ReleaseFont(font);

 		TEST(!iGc->HasFont());

 		}

 	region.Close();

 	if(aClipText)

 		{

 		iGc->ResetClippingRegion();

 		}

 	// Write the output to file.

 	//

 	TESTNOERROR(WriteTargetOutput(iTestParams, testName));

 	}

 /**

 @SYMTestCaseID

 	GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0003

 @SYMPREQ 

 	PREQ39

 @SYMREQ

 	REQ9195

 	REQ9201 

 	REQ9202 

 	REQ9222 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestCaseDesc

 	Filling up the glyph image cache

 @SYMTestStatus

 	Implemented

 @SYMTestPriority

 	High

 @SYMTestActions

 	1.	Fill glyph image storage with the same font but different glyphs until it exceeds its limit and resets the cache.

 	Repeat this operation for other glyph types

 	2.	Fill glyph image storage with different font and different glyph codes

 @SYMTestExpectedResults

 	Check that Glyph cache storage increments cache size correctly and deletes the least 

 	usable tree.

 */

 void CTGlyphImageCache::FillUpCacheL(MFontGlyphImageStorage* aGlyphStorage)

 	{

 	if(!aGlyphStorage)

 		return;

 	aGlyphStorage->CleanGlyphImageCache();

 	TBuf<128> testName;

 	_LIT(KTestName, "GlyphCache_FillUpCache"); 

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestName);

 		}

 	const TSize size(12, 16);

 	TUint8* buffer = (TUint8*)User::AllocL(size.iWidth * size.iHeight);

 	CleanupStack::PushL(buffer);

 	TInt fontId = 10;

 	TGlyphBitmapType glyphTypeList[] = 

 		{

 		EMonochromeGlyphBitmap,

 		EAntiAliasedGlyphBitmap,

 		EFourColourBlendGlyphBitmap,

 		};

 	const TInt numGlyphType = sizeof(glyphTypeList) / sizeof(glyphTypeList[0]);

 	TESTL(aGlyphStorage->GlyphCacheSize() == 0);

 	TInt glyphSizeInByte = 0;

 	TInt expectedSize = 0;

 	TUint32 glyphCode = 1;

 	VGImage foregroundImg = VG_INVALID_HANDLE;

 	VGImage shadowImg = VG_INVALID_HANDLE;

 	VGImage outlineImg = VG_INVALID_HANDLE;

 	for(TInt ii = 0; ii < numGlyphType; ii++)

 		{

 		TGlyphBitmapType glyphType = glyphTypeList[ii];

 		//calculate the actual size of the glyph

 		glyphSizeInByte = GlyphImageSizeInByte(glyphType, size);

 		TUint maxGlyphSize = aGlyphStorage->MaxGlyphCacheSize() + glyphSizeInByte;

 		do 

 			{

 			TEST(expectedSize == aGlyphStorage->GlyphCacheSize());

 			TBool res = aGlyphStorage->GlyphImage(fontId, TChar(glyphCode), (TGlyphBitmapType)glyphType, buffer, size, &foregroundImg, &shadowImg, &outlineImg);

 			TESTNOERRORL(res);

 			glyphCode++;

 			expectedSize+= glyphSizeInByte; 

 			foregroundImg = VG_INVALID_HANDLE;

 			shadowImg = VG_INVALID_HANDLE;

 			outlineImg = VG_INVALID_HANDLE;

 			}while(expectedSize <= maxGlyphSize);

 		glyphCode = 1;	

 		expectedSize = 0;

 		TEST(glyphSizeInByte == aGlyphStorage->GlyphCacheSize());

 		aGlyphStorage->CleanGlyphImageCache();

 		}

 	//now try to filling cache with different fonts and check that last usable font wont be removed

 	TUint maxGlyphSize = aGlyphStorage->MaxGlyphCacheSize();

 	glyphSizeInByte = GlyphImageSizeInByte(EMonochromeGlyphBitmap, size);

 	do 

 		{

 		TEST(expectedSize == aGlyphStorage->GlyphCacheSize());

 		TBool res = aGlyphStorage->GlyphImage(fontId, TChar(glyphCode), EMonochromeGlyphBitmap, buffer, size, &foregroundImg, &shadowImg, &outlineImg);

 		TESTNOERRORL(res);

 		glyphCode++;

 		expectedSize+= glyphSizeInByte; 

 		foregroundImg = VG_INVALID_HANDLE;

 		shadowImg = VG_INVALID_HANDLE;

 		outlineImg = VG_INVALID_HANDLE;

 		}while(expectedSize <= maxGlyphSize);

 	fontId += 10;

 	glyphCode = 1;

 	TBool res = aGlyphStorage->GlyphImage(fontId, TChar(glyphCode), EMonochromeGlyphBitmap, buffer, size, &foregroundImg, &shadowImg, &outlineImg);

 	TEST(glyphSizeInByte == aGlyphStorage->GlyphCacheSize());

 	TESTNOERROR(res);

 	RArray<TUint32> listFontId;

 	aGlyphStorage->FontIdInOrder(listFontId);

 	TESTL(listFontId.Count() == 1);

 	TEST(listFontId[0] == fontId);

 	listFontId.Reset();

 	CleanupStack::PopAndDestroy(buffer);

 	}

 /**

 @SYMTestCaseID

 	GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0004

 @SYMPREQ 

 	PREQ39

 @SYMREQ

 	REQ9195

 	REQ9201 

 	REQ9202 

 	REQ9222 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestCaseDesc

 	Tests filling the glyph image cache with different glyph images

 @SYMTestStatus

 	Implemented

 @SYMTestPriority

 	High

 @SYMTestActions

 	Specify glyphs which correspond to different fonts, glyph codes.

 	Request related VGImages.

 	Test the cache size is correct after each operation.

 	Get the driver's MDirectGdiDriverCacheSize interface.

 	Attempt to set the maximum size of the glyph cache to a size smaller than

 	the existing cache size.

 	Attempt to set the maximum size of the glyph cache to a size the same as

 	the existing cache size.

 @SYMTestExpectedResults

 	Obtained glyph code and cache size must be correct each time.

 	Setting the maximum glyph cache size to a smaller size than the existing cache

 	size should fail with error KErrArgument.

 	Setting the maximum glyph cache size to a size the same as the existing cache

 	size should pass.

 */

 void CTGlyphImageCache::FillCacheL(MFontGlyphImageStorage* aGlyphStorage)

 	{

 	ASSERT(aGlyphStorage);		

 	aGlyphStorage->CleanGlyphImageCache();

 	TBuf<128> testName;

 	_LIT(KTestName, "GlyphCache_FillCache"); 

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestName);

 		}

 	const TSize smallFontSize = TSize(12, 16);

 	const TSize smallFont1Size = TSize(10, 14);

 	const TSize bigFontSize = TSize(18, 24);

 	const TSize bigFont1Size = TSize(20, 26);

 	const TInt smallFontId = 10;

 	const TInt bigFontId = 20;

 	const TInt smallFont1Id = 30;

 	const TInt bigFont1Id = 40;

 	VGImage foregroundImg = VG_INVALID_HANDLE;

 	VGImage shadowImg = VG_INVALID_HANDLE;

 	VGImage outlineImg = VG_INVALID_HANDLE;

 	TUint8* buffer = (TUint8*)User::AllocL(bigFontSize.iWidth * bigFontSize.iHeight);

 	CleanupStack::PushL(buffer);

 	TESTL(aGlyphStorage->GlyphCacheSize() == 0);

 	TInt expectedCacheSize = 0;

 	TChar glyphCode = TChar(1);

 	TGlyphBitmapType glyphType = EMonochromeGlyphBitmap;

 	TBool res = aGlyphStorage->GlyphImage(smallFontId, glyphCode, glyphType, buffer, smallFontSize, &foregroundImg, &shadowImg, &outlineImg);

 	TESTNOERRORL(res);

 	expectedCacheSize = GlyphImageSizeInByte(glyphType, smallFontSize);

 	TEST(expectedCacheSize == aGlyphStorage->GlyphCacheSize());

 	//try to retrieve the same glyph

 	res = aGlyphStorage->GlyphImage(smallFontId, glyphCode, glyphType, buffer, smallFontSize, &foregroundImg, &shadowImg, &outlineImg);

 	TESTNOERRORL(res);

 	//the size should be the same

 	TEST(expectedCacheSize == aGlyphStorage->GlyphCacheSize()); 

 	//now retrieving the same glyphCode but for the different font

 	res = aGlyphStorage->GlyphImage(bigFontId, glyphCode, glyphType, buffer, bigFontSize, &foregroundImg, &shadowImg, &outlineImg);

 	TESTNOERRORL(res);

 	expectedCacheSize += GlyphImageSizeInByte(glyphType, bigFontSize);

 	TEST(expectedCacheSize == aGlyphStorage->GlyphCacheSize()); 

 	//last font but different glyphCode

 	glyphCode = TChar(2);

 	res = aGlyphStorage->GlyphImage(bigFontId, glyphCode, glyphType, buffer, bigFontSize, &foregroundImg, &shadowImg, &outlineImg);

 	TESTNOERRORL(res);

 	expectedCacheSize += GlyphImageSizeInByte(glyphType, bigFontSize);

 	TEST(expectedCacheSize == aGlyphStorage->GlyphCacheSize()); 

 	//small font and last glyphCode

 	res = aGlyphStorage->GlyphImage(smallFontId, glyphCode, glyphType, buffer, smallFontSize, &foregroundImg, &shadowImg, &outlineImg);

 	TESTNOERRORL(res);

 	expectedCacheSize += GlyphImageSizeInByte(glyphType, smallFontSize);

 	TEST(expectedCacheSize == aGlyphStorage->GlyphCacheSize()); 

 	//now change the type

 	glyphType = EAntiAliasedGlyphBitmap;

 	res = aGlyphStorage->GlyphImage(smallFont1Id, glyphCode, glyphType, buffer, smallFont1Size, &foregroundImg, &shadowImg, &outlineImg);

 	TESTNOERRORL(res);

 	expectedCacheSize += GlyphImageSizeInByte(glyphType, smallFont1Size);

 	TEST(expectedCacheSize == aGlyphStorage->GlyphCacheSize()); 

 	//try again

 	res = aGlyphStorage->GlyphImage(smallFont1Id, glyphCode, glyphType, buffer, smallFont1Size, &foregroundImg, &shadowImg, &outlineImg);

 	TESTNOERRORL(res);

 	TEST(expectedCacheSize == aGlyphStorage->GlyphCacheSize()); 

 	//now change the type again

 	glyphType = EFourColourBlendGlyphBitmap;

 	res = aGlyphStorage->GlyphImage(bigFont1Id, glyphCode, glyphType, buffer, bigFont1Size, &foregroundImg, &shadowImg, &outlineImg);

 	TESTNOERRORL(res);

 	expectedCacheSize += GlyphImageSizeInByte(glyphType, bigFont1Size);

 	TEST(expectedCacheSize == aGlyphStorage->GlyphCacheSize()); 

 	//using initial value.

 	glyphType = EMonochromeGlyphBitmap;

 	glyphCode = TChar(1);

 	res = aGlyphStorage->GlyphImage(smallFontId, glyphCode, glyphType, buffer, smallFontSize, &foregroundImg, &shadowImg, &outlineImg);

 	TESTNOERRORL(res);

 	TEST(expectedCacheSize == aGlyphStorage->GlyphCacheSize());

 	//get the driver's MDirectGdiDriverCacheSize extension interface and attempt

 	//to set the maximum cache size to be smaller than the existing cache size

 	CDirectGdiDriver* driver = CDirectGdiDriver::Static();

 	TESTL(driver != NULL);

 	MDirectGdiDriverCacheSize* driverCacheSize = NULL;

 	res = driver->GetInterface(TUid::Uid(KDirectGdiDriverCacheSizeUid), (TAny*&)driverCacheSize);

 	TESTNOERRORL(res);

 	//save the original cache size

 	TInt originalCacheSize = driverCacheSize->MaxGlyphCacheSize();

 	//setting the cache size to a size smaller than the existing cache should fail

 	res = driverCacheSize->SetMaxGlyphCacheSize(aGlyphStorage->GlyphCacheSize()-1);

 	TEST(res == KErrArgument);	

 	//setting the cache size to the same size as the existing cache should pass

 	res = driverCacheSize->SetMaxGlyphCacheSize(aGlyphStorage->GlyphCacheSize());

 	TESTNOERROR(res);

 	TEST(aGlyphStorage->GlyphCacheSize() == driverCacheSize->MaxGlyphCacheSize());

 	//reset the original driver cache size

 	res = driverCacheSize->SetMaxGlyphCacheSize(originalCacheSize);

 	TESTNOERROR(res);

 	CleanupStack::PopAndDestroy(buffer);

 	}

 /**

 @SYMTestCaseID

 	GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0005

 @SYMPREQ 

 	PREQ39

 @SYMREQ

 	REQ9195

 	REQ9201 

 	REQ9202 

 	REQ9222 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestCaseDesc

 	Tests the ordering font IDs in the glyph image cache.

 @SYMTestStatus

 	Implemented

 @SYMTestPriority

 	High

 @SYMTestActions

 	Request glyph images for different fonts.

 @SYMTestExpectedResults

 	List of glyph cache trees must be arranged in order from most used to least used.

 */

 void CTGlyphImageCache::FontListIdOrderL(MFontGlyphImageStorage* aGlyphStorage)

 	{

 	if(!aGlyphStorage)

 		return;

 	aGlyphStorage->CleanGlyphImageCache();

 	TBuf<128> testName;

 	_LIT(KTestName, "GlyphCache_FontListIdOrder"); 

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestName);

 		}

 	const TSize fontSize = TSize(12, 16);

 	TUint8* buffer = (TUint8*)User::AllocL(fontSize.iWidth * fontSize.iHeight);

 	CleanupStack::PushL(buffer);

 	TChar glyphCode = TChar(10);

 	TInt fontId = 10;

 	VGImage foregroundImg = VG_INVALID_HANDLE;

 	VGImage shadowImg = VG_INVALID_HANDLE;

 	VGImage outlineImg = VG_INVALID_HANDLE;

 	TGlyphBitmapType glyphType = EMonochromeGlyphBitmap;

 	TInt res = aGlyphStorage->GlyphImage(fontId, glyphCode, glyphType, buffer, fontSize, &foregroundImg, &shadowImg, &outlineImg);

 	TESTNOERRORL(res);

 	fontId = 20;

 	res = aGlyphStorage->GlyphImage(fontId, glyphCode, glyphType, buffer, fontSize, &foregroundImg, &shadowImg, &outlineImg);

 	TESTNOERRORL(res);

 	fontId = 30;

 	res = aGlyphStorage->GlyphImage(fontId, glyphCode, glyphType, buffer, fontSize, &foregroundImg, &shadowImg, &outlineImg);

 	TESTNOERRORL(res);

 	RArray<TUint32> fontListId;

 	res = aGlyphStorage->FontIdInOrder(fontListId);

 	if(res != KErrNone)

 		{

 		fontListId.Reset();

 		User::Leave(res);

 		}

 	TESTL(fontListId.Count() == 3);

 	TEST(fontListId[0] == 30);

 	TEST(fontListId[1] == 20);

 	TEST(fontListId[2] == 10);

 	fontListId.Reset();

 	//call entries again to reorder font id list

 	fontId = 30;

 	res = aGlyphStorage->GlyphImage(fontId, glyphCode, glyphType, buffer, fontSize, &foregroundImg, &shadowImg, &outlineImg);

 	TESTNOERRORL(res);

 	fontId = 20;

 	res = aGlyphStorage->GlyphImage(fontId, glyphCode, glyphType, buffer, fontSize, &foregroundImg, &shadowImg, &outlineImg);

 	TESTNOERRORL(res);

 	fontId = 40;

 	res = aGlyphStorage->GlyphImage(fontId, glyphCode, glyphType, buffer, fontSize, &foregroundImg, &shadowImg, &outlineImg);

 	TESTNOERRORL(res);

 	fontId = 10;

 	res = aGlyphStorage->GlyphImage(fontId, glyphCode, glyphType, buffer, fontSize, &foregroundImg, &shadowImg, &outlineImg);

 	TESTNOERRORL(res);

 	fontId = 50;

 	res = aGlyphStorage->GlyphImage(fontId, glyphCode, glyphType, buffer, fontSize, &foregroundImg, &shadowImg, &outlineImg);

 	TESTNOERRORL(res);

 	res = aGlyphStorage->FontIdInOrder(fontListId);

 	if(res != KErrNone)

 		{

 		fontListId.Reset();

 		User::Leave(res);

 		}

 	TESTL(fontListId.Count() == 5);

 	TEST(fontListId[0] == 50);

 	TEST(fontListId[1] == 10);

 	TEST(fontListId[2] == 40);

 	TEST(fontListId[3] == 20);

 	TEST(fontListId[4] == 30);

 	fontListId.Reset();

 	CleanupStack::PopAndDestroy(buffer);

 	}

 /**

 @SYMTestCaseID

 	GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0006

 @SYMPREQ 

 	PREQ39

 @SYMREQ

 	REQ9195

 	REQ9222 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestCaseDesc

 	Test the operation of the glyph image cache when sent wrong parameters.

 @SYMTestStatus

 	Implemented

 @SYMTestPriority

 	High

 @SYMTestActions

 	Test requesting of glyph images with invalid paramaters - test an invalid glyph type

 	and test requesting a glyph image with zero height and one with zero width.

 @SYMTestExpectedResults

 	The function must identify wrong arguments and return the expected error.

 */

 void CTGlyphImageCache::WrongParameterL(MFontGlyphImageStorage* aGlyphStorage)

 	{

 	_LIT(KTestName, "GlyphCache_WrongParameters"); 

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestName);

 		}

 	aGlyphStorage->CleanGlyphImageCache();

 	TChar glyphCode = TChar(10);

 	TInt fontId = 10;

 	VGImage foregroundImg = VG_INVALID_HANDLE;

 	VGImage shadowImg = VG_INVALID_HANDLE;

 	VGImage outlineImg = VG_INVALID_HANDLE;

 	TSize fontSize = TSize(10, 12);

 	TUint8* buffer = (TUint8*)User::AllocL(fontSize.iWidth * fontSize.iHeight);

 	CleanupStack::PushL(buffer);

 	TGlyphBitmapType glyphType = EDefaultGlyphBitmap; // unsupported

 	TInt res = aGlyphStorage->GlyphImage(fontId, glyphCode, glyphType, buffer, fontSize, &foregroundImg, &shadowImg, &outlineImg);

 	TEST(res == KErrNotSupported);

 	TEST(foregroundImg == VG_INVALID_HANDLE);

 	TEST(shadowImg == VG_INVALID_HANDLE);

 	TEST(outlineImg == VG_INVALID_HANDLE);

 	glyphType = EMonochromeGlyphBitmap; // supported

 	res = aGlyphStorage->GlyphImage(fontId, glyphCode, glyphType, buffer, TSize(12, 0), &foregroundImg, &shadowImg, &outlineImg);

 	TEST(res == KErrArgument);

 	res = aGlyphStorage->GlyphImage(fontId, glyphCode, glyphType, buffer, TSize(0, 12), &foregroundImg, &shadowImg, &outlineImg);

 	TEST(res == KErrArgument);

 	TEST(foregroundImg == VG_INVALID_HANDLE);

 	TEST(shadowImg == VG_INVALID_HANDLE);

 	TEST(outlineImg == VG_INVALID_HANDLE);

 	CleanupStack::PopAndDestroy(buffer);

 	}

 TInt CTGlyphImageCache::GlyphImageSizeInByte(TGlyphBitmapType aGlyphType, const TSize& aSize) const

 	{

 	TInt glyphSizeInByte = 0;	

 		//calculate the actual size of the glyph

 	switch(aGlyphType)

 		{

 	case EMonochromeGlyphBitmap:

 		glyphSizeInByte = (((aSize.iWidth + 31) / 32) << 2) * aSize.iHeight;

 		break;

 	case EAntiAliasedGlyphBitmap:

 		glyphSizeInByte = aSize.iWidth * aSize.iHeight;

 		break;

 	case EFourColourBlendGlyphBitmap:

 		glyphSizeInByte = aSize.iWidth * aSize.iHeight;

 		//we have to allocate memory for shadow and outline bitmap as well

 		glyphSizeInByte *= 3;

 		break;

 	default :

 		break;

 		}

 	return glyphSizeInByte;

 	}

 /**

 Draws the text on the screen according its direction and alignment.

 */	

 void CTGlyphImageCache::DrawText(const TDesC& aText, const TPoint& aPt, DrawTextDirection aDirection, DrawTextAdjustment aDrawAdjustment, TBool aUpdateJustification)

 	{

 	const TSize size = iGdiTarget->SizeInPixels();

 	TRect rect = size;

 	if(aDirection == EDrawTextHorizontal)

 		{

 		switch(aDrawAdjustment)

 			{

 		case EDrawFromPoint:

 			iGc->DrawText(aText, NULL, aPt);

 			break;

 		case EDrawInBox:

 			iGc->SetOrigin(aPt);

 			rect = TRect(-aPt, size);

 			iGc->DrawText(aText, NULL, rect);

 			break;

 		case EDrawRightAlignment:

 			rect.iTl = aPt;

 			rect.iBr.iX -= 30;

 			iGc->DrawText(aText, NULL, rect, 0, DirectGdi::ERight);

 			break;

 			}

 		}

 	else if ((aDirection == EDrawTextVerticalDown) || (aDirection == EDrawTextVerticalUp))

 		{

 		TBool up = (aDirection==EDrawTextVerticalUp);

 		switch(aDrawAdjustment)

 			{

 		case EDrawFromPoint:

 			iGc->DrawTextVertical(aText, NULL, aPt, up);

 			break;

 		case EDrawInBox:

 			iGc->SetOrigin(aPt);

 			rect = TRect(-aPt, size);

 			if(aUpdateJustification)

 				{

 				iGc->SetCharJustification(80, aText.Length());

 				iGc->UpdateJustificationVertical(aText, NULL, up);

 				}

 			iGc->DrawTextVertical(aText, NULL, rect, up);

 			iGc->SetOrigin(TPoint());

 			break;

 		case EDrawRightAlignment:

 			rect.iTl = aPt;

 			rect.iBr.iY -= 30;

 			iGc->DrawTextVertical(aText, NULL, rect, 0, DirectGdi::ERight);

 			break;

 			}

 		}

 	}

 /**

 Overrides of base class virtual

 @leave Gets system wide error code

 @return - TVerdict code

 */

 TVerdict CTGlyphImageCache::doTestStepPreambleL()

 	{			

 	CTDirectGdiStepBase::doTestStepPreambleL();

 	return TestStepResult();

 	}

 /** 

 Overrides of base class pure virtual

 Our implementation only gets called if the base class doTestStepPreambleL() did

 not leave. That being the case, the current test result value will be EPass.

 @leave Gets system wide error code

 @return TVerdict code

 */	

 TVerdict CTGlyphImageCache::doTestStepL()

 	{		

 	// Test for each pixel format

 	TInt maxPixelFormat =  iTargetPixelFormatArray.Count() - 1;

 	for(TInt targetPixelFormatIndex = maxPixelFormat; targetPixelFormatIndex >= 0 ; targetPixelFormatIndex--)

 		{

 		iTestParams.iTargetPixelFormat = iTargetPixelFormatArray[targetPixelFormatIndex];

 		SetTargetL(iTestParams.iTargetPixelFormat, EOneContextOneTarget, KGlyphCacheWindowSize);

 		if(maxPixelFormat == targetPixelFormatIndex)

 			{

 			iMonotypeFont = DetectMonotypeFontL();

 			if(!iMonotypeFont)

 				{

 				WARN_PRINTF1(_L("!! Due to running the test in environment without monotype fonts, some test cases will not \

 be executed! To set up environment with monotype font support, launch ityperast.cmd \

 from epoc32\\winscw\\c\\, and then follow the instruction on the screen!!"));

 				}

 			else

 				{

 				INFO_PRINTF1(_L("Monotype fonts have been detected"));

 				}	

 			}

 		RunTestsL();

 		if(targetPixelFormatIndex == 0)

 			{

 			RunOomTestsL();

 			}

 		}

 	CloseTMSGraphicsStep();

 	return TestStepResult();

 	}

 /**

 Overrides of base class pure virtual function

 Lists the tests to be run

 */

 void CTGlyphImageCache::RunTestsL()

 	{

 	MFontGlyphImageStorage* glyphStorage = NULL;

 	TBool testImageCache = (iUseDirectGdi && !iUseSwDirectGdi);

 	if(testImageCache)

 		{

 		TInt err = iGc->GetInterface(TUid::Uid(KDirectGdiGetGlyphStorageUid), (TAny*&) glyphStorage);

 		if(err != KErrNone)

 			{

 			ERR_PRINTF2(_L("Error while retrieving Glyph Storage Interface, err = %d"), err);

 			TESTNOERRORL(err);

 			}

 		User::LeaveIfNull(glyphStorage);

 		CleanupStack::PushL(TCleanupItem(CleanCache, glyphStorage));

 		glyphStorage->CleanGlyphImageCache();

 		}

 	if(testImageCache)

 		{

 		SetTestStepID(_L("GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0001"));

 		TestRetrieveEntryL(glyphStorage, EAntiAliasedGlyphBitmap);

 		RecordTestResultL();

 		glyphStorage->CleanGlyphImageCache();

 		SetTestStepID(_L("GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0001"));

 		TestRetrieveEntryL(glyphStorage, EFourColourBlendGlyphBitmap);

 		RecordTestResultL();

 		glyphStorage->CleanGlyphImageCache();

 		SetTestStepID(_L("GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0001"));

 		TestRetrieveEntryL(glyphStorage, EMonochromeGlyphBitmap);

 		RecordTestResultL();

 		SetTestStepID(_L("GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0006"));

 		WrongParameterL(glyphStorage);

 		RecordTestResultL();

 		SetTestStepID(_L("GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0005"));

 		FontListIdOrderL(glyphStorage);

 		RecordTestResultL();

 		glyphStorage->CleanGlyphImageCache();

 		}

 	if(!iRunningOomTests)//fonts are cached in the array, where memory won't be freed even if the font is released

 		{

 		if(testImageCache)

 			{

 			SetTestStepID(_L("GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0004"));

 			FillCacheL(glyphStorage);

 			RecordTestResultL();

 			SetTestStepID(_L("GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0003"));

 			FillUpCacheL(glyphStorage);

 			RecordTestResultL();

 			glyphStorage->CleanGlyphImageCache();

 			}

 		for(TInt ii = EDrawTextHorizontal; ii < EDrawTextLast; ii++)

 			{

 			for(TInt kk = EDrawFromPoint; kk <= EDrawInBox; kk++)

 				{

 				DrawTextDirection direction = (DrawTextDirection) ii;

 				DrawTextAdjustment adjustment = (DrawTextAdjustment) kk;

 				SetTestStepID(_L("GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0002"));

 				TestDrawGlyphL(glyphStorage, EMonochromeGlyphBitmap, direction, adjustment, EFalse);

 				RecordTestResultL();

 				SetTestStepID(_L("GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0002"));

 				TestDrawGlyphL(glyphStorage, EMonochromeGlyphBitmap, direction, adjustment, ETrue);

 				RecordTestResultL();

 				SetTestStepID(_L("GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0002"));

 				TestDrawGlyphL(glyphStorage, EAntiAliasedGlyphBitmap, direction, adjustment, EFalse);

 				RecordTestResultL();

 				SetTestStepID(_L("GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0002"));

 				TestDrawGlyphL(glyphStorage, EAntiAliasedGlyphBitmap, direction, adjustment, ETrue);

 				RecordTestResultL();

 				if(iMonotypeFont)

 					{

 					SetTestStepID(_L("GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0002"));

 					TestDrawGlyphL(glyphStorage, EFourColourBlendGlyphBitmap, direction, adjustment, EFalse);

 					RecordTestResultL();

 					SetTestStepID(_L("GRAPHICS-DIRECTGDI-GLYPHIMAGECACHE-0002"));

 					TestDrawGlyphL(glyphStorage, EFourColourBlendGlyphBitmap, direction, adjustment, ETrue);

 					RecordTestResultL();

 					}

 				}

 			}

 		}

 	//next set of tests should start from clean cache to garantee consistent results

 	if(testImageCache)

 		{

 		glyphStorage->CleanGlyphImageCache();

 		CleanupStack::Pop(glyphStorage);

 		}

 	}

 /**

 See if monotype font is installed on the platform we are running on. Monotype font is required

 to run the glyph tests that use the glyph bitmap type EFourColourBlendGlyphBitmap to draw

 outlined and shadowed fonts.

 @return ETrue if monotype is installed, EFalse if it is not installed.

  */

 TBool CTGlyphImageCache::DetectMonotypeFontL()

 	{

 	CFont *font = NULL;

 	_LIT(KTestFontTypefaceName,"DejaVu Sans Condensed");

 	TFontSpec fspec(KTestFontTypefaceName, 12);

 	fspec.iFontStyle.SetBitmapType(EFourColourBlendGlyphBitmap);

 	fspec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

 	fspec.iFontStyle.SetEffects(FontEffect::EOutline, ETrue);

 	fspec.iFontStyle.SetEffects(FontEffect::EDropShadow, ETrue);

 	User::LeaveIfError(iFontStore->GetNearestFontToDesignHeightInPixels((CFont*&) font, fspec));

 	TFontSpec fontSpec = font->FontSpecInTwips();

 	TGlyphBitmapType glyphBitmapType = fontSpec.iFontStyle.BitmapType();

 	iFontStore->ReleaseFont(font);

 	return (EFourColourBlendGlyphBitmap==glyphBitmapType);

 	}