--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fbs/fontandbitmapserver/tfbs/TBITMAP.CPP	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,5672 @@
+// Copyright (c) 1996-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:
+//
+
+/**
+ @file
+ @test
+ @internalComponent - Internal Symbian test code
+*/
+
+#include <e32math.h>
+#include <s32file.h>
+#include <bautils.h>
+#include <hal.h>
+#include <test/tefunit.h>
+#include <graphics/bitmapuid.h>
+#include "../sfbs/UTILS.H"
+#include "TBitmap.h"
+#include "../sfbs/fbsbitmapasyncstreamer.h"
+#include "fbsmessage.h"
+
+// Symbian modification to help reduce unnecessary warnings 
+#if (__ARMCC_VERSION >= 310000)
+//turn off Warning:  #546-D: transfer of control bypasses initialization of variable, which is unnecessary.
+#pragma diag_suppress 546
+#endif
+// End of Symbian modification
+
+
+
+//
+//
+//Globals
+//LOCAL_D RTest	TheTest(_L("Test Bitmap"));
+LOCAL_D RFs		TheFs;
+const TUint8	KCheckValue = 0x69;//pixel value used in the tests
+
+_LIT(KBmpCompr12, "z:\\system\\data\\compr12.mbm");
+_LIT(KBmpCompr16, "z:\\system\\data\\compr16.mbm");
+_LIT(KBmpCompr24, "z:\\system\\data\\compr24.mbm");
+_LIT(KBmpZCompr12, "z:\\system\\data\\racompr12.mbm");
+_LIT(KBmpZCompr16, "z:\\system\\data\\racompr16.mbm");
+_LIT(KBmpZCompr24, "z:\\system\\data\\racompr24.mbm");
+_LIT(KBmpCCompr12, "c:\\racompr12.mbm");
+_LIT(KBmpCCompr16, "c:\\racompr16.mbm");
+_LIT(KBmpCCompr24, "c:\\racompr24.mbm");
+
+_LIT(KRc_RamInRom8, "z:\\system\\data\\rc_ram8.mbm");
+_LIT(KRc_RamInRom12, "z:\\system\\data\\rc_ram12.mbm");
+_LIT(KRc_RamInRom16, "z:\\system\\data\\rc_ram16.mbm");
+_LIT(KRc_RamInRom24, "z:\\system\\data\\rc_ram24.mbm");
+
+_LIT(KRc_Ram8, "c:\\rc_ram8.mbm");
+_LIT(KRc_Ram12, "c:\\rc_ram12.mbm");
+_LIT(KRc_Ram16, "c:\\rc_ram16.mbm");
+_LIT(KRc_Ram24, "c:\\rc_ram24.mbm");
+
+_LIT(KRamBitmapOnZ, "z:\\system\\data\\16RAM2.mbm");
+_LIT(KRamBitmap, "c:\\16RAM2.mbm");
+_LIT(KRamBitmap2, "c:\\16RAM3.mbm");
+
+_LIT(KMono_RamInRom_M1, "z:\\system\\data\\mono_m1.mbm");
+_LIT(KMono_RamInRom_M2, "z:\\system\\data\\mono_m2.mbm");
+_LIT(KMono_RamInRom_M4, "z:\\system\\data\\mono_m4.mbm");
+_LIT(KMono_RamInRom_M8, "z:\\system\\data\\mono_m8.mbm");
+_LIT(KMono_RamInRom_C4, "z:\\system\\data\\mono_c4.mbm");
+_LIT(KMono_RamInRom_C8, "z:\\system\\data\\mono_c8.mbm");
+_LIT(KMono_RamInRom_C12, "z:\\system\\data\\mono_c12.mbm");
+_LIT(KMono_RamInRom_C16, "z:\\system\\data\\mono_c16.mbm");
+_LIT(KMono_RamInRom_C24, "z:\\system\\data\\mono_c24.mbm");
+_LIT(KMono_RamInRom_C32, "z:\\system\\data\\mono_c32.mbm");
+
+_LIT(KMono_M1, "c:\\mono_m1.mbm");
+_LIT(KMono_M2, "c:\\mono_m2.mbm");
+_LIT(KMono_M4, "c:\\mono_m4.mbm");
+_LIT(KMono_M8, "c:\\mono_m8.mbm");
+_LIT(KMono_C4, "c:\\mono_c4.mbm");
+_LIT(KMono_C8, "c:\\mono_c8.mbm");
+_LIT(KMono_C12, "c:\\mono_c12.mbm");
+_LIT(KMono_C16, "c:\\mono_c16.mbm");
+_LIT(KMono_C24, "c:\\mono_c24.mbm");
+_LIT(KMono_C32, "c:\\mono_c32.mbm");
+
+_LIT(KRomBitmap,"z:\\system\\data\\tfbs.rbm");
+
+//
+//
+//Create/Destroy test environment global functions
+
+//Delete "aFullName" file.
+LOCAL_C void DeleteDataFile(const TDesC& aFullName)
+	{
+	RFs fsSession;
+	TInt err = fsSession.Connect();
+	if(err == KErrNone)
+		{
+		TEntry entry;
+		if(fsSession.Entry(aFullName, entry) == KErrNone)
+			{
+			RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName);
+			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);
+			if(err != KErrNone) 
+				{
+				RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);
+				}
+			err = fsSession.Delete(aFullName);
+			if(err != KErrNone) 
+				{
+				RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);
+				}
+			}
+		fsSession.Close();
+		}
+	else
+		{
+		RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);
+		}
+	}
+
+//Copy test bitmaps from Z: to C: drive. RFs::Connect() had to be called already 
+//on "TheFs" object.
+LOCAL_C void CopyFilesOnC()
+	{
+	BaflUtils::CopyFile(TheFs, KTestBitmapOnZ, KTestBitmapOnC);
+	BaflUtils::CopyFile(TheFs, KBmpZCompr12, KBmpCCompr12);
+	BaflUtils::CopyFile(TheFs, KBmpZCompr16, KBmpCCompr16);
+	BaflUtils::CopyFile(TheFs, KBmpZCompr24, KBmpCCompr24);
+	BaflUtils::CopyFile(TheFs, KRc_RamInRom8, KRc_Ram8);
+	BaflUtils::CopyFile(TheFs, KRc_RamInRom12, KRc_Ram12);
+	BaflUtils::CopyFile(TheFs, KRc_RamInRom16, KRc_Ram16);
+	BaflUtils::CopyFile(TheFs, KRc_RamInRom24, KRc_Ram24);
+	BaflUtils::CopyFile(TheFs, KRamBitmapOnZ, KRamBitmap);
+	BaflUtils::CopyFile(TheFs, KRamBitmapOnZ, KRamBitmap2);
+	BaflUtils::CopyFile(TheFs, KMono_RamInRom_M1, KMono_M1);
+	BaflUtils::CopyFile(TheFs, KMono_RamInRom_M2, KMono_M2);
+	BaflUtils::CopyFile(TheFs, KMono_RamInRom_M4, KMono_M4);
+	BaflUtils::CopyFile(TheFs, KMono_RamInRom_M8, KMono_M8);
+	BaflUtils::CopyFile(TheFs, KMono_RamInRom_C4, KMono_C4);
+	BaflUtils::CopyFile(TheFs, KMono_RamInRom_C8, KMono_C8);
+	BaflUtils::CopyFile(TheFs, KMono_RamInRom_C12, KMono_C12);
+	BaflUtils::CopyFile(TheFs, KMono_RamInRom_C16, KMono_C16);
+	BaflUtils::CopyFile(TheFs, KMono_RamInRom_C24, KMono_C24);
+	BaflUtils::CopyFile(TheFs, KMono_RamInRom_C32, KMono_C32);
+	}
+
+//Delete data files used by the test
+LOCAL_C void DeleteFilesFromC()
+	{
+	DeleteDataFile(KTestBitmapOnC);
+	DeleteDataFile(KBmpCCompr12);
+	DeleteDataFile(KBmpCCompr16);
+	DeleteDataFile(KBmpCCompr24);
+	DeleteDataFile(KRc_Ram8);
+	DeleteDataFile(KRc_Ram12);
+	DeleteDataFile(KRc_Ram16);
+	DeleteDataFile(KRc_Ram24);
+	DeleteDataFile(KRamBitmap);
+	DeleteDataFile(KRamBitmap2);
+	DeleteDataFile(KMono_M1);
+	DeleteDataFile(KMono_M2);
+	DeleteDataFile(KMono_M4);
+	DeleteDataFile(KMono_M8);
+	DeleteDataFile(KMono_C4);
+	DeleteDataFile(KMono_C8);
+	DeleteDataFile(KMono_C12);
+	DeleteDataFile(KMono_C16);
+	DeleteDataFile(KMono_C24);
+	DeleteDataFile(KMono_C32);
+	}
+
+//
+//
+
+void CTBitmap::DeleteScanLineBuffer()
+	{
+	RFbsSession* fbs = RFbsSession::GetSession();
+	delete fbs->iScanLineBuffer;
+	fbs->iScanLineBuffer = NULL;
+	}
+
+CTBitmap::CTBitmap(CTestStep* aStep):
+	CTGraphicsBase(aStep),
+	iBmpHandler(NULL),
+	iBitmap(NULL),
+	iAs(NULL)
+	{
+	__ASSERT_DEBUG(CActiveScheduler::Current(), User::Invariant());
+	CFbsBitmap bmp;
+	iTestBitmapName = KTestBitmapOnZ;
+	TInt ret=bmp.Load(iTestBitmapName,ETfbs,NULL);
+	TEST2(ret, KErrNone);
+	bmp.Reset();
+
+	ret = iFs.Connect();
+	TEST2(ret, KErrNone);
+
+	// Expand session scanline buffer cache to avoid spurious alloc heavens later on
+	const TInt bufferSize = 1024;
+
+	ret = bmp.Create(TSize(bufferSize,1),EColor256);
+	TEST2(ret, KErrNone);
+
+	ret = bmp.Compress();
+	TEST2(ret, KErrNone);
+
+	TUint8* buffer = new TUint8[bufferSize];
+	TEST(buffer != NULL);
+
+	TPtr8 scanline(buffer,bufferSize,bufferSize);
+	bmp.GetScanLine(scanline,TPoint(0,0),bufferSize,EColor256);
+	delete [] buffer;
+	bmp.Reset();
+	
+	TUint32* romAddress = NULL;
+	if(!CFbsBitmap::IsFileInRom(KRomBitmap, romAddress)) //any ROM bitmap
+		{
+		INFO_PRINTF2(_L("Skipping ROM bitmap tests since file \"%S\" is reported to not be a ROM bitmap."),
+				&KRomBitmap);
+		INFO_PRINTF1(_L("This should only occur on non-XIP ROMs, e.g. NAND ROMs, where ROM bitmaps aren't supported."));
+		iSkipRomBitmapTests = ETrue;
+		}
+	}
+
+CTBitmap::~CTBitmap()
+	{
+	iFs.Close();
+	}
+
+void CTBitmap::RunTestCaseL(TInt aCurTestCase)
+    {
+    ((CTBitmapStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
+	switch(aCurTestCase)
+		{
+	case 1:		
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0550"));
+		TwoComprLines();
+		break;
+	case 2:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0517"));
+	// they are fast hence at the beginning
+		CheckScanlineL();
+		break;
+	case 3:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0534"));
+		Compress();
+		break;
+	case 4:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0518"));
+		StreamBitmap();
+		break;
+	case 5:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0519"));
+		StreamRectangle();
+		break;
+	case 6:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0523"));
+		LoadInSegments();
+		break;
+	case 7:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0524"));
+		SaveInSegments();
+		break;
+	case 8:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0525"));
+		MonoDetect();
+		break;
+	case 9:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0526"));
+		ChunkPileL();
+		break;
+	case 10:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0527"));
+		LargeBitmaps();
+		break;
+	case 12:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0528"));
+		HugeBitmaps();
+		break;
+	case 13:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0529"));
+		Resize();
+		break;
+	case 14:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0520"));
+		GetScanline();
+		break;
+	case 15:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0521"));
+		SetScanline();
+		break;
+	case 16:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0522"));
+		StretchScanline();
+		break;
+	case 17:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0530"));
+		BitmapUtil();
+		break;
+	case 18:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0531"));
+		InvalidBitmap();
+		break;
+	case 19:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L(" GRAPHICS-FBSERV-0533"));
+		SaveAndLoadFast();
+		break;
+	case 20:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0532"));
+		SaveAndLoad();
+		break;
+	case 21:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0535"));
+		Color256BitmapUtil();
+		break;
+	case 22:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0536"));
+		HardwareBitmaps();
+		break;
+	case 23:
+		((CTBitmapStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+	//	BitmapTiming(); 
+		break;
+	case 24:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0537"));
+		INC036062L();
+		break;
+	case 25:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0538"));
+		PerformanceTest_INC036062L();
+		break;
+	case 26:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0539"));
+		INC037474L();
+		break;
+	case 27:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0540"));
+		DEF038286L();
+		break;
+	case 28:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0541"));
+		DEF038286_2L();
+		break;
+	case 29:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0542"));
+		MonohromeL();
+		break;
+	case 30:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0543"));
+		GetVerticalScanLineL();
+		break;
+	case 31:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0544"));
+		GetVerticalScanLinePerformanceL();
+		break;
+	case 32:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0545"));
+		DEF071843_16MAL();
+		((CTBitmapStep*)iStep)->RecordTestResultL();
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0546"));	
+		DEF071843_16MUL();
+		((CTBitmapStep*)iStep)->RecordTestResultL();
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0547"));
+		DEF071843_16ML();
+#ifdef _DEBUG
+		((CTBitmapStep*)iStep)->RecordTestResultL();
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0549"));
+		//It uses Heap Allocation failure macro 
+		//which is supported only for debug mode	
+		DEF095361_16MAL();
+#endif		
+		break;
+	case 33:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0548"));
+		DEF074623_16MAL();
+		break;
+	case 34:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0551"));
+		TestPaletteCompressionL();
+		break;
+	case 35:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0552"));
+		TestSynchronousBackgroundPaletteCompressionL();
+		break;
+	case 36:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0553"));
+		TestAsynchronousBackgroundPaletteCompressionL();
+		break;
+	case 37:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0501"));
+		GetAllBitmapsIdsL();
+		break;
+	case 38:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0554"));
+		CheckBadBmp();
+		break; 
+	case 39:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0516"));
+		CheckSetDisplayModeL();
+		break; 	
+	case 40:
+/**
+	@SYMTestCaseID GRAPHICS-FBSERV-0619
+*/
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0619"));
+		MultiThreadedTestsL();
+		break;
+	case 41:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0612"));
+		TestBgCompressL();
+		break;
+	case 42:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0613"));
+		TestBgCompressInUseL();
+		break;
+	case 43:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0614"));
+		TestDisconnectWithBitmapL();
+		break;
+	case 44:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0617"));
+		TestTouchedAndVolatileL();
+		break;
+	case 45:
+		((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0618"));
+		TestBitmapWhiteFillL();
+		break;
+	case 46:
+		((CTBitmapStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+		((CTBitmapStep*)iStep)->CloseTMSGraphicsStep();
+		TestComplete();
+		break;
+	default:
+		((CTBitmapStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+		break;
+		}
+		
+	((CTBitmapStep*)iStep)->RecordTestResultL();
+    }
+   
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0516
+
+	@SYMTestCaseDesc
+	Checks that the display mode can be set 
+	to various modes, including EColor16MAP
+	
+	@SYMTestActions
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/  
+void CTBitmap::CheckSetDisplayModeL()
+	{
+	INFO_PRINTF1(_L("Check SetDisplayMode EColor16MAP"));
+
+	CFbsBitmap bmp;
+	User::LeaveIfError(bmp.Create(TSize(4,4),EColor16MA));
+	TInt ret=bmp.SetDisplayMode(EColor16MAP);
+	TEST(ret==KErrNone);
+	bmp.Reset();
+
+	User::LeaveIfError(bmp.Create(TSize(4,4),EColor16MU));
+	ret=bmp.SetDisplayMode(EColor16MAP);
+	TEST(ret==KErrNone);
+	bmp.Reset();
+
+	User::LeaveIfError(bmp.Create(TSize(4,4),EColor64K));
+	ret=bmp.SetDisplayMode(EColor16MAP);
+	TEST(ret==KErrArgument);
+	bmp.Reset();
+
+	User::LeaveIfError(bmp.Create(TSize(4,4),EColor16MAP));
+	ret=bmp.SetDisplayMode(EColor16MAP);
+	TEST(ret==KErrNone);
+
+	ret=bmp.SetDisplayMode(EColor16MU);
+	TEST(ret==KErrNone);
+	bmp.Reset();
+	
+	}    
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0517
+
+	@SYMTestCaseDesc
+	Compares a pixel retrieved with GetPixel and GetScanLine
+
+	@SYMTestActions
+	Zero fills a buffer which has an uneven length of bytes and
+	gets a pixel from a point which should coincide with
+	that of a point retrieved with scan line
+		
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::CheckScanlineL()
+	{
+	INFO_PRINTF1(_L("Scanline sanity check"));
+
+	CFbsBitmap bmp;
+	User::LeaveIfError(bmp.Create(TSize(32,1),EGray2));
+
+	// try using a buffer that isn't a whole number of words long. 
+	TUint8 buffer[3];
+	Mem::FillZ(buffer,3);
+	TPtr8 scanline(buffer,3,3);
+	bmp.GetScanLine(scanline,TPoint(0,0),24,EGray2);
+
+	TRgb pixel(KRgbRed);
+	bmp.GetPixel(pixel,TPoint(0,0));
+
+	// getscanline and getpixel should agree
+	TEST(TRgb::Gray2(buffer[0] & 0x01) == pixel);
+
+	bmp.Reset();
+
+	
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0518
+
+	@SYMTestCaseDesc
+	Streams different bitmap size of different colour depth.
+
+	@SYMTestActions
+
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::StreamBitmap()
+	{
+	INFO_PRINTF1(_L("Test Bitmap Streaming"));
+
+	DoStreamBitmapSizes(EGray2);
+	DoStreamBitmapSizes(EGray4);
+	DoStreamBitmapSizes(EGray16);
+	DoStreamBitmapSizes(EGray256);
+	DoStreamBitmapSizes(EColor16);
+	DoStreamBitmapSizes(EColor256);
+	DoStreamBitmapSizes(EColor4K);
+	DoStreamBitmapSizes(EColor64K);
+	DoStreamBitmapSizes(EColor16M);
+	DoStreamBitmapSizes(EColor16MU);
+	DoStreamBitmapSizes(EColor16MAP);
+	}
+
+void CTBitmap::DoStreamBitmapSizes(TDisplayMode aDispMode)
+	{
+	const TSize smallStreamBitmapSize(32,10);
+	const TSize largeStreamBitmapSize(256,256);
+	const TSize oddStreamBitmapSize(31,2);
+
+	DoStreamBitmap(smallStreamBitmapSize,aDispMode,ETrue);
+	DoStreamBitmap(smallStreamBitmapSize,aDispMode,EFalse);
+	DoStreamBitmap(largeStreamBitmapSize,aDispMode,ETrue);
+	DoStreamBitmap(largeStreamBitmapSize,aDispMode,EFalse);
+	DoStreamBitmap(oddStreamBitmapSize,aDispMode,ETrue);
+	DoStreamBitmap(oddStreamBitmapSize,aDispMode,EFalse);
+	}
+
+void CTBitmap::DoStreamBitmap(const TSize& aSize,TDisplayMode aDispMode,TBool aBlank)
+	{
+	__UHEAP_MARK;
+
+	CFbsBitmapEx bmp;
+	TInt ret = bmp.Create(aSize,aDispMode);
+	TEST2(ret, KErrNone);
+
+	if (aBlank)
+		BlankBitmap(bmp);
+	else
+		FillBitmap(bmp);
+
+	CDirectFileStore* writestore=NULL;
+
+	TRAP(ret,writestore=CDirectFileStore::ReplaceL(iFs,KTempFilename,EFileStream|EFileWrite));
+	TEST2(ret, KErrNone);
+
+	TUidType uidtype(KDirectFileStoreLayoutUid,KMultiBitmapFileImageUid);
+
+	TRAP(ret,writestore->SetTypeL(uidtype));
+	TEST2(ret, KErrNone);
+
+	RStoreWriteStream writestrm;
+	TStreamId headerid(0);
+
+	TRAP(ret,headerid=writestrm.CreateL(*writestore));
+	TEST2(ret, KErrNone);
+
+	TRAP(ret,writestore->SetRootL(headerid));
+	TEST2(ret, KErrNone);
+
+	TRAP(ret,bmp.ExternalizeL(writestrm));
+	TEST2(ret, KErrNone);
+
+	writestrm.Close();
+	delete writestore;
+
+	CFbsBitmapEx bmpst;
+	CDirectFileStore* readstore=NULL;
+
+	TRAP(ret,readstore=CDirectFileStore::OpenL(iFs,KTempFilename,EFileStream|EFileRead));
+	TEST2(ret, KErrNone);
+
+	RStoreReadStream readstrm;
+	headerid=readstore->Root();
+
+	TRAP(ret,readstrm.OpenL(*readstore,headerid));
+	TEST2(ret, KErrNone);
+
+	TRAP(ret,bmpst.InternalizeL(readstrm));
+	TEST2(ret, KErrNone);
+
+	readstrm.Close();
+	delete readstore;
+
+	CompareBitmaps(bmp,bmpst,EColor16M);
+
+	iFs.Delete(KTempFilename);
+	bmp.Reset();
+	bmpst.Reset();
+	User::Heap().Check();
+	__UHEAP_MARKEND;
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0519
+
+	@SYMTestCaseDesc
+	Streams bitmap rectangles of different colour depth
+	to file store and reads them back again.
+
+	@SYMTestActions
+	Bitmap rectangles are externalized to file store and
+	read back again. ScanLine is used and compared to GetPixel
+	from the bitmap read back from file store.
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::StreamRectangle()
+	{
+	INFO_PRINTF1(_L("Test Rectangle Streaming"));
+
+	DoStreamRectangle(EGray2,ETrue);
+	DoStreamRectangle(EGray2,EFalse);
+	DoStreamRectangle(EGray4,ETrue);
+	DoStreamRectangle(EGray4,EFalse);
+	DoStreamRectangle(EGray16,ETrue);
+	DoStreamRectangle(EGray16,EFalse);
+	DoStreamRectangle(EGray256,ETrue);
+	DoStreamRectangle(EGray256,EFalse);
+	DoStreamRectangle(EColor16,ETrue);
+	DoStreamRectangle(EColor16,EFalse);
+	DoStreamRectangle(EColor256,ETrue);
+	DoStreamRectangle(EColor256,EFalse);
+	DoStreamRectangle(EColor4K,ETrue);
+	DoStreamRectangle(EColor4K,EFalse);
+	DoStreamRectangle(EColor64K,ETrue);
+	DoStreamRectangle(EColor64K,EFalse);
+	DoStreamRectangle(EColor16M,ETrue);
+	DoStreamRectangle(EColor16M,EFalse);
+	DoStreamRectangle(EColor16MU,ETrue);
+	DoStreamRectangle(EColor16MU,EFalse);
+	DoStreamRectangle(EColor16MAP,ETrue);
+	DoStreamRectangle(EColor16MAP,EFalse);
+	}
+
+void CTBitmap::DoStreamRectangle(TDisplayMode aDispMode,TBool aBlank)
+	{
+	__UHEAP_MARK;
+	CFbsBitmapEx bmp;
+	TInt ret = bmp.Create(TSize(160,80),aDispMode);
+	TEST2(ret, KErrNone);
+
+	if (aBlank)
+		BlankBitmap(bmp);
+	else
+		FillBitmap(bmp);
+
+	CDirectFileStore* writestore=NULL;
+	TRAP(ret,writestore=CDirectFileStore::ReplaceL(iFs,KTempFilename,EFileStream|EFileWrite));
+	TEST2(ret, KErrNone);
+
+	TUidType uidtype(KDirectFileStoreLayoutUid,KMultiBitmapFileImageUid);
+	TRAP(ret,writestore->SetTypeL(uidtype));
+	TEST2(ret, KErrNone);
+
+	RStoreWriteStream writestrm;
+	TStreamId headerid(0);
+	TRAP(ret,headerid=writestrm.CreateL(*writestore));
+	TEST2(ret, KErrNone);
+
+	TRAP(ret,writestore->SetRootL(headerid));
+	TEST2(ret, KErrNone);
+
+	TRAP(ret,bmp.ExternalizeRectangleL(writestrm,TRect(40,20,120,60)));
+	TEST2(ret, KErrNone);
+
+	writestrm.Close();
+	delete writestore;
+
+	CFbsBitmapEx bmpst;
+	CDirectFileStore* readstore=NULL;
+	TRAP(ret,readstore=CDirectFileStore::OpenL(iFs,KTempFilename,EFileStream|EFileRead));
+	TEST2(ret, KErrNone);
+
+	RStoreReadStream readstrm;
+	headerid=readstore->Root();
+	TRAP(ret,readstrm.OpenL(*readstore,headerid));
+	TEST2(ret, KErrNone);
+
+	TRAP(ret,bmpst.InternalizeL(readstrm));
+	TEST2(ret, KErrNone);
+
+	readstrm.Close();
+	delete readstore;
+
+	TInt scanLineLength = CFbsBitmap::ScanLineLength(80,aDispMode);
+	TUint8* buffer = new TUint8[scanLineLength];
+	TUint8* bufferst = new TUint8[scanLineLength];
+	Mem::FillZ(buffer,scanLineLength);
+	Mem::FillZ(bufferst,scanLineLength);
+	TPtr8 scanline(buffer,scanLineLength,scanLineLength);
+	TPtr8 scanlinest(bufferst,scanLineLength,scanLineLength);
+
+	for(TInt yy=0;yy<40;yy++)
+		{
+		bmp.GetScanLine(scanline,TPoint(40,yy+20),80,aDispMode);
+		bmpst.GetScanLine(scanlinest,TPoint(0,yy),80,aDispMode);
+		
+		if(aDispMode != EColor16MU)
+			{
+			TInt memRet = Mem::Compare(buffer,scanLineLength,bufferst,scanLineLength);
+			TEST(memRet == 0);
+			}
+		else
+			{
+			TInt pixelsToCompare = scanLineLength / 4;
+			TUint8* bufferCur = buffer;
+			TUint8* bufferstCur = bufferst;
+			
+			//top byte is unused, and would be more accurate to ignore it
+			for(TInt ii = 0; ii < pixelsToCompare; ii++)
+				{
+				TInt memRet = Mem::Compare(bufferCur,3,bufferstCur,3);
+				TEST(memRet == 0);
+				bufferCur += 4;
+				bufferstCur += 4;
+				}
+			}	
+		}
+	delete [] bufferst;
+	delete [] buffer;
+
+	iFs.Delete(KTempFilename);
+	bmp.Reset();
+	bmpst.Reset();
+	User::Heap().Check();
+	__UHEAP_MARKEND;
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0520
+
+	@SYMTestCaseDesc
+	Calls GetScanLine for different screen modes with
+	the bitmap compressed and uncompressed and checks
+	if the pixels are correct.
+
+	@SYMTestActions
+
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::GetScanline()
+	{
+	INFO_PRINTF1(_L("Test GetScanline"));
+
+	const TSize size1(257,5);
+	const TSize size2(33,17);
+
+	INFO_PRINTF1(_L("EGray2"));
+	DoGetScanline(size1,EGray2);
+	DoGetScanline(size2,EGray2);
+	DoGetScanlineAlt(EGray2);
+
+	INFO_PRINTF1(_L(" EGray4"));
+	DoGetScanline(size1,EGray4);
+	DoGetScanline(size2,EGray4);
+	DoGetScanlineAlt(EGray4);
+
+	INFO_PRINTF1(_L(" EGray16"));
+	DoGetScanline(size1,EGray16);
+	DoGetScanline(size2,EGray16);
+	DoGetScanlineAlt(EGray16);
+
+	INFO_PRINTF1(_L(" EGray256"));
+	DoGetScanline(size1,EGray256);
+	DoGetScanline(size2,EGray256);
+	DoGetScanlineAlt(EGray256);
+
+	INFO_PRINTF1(_L(" EColor16"));
+	DoGetScanline(size1,EColor16);
+	DoGetScanline(size2,EColor16);
+	DoGetScanlineAlt(EColor16);
+
+	INFO_PRINTF1(_L(" EColor256"));
+	DoGetScanline(size1,EColor256);
+	DoGetScanline(size2,EColor256);
+	DoGetScanlineAlt(EColor256);
+
+	INFO_PRINTF1(_L(" EColor4K"));
+	DoGetScanline(size1,EColor4K);
+	DoGetScanline(size2,EColor4K);
+	DoGetScanlineAlt(EColor4K);
+
+	INFO_PRINTF1(_L(" EColor64K"));
+	DoGetScanline(size1,EColor64K);
+	DoGetScanline(size2,EColor64K);
+	DoGetScanlineAlt(EColor64K);
+
+	INFO_PRINTF1(_L(" EColor16M"));
+	DoGetScanline(size1,EColor16M);
+	DoGetScanline(size2,EColor16M);
+	DoGetScanlineAlt(EColor16M);
+
+	INFO_PRINTF1(_L(" EColor16MA"));
+	DoGetScanline(size1,EColor16MA);
+	DoGetScanline(size2,EColor16MA);
+	DoGetScanlineAlt(EColor16MA);
+
+	INFO_PRINTF1(_L(" EColor16MU"));
+	DoGetScanline(size1,EColor16MU);
+	DoGetScanline(size2,EColor16MU);
+	DoGetScanlineAlt(EColor16MU);
+
+	INFO_PRINTF1(_L(" EColor16MAP"));
+	DoGetScanline(size1,EColor16MAP);
+	DoGetScanline(size2,EColor16MAP);
+	DoGetScanlineAlt(EColor16MAP);
+
+	INFO_PRINTF1(_L("\n"));
+	}
+
+void CTBitmap::DoGetScanline(const TSize& aSize,TDisplayMode aDispMode)
+	{
+	__UHEAP_MARK;
+	CFbsBitmapEx bmp;
+	TInt ret = bmp.Create(aSize,aDispMode);
+	TEST2(ret, KErrNone);
+	FillBitmap(bmp);
+
+	DoGetScanlineCheck1(bmp, bmp, aSize, aDispMode);
+	DoGetScanlineCheck2(bmp, bmp, aSize, aDispMode);
+	DoGetScanlineCheck3(bmp, aDispMode);
+
+	ret = bmp.Create(aSize,aDispMode);
+	TEST2(ret, KErrNone);
+
+	StripeBitmap(bmp);
+	CFbsBitmapEx ref;
+	ret = ref.Create(aSize,aDispMode);
+	TEST2(ret, KErrNone);
+
+	CopyBitmap(ref, bmp);
+	ret = bmp.Compress();
+	TEST2(ret, KErrNone);
+
+	DoGetScanlineCheck1(bmp, ref, aSize, aDispMode);
+
+	ref.Reset();
+	bmp.Reset();
+	User::Heap().Check();
+	__UHEAP_MARKEND;
+	}
+
+void CTBitmap::DoGetScanlineCheck1(CFbsBitmap& aBitmap,CFbsBitmap& aReference,const TSize& aSize,TDisplayMode aDispMode)
+	{
+	TInt byteWidth = CFbsBitmap::ScanLineLength(aSize.iWidth,aDispMode);
+	TUint8* buffer = new TUint8[byteWidth + 1];
+	buffer[byteWidth] = KCheckValue;
+	TPtr8 scanline(buffer,byteWidth,byteWidth);
+
+	for(TInt xStart = 0; xStart <= 33; xStart++)
+		{
+		for (TInt xLength = 1; xLength <= 33; xLength++)
+			{
+			TInt xEnd = xStart + xLength;
+			if (xEnd <= aSize.iWidth)
+				{
+				aBitmap.GetScanLine(scanline,TPoint(xStart,0),xLength,aDispMode);
+				for(TInt xx = xStart; xx < xEnd; xx++)
+					{
+					TRgb color;
+					aReference.GetPixel(color,TPoint(xx,0));
+					TRgb bufferColor = ExtractRgb(buffer,xx - xStart,aDispMode);
+					TEST(bufferColor == color);
+					}
+				}
+			}
+		}
+
+	for(TInt yy = 0; yy < aSize.iHeight; yy++)
+		{
+		aBitmap.GetScanLine(scanline,TPoint(0,yy),aSize.iWidth,aDispMode);
+		for(TInt xx = 0; xx < aSize.iWidth; xx++)
+			{
+			TRgb color;
+			aReference.GetPixel(color,TPoint(xx,yy));
+			TRgb bufferColor = ExtractRgb(buffer,xx,aDispMode);
+			TEST(bufferColor == color);
+			}
+		}
+
+	TEST(buffer[byteWidth] == KCheckValue);
+	delete [] buffer;
+	}
+
+void CTBitmap::DoGetScanlineCheck2(CFbsBitmap& aBitmap,CFbsBitmap& aReference,const TSize& aSize,TDisplayMode aDispMode)
+	{
+	TInt byteHeight = CFbsBitmap::ScanLineLength(aSize.iHeight,ERgb);
+	TUint8* buffer = new TUint8[byteHeight];
+	TPtr8 scanline(buffer,byteHeight,byteHeight);
+
+	TInt xx;
+	for(xx = 0; xx < aSize.iWidth; xx++)
+		{
+		aBitmap.GetVerticalScanLine(scanline,xx,aDispMode);
+		for(TInt yy = 0; yy < aSize.iHeight; yy++)
+			{
+			TRgb color;
+			aReference.GetPixel(color,TPoint(xx,yy));
+			TRgb bufferColor = ExtractRgb(buffer,yy,aDispMode);
+			TEST(bufferColor == color);
+			}
+		}
+
+	for(xx = 0; xx < aSize.iWidth; xx++)
+		{
+		aBitmap.GetVerticalScanLine(scanline,xx,ERgb);
+		for(TInt yy = 0; yy < aSize.iHeight; yy++)
+			{
+			TRgb color;
+			aReference.GetPixel(color,TPoint(xx,yy));
+			TRgb bufferColor = ExtractRgb(buffer,yy,ERgb);
+			TEST(bufferColor == color);
+			}
+		}
+
+	delete [] buffer;
+	}
+
+void CTBitmap::DoGetScanlineCheck3(CFbsBitmap& aBitmap,TDisplayMode aDispMode)
+	{
+	TUint32 wordline=0xffffffff;
+	TPtr8 scanline((TUint8*)&wordline,4,4);
+	aBitmap.Create(TSize(31,1),aDispMode);
+	aBitmap.LockHeap();
+	Mem::Fill(aBitmap.DataAddress(),CFbsBitmap::ScanLineLength(31,aDispMode),0xff);
+	aBitmap.UnlockHeap();
+	aBitmap.SetScanLine(scanline,0);
+	TUint32 expected=0;
+
+	for(TInt zz=1;zz<31;zz++)
+		{
+		expected|=1<<(zz-1);
+		wordline=0;
+		aBitmap.GetScanLine(scanline,TPoint(0,0),zz,EGray2);
+		TUint32 actual=wordline&expected;
+		TEST(actual==expected);
+		}
+	}
+
+/* this function calls CheckScanLine with various screen modes, and with the bitmap
+   compressed, and not compressed
+ */
+void CTBitmap::DoGetScanlineAlt(TDisplayMode aDispMode)
+	{
+	__UHEAP_MARK;
+
+	CFbsBitmapEx bmp;
+	TInt ret = bmp.Create(TSize(256,3),aDispMode);
+	TEST2(ret, KErrNone);
+
+	FillBitmap(bmp);
+
+	CheckScanLine(bmp,bmp,EGray2);
+	CheckScanLine(bmp,bmp,EGray4);
+	CheckScanLine(bmp,bmp,EGray16);
+	CheckScanLine(bmp,bmp,EGray256);
+	CheckScanLine(bmp,bmp,EColor16);
+	CheckScanLine(bmp,bmp,EColor256);
+	CheckScanLine(bmp,bmp,EColor4K);
+	CheckScanLine(bmp,bmp,EColor64K);
+	CheckScanLine(bmp,bmp,EColor16M);
+	CheckScanLine(bmp,bmp,ERgb);
+	CheckScanLine(bmp,bmp,EColor16MU);
+	CheckScanLine(bmp,bmp,EColor16MAP);
+
+	CFbsBitmapEx ref;
+	ret = ref.Create(bmp.SizeInPixels(),aDispMode);
+	TEST2(ret, KErrNone);
+	CopyBitmap(ref,bmp);
+	bmp.Compress();
+
+	CheckScanLine(bmp,ref,EGray2);
+	CheckScanLine(bmp,ref,EGray4);
+	CheckScanLine(bmp,ref,EGray16);
+	CheckScanLine(bmp,ref,EGray256);
+	CheckScanLine(bmp,ref,EColor16);
+	CheckScanLine(bmp,ref,EColor256);
+	CheckScanLine(bmp,ref,EColor4K);
+	CheckScanLine(bmp,ref,EColor64K);
+	CheckScanLine(bmp,ref,EColor16M);
+	CheckScanLine(bmp,ref,ERgb);
+	CheckScanLine(bmp,ref,EColor16MU);
+	CheckScanLine(bmp,ref,EColor16MAP);
+
+	User::Heap().Check();
+	__UHEAP_MARKEND;
+	}
+
+void CTBitmap::CheckScanLine(CFbsBitmapEx& aBitmap,CFbsBitmapEx& aReference,TDisplayMode aDispMode)
+	{
+	const TSize bmpSize(aBitmap.SizeInPixels());
+	TInt byteWidth = CFbsBitmap::ScanLineLength(bmpSize.iWidth,aDispMode);
+	TUint8* buffer = new TUint8[byteWidth + 1];
+	buffer[byteWidth] = KCheckValue;
+	TPtr8 scanLine(buffer,byteWidth,byteWidth);
+
+	aBitmap.GetScanLine(scanLine,TPoint(0,1),bmpSize.iWidth,aDispMode);
+
+	for(TInt xx = 0; xx < bmpSize.iWidth; xx++)
+		{
+		TRgb color;
+		aReference.GetPixel(color,TPoint(xx,1));
+		TRgb bufferColor = ExtractRgb(buffer,xx,aDispMode);
+		switch (aDispMode)
+			{
+		case EGray2:
+			if (color.Gray4() == 0 || color.Gray4() == 3) // doesn't check in great detail because dithering occurs
+				TEST(bufferColor.Gray2() == color.Gray2());
+			break;
+		case EGray4:
+			if (aBitmap.DisplayMode() != EGray16) // doesn't check EGray16 because dithering occurs
+				TEST(bufferColor.Gray4() == color.Gray4());
+			break;
+		case EGray16:
+			TEST(bufferColor.Gray16() == color.Gray16());
+			break;
+		case EGray256:
+			TEST(bufferColor.Gray256() == color.Gray256());
+			break;
+		case EColor16:
+			TEST(bufferColor.Color16() == color.Color16());
+			break;
+		case EColor256:
+			TEST(bufferColor.Color256() == color.Color256());
+			break;
+		case EColor4K:
+			TEST(bufferColor.Color4K() == color.Color4K());
+			break;
+		case EColor64K:
+			TEST(bufferColor.Color64K() == color.Color64K());
+			break;
+		case EColor16M:
+			TEST(bufferColor.Color16M() == color.Color16M());
+			break;
+		case ERgb:
+			TEST(bufferColor == color);
+			break;
+		case EColor16MU:
+			if (aReference.DisplayMode()==EColor16MAP || aReference.DisplayMode()==EColor16MA)
+				color.SetAlpha(0xff);
+			CompareColourLikeness(bufferColor, color);			
+			break;
+		case EColor16MAP:
+			//Compare the TRgb values.  For an exact match to work the comparison would
+			//need to be done in PMA space.
+			color.SetInternal(color.Color16MAP());
+			bufferColor.SetInternal(bufferColor.Color16MAP());
+			CompareColourLikeness(bufferColor, color);			
+			break;	
+		default:
+			break;
+			};
+		}
+
+	TEST(buffer[byteWidth] == KCheckValue);
+	delete [] buffer;
+	}
+
+/**
+Compares two TRgbs and tests if they are similar colour.
+This is required because there may be some rounding errors when converting bitmaps from one display mode to another
+or due to alpha blending calculations.
+
+@param aSrc is the source colour
+@param aDest is the destination colour
+@param aDifference use this value for colour difference.  Value of 0 use KColourDifference;
+*/
+void CTBitmap::CompareColourLikeness(const TRgb& aSrc, const TRgb& aDest, TInt aDifference)
+	{
+	const TInt KColourDifference = 2;	// Acceptable difference to check for
+	TInt diff;
+	
+	if (aDifference==0)
+		diff=KColourDifference;
+	else
+		diff=aDifference;
+	
+	TInt redDiff = Abs(aSrc.Red() - aDest.Red());
+	TInt greenDiff = Abs(aSrc.Green() - aDest.Green());	
+	TInt blueDiff = Abs(aSrc.Blue() - aDest.Blue());	
+	TInt alphaDiff = Abs(aSrc.Alpha() - aDest.Alpha());	
+	
+	// Test each channel
+	TEST(redDiff <= diff);
+	TEST(greenDiff <= diff);
+	TEST(blueDiff <= diff);
+	TEST(alphaDiff <= diff);
+	
+	// the code below is useful for a breakpoint, to inspect the differences, in case of failure
+/**	
+	if ((redDiff > diff)||(greenDiff > diff)||(blueDiff > diff)||(alphaDiff > diff))
+		TInt temp=1;
+*/
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0521
+
+	@SYMTestCaseDesc
+	Sets a scanline of random values into
+	bitmaps of different color depths
+
+	@SYMTestActions
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::SetScanline()
+	{
+	INFO_PRINTF1(_L("Test SetScanline"));
+
+	DoSetScanline(EGray2);
+	DoSetScanline(EGray4);
+	DoSetScanline(EGray16);
+	DoSetScanline(EGray256);
+	DoSetScanline(EColor16);
+	DoSetScanline(EColor256);
+	DoSetScanline(EColor4K);
+	DoSetScanline(EColor64K);
+	DoSetScanline(EColor16M);
+	DoSetScanline(EColor16MU);
+	DoSetScanline(EColor16MAP);
+	}
+
+void CTBitmap::DoSetScanline(TDisplayMode aDispMode)
+	{
+	__UHEAP_MARK;
+	CFbsBitmap bmp;
+
+	TInt ret = bmp.Create(TSize(256,2),aDispMode);
+	TEST2(ret, KErrNone);
+
+	TInt scanLineLength = CFbsBitmap::ScanLineLength(256,aDispMode);
+	TUint8* buffer = new TUint8[scanLineLength];
+	TEST(buffer != NULL);
+	TPtr8 scanline(buffer,scanLineLength,scanLineLength);
+
+	TUint8* bufptr = buffer;
+	TInt64 seed = bmp.Handle();
+	for(TInt count = 0; count < scanLineLength; count++)
+		*bufptr++ = (TUint8)Math::Rand(seed);
+
+	bmp.SetScanLine(scanline,0);
+	bmp.SetScanLine(scanline,1);
+
+	bmp.LockHeap();
+	TUint8* data = (TUint8*)bmp.DataAddress();
+	bmp.UnlockHeap();
+	ret = Mem::Compare(buffer,scanLineLength,data,scanLineLength);
+	TEST(ret == 0);
+
+	data += scanLineLength;
+	ret = Mem::Compare(buffer,scanLineLength,data,scanLineLength);
+	TEST(ret == 0);
+
+	delete [] buffer;
+	bmp.Reset();
+	User::Heap().Check();
+	__UHEAP_MARKEND;
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0522
+
+	@SYMTestCaseDesc
+	Stretches a scan line to make it
+	double as long for different colour depths
+	tested on both small and large bitmaps.
+
+	@SYMTestActions
+
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::StretchScanline()
+	{
+	INFO_PRINTF1(_L("Test StretchScanline"));
+
+	const TSize smallBitmapSize(226,2);
+	const TSize largeBitmapSize(1026,40);
+
+	INFO_PRINTF1(_L("EGray2"));
+	DoStretchScanline(smallBitmapSize,EGray2);
+	DoStretchScanline(largeBitmapSize,EGray2);
+
+	INFO_PRINTF1(_L(" EGray4"));
+	DoStretchScanline(smallBitmapSize,EGray4);
+	DoStretchScanline(largeBitmapSize,EGray4);
+
+	INFO_PRINTF1(_L(" EGray16"));
+	DoStretchScanline(smallBitmapSize,EGray16);
+	DoStretchScanline(largeBitmapSize,EGray16);
+
+	INFO_PRINTF1(_L(" EGray256"));
+	DoStretchScanline(smallBitmapSize,EGray256);
+	DoStretchScanline(largeBitmapSize,EGray256);
+
+	INFO_PRINTF1(_L(" EColor16"));
+	DoStretchScanline(smallBitmapSize,EColor16);
+	DoStretchScanline(largeBitmapSize,EColor16);
+
+	INFO_PRINTF1(_L(" EColor256"));
+	DoStretchScanline(smallBitmapSize,EColor256);
+	DoStretchScanline(largeBitmapSize,EColor256);
+
+	INFO_PRINTF1(_L(" EColor4K"));
+	DoStretchScanline(smallBitmapSize,EColor4K);
+	DoStretchScanline(largeBitmapSize,EColor4K);
+
+	INFO_PRINTF1(_L(" EColor64K"));
+	DoStretchScanline(smallBitmapSize,EColor64K);
+	DoStretchScanline(largeBitmapSize,EColor64K);
+
+	INFO_PRINTF1(_L(" EColor16M"));
+	DoStretchScanline(smallBitmapSize,EColor16M);
+	DoStretchScanline(largeBitmapSize,EColor16M);
+
+	INFO_PRINTF1(_L(" EColor16MU"));
+	DoStretchScanline(smallBitmapSize,EColor16MU);
+	DoStretchScanline(largeBitmapSize,EColor16MU);
+	
+	INFO_PRINTF1(_L(" EColor16MA"));
+	DoStretchScanline(smallBitmapSize,EColor16MA);
+	DoStretchScanline(largeBitmapSize,EColor16MA);
+
+	INFO_PRINTF1(_L(" EColor16MAP"));
+	DoStretchScanline(smallBitmapSize,EColor16MAP);
+	DoStretchScanline(largeBitmapSize,EColor16MAP);
+	
+	DoStretchScanline(smallBitmapSize,EColor16MAP,EColor16M, ETrue);
+	DoStretchScanline(largeBitmapSize,EColor16MAP,EColor16M, ETrue);
+	DoStretchScanline(smallBitmapSize,EColor16MAP,EColor16MU, ETrue);
+	DoStretchScanline(largeBitmapSize,EColor16MAP,EColor16MU, ETrue);
+	DoStretchScanline(smallBitmapSize,EColor16MAP,EColor16MA, ETrue);
+	DoStretchScanline(largeBitmapSize,EColor16MAP,EColor16MA, ETrue);
+	DoStretchScanline(smallBitmapSize,EColor16MAP,EColor64K, ETrue);
+	DoStretchScanline(largeBitmapSize,EColor16MAP,EColor64K, ETrue);
+	DoStretchScanline(smallBitmapSize,EColor16MAP,EColor4K, ETrue);
+	DoStretchScanline(largeBitmapSize,EColor16MAP,EColor4K, ETrue);
+	DoStretchScanline(smallBitmapSize,EColor16MAP,EColor256, ETrue);
+	DoStretchScanline(largeBitmapSize,EColor16MAP,EColor256, ETrue);
+	
+	DoStretchScanline(smallBitmapSize,EColor16M,EColor16MAP, ETrue);
+	DoStretchScanline(largeBitmapSize,EColor16M,EColor16MAP, ETrue);
+	DoStretchScanline(smallBitmapSize,EColor16MU,EColor16MAP, ETrue);
+	DoStretchScanline(largeBitmapSize,EColor16MU,EColor16MAP, ETrue);
+	DoStretchScanline(smallBitmapSize,EColor16MA,EColor16MAP, ETrue);
+	DoStretchScanline(largeBitmapSize,EColor16MA,EColor16MAP, ETrue);
+	DoStretchScanline(smallBitmapSize,EColor64K,EColor16MAP, ETrue);
+	DoStretchScanline(largeBitmapSize,EColor64K,EColor16MAP, ETrue);
+	DoStretchScanline(smallBitmapSize,EColor4K,EColor16MAP, ETrue);
+	DoStretchScanline(largeBitmapSize,EColor4K,EColor16MAP, ETrue);
+	DoStretchScanline(smallBitmapSize,EColor256,EColor16MAP, ETrue);
+	DoStretchScanline(largeBitmapSize,EColor256,EColor16MAP, ETrue);
+	
+	DoStretchScanline(smallBitmapSize,EColor16MU,EColor16M, ETrue);
+	DoStretchScanline(largeBitmapSize,EColor16MU,EColor16M, ETrue);
+	
+	INFO_PRINTF1(_L("\n"));
+	}
+
+void CTBitmap::DoStretchScanline(const TSize& aSize,TDisplayMode aDispMode)
+	{
+	DoStretchScanline(aSize,aDispMode,aDispMode, EFalse);
+	}
+
+/* this function is used to determine an acceptable colour difference based on the screen mode 
+   and the alpha value.  This is because when converting from PMA to non pre-multiplied, there
+   can be large errors, especially if alpha is small.
+ */	
+TInt CTBitmap::ColorDifference(TDisplayMode aMode, TInt aAlpha)
+	{
+	switch (aMode)
+		{
+	case EGray2:// Monochrome display mode (1 bpp)
+		return 0xff>>1;
+	case EGray4:// Four grayscales display mode (2 bpp)
+		return 0xff>>2;
+	case EGray16:// 16 grayscales display mode (4 bpp)
+		return 0xff>>2;
+	case EGray256:// 256 grayscales display mode (8 bpp)
+		return 0xff>>2;
+	case EColor16:// Low colour EGA 16 colour display mode (4 bpp)
+		return 0xff>>2;
+	case EColor256: // 256 colour display mode (8 bpp)
+		return 0xff>>2;
+	case EColor64K: // 64,000 colour display mode (16 bpp) 
+		return 0xff>>5;
+	case EColor16M: // True colour display mode (24 bpp)
+		return 0xff>>5;
+	case EColor4K: // 4096 colour display (12 bpp).
+		return 0xff>>4;
+	case EColor16MU:// True colour display mode (32 bpp, but top byte is unused and unspecified)
+		return 0xff>>5;
+	case EColor16MA:// Display mode with alpha (24bpp colour plus 8bpp alpha)
+		return 0xff>>6;
+	case EColor16MAP:// Pre-multiplied Alpha display mode (24bpp color multiplied with the alpha channel value, plus 8bpp alpha)
+		if (aAlpha==0xff)
+			return 0xff>>4;
+		else
+			//make inaccuracy a function of alpha since the colour will the premultiplied, and then
+			//unpremultiplied.  For small alpha this can be quite large.
+			if (aAlpha==0)
+				return 0xff;
+			else
+				return Max(0xff>>4,Min(0xff,(0xff/aAlpha)+0xf));//value corrected by trial and error, with minimum of 15.
+		}
+	return 0xff>>7;	
+	}
+
+void CTBitmap::DoStretchScanline(const TSize& aSize,TDisplayMode aSrcMode,TDisplayMode aDstMode, TBool aUseCompareLikeness)
+	{
+	__UHEAP_MARK;
+	CFbsBitmapEx bmp;
+	CBitwiseBitmap* bmpadd=NULL;
+
+	TInt ret = bmp.Create(aSize,aSrcMode);
+	TEST2(ret, KErrNone);
+
+	FillBitmap(bmp);
+	bmpadd = bmp.BitmapAddress();
+	bmp.LockHeap();
+	TUint32* base = bmp.DataAddress();
+	bmp.UnlockHeap();
+
+	TInt scanLineLength = CFbsBitmap::ScanLineLength(aSize.iWidth,aSrcMode);
+	TInt scanLineDestLength = CFbsBitmap::ScanLineLength(aSize.iWidth,aDstMode)*2;
+	TUint8* buffer = new TUint8[scanLineLength];
+	TUint8* doubleBuffer = new TUint8[scanLineDestLength];
+	TPtr8 scanline(buffer,scanLineLength,scanLineLength);
+	TPtr8 doubleScanline(doubleBuffer,scanLineDestLength,scanLineDestLength);
+
+	TInt yy;
+	for(yy = 0; yy < aSize.iHeight; yy++)
+		{
+		bmp.GetScanLine(scanline,TPoint(0,yy),aSize.iWidth,aSrcMode);
+		bmpadd->StretchScanLine(doubleScanline,TPoint(0,yy),0,aSize.iWidth * 2,aSize.iWidth * 2,0,aSize.iWidth,TPoint(0,0),aDstMode,base);
+		for(TInt xx = 0; xx < aSize.iWidth; xx++)
+			{
+			TRgb scanlineColor = ExtractRgb(buffer,xx,aSrcMode);
+			TRgb firstStretchColor = ExtractRgb(doubleBuffer,xx * 2,aDstMode);
+			TRgb secondStretchColor = ExtractRgb(doubleBuffer,(xx * 2) + 1,aDstMode);
+			TRgb reportedColor;
+			bmpadd->GetPixel(reportedColor,TPoint(xx,yy),base,NULL);
+			if (!aUseCompareLikeness)
+				{
+				TEST(scanlineColor == firstStretchColor);
+				TEST(firstStretchColor == secondStretchColor);
+				TEST(secondStretchColor == reportedColor);
+				}
+			else
+				{
+				if (aDstMode==EColor16M||aDstMode==EColor16MU||aDstMode==EColor64K||aDstMode==EColor4K||aDstMode==EColor256)
+					{
+					//there is no alpha in the destination
+					scanlineColor.SetAlpha(0xff);
+					reportedColor.SetAlpha(0xff);	
+					}	
+				CompareColourLikeness(scanlineColor, firstStretchColor, ColorDifference(aDstMode,scanlineColor.Alpha()));
+				CompareColourLikeness(firstStretchColor, secondStretchColor,ColorDifference(aDstMode,scanlineColor.Alpha()));
+				CompareColourLikeness(secondStretchColor, reportedColor,ColorDifference(aDstMode,scanlineColor.Alpha()));
+				}
+			}
+		}
+
+	for(yy = 0; yy < aSize.iHeight; yy++)
+		{
+		bmp.GetScanLine(scanline,TPoint(0,yy),aSize.iWidth,aSrcMode);
+		bmpadd->StretchScanLine(doubleScanline,TPoint(0,yy),0,aSize.iWidth / 2,aSize.iWidth / 2,0,aSize.iWidth,TPoint(0,0),aDstMode,base);
+		for(TInt xx = 0; xx < aSize.iWidth; xx += 2)
+			{
+			TRgb scanlineColor = ExtractRgb(buffer,xx,aSrcMode);
+			TRgb compressColor = ExtractRgb(doubleBuffer,xx / 2,aDstMode);
+			TRgb reportedColor;
+			bmpadd->GetPixel(reportedColor,TPoint(xx,yy),base,NULL);
+			if (!aUseCompareLikeness)
+				{
+				TEST(scanlineColor == compressColor);
+				TEST(compressColor == reportedColor);
+				}
+			else
+				{
+				if (aDstMode==EColor16M||aDstMode==EColor16MU||aDstMode==EColor64K||aDstMode==EColor4K||aDstMode==EColor256)
+					{
+					//there is no alpha in the destination
+					scanlineColor.SetAlpha(0xff);
+					reportedColor.SetAlpha(0xff);	
+					}
+				CompareColourLikeness(scanlineColor, compressColor,ColorDifference(aDstMode,scanlineColor.Alpha()));
+				CompareColourLikeness(compressColor, reportedColor,ColorDifference(aDstMode,scanlineColor.Alpha()));
+				}
+			}
+		}
+
+	delete [] buffer;
+	delete [] doubleBuffer;
+	buffer = NULL;
+	doubleBuffer = NULL;
+
+	TInt rgbScanLineLength = aSize.iWidth * sizeof(TRgb) * 2;
+	TUint8* rgbBuffer = new TUint8[rgbScanLineLength];
+	TPtr8 rgbScanline(rgbBuffer,rgbScanLineLength,rgbScanLineLength);
+
+	for(yy = 0; yy < aSize.iHeight; yy++)
+		{
+		bmpadd->StretchScanLine(rgbScanline,TPoint(0,yy),0,aSize.iWidth * 2,aSize.iWidth * 2,0,aSize.iWidth,TPoint(0,0),ERgb,base);
+		for(TInt xx = 0; xx < aSize.iWidth; xx++)
+			{
+			TRgb firstStretchColor = ExtractRgb(rgbBuffer,xx * 2,ERgb);
+			TRgb secondStretchColor = ExtractRgb(rgbBuffer,(xx * 2) + 1,ERgb);
+			TRgb reportedColor;
+			bmpadd->GetPixel(reportedColor,TPoint(xx,yy),base,NULL);
+			if (!aUseCompareLikeness)
+				{
+				TEST(firstStretchColor == secondStretchColor);
+				TEST(secondStretchColor == reportedColor);
+				}
+			else
+				{
+				CompareColourLikeness(firstStretchColor, secondStretchColor);
+				CompareColourLikeness(secondStretchColor, reportedColor);
+				}
+			}
+		}
+
+	for(yy = 0; yy < aSize.iHeight; yy++)
+		{
+		bmpadd->StretchScanLine(rgbScanline,TPoint(0,yy),0,aSize.iWidth / 2,aSize.iWidth / 2,0,aSize.iWidth,TPoint(0,0),ERgb,base);
+		for(TInt xx = 0; xx < aSize.iWidth; xx += 2)
+			{
+			TRgb compressColor = ExtractRgb(rgbBuffer,xx / 2,ERgb);
+			TRgb reportedColor;
+			bmpadd->GetPixel(reportedColor,TPoint(xx,yy),base,NULL);
+			if (!aUseCompareLikeness)
+				{
+				TEST(compressColor == reportedColor);
+				}
+			else
+				{
+				CompareColourLikeness(compressColor, reportedColor);
+				}
+			}
+		}
+
+	delete [] rgbBuffer;
+	rgbBuffer = NULL;
+
+	bmp.Reset();
+	User::Heap().Check();
+	DeleteScanLineBuffer();
+	__UHEAP_MARKEND;
+	}
+
+TRgb CTBitmap::ExtractRgb(TUint8* aBuffer,TInt aPixelOffset,TDisplayMode aDispMode)
+	{
+	switch (aDispMode)
+		{
+	case EGray2:
+		{
+		TUint8 byte = *(aBuffer + (aPixelOffset >> 3));
+		if (byte & (1 << (aPixelOffset & 7)))
+			return KRgbWhite;
+		return KRgbBlack;
+		}
+	case EGray4:
+		{
+		TUint8 byte = *(aBuffer + (aPixelOffset >> 2));
+		byte >>= ((aPixelOffset & 3) << 1);
+		return TRgb::Gray4(byte & 3);
+		}
+	case EGray16:
+		{
+		TUint8 byte = *(aBuffer + (aPixelOffset >> 1));
+		if (aPixelOffset & 1)
+			byte >>= 4;
+		return TRgb::Gray16(byte & 0xf);
+		}
+	case EGray256:
+		return TRgb::Gray256(*(aBuffer + aPixelOffset));
+	case EColor16:
+		{
+		TUint8 byte = *(aBuffer + (aPixelOffset >> 1));
+		if (aPixelOffset & 1)
+			byte >>= 4;
+		return TRgb::Color16(byte & 0xf);
+		}
+	case EColor256:
+		return TRgb::Color256(*(aBuffer + aPixelOffset));
+	case EColor4K:
+		{
+		TUint16 doubleByte = *(((TUint16*)aBuffer) + aPixelOffset);
+		return TRgb::Color4K(doubleByte & 0xfff);
+		}
+	case EColor64K:
+		{
+		TUint16 doubleByte = *(((TUint16*)aBuffer) + aPixelOffset);
+		return TRgb::Color64K(doubleByte);
+		}
+	case EColor16M:
+		{
+		aBuffer += aPixelOffset * 3;
+		TInt value = *aBuffer++;
+		value |= *aBuffer++ << 8;
+		value |= *aBuffer << 16;
+		return TRgb::Color16M(value);
+		}
+	case ERgb:
+		return *(((TRgb*)aBuffer) + aPixelOffset);
+	case EColor16MU:
+		{
+		return TRgb::Color16MU(*(((TUint32*)aBuffer) + aPixelOffset));
+		}
+	case EColor16MA:
+		{
+		return TRgb::Color16MA(*(((TUint32*)aBuffer) + aPixelOffset));
+		}	
+	case EColor16MAP:
+		{
+		return TRgb::_Color16MAP(*(((TUint32*)aBuffer) + aPixelOffset));
+		}	
+	default:
+		break;
+		};
+	return KRgbBlack;
+	}
+	
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0523
+
+	@SYMTestCaseDesc
+	Streams a bitmap in segments and compares it
+	to an expected bitmap
+	
+	@SYMTestActions
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::LoadInSegments()
+	{
+	INFO_PRINTF1(_L("Test Segmented Loading"));
+
+	__UHEAP_MARK;
+	CFbsBitmapEx bmp;
+	TInt ret=bmp.Load(iTestBitmapName,ETfbs,NULL);
+	TEST2(ret, KErrNone);
+	CFbsBitmapAsyncStreamer* bmploader=NULL;
+	TRAP(ret,bmploader=CFbsBitmapAsyncStreamer::NewL(CFbsBitmapAsyncStreamer::ELoad));
+	TEST2(ret, KErrNone);
+	TInt slines=0;
+	ret=bmploader->Load(iTestBitmapName,ETfbs,slines);
+	TEST2(ret, KErrNone);
+	TEST(slines>0);
+	CFbsBitmap* newbmp=NULL;
+	TBool done=EFalse;
+	do	{
+		TEST(newbmp==NULL);
+		TRAP(ret,done=bmploader->LoadScanLinesL(slines/10,newbmp));
+		TEST2(ret, KErrNone);
+		}
+	while(!done);
+
+	TEST(newbmp!=NULL);
+	CompareBitmaps(bmp,(CFbsBitmapEx&)*newbmp,EColor16M);
+	delete bmploader;
+	delete newbmp;
+
+	TRAP(ret,iBmpHandler=CFbsBitmapAsyncStreamer::NewL(CFbsBitmapAsyncStreamer::ELoad));
+	TEST2(ret, KErrNone);
+	ret=iBmpHandler->Load(iTestBitmapName,ETfbs,slines);
+	TEST2(ret, KErrNone);
+	TEST(slines>0);
+	CIdle* idleobj=CIdle::New(-20);
+	TEST(idleobj!=NULL);
+	TCallBack callback(BmpLoadCallBack,this);
+	idleobj->Start(callback);
+	
+	CActiveScheduler* as = CActiveScheduler::Current();
+	__ASSERT_DEBUG(as, User::Invariant());
+	
+	TRAP(ret,as->Start());
+	TEST2(ret, KErrNone);
+	
+	CompareBitmaps(bmp,(CFbsBitmapEx&)*iBitmap,EColor16M);
+
+	delete iBmpHandler;
+	delete iBitmap;
+	bmp.Reset();
+	delete idleobj;
+	User::Heap().Check();
+	__UHEAP_MARKEND;
+
+	
+	}
+
+TInt CTBitmap::BmpLoadCallBack(TAny* aPtr)
+	{
+	CTBitmap* tbmp=(CTBitmap*)aPtr;
+	tbmp->INFO_PRINTF1(_L("*"));
+	TBool done=EFalse;
+	TRAPD(ret,done=tbmp->iBmpHandler->LoadScanLinesL(10,tbmp->iBitmap));
+	tbmp->TEST2(ret, KErrNone);
+	if(done)
+		{
+		tbmp->TEST(tbmp->iBitmap!=NULL);
+		CActiveScheduler::Stop();
+		}
+	else 
+		{
+		tbmp->TEST(tbmp->iBitmap==NULL);
+		}
+	return(ETrue);
+	}
+	
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0524
+
+	@SYMTestCaseDesc
+	A bitmap is saved in segments and then read back from file store
+	and compared to an expected bitmap
+
+	@SYMTestActions
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/	
+void CTBitmap::SaveInSegments()
+	{
+	INFO_PRINTF1(_L("Test Segmented Saving"));
+
+	__UHEAP_MARK;
+	CFbsBitmapEx bmp;
+	TInt ret=bmp.Load(iTestBitmapName,ETfbs,NULL);
+	TEST2(ret, KErrNone);
+	CFbsBitmapAsyncStreamer* bmpsaver=NULL;
+	TRAP(ret,bmpsaver=CFbsBitmapAsyncStreamer::NewL(CFbsBitmapAsyncStreamer::ESave));
+	TEST2(ret, KErrNone);
+	TInt slines=0;
+	TInt32 id;
+	ret=bmpsaver->Save(KTempFilename,&bmp,id,slines);
+	TEST2(ret, KErrNone);
+	TEST(id==0);
+	TEST(slines>0);
+	TBool done=EFalse;
+	do	{
+		TRAP(ret,done=bmpsaver->SaveScanLinesL(slines/10));
+		TEST2(ret, KErrNone);
+		}
+	while(!done);
+	delete bmpsaver;
+	CFbsBitmapEx bmp2;
+	ret=bmp2.Load(KTempFilename,id,NULL);
+	TEST2(ret, KErrNone);
+	TUint8 buffer[40];
+	TUint8 bufferst[40];
+	TPtr8 scanline(&buffer[0],40,40);
+	TPtr8 scanlinest(&bufferst[0],40,40);
+	TInt yy=0;
+	for(;yy<80;yy++)
+		{
+		bmp.GetScanLine(scanline,TPoint(0,yy),160,EGray4);
+		bmp2.GetScanLine(scanlinest,TPoint(0,yy),160,EGray4);
+		for(TInt count=0;count<40;count++)
+			TEST(buffer[count]==bufferst[count]);
+		}
+	bmp2.Reset();
+	iFs.Delete(KTempFilename);
+
+	CActiveScheduler* as = CActiveScheduler::Current();
+	__ASSERT_DEBUG(as, User::Invariant());
+
+	TRAP(ret,iBmpHandler=CFbsBitmapAsyncStreamer::NewL(CFbsBitmapAsyncStreamer::ESave));
+	TEST2(ret, KErrNone);
+	ret=iBmpHandler->Save(KTempFilename,&bmp,id,slines);
+	TEST2(ret, KErrNone);
+	TEST(id==0);
+	TEST(slines>0);
+	CIdle* idleobj=CIdle::New(-20);
+	TEST(idleobj!=NULL);
+	TCallBack callback(BmpSaveCallBack,this);
+	idleobj->Start(callback);
+	TRAP(ret,as->Start());
+	TEST2(ret, KErrNone);
+	delete iBmpHandler;
+	ret=bmp2.Load(KTempFilename,id,NULL);
+	TEST2(ret, KErrNone);
+	for(yy=0;yy<80;yy++)
+		{
+		bmp.GetScanLine(scanline,TPoint(0,yy),160,EGray4);
+		bmp2.GetScanLine(scanlinest,TPoint(0,yy),160,EGray4);
+		for(TInt count=0;count<40;count++)
+			TEST(buffer[count]==bufferst[count]);
+		}
+	bmp.Reset();
+	delete idleobj;
+	iFs.Delete(KTempFilename);
+	User::Heap().Check();
+	__UHEAP_MARKEND;
+
+	INFO_PRINTF1(_L("\r\n"));
+	
+	}
+
+TInt CTBitmap::BmpSaveCallBack(TAny* aPtr)
+	{
+	CTBitmap* tbmp=(CTBitmap*)aPtr;
+	tbmp->INFO_PRINTF1(_L("*"));
+	TBool done=EFalse;
+	TRAPD(ret,done=tbmp->iBmpHandler->SaveScanLinesL(10));
+	tbmp->TEST2(ret, KErrNone);
+	if(done) 
+		{
+		CActiveScheduler::Stop();
+		}
+	return(ETrue);
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0525
+
+	@SYMTestCaseDesc
+	Tests if a bitmap is monochrone for different
+	color depths
+
+	@SYMTestActions
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::MonoDetect()
+	{
+	INFO_PRINTF1(_L("Test Mono Detection"));
+
+	DoMonoDetect(EGray2);
+	DoMonoDetect(EGray4);
+	DoMonoDetect(EGray16);
+	DoMonoDetect(EGray256);
+	DoMonoDetect(EColor16);
+	DoMonoDetect(EColor256);
+	DoMonoDetect(EColor4K);
+	DoMonoDetect(EColor64K);
+	DoMonoDetect(EColor16M);
+	DoMonoDetect(EColor16MU);
+	DoMonoDetect(EColor16MAP);
+	}
+
+void CTBitmap::DoMonoDetect(TDisplayMode aDisplayMode)
+	{
+	CFbsBitmapEx bmp;
+	TInt ret = bmp.Create(TSize(100,3),aDisplayMode);
+	TEST2(ret, KErrNone);
+
+	CBitwiseBitmap* bmpadd = bmp.BitmapAddress();
+	bmp.LockHeap();
+	TUint32* base = bmp.DataAddress();
+	bmp.UnlockHeap();
+	TUint32* data = bmpadd->ScanLineAddress(base,1);
+
+	if(aDisplayMode == EColor16M)
+		{
+		*(data+1) = 0x0000FFFF;
+		*(data+2) = 0xFFFFFF00;
+		//Pixel at (data + 1). Bytes (3) and (2) are part of the pixel at (data) addr.
+		//LSB                        MSB
+		//3        2        1        0
+		//FF       FF       00       00  
+		//Pixel at (data + 2). Byte (3) is part of the pixel at (data + 1) addr.
+		//LSB                        MSB
+		//3        2        1        0
+		//00       FF       FF       FF
+		}
+	else
+		{
+		*(data+1) = 0;
+		}
+	TBool mono = bmp.IsMonochrome();
+	TEST(mono);
+
+	*(data+1) = 0x1234abcd;
+	mono = bmp.IsMonochrome();
+	if (aDisplayMode == EGray2)
+		TEST(mono);
+	else
+		TEST(!mono);
+
+	if(aDisplayMode == EColor16M)
+		{
+		*(data+1) = 0xffffffff;
+		*(data+2) = 0xffffffff;
+		}
+	else
+		{
+		*(data+1) = 0xffffffff;
+		}
+	mono=bmp.IsMonochrome();
+	TEST(mono);
+
+	bmp.Reset();
+	}
+
+
+#if defined(__WINS__)
+// these are patchable constants defined in fbscli.dll but on the emulator
+// it's not possible to import them so they are re-defined here
+const TInt KFbServLargeChunkGrowByShifter = 1;
+const TInt KFbServLargeChunkSizeShifter = 2;
+const TInt KFbServLargeChunkMinPhysicalSize = 0x4000;
+#elif defined(__X86GCC__)
+IMPORT_D extern const TInt KFbServLargeChunkGrowByShifter;
+IMPORT_D extern const TInt KFbServLargeChunkSizeShifter;
+IMPORT_D extern const TInt KFbServLargeChunkMinPhysicalSize;
+#endif
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0526
+
+	@SYMTestCaseDesc
+	Allocates different sized chunks of memory
+	in a loop and frees them
+
+	@SYMTestActions
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::ChunkPileL()
+	{
+	INFO_PRINTF1(_L("Test Chunk Pile"));
+
+	TInt virtualSize = 0x4000000;
+	RChunk chunk;
+	TInt ret = chunk.CreateDisconnectedGlobal(_L("TFbsLargeChunk"), 0, 0, virtualSize);
+	TEST2(ret, KErrNone);
+	CleanupClosePushL(chunk);
+	TInt pageSize = 0;
+	HAL::Get(HAL::EMemoryPageSize, pageSize);
+	TEST(pageSize == 4096);
+	TUint8* chunkSmallBase = chunk.Base() + pageSize;
+	TUint8* chunkLargeBase = chunk.Base() + (virtualSize >> KFbServLargeChunkSizeShifter);
+
+	CChunkPile* cp=NULL;
+	TRAP(ret, cp = CChunkPile::NewL(chunk));
+	TEST2(ret, KErrNone);
+	TEST(cp!=NULL);
+	CleanupStack::PushL(cp);
+	TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize);
+
+	TUint8* chunkalloc[16];
+	TInt size[16];
+	for (TInt i = 0; i < 64; ++i)
+		{
+		chunkalloc[0] = cp->Alloc(size[0] = 512);
+		TEST(chunkalloc[0] == chunkSmallBase);
+		chunkalloc[1] = cp->Alloc(size[1] = 8);
+		TEST(chunkalloc[1] == chunkalloc[0] + size[0]);
+		chunkalloc[2] = cp->Alloc(size[2] = 128);
+		TEST(chunkalloc[2] == chunkalloc[1] + size[1]);
+		chunkalloc[3] = cp->Alloc(size[3] = 372);
+		TEST(chunkalloc[3] == chunkalloc[2] + size[2]);
+		chunkalloc[4] = cp->Alloc(size[4] = 256);
+		TEST(chunkalloc[4] == chunkalloc[3] + size[3]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize);
+		// now we should have [0], [1], [2], [3], [4]
+
+		cp->Free(chunkalloc[2]);
+		cp->Free(chunkalloc[3]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize);
+		chunkalloc[5] = cp->Alloc(size[5] = size[2] + size[3]);
+		TEST(chunkalloc[5] == chunkalloc[2]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize);
+		// now we should have [0], [1], [5], [4]
+
+		chunkalloc[6] = cp->Alloc(size[6] = 4);
+		TEST(chunkalloc[6] == chunkalloc[4] + size[4]);
+		chunkalloc[7] = cp->Alloc(size[7] = 1024);
+		TEST(chunkalloc[7] == chunkalloc[6] + size[6]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize);
+		cp->Free(chunkalloc[7]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize);
+		// now we should have [0], [1], [5], [4], [6]
+
+		cp->Free(chunkalloc[1]);
+		cp->Free(chunkalloc[0]);
+		cp->Free(chunkalloc[4]);
+		cp->Free(chunkalloc[5]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize);
+		chunkalloc[8] = cp->Alloc(size[8] = size[0] + size[1] + size[4] + size[5] - 32);
+		TEST(chunkalloc[8] == chunkalloc[0]);
+		chunkalloc[9] = cp->Alloc(size[9] = 32);
+		TEST(chunkalloc[9] == chunkalloc[8] + size[8]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize);
+		// now we should have [8], [9], [6]
+
+		chunkalloc[10] = cp->Alloc(size[10] = KFbServLargeChunkMinPhysicalSize - size[6] - size[8] - size[9]);
+		TEST(chunkalloc[10] == chunkalloc[6] + size[6]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize);
+		chunkalloc[11] = cp->Alloc(size[11] = 16);
+		TEST(chunkalloc[11] == chunkalloc[10] + size[10]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize + (pageSize << KFbServLargeChunkGrowByShifter));
+		chunkalloc[12] = cp->Alloc(size[12] = ((pageSize << KFbServLargeChunkGrowByShifter) - 16) / 2);
+		TEST(chunkalloc[12] == chunkalloc[11] + size[11]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize + (pageSize << KFbServLargeChunkGrowByShifter));
+		chunkalloc[13] = cp->Alloc(size[13] = size[12]);
+		TEST(chunkalloc[13] == chunkalloc[12] + size[12]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize + (pageSize << KFbServLargeChunkGrowByShifter));
+		chunkalloc[14] = cp->Alloc(size[14] = pageSize << KFbServLargeChunkGrowByShifter);
+		TEST(chunkalloc[14] == chunkalloc[13] + size[13]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize + 2 * (pageSize << KFbServLargeChunkGrowByShifter));
+		chunkalloc[15] = cp->Alloc(size[15] = (pageSize << KFbServLargeChunkGrowByShifter) + 4);
+		TEST(chunkalloc[15] == chunkalloc[14] + size[14]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize + 4 * (pageSize << KFbServLargeChunkGrowByShifter));
+		// now we should have [8], [9], [6], [10], [11], [12], [13], [14], [15]
+
+		cp->Free(chunkalloc[15]);
+		cp->Free(chunkalloc[14]);
+		cp->Free(chunkalloc[13]);
+		cp->Free(chunkalloc[12]);
+		cp->Free(chunkalloc[11]);
+		cp->Free(chunkalloc[10]);
+		cp->Free(chunkalloc[9]);
+		cp->Free(chunkalloc[8]);
+		cp->Free(chunkalloc[6]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize);
+
+		TEST(cp->Alloc(virtualSize) == NULL);
+
+		TInt largeSize = 4 * pageSize;
+		chunkalloc[0] = cp->Alloc(size[0] = 2 * largeSize);
+		TEST(chunkalloc[0] == chunkLargeBase);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize + size[0]);
+		chunkalloc[1] = cp->Alloc(2 * largeSize + 1);
+		size[1] = 2 * largeSize + pageSize;
+		TEST(chunkalloc[1] == chunkalloc[0] + size[0]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize + size[0] + size[1]);
+		chunkalloc[2] = cp->Alloc(size[2] = 3 * largeSize + pageSize);
+		TEST(chunkalloc[2] == chunkalloc[1] + size[1]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize + size[0] + size[1] + size[2]);
+		// now we should have [0], [1], [2]
+
+		cp->Free(chunkalloc[1]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize + size[0] + size[2]);
+		chunkalloc[3] = cp->Alloc(largeSize + 1);
+		size[3] = largeSize + pageSize;
+		TEST(chunkalloc[3] == chunkalloc[1]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize + size[0] + size[2] + size[3]);
+		chunkalloc[4] = cp->Alloc(size[4] = largeSize);
+		TEST(chunkalloc[4] == chunkalloc[3] + size[3]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize + size[0] + size[2] + size[3] + size[4]);
+		chunkalloc[5] = cp->Alloc(size[5] = 64 * largeSize);
+		TEST(chunkalloc[5] == chunkalloc[2] + size[2]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize + size[0] + size[2] + size[3] + size[4] + size[5]);
+		// now we should have [0], [3], [4], [2], [5]
+
+		cp->Free(chunkalloc[0]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize + size[2] + size[3] + size[4] + size[5]);
+		cp->Free(chunkalloc[2]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize + size[3] + size[4] + size[5]);
+		cp->Free(chunkalloc[3]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize + size[4] + size[5]);
+		cp->Free(chunkalloc[4]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize + size[5]);
+		cp->Free(chunkalloc[5]);
+		TEST(chunk.Size() == KFbServLargeChunkMinPhysicalSize);
+		}
+
+	CleanupStack::PopAndDestroy(2, &chunk); // cp, chunk
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0527
+
+	@SYMTestCaseDesc
+	Creates large bitmaps of different colour depth. 
+
+	@SYMTestActions
+	The bitmaps allocated are too big so
+	the allocation should fail.
+	
+	@SYMTestExpectedResults
+	KErrNoMemory when allocating the bitmaps. 
+*/
+void CTBitmap::LargeBitmaps()
+	{
+	INFO_PRINTF1(_L("Test Large Bitmaps"));
+
+	TMemoryInfoV1Buf membuf;
+	UserHal::MemoryInfo(membuf);
+	const TReal maxmem = membuf().iTotalRamInBytes;
+
+	TReal realSize = 0;
+	TInt ret = Math::Sqrt(realSize,maxmem);
+	TEST2(ret, KErrNone);
+	TInt32 size = 0;
+	ret = Math::Int(size,realSize);
+	TEST2(ret, KErrNone);
+
+	DoLargeBitmaps(TSize(size * 8,size),EGray2);
+	DoLargeBitmaps(TSize(size * 4,size),EGray4);
+	DoLargeBitmaps(TSize(size * 2,size),EGray16);
+	DoLargeBitmaps(TSize(size,size),EGray256);
+	DoLargeBitmaps(TSize(size * 2,size),EColor16);
+	DoLargeBitmaps(TSize(size,size),EColor256);
+	DoLargeBitmaps(TSize(size / 2,size),EColor4K);
+	DoLargeBitmaps(TSize(size / 2,size),EColor64K);
+	DoLargeBitmaps(TSize(size / 3,size),EColor16M);
+	DoLargeBitmaps(TSize(size / 4,size),EColor16MU);
+	DoLargeBitmaps(TSize(size / 4,size),EColor16MAP);
+	}
+
+void CTBitmap::DoLargeBitmaps(const TSize& aSize,TDisplayMode aDisplayMode)
+	{
+	CFbsBitmapEx bmp1;
+	TInt ret = bmp1.Create(aSize,aDisplayMode);
+	TEST2(ret, KErrNoMemory);
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0528
+
+	@SYMTestCaseDesc
+	Check error handling for bitmaps above pixel and byte size limits
+
+	@SYMTestActions
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::HugeBitmaps()
+	{
+	// Check error handling for bitmaps above pixel and byte size limits
+	INFO_PRINTF1(_L("Test Huge Bitmaps"));
+
+	const TInt KLargePixelSize = 50000;
+
+	DoHugeBitmaps(TSize(KLargePixelSize * 8,KLargePixelSize),EGray2);
+	DoHugeBitmaps(TSize(KLargePixelSize * 4,KLargePixelSize),EGray4);
+	DoHugeBitmaps(TSize(KLargePixelSize * 2,KLargePixelSize),EGray16);
+	DoHugeBitmaps(TSize(KLargePixelSize,KLargePixelSize),EGray256);
+	DoHugeBitmaps(TSize(KLargePixelSize * 2,KLargePixelSize),EColor16);
+	DoHugeBitmaps(TSize(KLargePixelSize,KLargePixelSize),EColor256);
+	DoHugeBitmaps(TSize(KLargePixelSize / 2,KLargePixelSize),EColor4K);
+	DoHugeBitmaps(TSize(KLargePixelSize / 2,KLargePixelSize),EColor64K);
+	DoHugeBitmaps(TSize(KLargePixelSize / 3,KLargePixelSize),EColor16M);
+	DoHugeBitmaps(TSize(KLargePixelSize / 4,KLargePixelSize),EColor16MU);
+	DoHugeBitmaps(TSize(KLargePixelSize / 4,KLargePixelSize),EColor16MAP);
+	}
+
+void CTBitmap::DoHugeBitmaps(const TSize& aSize,TDisplayMode aDisplayMode)
+	{
+	const TInt KMaxPixelSize = KMaxTInt / 4 + 1;
+
+	CFbsBitmap bmp;
+
+	TInt ret = bmp.Create(TSize(aSize.iWidth / 2,aSize.iHeight / 2),aDisplayMode);
+	TEST2(ret, KErrNoMemory);
+
+	ret = bmp.Create(aSize,aDisplayMode);
+	TEST2(ret, KErrTooBig);
+
+	ret = bmp.Create(TSize(1,KMaxPixelSize),aDisplayMode);
+	TEST2(ret, KErrTooBig);
+
+	ret = bmp.Create(TSize(KMaxPixelSize,1),aDisplayMode);
+	TEST2(ret, KErrTooBig);
+
+	ret = bmp.Create(TSize(KMaxPixelSize,KMaxPixelSize),aDisplayMode);
+	TEST2(ret, KErrTooBig);
+
+	ret = bmp.Create(TSize(KMaxTInt,KMaxTInt),aDisplayMode);
+	TEST2(ret, KErrTooBig);
+
+
+	ret = bmp.Create(TSize(1,1),aDisplayMode);
+	TEST2(ret, KErrNone);
+
+	ret = bmp.Resize(TSize(aSize.iWidth / 2,aSize.iHeight / 2));
+	TEST2(ret, KErrNoMemory);
+
+	ret = bmp.Resize(aSize);
+	TEST2(ret, KErrTooBig);
+
+	ret = bmp.Resize(TSize(1,KMaxPixelSize));
+	TEST2(ret, KErrTooBig);
+
+	ret = bmp.Resize(TSize(KMaxPixelSize,1));
+	TEST2(ret, KErrTooBig);
+
+	ret = bmp.Resize(TSize(KMaxPixelSize,KMaxPixelSize));
+	TEST2(ret, KErrTooBig);
+
+	ret = bmp.Resize(TSize(KMaxTInt,KMaxTInt));
+	TEST2(ret, KErrTooBig);
+
+	bmp.Reset();
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0529
+
+	@SYMTestCaseDesc
+	Resizes a bitmap to a larger size and
+	checks if the new bitmap is as expected
+	
+	@SYMTestActions
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::Resize()
+	{
+	INFO_PRINTF1(_L("Test Resizing"));
+
+	DoResize(EGray2);
+	DoResize(EGray4);
+	DoResize(EGray16);
+	DoResize(EGray256);
+	DoResize(EColor16);
+	DoResize(EColor256);
+	DoResize(EColor4K);
+	DoResize(EColor64K);
+	DoResize(EColor16M);
+	DoResize(EColor16MU);
+	DoResize(EColor16MAP);
+	}
+
+void CTBitmap::DoResize(TDisplayMode aDispMode)
+	{
+	const TSize KBitmapOriginalSize(256,24);
+	const TSize KBitmapLargeSize(288,32);
+	const TSize KBitmapSmallSize(1,1);
+
+	CFbsBitmapEx bmp;
+	TInt ret = bmp.Create(KBitmapOriginalSize,aDispMode);
+	TEST2(ret, KErrNone);
+	bmp.SetSizeInTwips(KBitmapOriginalSize);
+	TEST(bmp.SizeInPixels() == KBitmapOriginalSize);
+	TEST(bmp.SizeInTwips() == KBitmapOriginalSize);
+
+	CBitwiseBitmap* bb = bmp.BitmapAddress();
+	bmp.LockHeap();
+	TUint32* base = bmp.DataAddress();
+	bmp.UnlockHeap();
+
+	TInt scanLineLength = CFbsBitmap::ScanLineLength(256,aDispMode);
+	TInt blockStart = scanLineLength / 4;
+	TInt blockLength = scanLineLength / 2;
+
+	TInt row;
+	for(row = 8; row < 16; row++)
+		{
+		TUint8* bmpadd = (TUint8*)bb->ScanLineAddress(base,row);
+		Mem::FillZ(bmpadd + blockStart,blockLength);
+		}
+
+	ret = bmp.Resize(KBitmapLargeSize);
+	TEST2(ret, KErrNone);
+	TEST(bmp.SizeInPixels() == KBitmapLargeSize);
+	TEST(bmp.SizeInTwips() == KBitmapLargeSize);
+	bb = bmp.BitmapAddress();
+	bmp.LockHeap();
+	base = bmp.DataAddress();
+	bmp.UnlockHeap();
+	scanLineLength = CFbsBitmap::ScanLineLength(288,aDispMode);
+
+	for(row = 0; row < 8; row++)
+		{
+		TUint8* bmpadd=(TUint8*)bb->ScanLineAddress(base,row);
+		CheckWhite(bmpadd,scanLineLength,aDispMode);
+		}
+
+	for(row = 16; row < 32; row++)
+		{
+		TUint8* bmpadd=(TUint8*)bb->ScanLineAddress(base,row);
+		CheckWhite(bmpadd,scanLineLength,aDispMode);
+		}
+
+	for(row = 8; row < 16; row++)
+		{
+		TUint8* bmpadd=(TUint8*)bb->ScanLineAddress(base,row);
+		CheckWhite(bmpadd,blockStart,aDispMode);
+
+		TUint8* ptr = bmpadd + blockStart;
+		TUint8* ptrLimit = ptr + blockLength;
+		while (ptr < ptrLimit)
+			TEST(*ptr++ == 0);
+
+		CheckWhite(ptr,scanLineLength - blockStart - blockLength,aDispMode);
+		}
+
+	ret = bmp.Resize(KBitmapSmallSize);
+	TEST2(ret, KErrNone);
+	TEST(bmp.SizeInPixels() == KBitmapSmallSize);
+	TEST(bmp.SizeInTwips() == KBitmapSmallSize);
+
+	ret = bmp.Resize(KBitmapOriginalSize);
+	TEST2(ret, KErrNone);
+	TEST(bmp.SizeInPixels() == KBitmapOriginalSize);
+	TEST(bmp.SizeInTwips() == KBitmapOriginalSize);
+
+	bmp.Reset();
+	}
+
+void CTBitmap::CheckWhite(TUint8* aData,TInt aDataLength,TDisplayMode aDispMode)
+	{
+	TUint8* dataLimit = aData + aDataLength;
+
+	if (aDispMode != EColor4K)
+		{
+		while (aData < dataLimit)
+			TEST(*aData++ == 0xff);
+		}
+	else
+		{
+		while (aData < dataLimit)
+			{
+			TEST(*aData == 0xff || *aData == 0x0f);
+			aData++;
+			}
+		}
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0530
+
+	@SYMTestCaseDesc
+	Creates BitmapUtil objects and sets the
+	current position to different positions
+	and retrieves and sets the pixels in these
+	and compares it to another Bitmap Util object
+	
+	@SYMTestActions
+
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::BitmapUtil()
+	{
+	INFO_PRINTF1(_L("Test Bitmap Util"));
+
+	TSize bmpUtilSize1(256,4);
+	TSize bmpUtilSize2(256,1);
+	TSize bmpUtilSize3(256,256);
+	TSize bmpUtilSize4(1024,1024);
+
+	INFO_PRINTF1(_L("256x4.. "));
+	DoBitmapUtil(bmpUtilSize1,EGray2);
+	DoBitmapUtil(bmpUtilSize1,EGray4);
+	DoBitmapUtil(bmpUtilSize1,EGray16);
+	DoBitmapUtil(bmpUtilSize1,EGray256);
+	DoBitmapUtil(bmpUtilSize1,EColor16);
+	DoBitmapUtil(bmpUtilSize1,EColor256);
+	DoBitmapUtil(bmpUtilSize1,EColor4K);
+	DoBitmapUtil(bmpUtilSize1,EColor64K);
+	DoBitmapUtil(bmpUtilSize1,EColor16M);
+	DoBitmapUtil(bmpUtilSize1,EColor16MU);
+	DoBitmapUtil(bmpUtilSize1,EColor16MAP);
+
+	INFO_PRINTF1(_L("256x1.. "));
+	DoBitmapUtil(bmpUtilSize2,EGray2);
+	DoBitmapUtil(bmpUtilSize2,EGray4);
+	DoBitmapUtil(bmpUtilSize2,EGray16);
+	DoBitmapUtil(bmpUtilSize2,EGray256);
+	DoBitmapUtil(bmpUtilSize2,EColor16);
+	DoBitmapUtil(bmpUtilSize2,EColor256);
+	DoBitmapUtil(bmpUtilSize2,EColor4K);
+	DoBitmapUtil(bmpUtilSize2,EColor64K);
+	DoBitmapUtil(bmpUtilSize2,EColor16M);
+	DoBitmapUtil(bmpUtilSize2,EColor16MU);
+	DoBitmapUtil(bmpUtilSize2,EColor16MAP);
+
+	INFO_PRINTF1(_L("256x256..\n"));
+	DoBitmapUtil(bmpUtilSize3,EGray2);
+	DoBitmapUtil(bmpUtilSize3,EGray4);
+	DoBitmapUtil(bmpUtilSize3,EGray16);
+	DoBitmapUtil(bmpUtilSize3,EGray256);
+	DoBitmapUtil(bmpUtilSize3,EColor16);
+	DoBitmapUtil(bmpUtilSize3,EColor256);
+	DoBitmapUtil(bmpUtilSize3,EColor4K);
+	DoBitmapUtil(bmpUtilSize3,EColor64K);
+	DoBitmapUtil(bmpUtilSize3,EColor16M);
+	DoBitmapUtil(bmpUtilSize3,EColor16MU);
+	DoBitmapUtil(bmpUtilSize3,EColor16MAP);
+		
+    INFO_PRINTF1(_L("Testing wastage bytes in 16M scanlines...\n"));
+	bmpUtilSize1.SetSize(5,13);
+	bmpUtilSize2.SetSize(6,14);
+	bmpUtilSize3.SetSize(7,15);
+	bmpUtilSize4.SetSize(8,16);
+	DoBitmapUtil(bmpUtilSize1,EColor16M);
+	DoBitmapUtil(bmpUtilSize2,EColor16M);
+	DoBitmapUtil(bmpUtilSize3,EColor16M);
+	DoBitmapUtil(bmpUtilSize4,EColor16M);
+
+    /*
+	 * Test code commented out as it results in test case failure. 
+	 * Problem recorded in defect DEF001233.
+	 *
+	INFO_PRINTF1(_L("Testing wastage bits in Gray16 scanlines...\n\n"));
+	bmpUtilSize1.SetSize(4,13);
+	bmpUtilSize2.SetSize(5,14);
+	bmpUtilSize3.SetSize(6,15);
+	bmpUtilSize4.SetSize(7,16);
+	DoBitmapUtil(bmpUtilSize1,EGray16);
+	DoBitmapUtil(bmpUtilSize2,EGray16);
+	DoBitmapUtil(bmpUtilSize3,EGray16);
+	DoBitmapUtil(bmpUtilSize4,EGray16);
+	 */
+	}
+
+void CTBitmap::DoBitmapUtil(const TSize& aSize,TDisplayMode aDispMode)
+	{
+	const TPoint startPoint(aSize.iWidth / 3,aSize.iHeight / 3);
+	const TPoint zeroPoint(0,0);
+
+	CFbsBitmapEx bmp1;
+	TInt ret=bmp1.Create(aSize,aDispMode);
+	TEST2(ret, KErrNone);
+	FillBitmap(bmp1);
+
+
+	const TInt numPixels = ((aSize.iWidth + 31) & ~0x1f) * aSize.iHeight;
+	TInt count1;
+	CFbsBitmapEx bmp2;
+
+	ret=bmp2.Create(aSize,aDispMode);
+	TEST2(ret, KErrNone);
+
+	TBitmapUtil util1(&bmp1);
+	util1.Begin(zeroPoint);
+	TBitmapUtil util2(&bmp2);
+	util2.Begin(zeroPoint,util1);
+
+	TPoint currentPosition;
+	for (currentPosition.iY = 0; currentPosition.iY < aSize.iHeight; currentPosition.iY++)
+		for (currentPosition.iX = 0; currentPosition.iX < aSize.iWidth; currentPosition.iX++)
+			{
+			util1.SetPos(currentPosition);
+			util2.SetPos(currentPosition);
+			TUint32 pixelData = util1.GetPixel();
+			util2.SetPixel(pixelData);
+			}
+	util1.End();
+	util2.End();
+	CompareBitmaps(bmp1,bmp2,EColor16M);
+	bmp2.Reset();
+
+	ret=bmp2.Create(aSize,aDispMode);
+	TEST2(ret, KErrNone);
+	util1.Begin(startPoint);
+	util2.Begin(startPoint,util1);
+	for (count1 = 0; count1 < numPixels; count1++)
+		{
+		util2.SetPixel(util1);
+		util1.IncXPos();
+		util2.IncXPos();
+		}
+	util1.End();
+	util2.End();
+	CompareBitmaps(bmp1,bmp2,EColor16M);
+	bmp2.Reset();
+
+	ret=bmp2.Create(aSize,aDispMode);
+	TEST2(ret, KErrNone);
+	util1.Begin(zeroPoint);
+	util2.Begin(zeroPoint,util1);
+	for (currentPosition.iX = 0; currentPosition.iX < aSize.iWidth; currentPosition.iX++)
+		{
+		for (currentPosition.iY = 0; currentPosition.iY < aSize.iHeight; currentPosition.iY++)
+			{
+			util2.SetPixel(util1);
+			util1.IncYPos();
+			util2.IncYPos();
+			}
+		util1.IncXPos();
+		util2.IncXPos();
+		}
+	util1.End();
+	util2.End();
+	CompareBitmaps(bmp1,bmp2,EColor16M);
+	bmp2.Reset();
+
+	ret=bmp2.Create(aSize,aDispMode);
+	TEST2(ret, KErrNone);
+	util1.Begin(startPoint);
+	util2.Begin(startPoint,util1);
+	for (count1 = 0; count1 < numPixels; count1++)
+		{
+		util2.SetPixel(util1);
+		util1.DecXPos();
+		util2.DecXPos();
+		}
+	util1.End();
+	util2.End();
+	CompareBitmaps(bmp1,bmp2,EColor16M);
+	bmp2.Reset();
+
+	ret=bmp2.Create(aSize,aDispMode);
+	TEST2(ret, KErrNone);
+	util1.Begin(zeroPoint);
+	util2.Begin(zeroPoint,util1);
+	for (currentPosition.iX = 0; currentPosition.iX < aSize.iWidth; currentPosition.iX++)
+		{
+		for (currentPosition.iY = 0; currentPosition.iY < aSize.iHeight; currentPosition.iY++)
+			{
+			util2.SetPixel(util1);
+			util1.DecYPos();
+			util2.DecYPos();
+			}
+		util1.DecXPos();
+		util2.DecXPos();
+		}
+	util1.End();
+	util2.End();
+	CompareBitmaps(bmp1,bmp2,EColor16M);
+	bmp2.Reset();
+
+	bmp1.Reset();
+	}
+
+void CTBitmap::BitmapTiming()
+	{
+	INFO_PRINTF1(_L("Test Timing"));
+
+	CFbsBitmap bmp;
+	TInt ret=bmp.Load(iTestBitmapName,ETfbs,NULL);
+	TEST2(ret, KErrNone);
+
+	CDirectFileStore* writestore=NULL;
+	TRAP(ret,writestore=CDirectFileStore::ReplaceL(iFs,KTempFilename,EFileStream|EFileWrite));
+	TEST2(ret, KErrNone);
+	TUidType uidtype(KDirectFileStoreLayoutUid,KMultiBitmapFileImageUid);
+	TRAP(ret,writestore->SetTypeL(uidtype));
+	TEST2(ret, KErrNone);
+	RStoreWriteStream writestrm;
+	TStreamId headerid(0);
+	TRAP(ret,headerid=writestrm.CreateL(*writestore));
+	TEST2(ret, KErrNone);
+	TRAP(ret,writestore->SetRootL(headerid));
+	TEST2(ret, KErrNone);
+	INFO_PRINTF1(_L("Save time: "));
+	TUint startTime=User::TickCount();
+	for(TInt count=0;count<5000;count++)
+		{
+		TRAP(ret,bmp.ExternalizeL(writestrm));
+		if(ret) break;
+		}
+	TUint stopTime=User::TickCount();
+	TEST2(ret, KErrNone);
+	writestrm.Close();
+	delete writestore;
+	INFO_PRINTF2(_L("%d ticks\r\n"),stopTime-startTime);
+
+	CDirectFileStore* readstore=NULL;
+	TRAP(ret,readstore=CDirectFileStore::OpenL(iFs,KTempFilename,EFileStream|EFileRead));
+	TEST2(ret, KErrNone);
+	RStoreReadStream readstrm;
+	headerid=readstore->Root();
+	INFO_PRINTF1(_L("Load time: "));
+	startTime=User::TickCount();
+	for(TInt count2=0;count2<5000;count2++)
+		{
+		TRAP(ret,readstrm.OpenL(*readstore,headerid));
+		if(ret) break;
+		TRAP(ret,bmp.InternalizeL(readstrm));
+		if(ret) break;
+		readstrm.Close();
+		}
+	stopTime=User::TickCount();
+	TEST2(ret, KErrNone);
+	delete readstore;
+	INFO_PRINTF2(_L("%d ticks\r\n"),stopTime-startTime);
+
+	bmp.Reset();
+	iFs.Delete(KTempFilename);
+
+	
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0531
+
+	@SYMTestCaseDesc
+	Tries to load non existing bitmaps from the
+	Z-drive.
+
+	@SYMTestActions
+
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::InvalidBitmap()
+	{
+	INFO_PRINTF1(_L("Test Invalid Bitmap"));
+
+	__UHEAP_MARK;
+	CFbsBitmapEx bmp;
+
+	TInt ret=bmp.Load(_L("z:\\tfbsx.mbm"),ETfbs,NULL);
+	TEST2(ret, KErrNotFound);
+	ret=bmp.Load(_L("z:\\tfbs.xbm"),ETfbs,NULL);
+	TEST2(ret, KErrNotFound);
+	ret=bmp.Load(iTestBitmapName,999,NULL);
+	TEST2(ret, KErrEof);
+	ret=bmp.Load(iTestBitmapName,-1,NULL);
+	TEST2(ret, KErrEof);
+
+	bmp.Reset();
+	User::Heap().Check();
+	__UHEAP_MARKEND;
+
+	
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0532
+
+	@SYMTestCaseDesc
+	Creates bitmaps and saves them to the C-drive
+	and loads them back again and compares them to
+	the original bitmaps. 
+
+	@SYMTestActions
+	The test uses different colour depths and sizes
+	of the bitmaps. The sizes of the bitmaps are
+	large.
+
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::SaveAndLoad()
+	{
+	INFO_PRINTF1(_L("Test Save/Load Bitmap"));
+
+	const TInt sizes[] = { 1,2,3,4,5,7,8,9,15,16,17,31,32,33,100 };
+	const TInt numSizes = sizeof(sizes) / sizeof(TInt);
+	TSize size;
+
+	for (TInt widthIndex = 0; widthIndex < numSizes; widthIndex++)
+		{
+		INFO_PRINTF3(_L("Index %d/%d\r"), widthIndex + 1, numSizes);
+		size.iWidth = sizes[widthIndex];
+
+		for (TInt heightIndex = 0; heightIndex < numSizes; heightIndex++)
+			{
+			size.iHeight = sizes[heightIndex];
+
+			DoSaveAndLoad(size,EGray2,EFalse);
+			DoSaveAndLoad(size,EGray2,ETrue);
+			DoSaveAndLoad(size,EGray4,EFalse);
+			DoSaveAndLoad(size,EGray4,ETrue);
+			DoSaveAndLoad(size,EGray16,EFalse);
+			DoSaveAndLoad(size,EGray16,ETrue);
+			DoSaveAndLoad(size,EGray256,EFalse);
+			DoSaveAndLoad(size,EGray256,ETrue);
+			DoSaveAndLoad(size,EColor16,EFalse);
+			DoSaveAndLoad(size,EColor16,ETrue);
+			DoSaveAndLoad(size,EColor256,EFalse);
+			DoSaveAndLoad(size,EColor256,ETrue);
+			DoSaveAndLoad(size,EColor4K,EFalse);
+			DoSaveAndLoad(size,EColor4K,ETrue);
+			DoSaveAndLoad(size,EColor64K,EFalse);
+			DoSaveAndLoad(size,EColor64K,ETrue);
+			DoSaveAndLoad(size,EColor16M,EFalse);
+			DoSaveAndLoad(size,EColor16M,ETrue);
+			DoSaveAndLoad(size,EColor16MU,EFalse);
+			DoSaveAndLoad(size,EColor16MU,ETrue);
+			DoSaveAndLoad(size,EColor16MAP,EFalse);
+			DoSaveAndLoad(size,EColor16MAP,ETrue);
+			}
+		}
+
+	INFO_PRINTF1(_L("\r\n"));
+	
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0533
+
+	@SYMTestCaseDesc
+	Creates bitmaps and saves them to the C-drive
+	and loads them back again and compares them to
+	the original bitmaps. 
+
+	@SYMTestActions
+	The test uses different colour depths and sizes
+	of the bitmaps. The sizes of the bitmaps are
+	small.
+
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::SaveAndLoadFast()
+	{
+	INFO_PRINTF1(_L("Test Save/Load Fast Bitmap"));
+
+	// Keep this array small as the test time increases with n^2
+	// This way we can put in bigger sizes...
+	const TInt sizes[] = { 501, 107, 213 };
+	const TInt numSizes = sizeof(sizes) / sizeof(TInt);
+	TSize size;
+
+	for (TInt widthIndex = 0; widthIndex < numSizes; widthIndex++)
+		{
+		INFO_PRINTF3(_L("Index %d/%d\r"), widthIndex + 1, numSizes);
+		size.iWidth = sizes[widthIndex];
+
+		for (TInt heightIndex = 0; heightIndex < numSizes; heightIndex++)
+			{
+			size.iHeight = sizes[heightIndex];
+
+			DoSaveAndLoad(size,EGray2,EFalse);
+			DoSaveAndLoad(size,EGray2,ETrue);
+			DoSaveAndLoad(size,EGray4,EFalse);
+			DoSaveAndLoad(size,EGray4,ETrue);
+			DoSaveAndLoad(size,EGray16,EFalse);
+			DoSaveAndLoad(size,EGray16,ETrue);
+			DoSaveAndLoad(size,EGray256,EFalse);
+			DoSaveAndLoad(size,EGray256,ETrue);
+			DoSaveAndLoad(size,EColor16,EFalse);
+			DoSaveAndLoad(size,EColor16,ETrue);
+			DoSaveAndLoad(size,EColor256,EFalse);
+			DoSaveAndLoad(size,EColor256,ETrue);
+			DoSaveAndLoad(size,EColor4K,EFalse);
+			DoSaveAndLoad(size,EColor4K,ETrue);
+			DoSaveAndLoad(size,EColor64K,EFalse);
+			DoSaveAndLoad(size,EColor64K,ETrue);
+			DoSaveAndLoad(size,EColor16M,EFalse);
+			DoSaveAndLoad(size,EColor16M,ETrue);
+			DoSaveAndLoad(size,EColor16MU,EFalse);
+			DoSaveAndLoad(size,EColor16MU,ETrue);
+			DoSaveAndLoad(size,EColor16MAP,EFalse);
+			DoSaveAndLoad(size,EColor16MAP,ETrue);
+			}
+		}
+
+	INFO_PRINTF1(_L("\r\n"));
+	
+	}
+
+
+void CTBitmap::DoSaveAndLoad(const TSize& aSize,TDisplayMode aDispMode,TBool aBlank)
+	{
+	CFbsBitmapEx bmp1;
+	bmp1.Create(aSize,aDispMode);
+
+	if (aBlank)
+		BlankBitmap(bmp1);
+	else
+		FillBitmap(bmp1);
+
+	TInt ret = bmp1.Save(KTempFilename);
+	TEST2(ret, KErrNone);
+
+	CFbsBitmapEx bmp2;
+	ret = bmp2.Load(KTempFilename);
+	TEST2(ret, KErrNone);
+
+	CompareBitmaps(bmp1,bmp2,EColor16M);
+
+	ret = bmp2.Compress();
+	TEST2(ret, KErrNone);
+
+	CompareBitmaps(bmp1,bmp2,EColor16M);
+
+	iFs.Delete(KTempFilename);
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0534
+
+	@SYMTestCaseDesc
+	Compresses bitmaps to ROM and RAM
+
+	@SYMTestActions
+	Tries to compress a bitmap in ROM and expects it to fail. 
+	Compresses a bitmap in RAM and expect it to succeed. 
+	Compression tested when executed in the background.
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::Compress()
+	{
+	INFO_PRINTF1(_L("Test Compression"));
+
+	CFbsBitmap bmp;
+	RFbsSession* fbs = RFbsSession::GetSession();
+	TRequestStatus rs;
+
+	if(!iSkipRomBitmapTests)
+		{
+		INFO_PRINTF1(_L("check compressing of ROM files causes error"));
+
+		TInt ret=bmp.Load(KRomBitmap,ETfbs,NULL);
+		TEST2(ret, KErrNone);
+
+		ret = bmp.Compress();
+		TEST2(ret, KErrAccessDenied); //cannot compress bitmaps in ROM
+
+		ret = bmp.CompressInBackground();
+		TEST2(ret, KErrAccessDenied); //cannot compress bitmaps in ROM
+
+		bmp.CompressInBackground(rs);
+		User::WaitForRequest(rs);
+		TEST2(rs.Int(), KErrAccessDenied); //cannot compress bitmaps in ROM
+
+		ret = bmp.Save(KTempFilename);
+		TEST2(ret, KErrNone);
+		bmp.Reset();
+
+		ret = bmp.Load(KTempFilename);
+		TEST2(ret, KErrNone);
+
+		ret = bmp.Compress();
+		TEST2(ret, KErrNone);
+		TEST(bmp.IsCompressedInRAM());
+		bmp.Reset();
+
+
+		ret = bmp.Load(KTempFilename);
+		TEST2(ret, KErrNone);
+
+		ret = bmp.CompressInBackground();
+		TEST2(ret, KErrNone);
+
+		fbs->SendCommand(EFbsCompress, 0); // force background compression to execute
+
+		TEST(bmp.IsCompressedInRAM());
+		bmp.Reset();
+
+
+		ret = bmp.Load(KTempFilename);
+		TEST2(ret, KErrNone);
+
+		bmp.CompressInBackground(rs);
+		User::WaitForRequest(rs); // wait until background compression is finished
+		TEST2(rs.Int(), KErrNone);
+
+		TEST(bmp.IsCompressedInRAM());
+		bmp.Reset();
+
+
+		iFs.Delete(KTempFilename);
+
+		}
+
+	INFO_PRINTF1(_L("check compressing of RAM files is OK"));
+	
+		{
+		TInt ret=bmp.Load(KTestBitmapOnC,ETfbs,NULL);
+		if(ret != KErrNone)
+			{
+			INFO_PRINTF1(_L("Could not load "));
+			INFO_PRINTF1(KTestBitmapOnC);
+			INFO_PRINTF1(_L(" Ensure is it copied over and rerun test\n"));
+			User::Panic(_L(""), ret);
+			}
+		
+		ret = bmp.Compress();
+		TEST2(ret, KErrNone);
+
+		TEST(bmp.IsCompressedInRAM());
+			
+		ret = bmp.Save(KTempFilename);
+		TEST2(ret, KErrNone);
+		bmp.Reset();
+
+
+		ret = bmp.Load(KTempFilename);
+		TEST2(ret, KErrNone);
+
+		ret = bmp.Compress();
+		TEST2(ret, KErrNone);
+
+		TEST(bmp.IsCompressedInRAM());
+		bmp.Reset();
+
+
+		ret = bmp.Load(KTempFilename);
+		TEST2(ret, KErrNone);
+
+		ret = bmp.CompressInBackground();
+		TEST2(ret, KErrNone);
+
+		fbs->SendCommand(EFbsCompress, 0); // force background compression to execute
+
+		TEST(bmp.IsCompressedInRAM());
+		bmp.Reset();
+
+
+		ret = bmp.Load(KTempFilename);
+		TEST2(ret, KErrNone);
+
+		bmp.CompressInBackground(rs);
+		fbs->SendCommand(EFbsCompress, 0); // force background compression to execute
+		User::WaitForRequest(rs);
+		TEST2(rs.Int(), KErrNone);
+
+		TEST(bmp.IsCompressedInRAM());
+		bmp.Reset();
+
+		iFs.Delete(KTempFilename);
+		}
+
+		
+		INFO_PRINTF1(_L("check compressing a created bitmap"));
+		{
+		INFO_PRINTF1(_L("1\r\n"));
+		CFbsBitmapEx bitmap;
+		TInt ret=bitmap.Create(TSize(200,200),EColor256);
+		TEST2(ret, KErrNone);
+		
+		INFO_PRINTF1(_L("2\r\n"));
+		BlankBitmap(bitmap);
+		
+		ret = bitmap.Compress();
+		TEST2(ret, KErrNone);
+		
+		INFO_PRINTF1(_L("3\r\n"));
+		
+		TEST(bitmap.IsCompressedInRAM());
+		}
+	
+	}
+
+void CTBitmap::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 CTBitmap::FillBitmap(CFbsBitmapEx& aBitmap)
+	{
+	TSize size = aBitmap.SizeInPixels();
+	TInt dataLength = CFbsBitmap::ScanLineLength(size.iWidth,aBitmap.DisplayMode()) * size.iHeight;
+
+	aBitmap.LockHeap();
+	TUint8* bmpBits = (TUint8*)aBitmap.DataAddress();
+	aBitmap.UnlockHeap();
+	TUint8* bmpBitsLimit = bmpBits + dataLength;
+	TInt64 seed = aBitmap.Handle();
+
+	switch (aBitmap.DisplayMode())
+		{
+		case EColor4K:
+			Mem::FillZ(bmpBits,dataLength);
+
+			while (bmpBits < bmpBitsLimit)
+				{
+				*bmpBits++ = (TUint8)Math::Rand(seed);
+				*bmpBits++ = (TUint8)(Math::Rand(seed) & 0x0f);
+				}	
+			break;
+		case EColor16MAP:
+			while (bmpBits < bmpBitsLimit)
+				{
+				TUint32 alpha = (TUint8)Math::Rand(seed);
+				TUint32 red = 	(TUint8)Math::Rand(seed);
+				TUint32 green = (TUint8)Math::Rand(seed);
+				TUint32 blue =  (TUint8)Math::Rand(seed);
+				red = ((red * alpha)/255)&0xff;
+				green  = ((green * alpha)/255)&0xff;
+				blue = ((blue * alpha)/255)&0xff;
+				*(TUint32*)bmpBits = (alpha<<24)|(red<<16)|(green<<8)|blue;
+				bmpBits+=4;
+				}
+			break;
+		default:
+			while (bmpBits < bmpBitsLimit)
+				*bmpBits++ = (TUint8)Math::Rand(seed);
+			break;	
+		}	
+	}
+
+void CTBitmap::StripeBitmap(CFbsBitmapEx& aBitmap) // Compression friendly bitmap filling
+	{
+	TSize size = aBitmap.SizeInPixels();
+	TInt dataLength = CFbsBitmap::ScanLineLength(size.iWidth,aBitmap.DisplayMode()) * size.iHeight;
+
+	aBitmap.LockHeap();
+	TUint8* bmpBits = (TUint8*)aBitmap.DataAddress();
+	aBitmap.UnlockHeap();
+	TUint8* bmpBitsLimit = bmpBits + dataLength;
+	TInt64 seed = aBitmap.Handle();
+
+	if (aBitmap.DisplayMode() != EColor4K)
+		{
+		while (bmpBits < bmpBitsLimit)
+			{
+			TUint8* tempBmpBitsLimit = Min(bmpBitsLimit, bmpBits + (TUint8)Math::Rand(seed));
+			while (bmpBits < tempBmpBitsLimit)
+				*bmpBits++ = 0;
+			tempBmpBitsLimit = Min(bmpBitsLimit, bmpBits + (TUint8)Math::Rand(seed));
+			while (bmpBits < tempBmpBitsLimit)
+				*bmpBits++ = 0xff;
+			}
+		}
+	else
+		{
+		Mem::FillZ(bmpBits,dataLength);
+
+		while (bmpBits < bmpBitsLimit)
+			{
+			TUint8* tempBmpBitsLimit = Min(bmpBitsLimit, bmpBits + (TUint8)(Math::Rand(seed) * 2));
+			while (bmpBits < tempBmpBitsLimit)
+				{
+				*bmpBits++ = 0;
+				*bmpBits++ = 0;
+				}
+			tempBmpBitsLimit = Min(bmpBitsLimit, bmpBits + (TUint8)Math::Rand(seed));
+			while (bmpBits < tempBmpBitsLimit)
+				{
+				*bmpBits++ = 0xff;
+				*bmpBits++ = 0x0f;
+				}
+			}		
+		}
+	}
+
+void CTBitmap::CompareBitmaps(CFbsBitmapEx& aBmp1,CFbsBitmapEx& aBmp2,TDisplayMode aDispMode)
+	{
+	// We will compare bitmaps that we draw beginning at four different offsets into the bitmap
+	const TInt KTestBitmapOrigins = 4;
+	const TSize bmpSize = aBmp1.SizeInPixels();
+	TEST(bmpSize == aBmp2.SizeInPixels());
+	TInt originIndex = 0;
+	
+	// Call DoCompareBitmaps() for four different origins
+	for(TInt ii=0;ii<KTestBitmapOrigins;ii++)
+		{
+		TInt xCoord = originIndex*(bmpSize.iWidth/4);
+		TInt yCoord = originIndex*(bmpSize.iHeight/4);
+		DoCompareBitmaps(aBmp1,aBmp2,aDispMode,TPoint(xCoord, yCoord), bmpSize);
+		originIndex++;
+		}
+	}
+	
+void CTBitmap::DoCompareBitmaps(CFbsBitmapEx& aBmp1,CFbsBitmapEx& aBmp2,TDisplayMode aDispMode, TPoint aLineOrigin, TSize aBmpSize)
+	{
+	// Compares two bitmaps line by line
+	const TInt KBitmapWidth = aBmpSize.iWidth;
+	const TInt KStartRow = aLineOrigin.iY;
+	const TInt KBitmapHeight = aBmpSize.iHeight;
+	
+	HBufC8* buf1 = HBufC8::NewMax(KBitmapWidth * 4);
+	HBufC8* buf2 = HBufC8::NewMax(KBitmapWidth * 4);
+	TEST(buf1 && buf2);
+
+	TPtr8 des1(buf1->Des());
+	TPtr8 des2(buf2->Des());
+	
+	for (TInt row = KStartRow; row < KBitmapHeight; row++) 
+		{
+		aBmp1.GetScanLine(des1,aLineOrigin,KBitmapWidth,aDispMode); 
+		aBmp2.GetScanLine(des2,aLineOrigin,KBitmapWidth,aDispMode);
+
+		const TInt ret = des1.Compare(des2);
+		if (ret!=0)
+			{
+			 INFO_PRINTF2(_L("Bitmap comparison failed, row %d differernt!\n"), row);
+			 aBmp1.Save(KFail1Filename);
+			 aBmp2.Save(KFail2Filename);
+			}
+		TEST(ret == 0);
+		}
+
+	delete buf1;
+	delete buf2;
+	}
+
+void CTBitmap::CopyBitmap(CFbsBitmapEx& aBmp1,const CFbsBitmapEx& aBmp2)
+	{
+	TSize bmp1size = aBmp1.SizeInPixels();
+	TSize bmp2size = aBmp2.SizeInPixels();
+	TInt bmp1dataLength = CFbsBitmap::ScanLineLength(bmp1size.iWidth,aBmp1.DisplayMode()) * bmp1size.iHeight;
+	TInt bmp2dataLength = CFbsBitmap::ScanLineLength(bmp2size.iWidth,aBmp2.DisplayMode()) * bmp2size.iHeight;
+	TEST(bmp1dataLength == bmp2dataLength);
+	aBmp1.LockHeap();
+	TUint32* bmp1Bits = aBmp1.DataAddress();
+	aBmp1.UnlockHeap();
+	aBmp2.LockHeap();
+	TUint32* bmp2Bits = aBmp2.DataAddress();
+	aBmp2.UnlockHeap();
+	Mem::Copy((TUint8*)bmp1Bits,(TUint8*)bmp2Bits,bmp1dataLength);
+	}
+
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0535
+
+	@SYMTestCaseDesc
+	Loads and copies bitmaps and does a
+	fuzzy compare on the bitmaps using 
+	scan lines
+
+	@SYMTestActions
+
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::Color256BitmapUtil()
+	{
+	INFO_PRINTF1(_L("Test CFbsColor256BitmapUtil"));
+
+	CFbsBitmapEx bmpRefDitherFs;
+	TInt ret=bmpRefDitherFs.Load(_L("z:\\system\\data\\8bitDitherFS.mbm"));
+	TEST2(ret, KErrNone);
+
+	CFbsBitmapEx bmpRefNoDither;
+	ret=bmpRefNoDither.Load(_L("z:\\system\\data\\8bitNoDither.mbm"));
+	TEST2(ret, KErrNone);
+
+	TSize size = bmpRefNoDither.SizeInPixels();
+
+	CFbsColor256BitmapUtil* util = NULL;
+	TRAP(ret, util=CFbsColor256BitmapUtil::NewL(NULL));
+	TEST2(ret, KErrNone);
+
+	CFbsBitmapEx bmp2;
+	ret = bmp2.Create(size,EColor256);
+	TEST2(ret, KErrNone);
+
+	CFbsBitmapEx bmp1;
+
+	INFO_PRINTF1(_L("EColor256 "));
+
+	ret = util->CopyBitmap(&bmp2,&bmpRefNoDither,CFbsColor256BitmapUtil::ENoDither);
+	TEST2(ret, KErrNone);
+	CompareBitmaps(bmpRefNoDither,bmp2,EColor16M);
+	ret = util->CopyBitmap(&bmp2,&bmpRefDitherFs,CFbsColor256BitmapUtil::EFloydSteinberg);
+	TEST2(ret, KErrNone);
+	CompareBitmaps(bmpRefDitherFs,bmp2,EColor16M);
+
+	INFO_PRINTF1(_L("EColor4K "));
+
+	ret=bmp1.Load(_L("z:\\system\\data\\12bit.mbm"));
+	TEST2(ret, KErrNone);
+	ret = util->CopyBitmap(&bmp2,&bmp1,CFbsColor256BitmapUtil::ENoDither);
+	TEST2(ret, KErrNone);
+	CompareBitmaps(bmpRefNoDither,bmp2,EColor16M);
+	ret = util->CopyBitmap(&bmp2,&bmp1,CFbsColor256BitmapUtil::EFloydSteinberg);
+	TEST2(ret, KErrNone);
+	FuzzyCompareBitmapsColor256(bmpRefNoDither,bmp2,23);
+
+	INFO_PRINTF1(_L("EColor64K "));
+
+	ret=bmp1.Load(_L("z:\\system\\data\\16bit.mbm"));
+	TEST2(ret, KErrNone);
+	ret = util->CopyBitmap(&bmp2,&bmp1,CFbsColor256BitmapUtil::ENoDither);
+	TEST2(ret, KErrNone);
+	CompareBitmaps(bmpRefNoDither,bmp2,EColor16M);
+	ret = util->CopyBitmap(&bmp2,&bmp1,CFbsColor256BitmapUtil::EFloydSteinberg);
+	TEST2(ret, KErrNone);
+	FuzzyCompareBitmapsColor256(bmpRefNoDither,bmp2,28);
+
+	INFO_PRINTF1(_L("EColor16M\r\n"));
+
+	ret=bmp1.Load(_L("z:\\system\\data\\24bit.mbm"));
+	TEST2(ret, KErrNone);
+	ret = util->CopyBitmap(&bmp2,&bmp1,CFbsColor256BitmapUtil::ENoDither);
+	TEST2(ret, KErrNone);
+	CompareBitmaps(bmpRefNoDither,bmp2,EColor16M);
+	ret = util->CopyBitmap(&bmp2,&bmp1,CFbsColor256BitmapUtil::EFloydSteinberg);
+	TEST2(ret, KErrNone);
+	FuzzyCompareBitmapsColor256(bmpRefNoDither,bmp2,32);
+
+	INFO_PRINTF1(_L("EColor16MU\r\n"));
+
+	ret=bmp1.Load(_L("z:\\system\\data\\32bit.mbm"));
+	TEST2(ret, KErrNone);
+	ret = util->CopyBitmap(&bmp2,&bmp1,CFbsColor256BitmapUtil::ENoDither);
+	TEST2(ret, KErrNone);
+	CompareBitmaps(bmpRefNoDither,bmp2,EColor16M);
+	ret = util->CopyBitmap(&bmp2,&bmp1,CFbsColor256BitmapUtil::EFloydSteinberg);
+	TEST2(ret, KErrNone);
+	FuzzyCompareBitmapsColor256(bmpRefNoDither,bmp2,32);
+	
+	CFbsBitmapEx bmp3;
+	ret = bmp3.Create(size,EColor16MAP);
+	TEST2(ret, KErrNone);
+	CopyBitmap(bmp3,bmp1);
+	TEST2(ret, KErrNone);
+	ret = util->CopyBitmap(&bmp2,&bmp3,CFbsColor256BitmapUtil::ENoDither);
+	TEST2(ret, KErrNone);
+	//Do not compare bitmaps since there is no reference EColor16MAP image
+	//CompareBitmaps(bmpRefNoDither,bmp2,EColor16M); - testing ensures that
+	//copying succeeds, not accuracy
+	ret = util->CopyBitmap(&bmp2,&bmp3,CFbsColor256BitmapUtil::EFloydSteinberg);
+	TEST2(ret, KErrNone);
+	//Do not compare bitmaps since there is no reference EColor16MAP image
+	//FuzzyCompareBitmapsColor256(bmpRefNoDither,bmp2,32); - testing ensures that
+	//copying succeeds, not accuracy
+	bmp3.Reset();	
+
+//	bmp2.Save(_L("c:\\8bitSaved.mbm"));
+
+	bmp1.Reset();
+	bmp2.Reset();
+	bmpRefNoDither.Reset();
+	bmpRefDitherFs.Reset();
+	delete util;
+
+	
+	}
+
+void CTBitmap::FuzzyCompareBitmapsColor256(CFbsBitmapEx& aBmp1,CFbsBitmapEx& aBmp2,TUint aDifLimit)
+	{
+	TSize bmp1size = aBmp1.SizeInPixels();
+	TSize bmp2size = aBmp2.SizeInPixels();
+	TInt bmp1dataLength = CFbsBitmap::ScanLineLength(bmp1size.iWidth,aBmp1.DisplayMode()) * bmp1size.iHeight;
+	TInt bmp2dataLength = CFbsBitmap::ScanLineLength(bmp2size.iWidth,aBmp2.DisplayMode()) * bmp2size.iHeight;
+	TEST(bmp1dataLength == bmp2dataLength);
+	aBmp1.LockHeap();
+	TUint8* bmp1Bits = (TUint8*)aBmp1.DataAddress();
+	aBmp1.UnlockHeap();
+	aBmp2.LockHeap();
+	TUint8* bmp2Bits = (TUint8*)aBmp2.DataAddress();
+	aBmp2.UnlockHeap();
+
+	TUint totalDifference = 0;
+	TUint difference = 0;
+	while(bmp1dataLength--)
+		{
+		difference = TRgb::Color256((TUint)*(bmp1Bits++)).Difference(TRgb::Color256((TUint)*(bmp2Bits++)));
+		totalDifference+=difference;
+		}
+	TUint avDif = totalDifference/bmp2dataLength;
+	TEST(avDif<=aDifLimit);
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0536
+
+	@SYMTestCaseDesc
+	Creates a hardware bitmap with a size and 
+	display mode for different display modes. 
+
+	@SYMTestActions
+	It checks some bitmap attributes, bitmapHandle,
+	if it is a large bitmap and if the bitmap is in ROM.
+	Creates a 'normal' bitmap with the same size as the 
+	hardware one. Checks it can write to the hardware 
+	bitmap. Checks reuse of a CFbsBitmap for mixture of 
+	hardware and normal bitmaps works.
+
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::HardwareBitmaps()
+	{
+	static const TDisplayMode modes[] =
+		{
+		EGray2,
+		EGray4,
+		EGray16,
+		EGray256,
+		EColor16,
+		EColor256,
+		EColor64K,
+		EColor16M,
+		EColor16MU,
+		EColor4K,
+		EColor16MAP,
+		ENone
+		};
+
+	INFO_PRINTF1(_L("Test Hardware Bitmaps"));
+
+	CFbsBitmapEx bitmap1;
+	// Large bitmap threshold increased from 4K to 64K
+	TSize size(300,300);
+	TDisplayMode displayMode;
+
+	// Try and find a display mode that hardware bitmaps support
+	TInt ret = KErrNotSupported;
+	TInt i=0;
+	while((displayMode=modes[i])!=ENone)
+		{
+		ret = bitmap1.CreateHardwareBitmap(size,displayMode,TUid::Uid(0));
+		if(ret!=KErrNotSupported)
+			{
+			TEST2(ret, KErrNone);
+			break;
+			}
+		i++;
+		}
+
+	if(ret==KErrNotSupported)
+		{
+		// Hardware bitmaps not supported on this device
+		WARN_PRINTF1(_L("...Not Supported"));
+		return;
+		}
+
+	// Check some bitmap attributes
+	TEST(bitmap1.HardwareBitmapHandle()!=NULL);
+	TEST(!bitmap1.IsLargeBitmap());
+	TEST(!bitmap1.IsRomBitmap());
+
+	// Create a 'normal' bitmap the same size as the hardware one
+	CFbsBitmapEx bitmap2;
+	ret = bitmap2.Create(size,displayMode);
+	TEST2(ret, KErrNone);
+	TEST(bitmap2.HardwareBitmapHandle()==NULL);
+	TEST(bitmap2.IsLargeBitmap());
+
+	// Check we can write to the hardware bitmap OK
+	FillBitmap(bitmap1);
+	CopyBitmap(bitmap1,bitmap2);
+	CompareBitmaps(bitmap1,bitmap2,EColor16M);
+
+	// Discard hardware bitmap
+	bitmap1.Reset();
+
+	// Check reuse of a CFbsBitmap for mixture of hardware and normal bitmaps works
+	ret = bitmap2.CreateHardwareBitmap(size,displayMode,TUid::Uid(0));
+	TEST2(ret, KErrNone);
+	ret = bitmap2.Create(TSize(10,10),displayMode);
+	TEST2(ret, KErrNone);
+	ret = bitmap2.CreateHardwareBitmap(size,displayMode,TUid::Uid(0));
+	TEST2(ret, KErrNone);
+	ret = bitmap2.Create(size,displayMode);
+	TEST2(ret, KErrNone);
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0537
+
+	@SYMTestCaseDesc
+	GetScanLine test
+	
+	@SYMDEF INC036062
+
+	@SYMTestActions
+	For each possible display mode it creates a test bitmap
+	and initialize it with the data from the gray bitmap.
+	Then for each possible display mode it calls GetScanLine 
+	on the gray and	test bitmaps and compares the lines.
+		
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::INC036062L()
+//INC036062  -  Optimise masked bitblit for 1 bit greyscale mask case 
+	{
+	INFO_PRINTF1(_L("INC036062"));
+	TDisplayMode displayMode[] = 
+		{
+		EGray2, EGray4, EGray16, EGray256, EColor16, EColor256, 
+		EColor64K, EColor16M, EColor4K, EColor16MU, EColor16MAP
+		};
+	//Two EGray2 test bitmaps with sizes (11, 11) and (121, 121).
+	TSize size[] = 
+		{
+		TSize(11, 11), TSize(121, 121)
+		};
+	//Masks for for the last scanline byte (probably partially initialized)
+	TUint8 mask[sizeof(size)/sizeof(size[0])][sizeof(displayMode)/sizeof(displayMode[0])] = 
+		{
+		//EGray2 EGray4 EGray16 EGray256 EColor16 EColor256 EColor64K EColor16M EColor4K EColor16MU
+		{0x07,   0x3F,  0x0F,   0xFF,    0x0F,    0xFF,     0xFF,     0xFF,     0x0F,    0xFF},
+		{0x01,   0x03,  0x0F,   0xFF,    0x0F,    0xFF,     0xFF,     0xFF,     0x0F,    0xFF}
+		};
+	for(TInt i=0;i<TInt(sizeof(size)/sizeof(size[0]));i++)
+		{
+		//Create EGray2 bitmap
+		CFbsBitmap* bmp = CreateBitmapLC(size[i], EGray2);
+		//GetScanLine test - for each possible display mode: create a test bitmap
+		//and initialize it with the data from the gray bitmap.
+		//After that: for each possible display mode - call GetScanLine on the gray and
+		//test bitmaps and compare the lines.
+		for(TInt m=0;m<TInt(sizeof(displayMode)/sizeof(displayMode[0]));m++)
+			{
+			HBufC8* row1 = HBufC8::NewLC(1000);
+			TPtr8 prow1 = row1->Des();
+			HBufC8* row2 = HBufC8::NewLC(1000);
+			TPtr8 prow2 = row2->Des();
+			//Create test bitmap
+			CFbsBitmap* tbmp = CreateBitmapLC(size[i], displayMode[m], bmp);
+			//Check test bitmap
+			for(TInt m2=0;m2<TInt(sizeof(displayMode)/sizeof(displayMode[0]));m2++)
+				{
+				for(TInt y=0;y<size[i].iHeight;y++)
+					{
+					bmp->GetScanLine(prow1, TPoint(0, y), size[i].iWidth, displayMode[m2]);
+					tbmp->GetScanLine(prow2, TPoint(0, y), size[i].iWidth, displayMode[m2]);
+					TInt len = prow1.Length();
+					TEST(len == prow2.Length());
+					TEST(len > 0);
+					TUint8 b1 = prow1[len - 1];
+					TUint8 b2 = prow2[len - 1];
+					if(mask[i][m2] != 0xFF)
+						{//Not all bits from the last byte are used.
+						TEST((b1 & mask[i][m2]) == (b2 & mask[i][m2]));
+						prow1.SetLength(len - 1);
+						prow2.SetLength(len - 1);
+						}
+					TEST(prow1 == prow2);
+					}//end of - for(TInt y=0;y<size[i].iHeight;y++)
+				}//end of - for(TInt m2=0;m2<(sizeof(displayMode)/sizeof(displayMode[0]));m2++)
+			CleanupStack::PopAndDestroy(tbmp);
+			CleanupStack::PopAndDestroy(row2);
+			CleanupStack::PopAndDestroy(row1);
+			}//end of - for(TInt m=0;m<(sizeof(displayMode)/sizeof(displayMode[0]));m++)
+		CleanupStack::PopAndDestroy(bmp);
+		}//end of - for(TInt i=0;i<(sizeof(size)/sizeof(size[0]));i++)
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0538
+
+	@SYMTestCaseDesc
+	Performance test of INC036062 (GetScanLine test)
+
+	@SYMDEF INC036062
+
+	@SYMTestActions
+		
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::PerformanceTest_INC036062L()
+//INC036062  -  Optimise masked bitblit for 1 bit greyscale mask case 
+	{
+	INFO_PRINTF1(_L("INC036062-Performance Test"));
+	TSize size(143, 143);
+	//Create EGray2 bitmap
+	CFbsBitmap* bmpGray2 = CreateBitmapLC(size, EGray2);
+	//Create EColor64 bitmap
+	CFbsBitmap* bmpEColor64 = CreateBitmapLC(size, EColor64K);
+	//Performance test
+	TDisplayMode displayMode[] = 
+		{
+		EGray2, EGray4, EGray16, EGray256, EColor16, EColor256, 
+		EColor64K, EColor16M, EColor4K, EColor16MU, EColor16MAP
+		};
+	TInt i;
+	HBufC8* row = HBufC8::NewLC(1000);
+	TPtr8 prow = row->Des();
+	for(TInt m=0;m<TInt(sizeof(displayMode)/sizeof(displayMode[0]));m++)
+		{
+		TUint time[2] = {0, 0};
+		CFbsBitmap* pbmp[2] = {bmpGray2, bmpEColor64};
+		for(TInt j=0;j<2;j++)
+			{
+			time[j] = User::TickCount();
+			for(i=0;i<200;i++)
+				{
+				for(TInt y=0;y<size.iHeight;y++)
+					{
+					pbmp[j]->GetScanLine(prow, TPoint(0, y), size.iWidth, displayMode[m]);
+					}
+				}
+			time[j] = User::TickCount() - time[j];
+			}
+		//"Time+" - time with optimized GetScanLine for EGray2 bitmaps
+		//"Time-" - time with GetScanLine for all bitmaps which colour is not EGray2.
+		INFO_PRINTF4(_L("GetScanLine. Mode=%d, Time+ =%d, Time- =%d\r\n"), displayMode[m], time[0], time[1]);
+		}
+	CleanupStack::PopAndDestroy(row);
+	CleanupStack::PopAndDestroy(bmpEColor64);
+	CleanupStack::PopAndDestroy(bmpGray2);
+	}
+
+CFbsBitmap* CTBitmap::CreateBitmapLC(const TSize& aSize, TDisplayMode aMode)
+	{
+	CFbsBitmap* bmp = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(bmp);
+	User::LeaveIfError(bmp->Create(aSize, aMode));
+	//Initialize the bitmap
+	TBitmapUtil bmpUtil(bmp);
+	bmpUtil.Begin(TPoint(0, 0));
+	for(TInt y=0;y<aSize.iHeight;bmpUtil.IncYPos(),y++)
+		{
+		for(TInt x=0;x<aSize.iWidth;bmpUtil.IncXPos(),x++)
+			{
+			TUint32 color = 0;
+			switch(aMode)
+				{
+				case EGray2:
+					color = Math::Random() % 2;
+					break;
+				case EColor64K:
+					color = Math::Random() % 0x10000;
+					break;
+				case EColor16MA:
+					color = Math::Random();
+					break;
+				default:
+					break;
+				}
+			bmpUtil.SetPixel(color);
+			}
+		}
+	bmpUtil.End();
+	return bmp;
+	}
+
+CFbsBitmap* CTBitmap::CreateBitmapLC(const TSize& aSize, TDisplayMode aMode, const CFbsBitmap* aSrcBmp)
+	{
+	CFbsBitmap* tbmp = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(tbmp);
+	User::LeaveIfError(tbmp->Create(aSize, aMode));
+	//Initialize test bitmap
+	HBufC8* row = HBufC8::NewLC(1000);
+	TPtr8 prow = row->Des();
+	for(TInt y=0;y<aSize.iHeight;y++)
+		{
+		aSrcBmp->GetScanLine(prow, TPoint(0, y), aSize.iWidth, aMode);
+		tbmp->SetScanLine(prow, y);
+		}
+	CleanupStack::PopAndDestroy(row);
+	return tbmp;
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0539
+
+	@SYMTestCaseDesc
+	Loads bitmaps from ROM and RAM
+	and does a GetScanLine on the bitmaps
+	and measures the time it takes to do
+	the GetScanLine.
+	
+	@SYMDEF INC037474
+	
+	@SYMTestActions
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::INC037474L()
+//INC037474 - SS66 - CBitwiseBitmap::GenerateLineFromCompressedSixteenBitData() is very slow
+	{
+	TPtrC bmpFile[] =
+		{
+		KBmpCompr12(),
+		KBmpCompr16(),
+		KBmpCompr24(),
+		KBmpCCompr12(),
+		KBmpCCompr16(),
+		KBmpCCompr24()
+		};
+	TPtrC tt[] = {_L("rom"), _L("rom"), _L("rom"), _L("ram"), _L("ram"), _L("ram")};
+	TBool inRam[] = {EFalse, EFalse, EFalse, ETrue, ETrue, ETrue};
+	TInt bpp[] = {12, 16, 24, 12, 16, 24};
+	TDisplayMode targetMode[] = {EColor4K, EColor64K, EColor16M, EColor4K, EColor64K, EColor16M};
+	const TInt KMaxScanLineLen = 800;
+	TBuf8<KMaxScanLineLen> scanLineBuf;
+	for(TInt i=0;i<TInt(sizeof(bmpFile)/sizeof(bmpFile[0]));i++)
+		{
+		if(iSkipRomBitmapTests && !inRam[i])
+			continue;
+		
+		CFbsBitmap* bmp = LoadBitmapLC(bmpFile[i]);
+		if(inRam[i])
+			{
+			User::LeaveIfError(bmp->Compress());
+			}
+		//
+		TDesC& des = tt[i];
+		INFO_PRINTF3(_L("%d bpp %S compressed bitmap, GetScanLine test\r\n"), bpp[i], &des);
+		TSize size = bmp->SizeInPixels();
+		TEST(TInt(size.iWidth * sizeof(TInt16)) <= KMaxScanLineLen);
+		TUint timeStart = User::TickCount();
+		enum {KTestTimes = 15};//Greater KTestTimes values make the test is too slow!
+		for(TInt j=0;j<KTestTimes;j++) 
+			{
+			TPoint startPixel(0, 0);
+			for(TInt k=0;k<size.iHeight;k++)
+				{
+				startPixel.iY = k;
+				bmp->GetScanLine(scanLineBuf, startPixel, size.iWidth, targetMode[i]);
+				}
+			}
+		TUint timeEnd = User::TickCount();
+		INFO_PRINTF4(_L("%d bpp %S compressed bitmap, time = %d\r\n"), bpp[i], &des, timeEnd - timeStart);
+		//
+		CleanupStack::PopAndDestroy(bmp);
+		}
+	}
+
+CFbsBitmap* CTBitmap::LoadBitmapLC(const TDesC& aFileName)
+	{
+	CFbsBitmap* bmp = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(bmp);
+	const TInt err = bmp->Load(aFileName, 0);
+	TEST(err == KErrNone);
+	User::LeaveIfError(err);
+	return bmp;
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0540
+
+	@SYMTestCaseDesc
+	Test to verify defect DEF038286.
+	
+	@SYMDEF DEF038286
+
+	@SYMTestActions
+	Initialized a test bitmap, compresses it
+	and performs a GetScanLine on the compressed
+	bitmap. Checks the color value against an
+	expected value.
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::DEF038286L()
+//DEF038286 - CBitwiseBitmap::GenerateLineFromCompressedSixteenBitData returns wrong clr value	
+	{
+	INFO_PRINTF1(_L("DEF038286 fix test"));
+	//Create test bitmap
+	CFbsBitmap* bmp = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(bmp);
+	const TInt width = 16;
+	const TSize size(width, 1);
+	User::LeaveIfError(bmp->Create(size, EColor64K));
+	//Test bitmap data
+	TUint8 colorVal[width * 2] = 
+	//	 0          1          2          3          4          5          6          7
+		{0x00,0x00, 0x00,0x00, 0x00,0x00, 0x00,0x00, 0x00,0x00, 0x00,0x00, 0x00,0x00, 0x00,0x00,
+	//	 8          9          10         11         12         13         14         15
+	     0x00,0x00, 0x00,0x00, 0x00,0x00, 0xFF,0xFF, 0xFF,0xFF, 0xFF,0xFF, 0xFF,0xFF, 0xFF,0xFF};
+	//Initialize test bitmap
+	TPtr8 ptr(colorVal, width * 2, width * 2);
+	bmp->SetScanLine(ptr, 0);
+	//Compress test bitmap
+	User::LeaveIfError(bmp->Compress());
+	//Check the test data
+	TUint8 colorVal2[width * 2];
+	TPtr8 ptr2(colorVal2, width * 2, width * 2);
+	//test 1
+	colorVal2[0] = colorVal2[1] = colorVal2[2] = colorVal2[3] = 0x12;
+	bmp->GetScanLine(ptr2, TPoint(10, 0), 2, EColor64K);
+	TEST(colorVal2[0] == colorVal[10 * 2] && colorVal2[1] == colorVal[10 * 2 + 1] &&
+		  colorVal2[2] == colorVal[11 * 2] && colorVal2[3] == colorVal[11 * 2 + 1]);
+	//test 2
+	colorVal2[0] = colorVal2[1] = colorVal2[2] = colorVal2[3] = 0x12;
+	bmp->GetScanLine(ptr2, TPoint(10, 0), 1, EColor64K);
+	TEST(colorVal2[0] == colorVal[10 * 2] && colorVal2[1] == colorVal[10 * 2 + 1]);
+	//test 3
+	colorVal2[0] = colorVal2[1] = colorVal2[2] = colorVal2[3] = 0x12;
+	bmp->GetScanLine(ptr2, TPoint(11, 0), 1, EColor64K);
+	TEST(colorVal2[0] == colorVal[11 * 2] && colorVal2[1] == colorVal[11 * 2 + 1]);
+
+	//Destroy test bitmap and data
+	CleanupStack::PopAndDestroy(bmp);
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0541
+
+	@SYMTestCaseDesc
+	Test to verify defect DEF038286.
+	
+	@SYMDEF DEF038286
+
+	@SYMTestActions
+	Initialized a test bitmap, compresses it
+	and performs a GetScanLine on the compressed
+	bitmap. Checks the colour value against an
+	expected value.
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::DEF038286_2L()
+//DEF038286 - CBitwiseBitmap::GenerateLineFromCompressedSixteenBitData returns wrong clr value
+//24 bpp bitmap test
+	{
+	INFO_PRINTF1(_L("DEF038286 fix test. 24 bpp bitmap."));
+	//Create test bitmap
+	CFbsBitmap* bmp = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(bmp);
+	const TInt width = 16;
+	const TSize size(width, 1);
+	User::LeaveIfError(bmp->Create(size, EColor16M));
+	//Test bitmap data
+	TUint8 colorVal[width * 3] = 
+	//	 0               1               2               3               4               5               6			     7
+		{0x00,0x00,0x00, 0x00,0x00,0x00, 0x00,0x00,0x00, 0x00,0x00,0x00, 0x00,0x00,0x00, 0x00,0x00,0x00, 0x00,0x00,0x00, 0x00,0x00,0x00,
+	//	 8               9               10              11              12              13              14              15
+	     0x00,0x00,0x00, 0x00,0x00,0x00, 0x00,0x00,0x00, 0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF};
+	//Initialize test bitmap
+	TPtr8 ptr(colorVal, width * 3, width * 3);
+	bmp->SetScanLine(ptr, 0);
+	//Compress test bitmap
+	User::LeaveIfError(bmp->Compress());
+	//Check the test data
+	TUint8 colorVal2[width * 3];
+	TPtr8 ptr2(colorVal2, width * 3, width * 3);
+	//test 1
+	colorVal2[0] = colorVal2[1] = colorVal2[2] = colorVal2[3] = colorVal2[4] = colorVal2[5] = 0x12;
+	bmp->GetScanLine(ptr2, TPoint(10, 0), 2, EColor16M);
+	TEST(colorVal2[0] == colorVal[10 * 3] && colorVal2[1] == colorVal[10 * 3 + 1] && colorVal2[2] == colorVal[10 * 3 + 2] &&
+		  colorVal2[3] == colorVal[11 * 3] && colorVal2[4] == colorVal[11 * 3 + 1] && colorVal2[5] == colorVal[11 * 3 + 2]);
+	//test 2
+	colorVal2[0] = colorVal2[1] = colorVal2[2] = colorVal2[3] = colorVal2[4] = colorVal2[5] = 0x12;
+	bmp->GetScanLine(ptr2, TPoint(10, 0), 1, EColor16M);
+	TEST(colorVal2[0] == colorVal[10 * 3] && colorVal2[1] == colorVal[10 * 3 + 1] && colorVal2[2] == colorVal[10 * 3 + 2]);
+	//test 3
+	colorVal2[0] = colorVal2[1] = colorVal2[2] = colorVal2[3] = colorVal2[4] = colorVal2[5] = 0x12;
+	bmp->GetScanLine(ptr2, TPoint(11, 0), 1, EColor16M);
+	TEST(colorVal2[0] == colorVal[11 * 3] && colorVal2[1] == colorVal[11 * 3 + 1] && colorVal2[2] == colorVal[11 * 3 + 2]);
+
+	//Destroy test bitmap and data
+	CleanupStack::PopAndDestroy(bmp);
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0542
+
+	@SYMTestCaseDesc
+	Tests the function CFbsBitmap::IsMonochrome()
+
+	@SYMTestActions
+	Loads uncompressed bitmaps and checks
+	them if they are monochrome
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::MonohromeL()
+	{
+	INFO_PRINTF1(_L("Monohrome bitmaps"));
+	TPtrC bitmap_ram[] = 
+		{
+		KMono_M1(),
+		KMono_M2(),
+		KMono_M4(),
+		KMono_M8(),
+		KMono_C4(),
+		KMono_C8(),
+		KMono_C12(),
+		KMono_C16(),
+		KMono_C24(),
+		KMono_C32()
+		};
+	TInt i;
+	//Check monohrome bitmaps
+	//1 bpp bitmap is always monochrome
+	for(i=0;i<TInt(sizeof(bitmap_ram)/sizeof(bitmap_ram[0]));i++)
+		{
+		CFbsBitmap* uncompressedBitmap = NULL;
+		LoadAndNotCompressBitmapLC(uncompressedBitmap, bitmap_ram[i]);
+		TEST(!uncompressedBitmap->IsCompressedInRAM());
+		TBool monochrome = uncompressedBitmap->IsMonochrome();
+		TEST(monochrome);
+		CleanupStack::PopAndDestroy(uncompressedBitmap);
+		}
+	//Modify monohrome bitmaps and check them
+	//1 bpp bitmap is always monochrome
+	for(i=0;i<TInt(sizeof(bitmap_ram)/sizeof(bitmap_ram[0]));i++)
+		{
+		CFbsBitmap* uncompressedBitmap = NULL;
+		LoadAndNotCompressBitmapLC(uncompressedBitmap, bitmap_ram[i]);
+		TEST(!uncompressedBitmap->IsCompressedInRAM());
+		//Change something into the bitmap data
+		uncompressedBitmap->LockHeap(ETrue);
+		TUint32* data = uncompressedBitmap->DataAddress();
+		*data = 0x12345678;
+		uncompressedBitmap->UnlockHeap(ETrue);
+		//Check the bitmap
+		TBool monochrome = uncompressedBitmap->IsMonochrome();
+		TEST(i > 0 ? !monochrome : monochrome);
+		CleanupStack::PopAndDestroy(uncompressedBitmap);
+		}
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0543
+
+	@SYMTestCaseDesc
+	Tests the function CFbsBitmap::GetVerticalScanLine
+
+	@SYMTestActions
+	Gets the bitmap's vertical scanline starting at 
+	a specified x co-ordinate.
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::GetVerticalScanLineL()
+	{
+	INFO_PRINTF1(_L("GetVerticalScanLine()"));
+	TDisplayMode displayMode[] = 
+		{
+		EGray2,
+		EGray4,
+		EGray16,
+		EGray256,
+		EColor16,
+		EColor256,
+		EColor64K,
+		EColor16M,
+		ERgb,
+		EColor4K,
+		EColor16MU,
+		EColor16MAP,
+		};
+	CFbsBitmap* uncompressedBitmap = NULL;
+	LoadAndNotCompressBitmapLC(uncompressedBitmap, KRamBitmap2);
+	TEST(!uncompressedBitmap->IsCompressedInRAM());
+	TSize sizeInPixels = uncompressedBitmap->SizeInPixels();
+	HBufC8* vertScanLine = HBufC8::NewLC(sizeInPixels.iHeight * 4);
+	TPtr8 p = vertScanLine->Des();
+	TDes8& des = p;
+	for(TInt i=0;i<TInt(sizeof(displayMode)/sizeof(displayMode[0]));i++)
+		{
+		TBuf<80> buf;
+		buf.Format(_L("--mode=%d\r\n"), displayMode[i]);
+		INFO_PRINTF1(buf);
+		for(TInt j=0;j<sizeInPixels.iWidth;j++)
+			{
+			uncompressedBitmap->GetVerticalScanLine(des, j, displayMode[i]);
+			}
+		}
+	CleanupStack::PopAndDestroy(vertScanLine);
+	CleanupStack::PopAndDestroy(uncompressedBitmap);
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0544
+	
+	@SYMTestCaseDesc
+	Tests the performance of the function 
+	CFbsBitmap::GetVerticalScanLine
+
+	@SYMTestActions
+	Gets the bitmap's vertical scanline starting at 
+	a specified x co-ordinate and measures the time
+	it takes.
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::GetVerticalScanLinePerformanceL()
+	{
+	INFO_PRINTF1(_L("GetVerticalScanLine() performance"));
+	TDisplayMode displayMode[] = 
+		{
+		EGray2,
+		EGray4,
+		EGray16,
+		EGray256,
+		EColor16,
+		EColor256,
+		EColor64K,
+		EColor16M,
+		ERgb,
+		EColor4K,
+		EColor16MU,
+		EColor16MAP
+		};
+	CFbsBitmap* uncompressedBitmap = NULL;
+	LoadAndNotCompressBitmapLC(uncompressedBitmap, KRamBitmap2);
+	TEST(!uncompressedBitmap->IsCompressedInRAM());
+	TSize sizeInPixels = uncompressedBitmap->SizeInPixels();
+	HBufC8* vertScanLine = HBufC8::NewLC(sizeInPixels.iHeight * 4);
+	TPtr8 p = vertScanLine->Des();
+	TDes8& des = p;
+	TUint time;
+	for(TInt i=0;i<TInt(sizeof(displayMode)/sizeof(displayMode[0]));i++)
+		{
+		time = User::TickCount();
+		for(TInt j=0;j<sizeInPixels.iWidth;j++)
+			{
+			uncompressedBitmap->GetVerticalScanLine(des, j, displayMode[i]);
+			}
+		INFO_PRINTF3(_L("Vert. line. Mode=%d, Time=%d\r\n"), displayMode[i], User::TickCount() - time);
+		}
+	CleanupStack::PopAndDestroy(vertScanLine);
+	CleanupStack::PopAndDestroy(uncompressedBitmap);
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0545
+
+	@SYMTestCaseDesc
+	Test to verify defect DEF071843
+	
+	@SYMDEF DEF071843
+	
+	@SYMTestActions
+	Creates a test bitmap. Initializes it 
+	with test data using SetScanLine. Saves 
+	bitmap and then reloads it and compares 
+	it against expected bitmap.
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::DEF071843_16MAL()
+	{
+	INFO_PRINTF1(_L("DEF071843 fix test. Saving and loading 16MA 32bpp bitmap."));
+	// Create test bitmap
+	CFbsBitmap* bmp = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(bmp);
+	const TInt width = 12;
+	const TSize size(width, 8);
+	User::LeaveIfError(bmp->Create(size, EColor16MA));
+
+	//Test bitmap data - 8 rows of 12 pixels each containing various run lengths
+	TUint8 colorVal0[width * 4] =  // runs: 12
+	//	 0         1         2         3         4         5         6         7         8         9         10        11
+		{0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0};
+	TUint8 colorVal1[width * 4] =  // runs: 1 1 1 1 1 1 1 1 1 1 1 1
+	//	 0         1         2         3         4         5         6         7         8         9         10        11
+		{0,0,0,0,  1,1,1,1,  2,2,2,2,  3,3,3,3,  4,4,4,4,  5,5,5,5,  6,6,6,6,  7,7,7,7,  8,8,8,8,  9,9,9,9,  10,10,10,10,  11,11,11,11};
+	TUint8 colorVal2[width * 4] =  // runs: 1 1 2 1 1 3 1 1 1
+	//	 0         1         2         3         4         5         6         7         8         9         10        11
+		{0,0,0,0,  1,1,1,1,  2,2,2,2,  2,2,2,2,  3,3,3,3,  4,4,4,4,  5,5,5,5,  5,5,5,5,  5,5,5,5,  6,6,6,6,  7,7,7,7,  8,8,8,8};
+	TUint8 colorVal3[width * 4] =   // runs: 1 2 1 3 1 4
+	//	 0         1         2         3         4         5         6         7         8         9         10        11
+		{0,0,0,0,  1,1,1,1,  1,1,1,1,  2,2,2,2,  3,3,3,3,  3,3,3,3,  3,3,3,3,  4,4,4,4,  5,5,5,5,  5,5,5,5,  5,5,5,5,  5,5,5,5};
+	TUint8 colorVal4[width * 4] =   // runs: 2 1 2 2 2 3
+	//	 0         1         2         3         4         5         6         7         8         9         10        11
+		{0,0,0,0,  0,0,0,0,  1,1,1,1,  2,2,2,2,  2,2,2,2,  3,3,3,3,  3,3,3,3,  4,4,4,4,  4,4,4,4,  5,5,5,5,  5,5,5,5,  5,5,5,5};
+	TUint8 colorVal5[width * 4] =   // runs: 3 1 3 2 3
+	//	 0         1         2         3         4         5         6         7         8         9         10        11
+		{0,0,0,0,  0,0,0,0,  0,0,0,0,  1,1,1,1,  2,2,2,2,  2,2,2,2,  2,2,2,2,  3,3,3,3,  3,3,3,3,  4,4,4,4,  4,4,4,4,  4,4,4,4};
+	TUint8 colorVal6[width * 4] =   // runs: 4 1 1 1 1 4
+	//	 0         1         2         3         4         5         6         7         8         9         10        11
+		{0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0,  1,1,1,1,  2,2,2,2,  3,3,3,3,  4,4,4,4,  5,5,5,5,  5,5,5,5,  5,5,5,5,  5,5,5,5};
+	TUint8 colorVal7[width * 4] =   // runs: 1 1 1 1 4 1 1 1 1
+	//	 0         1         2         3         4         5         6         7         8         9         10        11
+		{0,0,0,0,  1,1,1,1,  2,2,2,2,  3,3,3,3,  4,4,4,4,  4,4,4,4,  4,4,4,4,  4,4,4,4,  5,5,5,5,  6,6,6,6,  7,7,7,7,  8,8,8,8};
+
+	//Initialize test bitmap
+	TPtr8 line0(colorVal0, width * 4, width * 4);
+	bmp->SetScanLine(line0, 0);
+	TPtr8 line1(colorVal1, width * 4, width * 4);
+	bmp->SetScanLine(line1, 1);
+	TPtr8 line2(colorVal2, width * 4, width * 4);
+	bmp->SetScanLine(line2, 2);
+	TPtr8 line3(colorVal3, width * 4, width * 4);
+	bmp->SetScanLine(line3, 3);
+	TPtr8 line4(colorVal4, width * 4, width * 4);
+	bmp->SetScanLine(line4, 4);
+	TPtr8 line5(colorVal5, width * 4, width * 4);
+	bmp->SetScanLine(line5, 5);
+	TPtr8 line6(colorVal6, width * 4, width * 4);
+	bmp->SetScanLine(line6, 6);
+	TPtr8 line7(colorVal7, width * 4, width * 4);
+	bmp->SetScanLine(line7, 7);
+
+	// Save bitmap then reload and compare
+	_LIT(KTest16MABmpFile, "c:\\test16ma.mbm");
+	bmp->Save(KTest16MABmpFile);	
+	//
+	CFbsBitmap* bmp2 = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(bmp2);
+	TInt err = bmp2->Load(KTest16MABmpFile);
+	TEST2(err, KErrNone);
+	//
+	CompareBitmaps((CFbsBitmapEx&)*bmp, (CFbsBitmapEx&)*bmp2,EColor16MA);
+	
+	// Destroy test bitmaps
+	CleanupStack::PopAndDestroy(2, bmp); // bmp2
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0546
+
+	@SYMTestCaseDesc
+	Test to verify defect DEF071843
+	
+	@SYMDEF DEF071843
+	
+	@SYMTestActions
+	Creates a test bitmap. Initializes it 
+	with test data using SetScanLine. Saves 
+	bitmap and then reloads it and compares 
+	it against expected bitmap.
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::DEF071843_16MUL()
+	{
+	INFO_PRINTF1(_L("DEF071843 fix test. Compression improvements for 16MU 32bpp bitmap."));
+	// Create test bitmap
+	CFbsBitmap* bmp = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(bmp);
+	const TInt width = 12;
+	const TSize size(width, 8);
+	User::LeaveIfError(bmp->Create(size, EColor16MU));
+
+	//Test bitmap data - 8 rows of 12 pixels each containing various run lengths
+	//Format is b,g,r,a where a (alpha) is unused, hence 255.
+	TUint8 colorVal0[width * 4] =  // runs: 12
+	//	 0           1           2           3           4           5           6           7           8           9           10          11
+		{0,0,0,255,  0,0,0,255,  0,0,0,255,  0,0,0,255,  0,0,0,255,  0,0,0,255,  0,0,0,255,  0,0,0,255,  0,0,0,255,  0,0,0,255,  0,0,0,255,  0,0,0,255};
+	TUint8 colorVal1[width * 4] =  // runs: 1 1 1 1 1 1 1 1 1 1 1 1
+	//	 0           1           2           3           4           5           6           7           8           9           10          11
+		{0,0,0,255,  1,1,1,255,  2,2,2,255,  3,3,3,255,  4,4,4,255,  5,5,5,255,  6,6,6,255,  7,7,7,255,  8,8,8,255,  9,9,9,255,  10,10,10,255,  11,11,11,255};
+	TUint8 colorVal2[width * 4] =  // runs: 1 1 2 1 1 3 1 1 1
+	//	 0           1           2           3           4           5           6           7           8           9           10          11
+		{0,0,0,255,  1,1,1,255,  2,2,2,255,  2,2,2,255,  3,3,3,255,  4,4,4,255,  5,5,5,255,  5,5,5,255,  5,5,5,255,  6,6,6,255,  7,7,7,255,  8,8,8,255};
+	TUint8 colorVal3[width * 4] =   // runs: 1 2 1 3 1 4
+	//	 0           1           2           3           4           5           6           7           8           9           10          11
+		{0,0,0,255,  1,1,1,255,  1,1,1,255,  2,2,2,255,  3,3,3,255,  3,3,3,255,  3,3,3,255,  4,4,4,255,  5,5,5,255,  5,5,5,255,  5,5,5,255,  5,5,5,255};
+	TUint8 colorVal4[width * 4] =   // runs: 2 1 2 2 2 3
+	//	 0           1           2           3           4           5           6           7           8           9           10          11
+		{0,0,0,255,  0,0,0,255,  1,1,1,255,  2,2,2,255,  2,2,2,255,  3,3,3,255,  3,3,3,255,  4,4,4,255,  4,4,4,255,  5,5,5,255,  5,5,5,255,  5,5,5,255};
+	TUint8 colorVal5[width * 4] =   // runs: 3 1 3 2 3
+	//	 0           1           2           3           4           5           6           7           8           9           10          11
+		{0,0,0,255,  0,0,0,255,  0,0,0,255,  1,1,1,255,  2,2,2,255,  2,2,2,255,  2,2,2,255,  3,3,3,255,  3,3,3,255,  4,4,4,255,  4,4,4,255,  4,4,4,255};
+	TUint8 colorVal6[width * 4] =   // runs: 4 1 1 1 1 4
+	//	 0           1           2           3           4           5           6           7           8           9           10          11
+		{0,0,0,255,  0,0,0,255,  0,0,0,255,  0,0,0,255,  1,1,1,255,  2,2,2,255,  3,3,3,255,  4,4,4,255,  5,5,5,255,  5,5,5,255,  5,5,5,255,  5,5,5,255};
+	TUint8 colorVal7[width * 4] =   // runs: 1 1 1 1 4 1 1 1 1
+	//	 0           1           2           3           4           5           6           7           8           9           10          11
+		{0,0,0,255,  1,1,1,255,  2,2,2,255,  3,3,3,255,  4,4,4,255,  4,4,4,255,  4,4,4,255,  4,4,4,255,  5,5,5,255,  6,6,6,255,  7,7,7,255,  8,8,8,255};
+
+	//Initialize test bitmap
+	TPtr8 line0(colorVal0, width * 4, width * 4);
+	bmp->SetScanLine(line0, 0);
+	TPtr8 line1(colorVal1, width * 4, width * 4);
+	bmp->SetScanLine(line1, 1);
+	TPtr8 line2(colorVal2, width * 4, width * 4);
+	bmp->SetScanLine(line2, 2);
+	TPtr8 line3(colorVal3, width * 4, width * 4);
+	bmp->SetScanLine(line3, 3);
+	TPtr8 line4(colorVal4, width * 4, width * 4);
+	bmp->SetScanLine(line4, 4);
+	TPtr8 line5(colorVal5, width * 4, width * 4);
+	bmp->SetScanLine(line5, 5);
+	TPtr8 line6(colorVal6, width * 4, width * 4);
+	bmp->SetScanLine(line6, 6);
+	TPtr8 line7(colorVal7, width * 4, width * 4);
+	bmp->SetScanLine(line7, 7);
+
+	// Save bitmap then reload and compare
+	_LIT(KTest16MUBmpFile, "c:\\test16mu.mbm");
+	bmp->Save(KTest16MUBmpFile);	
+	//
+	CFbsBitmap* bmp2 = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(bmp2);
+	TInt err = bmp2->Load(KTest16MUBmpFile);
+	TEST2(err, KErrNone);
+	//
+	CompareBitmaps((CFbsBitmapEx&)*bmp, (CFbsBitmapEx&)*bmp2, EColor16MU);
+	
+	// Destroy test bitmaps
+	CleanupStack::PopAndDestroy(2, bmp); // bmp2
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0547
+
+	@SYMTestCaseDesc
+	Test to verify defect DEF071843
+	
+	@SYMDEF DEF071843
+	
+	@SYMTestActions
+	Creates a test bitmap. Initializes it 
+	with test data using SetScanLine. Saves 
+	bitmap and then reloads it and compares 
+	it against expected bitmap.
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::DEF071843_16ML()
+	{
+	INFO_PRINTF1(_L("DEF071843 fix test. Compression improvements for 16M 24bpp bitmap."));
+	// Create test bitmap
+	CFbsBitmap* bmp = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(bmp);
+	const TInt width = 12;
+	const TSize size(width, 8);
+	User::LeaveIfError(bmp->Create(size, EColor16M));
+
+	//Test bitmap data - 8 rows of 12 pixels each containing various run lengths
+	TUint8 colorVal0[width * 3] =  // runs: 12
+	//	 0       1       2       3       4       5       6       7       8       9       10      11
+		{0,0,0,  0,0,0,  0,0,0,  0,0,0,  0,0,0,  0,0,0,  0,0,0,  0,0,0,  0,0,0,  0,0,0,  0,0,0,  0,0,0};
+	TUint8 colorVal1[width * 3] =  // runs: 1 1 1 1 1 1 1 1 1 1 1 1
+	//	 0       1       2       3       4       5       6       7       8       9       10      11
+		{0,0,0,  1,1,1,  2,2,2,  3,3,3,  4,4,4,  5,5,5,  6,6,6,  7,7,7,  8,8,8,  9,9,9,  10,10,10,  11,11,11};
+	TUint8 colorVal2[width * 3] =  // runs: 1 1 2 1 1 3 1 1 1
+	//	 0       1       2       3       4       5       6       7       8       9       10      11
+		{0,0,0,  1,1,1,  2,2,2,  2,2,2,  3,3,3,  4,4,4,  5,5,5,  5,5,5,  5,5,5,  6,6,6,  7,7,7,  8,8,8};
+	TUint8 colorVal3[width * 3] =   // runs: 1 2 1 3 1 4
+	//	 0       1       2       3       4       5       6       7       8       9       10      11
+		{0,0,0,  1,1,1,  1,1,1,  2,2,2,  3,3,3,  3,3,3,  3,3,3,  4,4,4,  5,5,5,  5,5,5,  5,5,5,  5,5,5};
+	TUint8 colorVal4[width * 3] =   // runs: 2 1 2 2 2 3
+	//	 0       1       2       3       4       5       6       7       8       9       10      11
+		{0,0,0,  0,0,0,  1,1,1,  2,2,2,  2,2,2,  3,3,3,  3,3,3,  4,4,4,  4,4,4,  5,5,5,  5,5,5,  5,5,5};
+	TUint8 colorVal5[width * 3] =   // runs: 3 1 3 2 3
+	//	 0       1       2       3       4       5       6       7       8       9       10      11
+		{0,0,0,  0,0,0,  0,0,0,  1,1,1,  2,2,2,  2,2,2,  2,2,2,  3,3,3,  3,3,3,  4,4,4,  4,4,4,  4,4,4};
+	TUint8 colorVal6[width * 3] =   // runs: 4 1 1 1 1 4
+	//	 0       1       2       3       4       5       6       7       8       9       10      11
+		{0,0,0,  0,0,0,  0,0,0,  0,0,0,  1,1,1,  2,2,2,  3,3,3,  4,4,4,  5,5,5,  5,5,5,  5,5,5,  5,5,5};
+	TUint8 colorVal7[width * 3] =   // runs: 1 1 1 1 4 1 1 1 1
+	//	 0       1       2       3       4       5       6       7       8       9       10      11
+		{0,0,0,  1,1,1,  2,2,2,  3,3,3,  4,4,4,  4,4,4,  4,4,4,  4,4,4,  5,5,5,  6,6,6,  7,7,7,  8,8,8};
+
+	//Initialize test bitmap
+	TPtr8 line0(colorVal0, width * 3, width * 3);
+	bmp->SetScanLine(line0, 0);
+	TPtr8 line1(colorVal1, width * 3, width * 3);
+	bmp->SetScanLine(line1, 1);
+	TPtr8 line2(colorVal2, width * 3, width * 3);
+	bmp->SetScanLine(line2, 2);
+	TPtr8 line3(colorVal3, width * 3, width * 3);
+	bmp->SetScanLine(line3, 3);
+	TPtr8 line4(colorVal4, width * 3, width * 3);
+	bmp->SetScanLine(line4, 4);
+	TPtr8 line5(colorVal5, width * 3, width * 3);
+	bmp->SetScanLine(line5, 5);
+	TPtr8 line6(colorVal6, width * 3, width * 3);
+	bmp->SetScanLine(line6, 6);
+	TPtr8 line7(colorVal7, width * 3, width * 3);
+	bmp->SetScanLine(line7, 7);
+
+	// Save bitmap then reload and compare
+	_LIT(KTest16MBmpFile, "c:\\test16m.mbm");
+	bmp->Save(KTest16MBmpFile);	
+	//
+	CFbsBitmap* bmp2 = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(bmp2);
+	TInt err = bmp2->Load(KTest16MBmpFile);
+	TEST2(err, KErrNone);
+	//
+	CompareBitmaps((CFbsBitmapEx&)*bmp, (CFbsBitmapEx&)*bmp2, EColor16M);
+	
+	// Destroy test bitmaps
+	CleanupStack::PopAndDestroy(2, bmp); // bmp2
+	}
+	
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0548
+
+	@SYMTestCaseDesc
+	Test to verify defect DEF074623 (Alpha bit)
+
+	@SYMDEF DEF074623
+
+	@SYMTestActions
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::DEF074623_16MAL()
+	{
+	INFO_PRINTF1(_L("DEF074623 fix test For Alpha Bit."));
+	// Create test bitmap
+	CFbsBitmap* bmp = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(bmp);
+	const TInt iBitmapWidth = 10;
+	const TInt iBitmapHeight = 10;
+
+	
+	TInt rowIndex;
+	TInt colIndex;
+	TSize rectSize(iBitmapWidth,iBitmapHeight);
+	TRect srcRect(0,0,iBitmapWidth,iBitmapHeight);
+	User::LeaveIfError(bmp->Create(rectSize, EColor16MU));
+	srcRect.SetSize(rectSize);
+	TBitmapUtil bmpUtil(bmp);
+	bmpUtil.Begin(TPoint(0,0));
+	for (rowIndex=0;rowIndex<iBitmapHeight;++rowIndex)
+		{
+		TInt red=0;
+		TInt blue=255;
+		TInt green=0;
+		bmpUtil.SetPos(TPoint(0,rowIndex));
+		for (colIndex=0;colIndex<iBitmapWidth;++colIndex)
+			{
+			TRgb rgb(red,green,blue);
+			bmpUtil.SetPixel(rgb.Color16MA());
+			}
+		bmpUtil.IncXPos();
+		red-=10;
+		blue+=10;
+		green-=10;
+		if(red <= 0)
+			{
+			red+=255;
+			}
+		if(blue >= 255)
+			{
+			blue-=255;
+			}
+		if(green <= 0)
+			{
+			green+=255;
+			}
+		}
+	bmpUtil.End();
+	
+	bmp->SetDisplayMode(EColor16MA);
+	
+	for(TInt yy = 0; yy < iBitmapHeight; yy++)
+		{
+		
+		for(TInt xx = 0; xx < iBitmapWidth; xx++)
+			{
+			TRgb bmpcol;
+			bmp->GetPixel(bmpcol,TPoint(xx,yy));
+			TEST(bmpcol.Alpha() == 255);
+			}
+		}
+		
+	CleanupStack::PopAndDestroy(bmp);	
+
+	}
+	
+#ifdef _DEBUG
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0549
+
+	@SYMTestCaseDesc
+	Test to verify defect DEF095361
+	
+	@SYMDEF DEF095361
+	
+	@SYMTestActions
+	Creates a test bitmap. Initializes it 
+	with test data using SetScanLine. Compresses
+	the bitmap. Saves bitmap and then reloads it 
+	and compares it against expected bitmap.
+	Simulates heap allocation failure of memory.
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::DEF095361_16MAL()
+	{
+	INFO_PRINTF1(_L("DEF095361 fix test. Compressing, Saving and loading 16MA 32bpp bitmap."));
+	// Create test bitmap
+	CFbsBitmap* bmp = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(bmp);
+	const TInt width = 12;
+	const TSize size(width, 8);
+	User::LeaveIfError(bmp->Create(size, EColor16MA));
+
+	//Test bitmap data - 8 rows of 12 pixels each containing various run lengths
+	TUint8 colorVal0[width * 4] =  // runs: 12
+	//	 0         1         2         3         4         5         6         7         8         9         10        11
+		{0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0};
+	TUint8 colorVal1[width * 4] =  // runs: 1 1 1 1 1 1 1 1 1 1 1 1
+	//	 0         1         2         3         4         5         6         7         8         9         10        11
+		{0,0,0,0,  1,1,1,1,  2,2,2,2,  3,3,3,3,  4,4,4,4,  5,5,5,5,  6,6,6,6,  7,7,7,7,  8,8,8,8,  9,9,9,9,  10,10,10,10,  11,11,11,11};
+	TUint8 colorVal2[width * 4] =  // runs: 1 1 2 1 1 3 1 1 1
+	//	 0         1         2         3         4         5         6         7         8         9         10        11
+		{0,0,0,0,  1,1,1,1,  2,2,2,2,  2,2,2,2,  3,3,3,3,  4,4,4,4,  5,5,5,5,  5,5,5,5,  5,5,5,5,  6,6,6,6,  7,7,7,7,  8,8,8,8};
+	TUint8 colorVal3[width * 4] =   // runs: 1 2 1 3 1 4
+	//	 0         1         2         3         4         5         6         7         8         9         10        11
+		{0,0,0,0,  1,1,1,1,  1,1,1,1,  2,2,2,2,  3,3,3,3,  3,3,3,3,  3,3,3,3,  4,4,4,4,  5,5,5,5,  5,5,5,5,  5,5,5,5,  5,5,5,5};
+	TUint8 colorVal4[width * 4] =   // runs: 2 1 2 2 2 3
+	//	 0         1         2         3         4         5         6         7         8         9         10        11
+		{0,0,0,0,  0,0,0,0,  1,1,1,1,  2,2,2,2,  2,2,2,2,  3,3,3,3,  3,3,3,3,  4,4,4,4,  4,4,4,4,  5,5,5,5,  5,5,5,5,  5,5,5,5};
+	TUint8 colorVal5[width * 4] =   // runs: 3 1 3 2 3
+	//	 0         1         2         3         4         5         6         7         8         9         10        11
+		{0,0,0,0,  0,0,0,0,  0,0,0,0,  1,1,1,1,  2,2,2,2,  2,2,2,2,  2,2,2,2,  3,3,3,3,  3,3,3,3,  4,4,4,4,  4,4,4,4,  4,4,4,4};
+	TUint8 colorVal6[width * 4] =   // runs: 4 1 1 1 1 4
+	//	 0         1         2         3         4         5         6         7         8         9         10        11
+		{0,0,0,0,  0,0,0,0,  0,0,0,0,  0,0,0,0,  1,1,1,1,  2,2,2,2,  3,3,3,3,  4,4,4,4,  5,5,5,5,  5,5,5,5,  5,5,5,5,  5,5,5,5};
+	TUint8 colorVal7[width * 4] =   // runs: 1 1 1 1 4 1 1 1 1
+	//	 0         1         2         3         4         5         6         7         8         9         10        11
+		{0,0,0,0,  1,1,1,1,  2,2,2,2,  3,3,3,3,  4,4,4,4,  4,4,4,4,  4,4,4,4,  4,4,4,4,  5,5,5,5,  6,6,6,6,  7,7,7,7,  8,8,8,8};
+
+	//Initialize test bitmap
+	TPtr8 line0(colorVal0, width * 4, width * 4);
+	bmp->SetScanLine(line0, 0);
+	TPtr8 line1(colorVal1, width * 4, width * 4);
+	bmp->SetScanLine(line1, 1);
+	TPtr8 line2(colorVal2, width * 4, width * 4);
+	bmp->SetScanLine(line2, 2);
+	TPtr8 line3(colorVal3, width * 4, width * 4);
+	bmp->SetScanLine(line3, 3);
+	TPtr8 line4(colorVal4, width * 4, width * 4);
+	bmp->SetScanLine(line4, 4);
+	TPtr8 line5(colorVal5, width * 4, width * 4);
+	bmp->SetScanLine(line5, 5);
+	TPtr8 line6(colorVal6, width * 4, width * 4);
+	bmp->SetScanLine(line6, 6);
+	TPtr8 line7(colorVal7, width * 4, width * 4);
+	bmp->SetScanLine(line7, 7);
+
+	//Compress bitmap using RLE Compression
+	bmp->Compress(ERLECompression);
+ 
+	// Save bitmap then reload and compare
+	_LIT(KTest16MABmpFile, "c:\\testDEF095361_16ma.mbm");
+	bmp->Save(KTest16MABmpFile);	
+	//
+	CFbsBitmap* bmp2 = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(bmp2);
+	
+	RFbsSession* fbs = RFbsSession::GetSession();
+	
+	TInt count;
+	for (count = 1; ; count++)
+		{
+		fbs->SendCommand(EFbsMessDefaultAllocFail,count);
+
+		TInt ret = bmp2->Load(KTest16MABmpFile, 0, EFalse);
+
+		if (ret == KErrNoMemory)
+			{
+				// Do Nothing
+			}
+		else if (ret == KErrNone)
+			{
+			break;
+			}
+		else 
+			TEST2(ret, KErrNone);
+		}
+
+	fbs->SendCommand(EFbsMessDefaultAllocFail,0);
+	
+	//
+	CompareBitmaps((CFbsBitmapEx&)*bmp, (CFbsBitmapEx&)*bmp2,EColor16MA);
+	
+	// Destroy test bitmaps
+	CleanupStack::PopAndDestroy(2, bmp); // bmp2
+	}
+#endif
+void CTBitmap::LoadAndCompressBitmapLC(CFbsBitmap*& aBmp, const TDesC& aBmpFile)
+	{
+	aBmp = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(aBmp);
+	TInt err = aBmp->Load(aBmpFile);
+	TEST2(err, KErrNone);
+	err = aBmp->Compress();
+	TEST2(err, KErrNone);
+	TEST(aBmp->IsCompressedInRAM());
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0550
+
+	@SYMTestCaseDesc
+	Compresses a bitmap containing two lines
+
+	@SYMTestActions
+	Creates a test bitmap with two lines. Compresses it (16 bpp)
+	and checks if compressed successfully
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+
+void CTBitmap::TwoComprLines()
+	{
+	INFO_PRINTF1(_L("16 bpp compressed bitmap - 2 lines"));
+	//Create test bitmap
+	CFbsBitmap* bmp = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(bmp);
+	const TInt width = 3;
+	const TSize size(width, 2);
+	User::LeaveIfError(bmp->Create(size, EColor64K));
+	//Test bitmap data
+	TUint8 colorVal[width * 2] = 
+	//	 0          1          2        
+		{0x13,0x13, 0x13,0x13, 0x13,0x13};
+	//Initialize test bitmap
+	TPtr8 ptr(colorVal, width * 2, width * 2);
+	bmp->SetScanLine(ptr, 0);
+	bmp->SetScanLine(ptr, 1);
+	//Compress test bitmap
+	User::LeaveIfError(bmp->Compress());
+	//Check the test data
+	TUint8 colorVal2[width * 2];
+	TPtr8 ptr2(colorVal2, width * 2, width * 2);
+	//test 1
+	bmp->GetScanLine(ptr2, TPoint(0, 0), 3, EColor64K);
+	TEST(ptr2 == ptr);
+	bmp->GetScanLine(ptr2, TPoint(0, 1), 3, EColor64K);
+	TEST(ptr2 == ptr);
+	//Destroy test bitmap and data
+	CleanupStack::PopAndDestroy(bmp);
+	}
+
+void CTBitmap::LoadAndNotCompressBitmapLC(CFbsBitmap*& aBmp, const TDesC& aBmpFile)
+	{
+	aBmp = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(aBmp);
+	TInt err = aBmp->Load(aBmpFile);
+	TEST2(err, KErrNone);
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0551
+
+	@SYMTestCaseDesc
+	The test verifies the 
+	CFbsBitmap::Compress((TBitmapfileCompressionScheme aScheme) API.
+	It loads bitmaps from ROM & saves (temporarily) to C-drive. 
+	Then it loads from C-drive into a new bitmap.
+
+	@SYMTestActions
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::TestPaletteCompressionL()
+	{
+	INFO_PRINTF1(_L("Test Palette Compression"));
+	_LIT(KmbmFileInRom, "z:\\system\\data\\24bitskin.mbm");
+	RFbsSession* fbs = RFbsSession::GetSession();
+	//create bitmap
+	CFbsBitmap* fbsCompressed = new(ELeave) CFbsBitmap;
+	CFbsBitmap* fbsUnCompressed = new(ELeave) CFbsBitmap;
+	CleanupStack::PushL(fbsCompressed);
+	CleanupStack::PushL(fbsUnCompressed);
+	TEST2(fbsUnCompressed->Load(KmbmFileInRom, 0, EFalse), KErrNone);
+	fbsUnCompressed->Save(KTempFilename);
+	//load bitmap
+	TEST2(fbsCompressed->Load(KTempFilename, 0, EFalse), KErrNone);
+	//compress bitmap (force foreground compression)
+	fbsCompressed->Compress(EPaletteCompression);
+	fbs->SendCommand(EFbsCompress, 0); //force background compression to execute
+	//test that palette compression occurred
+	TEST(fbsCompressed->Header().iCompression == EGenericPaletteCompression);
+	//compare with original
+	INFO_PRINTF1(_L("Compare Palette Compressed bmp with original"));
+	CompareBitmaps((CFbsBitmapEx&)*fbsCompressed, (CFbsBitmapEx&)*fbsUnCompressed, EColor16M);
+	CleanupStack::PopAndDestroy(2);
+	iFs.Delete(KTempFilename);
+
+	//Test that the RLE option works.
+	//------------------------------------
+	//create bitmap
+	fbsCompressed = new(ELeave) CFbsBitmap ;
+	fbsUnCompressed = new(ELeave) CFbsBitmap ;
+	CleanupStack::PushL(fbsCompressed);
+	CleanupStack::PushL(fbsUnCompressed);
+	TEST2(fbsUnCompressed->Load(KmbmFileInRom, 0, EFalse), KErrNone);
+	fbsUnCompressed->Save(KTempFilename);
+	//load bitmap
+	TEST2(fbsCompressed->Load(KTempFilename, 0, EFalse), KErrNone);
+	//compress bitmap (force foreground compression)
+	fbsCompressed->Compress(ERLECompression);
+	fbs->SendCommand(EFbsCompress, 0); //force background compression to execute
+	//test that RLE compression occurred
+	TEST(fbsCompressed->Header().iCompression == ETwentyFourBitRLECompression);
+	CleanupStack::PopAndDestroy(2);
+	iFs.Delete(KTempFilename);
+
+	//Test that unsuitable bitmaps are not palette compressed (too many colours).
+	//----------------------------------------------------------------------------------------
+	_LIT(KmbmMultiColourMBMInRom, "z:\\system\\data\\24bit.mbm");
+	//create bitmap
+	fbsCompressed = new(ELeave) CFbsBitmap;
+	fbsUnCompressed = new(ELeave) CFbsBitmap;
+	CleanupStack::PushL(fbsCompressed);
+	CleanupStack::PushL(fbsUnCompressed);
+	TEST2(fbsUnCompressed->Load(KmbmMultiColourMBMInRom, 0, EFalse), KErrNone);
+	fbsUnCompressed->Save(KTempFilename);
+	//load bitmap
+	TEST2(fbsCompressed->Load(KTempFilename, 0, EFalse), KErrNone);
+	//compress bitmap (force foreground compression)
+	fbsCompressed->Compress(EPaletteCompression);
+	fbs->SendCommand(EFbsCompress, 0); //force background compression to execute
+	//test that palette compression occurred
+	TEST(fbsCompressed->Header().iCompression != EGenericPaletteCompression);
+	CleanupStack::PopAndDestroy(2);
+	iFs.Delete(KTempFilename);
+	
+	//Test that unsuitable bitmaps are not palette compressed (too few BPP)
+	//---------------------------------------------------------------------------------
+	//create bitmap
+	fbsCompressed = new(ELeave) CFbsBitmap ;
+	fbsUnCompressed = new(ELeave) CFbsBitmap ;
+	CleanupStack::PushL(fbsCompressed);
+	CleanupStack::PushL(fbsUnCompressed);
+	TEST2(fbsUnCompressed->Load(KmbmMultiColourMBMInRom, 0, EFalse), KErrNone);
+	fbsUnCompressed->Save(KTempFilename);
+	//load bitmap
+	TEST2(fbsCompressed->Load(KTempFilename, 0, EFalse), KErrNone);
+	//compress bitmap (force foreground compression)
+	fbsCompressed->Compress(EPaletteCompression);
+	fbs->SendCommand(EFbsCompress, 0); //force background compression to execute
+	//test that palette compression occurred
+	TEST(fbsCompressed->Header().iCompression != EGenericPaletteCompression);
+	CleanupStack::PopAndDestroy(2);
+	iFs.Delete(KTempFilename);
+
+	
+	// Test that 12bitmap cannot pallete compress but will fall back to RLE
+	// --------------------------------------------------------------------
+	_LIT(Kmbm12BitMBMInRom, "z:\\system\\data\\file.mbm");
+	fbsCompressed = new(ELeave) CFbsBitmap ;
+	fbsUnCompressed = new(ELeave) CFbsBitmap ;
+	CleanupStack::PushL(fbsCompressed);
+	CleanupStack::PushL(fbsUnCompressed);
+	TEST2(fbsUnCompressed->Load(Kmbm12BitMBMInRom, 0, EFalse), KErrNone);
+	fbsUnCompressed->Save(KTempFilename);
+	//load bitmap
+	TEST2(fbsCompressed->Load(KTempFilename, 0, EFalse), KErrNone);
+	//compress bitmap (force foreground compression)
+	fbsCompressed->Compress(EPaletteCompressionWithRLEFallback);
+	fbs->SendCommand(EFbsCompress, 0); //force background compression to execute
+	TBitmapfileCompression comp = fbsCompressed->Header().iCompression;
+	//test that palette compression occurred
+	TEST(fbsCompressed->Header().iCompression != EGenericPaletteCompression);
+	CleanupStack::PopAndDestroy(2);
+	iFs.Delete(KTempFilename);
+	
+
+	// Test that multi colour bitmap cannot pallete compress but will fall back to RLE
+	// -------------------------------------------------------------------------------
+	fbsCompressed = new(ELeave) CFbsBitmap ;
+	fbsUnCompressed = new(ELeave) CFbsBitmap ;
+	CleanupStack::PushL(fbsCompressed);
+	CleanupStack::PushL(fbsUnCompressed);
+	TEST2(fbsUnCompressed->Load(KmbmMultiColourMBMInRom, 0, EFalse), KErrNone);
+	fbsUnCompressed->Save(KTempFilename);
+	//load bitmap
+	TEST2(fbsCompressed->Load(KTempFilename, 0, EFalse), KErrNone);
+	//compress bitmap (force foreground compression)
+	fbsCompressed->Compress(EPaletteCompressionWithRLEFallback);
+	fbs->SendCommand(EFbsCompress, 0); //force background compression to execute
+	comp = fbsCompressed->Header().iCompression;
+	//test that palette compression occurred
+	TEST(fbsCompressed->Header().iCompression != EGenericPaletteCompression);
+	CleanupStack::PopAndDestroy(2);
+	iFs.Delete(KTempFilename);
+	
+	
+	
+	//Test various BPP & bitmap widths
+	//----------------------------------------
+	INFO_PRINTF1(_L("Test assorted BPP & colour counts"));
+	_LIT(Kmbm16NarrowFileInRom, "z:\\system\\data\\16bitskin.mbm");
+	TestAssortedBPPandColourDepthL(Kmbm16NarrowFileInRom, fbs);
+	_LIT(Kmbm24bit6colFileInRom, "z:\\system\\data\\24bit6col.mbm");
+	TestAssortedBPPandColourDepthL(Kmbm24bit6colFileInRom, fbs);
+	_LIT(Kmbm24bit2colFileInRom, "z:\\system\\data\\24bit2col.mbm");
+	TestAssortedBPPandColourDepthL(Kmbm24bit2colFileInRom, fbs);
+	_LIT(Kmbm24bit3colFileInRom, "z:\\system\\data\\24bit3col.mbm");
+	TestAssortedBPPandColourDepthL(Kmbm24bit3colFileInRom, fbs);
+	_LIT(Kmbm24bit20colFileInRom, "z:\\system\\data\\24bit20col.mbm");
+	TestAssortedBPPandColourDepthL(Kmbm24bit20colFileInRom, fbs);
+	_LIT(Kmbm16bit6colFileInRom, "z:\\system\\data\\16bit6col.mbm");
+	TestAssortedBPPandColourDepthL(Kmbm16bit6colFileInRom, fbs);
+	_LIT(Kmbm16bit2colFileInRom, "z:\\system\\data\\16bit2col.mbm");
+	TestAssortedBPPandColourDepthL(Kmbm16bit2colFileInRom, fbs);
+	_LIT(Kmbm16bit3colFileInRom, "z:\\system\\data\\16bit3col.mbm");
+	TestAssortedBPPandColourDepthL(Kmbm16bit3colFileInRom, fbs);
+	_LIT(Kmbm16bit20colFileInRom, "z:\\system\\data\\16bit20col.mbm");
+	TestAssortedBPPandColourDepthL(Kmbm16bit20colFileInRom, fbs);
+	_LIT(Kmbm32BitSkinFileInRom, "z:\\system\\data\\32bitskin.mbm");
+	TestAssortedBPPandColourDepthL(Kmbm32BitSkinFileInRom, fbs);
+	_LIT(Kmbm32bit6colFileInRom, "z:\\system\\data\\32bit6col.mbm");
+	TestAssortedBPPandColourDepthL(Kmbm32bit6colFileInRom, fbs);
+	_LIT(Kmbm32bit2colFileInRom, "z:\\system\\data\\32bit2col.mbm");
+	TestAssortedBPPandColourDepthL(Kmbm32bit2colFileInRom, fbs);
+	_LIT(Kmbm32bit3colFileInRom, "z:\\system\\data\\32bit3col.mbm");
+	TestAssortedBPPandColourDepthL(Kmbm32bit3colFileInRom, fbs);
+	_LIT(Kmbm32bit20colFileInRom, "z:\\system\\data\\32bit20col.mbm");
+	TestAssortedBPPandColourDepthL(Kmbm32bit20colFileInRom, fbs);
+	INFO_PRINTF1(_L("Test Palette Compression - COMPLETE"));
+	}
+
+void CTBitmap::TestAssortedBPPandColourDepthL(const TDesC& aFilename, RFbsSession* aFbs)
+	{
+	//create bitmap
+	CFbsBitmap* fbsCompressed = new (ELeave) CFbsBitmap ;
+	CFbsBitmap* fbsUnCompressed = new (ELeave) CFbsBitmap ;
+	CleanupStack::PushL(fbsCompressed);
+	CleanupStack::PushL(fbsUnCompressed);
+	TEST2(fbsUnCompressed->Load(aFilename, 0, EFalse), KErrNone);
+	fbsUnCompressed->Save(KTempFilename);
+	//load bitmap
+	TEST2(fbsCompressed->Load(KTempFilename, 0, EFalse), KErrNone);
+	//compress bitmap (force foreground compression)
+	fbsCompressed->Compress(EPaletteCompression);
+	aFbs->SendCommand(EFbsCompress, 0); //force background compression to execute
+	//test that palette compression occurred
+	TEST(fbsCompressed->Header().iCompression == EGenericPaletteCompression);
+	//compare with original
+	INFO_PRINTF1(_L("Compare Palette Compressed bmp with original"));
+	CompareBitmaps((CFbsBitmapEx&)*fbsCompressed, (CFbsBitmapEx&)*fbsUnCompressed, EColor16M);
+	CleanupStack::PopAndDestroy(2);
+	iFs.Delete(KTempFilename);
+	}
+	
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0552
+
+	@SYMTestCaseDesc
+	The test verifies the 
+	CFbsBitmap::CompressInBackground((TBitmapfileCompressionScheme aScheme)
+	API. It loads bitmaps from ROM & saves (temporarily) to C-drive. 
+	Then it loads from C-drive into a new bitmap.
+
+	@SYMTestActions
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::TestSynchronousBackgroundPaletteCompressionL()
+	{
+	INFO_PRINTF1(_L("Test Background Palette Compression"));
+	_LIT(KmbmFileInRom, "z:\\system\\data\\24bitskin.mbm");
+	RFbsSession* fbs = RFbsSession::GetSession();
+	//create bitmap
+	CFbsBitmap* fbsCompressed = new(ELeave) CFbsBitmap ;
+	CFbsBitmap* fbsUnCompressed = new(ELeave) CFbsBitmap ;
+	CleanupStack::PushL(fbsCompressed);
+	CleanupStack::PushL(fbsUnCompressed);
+	TEST2(fbsUnCompressed->Load(KmbmFileInRom, 0, EFalse), KErrNone);
+	fbsUnCompressed->Save(KTempFilename);
+	//load bitmap
+	TEST2(fbsCompressed->Load(KTempFilename, 0, EFalse), KErrNone);
+	//compress bitmap (force immediate compression)
+	fbsCompressed->CompressInBackground(EPaletteCompression);
+	fbs->SendCommand(EFbsCompress, 0); //force background compression to execute
+	//test that palette compression occurred
+	TEST(fbsCompressed->Header().iCompression == EGenericPaletteCompression);
+	//compare with original
+	INFO_PRINTF1(_L("Compare Palette Compressed bmp with original"));
+	CompareBitmaps((CFbsBitmapEx&)*fbsCompressed, (CFbsBitmapEx&)*fbsUnCompressed, EColor16M);
+	CleanupStack::PopAndDestroy(2);
+	iFs.Delete(KTempFilename);
+	
+	//Test that the RLE option works.
+	//------------------------------------
+	//create bitmap
+	fbsCompressed = new(ELeave) CFbsBitmap ;
+	fbsUnCompressed = new(ELeave) CFbsBitmap ;
+	CleanupStack::PushL(fbsCompressed);
+	CleanupStack::PushL(fbsUnCompressed);
+	TEST2(fbsUnCompressed->Load(KmbmFileInRom, 0, EFalse), KErrNone);
+	fbsUnCompressed->Save(KTempFilename);
+	//load bitmap
+	TEST2(fbsCompressed->Load(KTempFilename, 0, EFalse), KErrNone);
+	//compress bitmap (force immediate compression)
+	fbsCompressed->CompressInBackground(ERLECompression);
+	fbs->SendCommand(EFbsCompress, 0); //force background compression to execute
+	//test that RLE compression occurred
+	TEST(fbsCompressed->Header().iCompression == ETwentyFourBitRLECompression);
+	CleanupStack::PopAndDestroy(2);
+	iFs.Delete(KTempFilename);
+
+	//Test that unsuitable bitmaps are not palette compressed (too many colours).
+	//----------------------------------------------------------------------------------------
+	_LIT(KmbmMultiColourMBMInRom, "z:\\system\\data\\24bit.mbm");
+	//create bitmap
+	fbsCompressed = new(ELeave) CFbsBitmap ;
+	fbsUnCompressed = new(ELeave) CFbsBitmap ;
+	CleanupStack::PushL(fbsCompressed);
+	CleanupStack::PushL(fbsUnCompressed);
+	TEST2(fbsUnCompressed->Load(KmbmMultiColourMBMInRom, 0, EFalse), KErrNone);
+	fbsUnCompressed->Save(KTempFilename);
+	//load bitmap
+	TEST2(fbsCompressed->Load(KTempFilename, 0, EFalse), KErrNone);
+	//compress bitmap (force immediate compression)
+	fbsCompressed->CompressInBackground(EPaletteCompression);
+	fbs->SendCommand(EFbsCompress, 0); //force background compression to execute
+	//test that palette compression occurred
+	TEST(fbsCompressed->Header().iCompression != EGenericPaletteCompression);
+	CleanupStack::PopAndDestroy(2);
+	iFs.Delete(KTempFilename);
+	
+	//Test that unsuitable bitmaps are not palette compressed (too few BPP)
+	//---------------------------------------------------------------------------------
+	//create bitmap
+	fbsCompressed = new(ELeave) CFbsBitmap ;
+	fbsUnCompressed = new(ELeave) CFbsBitmap ;
+	CleanupStack::PushL(fbsCompressed);
+	CleanupStack::PushL(fbsUnCompressed);
+	TEST2(fbsUnCompressed->Load(KmbmMultiColourMBMInRom, 0, EFalse), KErrNone);
+	fbsUnCompressed->Save(KTempFilename);
+	//load bitmap
+	TEST2(fbsCompressed->Load(KTempFilename, 0, EFalse), KErrNone);
+	//compress bitmap (force immediate compression)
+	fbsCompressed->CompressInBackground(EPaletteCompression);
+	fbs->SendCommand(EFbsCompress, 0); //force background compression to execute
+	//test that palette compression occurred
+	TEST(fbsCompressed->Header().iCompression != EGenericPaletteCompression);
+	CleanupStack::PopAndDestroy(2);
+	iFs.Delete(KTempFilename);
+	INFO_PRINTF1(_L("Test Background Palette Compression - COMPLETE"));
+	}
+	
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0553
+
+	@SYMTestCaseDesc
+	The test verifies the 
+	CFbsBitmap::CompressInBackground(TRequestStatus& aRequestStatus, TBitmapfileCompressionScheme aScheme)
+	API. It loads bitmaps from ROM & saves (temporarily) to C-drive. 
+	Then it loads from C-drive into a new bitmap.
+
+	@SYMTestActions
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/	
+void CTBitmap::TestAsynchronousBackgroundPaletteCompressionL()
+	{
+	INFO_PRINTF1(_L("Test Asynch background Palette Compression"));
+	TRequestStatus status ;
+	_LIT(KmbmFileInRom, "z:\\system\\data\\24bitskin.mbm");
+	RFbsSession* fbs = RFbsSession::GetSession();
+	//create bitmap
+	CFbsBitmap* fbsCompressed = new(ELeave) CFbsBitmap ;
+	CFbsBitmap* fbsUnCompressed = new(ELeave) CFbsBitmap ;
+	CleanupStack::PushL(fbsCompressed);
+	CleanupStack::PushL(fbsUnCompressed);
+	TEST2(fbsUnCompressed->Load(KmbmFileInRom, 0, EFalse), KErrNone);
+	fbsUnCompressed->Save(KTempFilename);
+	//load bitmap
+	TEST2(fbsCompressed->Load(KTempFilename, 0, EFalse), KErrNone);
+	//compress bitmap (force immediate compression)
+	fbsCompressed->CompressInBackground(status, EPaletteCompression);
+	fbs->SendCommand(EFbsCompress, 0); //force background compression to execute
+	User::WaitForRequest(status);
+	TEST2(status.Int(), KErrNone);
+	//test that palette compression occurred
+	TEST(fbsCompressed->Header().iCompression == EGenericPaletteCompression);
+	//compare with original
+	INFO_PRINTF1(_L("Compare Palette Compressed bmp with original"));
+	CompareBitmaps((CFbsBitmapEx&)*fbsCompressed, (CFbsBitmapEx&)*fbsUnCompressed, EColor16M);
+	CleanupStack::PopAndDestroy(2);
+	iFs.Delete(KTempFilename);
+	
+	//Test that the RLE option works.
+	//------------------------------------
+	//create bitmap
+	fbsCompressed = new (ELeave) CFbsBitmap ;
+	fbsUnCompressed = new (ELeave) CFbsBitmap ;
+	CleanupStack::PushL(fbsCompressed);
+	CleanupStack::PushL(fbsUnCompressed);
+	TEST2(fbsUnCompressed->Load(KmbmFileInRom, 0, EFalse), KErrNone);
+	fbsUnCompressed->Save(KTempFilename);
+	//load bitmap
+	TEST2(fbsCompressed->Load(KTempFilename, 0, EFalse), KErrNone);
+	//compress bitmap (force immediate compression)
+	fbsCompressed->CompressInBackground(status, ERLECompression);
+	fbs->SendCommand(EFbsCompress, 0); //force background compression to execute
+	User::WaitForRequest(status);
+	TEST2(status.Int(), KErrNone);
+	//test that RLE compression occurred
+	TEST(fbsCompressed->Header().iCompression == ETwentyFourBitRLECompression);
+	CleanupStack::PopAndDestroy(2);
+	iFs.Delete(KTempFilename);
+
+	//Test that unsuitable bitmaps are not palette compressed (too many colours).
+	//----------------------------------------------------------------------------------------
+	_LIT(KmbmMultiColourMBMInRom, "z:\\system\\data\\24bit.mbm");
+	//create bitmap
+	fbsCompressed = new (ELeave) CFbsBitmap ;
+	fbsUnCompressed = new (ELeave) CFbsBitmap ;
+	CleanupStack::PushL(fbsCompressed);
+	CleanupStack::PushL(fbsUnCompressed);
+	TEST2(fbsUnCompressed->Load(KmbmMultiColourMBMInRom, 0, EFalse), KErrNone);
+	fbsUnCompressed->Save(KTempFilename);
+	//load bitmap
+	TEST2(fbsCompressed->Load(KTempFilename, 0, EFalse), KErrNone);
+	//compress bitmap (force immediate compression)
+	fbsCompressed->CompressInBackground(status, EPaletteCompression);
+	fbs->SendCommand(EFbsCompress, 0); //force background compression to execute
+	User::WaitForRequest(status);
+	TEST2(status.Int(), KErrNotSupported);
+	//test that palette compression occurred
+	TEST(fbsCompressed->Header().iCompression != EGenericPaletteCompression);
+	CleanupStack::PopAndDestroy(2);
+	iFs.Delete(KTempFilename);
+	
+	//Test that unsuitable bitmaps are not palette compressed (too few BPP)
+	//---------------------------------------------------------------------------------
+	//create bitmap
+	fbsCompressed = new(ELeave) CFbsBitmap ;
+	fbsUnCompressed = new(ELeave) CFbsBitmap ;
+	CleanupStack::PushL(fbsCompressed);
+	CleanupStack::PushL(fbsUnCompressed);
+	TEST2(fbsUnCompressed->Load(KmbmMultiColourMBMInRom, 0, EFalse), KErrNone);
+	fbsUnCompressed->Save(KTempFilename);
+	//load bitmap
+	TEST2(fbsCompressed->Load(KTempFilename, 0, EFalse), KErrNone);
+	//compress bitmap (force immediate compression)
+	fbsCompressed->CompressInBackground(status, EPaletteCompression);
+	fbs->SendCommand(EFbsCompress, 0); //force background compression to execute
+	User::WaitForRequest(status);
+	TEST2(status.Int(), KErrNotSupported);
+	//test that palette compression occurred
+	TEST(fbsCompressed->Header().iCompression != EGenericPaletteCompression);
+	CleanupStack::PopAndDestroy(2);
+	iFs.Delete(KTempFilename);
+	INFO_PRINTF1(_L("Test Asynch background Palette Compressio - COMPLETE"));
+	}
+
+/**
+@SYMTestCaseID GRAPHICS-FBSERV-0501
+
+@SYMTestType UT
+
+@SYMTestPriority Medium
+
+@SYMCR DKRN-6QGJPT
+
+@SYMTestCaseDesc Get all bitmap handles before and after loading a bitmap. 
+
+@SYMTestActions
+1) Get all bitmap handles and store number of bitmaps obtained
+2) Load a new bitmap
+3) Get all bitmap handles and store number of bitmaps obtained
+
+@SYMTestExpectedResults
+The number of bitmap handles retrieved after loading the bitmap should be one more than prior to loading the bitmap.
+*/
+void CTBitmap::GetAllBitmapsIdsL()
+	{
+	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(bitmap);
+	
+	RArray <TInt> bitmapHandleArray;
+	CleanupClosePushL(bitmapHandleArray);
+	
+	// Get current number of bitmap handles
+	User::LeaveIfError(bitmap->GetAllBitmapHandles(bitmapHandleArray));
+	const TInt numBitmapHandles = bitmapHandleArray.Count();
+	
+	// Load another bitmap
+	CFbsBitmap* bmp = LoadBitmapLC(KRc_Ram8);
+	
+	// Get current number of bitmap handles
+	User::LeaveIfError(bitmap->GetAllBitmapHandles(bitmapHandleArray));
+	const TInt newNumBitmapHandles = bitmapHandleArray.Count();
+	TEST(numBitmapHandles == newNumBitmapHandles - 1);	// Ensure there is one more bitmap handle from the bitmap we just added
+	
+	const TInt handle = bmp->Handle();
+	
+	TInt foundHandle = 0;
+	for (TInt count = newNumBitmapHandles-1; count>=0; --count)
+		{
+		if (handle == bitmapHandleArray[count])
+			{
+			foundHandle++;
+			}
+		}
+	TEST(foundHandle==1);	// Ensure only one instance of this handle is found in the array
+	CleanupStack::PopAndDestroy(3, bitmap);	// bmp, bitmapHandleArray, bitmap	
+	}
+
+/**
+	@SYMTestCaseID
+	GRAPHICS-FBSERV-0554
+
+	@SYMTestCaseDesc
+	Test Code For Corrupted MBM File.
+	
+	@SYMTestActions
+	Loads a specific bitmap from a multi-bitmap 
+	file from ROM and tests if it is corrupted.
+	
+	@SYMTestExpectedResults
+	Test should pass
+*/
+void CTBitmap::CheckBadBmp()
+{
+	INFO_PRINTF1(_L("MalformedBmp"));
+	_LIT(KmalmbmFile0, "z:\\system\\data\\00_grbmap.mbm");
+	_LIT(KmalmbmFile1, "z:\\system\\data\\01_totalstramsize!.mbm");
+	_LIT(KmalmbmFile2, "z:\\system\\data\\02_headersize.mbm");
+	_LIT(KmalmbmFile3, "z:\\system\\data\\03_width!.mbm");
+	_LIT(KmalmbmFile4, "z:\\system\\data\\04_height!.mbm");
+	_LIT(KmalmbmFile5, "z:\\system\\data\\05_bitsperpixel.mbm");
+	_LIT(KmalmbmFile6, "z:\\system\\data\\bad_bmpsize.mbm");
+	_LIT(KmalmbmFile7, "z:\\system\\data\\bad_colormode.mbm");
+	_LIT(KmalmbmFile8, "z:\\system\\data\\bad_compression.mbm");
+	_LIT(KmalmbmFile9, "z:\\system\\data\\bad_paletteentries.mbm"); 
+
+	CFbsBitmap* fbsmalBmp = new(ELeave) CFbsBitmap;
+	CleanupStack::PushL(fbsmalBmp);
+
+	//load bitmap
+	TEST2(fbsmalBmp->Load(KmalmbmFile0, 0, EFalse), KErrNone);
+	TEST2(fbsmalBmp->Load(KmalmbmFile1, 0, EFalse), KErrCorrupt);
+	TEST2(fbsmalBmp->Load(KmalmbmFile2, 0, EFalse), KErrCorrupt);
+	TEST2(fbsmalBmp->Load(KmalmbmFile3, 0, EFalse), KErrCorrupt);
+	TEST2(fbsmalBmp->Load(KmalmbmFile4, 0, EFalse), KErrCorrupt);
+	TEST2(fbsmalBmp->Load(KmalmbmFile5, 0, EFalse), KErrNotSupported);
+	TEST2(fbsmalBmp->Load(KmalmbmFile6, 0, EFalse), KErrCorrupt);
+	TEST2(fbsmalBmp->Load(KmalmbmFile7, 0, EFalse), KErrCorrupt);
+	TEST2(fbsmalBmp->Load(KmalmbmFile8, 0, EFalse), KErrCorrupt);
+	TEST2(fbsmalBmp->Load(KmalmbmFile9, 0, EFalse), KErrNotSupported);
+
+	CleanupStack::PopAndDestroy(fbsmalBmp);
+}
+
+/**
+@SYMTestCaseID			GRAPHICS-FBSERV-0613
+
+@SYMDEF					PDEF111181
+
+@SYMTestCaseDesc		Test the return code of operations on bitmaps in the background compression queue
+
+@SYMTestPriority		Critical
+
+@SYMTestType			UT
+
+@SYMTestStatus			Implemented
+
+@SYMTestActions			1. Creates a bitmap
+						2. Calls CompressInBackground()
+						3. Call Resize
+						4. Waits until compression is finished
+
+@SYMTestExpectedResults The call to resize should return with KErrInUse since the compression is in progress
+*/
+
+void CTBitmap::TestBgCompressInUseL()
+	{
+	INFO_PRINTF1(_L("Test the return code of operations on bitmaps in the background compression queue"));
+	
+	CFbsBitmap* bmp = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(bmp);
+
+	TInt ret = bmp->Create(TSize(256, 256), EGray256); // create a solid grey bitmap
+	TEST2 (ret,KErrNone);
+	TRequestStatus status;
+	bmp->CompressInBackground(status);
+	TInt resizeRet = bmp->Resize(TSize(512,512));
+	
+	TEST2 (resizeRet,KErrInUse);
+	User::WaitForRequest(status);
+	TEST2 (status.Int(), KErrNone);
+	CleanupStack::PopAndDestroy(bmp);
+	}
+
+
+//------------------------------------------------------------------------------
+
+LOCAL_D const TInt KTestBitmapWidth = 256; // this affects BitmapCheckCompressed()
+LOCAL_D const TInt KTestBitmapHeight = 256;
+LOCAL_D const TInt KTestBitmapResizeHeight = 512;
+LOCAL_D const TInt KMaxRLERunLength = 127;
+
+LOCAL_C void SetBitmapDataWithVerticalGradient(TUint8* aDataPtr)
+	{
+	for (TInt y = 0; y < KTestBitmapHeight; ++y)
+		for (TInt x = 0; x < KTestBitmapWidth; ++x)
+			*aDataPtr++ = y;
+	}
+
+LOCAL_C TBool BitmapDataCheckVerticalGradient(const TUint8* aDataPtr)
+	{
+	for (TInt y = 0; y < KTestBitmapHeight; ++y)
+		for (TInt x = 0; x < KTestBitmapWidth; ++x)
+			if (*aDataPtr++ != y)
+				return EFalse;
+	return ETrue;
+	}
+
+LOCAL_C void SetBitmapDataWithHorizontalGradient(TUint8* aDataPtr)
+	{
+	for (TInt y = 0; y < KTestBitmapHeight; ++y)
+		for (TInt x = 0; x < KTestBitmapWidth; ++x)
+			*aDataPtr++ = x;
+	}
+
+LOCAL_C TBool BitmapDataCheckHorizontalGradient(const TUint8* aDataPtr)
+	{
+	for (TInt y = 0; y < KTestBitmapHeight; ++y)
+		for (TInt x = 0; x < KTestBitmapWidth; ++x)
+			if (*aDataPtr++ != x)
+				return EFalse;
+	return ETrue;
+	}
+
+LOCAL_C TInt ResizeTestBitmap(CFbsBitmap* aBitmap)
+	{
+	return aBitmap->Resize(TSize(KTestBitmapWidth, KTestBitmapResizeHeight));
+	}
+
+LOCAL_C TBool BitmapCheckResized(const CFbsBitmap* aBitmap)
+	{
+	if (aBitmap->SizeInPixels() != TSize(KTestBitmapWidth, KTestBitmapResizeHeight))
+		return EFalse;
+	TUint8* dataPtr = (TUint8*)aBitmap->DataAddress();
+	for (TInt y = 0; y < KTestBitmapHeight; ++y)
+		for (TInt x = 0; x < KTestBitmapWidth; ++x)
+			if (*dataPtr++ != y)
+				return EFalse;
+	for (TInt y = KTestBitmapHeight; y < KTestBitmapResizeHeight; ++y)
+		for (TInt x = 0; x < KTestBitmapWidth; ++x)
+			if (*dataPtr++ != 0xFF)
+				return EFalse;
+	return ETrue;
+	}
+
+LOCAL_C TInt CompressTestBitmap(CFbsBitmap* aBitmap)
+	{
+	return aBitmap->Compress();
+	}
+
+LOCAL_C TBool BitmapCheckCompressed(const CFbsBitmap* aBitmap)
+	{
+	if (aBitmap->SizeInPixels() != TSize(KTestBitmapWidth, KTestBitmapHeight))
+		return EFalse;
+	// check RLE compression on vertical gradient
+	TUint8* dataPtr = (TUint8*)aBitmap->DataAddress();
+	for (TInt y = 0; y < KTestBitmapHeight - 1; ++y)
+		{
+		// this works when the width of the bitmap is 256, or twice the maximum encodable run length, which is 128
+		if (*dataPtr++ != KMaxRLERunLength)
+			return EFalse;
+		if (*dataPtr++ != y)
+			return EFalse;
+		if (*dataPtr++ != KMaxRLERunLength)
+			return EFalse;
+		if (*dataPtr++ != y)
+			return EFalse;
+		}
+	return ETrue;
+	}
+
+struct TTestThreadParams
+	{
+	TInt iBitmapHandle;
+	TInt (*iBitmapFunction)(CFbsBitmap*); // operation to perform on the bitmap
+	TBool (*iCheckFunction)(const CFbsBitmap*); // check that the operation was successfully performed
+	};
+
+LOCAL_C void AlternateTestThreadL(const TTestThreadParams& aParams)
+	{
+	RFbsSession* fbs = RFbsSession::GetSession();
+	if (fbs->ResourceCount() != 0)
+		User::Leave(KErrGeneral);
+	CFbsBitmap* bmp = new(ELeave) CFbsBitmap;
+	CleanupStack::PushL(bmp);
+	User::LeaveIfError(bmp->Duplicate(aParams.iBitmapHandle));
+	if (fbs->ResourceCount() != 1)
+		User::Leave(KErrGeneral);
+	if (!BitmapDataCheckVerticalGradient((TUint8*)bmp->DataAddress()))
+		User::Leave(KErrGeneral);
+	User::LeaveIfError((*aParams.iBitmapFunction)(bmp));
+	if (fbs->ResourceCount() != 1)
+		User::Leave(KErrGeneral);
+	if (aParams.iCheckFunction != NULL && !(*aParams.iCheckFunction)(bmp))
+		User::Leave(KErrGeneral);
+	CleanupStack::PopAndDestroy(bmp);
+	if (fbs->ResourceCount() != 0)
+		User::Leave(KErrGeneral);
+	}
+
+LOCAL_C TInt AlternateTestThread(TAny* aParams)
+	{
+	__UHEAP_MARK;
+	TInt ret = RFbsSession::Connect();
+	if (ret != KErrNone)
+		return ret;
+	CTrapCleanup* cleanupStack = CTrapCleanup::New();
+	if (cleanupStack == NULL)
+		return KErrNoMemory;
+	TRAP(ret, AlternateTestThreadL(*static_cast<TTestThreadParams*>(aParams)));
+	delete cleanupStack;
+	RFbsSession::Disconnect();
+	__UHEAP_MARKEND;
+	return ret;
+	}
+
+void CTBitmap::MultiThreadedTestsL()
+	{
+	((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0503"));
+	MultiThreadedResizeTestL();
+	((CTBitmapStep*)iStep)->RecordTestResultL();
+	((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0504"));
+	MultiThreadedCompressTestL();
+#ifdef SYMBIAN_DEBUG_FBS_LOCKHEAP
+	((CTBitmapStep*)iStep)->RecordTestResultL();
+	((CTBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0505"));
+	MultiThreadedLockHeapTestL();
+#endif
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-FBSERV-0503
+
+@SYMDEF					DEF090812
+
+@SYMTestCaseDesc		Tests behaviour of CFbsBitmap::DataAddress() and CFbsBitmap::Resize() when called concurrently by different threads
+
+@SYMTestPriority		High
+
+@SYMTestType			UT
+
+@SYMTestStatus			Implemented
+
+@SYMTestActions			1. The 1st thread will create a bitmap, store a pointer to the bitmap data, launch the 2nd thread and then wait for it to terminate
+						2. The 2nd thread will resize the same bitmap and exit
+						3. The 1st thread will manipulate the bitmap data using the stored pointer and then re-fetch the bitmap data
+
+@SYMTestExpectedResults	The 1st thread should be able both to manipulate the old bitmap data and check the resized bitmap data
+*/
+void CTBitmap::MultiThreadedResizeTestL()
+	{
+	INFO_PRINTF1(_L("Test Resize() with Multiple Threads"));
+	DoMultiThreadedTestL(_L("AlternateResizeThread"), ResizeTestBitmap, BitmapCheckResized);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-FBSERV-0504
+
+@SYMDEF					DEF090812
+
+@SYMTestCaseDesc		Tests behaviour of CFbsBitmap::DataAddress() and CFbsBitmap::Compress() when called concurrently by different threads
+
+@SYMTestPriority		High
+
+@SYMTestType			UT
+
+@SYMTestStatus			Implemented
+
+@SYMTestActions			1. The 1st thread will create a bitmap, store a pointer to the bitmap data, launch the 2nd thread and then wait for it to terminate
+						2. The 2nd thread will compress the same bitmap and exit
+						3. The 1st thread will manipulate the bitmap data using the stored pointer and then re-fetch the bitmap data
+
+@SYMTestExpectedResults	The 1st thread should be able both to manipulate the old bitmap data and check the compressed bitmap data
+*/
+void CTBitmap::MultiThreadedCompressTestL()
+	{
+	INFO_PRINTF1(_L("Test Compress() with Multiple Threads"));
+	DoMultiThreadedTestL(_L("AlternateCompressThread"), CompressTestBitmap, BitmapCheckCompressed);
+	}
+
+void CTBitmap::DoMultiThreadedTestL(const TDesC& aThreadName, TInt (*aBitmapFunction)(CFbsBitmap*), TBool (*aCheckFunction)(const CFbsBitmap*))
+	{
+	CFbsBitmap* bmp = new CFbsBitmap;
+	ASSERT_NOT_NULL(bmp);
+	CleanupStack::PushL(bmp);
+	TInt ret = bmp->Create(TSize(KTestBitmapWidth, KTestBitmapHeight), EGray256);
+	ASSERT_EQUALS(ret, KErrNone);
+	TUint8* dataPtr = (TUint8*)bmp->DataAddress();
+	SetBitmapDataWithVerticalGradient(dataPtr);
+	TTestThreadParams params;
+	params.iBitmapHandle = bmp->Handle();
+	params.iBitmapFunction = aBitmapFunction;
+	params.iCheckFunction = aCheckFunction;
+	RThread thread;
+	ret = thread.Create(aThreadName, AlternateTestThread, KDefaultStackSize, 0x2000, 0x2000, &params);
+	ASSERT_EQUALS(ret, KErrNone);
+	TRequestStatus status;
+	thread.Logon(status);
+	thread.Resume();
+	User::WaitForRequest(status);
+	TExitType exitType = thread.ExitType();
+	TInt exitReason = thread.ExitReason();
+	TEST(exitType == EExitKill);
+	TEST(exitReason == KErrNone);
+	thread.Close();
+	TEST(BitmapDataCheckVerticalGradient(dataPtr));
+	SetBitmapDataWithHorizontalGradient(dataPtr);
+	TEST(BitmapDataCheckHorizontalGradient(dataPtr));
+	TEST((*aCheckFunction)(bmp));
+	CleanupStack::PopAndDestroy(bmp);
+	User::Heap().Check();
+	}
+
+#ifdef SYMBIAN_DEBUG_FBS_LOCKHEAP
+_LIT(KFBSERVClientPanicCategory, "FBSCLI");
+
+LOCAL_C TInt LockHeapTestBitmap(CFbsBitmap* aBitmap)
+	{
+	aBitmap->LockHeap();
+	return KErrNone;
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-FBSERV-0505
+
+@SYMDEF					DEF090812
+
+@SYMTestCaseDesc		Tests behaviour of CFbsBitmap::LockHeap() when called concurrently by different threads
+
+@SYMTestPriority		High
+
+@SYMTestType			UT
+
+@SYMTestStatus			Implemented
+
+@SYMTestActions			1. The 1st thread will create a bitmap, call LockHeap() on it, launch the 2nd thread and then wait for it to terminate
+						2. The 2nd thread will also call LockHeap() on the same bitmap
+						3. The 1st thread will check that the 2nd thread has panicked
+
+@SYMTestExpectedResults	Panic FBSCLI 22
+*/
+void CTBitmap::MultiThreadedLockHeapTestL()
+	{
+	INFO_PRINTF1(_L("Test LockHeap() Panic with Multiple Threads"));
+	CFbsBitmap* bmp = new CFbsBitmap;
+	ASSERT_NOT_NULL(bmp);
+	CleanupStack::PushL(bmp);
+	TInt ret = bmp->Create(TSize(KTestBitmapWidth, KTestBitmapHeight), EGray256);
+	ASSERT_EQUALS(ret, KErrNone);
+	SetBitmapDataWithVerticalGradient((TUint8*)bmp->DataAddress());
+	bmp->LockHeap();
+	TTestThreadParams params;
+	params.iBitmapHandle = bmp->Handle();
+	params.iBitmapFunction = LockHeapTestBitmap;
+	params.iCheckFunction = NULL;
+	RThread thread;
+	ret = thread.Create(_L("AlternateLockHeapThread"), AlternateTestThread, KDefaultStackSize, 0x2000, 0x2000, &params);
+	ASSERT_EQUALS(ret, KErrNone);
+	TRequestStatus status;
+	thread.Logon(status);
+	thread.Resume();
+	User::WaitForRequest(status);
+	TExitType exitType = thread.ExitType();
+	TExitCategoryName exitCategory = thread.ExitCategory();
+	TInt exitReason = thread.ExitReason();
+	TEST(exitType == EExitPanic);
+	TEST(exitCategory == KFBSERVClientPanicCategory);
+	TEST(exitReason == EFbsPanicBadHeapLock);
+	thread.Close();
+	CleanupStack::PopAndDestroy(bmp);
+	User::Heap().Check();
+	}
+#endif
+
+//--------------
+
+class CStopTestBgCompress: public CAsyncOneShot
+	{
+public:
+	CStopTestBgCompress(): CAsyncOneShot(CActive::EPriorityIdle - 1) {} // priority must be less than CFbsSessionHelper
+	void RunL() { CActiveScheduler::Stop(); }
+	};
+
+LOCAL_C TInt TestBgCompressThread(TAny* /*aParams*/)
+	{
+	const TInt KBmpSize = 0x100000 + sizeof(SEpocBitmapHeader);
+	// assuming run-length encoding every scan line gets compressed into 8 runs of 128 bytes each
+	// 2 bytes per encoded run results in 16 bytes per scan line so the compressed bitmap is large (>16K)
+	// a few bytes added at the end for the compression bookmark are rounded up to a page
+	const TInt KBmpCompressedSize = 0x5000;
+	TInt ret = KErrNone;
+	__UHEAP_MARK;
+	CTrapCleanup* trap = CTrapCleanup::New();
+	TRequestStatus status;
+	if (trap == NULL)
+		{
+		ret = KErrNoMemory;
+		goto exitNoTrap;
+		}
+	CActiveScheduler* scheduler = new CActiveScheduler;
+	if (scheduler == NULL)
+		{
+		ret = KErrNoMemory;
+		goto exitNoScheduler;
+		}
+	CActiveScheduler::Install(scheduler);
+	CStopTestBgCompress* stop = new CStopTestBgCompress;
+	if (stop == NULL)
+		{
+		ret = KErrNoMemory;
+		goto exitNoStop;
+		}
+	ret = RFbsSession::Connect();
+	if (ret != KErrNone)
+		goto exitNoFbs;
+	CFbsBitmapEx* bmp = new CFbsBitmapEx;
+	if (bmp == NULL)
+		{
+		ret = KErrNoMemory;
+		goto exitNoBmp;
+		}
+	CFbsBitmapEx* bmp2 = new CFbsBitmapEx;
+	if (bmp2 == NULL)
+		{
+		ret = KErrNoMemory;
+		goto exitNoBmp2;
+		}
+	ret = bmp->Create(TSize(1024, 1024), EGray256); // create a solid white bitmap
+	if (ret != KErrNone)
+		goto exitAll;
+	ret = bmp2->Duplicate(bmp->Handle()); // duplicate the bitmap handle
+	if (ret != KErrNone)
+		goto exitAll;
+	bmp->CompressInBackground(status);
+	User::WaitForRequest(status);
+	if (status != KErrNone)
+		{
+		ret = status.Int();
+		goto exitAll;
+		}
+	if (bmp->BitmapAddress()->Header().iBitmapSize != KBmpSize || bmp->BitmapAddress() != bmp2->BitmapAddress())
+		{
+		ret = KErrGeneral;
+		goto exitAll;
+		}
+	stop->Call();
+	CActiveScheduler::Start(); // now CFbsSessionHelper should clean both bmp and bmp2 and free the dirty bitmap data
+	if (!bmp->BitmapAddress()->IsCompressedInRAM() || bmp->BitmapAddress()->Header().iBitmapSize > KBmpCompressedSize || bmp->BitmapAddress() != bmp2->BitmapAddress())
+		ret = KErrGeneral;
+exitAll:
+	delete bmp2;
+exitNoBmp2:
+	delete bmp;
+exitNoBmp:
+	RFbsSession::Disconnect();
+exitNoFbs:
+	delete stop;
+exitNoStop:
+	delete scheduler;
+exitNoScheduler:
+	delete trap;
+exitNoTrap:
+	__UHEAP_MARKEND;
+	return ret;
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-FBSERV-0612
+
+@SYMDEF					INC109293
+
+@SYMTestCaseDesc		Tests memory usage with CFbsBitmap::CompressInBackground()
+
+@SYMTestPriority		High
+
+@SYMTestType			UT
+
+@SYMTestStatus			Implemented
+
+@SYMTestActions			1. Creates a bitmap
+						2. Calls CompressInBackground()
+						3. Waits until compression is finished
+						4. Gives the active scheduler the chance to run the session's helper
+
+@SYMTestExpectedResults	Efficient use of memory
+*/
+void CTBitmap::TestBgCompressL()
+	{
+	INFO_PRINTF1(_L("Test memory usage with CFbsBitmap::CompressInBackground()"));
+	RThread thread;
+	TInt ret = thread.Create(_L("TestBgCompressThread"), TestBgCompressThread, KDefaultStackSize, 0x2000, 0x2000, NULL);
+	ASSERT_EQUALS(ret, KErrNone);
+	TRequestStatus status;
+	thread.Logon(status);
+	thread.Resume();
+	User::WaitForRequest(status);
+	TExitType exitType = thread.ExitType();
+	TInt exitReason = thread.ExitReason();
+	TEST(exitType == EExitKill);
+	TEST(exitReason == KErrNone);
+	if (exitType != EExitKill || exitReason != KErrNone)
+		{
+		INFO_PRINTF3(_L("Exit Type = %d, Exit Reason = %d"), TInt(exitType), exitReason);
+		}
+	thread.Close();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-FBSERV-0618
+
+@SYMDEF					DEF123068
+
+@SYMTestCaseDesc		Tests that small and large bitmaps are white-filled upon creation.
+
+@SYMTestPriority		High
+
+@SYMTestType			UT
+
+@SYMTestStatus			Implemented
+
+@SYMTestActions			1. Create a small bitmap
+						2. Create a large bitmap
+
+@SYMTestExpectedResults	Both bitmaps are filled with white
+*/
+void CTBitmap::TestBitmapWhiteFillL()
+	{
+	INFO_PRINTF1(_L("Test white fill of CFbsBitmap upon creation."));
+	const TDisplayMode KDispMode = EColor16MAP;
+	RPointerArray<CFbsBitmap> bmpArray;
+	const TSize KBitmapSmallSize(4,4);
+	const TSize KBitmapLargeSize(200,200);
+	
+	// Create small CFbsBitmap
+	CFbsBitmap* bmp = new (ELeave) CFbsBitmap;;
+	TInt ret = bmp->Create(KBitmapSmallSize,KDispMode);
+	TEST2(ret, KErrNone);
+	bmpArray.AppendL(bmp);
+	// Create large CFbsBitmap
+	bmp = new (ELeave) CFbsBitmap;;
+	ret = bmp->Create(KBitmapLargeSize,KDispMode);
+	TEST2(ret, KErrNone);
+	bmpArray.AppendL(bmp);
+	// Create small hardware bitmap
+	bmp = new (ELeave) CFbsBitmap;;
+	ret = bmp->CreateHardwareBitmap(KBitmapSmallSize, KDispMode, KNullUid);
+	if (ret == KErrNotSupported)
+		{
+		INFO_PRINTF1(_L("WhiteFill test skipped for small hardware bitmaps as they are not supported"));
+		delete bmp;
+		}
+	else
+		{
+		TEST2(ret, KErrNone);
+		bmpArray.AppendL(bmp);
+		}
+	// Create large hardware bitmap
+	bmp = new (ELeave) CFbsBitmap;;
+	ret = bmp->CreateHardwareBitmap(KBitmapLargeSize, KDispMode, KNullUid);
+	if (ret == KErrNotSupported)
+		{
+		INFO_PRINTF1(_L("WhiteFill test skipped for large hardware bitmaps as they are not supported"));
+		delete bmp;
+		}
+	else
+		{
+		TEST2(ret, KErrNone);
+		bmpArray.AppendL(bmp);
+		}
+	
+	for (TInt ii = 0; ii < bmpArray.Count(); ++ii)
+		{
+		bmp = bmpArray[ii];
+		bmp->BeginDataAccess();
+		TUint32* base = bmp->DataAddress();
+		TSize size = bmp->SizeInPixels();
+		TInt scanLineLength = CFbsBitmap::ScanLineLength(size.iWidth,KDispMode);
+		TInt dataLength = scanLineLength * size.iHeight;
+		CheckWhite((TUint8*)base,dataLength,KDispMode);
+		bmp->EndDataAccess(ETrue);
+		delete bmp;
+		}
+	bmpArray.Close();
+	}
+
+//--------------
+
+// The code for regression test case GRAPHICS-FBSERV-0614 must be in a separate thread
+// because it has to call RFbsSession::Disconnect() and without the fix it panics.
+LOCAL_C TInt TestDisconnectWithBitmapThread(TAny* /*aParams*/)
+	{
+	CTrapCleanup* trap = CTrapCleanup::New();
+	if (trap == NULL)
+		return KErrNoMemory;
+	CActiveScheduler* scheduler = new CActiveScheduler;
+	if (scheduler == NULL)
+		{
+		delete trap;
+		return KErrNoMemory;
+		}
+	CActiveScheduler::Install(scheduler);
+	TInt ret = RFbsSession::Connect();
+	if (ret != KErrNone)
+		{
+		delete scheduler;
+		delete trap;
+		return ret;
+		}
+	CFbsBitmap* bmp = new CFbsBitmap;
+	if (bmp == NULL)
+		{
+		RFbsSession::Disconnect();
+		delete scheduler;
+		delete trap;
+		return KErrNoMemory;
+		}
+	ret = bmp->Create(TSize(256, 256), EGray256); // create a solid white bitmap
+	if (ret != KErrNone)
+		{
+		RFbsSession::Disconnect();
+		delete scheduler;
+		delete trap;
+		return ret;
+		}
+	RFbsSession::Disconnect();
+	delete scheduler;
+	delete trap;
+	return ret;
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-FBSERV-0614
+
+@SYMDEF					INC113118
+
+@SYMTestCaseDesc		Tests behaviour when RFbsSession::Disconnect() is called and there is a CFbsBitmap not yet deleted
+
+@SYMTestPriority		High
+
+@SYMTestType			UT
+
+@SYMTestStatus			Implemented
+
+@SYMTestActions			1. Creates and installs an active scheduler so that CFbsSessionHelper can be activated
+						2. Calls RFbsSession::Connect()
+						3. Creates a bitmap
+						4. Calls RFbsSession::Disconnect()
+
+@SYMTestExpectedResults	The bitmap should be destroyed automatically and no panics should occur
+*/
+void CTBitmap::TestDisconnectWithBitmapL()
+	{
+	INFO_PRINTF1(_L("Test RFbsSession::Disconnect() with a CFbsBitmap not yet deleted"));
+	RThread thread;
+	TInt ret = thread.Create(_L("TestDisconnectWithBitmapThread"), TestDisconnectWithBitmapThread, KDefaultStackSize, 0x2000, 0x2000, NULL);
+	ASSERT_EQUALS(ret, KErrNone);
+	TRequestStatus status;
+	thread.Logon(status);
+	thread.Resume();
+	User::WaitForRequest(status);
+	TExitType exitType = thread.ExitType();
+	TInt exitReason = thread.ExitReason();
+	TEST(exitType == EExitKill);
+	TEST(exitReason == KErrNone);
+	thread.Close();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-FBSERV-0617
+
+@SYMPREQ				PREQ39
+
+@SYMTestCaseDesc		Test that bitmaps have been touched when data changes.
+						Test that bitmaps become volatile when DataAddress is called outside of 
+						calls to  BeginDataAccess()	and EndDataAccess().
+
+@SYMTestStatus			Implemented
+
+@SYMTestPriority		High
+
+@SYMTestActions			Create a bitmap.
+						Call each public API.
+						Check that the touch count increases when the bitmap data has been modified.
+						Check whether bitmap is volatile.
+@SYMTestExpectedResults	Touch count only increases for the following functions:
+	 						Resize,
+	 						SetDisplayMode,
+	 						SetScanLine,
+	 						InternalizeL,
+	 						SwapWidthAndHeight,
+	 						DataAddress() called inside a Begin() and End(EFalse) pairing.
+	 					Bitmap is volatile only when DataAddress() called outside
+	 					a Begin() and End(EFalse) pairing.
+*/
+void CTBitmap::TestTouchedAndVolatileL()
+	{
+	INFO_PRINTF1(_L("Test bitmaps become touched or volatile when data changes."));
+	CFbsBitmap* bmp = new CFbsBitmap;
+	TEST(bmp != NULL);
+	TInt touchCount = 0;
+	TInt newTouchCount = 0;
+	CleanupStack::PushL(bmp);
+	
+	// Resize
+	User::LeaveIfError(bmp->Create(TSize(4,4),EColor16MA));
+	touchCount = bmp->TouchCount();
+	TInt ret = bmp->Resize(TSize(5,5));
+	TEST(ret == KErrNone);
+	newTouchCount = bmp->TouchCount();
+	TEST(newTouchCount == touchCount+1);
+	TEST(!bmp->IsVolatile());
+	touchCount = bmp->TouchCount();
+	ret = bmp->Resize(TSize(3,3));
+	TEST(ret == KErrNone);
+	newTouchCount = bmp->TouchCount();
+	TEST(newTouchCount == touchCount+1);
+	TEST(!bmp->IsVolatile());
+	touchCount = bmp->TouchCount();
+	ret = bmp->Resize(TSize(3,3));
+	TEST(ret == KErrNone);
+	newTouchCount = bmp->TouchCount();
+	TEST(newTouchCount == touchCount+1);
+	TEST(!bmp->IsVolatile());
+	bmp->Reset();
+
+	// SetDisplayMode
+	User::LeaveIfError(bmp->Create(TSize(4,4),EColor16MA));
+	touchCount = bmp->TouchCount();
+	ret = bmp->SetDisplayMode(EColor16MAP);
+	TEST(ret == KErrNone);
+	newTouchCount = bmp->TouchCount();
+	TEST(newTouchCount == touchCount+1);
+	TEST(!bmp->IsVolatile());
+	bmp->Reset();
+
+	// SetScanLine
+	TInt scanLineLength = CFbsBitmap::ScanLineLength(256,EColor16MA);
+	TUint8* buffer = new TUint8[scanLineLength];
+	TEST(buffer != NULL);
+	TPtr8 scanline(buffer,scanLineLength,scanLineLength);
+	User::LeaveIfError(bmp->Create(TSize(4,4),EColor16MA));
+	touchCount = bmp->TouchCount();
+	bmp->SetScanLine(scanline, 1);
+	newTouchCount = bmp->TouchCount();
+	TEST(newTouchCount == touchCount+1);
+	TEST(!bmp->IsVolatile());
+	delete[] buffer;
+	bmp->Reset();
+
+	// SwapWidthAndHeight
+	User::LeaveIfError(bmp->Create(TSize(4,6),EColor16MA));
+	touchCount = bmp->TouchCount();
+	ret = bmp->SwapWidthAndHeight();
+	TEST(ret == KErrNone);
+	newTouchCount = bmp->TouchCount();
+	TEST(newTouchCount == touchCount+1);
+	TEST(!bmp->IsVolatile());
+	bmp->Reset();
+
+	// InternalizeL
+	// Requires data to be externalised first
+	User::LeaveIfError(bmp->Create(TSize(4,6),EColor16MA));
+	touchCount = bmp->TouchCount();
+	CDirectFileStore* writestore = CDirectFileStore::ReplaceL(iFs,KTempFilename,EFileStream|EFileWrite);
+	TEST(writestore != NULL);
+	TUidType uidtype(KDirectFileStoreLayoutUid,KMultiBitmapFileImageUid);
+	writestore->SetTypeL(uidtype);
+	RStoreWriteStream writestrm;
+	TStreamId headerid(0);
+	headerid = writestrm.CreateL(*writestore);
+	writestore->SetRootL(headerid);
+	bmp->ExternalizeL(writestrm);
+	writestrm.Close();
+	delete writestore;
+	bmp->Reset();
+	// Now internalise data to reset bitmap.
+	CDirectFileStore* readstore = CDirectFileStore::OpenL(iFs,KTempFilename,EFileStream|EFileRead);
+	RStoreReadStream readstrm;
+	headerid = readstore->Root();
+	readstrm.OpenL(*readstore,headerid);
+	bmp->InternalizeL(readstrm);
+	readstrm.Close();
+	delete readstore;
+	newTouchCount = bmp->TouchCount();
+	TEST(newTouchCount == touchCount+1);
+	TEST(!bmp->IsVolatile());
+	bmp->Reset();
+	
+	
+	// DataAddress
+	// 1. Call as read-only (by passing ETrue into End())
+	// Expect: touch count doesn't increase & bitmap not volatile
+	User::LeaveIfError(bmp->Create(TSize(4,6),EColor16MA));
+	touchCount = bmp->TouchCount();
+	bmp->BeginDataAccess();
+	bmp->DataAddress(); // ignore returned value for this test.
+	bmp->EndDataAccess(ETrue);
+	newTouchCount = bmp->TouchCount();
+	TEST(newTouchCount == touchCount);
+	TEST(!bmp->IsVolatile());
+	// 2. Call as writeable  (by passing EFalse into End())
+	// Expect: touch count increases & bitmap not volatile
+	touchCount = newTouchCount;
+	bmp->BeginDataAccess();
+	bmp->DataAddress(); // ignore returned value for this test.
+	bmp->EndDataAccess(EFalse);
+	newTouchCount = bmp->TouchCount();
+	TEST(newTouchCount == touchCount+1);
+	TEST(!bmp->IsVolatile());
+	// 3. Call without Begin/End pairing
+	// Expect: bitmap is volatile
+	bmp->DataAddress(); // ignore returned value for this test.
+	TEST(bmp->IsVolatile());
+	bmp->Reset();
+
+	CleanupStack::PopAndDestroy(bmp);
+	}
+
+//--------------
+__CONSTRUCT_STEP__(Bitmap)
+
+void CTBitmapStep::TestSetupL()
+	{
+	TheFs.Connect();
+	::CopyFilesOnC();
+	}
+	
+void CTBitmapStep::TestClose()
+	{
+	::DeleteFilesFromC();		//clean up data files used by this test - must be done before call to End() - DEF047652
+	TheFs.Close();
+	}
+