// Copyright (c) 2002-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 <bitdev.h>

 #include <e32math.h>

 #include "tcompressed.h"

 CTCompressed::CTCompressed(CTestStep* aStep) :

 	CTGraphicsBase(aStep)

 	{

 	}

 void CTCompressed::BlankBitmap(CFbsBitmapEx& aBitmap)

 	{

 	TSize size = aBitmap.SizeInPixels();

 	TInt dataLength = CFbsBitmap::ScanLineLength(size.iWidth,aBitmap.DisplayMode()) * size.iHeight;

 	aBitmap.LockHeap();

 	Mem::FillZ((TUint8*)aBitmap.DataAddress(),dataLength);

 	aBitmap.UnlockHeap();

 	}

 void CTCompressed::RunTestCaseL(TInt aCurTestCase)

     {

     ((CTCompressedStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

 	switch(aCurTestCase)

 		{

 	case 1:

 		((CTCompressedStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0571"));

 		TRAPD(err, RunTestL());

 		TEST(err == KErrNone);

 		break;	

 	case 2:

 		((CTCompressedStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0572"));

 		TRAP(err, DefectFix_EXT5DXGK6_L());

 		TEST(err == KErrNone);

 		break;	

 	case 3:

 		{

 		((CTCompressedStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0500"));

 		// Set size of bitmap large enough to warrant compression

 		const TSize KBitmapSize(200,200);

 		INFO_PRINTF1(_L("Test case for INC082713\r\n"));

 		TRAP(err, DefectFix_INC082713_L(EColor16MU, KBitmapSize));

 		TEST(err == KErrNone);		

 		TRAP(err, DefectFix_INC082713_L(EColor16MA, KBitmapSize));

 		TEST(err == KErrNone);

 		}

 		break;

 	case 4:

 		((CTCompressedStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0573"));

 		TRAPD(err1, INC088856_TestL());

 		TEST(err1 == KErrNone);

 		break;

  	case 5:

  		((CTCompressedStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0615"));

 		TestDestroyBitmapWhileBeingBackgroundCompressedL();

 		break;

 	case 6:

 		((CTCompressedStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0616"));

 		TestBackgroundCompressionThreadPriorityInheritanceL();

 		break;

 	case 7:

 		((CTCompressedStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

 		((CTCompressedStep*)iStep)->CloseTMSGraphicsStep();

 		TestComplete();

 		break;	

 		}

 	((CTCompressedStep*)iStep)->RecordTestResultL();

     }

 /**

 	@SYMTestCaseID

 	GRAPHICS-FBSERV-0571

 	@SYMTestCaseDesc

 	Tests compression of bitmaps in RAM and ROM.

 	@SYMTestActions

 	Four bitmaps are loaded. One compressed and one

 	uncompressed from ROM and from RAM. The bitmap

 	in RAM is tested if it can be compressed successfully.

 	The bitmap in ROM should fail when tried to be compressed.

 	All of the bitmaps are then tried to be BitBlt.	

 	@SYMTestExpectedResults

 	Test should pass

 */

 void CTCompressed::RunTestL()

     {

     TInt skipRomBitmapTests = EFalse;

 	TUint32* romAddress = NULL;

 	if(!CFbsBitmap::IsFileInRom(KRomNotCompressed, romAddress)) //any ROM bitmap

 		{

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

 				&KRomNotCompressed);

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

 		skipRomBitmapTests = ETrue;

 		}

 	TBuf<64> romNotCompressed(KRomNotCompressed);

 	TBuf<64> romCompressed(KRomCompressed);

 	TBuf<64> fileNotCompressed(KFileNotCompressed);

 	TBuf<64> fileCompressed(KFileCompressed);

 	TInt ret = KErrNone;

 	CFbsBitmap rom;

 	CFbsBitmap romcomp;

 	if(!skipRomBitmapTests)

 		{

 		TEST(rom.Load(romNotCompressed, 0, EFalse)== KErrNone);

 		TEST(romcomp.Load(romCompressed, 0, EFalse)== KErrNone);

 		INFO_PRINTF1(_L("Check compressing of ROM bitmaps causes error.\r\n"));

 		ret = rom.Compress();

 		TEST(ret == KErrAccessDenied); //cannot compress bitmaps in ROM

 		TEST(rom.IsCompressedInRAM());

 		}

 	CFbsBitmap file;

 	CFbsBitmap filecomp;

 	TEST(file.Load(fileNotCompressed, 0, EFalse)== KErrNone);

 	TEST(filecomp.Load(fileCompressed, 0, EFalse)== KErrNone);

 	INFO_PRINTF1(_L("Check compressing of RAM files is OK.\r\n"));

 	CFbsBitmap ram;

 	ret=ram.Load(fileNotCompressed,0,EFalse);

 	TEST(ret == KErrNone);

 	ret = ram.Compress();

 	TEST(ret == KErrNone); //can compress bitmaps in RAM

 	TEST(ram.IsCompressedInRAM());

 	INFO_PRINTF1(_L("Check compressing a created EColor256 bitmap.\r\n"));

 	CFbsBitmapEx created;

 	ret=created.Create(TSize(200,200),EColor256);

 	TEST(ret==KErrNone);

 	// This makes sure we can compress it...

 	BlankBitmap(created);

 	ret = created.Compress();

 	TEST(ret==KErrNone);

 	TEST(created.IsCompressedInRAM());

 	INFO_PRINTF1(_L("Check compressing a created EColor24MU bitmap.\r\n"));

 	CFbsBitmapEx created24MU;

 	ret=created24MU.Create(TSize(200,200),EColor16MU);

 	TEST(ret==KErrNone);

 	// This makes sure we can compress it...

 	BlankBitmap(created24MU);

 	ret = created24MU.Compress();

 	TEST(ret==KErrNone);

 	TEST(created24MU.IsCompressedInRAM());

 	INFO_PRINTF1(_L("Try bitblt on all bitmaps"));

 	for (TInt mode = EGray2; mode < EColorLast; mode++)

 		{

 		if(!skipRomBitmapTests)

 			{

 			INFO_PRINTF2(_L("BitBlt rom with %d display mode.\r\n"), mode);

 			TestBitBltL(rom,      TDisplayMode(mode));

 			INFO_PRINTF2(_L("BitBlt romcomp with %d display mode.\r\n"), mode);

 			TestBitBltL(romcomp,  TDisplayMode(mode));

 			}

 		INFO_PRINTF2(_L("BitBlt file with %d display mode.\r\n"), mode);

 		TestBitBltL(file,     TDisplayMode(mode));

 		INFO_PRINTF2(_L("BitBlt filecomp with %d display mode.\r\n"), mode);

 		TestBitBltL(filecomp, TDisplayMode(mode));

 		INFO_PRINTF2(_L("BitBlt ram with %d display mode.\r\n"), mode);

 		TestBitBltL(ram,      TDisplayMode(mode));

 		INFO_PRINTF2(_L("BitBlt created with %d display mode.\r\n"), mode);

 		TestBitBltL(created,  TDisplayMode(mode));

 		INFO_PRINTF2(_L("BitBlt 24MU created bitmap with %d display mode.\r\n"), mode);

 		TestBitBltL(created24MU,  TDisplayMode(mode));

 		}

 	}

 /**

 	@SYMTestCaseID

 	GRAPHICS-FBSERV-0572

 	@SYMTestCaseDesc

 	Testcode to check for fix to defect EXT-5DXGK6 Bitmap 

 	compression causes crash when loading skins.

 	Its not a conclusive test as it depends on where the 

 	bitmap is loaded into memory and if there is 

 	memory allocated at the end of the bitmap.

 	@SYMTestActions

 	@SYMTestExpectedResults

 	Test should pass

 */

 void CTCompressed::DefectFix_EXT5DXGK6_L()

 	{

 	CFbsBitmapEx bmp1;

 	TSize size(1000,1);

 	TInt ret=bmp1.Create(size,EGray2);

 	TEST(ret==KErrNone);

 	BlankBitmap(bmp1);

 //

 	// calculate the size of the destination scan line in bytes

 	// + 31 to pad to 4 byte boundary; 8 bits in a byte

 	TInt source_buffer_size = (size.iWidth + 31) / 8 ;

 	TUint8* buffer = new(ELeave) TUint8[source_buffer_size];

 	TPtr8 source_ptr(buffer,source_buffer_size,source_buffer_size);

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

 		{

 		if(ii%2)

 			source_ptr[ii] = 2;

 		else

 			source_ptr[ii] = 3;

 		}

 	source_ptr[source_buffer_size-1] = 5;

 	source_ptr[source_buffer_size-2] = 5;

 	source_ptr[source_buffer_size-3] = 5;

 	source_ptr[source_buffer_size-4] = 4;

 	bmp1.SetScanLine(source_ptr,0);

 	delete [] buffer;

 	bmp1.Compress();

 	}

 /**

  * @SYMTestCaseID GRAPHICS-FBSERV-0500

  *

  * @SYMDEF INC082713

  *

  * @SYMTestCaseDesc Test RLE compression algorithm of EColor16MU and EColor16MA bitmaps.

  *

  * @SYMTestPriority Critical

  *

  * @SYMTestStatus Implemented

  *

  * @SYMTestActions The following test checks a corner-case of the algorithm triggered by a specific pixel pattern.

  *

  * The corner case is triggered when the input to the compression function ends in a run of equal pixels, 

  * terminated by a single pixel that is different i.e. ...rrrrrrrrrrrrrrrg 

  * where we have a run of equal (red) pixels followed by a green pixel, which is the last pixel in the 

  * bitmap (or the scanline, depending on how the data is being compressed).

  *

  * This test case performs the following:

  * 1) Creates a bitmap in the display mode and of size specified in function args.

  * This size must be large enough to trigger the compression when requested.

  * 2) Creates a scanline the width of this bitmap, which is a run of equal pixels, and 

  * then sets the last pixel to be different.

  * 3) Sets the last scanline of the bitmap to the scanline we have just created. 

  * This means that the last scanline of the bitmap conforms to the corner-case pattern.

  * 4) Compresses the bitmap

  * 5) Checks the compression has been successful

  * 6) Retrieves the last scanline of the bitmap and compares it with the original one

  * to verify that the compression of data has been successful.

  *

  * @SYMTestExpectedResults

  * The compression should occur successfully without panicking.

  * The scanline retrieved from the compressed version of the bitmap should match

  * the original scanline created.

  */

 void CTCompressed::DefectFix_INC082713_L(const TDisplayMode aDispMode, const TSize aBitmapSize)

 	{

 	// *** This function assumes that pixels are stored as 32 bit words ***

 	// *** for EColor16MU and EColor16MA bitmaps                        ***

 	switch(aDispMode)

 		{

 	case EColor16MU:

 		INFO_PRINTF1(_L("Check compression algorithm corner case for EColor16MU bitmap.\r\n"));

 		break;

 	case EColor16MA:

 		INFO_PRINTF1(_L("Check compression algorithm corner case for EColor16MA bitmap.\r\n"));

 		break;

 	default:

 		INFO_PRINTF1(_L("Unsupported display mode for test"));

 		return;

 		}

 	CFbsBitmap bitmap;

 	TInt ret=bitmap.Create(aBitmapSize,aDispMode);

 	TEST(ret==KErrNone);

 	TInt widthInPixels = bitmap.SizeInPixels().iWidth;

 	TInt heightInPixels = bitmap.SizeInPixels().iHeight;

 	TInt scanLineByteLength = bitmap.ScanLineLength(widthInPixels, aDispMode);

 	TUint32* buffer = (TUint32*)User::AllocLC(scanLineByteLength);

 	// Breaking from a run of equal pixels

 	// i.e. rrrrrrr...rrrrrrrrg

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

 		{

 		buffer[ii] = 0xc6ebff;

 		}

 	// Last pixel differs - must be able to re-enter loop when at last pixel

 	buffer[widthInPixels - 1] = 0xcee7ff;

 	TPtr8 scanline((TUint8*)buffer ,scanLineByteLength,scanLineByteLength);

 	bitmap.SetScanLine(scanline, heightInPixels - 1);

 	INFO_PRINTF1(_L("Compressing bitmap"));

 	ret = bitmap.Compress();

 	TEST(ret==KErrNone);

 	TEST(bitmap.IsCompressedInRAM());

 	// Retrieve the scanline from the compressed bitmap and compare with original

 	// in order to test whether the scanline is correctly compressed

 	INFO_PRINTF1(_L("Retrieving scanline from compressed bitmap"));

 	TUint32* readbackbuffer = (TUint32*)User::AllocLC(scanLineByteLength);

 	TPtr8 readbackscanline((TUint8*)readbackbuffer ,scanLineByteLength,scanLineByteLength);

 	readbackscanline.Fill(0xff);

 	bitmap.GetScanLine(readbackscanline,TPoint(0,heightInPixels - 1),widthInPixels, aDispMode);

 	INFO_PRINTF1(_L("Comparing scanlines\r\n"));

 	// Compare the original scanline with the one retrieved from the compressed version

 	switch(aDispMode)

 		{

 	case EColor16MU:

 		{		

 		TBool result = ETrue;

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

 			{

 			// Must mask off top bits (as we can ignore them, since we have no alpha channel)

 			TUint32 original = buffer[ii] & 0x00ffffff;

 			TUint32 readback = readbackbuffer[ii] & 0x00ffffff;

 			result = result && (original == readback);

 			}

 		TEST(result);

 		}

 		break;

 	case EColor16MA:

 		ret = Mem::Compare((TUint8*)buffer, scanLineByteLength, (TUint8*)readbackbuffer, scanLineByteLength);

 		// Mem::Compare returns 0 if the two scanlines are equal

 		TEST(ret == 0);

 		break;

 	default:

 		INFO_PRINTF1(_L("Unsupported display mode for test"));

 		break;

 		}

 	CleanupStack::PopAndDestroy(2, buffer);

 	}

 void CTCompressed::TestBitBltL(CFbsBitmap& aBmp, TDisplayMode aDispMode)

 	{

 	CFbsScreenDevice* scd = 0;

 	TRAPD(ret, scd = CFbsScreenDevice::NewL(_L("scdv"),aDispMode));

 	if (!scd)

 		{

 		WARN_PRINTF3(_L("Could not create screen device in %d mode, reason=%d.\r\n"), aDispMode, ret);

 		return;

 		}

 	CleanupStack::PushL(scd);

 	scd->ChangeScreenDevice(NULL);

 	CFbsBitGc* sgc;

 	if (scd->CreateContext((CGraphicsContext*&)sgc)==KErrNone) 

 		{

 		CleanupStack::PushL(sgc);

 		TSize halfScreen = scd->SizeInPixels();

 		halfScreen.iWidth /= 2;

 		INFO_PRINTF1(_L("BitBlt..."));

 		sgc->BitBlt(TPoint(halfScreen.iWidth,0),&aBmp);

 		INFO_PRINTF1(_L("worked\r\n"));

 		CleanupStack::PopAndDestroy(sgc);

 		}

 	else

 		{

 		INFO_PRINTF2(_L("Could not create context in %d mode.\r\n"), aDispMode);

 		}

 	CleanupStack::PopAndDestroy(scd);

 	}

 /**

 	@SYMTestCaseID

 	GRAPHICS-FBSERV-0573

 	@SYMDEF INC088856

 	@SYMTestCaseDesc

 	Verifies defect INC088856. Checks the 

 	updated padding value before compression for

 	256 gray scale and 64k colour.

 	@SYMTestActions

 	Creates a bitmap. Gets the bitmaps scanline length.

 	Locks the heap. Retrieves the bitmaps data address.

 	Unlocks the heap. Then for both 256 gray scale and 64k colour

 	it checks the padding after compression matches before compression.

 	@SYMTestExpectedResults

 	Test should pass

 */

 void CTCompressed::INC088856_TestL()

 	{

 	INFO_PRINTF1(_L("Check updated Padding value in before compression \r\n"));

 	INFO_PRINTF1(_L("Check updated Padding value for EGray256 \r\n"));

 	DoUpdateOnPadding(TSize(5,3),EGray256);

 	DoUpdateOnPadding(TSize(25,43),EGray256);

 	INFO_PRINTF1(_L("Check updated Padding value for EColor64K \r\n"));

 	DoUpdateOnPadding(TSize(5,3),EColor64K);

 	DoUpdateOnPadding(TSize(25,43),EColor64K);

 	}

 void CTCompressed::DoUpdateOnPadding(const TSize aSize, const TDisplayMode aDispMode)

 	{

 	CFbsBitmapEx bmp1;

 	TInt ret=bmp1.Create(aSize,aDispMode);

 	TEST(ret==KErrNone);

 	TInt dataLength = CFbsBitmap::ScanLineLength(aSize.iWidth, bmp1.DisplayMode()) * aSize.iHeight;

 	bmp1.LockHeap();

 	TUint8* srcBits = (TUint8*)bmp1.DataAddress();

 	bmp1.UnlockHeap();

 	TInt val=1,pos=0;

 	switch (aDispMode)

 		{

 	case EGray256:

 		{

 		TUint8* bmpBits = srcBits;

 		TUint8* bmpBitsLimit = srcBits + dataLength;

 		while(bmpBits<bmpBitsLimit)

 			{

 			if(pos++ < aSize.iWidth)

 				{

 				*bmpBits++ = val;

 				}

 			else 

 				{

 				bmpBits += 3;

 				val++;

 				pos=0;

 				}

 			}

 		}

 		break;

 	case EColor64K:

 		{

 		TUint16* bmpBits = (TUint16*)srcBits;

 		TUint16* bmpBitsLimit = (TUint16*)(srcBits + dataLength);

 		while(bmpBits<bmpBitsLimit)

 			{

 			if(pos++ < aSize.iWidth)

 				{

 				*bmpBits++ = val;

 				}

 			else 

 				{

 				bmpBits++;

 				val++;

 				pos=0;

 				}

 			}

 		}

 		break;

 	default:

 		break;

 		}

 	bmp1.Compress();

 	TInt stride = bmp1.DataStride();

 	TUint8* dataPtr = (TUint8*)bmp1.DataAddress();

 	switch(aDispMode)

 		{

 	case EGray256:

 		{

 		for (TInt row = 0; row < aSize.iHeight - 1; ++row)

 			{

 			TEST(*dataPtr++ == stride - 1);

 			TEST(*dataPtr++ == row + 1);

 			}

 		break;

 		}

 	case EColor64K:

 		{

 		for (TInt row = 0; row < aSize.iHeight - 1; ++row)

 			{

 			TEST(*dataPtr++ == stride / 2 - 1);

 			TEST(*dataPtr++ == row + 1);

 			TEST(*dataPtr++ == 0);

 			}

 		}

 		break;

 	default:

 		break;

 		}

 	}

 /**

  * @SYMTestCaseID GRAPHICS-FBSERV-0615

  *

  * @SYMDEF PDEF115511

  *

  * @SYMTestCaseDesc

  * Test Fbserv robustness when bitmaps are destroyed while they are being background compressed

  *

  * @SYMTestPriority High

  *

  * @SYMTestStatus Implemented

  *

  * @SYMTestActions

  * Preform various scenarios to create bitmaps, compress them in background and then destroy the 

  * bitmaps without waiting the compression to complete.

  *

  * @SYMTestExpectedResults

  * Fbserv does not crash because of misfirig its background compression active object

  */

 void CTCompressed::TestDestroyBitmapWhileBeingBackgroundCompressedL()

 	{

 	const TInt KNumOfBitmaps = 1000;

 	const TSize KSize(1,1);

 	const TDisplayMode KMode = EColor64K;

 	CFbsBitmap* bitmaps[KNumOfBitmaps];

 	// TestCase #1

 	// Create N bitmap instances, compress them in background and destroy them in-reverse order

 	// without waiting compression to complete

 	INFO_PRINTF2(_L("Create %d bitmaps,compress them in background and destroy in reverse order"), KNumOfBitmaps);

 	for (TInt idx=0; idx<KNumOfBitmaps; ++idx)

 		{

 		bitmaps[idx] = new(ELeave) CFbsBitmap;

 		CleanupStack::PushL(bitmaps[idx]);

 		User::LeaveIfError(bitmaps[idx]->Create(KSize, KMode));

 		}

 	for (TInt idx=0; idx<KNumOfBitmaps; ++idx)

 		{

 		User::LeaveIfError(bitmaps[idx]->CompressInBackground());

 		}

 	// Delete bitmaps in reverse order

 	CleanupStack::PopAndDestroy(KNumOfBitmaps, bitmaps[0]);

 	// TestCase #2

 	// Create N bitmap instances, compress them in background and destroy them in the compression order

 	// without waiting compression to complete

 	INFO_PRINTF2(_L("Create %d bitmaps,compress them in background and destroy in forward order"), KNumOfBitmaps);

 	for (TInt idx=0; idx<KNumOfBitmaps; ++idx)

 		{

 		bitmaps[idx] = new(ELeave) CFbsBitmap;

 		CleanupStack::PushL(bitmaps[idx]);

 		User::LeaveIfError(bitmaps[idx]->Create(KSize, KMode));

 		}

 	for (TInt idx=0; idx<KNumOfBitmaps; ++idx)

 		{

 		User::LeaveIfError(bitmaps[idx]->CompressInBackground());

 		}

 	// Delete bitmaps in compression order

 	CleanupStack::Pop(KNumOfBitmaps, bitmaps[0]);	

 	for (TInt idx=0; idx<KNumOfBitmaps; ++idx)

 		{

 		delete bitmaps[idx];

 		}

 	// TestCase #3

 	// Create N bitmap instances, compress them in background and destroy them in random order

 	// without waiting compression to complete

 	INFO_PRINTF2(_L("Create %d bitmaps,compress them in background and destroy in random order"), KNumOfBitmaps);

 	TInt randomOrder[KNumOfBitmaps];

 	for (TInt idx=0; idx<KNumOfBitmaps; ++idx)

 		{

 		bitmaps[idx] = new(ELeave) CFbsBitmap;

 		CleanupStack::PushL(bitmaps[idx]);

 		User::LeaveIfError(bitmaps[idx]->Create(KSize, KMode));

 		randomOrder[idx] = idx;

 		}

 	// Randomise deletion order

 	for (TInt idx=0; idx<KNumOfBitmaps; ++idx)

 		{

 		TInt swap = Math::Random()%KNumOfBitmaps;

 		TInt tmp = randomOrder[idx];

 		randomOrder[idx] = randomOrder[swap];

 		randomOrder[swap] = tmp;

 		}

 	for (TInt idx=0; idx<KNumOfBitmaps; ++idx)

 		{

 		User::LeaveIfError(bitmaps[idx]->CompressInBackground());

 		}

 	// Delete bitmaps in random order

 	CleanupStack::Pop(KNumOfBitmaps, bitmaps[0]);	

 	for (TInt idx=0; idx<KNumOfBitmaps; ++idx)

 		{

 		delete bitmaps[randomOrder[idx]];

 		bitmaps[randomOrder[idx]] = NULL;

 		}

 	// Test all bitmaps has been destroyed

 	for (TInt idx=0; idx<KNumOfBitmaps; ++idx)

 		{

 		TEST(bitmaps[idx]==NULL);

 		}

 	// TestCase #4

 	// Create bitmap, compress it in background and immediately destroyed without waiting compression

 	// to complete

 	INFO_PRINTF2(_L("Create bitmap,compress in background and immediately destroyed. Repeat %d times"), KNumOfBitmaps);

 	for (TInt idx=0; idx<KNumOfBitmaps; ++idx)

 		{

 		CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;

 		CleanupStack::PushL(bitmap);

 		User::LeaveIfError(bitmap->Create(KSize, KMode));

 		User::LeaveIfError(bitmap->CompressInBackground());

 		CleanupStack::PopAndDestroy(bitmap);

 		}

 	// TestCase #5

 	// Similar from #4 but executed from two different threads

 	INFO_PRINTF2(_L("Create bitmap,compress in background and immediately destroyed from 2 different threads. Repeat %d times"), KNumOfBitmaps);

 	const TInt KStackSize = 4096;

 	const TInt KMinHeapSize = 4096;

 	const TInt KMaxHeapSize = 1024*1024;

 	RThread t1;

 	User::LeaveIfError(t1.Create(_L("bgCompThreadFunc#1"), CTCompressed::BgCompThreadFunc, KStackSize, KMinHeapSize, KMaxHeapSize, NULL));

 	RThread t2;

 	User::LeaveIfError(t2.Create(_L("bgCompThreadFunc#2"), CTCompressed::BgCompThreadFunc, KStackSize, KMinHeapSize, KMaxHeapSize, NULL));

 	TRequestStatus s1;

 	TRequestStatus s2;

 	t1.Logon(s1);

 	t2.Logon(s2);

 	t1.Resume();

 	t2.Resume();

 	User::WaitForRequest(s1);

 	User::WaitForRequest(s2);

 	t1.Close();

 	t2.Close();

 	}

 TInt CTCompressed::BgCompThreadFunc(TAny*)

 	{

 	const TInt KNumOfBitmaps = 1000;

 	const TSize KSize(1,1);

 	const TDisplayMode KMode = EColor64K;

 	// No need to worries with cleanup stack and trap as resources will be freed if the thread

 	// running this functions dies, panics or leaves.

 	RFbsSession::Connect();

 	for (TInt idx=0; idx<KNumOfBitmaps; ++idx)

 		{

 		CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;

 		User::LeaveIfError(bitmap->Create(KSize, KMode));

 		User::LeaveIfError(bitmap->CompressInBackground());

 		delete bitmap;

 		}

 	RFbsSession::Disconnect();

 	return KErrNone;

 	}

 /**

  * @SYMTestCaseID GRAPHICS-FBSERV-0616

  *

  * @SYMDEF INC123238

  *

  * @SYMTestCaseDesc

  * Test Fbserv bitmap's priority inversion when we use background compression against a long running thread

  *

  * @SYMTestPriority High

  *

  * @SYMTestStatus Implemented

  *

  * @SYMTestActions

  * Create a thread which creates a bitmap and makes a call to background compression. Once this thread resumed,

  * make the current thread as busy by doing some long running task and test the exit status of the bitmap compression thread.

  *

  * @SYMTestExpectedResults

  * Fbserv does priority inheritance and therefore protect against priority inversion, so the thread function will

  * do backgroud compression and the thread will exit successfully, which will pass the test. If it is not protect

  * against priority inversion with in 30 seconds(approximately) the test will fail without doing background compression.

  */

 void CTCompressed::TestBackgroundCompressionThreadPriorityInheritanceL()

 	{

 	const TInt KStackSize = 4096;

 	const TInt KMinHeapSize = 4096;

 	const TInt KMaxHeapSize = 1024*1024;

 	const TInt KMaxViewChangeTime = 2000;

 	INFO_PRINTF1(_L("Test case for Background Compression Thread Priority Inheritance\r\n"));	

 	//Create and start a thread which create a bitmap and calls CompressInBackground

 	RThread thread1;

 	User::LeaveIfError(thread1.Create(_L("CompressBgThreadFunc"), CTCompressed::CompressBgThreadFunc, KStackSize, KMinHeapSize, KMaxHeapSize, NULL));

 	thread1.Resume();

 	TUint startTime = User::TickCount();

 	//Start a infinite running loop to make current thread as a busy and long running thread...

 	for (;;)

 		{

 		TExitType exitType = thread1.ExitType();

 		if(exitType != EExitPending)

 			{

 			TInt exitReason = thread1.ExitReason();

 			TEST(exitType == EExitKill);

 			TEST(exitReason == KErrNone);

 			break;

 			}

 		TUint stopTime = User::TickCount();

 		if((stopTime - startTime) > KMaxViewChangeTime) //Check for the busy task is running for more than 30 seconds...

 			{

 			TEST(EFalse);

 			thread1.Terminate(KErrGeneral);

 			break;

 			}

 		}

 	thread1.Close();

 	}

 /*

  Thread function used from the test case TestBackgroundCompressionThreadPriorityInheritanceL

  */

 TInt CTCompressed::CompressBgThreadFunc(TAny*)

 	{

 	const TSize KSize(100, 100);

 	const TDisplayMode KMode = EColor64K;

 	TInt err = RFbsSession::Connect();

 	if (err != KErrNone)

 		return err;

 	CFbsBitmap* bitmap = new CFbsBitmap;

 	if (!bitmap)

 		return KErrNoMemory;

 	err = bitmap->Create(KSize, KMode);

 	if (err != KErrNone)

 		return err;

 	err = bitmap->CompressInBackground();

 	if (err != KErrNone)

 		return err;

 	delete bitmap;

 	RFbsSession::Disconnect();

 	return KErrNone;

 	}

 //--------------

 __CONSTRUCT_STEP__(Compressed)