// 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:

//

#include "tvgimagecache.h"

#include <graphics/directgdiengine.h>

_LIT(KRomBitmap, "z:\\system\\data\\dgdi32bit.mbm");

CTVgImageCache::CTVgImageCache()

	{

	SetTestStepName(KTDirectGdiVgImageCacheStep);

	}

CTVgImageCache::~CTVgImageCache()

	{	

	}

/**

@SYMTestCaseID

	GRAPHICS-DIRECTGDI-VGIMAGECACHE-0001

@SYMPREQ 

	PREQ39

@SYMREQ

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc

	Test entries are added to the cache.

@SYMTestStatus

	Implemented

@SYMTestPriority

	High

@SYMTestActions

	1.	Create bitmaps and bitmap masks.  Blit them so that they are stored in the cache.

		Check the VGImages created from the bitmaps are stored in the cache.

	2.	Blit the bitmaps again in a different order.

		Check the order that the bitmaps are stored in the cache.

@SYMTestExpectedResults

	1.	There are entries for each bitmap and bitmap mask.

	2.	The bitmaps are stored in the cache in order of most-recently used to least-recently used.

 */

void CTVgImageCache::TestAddEntriesL()

	{	

	_LIT(KTestName, "Test Bitmaps Are Added To Cache"); 

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(KTestName);

		}

	CFbsBitmap* romBitmap = new(ELeave) CFbsBitmap;

	TInt err = romBitmap->Load(KRomBitmap);

	TESTNOERRORL(err);

	CleanupStack::PushL(romBitmap);

	TSize bitmapSize(48,48);

	TRect bitmapRect(TPoint(0,0), bitmapSize);

	CFbsBitmap* bitmap1 = CreateCheckedBoardBitmapL(iTestParams.iSourcePixelFormat,  bitmapSize, TSize (20, 20));

	TESTL(bitmap1 != NULL);

	CleanupStack::PushL(bitmap1);

	CFbsBitmap* bitmap2 = CreateCheckedBoardBitmapL(iTestParams.iSourcePixelFormat, bitmapSize, TSize (10, 10));

	TESTL(bitmap2 != NULL);

	CleanupStack::PushL(bitmap2);

	CFbsBitmap* bitmap3 = CreateCheckedBoardBitmapL(iTestParams.iSourcePixelFormat, bitmapSize, TSize (8, 8));

	TESTL(bitmap3 != NULL);

	CleanupStack::PushL(bitmap3);

	CFbsBitmap* mask1 = CreateCheckedBoardBitmapL(iTestParams.iSourcePixelFormat, bitmapSize, TSize (4, 4));

	TESTL(mask1 != NULL);

	CleanupStack::PushL(mask1);

	CFbsBitmap* mask2 = CreateCheckedBoardBitmapL(iTestParams.iSourcePixelFormat, bitmapSize, TSize (2, 2));

	TESTL(mask2 != NULL);

	CleanupStack::PushL(mask2);

	ResetGc();

	CleanupStack::PushL(TCleanupItem(ResetCache, iVgImageCache));

	iGc->BitBlt(TPoint(0,0), *romBitmap);		

	iGc->DrawBitmap(bitmapRect, *bitmap1);

	iGc->BitBltMasked(TPoint(0,0), *bitmap2, bitmapRect, *mask1, EFalse);

	iGc->DrawBitmapMasked(bitmapRect, *bitmap3, bitmapRect, *mask2, EFalse);

	// Check bitmaps added

	TInt numEntries = iVgImageCache->NumEntries();

	TEST(numEntries == 6);

	// The following tests must leave if they fail,

	// otherwise a panic will occur in the ordered cache entry test

	TESTL(iVgImageCache->IsInCache(romBitmap->SerialNumber()));

	TESTL(iVgImageCache->IsInCache(bitmap1->SerialNumber()));

	TESTL(iVgImageCache->IsInCache(bitmap2->SerialNumber()));

	TESTL(iVgImageCache->IsInCache(bitmap3->SerialNumber()));

	TESTL(iVgImageCache->IsInCache(mask1->SerialNumber()));

	TESTL(iVgImageCache->IsInCache(mask2->SerialNumber()));

	//Blit a few more times and check order of items in cache

	iGc->BitBlt(TPoint(0,0), *bitmap3);

	iGc->BitBlt(TPoint(0,0), *bitmap1);

	iGc->BitBlt(TPoint(0,0), *romBitmap);

	iGc->BitBlt(TPoint(0,0), *mask2);

	iGc->BitBlt(TPoint(0,0), *bitmap2);

	// Expect the most recently used to be at the head of the list

	// i.e. bitmap2, mask2, romBitmap, bitmap1, bitmap3, mask1

	TInt64* serialNumList = new TInt64[numEntries];

	TESTL(serialNumList != NULL);

	iVgImageCache->GetOrderedCacheEntries(*serialNumList,numEntries);

	TEST(serialNumList[0] == bitmap2->SerialNumber());

	TEST(serialNumList[1] == mask2->SerialNumber());

	TEST(serialNumList[2] == romBitmap->SerialNumber());

	TEST(serialNumList[3] == bitmap1->SerialNumber());

	TEST(serialNumList[4] == bitmap3->SerialNumber());

	TEST(serialNumList[5] == mask1->SerialNumber());

	delete[] serialNumList;

	CleanupStack::PopAndDestroy(7, romBitmap);

	}

/**

@SYMTestCaseID

	GRAPHICS-DIRECTGDI-VGIMAGECACHE-0002

@SYMPREQ 

	PREQ39

@SYMREQ

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc

	Test entries are added to the cache.

@SYMTestStatus

	Implemented

@SYMTestPriority

	High

@SYMTestActions

	Create a bitmap.  Blit it so that it is stored in the cache.

	Check there is an entry for that bitmap in the cache.

	Resize the bitmap (so that the bitmap's touch count is increased).

	Blit the bitmap again.

	Check the value of the touch count stored in the cache.

@SYMTestExpectedResults

	Entry exists for bitmap and touch count value stored in cache

	is same as the bitmap after it was resized.

 */

void CTVgImageCache::TestBitmapResizedL()

	{	

	_LIT(KTestName, "Test That Images In Cache Are Updated When Associated Bitmap Is Resized"); 

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(KTestName);

		}

	TSize bitmapSize(48,48);

	CFbsBitmap* bitmap = CreateCheckedBoardBitmapL(iTestParams.iSourcePixelFormat,  bitmapSize, TSize (8, 8));

	TESTL(bitmap != NULL);

	ResetGc();

	iGc->BitBlt(TPoint(0,0), *bitmap);

	TInt64 serialNumber = bitmap->SerialNumber();

	// Check bitmaps added

	TEST(iVgImageCache->IsInCache(serialNumber));

	TInt oldTouchCount = iVgImageCache->TouchCount(serialNumber);

	TEST(oldTouchCount == bitmap->TouchCount());

	//Resize bitmap

	TESTNOERROR(bitmap->Resize(TSize(80,24)));

	iGc->BitBlt(TPoint(0,0), *bitmap);

	TEST(iVgImageCache->TouchCount(serialNumber) != oldTouchCount);

	TEST(iVgImageCache->TouchCount(serialNumber) == bitmap->TouchCount());

	delete bitmap;

	iVgImageCache->ResetCache();

	}

/**

@SYMTestCaseID

	GRAPHICS-DIRECTGDI-VGIMAGECACHE-0003

@SYMPREQ 

	PREQ39

@SYMREQ

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc

	Test entries are added to the cache.

@SYMTestStatus

	Implemented

@SYMTestPriority

	High

@SYMTestActions

	Create a bitmap.  Blit it so that it is stored in the cache.

	Check there is an entry for that bitmap in the cache.

	Swap the width and height of the bitmap (so that the bitmap's touch count is increased).

	Blit the bitmap again.

	Check the value of the touch count stored in the cache.

@SYMTestExpectedResults

	Entry exists for bitmap and touch count value stored in cache

	is same as the bitmap after its width and height were swapped.

 */

void CTVgImageCache::TestBitmapSwapWidthAndHeightL()

	{	

	_LIT(KTestName, "Test That Images In Cache Are Updated When Associated Bitmap Swaps Height and Width"); 

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(KTestName);

		}

	TSize bitmapSize(40,60);

	CFbsBitmap* bitmap = CreateCheckedBoardBitmapL(iTestParams.iSourcePixelFormat,  bitmapSize, TSize (8, 8));

	TESTL(bitmap != NULL);

	ResetGc();

	iVgImageCache->ResetCache();

	iGc->BitBlt(TPoint(0,0), *bitmap);

	// Check bitmap is added to cache

	TEST(iVgImageCache->IsInCache(bitmap->SerialNumber()));

	TInt oldTouchCount = bitmap->TouchCount();

	TEST(oldTouchCount == iVgImageCache->TouchCount(bitmap->SerialNumber()));

	// Swap width & height of bitmap within a Begin/End bounds

	// so that touch count increases

	TESTNOERROR(bitmap->SwapWidthAndHeight());

	TInt newTouchCount = bitmap->TouchCount();

	iGc->BitBlt(TPoint(0,0), *bitmap);

	// Check touch count is now different

	TEST(newTouchCount != oldTouchCount);

	// Expect cache to update entry for bitmap

	TEST(iVgImageCache->TouchCount(bitmap->SerialNumber()) == newTouchCount);

	delete bitmap;

	iVgImageCache->ResetCache();

	}

/**

@SYMTestCaseID

	GRAPHICS-DIRECTGDI-VGIMAGECACHE-0004

@SYMPREQ 

	PREQ39

@SYMREQ

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc

	Test entries are not added to the cache for volatile bitmaps.

@SYMTestStatus

	Implemented

@SYMTestPriority

	High

@SYMTestActions

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

	code and font ID. 

	Delete Glyph Storage.

@SYMTestExpectedResults

	No entry exists for the bitmap in the cache.

 */

void CTVgImageCache::TestVolatileBitmapL()

	{	

	_LIT(KTestName, "Test That Volatile Bitmaps Are not Stored In Cache"); 

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(KTestName);

		}

	TSize bitmapSize(40,60);

	CFbsBitmap* bitmap = CreateCheckedBoardBitmapL(iTestParams.iSourcePixelFormat,  bitmapSize, TSize (8, 8));

	TESTL(bitmap != NULL);

	ResetGc();

	iVgImageCache->ResetCache();

	// Make bitmap volatile

	bitmap->DataAddress();

	iGc->BitBlt(TPoint(0,0), *bitmap);

	// Check bitmap is added to cache

	TEST(!iVgImageCache->IsInCache(bitmap->SerialNumber()));

	delete bitmap;

	iVgImageCache->ResetCache();

	}

/**

@SYMTestCaseID

	GRAPHICS-DIRECTGDI-VGIMAGECACHE-0005

@SYMPREQ 

	PREQ39

@SYMREQ

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc

	Test least recently used entries are deleted  when the cache is full and a new entry is added to the cache.

@SYMTestStatus

	Implemented

@SYMTestPriority

	High

@SYMTestActions

	Fill the cache up (by blitting many different bitmaps).

	Blit one more bitmap so that the cache has to delete an entry.

	Get the driver's MDirectGdiDriverCacheSize extension interface.

	Check that a new maximum cache size cannot be set that is smaller

	than the existing cache size.

@SYMTestExpectedResults

	An entry was deleted and that entry was the least recently used.

	A cache size cannot be set that is smaller than the existing cache size.

 */

void CTVgImageCache::TestFullCacheL()

	{	

	_LIT(KTestName, "Test Adding Image to Cache when Cache is Full"); 

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(KTestName);

		}

	ResetGc();

	iVgImageCache->ResetCache();

	CleanupStack::PushL(TCleanupItem(ResetCache, iVgImageCache));

	TInt maxCacheSize = iVgImageCache->MaxCacheSize();

	TSize bitmapSize(200,200);

	TInt dataStride = CFbsBitmap::ScanLineLength(bitmapSize.iWidth, TDisplayModeMapping::MapPixelFormatToDisplayMode(iTestParams.iSourcePixelFormat));

	TInt imageSizeInBytes = bitmapSize.iHeight * dataStride;

	TSize checksPerAxis(1,1);

	// Create the first bitmap to be added to the cache.

	// This is also be the bitmap to be removed from the cache when full.

	CFbsBitmap* firstBitmap = CreateCheckedBoardBitmapL(iTestParams.iSourcePixelFormat,  bitmapSize, checksPerAxis);

	TESTL(firstBitmap != NULL);

	CleanupStack::PushL(firstBitmap);

	iGc->BitBlt(TPoint(0,0), *firstBitmap);

	TEST(iVgImageCache->IsInCache(firstBitmap->SerialNumber()));

	// Fill the cache up.

	while(imageSizeInBytes + iVgImageCache->CacheSizeInBytes() < maxCacheSize)

		{

		CFbsBitmap* bitmap = CreateCheckedBoardBitmapL(iTestParams.iSourcePixelFormat,  bitmapSize, checksPerAxis);

		TESTL(bitmap != NULL);

		iGc->BitBlt(TPoint(0,0), *bitmap);

		delete bitmap;

		}

	// Add one more entry to the cache

	CFbsBitmap* bitmap = CreateCheckedBoardBitmapL(iTestParams.iSourcePixelFormat,  bitmapSize, checksPerAxis);

	TESTL(bitmap != NULL);

	TEST(!iVgImageCache->IsInCache(bitmap->SerialNumber()));

	TEST(iVgImageCache->IsInCache(firstBitmap->SerialNumber()));

	iGc->BitBlt(TPoint(0,0), *bitmap);

	// firstBitmap should now have been removed from the cache as it was the least recently used.

	TEST(!iVgImageCache->IsInCache(firstBitmap->SerialNumber()));

	// last bitmap should be in cache

	TEST(iVgImageCache->IsInCache(bitmap->SerialNumber()));

	// 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;

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

	TESTNOERRORL(res);

	// save the original cache size

	TInt originalCacheSize = driverCacheSize->MaxImageCacheSize();

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

	res = driverCacheSize->SetMaxImageCacheSize(iVgImageCache->CacheSizeInBytes()-1);

	TEST(res == KErrArgument);	

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

	res = driverCacheSize->SetMaxImageCacheSize(iVgImageCache->CacheSizeInBytes());

	TESTNOERROR(res);

	TEST(iVgImageCache->CacheSizeInBytes() == driverCacheSize->MaxImageCacheSize());

	// reset the original driver cache size

	res = driverCacheSize->SetMaxImageCacheSize(originalCacheSize);

	TESTNOERROR(res);

	delete bitmap;

	CleanupStack::PopAndDestroy(firstBitmap);

	CleanupStack::PopAndDestroy(iVgImageCache);

	}

/**

@SYMTestCaseID

	GRAPHICS-DIRECTGDI-VGIMAGECACHE-0006

@SYMPREQ 

	PREQ39

@SYMREQ

	REQ9195

	REQ9201 

	REQ9202 

	REQ9222 

	REQ9223 

	REQ9236 

	REQ9237

@SYMTestCaseDesc

	Test adding a bitmap larger than maximum size of cache.

@SYMTestStatus

	Implemented

@SYMTestPriority

	High

@SYMTestActions.

	Blit a small bitmap which is added to the cache.

	Blit a bitmap whose size in pixels is more than the maximum size of the cache.

@SYMTestExpectedResults

	An entry for the large bitmap should not appear in the cache.

	An entry for the small bitmap should appear in the cache.

 */

void CTVgImageCache::TestImageLargerThanCacheL()

	{	

	_LIT(KTestName, "Test Adding Image Larger Than Cache"); 

	if(!iRunningOomTests)

		{

		INFO_PRINTF1(KTestName);

		}

	ResetGc();

	iVgImageCache->ResetCache();

	TInt maxCacheSize = iVgImageCache->MaxCacheSize();

	// Calculate height of bitmap whose width is 512 pixels so that the total size in bytes of the bitmap

	// is the same as the maximum cache size.

	TInt dataStride = CFbsBitmap::ScanLineLength(512, TDisplayModeMapping::MapPixelFormatToDisplayMode(iTestParams.iSourcePixelFormat));

	TInt largeBitmapHeight = maxCacheSize / dataStride;

	// Want bitmap with a larger size in bytes than cache,

	// so create a bitmap with width of 550 pixels and largeBitmapHeight

	TSize largeBitmapSize(550,largeBitmapHeight);

	TSize smallBitmapSize(200,200);

	TSize checksPerAxis(1,1);

	// Create a small bitmap to be added to the cache.

	CFbsBitmap* smallBitmap = CreateCheckedBoardBitmapL(iTestParams.iSourcePixelFormat,  smallBitmapSize, checksPerAxis);

	TESTL(smallBitmap != NULL);

	CleanupStack::PushL(smallBitmap);

	// Create large bitmap which is too large to fit in cache

	CFbsBitmap* largeBitmap = CreateCheckedBoardBitmapL(iTestParams.iSourcePixelFormat,  largeBitmapSize, checksPerAxis);

	TESTL(largeBitmap != NULL);

	// Add small bitmap to cache

	iGc->BitBlt(TPoint(0,0), *smallBitmap);

	TEST(iVgImageCache->IsInCache(smallBitmap->SerialNumber()));

	// Blit large bitmap

	iGc->BitBlt(TPoint(0,0), *largeBitmap);

	TEST(!iVgImageCache->IsInCache(largeBitmap->SerialNumber()));

	TEST(iVgImageCache->IsInCache(smallBitmap->SerialNumber()));

	delete largeBitmap;

	CleanupStack::PopAndDestroy(smallBitmap);

	iVgImageCache->ResetCache();

	}

/**

Override of base class virtual

@leave Gets system wide error code

@return - TVerdict code

*/

TVerdict CTVgImageCache::doTestStepPreambleL()

	{			

	CTDirectGdiStepBase::doTestStepPreambleL();

	return TestStepResult();

	}

/** 

Override 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 CTVgImageCache::doTestStepL()

	{

	if (iUseDirectGdi)

		{

		// Test independent of target pixel formats, so just use first.

		iTestParams.iTargetPixelFormat = iTargetPixelFormatArray[0];

		// Test needs a VG compatible source pixel format.

		iTestParams.iSourcePixelFormat = EUidPixelFormatRGB_565;

		SetTargetL(iTestParams.iTargetPixelFormat);

		if (!iUseSwDirectGdi)

			{

			RunTestsL();

			RunOomTestsL();

			}

		else

			{

			INFO_PRINTF1(_L("SW DirectGDI has no image cache to test!"));

			}

		}

	else

		{

		INFO_PRINTF1(_L("BitGDI has no image cache to test!"));

		}

	return TestStepResult();

	}

/**

Override of base class pure virtual

Lists the tests to be run

*/

void CTVgImageCache::RunTestsL()

	{

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

	TestAddEntriesL();

	RecordTestResultL();

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

	TestFullCacheL();

	RecordTestResultL();

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

	TestImageLargerThanCacheL();

	RecordTestResultL();

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

	TestBitmapResizedL();

	RecordTestResultL();

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

	TestBitmapSwapWidthAndHeightL();

	RecordTestResultL();

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

	TestVolatileBitmapL();

	RecordTestResultL();

	}