--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fbs/fontandbitmapserver/tfbs/tcompressed.cpp	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,770 @@
+// 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)