FCL/sf/os/kernelhwsrv: comparison kerneltest/e32test/defrag/t

equal deleted inserted replaced

--1:000000000000
+:a41df078684a
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "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:
+// e32test\defrag\t_ramdefrag.cpp
+// RAM Defragmentation Functional Tests
+//
+//
+//#define RUN_ALL_TESTS			// Uncomment to ensure that all tests are run regardless of test failures
+//#define DEBUG_VER				// Uncomment for information output from tests
+#define __E32TEST_EXTENSION__
+#include <e32test.h>
+RTest test(_L("T_RAMDEFRAG"));
+#include <e32rom.h>
+#include <u32hal.h>
+#include <f32file.h>
+#include <f32dbg.h>
+#include <e32msgqueue.h>
+#include <e32math.h>
+#include <hal.h>
+#include "testdefs.h"
+#include <dptest.h>
+#include "t_ramdefrag.h"
+#define READ(a) ReadByte((volatile TUint8*)(a))
+#ifdef RUN_ALL_TESTS
+#define TEST_FAIL {gTestStepFailed++;}
+#define CLEANUP(a) {}
+#else
+#define TEST_FAIL {TestCleanup(); test(EFalse);}
+#define CLEANUP(a) {if (!gFailPrintPageInfo) \
+						{ \
+						PrintPageInfo(); \
+						gFailPrintPageInfo = ETrue; \
+						} \
+					a;}
+#endif
+#define TEST_DRIVER_OPEN		1
+#define TEST_DRIVER_CLOSE		0
+#define BEST_MOVABLE			1
+#define BEST_DISCARDABLE		2
+#define BEST_FIXED				3
+#define Z_ALLOC_CONTIG			1
+#define Z_ALLOC_DISC			2
+LOCAL_D TUint gTestStarted = EFalse;								// Used to ensure matching TestStart() and TestEnd().
+LOCAL_D TBool gPagedRom = ETrue;									// Stores whether or not is a paged ROM
+LOCAL_D TInt gTestStepFailed = 0;									// Stores the number of test steps failed
+LOCAL_D TBool gFailPrintPageInfo = EFalse;							// Set to ETrue once CLEANUP has been invoked once.
+LOCAL_D TBool gFileCacheRun = EFalse;								// Set to ETrue whe FSCaching tests have been run
+LOCAL_D TInt gRamSize;												// The total RAM size in bytes
+LOCAL_D TInt gFreeRam;												// The amount of free RAM available in bytes
+LOCAL_D TInt gPageSize;												// The number of bytes per page
+LOCAL_D TUint gPageShift;
+#ifdef DEBUG_VER
+LOCAL_D TInt gRamUsed; 												// The amount of RAM used in bytes
+#endif
+LOCAL_D TInt gInitialRam;											// The initial free RAM before a test starts
+LOCAL_D TInt gEndRam;												// The end free RAM when a test finishes
+LOCAL_D TUint gOriginalMinCacheSize;									// The original DP minSize
+LOCAL_D TUint gOriginalMaxCacheSize;									// The original DP maxSize
+LOCAL_D TInt gTotalRamLost;											// The total amount of RAM lost during the test
+LOCAL_D TUint gZoneCount = 0;										// Number of zones
+LOCAL_D const TUint KInvalidZoneID = 0xffffffff;					// Invalid value for a zone ID
+LOCAL_D STestPageCount gTotalPageCount;
+LOCAL_D struct SRamZoneConfig*	gZoneConfigArray;					// Contains the configurations of all the zones
+LOCAL_D struct SRamZoneUtilisation*	gZoneUtilArray;					// Contains the utilisations of all the zones
+LOCAL_D struct SRamZoneUtilisation* gOriginalPageCountArray;		// Contains the original utilisations of the zones
+LOCAL_D TInt* gPrefArray;											// Contains the preference order of the zones
+LOCAL_D TUint8* gOrigFlagArray;										// Contains the orignal values for the zone flags
+LOCAL_D TInt gDefragMaxPages = 0;
+const TInt KFillAllMovable = -1;
+LOCAL_D RChunk* gChunkArray1 = NULL;								// Stores reference to all the chunks that have been created
+LOCAL_D RChunk* gChunkArray2 = NULL;								// Stores reference to all the chunks that have been created
+LOCAL_D TUint gChunkArraySize1 = 0;									// The size of the array gChunkArray
+LOCAL_D TUint gChunkArraySize2 = 0;									// The size of the array gChunkArray
+const TUint KChunkDefaultSize = 0x300000;
+const TUint KMaxChunks = 14;
+LOCAL_D const TUint KNumAllocChunks = 10;							// The number of chunks to be allocd for some tests.
+LOCAL_D RRamDefragFuncTestLdd Ldd;									// Main Ldd used to call into device driver
+LOCAL_D TBuf<20> gTestThreadName =_L("TestThread");
+LOCAL_D RThread gTestThread;
+LOCAL_D TRequestStatus status;
+LOCAL_D TInt gDrive;												// The removable media drive
+LOCAL_D RFs gTheFs;
+LOCAL_D TFileName gSessionPath;
+const TInt KNoRemovableDrive = -1;									// gDrive is set to this when no suitable drive can be found.
+const TInt KDefaultCacheSize = (128 + 12) * 1024;					// The default file system cache size
+const TUint KNumFilesOrig = (32 * 1024 * 1024) / KDefaultCacheSize;	// The number of files that are needed to fill the file system cache
+LOCAL_D TInt gFilesNeededToFillCache = KNumFilesOrig ;				// Not constant as can change depending on the size of the disk
+LOCAL_D RFile gFile[KNumFilesOrig];
+LOCAL_D TInt* gCandList1;											// Array of zones that have the same preference and the same
+LOCAL_D TInt* gCandList2;											// amount of free pages
+const TInt KInvalidCandIndex = -1;
+//
+// GetDrive
+//
+// Gets the removable drive number
+//
+TInt GetDrive()
+	{
+	RFs theFs;
+	TInt r = theFs.Connect();
+	test_KErrNone(r);
+	TInt driveLet = KNoRemovableDrive;
+	TInt i = EDriveA;
+	for (; i <= EDriveZ; i++)
+		{
+		TVolumeInfo volInfo;
+		r = theFs.Volume(volInfo, i);
+		if (r == KErrNone)
+			{// This drive no. exists so determine if it is removable and
+			//  formattable media.
+			if ((volInfo.iDrive.iDriveAtt & KDriveAttRemovable) &&
+				(volInfo.iDrive.iMediaAtt & KMediaAttFormattable))
+				{
+				driveLet = i;
+				break;
+				}
+			}
+		}
+	theFs.Close();
+	return driveLet;
+	}
+//
+// DeviceDriver
+//
+// Opens or closes the device driver used
+//
+TInt DeviceDriver(TInt aFunctionNum)
+	{
+	TInt r = 0;
+	switch (aFunctionNum)
+		{
+		case TEST_DRIVER_OPEN:
+			{
+			r = User::LoadLogicalDevice(KRamDefragFuncTestLddName);
+			test(r==KErrNone || r==KErrAlreadyExists);
+			r = Ldd.Open();
+			test_KErrNone(r);
+			}
+		break;
+		case TEST_DRIVER_CLOSE:
+			{
+			Ldd.Close();
+			r = User::FreeLogicalDevice(KRamDefragFuncTestLddName);
+			test_KErrNone(r);
+			}
+		break;
+		default:
+		break;
+		}
+	return r;
+	}
+//
+// GetOriginalPageCount
+//
+// Obtains the orginal types of pages in each of the zones
+//
+void GetOriginalPageCount()
+	{
+	TUint index;
+	TInt ret = 0;
+	TESTDEBUG(test.Printf(_L("ram defrag : Get info about the zones\n")));
+	for (index = 0; index < gZoneCount; index ++)
+		{
+		ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneUtilisation,(TAny*)index, (TAny*)&gOriginalPageCountArray[index]);
+		test(ret == KErrNone);
+		}
+	}
+//
+// PrintPageInfo
+//
+// Prints various page information to the screen
+//
+void PrintPageInfo()
+	{
+	test.Printf(_L("\nZONE CONFIGURATIONS:\n"));
+	for (TUint index = 0; index < gZoneCount; index ++)
+		{
+		TInt ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneConfig,(TAny*)index, (TAny*)&gZoneConfigArray[index]);
+		test(ret == KErrNone);
+		test.Printf(_L("config : id=0x%08x  index=%-2d  base=0x%08x  end=0x%08x  pages=0x%08x  pref=%-2d  flags=0x%x\n"),
+					gZoneConfigArray[index].iZoneId,gZoneConfigArray[index].iZoneIndex,
+					gZoneConfigArray[index].iPhysBase,gZoneConfigArray[index].iPhysEnd,
+					gZoneConfigArray[index].iPhysPages,gZoneConfigArray[index].iPref,gZoneConfigArray[index].iFlags);
+		}
+	test.Printf(_L("\nZONE UTILISATIONS:\n"));
+	for (TUint index = 0; index < gZoneCount; index ++)
+		{
+		TInt ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneUtilisation,(TAny*)index, (TAny*)&gZoneUtilArray[index]);
+		test(ret == KErrNone);
+		test.Printf(_L("usage  : id=0x%08x  index=%-2d  pref=%d  pages=0x%08x free=0x%08x  unknown=0x%08x  fixed=0x%08x  move=0x%08x  discard=0x%08x  other=0x%08x\n"),
+					gZoneUtilArray[index].iZoneId,gZoneUtilArray[index].iZoneIndex,gZoneConfigArray[index].iPref,
+					gZoneUtilArray[index].iPhysPages,gZoneUtilArray[index].iFreePages,
+					gZoneUtilArray[index].iAllocUnknown,gZoneUtilArray[index].iAllocFixed,gZoneUtilArray[index].iAllocMovable,
+					gZoneUtilArray[index].iAllocDiscardable,gZoneUtilArray[index].iAllocOther);
+		}
+	}
+//
+// GetAllPageInfo
+//
+// Get various different page information for all zones
+// Also updates the total page count
+//
+void GetAllPageInfo()
+	{
+	TInt ret = 0;
+	gTotalPageCount.iFreePages = 0;
+	gTotalPageCount.iUnknownPages = 0;
+	gTotalPageCount.iFixedPages = 0;
+	gTotalPageCount.iMovablePages = 0;
+	gTotalPageCount.iDiscardablePages = 0;
+	gTotalPageCount.iOtherPages = 0;
+	// now get the config of each of the zones.
+	TUint	index;
+	TESTDEBUG(test.Printf(_L("ram defrag : Get info about the zones\n")));
+	for (index = 0; index < gZoneCount; index ++)
+		{
+		ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneConfig,(TAny*)index, (TAny*)&gZoneConfigArray[index]);
+		test(ret == KErrNone);
+		ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneUtilisation,(TAny*)index, (TAny*)&gZoneUtilArray[index]);
+		test(ret == KErrNone);
+		gTotalPageCount.iFreePages += gZoneUtilArray[index].iFreePages;
+		gTotalPageCount.iUnknownPages += gZoneUtilArray[index].iAllocUnknown;
+		gTotalPageCount.iFixedPages += gZoneUtilArray[index].iAllocFixed;
+		gTotalPageCount.iMovablePages += gZoneUtilArray[index].iAllocMovable;
+		gTotalPageCount.iDiscardablePages += gZoneUtilArray[index].iAllocDiscardable;
+		gTotalPageCount.iOtherPages += gZoneUtilArray[index].iAllocOther;
+		}
+	TESTDEBUG(test.Printf(_L("free=0x%x unknown=0x%x fixed=0x%x move=0x%x discard=0x%x other=0x%x\n"),
+					gTotalPageCount.iFreePages, gTotalPageCount.iUnknownPages, gTotalPageCount.iFixedPages,
+					gTotalPageCount.iMovablePages, gTotalPageCount.iDiscardablePages,gTotalPageCount.iOtherPages));
+	TESTDEBUG(PrintPageInfo());
+	}
+void RestoreRamZoneFlags()
+	{
+	GetAllPageInfo(); // Update the current set of RAM zone flag data.
+	for (TUint index=0; index < gZoneCount; index++)
+		{
+		TUint zoneDefragID = gZoneConfigArray[index].iZoneId;
+		Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, ORIG_FLAG, gOrigFlagArray[index]);
+		}
+	}
+void ResetRamZoneFlags()
+	{
+	GetAllPageInfo(); // Update the current set of RAM zone flag data.
+	for (TUint index=0; index < gZoneCount; index++)
+		{
+		TUint zoneDefragID = gZoneConfigArray[index].iZoneId;
+		Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, RESET_FLAG);
+		}
+	}
+void RemoveChunkAlloc(RChunk*& aChunkArray, TUint& aChunkArraySize);
+void ResetDPCache();
+void FSCachCleanUp()
+	{
+	// If the File System Caching tests have been run,
+	// ensure that they are cleaned up
+	if (gFileCacheRun)
+		{
+		TUint i = 0;
+		// First close all the open handles to the RFile objects open
+		for (i = 0; i < KNumFilesOrig; i++)
+			{
+			gFile[i].Close();
+			}
+		// Now call EmptyRamZone on every zone to ensure that
+		// discardable pages are cleaned up
+		GetAllPageInfo();
+		for (i = 0; i < gZoneCount; i++)
+			{
+			TUint zoneID = gZoneConfigArray[i].iZoneId;
+			Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, zoneID);
+			}
+		gFileCacheRun = EFalse;
+		}
+	}
+//
+// TestCleanup
+//
+// Cleans up all the allocations made at the beginning of the test
+//
+void TestCleanup()
+	{
+	Ldd.ResetDriver();
+	// Revert the cleared flags to their original values before the tests were carried out
+	RestoreRamZoneFlags();
+	// Reset the DP cache and remove any allocated chunks and fixed pages.
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	RemoveChunkAlloc(gChunkArray2, gChunkArraySize2);
+	ResetDPCache();
+	Ldd.FreeAllFixedPages();
+	Ldd.FreeFromAllZones();
+	FSCachCleanUp();
+	User::Free(gPrefArray);
+	gPrefArray = NULL;
+	User::Free(gOrigFlagArray);
+	gOrigFlagArray = NULL;
+	User::Free(gCandList1);
+	gCandList1 = NULL;
+	User::Free(gCandList2);
+	gCandList2 = NULL;
+	User::Free(gOriginalPageCountArray);
+	gOriginalPageCountArray = NULL;
+	// Output the last possible state of memory
+	if (!gFailPrintPageInfo)
+		PrintPageInfo();
+	User::Free(gZoneConfigArray);
+	gZoneConfigArray = NULL;
+	User::Free(gZoneUtilArray);
+	gZoneUtilArray = NULL;
+	}
+// TestSetup
+//
+// Get the necessary information needed to carry out the tests
+//
+TInt TestSetup()
+	{
+	// Get the MMC drive
+	gDrive = GetDrive();
+	// first get the number of zones
+	TInt ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneCount,&gZoneCount,0);
+	if (ret != KErrNone)
+		{
+		test.Printf(_L("Cannot obtain the number of zones\n"));
+		return ret;
+		}
+	test.Printf(_L("RAM Zones (count=%u)\n"),gZoneCount);
+	// Obtain the size of the RAM and the size of a page
+	ret = HAL::Get(HAL::EMemoryRAM, gRamSize);
+	if (ret != KErrNone)
+		{
+		test.Printf(_L("Cannot obtain the size of RAM\n"));
+		return ret;
+		}
+	// Retrieve the page size and use it to detemine the page shift (assumes 32-bit system).
+	ret = HAL::Get(HAL::EMemoryPageSize, gPageSize);
+	if (ret != KErrNone)
+		{
+		test.Printf(_L("Cannot obtain the page size\n"));
+		return ret;
+		}
+	TUint32 pageMask = gPageSize;
+	TUint i = 0;
+	for (; i < 32; i++)
+		{
+		if (pageMask & 1)
+			{
+			if (pageMask & ~1u)
+				{
+				test.Printf(_L("ERROR - page size not a power of 2"));
+				return KErrNotSupported;
+				}
+			gPageShift = i;
+			break;
+			}
+		pageMask >>= 1;
+		}
+	gZoneConfigArray = (SRamZoneConfig *)User::AllocZ(sizeof(SRamZoneConfig) * gZoneCount);
+	if (gZoneConfigArray == NULL)
+		return KErrNoMemory;
+	gZoneUtilArray = (SRamZoneUtilisation *)User::AllocZ(sizeof(SRamZoneUtilisation) * gZoneCount);
+	if (gZoneUtilArray == NULL)
+		return KErrNoMemory;
+	gPrefArray = (TInt *)User::AllocZ(sizeof(TInt) * gZoneCount);
+	if (gPrefArray == NULL)
+		return KErrNoMemory;
+	gOrigFlagArray = (TUint8 *)User::AllocZ(sizeof(TUint8) * gZoneCount);
+	if (gOrigFlagArray == NULL)
+		return KErrNoMemory;
+	gOriginalPageCountArray = (SRamZoneUtilisation *)User::AllocZ(sizeof(SRamZoneUtilisation) * gZoneCount);
+	if (gOriginalPageCountArray == NULL)
+		return KErrNoMemory;
+	gCandList1 = (TInt *)User::AllocZ(sizeof(TInt) * gZoneCount);
+	if (gCandList1 == NULL)
+		return KErrNoMemory;
+	gCandList2 = (TInt *)User::AllocZ(sizeof(TInt) * gZoneCount);
+	if (gCandList2 == NULL)
+		return KErrNoMemory;
+	GetAllPageInfo();
+	PrintPageInfo();
+	// Store the original flags
+	for (i=0; i < gZoneCount; i++)
+		gOrigFlagArray[i] = gZoneConfigArray[i].iFlags;
+	// Now clear the flags for carrying out tests
+	Ldd.ResetDriver();
+	ResetRamZoneFlags();
+	// Check whether the ROM is paged or not
+	TRomHeader* romHeader = (TRomHeader*)UserSvr::RomHeaderAddress();
+	if(!romHeader->iPageableRomStart)
+		{
+		test.Printf(_L("Not a Paged ROM - Skipping all discardable page tests.\n"));
+		gPagedRom = EFalse;
+		}
+	else
+		{// Save the current state of the DP cache so it can be restored when required and
+		// after the test has finished.
+		TUint currentCacheSize;
+		DPTest::CacheSize(gOriginalMinCacheSize, gOriginalMaxCacheSize, currentCacheSize);
+		TESTDEBUG(test.Printf(_L("Original CacheSize: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"),
+									gOriginalMinCacheSize >> gPageShift, gOriginalMaxCacheSize >> gPageShift,
+									currentCacheSize >> gPageShift));
+		}
+	return KErrNone;
+	}
+//
+// UpdateRamInfo
+//
+// Updating the various RAM information
+//
+void UpdateRamInfo()
+	{
+	HAL::Get(HAL::EMemoryRAMFree, gFreeRam);
+	TESTDEBUG(gRamUsed = gRamSize - gFreeRam);
+	}
+//
+// CheckRamDifference
+//
+// Checks the difference between the initial free RAM and the end free RAM
+//
+void CheckRamDifference()
+	{
+	if (gInitialRam == gEndRam)
+		{
+		TESTDEBUG(test.Printf(_L("No RAM was lost during this test\n")));
+		}
+	else
+		{
+		TInt diff = gInitialRam - gEndRam;
+		gTotalRamLost = gTotalRamLost + diff;
+		}
+	}
+TInt VerifyMovDisAlloc();
+//
+// TestStart
+//
+// Updates the RAM information at the beginning of a test step
+//
+void TestStart()
+	{
+	test(!gTestStarted);
+	gTestStarted = ETrue;
+	Ldd.ResetDriver();
+	Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+	if (VerifyMovDisAlloc() != KErrNone)
+		{
+		CLEANUP(;);
+		TEST_FAIL;
+		}
+	UpdateRamInfo();
+	gInitialRam = gFreeRam;
+	TESTDEBUG(test.Printf(_L("Initial Free RAM = 0x%x, Initial RAM Used = 0x%x\n"), gFreeRam, gRamUsed));
+	}
+void RemoveChunkAlloc(RChunk*& aChunkArray, TUint& aChunkArraySize);
+//
+// TestEnd
+//
+// Updates RAM information at end of test step and checks the RAM delta
+//
+void TestEnd()
+	{
+	test(gTestStarted);
+	gTestStarted = EFalse;
+	gDefragMaxPages = 0;
+	// Clean up anything that may need to be cleaned.
+	ResetRamZoneFlags();
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	RemoveChunkAlloc(gChunkArray2, gChunkArraySize2);
+	ResetDPCache();
+	Ldd.FreeAllFixedPages();
+	FSCachCleanUp();
+	UpdateRamInfo();
+	gEndRam = gFreeRam;
+	TESTDEBUG(test.Printf(_L("End RAM Free = 0x%x, End RAM Used = 0x%x\n"), gEndRam, gRamUsed));
+	CheckRamDifference();
+	test.Printf(_L(" \n"));
+	}
+//
+// CheckZonesSwitchedOff
+//
+// Checks that zones have been switched off
+//
+TBool CheckZonesSwitchedOff()
+	{
+	GetAllPageInfo();
+	for (TUint i = 0; i < gZoneCount; i++)
+		{
+		if (gOriginalPageCountArray[i].iFreePages != gOriginalPageCountArray[i].iPhysPages &&
+			gZoneUtilArray[i].iFreePages == gZoneUtilArray[i].iPhysPages)
+			{
+			return ETrue;
+			}
+		}
+	return EFalse;
+	}
+//
+// CheckZoneIsOff
+//
+// Checks if a particular zone is empty
+//
+TBool CheckZoneIsOff(TUint aZoneIndex)
+	{
+	GetAllPageInfo();
+	if (gZoneUtilArray[aZoneIndex].iFreePages == gZoneUtilArray[aZoneIndex].iPhysPages)
+		{
+		TESTDEBUG(test.Printf(_L("Zone index %d is Empty\n"), aZoneIndex));
+		return ETrue;
+		}
+	else
+		{
+		TESTDEBUG(test.Printf(_L("Zone index %d is Not empty\n"), aZoneIndex));
+		return EFalse;
+		}
+	}
+//
+// GetPrefOrder
+//
+// Go through each zone ordering them in preference order
+//
+void GetPrefOrder()
+	{
+	GetAllPageInfo();
+	TESTDEBUG(PrintPageInfo());
+	for (TUint i=0; i < (TUint)gZoneCount; i++)
+		gPrefArray[i] = KErrNotFound;
+	for (TUint curIndex = 0; curIndex < gZoneCount; curIndex++)
+		{
+		TBool currentEmpty = gZoneUtilArray[curIndex].iPhysPages == gZoneUtilArray[curIndex].iFreePages;
+		TUint currentPref = gZoneConfigArray[curIndex].iPref;
+		TUint currentImmovPages = 	gZoneUtilArray[curIndex].iAllocFixed +
+									gZoneUtilArray[curIndex].iAllocUnknown;
+		TUint morePrefCnt = 0;
+		for (TUint index = 0; index < gZoneCount; index++)
+			{// A RAM zone with the same iPref is more preferable if it has
+			// more immovable pages.
+			if (gZoneConfigArray[index].iPref < currentPref ||
+				(gZoneConfigArray[index].iPref == currentPref &&
+				(currentImmovPages < gZoneUtilArray[index].iAllocFixed + gZoneUtilArray[index].iAllocUnknown ||
+				(currentEmpty &&
+				gZoneUtilArray[index].iFreePages != gZoneUtilArray[index].iPhysPages))))
+				{
+				morePrefCnt++;
+				}
+			}
+		while (gPrefArray[morePrefCnt] != KErrNotFound)
+			{// Zone(s) of this preference and size already exist so
+			 // place this one after it/them
+			morePrefCnt++;
+			}
+		gPrefArray[morePrefCnt] = curIndex;
+		}
+	}
+//
+// ZonesSamePref
+//
+// Return ETrue if the RAM zones are of the same preference.
+//
+// NOTE - This requires GetAllPageInfo() to have already been called.
+//
+TBool ZonesSamePref(TUint aZoneIndex1, TUint aZoneIndex2)
+	{
+	TBool zoneEmpty1 = gZoneUtilArray[aZoneIndex1].iFreePages == gZoneUtilArray[aZoneIndex1].iPhysPages;
+	TBool zoneEmpty2 = gZoneUtilArray[aZoneIndex2].iFreePages == gZoneUtilArray[aZoneIndex2].iPhysPages;
+	if (gZoneConfigArray[aZoneIndex1].iPref == gZoneConfigArray[aZoneIndex2].iPref &&
+		(gZoneUtilArray[aZoneIndex1].iAllocFixed + gZoneUtilArray[aZoneIndex1].iAllocUnknown ==
+		gZoneUtilArray[aZoneIndex2].iAllocFixed + gZoneUtilArray[aZoneIndex2].iAllocUnknown &&
+		(zoneEmpty1 == zoneEmpty2)))
+		{
+		return ETrue;
+		}
+	return EFalse;
+	}
+//
+// FindMostPrefEmpty
+//
+// Checks all zones and returns the most preferable RAM zone which
+// is completely emtpy
+//
+// @param aZoneIndex On return this will contain the index into gZoneUtilArray of the most preferable empty RAM zone.
+// @param aPrefIndex On return this will contain the index into gPrefArray of the most preferable empty RAM zone.
+//
+// @return KErrNotFound if a zone cannot be found, else KErrNone
+//
+TInt FindMostPrefEmpty(TUint& aZoneIndex, TUint* aPrefIndex = NULL)
+	{
+	// Get the most pref zone which is completely free to use as a test zone
+	GetPrefOrder();
+	TUint prefIndex = 0;
+	for (; prefIndex < gZoneCount; prefIndex++)
+		{
+		TUint zoneIndex = gPrefArray[prefIndex];
+		if (gZoneUtilArray[zoneIndex].iFreePages == gZoneUtilArray[zoneIndex].iPhysPages)
+			{
+			aZoneIndex = zoneIndex;
+			if (aPrefIndex)
+				{
+				*aPrefIndex = prefIndex;
+				}
+			return KErrNone;
+			}
+		}
+	return KErrNotFound;
+	}
+//
+// FindLeastPrefEmpty
+//
+// Checks all zones and returns the least preferable RAM zone which
+// is completely emtpy
+//
+// @param aZoneIndex On return this will contain the index into gZoneUtilArray of the least preferable empty RAM zone.
+// @param aPrefIndex On return this will contain the index into gPrefArray of the least preferable empty RAM zone.
+//
+// @return KErrNotFound if a zone cannot be found, else KErrNone
+//
+TInt FindLeastPrefEmpty(TUint& aZoneIndex, TUint* aPrefIndex = NULL)
+	{
+	// Get the most pref zone which is completely free to use as a test zone
+	GetPrefOrder();
+	TInt prefIndex = gZoneCount - 1;
+	for (; prefIndex >= 0; prefIndex--)
+		{
+		TUint zoneIndex = gPrefArray[prefIndex];
+		if (gZoneUtilArray[zoneIndex].iFreePages == gZoneUtilArray[zoneIndex].iPhysPages)
+			{
+			aZoneIndex = zoneIndex;
+			if (aPrefIndex)
+				{
+				*aPrefIndex = (TUint)prefIndex;
+				}
+			return KErrNone;
+			}
+		}
+	return KErrNotFound;
+	}
+//
+// FindMostPrefWithFree
+//
+// Checks all zones and returns the most preferable RAM zone which
+// has at least 1 free page
+//
+// @param aZoneIndex On return this will contain the index into gZoneUtilArray of the most preferable RAM zone with free pages.
+// @param aPrefIndex On return this will contain the index into gPrefArray of the most preferable RAM zone with free pages.
+//
+// @return KErrNotFound if a zone cannot be found, else KErrNone
+//
+TInt FindMostPrefWithFree(TUint& aZoneIndex, TUint* aPrefIndex = NULL)
+	{
+	// Get the most pref zone which has free pages
+	GetPrefOrder();
+	TUint prefIndex = 0;
+	for (; prefIndex < gZoneCount; prefIndex++)
+		{
+		TUint zoneIndex = gPrefArray[prefIndex];
+		if (gZoneUtilArray[zoneIndex].iFreePages)
+			{
+			aZoneIndex = zoneIndex;
+			if (aPrefIndex)
+				{
+				*aPrefIndex = prefIndex;
+				}
+			return KErrNone;
+			}
+		}
+	return KErrNotFound;
+	}
+//
+// CanGenSucceed
+//
+// Check whether a call to TRamDefragRequest::DefragRam() would be able to
+// succeed or not.
+//
+TBool CanGenSucceed()
+	{
+	GetPrefOrder();
+	TBool genSucceed = EFalse;
+	// Work out if general has anything to do
+	for(TInt prefIndex = (TInt)gZoneCount-1; prefIndex >= 0; prefIndex--)
+		{
+		TUint zoneIndex = gPrefArray[prefIndex];
+		TESTDEBUG(test.Printf(_L("prefIndex = %d zoneIndex = 0x%x\n"), prefIndex, zoneIndex));
+		TUint samePrefCount = 1;
+		TUint samePrefSucceed = 0;
+		// The number of zones of this preference that will be skipped by the general defrag
+		TUint samePrefEmptyImmovable = 0;
+		// Determine how many zones have the same preference as this one
+		TInt prevPrefIndex = (prefIndex != 0)? (prefIndex - 1) : -1;
+		for (; prevPrefIndex >= 0; prevPrefIndex--)
+			{
+			TUint prevIndex = gPrefArray[prevPrefIndex];
+			if (ZonesSamePref(zoneIndex, prevIndex))
+				{
+				samePrefCount++;
+				}
+			else // no more zones with this preference
+				break;
+			}
+		TESTDEBUG(test.Printf(_L("samePrefCount = %d\n"), samePrefCount));
+		for (TInt l = prefIndex - (samePrefCount-1); l <= prefIndex; l++)
+			{
+			TUint curPrefIndex = gPrefArray[l];
+			TESTDEBUG(test.Printf(_L("curPrefIndex = %d\n"), curPrefIndex));
+			if (gZoneUtilArray[curPrefIndex].iFreePages != gZoneConfigArray[curPrefIndex].iPhysPages)
+				{
+				TBool clearMovable = EFalse;
+				TBool clearDiscardable = EFalse;
+				if (gZoneUtilArray[curPrefIndex].iAllocUnknown || gZoneUtilArray[curPrefIndex].iAllocFixed)
+					{
+					TESTDEBUG(test.Printf(_L("unknown or fixed\n")));
+					samePrefEmptyImmovable++;
+					continue;
+					}
+				if (gZoneUtilArray[curPrefIndex].iAllocMovable)
+					{// determine if movable can potentially be cleared from this zone
+					TUint freeInLower = 0;
+					for (TInt j=0; j <= prefIndex; j++)
+						{
+						TUint idx = gPrefArray[j];
+						if (idx == curPrefIndex)
+							continue;
+						freeInLower += gZoneUtilArray[idx].iFreePages;
+						}
+					if (gZoneUtilArray[curPrefIndex].iAllocMovable <= freeInLower)
+						{
+						clearMovable = ETrue;
+						TESTDEBUG(test.Printf(_L("Can clear movable, curPrefIndex = %d\n"), curPrefIndex));
+						}
+					}
+				else
+					{
+					TESTDEBUG(test.Printf(_L("Can clear movable, curPrefIndex = %d\n"), curPrefIndex));
+					clearMovable = ETrue;
+					}
+				if (gZoneUtilArray[curPrefIndex].iAllocDiscardable)
+					{
+					if (gPagedRom)
+						{
+						TUint minCacheSize = 0;
+						TUint maxCacheSize = 0;
+						TUint currentCacheSize = 0;
+						DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
+						TUint spareCache = currentCacheSize - minCacheSize;
+						if (spareCache >= gZoneUtilArray[curPrefIndex].iAllocDiscardable )
+							{
+							clearDiscardable = ETrue;
+							TESTDEBUG(test.Printf(_L("Paged: Can clear discardable\n")));
+							}
+						else
+							{// determine space for discardable in more preferable zones
+							TUint freeInLower = 0;
+							for (TInt j=0; j <= prefIndex; j++)
+								{
+								TUint idx = gPrefArray[j];
+								if (idx == curPrefIndex)
+									continue;
+								freeInLower += gZoneUtilArray[idx].iFreePages;
+								}
+							if (gZoneUtilArray[curPrefIndex].iAllocDiscardable - spareCache <= freeInLower)
+								{
+								clearDiscardable = ETrue;
+								TESTDEBUG(test.Printf(_L("Paged: Can clear discardable curPrefIndex = %d\n"), curPrefIndex));
+								}
+							}
+						}
+					else
+						{//Should always be OK to discard as no min cache size on non-paged ROMS
+						clearDiscardable = ETrue;
+						test.Printf(_L("Can clear discardable curPrefIndex = %d\n"), curPrefIndex);
+						}
+					}
+				else
+					{
+					clearDiscardable = ETrue;
+					}
+				if (clearDiscardable && clearMovable)
+					{
+					samePrefSucceed++;
+					TESTDEBUG(test.Printf(_L("General should succeed ID=%x\n"), gZoneConfigArray[curPrefIndex].iZoneId));
+					}
+				}
+			else
+				{//zone already empty
+				samePrefEmptyImmovable++;
+				}
+			}
+		if (samePrefSucceed == 0 && samePrefEmptyImmovable == 0)
+			{// no zones can be defragged and none are already empty/have immovable.
+			break;
+			}
+		if (samePrefEmptyImmovable != samePrefCount)
+			{// Have reached some zones with allocated pages in them.
+			if (samePrefSucceed + samePrefEmptyImmovable == samePrefCount)
+				{// general should definitely succeed as each of the zones of this preference
+				// can be emptied or are already empty/have immovable pages allocated.
+				TESTDEBUG(test.Printf(_L("General should succeed \n")));
+				genSucceed = ETrue;
+				}
+			break;
+			}
+		prefIndex -= samePrefCount - 1;
+		}
+	return genSucceed;
+	}
+//
+// ReadByte
+//
+// Read a particular byte
+//
+TUint8 ReadByte(volatile TUint8* aPtr)
+	{
+	return *aPtr;
+	}
+//
+// AllocDiscardable
+//
+// Allocate Discardable pages in the form of demand paged pages
+//
+// @param aNumDiscardableBytes On return this will contain the number of discardable bytes above the min cache size.
+// @param aMaxBytes The new limit for maximum number of bytes in the DP cache, set to KMaxTUInt64 to fill RAM.
+// @param aMinOffsetBytes When not set to KMaxTUint64, this sets the min cache size to be the max cache size - aMinOffsetBytes.
+//
+TInt AllocDiscardable(TInt& aNumDiscardableBytes, TUint64 aMaxBytes = KMaxTUint64, TUint64 aMinOffsetBytes = KMaxTUint64)
+	{
+	TUint minCacheSize = 0;
+	TUint maxCacheSize = 0;
+	TUint currentCacheSize = 0;
+	DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
+	TESTDEBUG(test.Printf(_L("Original CacheSize: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"),
+								minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift));
+	TESTDEBUG(test.Printf(_L("SetCacheSize: minCacheSize = 0x%x, maxCacheSize = 0x%x\n"), minCacheSize >> gPageShift, aMaxBytes >> gPageShift));
+	if (aMaxBytes == KMaxTUint64)
+		{// Need to fill all of free memory with discardable pages
+		UpdateRamInfo();
+		maxCacheSize = minCacheSize + gFreeRam;
+		if (aMinOffsetBytes != KMaxTUint64)
+			{// Set the min cache size relative to the max cache size.
+			minCacheSize = maxCacheSize - aMinOffsetBytes;
+			}
+		TESTDEBUG(test.Printf(_L("free 0x%x max 0x%x min 0x%x\n"), gFreeRam, maxCacheSize, minCacheSize));
+		}
+	else
+		{
+		maxCacheSize = aMaxBytes;
+		}
+	TInt r = DPTest::SetCacheSize(maxCacheSize, maxCacheSize);
+	if (r != KErrNone)
+		return r;
+	r = DPTest::SetCacheSize(minCacheSize, maxCacheSize);
+	if (r != KErrNone)
+		return r;
+	DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
+	TESTDEBUG(test.Printf(_L("After CacheSize: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"),
+					minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift));
+	aNumDiscardableBytes = currentCacheSize - minCacheSize;
+	TESTDEBUG(test.Printf(_L("Number of discardable bytes 0x%x\n"), aNumDiscardableBytes));
+	if (aMaxBytes == KMaxTUint64)
+		{
+		UpdateRamInfo();
+		if (gFreeRam != aNumDiscardableBytes)
+			{// The only free RAM should be that of the DP cache.
+			test.Printf(_L("gFreeRam 0x%x aNumDiscardableBytes 0x%x\n"), gFreeRam, aNumDiscardableBytes);
+			return KErrGeneral;
+			}
+		}
+	return KErrNone;
+	}
+//
+// ResetDPCache
+//
+// Flush the cache and set the boundaries back to their original values
+//
+void ResetDPCache()
+	{
+	if (gPagedRom)
+		{
+		TUint minCacheSize = 0;
+		TUint maxCacheSize = 0;
+		TUint currentCacheSize = 0;
+		TESTDEBUG(test.Printf(_L("FlushCache\n")));
+		TInt r = DPTest::FlushCache();
+		DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
+		TESTDEBUG(test.Printf(_L("After CacheSize: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"),
+						minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift));
+		r = DPTest::SetCacheSize(gOriginalMinCacheSize, gOriginalMinCacheSize);
+		r = DPTest::SetCacheSize(gOriginalMinCacheSize, gOriginalMaxCacheSize);
+		TESTDEBUG(test.Printf(_L("SetCacheSize returns r = %d\n"), r));
+		DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
+		TESTDEBUG(test.Printf(_L("After CacheSize: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"),
+						minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift));
+		}
+	}
+//
+// WriteToChunk
+//
+// Write to a number of chunks
+//
+TInt WriteToChunk(RChunk* aChunkArray, TUint aChunkArraySize, TInt aChunk, TUint8 aStart=0)
+	{
+	for (TUint i=0; i<10; i++) // Write to all chunks 10 times
+		{
+		for (TUint j=0; j < aChunkArraySize; j++) //Write to all open chunks except aChunk.
+			{
+			if (aChunkArray[j].Handle() != NULL)
+				{
+				if ((TInt)j == aChunk) // Don't write to specified chunk
+					{
+					continue;
+					}
+				TUint8* base = aChunkArray[j].Base();
+				for (TUint8 k = aStart; k < aStart + 10; k++)
+					{
+					*base++ = k; // write 0 - 9 to the chunk
+					}
+				}
+			}
+		}
+	return KErrNone;
+	}
+//
+// ReadChunk
+//
+// Read chunks - If a chunk is specified, that particular chunk is not read
+//
+TInt ReadChunk(RChunk* aChunkArray, TUint aChunkArraySize, TInt aChunk=-1)
+	{
+	for (TUint j=0; j < aChunkArraySize; j++) //Read all open chunks
+		{
+		if (aChunkArray[j].Handle() != NULL)
+			{
+			if ((TInt)j == aChunk) // Don't read specified chunk
+				{
+				continue;
+				}
+			TUint8* base = aChunkArray[j].Base();
+			while ((aChunkArray[j].Base() + aChunkArray[j].Size()) != base)
+				{
+				READ(base++);
+				}
+			}
+		}
+	return KErrNone;
+	}
+//
+// RemoveChunkAlloc
+//
+// Remove ALL chunks allocated
+//
+// @param aChunkArray The array that stores a reference to the chunks created.
+// @param aChunkArraySize The size of aChunkArray.
+//
+void RemoveChunkAlloc(RChunk*& aChunkArray, TUint& aChunkArraySize)
+	{
+	TInt closedChunks = 0;
+	if (aChunkArray == NULL)
+		{// The chunk array has already been deleted.
+		return;
+		}
+	for (TUint i = 0; i < aChunkArraySize; i++)
+		{
+		if (aChunkArray[i].Handle() != NULL)
+			{
+			aChunkArray[i].Close();
+			closedChunks ++;
+			}
+		}
+	delete[] aChunkArray;
+	aChunkArray = NULL;
+	aChunkArraySize = 0;
+	UpdateRamInfo();
+	test.Printf(_L("Free RAM after closing %d chunks = 0x%x\n"),closedChunks,gFreeRam);
+	}
+TBool SpaceAvailForPageTables(TUint aZoneIndex, TInt aNumPages)
+	{
+	// Every 1MB allocated needs a new page table
+	const TUint KDataBytesPerPageTable = 1024 * 1024;
+	// 1 Page can fit 4 page tables
+	const TUint KPageTablesPerPage = 4;
+	GetAllPageInfo();
+	if (aNumPages == KFillAllMovable)
+		{
+		aNumPages = gTotalPageCount.iFreePages;
+		}
+	TUint allocBytes = aNumPages << gPageShift;
+	// Add 1 as you always require at least 1 page table
+	TUint pageTablesRequired = (allocBytes / KDataBytesPerPageTable) + 1;
+	// Add 1 as the first 1-3 page tables may require a new page.
+	TUint pageTablePagesRequired = (pageTablesRequired / KPageTablesPerPage) + 1;
+	// Determine the number of free pages in the other zones
+	TUint freeInOther = 0;
+	for (TUint index = 0; index < gZoneCount; index++)
+		{
+		if (index != aZoneIndex)
+			{
+			freeInOther += gZoneUtilArray[index].iFreePages;
+			}
+		}
+	// Need an overhead for the heap to grow (5 pages)
+	const TUint KOverhead = 5;
+	if (freeInOther < pageTablePagesRequired + KOverhead)
+		{// Not enough space in other zones to fit all page tables
+		test.Printf(_L("No space in other zones for page table pages\n"));
+		return EFalse;
+		}
+	// There is space available in the other zones to fit all the page tables
+	return ETrue;
+	}
+//
+// AllocMovable
+//
+// Allocate movable memory in the form of chunks
+//
+// @param aChunkArray The array to store a reference to the chunks created.
+// @param aChunkArraySize The size of aChunkArray.
+// @param aNumChunks The number of chunks to create.
+// @param aNumPages The size of each chunk.
+//
+TInt AllocMovable(RChunk*& aChunkArray, TUint& aChunkArraySize, TInt aNumChunks, TUint aChunkSize=KChunkDefaultSize, TBool aForceFill = ETrue)
+	{
+	TUint i = 0;
+	TInt r = 0;
+	TUint chunksAllocd = 0;
+	TBool fillAll = EFalse;
+	TInt numChunks = aNumChunks;
+	UpdateRamInfo();
+	// Allocate chunks to take up all of memory with the maximum number of chunks
+	if (aNumChunks == KFillAllMovable)
+		{
+		fillAll = ETrue;
+		if (aChunkSize == KChunkDefaultSize)
+			{
+			numChunks = KMaxChunks;
+			aChunkSize = gFreeRam / numChunks;
+			}
+		else
+			{
+			numChunks = gFreeRam  / aChunkSize;
+			}
+		}
+	test.Printf(_L("gFreeRam = 0x%x, aChunkSize = 0x%x, numChunks = %d\n"), gFreeRam, aChunkSize, numChunks);
+	// Allocate as many chunks as is specified, either with the default chunk size or a specified chunk size
+	if (aChunkArray == NULL)
+		{
+		aChunkArraySize = numChunks;
+		aChunkArray = new RChunk[aChunkArraySize];
+		if (aChunkArray == NULL)
+			return KErrNoMemory;
+		}
+	// Create chunks for each RChunk with a NULL handle.
+	for (i = 0; i < aChunkArraySize; i++)
+		{
+		if (aChunkArray[i].Handle() == NULL)
+			{
+			// Keep going even if a chunk creation fails as the flag tests rely
+			// on this.
+			r = aChunkArray[i].CreateLocal(aChunkSize, aChunkSize);
+			if (r != KErrNone && fillAll && aForceFill)
+				{
+				while (aChunkArray[i].CreateLocal(aChunkSize, aChunkSize) != KErrNone)
+					{
+					aChunkSize -= gPageSize;
+					}
+				}
+			if (r == KErrNone)
+				{
+				chunksAllocd++;
+				}
+			}
+		User::After(10); // Wait so that the next chunk gets allocated in the next time slice
+		}
+	test.Printf(_L("Number of chunks allocd = %d\n"),chunksAllocd);
+	return r;
+	}
+//
+// ZoneAllocMovable
+//
+// Allocate the specified number of movable pages to a specific zone
+// If the number of pages is not specified, then fill the specified zone with
+// movable pages
+//
+// @param aChunkArray The array to store a reference to the chunks created.
+// @param aChunkArraySize The size of aChunkArray.
+// @param aZoneIndex The zone index to allocate movable pages to.
+// @param aNumPages The number of movable pages to allocate.
+//
+TInt ZoneAllocMovable(RChunk*& aChunkArray, TUint& aChunkArraySize, TUint aZoneIndex, TUint aNumPages = KMaxTUint)
+	{
+	ResetRamZoneFlags();
+	TInt r = KErrNone;
+	TUint allocBytes = 0;
+	if (aNumPages == KMaxTUint)
+		{
+		aNumPages = gZoneUtilArray[aZoneIndex].iFreePages;
+		}
+	allocBytes = aNumPages << gPageShift;
+	if (!SpaceAvailForPageTables(aZoneIndex, aNumPages))
+		{
+		return KErrGeneral;
+		}
+	// Block all other zones from allocation
+	for(TUint index = 0; index < gZoneCount; index++)
+		{
+		if (index == aZoneIndex)
+			{
+			r = Ldd.SetZoneFlag(gZoneConfigArray[index].iZoneId, gZoneConfigArray[index].iFlags, NO_FIXED_FLAG);
+			}
+		else
+			{
+			r = Ldd.SetZoneFlag(gZoneConfigArray[index].iZoneId, gZoneConfigArray[index].iFlags, NO_MOVE_FLAG);
+			}
+		if (r != KErrNone)
+			{
+			test.Printf(_L("Failed to set RAM zone flag on zone %d r = %d\n"), index, r);
+			return r;
+			}
+		}
+	// Allocate the movable pages
+	r = AllocMovable(aChunkArray, aChunkArraySize, 1, allocBytes);
+	ResetRamZoneFlags();
+	return r;
+	}
+//
+// ZoneAllocDiscard
+//
+// Allocate the specified number of discardable pages to a specific zone
+//
+// @param aZoneIndex The zone index to allocate discardable pages to.
+// @param aNumPages The number of discardable pages to allocate.
+// @param aDisPages On return this will contain the number of discardable pages allocated
+//
+TInt ZoneAllocDiscard(TUint aZoneIndex, TUint aNumPages, TInt& aDisPages)
+	{
+	TInt r = KErrNone;
+	ResetRamZoneFlags();
+	for (TUint index = 0; index < gZoneCount; index++)
+		{
+		TUint zoneID = gZoneConfigArray[index].iZoneId;
+		if (index == aZoneIndex)
+			{
+			r = Ldd.SetZoneFlag(zoneID, gZoneConfigArray[index].iFlags, ONLY_DISCARD_FLAG);
+			}
+		else
+			{
+			r = Ldd.SetZoneFlag(zoneID, gZoneConfigArray[index].iFlags, NO_DISCARD_FLAG);
+			}
+		if (r != KErrNone)
+			{
+			test.Printf(_L("Failed to set flag r = %d\n"), r);
+			return r;
+			}
+		}
+	TUint disBytes = gTotalPageCount.iDiscardablePages + aNumPages << gPageShift;
+	r = AllocDiscardable(aDisPages, disBytes);
+	aDisPages = aDisPages >> gPageShift;
+	if (r != KErrNone)
+		{
+		test.Printf(_L("Discardable pages not allocated r = %d\n"), r);
+		}
+	ResetRamZoneFlags();
+	return r;
+	}
+//
+// FreeMovable
+//
+// Free movable pages by closing chunks.
+// The function will close every other chunk so that the movable pages are scattered in every zone
+//
+// @param aChunkArray The array that stores reference to the chunks created.
+// @param aChunkArraySize The size of aChunkArray.
+//
+TInt FreeMovable(RChunk* aChunkArray, TUint aChunkArraySize)
+	{
+	TUint i;
+	TInt closedChunks = 0;
+	for (i=0; i < aChunkArraySize; i+=2) // Close every other chunk
+		{
+		if (aChunkArray[i].Handle() != NULL)
+			{
+			aChunkArray[i].Close();
+			closedChunks ++;
+			}
+		}
+	UpdateRamInfo();
+	test.Printf(_L("Free RAM after closing %d chunks = 0x%x\n"),closedChunks,gFreeRam);
+	return KErrNone;
+	}
+//
+// GetBestZone
+//
+// Obtains the most preferable zone for allocating a specific type of page
+//
+// @param aPageType The page type that we are interested in
+// @param aBestPrefIndex The index into the preference array for the zone.
+//
+// @return KErrNotFound if a zone cannot be found, else the zone index into gZoneUtilArray
+//
+TInt GetBestZone(TInt aPageType, TUint* aBestPrefIndex = NULL)
+	{
+	GetPrefOrder();
+	switch (aPageType)
+		{
+		case BEST_MOVABLE:
+		case BEST_DISCARDABLE:
+			{
+			TInt bestIndex = KErrNotFound;
+			TUint bestPrefIndex = 0;
+			TUint curIndex = 0;
+			TInt startIndex = KErrNotFound;
+			TBool zoneFound = EFalse;
+			// Find the least preferable zone that has movable or discardable pages
+			for (TInt prefIndex = gZoneCount - 1; prefIndex >= 0; prefIndex--)
+				{
+				curIndex = gPrefArray[prefIndex];
+				if (gZoneUtilArray[curIndex].iAllocMovable || gZoneUtilArray[curIndex].iAllocDiscardable)
+					{
+					startIndex = prefIndex;
+					break;
+					}
+				}
+			if (startIndex == KErrNotFound)
+				return startIndex;
+			// Work up the preference list to look for the best zone
+			for (TInt prefIndex = startIndex; prefIndex >= 0; prefIndex--)
+				{
+				curIndex = gPrefArray[prefIndex];
+				if (gZoneUtilArray[curIndex].iFreePages)
+					{
+					bestIndex = curIndex;
+					bestPrefIndex = prefIndex;
+					zoneFound = ETrue;
+					break;
+					}
+				}
+			// If the zone still isn't found, look down the preference list
+			if (!zoneFound)
+				{
+				for (TUint prefIndex = startIndex; prefIndex < gZoneCount; prefIndex++)
+					{
+					curIndex = gPrefArray[prefIndex];
+					if (gZoneUtilArray[curIndex].iFreePages)
+						{
+						bestIndex = curIndex;
+						bestPrefIndex = prefIndex;
+						zoneFound = ETrue;
+						break;
+						}
+					}
+				}
+			test.Printf(_L("leastPref = %d\n"), bestIndex);
+			if (aBestPrefIndex)
+				*aBestPrefIndex = bestPrefIndex;
+			return bestIndex;
+			}
+		case BEST_FIXED:
+			for (TUint prefIndex = 0; prefIndex < gZoneCount; prefIndex++)
+				{
+				TUint mostPref = gPrefArray[prefIndex];
+				if (gZoneUtilArray[mostPref].iFreePages != 0 ||
+					gZoneUtilArray[mostPref].iAllocMovable != 0 ||
+					gZoneUtilArray[mostPref].iAllocDiscardable != 0)
+					{
+					test.Printf(_L("mostPref = %d\n"), mostPref);
+					if (aBestPrefIndex)
+						*aBestPrefIndex = prefIndex;
+					return mostPref;
+					}
+				}
+			break;
+		}
+	test.Printf(_L("Cannot find zone\n"));
+	return KErrNotFound;
+	}
+void GetCandList1(TInt aIndex);
+//
+// VerifyMovDisAlloc
+//
+// Checks that all movable and discardable pages are in the correct RAM zones.
+// Should only be invoked after a general defragmentation or a general
+// defragmentation followed by an allocation.
+//
+//	NOTE - This shouldn't be used to verify RAM if a RAM specific allocation or
+//	zone claim operation has been performed.
+//
+// @return KErrNone if RAM layout is good, KErrGeneral if not, KErrNotFound if no
+// movable or discardable pages are allocated.
+//
+TInt VerifyMovDisAlloc()
+	{
+	GetPrefOrder();
+	TInt leastInUse = KErrNotFound;
+	TUint requiredMovDis = 0;
+	TUint totalMorePrefInUse = 0;
+	TBool verifySpread = ETrue;
+	TBool prevZoneNotFull = EFalse;
+	// Determine which is the least prefable RAM zone in use and how many pages
+	// are allocated of each type.
+	for (TInt prefIndex = gZoneCount - 1; prefIndex >= 0; prefIndex--)
+		{
+		TUint index = gPrefArray[prefIndex];
+		TUint allocMov = gZoneUtilArray[index].iAllocMovable;
+		TUint allocDis = gZoneUtilArray[index].iAllocDiscardable;
+		TUint allocFixed = gZoneUtilArray[index].iAllocFixed;
+		TESTDEBUG(test.Printf(_L("pref ID 0x%x\n"), gZoneConfigArray[index].iZoneId));
+		if (allocMov || allocDis || allocFixed)
+			{
+			TBool zoneNotFull = EFalse;
+			GetCandList1(index);
+			TUint candIndex = 0;
+			for (; candIndex < gZoneCount; candIndex++)
+				{
+				TInt zoneIndexCand = gCandList1[candIndex];
+				if (zoneIndexCand == KInvalidCandIndex)
+					{
+					break;
+					}
+				allocMov  += gZoneUtilArray[zoneIndexCand].iAllocMovable;
+				allocDis  += gZoneUtilArray[zoneIndexCand].iAllocDiscardable;
+				if (gZoneUtilArray[zoneIndexCand].iFreePages)
+					{
+					zoneNotFull = ETrue;
+					}
+				}
+			prefIndex -= candIndex - 1;
+			if (leastInUse == KErrNotFound)
+				{// Have found least preferable RAM zone that is in use.
+				leastInUse = index;
+				if (allocFixed)
+					{// The least preferable RAM zone has fixed pages in it so
+					// RAM may be more spread out than is necessary.
+					verifySpread = EFalse;
+					}
+				}
+			else
+				{
+				if ((allocMov || allocDis) && prevZoneNotFull)
+					{// The previous least preferable RAM zones were not full so shouldn't
+					// be any movable or discardable pages in the RAM zones of this preference.
+					test.Printf(_L("Movable or discardable pages in more preferable RAM zones unnecessarily\n"));
+					return KErrGeneral;
+					}
+				prevZoneNotFull = zoneNotFull;
+				// Not the least preferable RAM zone so add to total allocatable.
+				totalMorePrefInUse += allocMov + allocDis + gZoneUtilArray[index].iFreePages;
+				}
+			requiredMovDis += allocMov + allocDis;
+			}
+		}
+	if (leastInUse == KErrNotFound)
+		{// No movable or discardable pages are allocated.
+		test.Printf(_L("No in use RAM zones found????\n"));
+		return KErrNotFound;
+		}
+	if (totalMorePrefInUse > requiredMovDis)
+		{// There enough allocatable pages in the RAM zones below the currently
+		// least preferable RAM in use.
+		test.Printf(_L("Memory is spread out totalMorePref 0x%x required 0x%x\n"), totalMorePrefInUse, requiredMovDis);
+		if (verifySpread)
+			return KErrGeneral;
+		}
+	return KErrNone;
+	}
+//
+// GetCandList1
+//
+// Populates a list of all zones that have the same preference and the same amount
+// of immovable pages
+//
+void GetCandList1(TInt aIndex)
+	{
+	for (TUint i=0; i<gZoneCount; i++)
+		{
+		gCandList1[i] = KInvalidCandIndex;
+		}
+	TInt candListIndex = 0;
+	GetAllPageInfo();
+	for (TUint i=0; i<gZoneCount; i++)
+		{
+		if (ZonesSamePref(aIndex, i))
+			{
+			gCandList1[candListIndex] = i;
+			candListIndex ++;
+			}
+		}
+	}
+//
+// GetCandList2
+//
+// Populates a list of all zones that have the same preference and the same amount
+// of immovable pages
+//
+void GetCandList2(TInt aIndex)
+	{
+	for (TUint i=0; i<gZoneCount; i++)
+		{
+		gCandList2[i] = KInvalidCandIndex;
+		}
+	TInt candListIndex = 0;
+	GetAllPageInfo();
+	for (TUint i=0; i<gZoneCount; i++)
+		{
+		if (ZonesSamePref(aIndex, i))
+			{
+			gCandList2[candListIndex] = i;
+			candListIndex ++;
+			}
+		}
+	}
+//
+// GetCandListFixed1
+//
+// Populates a list of all zones that have the same preference and the same
+// amount of immovable pages, it will ignore RAM zones that are full of
+// immovable pages as these are the only RAM zones that fixed pages can't be
+// allocated into.
+//
+void GetCandListFixed1(TInt aIndex)
+	{
+	for (TUint i=0; i<gZoneCount; i++)
+		{
+		gCandList1[i] = KInvalidCandIndex;
+		}
+	TInt candListIndex = 0;
+	GetAllPageInfo();
+	for (TUint i=0; i<gZoneCount; i++)
+		{
+		if (ZonesSamePref(aIndex, i) &&
+			gZoneUtilArray[i].iAllocFixed + gZoneUtilArray[i].iAllocUnknown !=
+			gZoneConfigArray[i].iPhysPages)
+			{
+			gCandList1[candListIndex] = i;
+			candListIndex ++;
+			}
+		}
+	}
+//
+// MultiGenDefragThreadFunc
+//
+// Called when a general defrag is called to run at the same time as another operation
+//
+TInt MultiGenDefragThreadFunc(TAny* /*aPtr*/)
+	{
+	RRamDefragFuncTestLdd Ldd2;
+	TInt r = Ldd2.Open();
+	if (r != KErrNone)
+		{
+		RDebug::Printf("Unable to open Ldd2 in MultiGenDefragThreadFunc, r = %d\n", r);
+		return r;
+		}
+	RThread thisThread = RThread();
+	thisThread.SetPriority(EPriorityLess);
+	r = Ldd2.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+	Ldd2.Close();
+	thisThread.Close();
+	return r;
+	}
+TBool gTestLoop = EFalse;
+//
+// MultiLoopGenDefragThreadFunc
+//
+// Called when a general defrag is called to run at the same time as another operation
+//
+TInt MultiLoopGenDefragThreadFunc(TAny* /*aPtr*/)
+	{
+	RRamDefragFuncTestLdd Ldd2;
+	TInt r = Ldd2.Open();
+	if (r != KErrNone)
+		{
+		RDebug::Printf("Unable to open Ldd2 in MultiLoopGenDefragThreadFunc, r = %d\n", r);
+		return r;
+		}
+	RThread thisThread = RThread();
+	thisThread.SetPriority(EPriorityLess);
+	while (gTestLoop)
+		{
+		r = Ldd2.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+		if (r != KErrNone)
+			goto threadExit;
+		}
+threadExit:
+	Ldd2.Close();
+	thisThread.Close();
+	return r;
+	}
+//
+// MultiEmptyZoneThreadFunc
+//
+// Called when a zone defrag is called to run at the same time as another operation
+//
+TInt MultiEmptyZoneThreadFunc(TAny* zoneID)
+	{
+	RRamDefragFuncTestLdd Ldd2;
+	TInt r = Ldd2.Open();
+	if (r != KErrNone)
+		{
+		RDebug::Printf("Unable to open Ldd2 in MultiEmptyZoneThreadFunc, r = %d\n", r);
+		return r;
+		}
+	RThread thisThread = RThread();
+	thisThread.SetPriority(EPriorityLess);
+	r = Ldd2.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, (TUint)zoneID);
+	Ldd2.Close();
+	thisThread.Close();
+	return r;
+	}
+//
+// MultiClaimZoneThreadFunc
+//
+// Called when a ClaimRamZone is called to run at the same time as another operation
+//
+TInt MultiClaimZoneThreadFunc(TAny* zoneID)
+	{
+	RRamDefragFuncTestLdd Ldd2;
+	TInt r = Ldd2.Open();
+	if (r != KErrNone)
+		{
+		RDebug::Printf("Unable to open Ldd2 in MultiClaimZoneThreadFunc, r = %d\n", r);
+		return r;
+		}
+	RThread thisThread = RThread();
+	thisThread.SetPriority(EPriorityLess);
+	r = Ldd2.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, (TUint)zoneID);
+	Ldd2.Close();
+	thisThread.Close();
+	return r;
+	}
+//
+// TestAllocStrategies
+//
+// Verifying that pages are allocated correctly.  All tests rely on a general defragmentation occuring
+// in TestStart() so that memory is in a defragmented state before the allocations.
+//
+//---------------------------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID				KBASE-t_ramdefrag-0525
+//! @SYMTestCaseDesc			Verifying that pages are allocated correctly
+//! @SYMTestType				CIT
+//! @SYMPREQ					PREQ308
+//! @SYMTestPriority			High
+//! @SYMTestActions
+//! 	1.	Allocate one chunk to memory.
+//! 		Check which zone the chunk has been allocated to by checking the
+//! 		number of movable pages before and after the allocation has taken place.
+//!		2.	Allocate one chunk to memory that is large enough to cause an empty RAM
+//!			zone to be used.
+//! 	3.	Allocate a certain number of fixed pages to memory.
+//! 		Check which zone the chunk has been allocated to by checking the
+//! 		number of fixed pages before and after the allocation has taken place.
+//!		4.	Allocate fixed pages when it is known that discardable pages will need
+//!			to be discarded for the allocation to succeed.
+//!		5.	Allocate fixed pages when it is known that movable pages will need
+//!			to be moved for the allocation to succeed.
+//! 	6.	Allocate fixed pages when it is known that movable pages will need
+//!			to be moved for the allocation to succeed, Determine the "best" zone for fixed pages and allocate 1 more
+//!			than that.
+//!		7.	Allocate discardable pages by loading pages that are demand paged.
+//! 		Check which zone the memory has been allocated to by checking the number of
+//! 		discardable pages before and after the allocation has taken place.
+//!
+//! @SYMTestExpectedResults
+//! 	1.	The memory has been allocated to the most preferred zone with the least amount of
+//! 		space accounting for the zone threshold for movable pages.
+//!		2.	The new RAM zone is used and the movable page are allocated into it first then the other
+//!			more preferable RAM zones.
+//! 	3.	The fixed pages are allocated to the most preferred zone
+//!		4.	The fixed pages are allocatted to the most preferred zone with free, movable or discardable pages in it.
+//!		5.	The fixed pages are allocatted to the most preferred zone with free, movable or discardable pages in it.
+//! 	6.	Extra page is placed in the next preferable to the "best"zone
+//!		7.	Memory is allocated to the most preferred zone with the least amount of
+//! 		space accounting for the zone threshold for discardable pages.
+//---------------------------------------------------------------------------------------------------------------------
+TInt TestAllocStrategies()
+	{
+	test.Start(_L("Test1: Check which zone a movable page has been allocated to "));
+	TestStart(); //This will perform a general defrag which should tidy up RAM for us
+	gChunkArray1 = new RChunk;
+	gChunkArraySize1 = 1;
+	TBool zoneFound = EFalse;
+	// Determine if suitable RAM zone exists for testing
+	TInt best = GetBestZone(BEST_MOVABLE);
+	if (best == KErrNotFound)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping...\n"));
+		}
+	else
+		{
+		test.Printf(_L("best = %d\n"), best);
+		// Populate the candidate list
+		GetCandList2(best);
+		// Allocate 1 movable page
+		GetOriginalPageCount();
+		if (AllocMovable(gChunkArray1, gChunkArraySize1, 1, gPageSize) != KErrNone)
+			{
+			test.Printf(_L("Not enough free RAM for test - Skipping...\n"));
+			}
+		else
+			{
+			GetAllPageInfo();
+			TInt r = VerifyMovDisAlloc();
+			// Need to check all candidates to see if page has gone into any one of them
+			for (TUint i=0; i < gZoneCount; i++)
+				{
+				if (gCandList2[i] == KInvalidCandIndex)
+					{
+					break;
+					}
+				TUint zoneIndex = gCandList2[i];
+				if (gOriginalPageCountArray[zoneIndex].iAllocMovable < gZoneUtilArray[zoneIndex].iAllocMovable)
+					{
+					zoneFound = ETrue;
+					break;
+					}
+				}
+			if (r == KErrNone && zoneFound)
+				{
+				test.Printf(_L("Pass: Movable allocated to the zone expected\n"));
+				}
+			else
+				{
+				test.Printf(_L("Fail: Movable allocated to a zone that was not expected, r %d\n"), r);
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				TEST_FAIL;
+				}
+			}
+		}
+	TestEnd();
+	test.Next(_L("Test2: Check that movable pages allocated from least preferable RAM zone to be used\n"));
+	TestStart();
+	gChunkArray1 = new RChunk;
+	gChunkArraySize1 = 1;
+	// Determine if suitable RAM zone exists for testing.
+	TUint bestPrefIndex;
+	best = GetBestZone(BEST_MOVABLE, &bestPrefIndex);
+	TUint morePrefIndex = bestPrefIndex - 1;
+	TUint nextLeastPrefIndex = bestPrefIndex + 1;
+	// Check number of free pages in the more preferable zones
+	TUint freeInMorePref = 0;
+	for (TUint i = 0; i < bestPrefIndex; i++)
+		{
+		freeInMorePref += gZoneUtilArray[gPrefArray[i]].iFreePages;
+		}
+	test.Printf(_L("freeInMorePref = 0x%x\n"), freeInMorePref);
+	const TUint KHeapOverhead = 5; // Room for kernel heap allocations so they don't affect the page count
+	if (best == KErrNotFound || nextLeastPrefIndex >= gZoneCount ||
+		(gZoneUtilArray[gPrefArray[nextLeastPrefIndex]].iFreePages < KHeapOverhead &&
+		freeInMorePref < KHeapOverhead)||
+		gZoneConfigArray[gPrefArray[nextLeastPrefIndex]].iPref == gZoneConfigArray[best].iPref ||
+		gZoneConfigArray[gPrefArray[morePrefIndex]].iPref == gZoneConfigArray[best].iPref)
+		{// No less preferable RAM zone or there are more or less preferable of
+		// same preference so re-ordering potential makes verification too complex.
+		test.Printf(_L("Cannot find zone to perform test - Skipping...\n"));
+		}
+	else
+		{
+		// Ensure the zone is almost full as chunks will get allocated in blocks
+		// by almost filling the best zone with fixed pages, leaving a space (e.g. 20 pages)
+		const TUint KSpaceNeeded = 20;
+		if (gZoneUtilArray[best].iFreePages > KSpaceNeeded)
+			{
+			TUint zoneID = gZoneUtilArray[best].iZoneId;
+			TUint diffAlloc = gZoneUtilArray[best].iFreePages - KSpaceNeeded;
+			TInt r = Ldd.ZoneAllocDiscontiguous(zoneID, diffAlloc);
+			if (r != KErrNone)
+				{
+				CLEANUP(Ldd.FreeAllFixedPages());
+				TEST_FAIL;
+				}
+			}
+		GetAllPageInfo();
+		// Update the number of free pages in the more preferable zones
+		freeInMorePref = 0;
+		for (TUint i = 0; i < bestPrefIndex; i++)
+			{
+			freeInMorePref += gZoneUtilArray[gPrefArray[i]].iFreePages;
+			}
+		TUint origFixed = gTotalPageCount.iFixedPages;
+		GetOriginalPageCount();
+		// Allocate enough movable pages that the next least preferable RAM zone
+		// will need to be used.
+		TUint movPages = gZoneUtilArray[best].iFreePages + 1;
+		TUint movBytes = movPages << gPageShift;
+		TInt r = AllocMovable(gChunkArray1, gChunkArraySize1, 1, movBytes);
+		if (r != KErrNone)
+			{
+			CLEANUP(Ldd.FreeAllFixedPages());
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		GetAllPageInfo();
+		TUint curFixed = gTotalPageCount.iFixedPages;
+		TInt difFixed = curFixed - origFixed;
+		// If there is space in the more preferable zones then they should be allocated starting from
+		// the "best" zone to the more preferable zones, else from the next least preferable zone to the more preferable zones
+		TUint prefIndex;
+		if ((TInt)freeInMorePref > difFixed)
+			{//No new zones should be turned on, allocation should have gone into bestPrefIndex then down towards most preferred zones
+			TUint nextIndex = gPrefArray[nextLeastPrefIndex];
+			if (gOriginalPageCountArray[best].iAllocMovable >= gZoneUtilArray[best].iAllocMovable ||
+				gOriginalPageCountArray[nextIndex].iAllocMovable < gZoneUtilArray[nextIndex].iAllocMovable)
+				{
+				test.Printf(_L("Movable page allocated incorrectly origFree 0x%x curFree 0x%x nxtPrefFree 0x%x\n"),
+								gOriginalPageCountArray[best].iFreePages, gZoneUtilArray[best].iFreePages,
+								gZoneUtilArray[nextLeastPrefIndex].iFreePages);
+				CLEANUP(Ldd.FreeAllFixedPages());
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				TEST_FAIL;
+				}
+			prefIndex = morePrefIndex;
+			}
+		else
+			{// If there are enough free pages in "nextIndex" to fit all movable pages allocated then the movable
+			// page count in "best" should stay the same, else they should be allocated between "nextIndex" and "best".
+			TUint nextIndex = gPrefArray[nextLeastPrefIndex];
+			test.Printf(_L("nextIndex = %d\n"), nextIndex);
+			if (gOriginalPageCountArray[nextIndex].iAllocMovable >= gZoneUtilArray[nextIndex].iAllocMovable ||
+				(gOriginalPageCountArray[nextIndex].iFreePages >= movPages &&
+				gOriginalPageCountArray[best].iAllocMovable != gZoneUtilArray[best].iAllocMovable) ||
+				(gOriginalPageCountArray[nextIndex].iFreePages < movPages &&
+				gOriginalPageCountArray[best].iAllocMovable == gZoneUtilArray[best].iAllocMovable))
+				{
+				test.Printf(_L("Movable page allocated incorrectly origFree 0x%x curFree 0x%x nxtPrefFree 0x%x\n"),
+								gOriginalPageCountArray[nextIndex].iFreePages, gZoneUtilArray[nextIndex].iFreePages,
+								gZoneUtilArray[nextIndex].iFreePages);
+				CLEANUP(Ldd.FreeAllFixedPages());
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				TEST_FAIL;
+				}
+			prefIndex = bestPrefIndex;
+			}
+		// Check that movable pages have only been allocated into the more
+		// preferable RAM zones if the less preferable ram zones in use are full.
+		prefIndex++;
+		do
+			{
+			prefIndex--;
+			TUint indexCurrent = gPrefArray[prefIndex];
+			TUint indexLessPref = gPrefArray[prefIndex+1];
+			if (gOriginalPageCountArray[indexCurrent].iAllocMovable < gZoneUtilArray[indexCurrent].iAllocMovable &&
+				gZoneUtilArray[indexLessPref].iFreePages)
+				{// Current in use zone or less preferable than current has free pages so fail
+				test.Printf(_L("Movable page allocated incorrectly origFree 0x%x curFree 0x%x nxtPrefFree 0x%x\n"),
+								gOriginalPageCountArray[best].iFreePages, gZoneUtilArray[best].iFreePages,
+								gZoneUtilArray[nextLeastPrefIndex].iFreePages);
+				CLEANUP(Ldd.FreeAllFixedPages());
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				TEST_FAIL;
+				}
+			}
+		while(prefIndex);
+		test.Printf(_L("Pass: Pages allocated to the zone expected\n"));
+		}
+	TestEnd();
+	test.Next(_L("Test3: Check which zone a fixed page has been allocated to "));
+	for (TUint testStep = 0; testStep < 2; testStep++)
+		{
+		switch (testStep)
+			{
+			case 0:
+				test.Printf(_L("Testing discontiguous allocations\n"));
+				break;
+			case 1:
+				test.Printf(_L("Testing contiguous allocations\n"));
+				break;
+			}
+		TestStart();
+		zoneFound = EFalse;
+		GetOriginalPageCount();
+		best = GetBestZone(BEST_FIXED);
+		TESTDEBUG(test.Printf(_L("best = %d\n"), best));
+		if (best == KErrNotFound)
+			{
+			test.Printf(_L("Cannot find zone to perform test - Skipping...\n"));
+			}
+		else
+			{
+			GetCandList1(best);
+			TInt allocFixedPages = 1; // Try and allocate just 1 fixed page
+			switch (testStep)
+				{
+				case 0:
+					Ldd.AllocateFixed(allocFixedPages);
+					break;
+				case 1:
+					TUint allocFixedBytes = allocFixedPages << gPageShift;
+					Ldd.AllocContiguous(allocFixedBytes);
+					break;
+				}
+			GetAllPageInfo();
+			for (TUint i=0; i<gZoneCount; i++)
+				{
+				if (gCandList1[i] == KInvalidCandIndex)
+					{
+					break;
+					}
+				TUint zoneIndex = gCandList1[i];
+				if (gOriginalPageCountArray[zoneIndex].iAllocFixed + allocFixedPages <= gZoneUtilArray[zoneIndex].iAllocFixed)
+					{
+					zoneFound = ETrue;
+					break;
+					}
+				}
+			if (zoneFound)
+				{
+				test.Printf(_L("Pass: Chunk has been allocated to the zone expected\n"));
+				}
+			else
+				{
+				test.Printf(_L("Fail: Fixed been allocated to a zone that was not expected\n"));
+				CLEANUP(Ldd.FreeAllFixedPages());
+				TEST_FAIL;
+				}
+			Ldd.FreeAllFixedPages();
+			}
+		TestEnd();
+		}
+	test.Next(_L("Test4: Check fixed page allocations will discard pages"));
+	for (TUint testStep = 0; testStep < 2; testStep++)
+		{
+		switch (testStep)
+			{
+			case 0:
+				test.Printf(_L("Testing discontiguous allocations\n"));
+				break;
+			case 1:
+				test.Printf(_L("Testing contiguous allocations\n"));
+				break;
+			}
+		TestStart();
+		TInt discardBytes;
+		TInt r;
+		if (!gPagedRom)
+			{
+			test.Printf(_L("Not a paged ROM - Skipping test step\n"));
+			goto SkipTest4;
+			}
+		best = GetBestZone(BEST_FIXED);
+		TESTDEBUG(test.Printf(_L("best = %d\n"), best));
+		if (best == KErrNotFound)
+			{
+			test.Printf(_L("Cannot find zone to perform test - Skipping...\n"));
+			goto SkipTest4;
+			}
+		// Ensure discardable pages in the preferred RAM zone.
+		r = AllocDiscardable(discardBytes);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+			TEST_FAIL;
+			}
+		if (discardBytes < gPageSize)
+			{// Can't discard any pages so test can't run.
+			test.Printf(_L("Memory too full to perform test - Skipping...\n"));
+			goto SkipTest4;
+			}
+		// Make sure all RAM zones that the fixed page allocation could potentially
+		// go to have discardable pages allocated in it.
+		GetOriginalPageCount();
+		GetCandListFixed1(best);
+		for (TUint i = 0; i < gZoneCount; i++)
+			{
+			if (gCandList1[i] == KInvalidCandIndex)
+				{
+				break;
+				}
+			TUint zoneIndex = gCandList1[i];
+			if (gOriginalPageCountArray[zoneIndex].iAllocDiscardable == 0)
+				{
+				test.Printf(_L("No dicardable pages in one of the candidates RAM zones - Skipping...\n"));
+				goto SkipTest4;
+				}
+			if (gOriginalPageCountArray[zoneIndex].iFreePages != 0)
+				{
+				test.Printf(_L("Some free pages in candidate RAM zone ID%x\n"),
+							gZoneConfigArray[zoneIndex].iZoneId);
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			}
+		// Allocate 1 fixed page and ensure that it discards a page.
+		switch (testStep)
+			{
+			case 0:
+				r = Ldd.AllocateFixed(1);
+				break;
+			case 1:
+				r = Ldd.AllocContiguous(gPageSize);
+				break;
+			}
+		// Find RAM zone the fixed page was allocated into.
+		GetAllPageInfo();
+		zoneFound = EFalse;
+		for (TUint i = 0; i < gZoneCount; i++)
+			{
+			if (gCandList1[i] == KInvalidCandIndex)
+				{
+				break;
+				}
+			TUint zoneIndex = gCandList1[i];
+			if (gOriginalPageCountArray[zoneIndex].iAllocFixed < gZoneUtilArray[zoneIndex].iAllocFixed)
+				{
+				zoneFound = ETrue;
+				if (gOriginalPageCountArray[zoneIndex].iAllocDiscardable <= gZoneUtilArray[zoneIndex].iAllocDiscardable &&
+					gOriginalPageCountArray[zoneIndex].iAllocMovable <= gZoneUtilArray[zoneIndex].iAllocMovable)
+					{
+					test.Printf(_L("Fixed pages allocated but no pages discarded in RAM zone ID 0x%x\n"),
+						gZoneConfigArray[zoneIndex].iZoneId);
+					CLEANUP(ResetDPCache());
+					TEST_FAIL;
+					}
+				}
+			}
+		if (!zoneFound || r != KErrNone)
+			{
+			test.Printf(_L("No fixed pages were allocated r = %d\n"), r);
+			CLEANUP(ResetDPCache());
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Pass: Pages been allocated to the zone expected\n"));
+			}
+	SkipTest4 :
+		// This will free any DP cache pages and fixed pages allocated.
+		TestEnd();
+		}
+	for (TUint testIndex = 0; testIndex < 2; testIndex++)
+		{
+		switch (testIndex)
+			{
+			case 0:
+				test.Next(_L("Test5: Check fixed page allocations (discontiguous) will move pages"));
+				break;
+			case 1:
+				test.Next(_L("Test6: Check fixed page will only go into a new zone if all other fix page zones are full of fix"));
+				break;
+			}
+		TestStart();
+		gChunkArray1 = new RChunk;
+		gChunkArraySize1 = 1;
+		TInt r = KErrNone;
+		TUint freeInOtherZones = 0;
+		TUint allocatablePages;
+		TUint allocImmovPages;
+		TUint bestPrefIndex;
+		TUint nextBestIndex = 0;
+		const TUint KMovAllocOverhead = 5;	// need pages for page tables and kernel heap expansion.
+		best = GetBestZone(BEST_FIXED, &bestPrefIndex);
+		TESTDEBUG(test.Printf(_L("best = %d\n"), best));
+		GetCandListFixed1(best);
+		TUint candidates = 0;
+		for (TUint i = 0; i < gZoneCount; i++)
+			{
+			if (gCandList1[i] == KInvalidCandIndex)
+				{
+				break;
+				}
+			candidates++;
+			}
+		if (best == KErrNotFound ||
+			(gZoneUtilArray[best].iAllocMovable == 0 && gZoneUtilArray[best].iFreePages < KMovAllocOverhead) ||
+			candidates != 1)
+			{
+			test.Printf(_L("Cannot find zone or too many equal pref zones to perform test - Skipping...\n"));
+			goto SkipTest5;
+			}
+		if (testIndex == 1)
+			{// need to work out what the next best zone would be
+			GetPrefOrder();
+			if (bestPrefIndex + 1 >= gZoneCount)
+				{
+				test.Printf(_L("Cannot find next best zone - Skipping...\n"));
+				goto SkipTest5;
+				}
+			nextBestIndex = gPrefArray[bestPrefIndex + 1];
+			test.Printf(_L("nextBestIndex= %d\n"), nextBestIndex);
+			GetCandListFixed1(nextBestIndex);
+			candidates = 0;
+			for (TUint i = 0; i < gZoneCount; i++)
+				{
+				if (gCandList1[i] == KInvalidCandIndex)
+					{
+					break;
+					}
+				candidates++;
+				}
+			if (gZoneUtilArray[nextBestIndex].iPhysPages == gZoneUtilArray[nextBestIndex].iAllocFixed +
+															gZoneUtilArray[nextBestIndex].iAllocUnknown ||
+				candidates != 1)
+				{
+				test.Printf(_L("Cannot find zone or too many equal pref zones to perform test - Skipping...\n"));
+				goto SkipTest5;
+				}
+			}
+		for (TUint i = 0; i < gZoneCount; i++)
+			{
+			if (i != (TUint)best)
+				{
+				freeInOtherZones += gZoneUtilArray[i].iFreePages;
+				}
+			}
+		allocatablePages = 	gZoneUtilArray[best].iFreePages +
+							gZoneUtilArray[best].iAllocMovable +
+							gZoneUtilArray[best].iAllocDiscardable;
+		if (allocatablePages > freeInOtherZones)
+			{
+			test.Printf(_L("Not enough free RAM for test - Skipping...\n"));
+			goto SkipTest5;
+			}
+		// Allocate the fixed array before getting any page counts
+		r = Ldd.AllocFixedArray(allocatablePages + 1);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("Failed to allocate fixed array r = %d - Skipping...\n"), r);
+			goto SkipTest5;
+			}
+		// Fill the RAM zone with movable pages if none already in it.
+		GetAllPageInfo();
+		if (gZoneUtilArray[best].iAllocMovable == 0)
+			{
+			if (!gZoneUtilArray[best].iFreePages)
+				{
+				test.Printf(_L("RAM zone ID %x too full for test - Skipping...\n"), gZoneConfigArray[best].iZoneId);
+				goto SkipTest5;
+				}
+			// Fill the zone with movable pages
+			r = ZoneAllocMovable(gChunkArray1, gChunkArraySize1, best);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("Failed to fill zone index %d with movable r = %d\n"), best, r);
+				CLEANUP(ResetRamZoneFlags());
+				TEST_FAIL;
+				}
+			if (GetBestZone(BEST_FIXED) != best)
+				{
+				test.Printf(_L("Unable to complete test; RAM zone reordering - Skipping...\n"));
+				goto SkipTest5;
+				}
+			}
+		// Allocate fixed pages after reseting the allocation flags.
+		GetAllPageInfo();
+		ResetRamZoneFlags();
+		allocatablePages = 	gZoneUtilArray[best].iFreePages +
+							gZoneUtilArray[best].iAllocMovable +
+							gZoneUtilArray[best].iAllocDiscardable;
+		switch (testIndex)
+			{
+			case 0:
+				r = Ldd.AllocateFixed2(allocatablePages);
+				GetAllPageInfo();
+				allocImmovPages = gZoneUtilArray[best].iAllocFixed + gZoneUtilArray[best].iAllocUnknown;
+				if (r != KErrNone || gZoneConfigArray[best].iPhysPages != allocImmovPages)
+					{
+					test.Printf(_L("RAM zone ID 0x%x not full of immovable pages\n"), gZoneConfigArray[best].iZoneId);
+					CLEANUP(ResetRamZoneFlags());
+					TEST_FAIL;
+					}
+				else
+					{
+					test.Printf(_L("Pass: Pages allocated to the zone expected\n"));
+					}
+				break;
+			case 1:
+				GetOriginalPageCount();
+				r = Ldd.AllocateFixed2(allocatablePages + 1);
+				GetAllPageInfo();
+				allocImmovPages = gZoneUtilArray[best].iAllocFixed + gZoneUtilArray[best].iAllocUnknown;
+				if (r != KErrNone || gZoneUtilArray[best].iPhysPages != allocImmovPages ||
+					gZoneUtilArray[nextBestIndex].iAllocFixed <= gOriginalPageCountArray[nextBestIndex].iAllocFixed)
+					{
+					test.Printf(_L("RAM zone ID 0x%x not full of immovable pages or next best ID 0x%x no fix pages\n"),
+									gZoneConfigArray[best].iZoneId, gZoneConfigArray[nextBestIndex].iZoneId);
+					test.Printf(_L("nextBest %d origFix 0x%x curFix 0x%x\n"),
+									nextBestIndex, gOriginalPageCountArray[nextBestIndex].iAllocFixed,
+									gZoneUtilArray[nextBestIndex].iAllocFixed);
+					CLEANUP(ResetRamZoneFlags());
+					TEST_FAIL;
+					}
+				// Go through every other zone and check that fixed pages haven't increased
+				for (TUint i = 0; i < gZoneCount; i++)
+					{
+					if (i != (TUint)best && i != (TUint)nextBestIndex &&
+						gZoneUtilArray[i].iAllocFixed > gOriginalPageCountArray[i].iAllocFixed)
+						{
+						test.Printf(_L("FAIL: Fix page count increased zoneIndex %d orig 0x%x current 0x%x\n"),
+										i, gOriginalPageCountArray[i].iAllocFixed, gZoneUtilArray[i].iAllocFixed);
+						CLEANUP(ResetRamZoneFlags());
+						TEST_FAIL;
+						}
+					}
+				test.Printf(_L("Pass: Pages allocated to the zone expected\n"));
+				break;
+			}
+	SkipTest5 :
+		// This will perform any required clean up.
+		ResetRamZoneFlags();
+		TestEnd();
+	}
+	test.Next(_L("Test7: Check which zone a discardable page has been allocated to"));
+	TestStart();
+	if (gPagedRom)
+		{
+		GetAllPageInfo();
+		// Try to allocate just one more discardable page
+		TUint allocBytes = (gTotalPageCount.iDiscardablePages + 1) << gPageShift;
+		TInt discardablePages;
+		best = GetBestZone(BEST_DISCARDABLE);
+		if (best == KErrNotFound)
+			{
+			test.Printf(_L("Cannot find zone to perform test - Skipping...\n"));
+			}
+		else
+			{
+			// Populate the candidate list
+			GetCandList2(best);
+			zoneFound = EFalse;
+			GetOriginalPageCount();
+			TInt r = AllocDiscardable(discardablePages, allocBytes);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("Fail: r %d\n"), r);
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			r = VerifyMovDisAlloc();
+			// Need to check all candidates to see if page has gone into any one of them
+			for (TUint i=0; i < gZoneCount; i++)
+				{
+				if (gCandList2[i] == KInvalidCandIndex)
+					{
+					break;
+					}
+				TUint zoneIndex = gCandList2[i];
+				if (gOriginalPageCountArray[zoneIndex].iAllocDiscardable < gZoneUtilArray[zoneIndex].iAllocDiscardable)
+					{
+					zoneFound = ETrue;
+					break;
+					}
+				}
+			if (r == KErrNone && zoneFound)
+				{
+				test.Printf(_L("Pass: Discardable allocated to the zone expected\n"));
+				}
+			else
+				{
+				test.Printf(_L("Fail: Discardable been allocated to a zone that was not expected r %d\n"), r);
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			}
+		}
+	else
+		{
+		test.Printf(_L("Not a paged ROM - Skipping test step\n"));
+		}
+	TestEnd();
+	test.Next(_L("Test8: Check fixed page allocations (contiguous) will move pages"));
+	TestStart();
+	gChunkArray1 = new RChunk;
+	gChunkArraySize1 = 1;
+	TInt r = KErrNone;
+	TUint testZoneIndex = 0;
+	// Get the most pref zone which is completely free to use as a test zone
+	r = FindMostPrefEmpty(testZoneIndex);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("Cannot find empty zone - Skipping...\n"));
+		goto skipTest8;
+		}
+	// fill the test zone with movable pages
+	r = ZoneAllocMovable(gChunkArray1, gChunkArraySize1, testZoneIndex);
+	GetAllPageInfo();
+	if (r != KErrNone ||
+		gZoneUtilArray[testZoneIndex].iAllocMovable != gZoneUtilArray[testZoneIndex].iPhysPages)
+		{
+		test.Printf(_L("Failed to allocate movable r = %d - Skipping...\n"), r);
+		goto skipTest8;
+		}
+	if (gTotalPageCount.iFreePages < 1)
+		{
+		test.Printf(_L("Insufficient memory - totalFreePages = 0x%x - Skipping...\n"), gTotalPageCount.iFreePages);
+		goto skipTest8;
+		}
+	for (TUint zoneIndex = 0; zoneIndex < gZoneCount; zoneIndex++)
+		{
+		TUint zoneId = gZoneConfigArray[zoneIndex].iZoneId;
+		if (zoneIndex != testZoneIndex)
+			{
+			r = Ldd.SetZoneFlag(zoneId, gZoneConfigArray[zoneIndex].iFlags, NO_FIXED_FLAG);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("Failed to set flag on zone index %d r = %d- Skipping...\n"), zoneIndex, r);
+				goto skipTest8;
+				}
+			}
+		}
+	//attempt to alloc 1 contiguous fixed page
+	r = Ldd.AllocContiguous(gPageSize);
+	GetAllPageInfo();
+	if (r != KErrNone ||
+		!gZoneUtilArray[testZoneIndex].iAllocFixed)
+		{
+		test.Printf(_L("FAIL: no fixed pages in testZoneIndex(%d) r = %d\n"), testZoneIndex, r);
+		CLEANUP(Ldd.FreeAllFixedPages());
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+skipTest8:
+	TestEnd();
+	test.End();
+	return KErrNone;
+	}
+//
+// TestMovingPages
+//
+//---------------------------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID				KBASE-t_ramdefrag-0526
+//! @SYMTestType				CIT
+//! @SYMTestCaseDesc			Verifying that pages are moved correctly
+//! @SYMPREQ					PREQ308
+//! @SYMTestPriority			High
+//! @SYMTestActions
+//! 	1.	Fragment the memory. Write to all chunks apart from chunk 9.
+//! 		Following this start a RAM defrag and whilst defrag is running write to chunk 9.
+//! 	2.	Fragment the memory. Start a RAM defrag and whilst defrag is running
+//! 		continuously write different values to the chunks.
+//! 	3.	Fragment the memory. Following this start a RAM defrag and whilst this
+//! 		is happening, continuously read from all chunks.
+//! 	4.	Allocate some movable pages. Call a device driver that will allocate fixed
+//! 		pages and write values to these fixed pages.
+//! 		Close every other chunk so that only 5 chunks are now still open.
+//! 		Following this perform a RAM defrag.
+//! 		Read from the fixed pages that were originally written to, ensuring
+//! 		that they have not changed.
+//! 	5.	Without starting any processes, allocate discardable pages by loading
+//! 		pages that are demand paged.
+//! 		Read each of the constants from beginning to end.
+//! 		Following this perform a RAM defrag.
+//!
+//! @SYMTestExpectedResults
+//! 	1.	Zones are emptied
+//! 	2.	Zones are emptied
+//! 	3.	Zones are emptied
+//! 	4.	The values written to the fixed pages have not changed.
+//! 	5.	Zones are emptied
+//---------------------------------------------------------------------------------------------------------------------
+TInt TestMovingPages()
+	{
+	const TInt KAllChunks = -1;  // Specifies that all chunks should be written to
+	test.Start(_L("Test1: Whilst moving page, change the usage "));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks, KChunkDefaultSize);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	// Find a chunk that exists
+	TInt chunkIndex = gChunkArraySize1 - 1;
+	for (; chunkIndex >= 0 && gChunkArray1[chunkIndex].Handle() == NULL; chunkIndex--);
+	if (chunkIndex < 0)
+		{
+		test.Printf(_L("No chunks were allocated\n"));
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		TEST_FAIL;
+		}
+	WriteToChunk(gChunkArray1, gChunkArraySize1, chunkIndex);
+	TInt r = gTestThread.Create(gTestThreadName,MultiGenDefragThreadFunc,KDefaultStackSize,0x1000,0x1000,NULL);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		TEST_FAIL;
+		}
+	gTestThread.Logon(status);
+	gTestThread.Resume();
+	TUint8* base = gChunkArray1[chunkIndex].Base();
+	while (status.Int() == KRequestPending)
+		{
+		User::After(10000);
+		for (TInt8 k = 0; k < 10; k ++)
+			{
+			if (base == gChunkArray1[chunkIndex].Base() + gChunkArray1[chunkIndex].Size())
+				{
+				base = gChunkArray1[chunkIndex].Base();
+				}
+			*base++ = k; // write 0 - 9 to the chunk
+			}
+		}
+	User::WaitForRequest(status);
+	r = status.Int();
+	TESTDEBUG(test.Printf(_L("defrag running on another thread returns %d\n"), r));
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	if (r == KErrNone)
+		{
+		test.Printf(_L("Correct return value\n"));
+		test.Printf(_L("Passed...\n"));
+		}
+	else
+		{
+		test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrNone);
+		TEST_FAIL;
+		}
+	gTestThread.Close();
+	TestEnd();
+	test.Next(_L("Test2: Whilst moving page, change the contents of the page"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks, KChunkDefaultSize);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	WriteToChunk(gChunkArray1, gChunkArraySize1, KAllChunks);
+	r = gTestThread.Create(gTestThreadName,MultiGenDefragThreadFunc,KDefaultStackSize,0x1000,0x1000,NULL);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		TEST_FAIL;
+		}
+	gTestThread.Logon(status);
+	gTestThread.Resume();
+	TUint8 startValue = 0;
+	while (status.Int() == KRequestPending)
+		{
+		User::After(10000);
+		WriteToChunk(gChunkArray1, gChunkArraySize1, KAllChunks, startValue);
+		if (++startValue > 245)
+			{
+			startValue = 0;
+			}
+		}
+	User::WaitForRequest(status);
+	r = status.Int();
+	TESTDEBUG(test.Printf(_L("defrag running on another thread returns %d\n"), r));
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	if (r == KErrNone)
+		{
+		test.Printf(_L("Correct return value\n"));
+		test.Printf(_L("Passed...\n"));
+		}
+	else
+		{
+		test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrNone);
+		TEST_FAIL;
+		}
+	gTestThread.Close();
+	TestEnd();
+	test.Next(_L("Test3: Whilst moving page, read pages"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks, KChunkDefaultSize);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	WriteToChunk(gChunkArray1, gChunkArraySize1, KAllChunks);
+	r = gTestThread.Create(gTestThreadName,MultiGenDefragThreadFunc,KDefaultStackSize,0x1000,0x1000,NULL);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		TEST_FAIL;
+		}
+	gTestThread.Logon(status);
+	gTestThread.Resume();
+	while (status.Int() == KRequestPending)
+		{
+		User::After(100000000);
+		ReadChunk(gChunkArray1, gChunkArraySize1);
+		}
+	User::WaitForRequest(status);
+	r = status.Int();
+	TESTDEBUG(test.Printf(_L("defrag running on another thread returns %d\n"), r));
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	if (r == KErrNone)
+		{
+		test.Printf(_L("Correct return value\n"));
+		test.Printf(_L("Passed...\n"));
+		}
+	else
+		{
+		test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+		TEST_FAIL;
+		}
+	gTestThread.Close();
+	TestEnd();
+	test.Next(_L("Test4: Allocate fixed pages and then perform a defrag"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	Ldd.AllocateFixedWrite(FILL_ALL_FIXED);
+	GetOriginalPageCount();
+	r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+	test.Printf(_L("defrag returns %d\n"), r);
+	if (CheckZonesSwitchedOff() != EFalse)
+		{
+		test.Printf(_L("Fail: Zones were switched off when they shouldn't have been\n"));
+		CLEANUP(r = Ldd.FreeAllFixedPagesRead());
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+	r = Ldd.FreeAllFixedPagesRead();
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test5: Allocate discardable pages and then perform a defrag"));
+	TestStart();
+	if (gPagedRom)
+		{
+		TInt discardablePages;
+		UpdateRamInfo();
+		r = AllocDiscardable(discardablePages);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+			TEST_FAIL;
+			}
+		TESTDEBUG(test.Printf(_L("Number of discardable pages = 0x%x\n"), discardablePages >> gPageShift));
+		GetOriginalPageCount();
+		TBool genSucceed = CanGenSucceed();
+		r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+		TESTDEBUG(test.Printf(_L("defrag returns %d\n"), r));
+		if (genSucceed && CheckZonesSwitchedOff() == EFalse)
+			{
+			test.Printf(_L("Fail: Zones were not switched off when they should have been\n"));
+			CLEANUP(ResetDPCache());
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		ResetDPCache();
+		}
+	else
+		{
+		test.Printf(_L("Not a paged ROM - Skipping test step\n"));
+		}
+	TestEnd();
+	test.End();
+	return 0;
+	}
+//
+// TestMovPgsDefrag
+//
+//---------------------------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID				KBASE-t_ramdefrag-0527
+//! @SYMTestType				CIT
+//! @SYMTestCaseDesc			Verifying the moving of pages in the defrag implmentation
+//! @SYMPREQ					PREQ308
+//! @SYMTestPriority			High
+//! @SYMTestActions
+//! 	1.	Fragment the memory. Following this perform a RAM defrag.
+//! 		Now that all movable memory has now been moved and the relevant source
+//! 		zones have been switched off, again attempt to perform a RAM defrag.
+//! 	2.	Fragment the memory. Following this perform a RAM defrag and whilst
+//! 		this is happening, continuously create more chunks.
+//!		3.	Set up memory so that there are a mix of movable and free pages in a low preference zone, with there
+//!			being movable pages in the higher preference zones. Following this call a general defrag
+//!		4.	Set up memory so that there are a mix of movable and free pages and a couple of free pages
+//!			in a low preference zone, with there being enough free pages in the higher preference zones for the
+//!			pages to be moved to. Following this call a general defrag
+//!		5.	Set up memory so that there is a fixed page and a movable page in an empty zone (testZone). Also ensure that
+//!			there are movable and free pages in more preferable zones than the test zone. Following this call a general
+//!			defrag
+//!		6.	Set up memory so that the mostPrefZone contains movable and free pages. Allocate 1 movable and 1 fixed
+//!			page into an empty zone (testZone). Following this call a general defrag.
+//!
+//! @SYMTestExpectedResults
+//! 	1.	Second defrag does not empty any zones
+//! 	2.	No zones have been emptied
+//!		3.	Zones are emptied if the general defrag can succeed
+//! 	4.	Defrag fills up the less preferable zones first
+//!		5.	movable pages are moved from the testZone
+//!		6.	testZone is not emptied
+//---------------------------------------------------------------------------------------------------------------------
+TInt TestMovPgsDefrag()
+	{
+	TInt r = KErrNone;
+	test.Start(_L("Test1: Performing a defrag twice"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+	TESTDEBUG(test.Printf(_L("After calling general defrag r = %d\n"), r));
+	r = VerifyMovDisAlloc();
+	// The first defrag should empty zones if the general can succeed
+	if (r != KErrNone)
+		{
+		test.Printf(_L("Fail: r = %d, memory is not laid out as expected\n"), r);
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		TEST_FAIL;
+		}
+	GetOriginalPageCount();
+	r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+	TESTDEBUG(test.Printf(_L("After calling general defrag again r = %d\n"), r));
+	// The second call to general defrag should have nothing further to do
+	if (r != KErrNone || CheckZonesSwitchedOff() != EFalse)
+		{
+		test.Printf(_L("Fail: r = %d, expected = %d, or zones have been switched off \n"),
+						r, KErrNone);
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test2: Ensure new memory allocations can occur successfully during a general defrag"));
+	TestStart();
+	// Create a thread to call Defrag continuously and resume it
+	r = gTestThread.Create(gTestThreadName,MultiLoopGenDefragThreadFunc,KDefaultStackSize,0x1000,0x1000,NULL);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+		TEST_FAIL;
+		}
+	gTestThread.Logon(status);
+	gTestLoop = ETrue;
+	gTestThread.Resume();
+	// Whilst the defrag loop is taking place, continuously allocate and free memory
+	for (TInt i = 0; i < 100; i++)
+		{
+		r = AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+		if (r != KErrNone)
+			break;
+		RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+		}
+	gTestLoop = EFalse;
+	User::WaitForRequest(status);
+	TESTDEBUG(test.Printf(_L("defrag running on another thread returns %d\n"), r));
+	if (r != KErrNone || status.Int() != KErrNone)
+		{
+		test.Printf(_L("Fail: r = %d, status.Int() = %d\n"), r, status.Int());
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	RemoveChunkAlloc(gChunkArray2, gChunkArraySize2);
+	gTestThread.Close();
+	TestEnd();
+	test.Next(_L("Test3: Check whether RAM defrag switches off any zones"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetOriginalPageCount();
+	TBool genSucceed = CanGenSucceed();
+	r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+	TESTDEBUG(test.Printf(_L("After calling zone defrag r = %d\n"), r));
+	if (r != KErrNone || (genSucceed && CheckZonesSwitchedOff() == EFalse))
+		{
+		test.Printf(_L("Fail: No zones were switched off or r = %d, expected = %d\n"), r, KErrNone);
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test4: Verify that a general defrag moves pages to the least preferable RAM zone in use"));
+	TestStart();
+	gChunkArray1 = new RChunk;
+	gChunkArraySize1 = 1;
+	// Get the preference order
+	GetPrefOrder();
+	TUint mostPrefIndex = 0;
+	TUint mostPrefArrayIndex = 0;
+	TUint totMov = 0;
+	TUint lastPrefIndex = 0;
+	TUint lastPrefArrayIndex = 0;
+	TUint movPages = 0;
+	TUint movBytes = 0;
+	TUint totFreeInTestZones = 0;
+	TBool zoneNotEmptyOrFull = EFalse;
+	// Find the first most pref zone that has free pages in it
+	r = FindMostPrefWithFree(mostPrefIndex, &mostPrefArrayIndex);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping...\n"));
+		goto skipTest4;
+		}
+	// Find the next most preferable free zone
+	lastPrefArrayIndex = mostPrefArrayIndex + 1;
+	while (lastPrefArrayIndex < gZoneCount &&
+		gZoneUtilArray[gPrefArray[lastPrefArrayIndex]].iFreePages != gZoneUtilArray[gPrefArray[lastPrefArrayIndex]].iPhysPages)
+		{
+		lastPrefArrayIndex++;
+		}
+	if (lastPrefArrayIndex >= gZoneCount)
+		{
+		test.Printf(_L("Skipping...\n"));
+		goto skipTest4;
+		}
+	// Block all other zones
+	for (TUint prefIndex = lastPrefArrayIndex + 1; prefIndex < gZoneCount; prefIndex++)
+		{
+		TUint zoneIndex = gPrefArray[prefIndex];
+		Ldd.SetZoneFlag(gZoneConfigArray[zoneIndex].iZoneId, gZoneConfigArray[zoneIndex].iFlags, NO_ALLOC_FLAG);
+		}
+	// Zone alloc to fill half of the last zone under test
+	GetAllPageInfo();
+	lastPrefIndex = gPrefArray[lastPrefArrayIndex];
+	r = Ldd.ZoneAllocDiscontiguous(gZoneConfigArray[lastPrefIndex].iZoneId, gZoneUtilArray[lastPrefIndex].iFreePages >> 1);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("Failed to allocate fixed pages r = %d - Skipping...\n"), r);
+		goto skipTest4;
+		}
+	// Go through the zones under test and determine the number of free pages
+	GetAllPageInfo();
+	for(TUint prefIndex = mostPrefArrayIndex; prefIndex <= lastPrefArrayIndex; prefIndex++)
+		{
+		TUint zoneIndex = gPrefArray[prefIndex];
+		totFreeInTestZones += gZoneUtilArray[zoneIndex].iFreePages;
+		}
+	// Allocate movable pages to almost fill zones under test
+	movPages = totFreeInTestZones;
+	movBytes = movPages << gPageShift;
+	while (movBytes && AllocMovable(gChunkArray1, gChunkArraySize1, 1, movBytes) != KErrNone)
+		{
+		movBytes -= gPageSize;
+		movPages--;
+		}
+	if (!movBytes)
+		{
+		test.Printf(_L("Failed to allocate 0x%x movable pages - Skipping...\n"), movPages);
+		goto skipTest4;
+		}
+	// Free the allocated fixed pages
+	Ldd.FreeAllFixedPages();
+	// Reset all the flags
+	ResetRamZoneFlags();
+	// Check that the most preferable zone still has movable pages in it
+	// and also check that the last zone under test has free pages in it
+	GetAllPageInfo();
+	if (gTotalPageCount.iMovablePages < movPages ||
+		gZoneUtilArray[mostPrefIndex].iAllocMovable == 0 ||
+		gZoneUtilArray[lastPrefIndex].iFreePages == 0)
+		{
+		test.Printf(_L("Setup failed - Skipping...\n"));
+		goto skipTest4;
+		}
+	r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+	// Check that defrag allocated the movable from the less preferable to the more preferable
+	GetPrefOrder();
+	totMov = gTotalPageCount.iMovablePages;
+	for(TInt prefIndex = gZoneCount - 1; prefIndex >= 0 ; prefIndex--)
+		{
+		TUint zoneIndex = gPrefArray[prefIndex];
+		GetCandList1(zoneIndex);
+		TUint candIndex = 0;
+		for (; candIndex < gZoneCount; candIndex++)
+			{// Check all the zones of this preference
+			TInt zoneIndexCand = gCandList1[candIndex];
+			if (zoneIndexCand == KInvalidCandIndex)
+				{
+				break;
+				}
+			totMov -= gZoneUtilArray[zoneIndexCand].iAllocMovable;
+			if (gZoneUtilArray[zoneIndexCand].iFreePages != gZoneUtilArray[zoneIndexCand].iPhysPages &&
+				gZoneUtilArray[zoneIndexCand].iFreePages != 0)
+				{
+				zoneNotEmptyOrFull = ETrue;
+				}
+			}
+		prefIndex -= candIndex - 1 ;
+		if (zoneNotEmptyOrFull && totMov != 0)
+			{
+			test.Printf(_L("FAIL: index = %d free = 0x%x totMov = 0x%x\n"),
+							zoneIndex, gZoneUtilArray[zoneIndex].iFreePages, totMov);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			CLEANUP(RemoveChunkAlloc(gChunkArray2, gChunkArraySize2));
+			TEST_FAIL;
+			}
+		}
+skipTest4:
+	TestEnd();
+	test.Next(_L("Test5: Verify that a general defrag tidies up if RAM zone to be emptied contains fixed pages"));
+	TestStart();
+	gChunkArray1 = new RChunk;
+	gChunkArraySize1 = 1;
+	gChunkArray2 = new RChunk;
+	gChunkArraySize2 = 1;
+	// find 2 empty zones - put 1 movable in 1 of them and 1 movable and 1 fixed in the other
+	TUint testZoneIndex1;
+	TUint testZoneIndex2;
+	TUint testZoneID2;
+	TUint numFreeInUse = 0;
+	r = FindMostPrefEmpty(testZoneIndex1);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("Skipping...\n"));
+		goto skipTest5;
+		}
+	// Allocate 1 movable page to the test zone
+	r = ZoneAllocMovable(gChunkArray1, gChunkArraySize1, testZoneIndex1, 1);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("Failed to allocate 1 movable page to zone index %d, r = %d - Skipping...\n"), testZoneIndex1, r);
+		goto skipTest5;
+		}
+	r = FindMostPrefEmpty(testZoneIndex2);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("Skipping...\n"));
+		goto skipTest5;
+		}
+	// Allocate 1 movable page to the test zone
+	r = ZoneAllocMovable(gChunkArray2, gChunkArraySize2, testZoneIndex2, 1);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("Failed to allocate 1 movable page to zone index %d, r = %d - Skipping...\n"), testZoneIndex2, r);
+		goto skipTest5;
+		}
+	// Zone alloc to put 1 fixed page last zone under test
+	testZoneID2 = gZoneConfigArray[testZoneIndex2].iZoneId;
+	r = Ldd.ZoneAllocContiguous(testZoneID2, gPageSize);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("Failed to allocate 1 fixed page to zone %d index, r = %d - Skipping...\n"), testZoneIndex2, r);
+		goto skipTest5;
+		}
+	// Allocate 2 fixed (as there is 1 in our test zone) to prevent reordering
+	GetAllPageInfo();
+	for (TUint index = 0; index < gZoneCount; index++)
+		{
+		TUint totImmovable = gZoneUtilArray[index].iAllocFixed + gZoneUtilArray[index].iAllocUnknown ;
+		if (index != testZoneIndex1 &&
+			index != testZoneIndex2 &&
+			gZoneUtilArray[index].iFreePages != gZoneUtilArray[index].iPhysPages &&
+			totImmovable < 2)
+			{
+			r = Ldd.ZoneAllocToMany(index, 2 - totImmovable);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("Failed to alloc 0x%x fixed to zone index %d r = %d - Skipping...\n"),
+								2, index, r);
+				goto skipTest5;
+				}
+			}
+		}
+	// Check that the number of free pages in the other in-use zones >= movable pages in test zone
+	GetAllPageInfo();
+	for (TUint index = 0; index < gZoneCount; index++)
+		{
+		if (index != testZoneIndex1 &&
+			index != testZoneIndex2 &&
+			gZoneUtilArray[index].iFreePages != gZoneUtilArray[index].iPhysPages)
+			{
+			numFreeInUse += gZoneUtilArray[index].iFreePages;
+			}
+		}
+	if (gZoneUtilArray[testZoneIndex1].iAllocMovable + gZoneUtilArray[testZoneIndex1].iAllocDiscardable +
+		gZoneUtilArray[testZoneIndex2].iAllocMovable + gZoneUtilArray[testZoneIndex2].iAllocDiscardable > numFreeInUse ||
+		gZoneUtilArray[testZoneIndex2].iAllocFixed == 0)
+		{
+		test.Printf(_L("Setup failed - Skipping...\n"));
+		goto skipTest5;
+		}
+	// Added extra tracing to debug random failures
+	PrintPageInfo();
+	// Call a general defrag
+	GetOriginalPageCount();
+	r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+	// Check that the defrag tidies up
+	GetAllPageInfo();
+	if(gZoneUtilArray[testZoneIndex1].iAllocMovable ||
+		gZoneUtilArray[testZoneIndex2].iAllocMovable)
+		{
+		test.Printf(_L("FAIL: testZoneIndex1(%d): mov orig 0x%x cur 0x%x, testZoneIndex2(%d) mov orig 0x%x cur 0x%x \n"),
+						testZoneIndex1, gOriginalPageCountArray[testZoneIndex1].iAllocMovable, gZoneUtilArray[testZoneIndex1].iAllocMovable,
+						testZoneIndex2, gOriginalPageCountArray[testZoneIndex2].iAllocMovable, gZoneUtilArray[testZoneIndex2].iAllocMovable);
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		CLEANUP(RemoveChunkAlloc(gChunkArray2, gChunkArraySize2));
+		CLEANUP(Ldd.FreeAllFixedPages());
+		TEST_FAIL;
+		}
+skipTest5:
+	TestEnd();
+	test.Next(_L("Test6: Verify that a general defrag will not move pages if RAM zone to be emptied contains fixed pages"));
+	TestStart();
+	gChunkArray1 = new RChunk;
+	gChunkArraySize1 = 1;
+	// Find the first most pref zone that has free pages in it
+	r = FindMostPrefWithFree(mostPrefIndex, &mostPrefArrayIndex);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping...\n"));
+		goto skipTest6;
+		}
+	// Find the next most preferable free zone
+	lastPrefArrayIndex = mostPrefArrayIndex + 1;
+	while (lastPrefArrayIndex < gZoneCount &&
+		gZoneUtilArray[gPrefArray[lastPrefArrayIndex]].iFreePages != gZoneUtilArray[gPrefArray[lastPrefArrayIndex]].iPhysPages)
+		{
+		lastPrefArrayIndex++;
+		}
+	if (lastPrefArrayIndex >= gZoneCount)
+		{
+		test.Printf(_L("Skipping...\n"));
+		goto skipTest6;
+		}
+	// Zone alloc to put 1 fixed page last zone under test
+	lastPrefIndex = gPrefArray[lastPrefArrayIndex];
+	r = Ldd.ZoneAllocDiscontiguous(gZoneConfigArray[lastPrefIndex].iZoneId, 1);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("Failed to allocate 1 fixed page to zone index %d r = %d - Skipping...\n"), lastPrefIndex, r);
+		goto skipTest6;
+		}
+	GetAllPageInfo();
+	if (!gZoneUtilArray[mostPrefIndex].iFreePages)
+		{
+		test.Printf(_L("Not enough space in zone under test  mostPrefIndex = %d - Skipping...\n"), mostPrefIndex);
+		goto skipTest6;
+		}
+	// Block all zones apart from the last zone under test from allocation
+	for (TUint prefIndex = 0; prefIndex < gZoneCount; prefIndex++)
+		{
+		TUint zoneIndex = gPrefArray[prefIndex];
+		if (zoneIndex != lastPrefIndex)
+			{
+			Ldd.SetZoneFlag(gZoneConfigArray[zoneIndex].iZoneId, gZoneConfigArray[zoneIndex].iFlags, NO_ALLOC_FLAG);
+			}
+		}
+	TESTDEBUG(test.Printf(_L("mostPrefIndex = %d lastPrefIndex = %d\n"), mostPrefIndex, lastPrefIndex));
+	// Allocate movable pages to the lastPrefZone that will fit into the most pref zone
+	movPages = gZoneUtilArray[mostPrefIndex].iFreePages;
+	movBytes = movPages << gPageShift;
+	while (movBytes && AllocMovable(gChunkArray1, gChunkArraySize1, 1, movBytes) != KErrNone)
+		{
+		movBytes -= gPageSize;
+		}
+	if (!movBytes)
+		{
+		test.Printf(_L("Failed to allocate 0x%x movable pages r = %d - Skipping...\n"), movPages, r);
+		goto skipTest6;
+		}
+	// Reset all the flags
+	ResetRamZoneFlags();
+	// Check that the number of movable pages in the least pref will fit
+	// into the most preferable zone
+	GetAllPageInfo();
+	if (gZoneUtilArray[lastPrefIndex].iAllocMovable > gZoneUtilArray[mostPrefIndex].iFreePages)
+		{
+		test.Printf(_L("Setup failed - Skipping...\n"));
+		PrintPageInfo();
+		goto skipTest6;
+		}
+	// Added extra tracing to debug random failures
+	PrintPageInfo();
+	// Call a general defrag
+	GetOriginalPageCount();
+	r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+	// Check that the defrag didn't move any pages from the least pref zone
+	GetAllPageInfo();
+	if(gOriginalPageCountArray[lastPrefIndex].iAllocMovable > gZoneUtilArray[lastPrefIndex].iAllocMovable)
+		{
+		test.Printf(_L("FAIL: mostPref(index %d): origMov = 0x%x curMov = 0x%x, lastPref(index %d): origMov = 0x%x curMov = 0x%x \n"),
+						mostPrefIndex, gOriginalPageCountArray[mostPrefIndex].iAllocMovable, gZoneUtilArray[mostPrefIndex].iAllocMovable,
+						lastPrefIndex, 	gOriginalPageCountArray[lastPrefIndex].iAllocMovable, gZoneUtilArray[lastPrefIndex].iAllocMovable);
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		CLEANUP(RemoveChunkAlloc(gChunkArray2, gChunkArraySize2));
+		CLEANUP(Ldd.FreeAllFixedPages());
+		TEST_FAIL;
+		}
+skipTest6:
+	TestEnd();
+	test.End();
+	return KErrNone;
+	}
+//
+// GenDefragTest123Setup
+//
+// Used to set up the memory ready for testing in TestGenDefrag, Test Steps 1, 2, 3 and 4
+//
+// @param aMovAlloc The number of movable pages to allocate.
+// @param aFixAlloc The number of fixed pages to allocate.
+// @param aDisAlloc The number of discardable pages to allocate.
+// @param aMovIndex On return contains the test zone index.
+// @param aNumFreeInUse On return contains the number of free pages in the inuse zones.
+// @param aTestNo The test number that is using this setup.
+//
+TInt GenDefragTest123Setup(TUint aMovAlloc, TUint aFixAlloc, TUint aDisAlloc, TUint& aMovIndex, TUint& aNumFreeInUse, TUint aTestNo)
+	{
+	TInt r = KErrNone;
+	aNumFreeInUse = 0;
+	const TUint KFillUpTo = 5;	// Rough estimate of how full the in-use zones should be
+	const TUint KSpaceNeeded = 2;
+	TUint movPrefIndex = 0;
+	if (aTestNo == 4)
+		{// Test 4 we need to look for the LEAST preferable RAM zone which is empty
+		TUint mostPrefIndex;
+		r = FindLeastPrefEmpty(aMovIndex, &movPrefIndex);
+		TInt r2 = FindMostPrefEmpty(mostPrefIndex);
+		if (r != KErrNone || r2 != KErrNone || !gPagedRom ||
+			gZoneConfigArray[aMovIndex].iPref == gZoneConfigArray[mostPrefIndex].iPref)
+			{
+			test.Printf(_L("r %d r2 %d or not a paged ROM or Equal zone preferences- Skipping test step...\n"),
+							r, r2);
+			return KErrGeneral;
+			}
+		}
+	else
+		{// All other tests look the MOST preferable RAM zone which is empty
+		r = FindMostPrefEmpty(aMovIndex, &movPrefIndex);
+		if (r != KErrNone || !gPagedRom)
+			{
+			test.Printf(_L("No suitable RAM zone found or not a paged ROM - Skipping test step...\n"));
+			return KErrGeneral;
+			}
+		}
+	// Go through all the in-use zones and check how many free pages there are
+	// Allocate fixed so there is only KFillUpTo pages in each in-use zone to
+	// ensure that the total number of free pages in the in-use zones can fit into
+	// the zone under test
+	GetAllPageInfo();
+	for (TUint index = 0; index < gZoneCount; index++)
+		{
+		if (gZoneUtilArray[index].iFreePages != gZoneUtilArray[index].iPhysPages &&
+			gZoneUtilArray[index].iFreePages > KFillUpTo)
+			{
+			r = Ldd.ZoneAllocToMany(index, gZoneUtilArray[index].iFreePages - KFillUpTo);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("Failed to alloc 0x%x fixed to zone index %d r = %d - Ending setup...\n"),
+								gZoneUtilArray[index].iFreePages - KFillUpTo, index, r);
+				return KErrGeneral;
+				}
+			}
+		}
+	GetAllPageInfo();
+	// If any of the in-use zones doesn't contain any fixed and unknown pages allocate one fixed
+	for (TUint index = 0; index < gZoneCount; index++)
+		{
+		if (gZoneUtilArray[index].iFreePages != gZoneUtilArray[index].iPhysPages &&
+			!gZoneUtilArray[index].iAllocFixed && !gZoneUtilArray[index].iAllocUnknown)
+			{
+			r = Ldd.ZoneAllocToMany(index, 1);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("Failed to alloc 0x%x fixed to zone index %d r = %d - Ending setup...\n"),
+								1, index, r);
+				return KErrGeneral;
+				}
+			}
+		}
+	GetAllPageInfo();
+	// Check the total number of free pages in the in-use zones
+	for (TUint index = 0; index < gZoneCount; index++)
+		{
+		if (gZoneUtilArray[index].iFreePages != gZoneUtilArray[index].iPhysPages)
+			{
+			aNumFreeInUse += gZoneUtilArray[index].iFreePages;
+			}
+		}
+	TESTDEBUG(test.Printf(_L("aNumFreeInUse = 0x%x\n"), aNumFreeInUse));
+	test.Printf(_L("aMovIndex = %d\n"), aMovIndex);
+	if (aNumFreeInUse < KSpaceNeeded)
+		{
+		test.Printf(_L("RAM zone to be tested is too full - Skipping test step...\n"));
+		return KErrGeneral;
+		}
+	// Ensure that there are movable pages in the zone under test
+	// ensuring that there is also room for discardable pages
+	GetAllPageInfo();
+	if (aMovAlloc != 0 && gZoneUtilArray[aMovIndex].iAllocMovable == 0)
+		{
+		// Allocate just aMovAlloc movable pages
+		TUint movPagesAlloc = aMovAlloc;
+		if (aTestNo == 2 || aTestNo == 4)
+			{// Tests 2 and 4 require that movable pages can't be moved from zone
+			movPagesAlloc = aNumFreeInUse + 1;
+			if (movPagesAlloc > gZoneUtilArray[aMovIndex].iFreePages)
+				{
+				test.Printf(_L("Insufficiant space in zone %d to allocate 0x%x pages - Ending setup...\n"),
+								aMovIndex, movPagesAlloc);
+				return KErrGeneral;
+				}
+			}
+		r = ZoneAllocMovable(gChunkArray1, gChunkArraySize1, aMovIndex, movPagesAlloc);
+		if (gZoneUtilArray[aMovIndex].iAllocMovable != movPagesAlloc ||
+			gZoneUtilArray[aMovIndex].iFreePages == 0 ||
+			r != KErrNone)
+			{// Movable page didn't go into RAM, or RAM zone is full.
+			test.Printf(_L("Can't complete test with current RAM layout. - Skipping...\n"));
+			test.Printf(_L("zone mov 0x%x free 0x%x r=%d\n"),
+						gZoneUtilArray[aMovIndex].iAllocMovable,
+						gZoneUtilArray[aMovIndex].iFreePages, r);
+			return KErrGeneral;
+			}
+		}
+	// Block all other zones from allocation
+	for(TUint i = 0; i < gZoneCount; i++)
+		{
+		if (i != aMovIndex)
+			{
+			r = Ldd.SetZoneFlag(gZoneConfigArray[i].iZoneId, gZoneConfigArray[i].iFlags, NO_ALLOC_FLAG);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("Failed to set flag on zone index %d r = %d- Ending setup...\n"), i, r);
+				return KErrGeneral;
+				}
+			}
+		}
+	// Now ensure that there are fixed pages in the zone under test
+	// ensuring that there is also room for discardable pages
+	GetAllPageInfo();
+	if (aFixAlloc != 0 && gZoneUtilArray[aMovIndex].iAllocFixed == 0)
+		{//Allocate just aFixAlloc fixed pages
+		r = Ldd.ZoneAllocToMany(aMovIndex, aFixAlloc);
+		GetAllPageInfo();
+		if (gZoneUtilArray[aMovIndex].iAllocMovable == 0 ||
+			gZoneUtilArray[aMovIndex].iFreePages == 0 ||
+			gZoneUtilArray[aMovIndex].iAllocFixed == 0 ||
+			r != KErrNone)
+			{// Fixed page didn't go into RAM or RAM zone is full.
+			test.Printf(_L("Can't complete test with current RAM layout. - Skipping...\n"));
+			test.Printf(_L("zone mov 0x%x fixed 0x%x free 0x%x r=%d\n"),
+						gZoneUtilArray[aMovIndex].iAllocMovable,
+						gZoneUtilArray[aMovIndex].iAllocFixed,
+						gZoneUtilArray[aMovIndex].iFreePages, r);
+			return KErrGeneral;
+			}
+		}
+	// Allocate aDisAlloc number of discardable pages
+	if (aDisAlloc != 0 && gZoneUtilArray[aMovIndex].iAllocDiscardable == 0)
+		{//Allocate just aDisAlloc discardable pages
+		TInt discard;
+		r = ZoneAllocDiscard(aMovIndex, aDisAlloc, discard);
+		GetAllPageInfo();
+		if (r != KErrNone || gZoneUtilArray[aMovIndex].iAllocDiscardable == 0)
+			{// Discardable page didn't go into RAM or RAM zone is full.
+			test.Printf(_L("Can't complete test with current RAM layout. - Skipping...\n"));
+			test.Printf(_L("zone mov 0x%x discardable 0x%x free 0x%x r=%d\n"),
+						gZoneUtilArray[aMovIndex].iAllocDiscardable,
+						gZoneUtilArray[aMovIndex].iAllocFixed,
+						gZoneUtilArray[aMovIndex].iFreePages, r);
+			return KErrGeneral;
+			}
+		}
+	// Update the total number of free pages in the in-use zones
+	aNumFreeInUse = 0;
+	for (TUint index = 0; index < gZoneCount; index++)
+		{
+		if (gZoneUtilArray[index].iFreePages != gZoneUtilArray[index].iPhysPages &&
+			index != aMovIndex)
+			{
+			aNumFreeInUse += gZoneUtilArray[index].iFreePages;
+			}
+		}
+	TESTDEBUG(test.Printf(_L("aNumFreeInUse = 0x%x\n"), aNumFreeInUse));
+	// now reset all the flags
+	ResetRamZoneFlags();
+	return KErrNone;
+	}
+//
+// TestGenDefrag
+//
+//---------------------------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID				KBASE-t_ramdefrag-0528
+//! @SYMTestType				CIT
+//! @SYMTestCaseDesc			Verifying general scenarios when RAM defrag would take place
+//! @SYMPREQ					PREQ308
+//! @SYMTestPriority			High
+//! @SYMTestActions
+//! 	1.	Allocate 1 movable, 1 fixed and 1 discardable pages into the most preferable empty RAM zone
+//!			ensuring that there is enough free space in the more preferable RAM zones for the
+//!			movable pages in the RAM zone under test. Following this call a general defrag.
+//!		2.	Allocate 1 movable and 1 discardable page into into the most preferable empty RAM zone
+//!			ensuring that there is not enough free space in the more preferable RAM zones for the
+//!			movable pages in the RAM zone under test. Following this call a general defrag.
+//!		3.	Allocate 1 movable and 1 discardable and 1 fixed page into the most preferable empty RAM zone(a).
+//!			Following this, place 1 movable page in an empty zone(b) ensuring that there is enough free space in
+//!			the more preferable RAM zones for the movable pages in both zones (a) and (b).
+//!			Following this call a general defrag.
+//!		4.	Allocate 1 movable and 1 discardable page into the least preferable empty RAM zone
+//!			ensuring that there is not enough free space in the more preferable RAM zones for the
+//!			movable pages in the RAM zone under test. Following this call a general defrag.
+//! 	5.	Fragment the memory.
+//! 		Following this allocate discardable pages by loading pages that are demand paged.
+//! 		Read each of the constants from beginning to end.
+//! 		Following this perform a RAM defrag.
+//! 	6.	Call a device driver that will continuously allocate fixed pages to the
+//! 		memory until it reports out of memory. Following this perform a RAM defrag.
+//!		7.	Defrag memory filled with discardable pages when the min cache size is reached
+//!		8.	Fragment the memory. Following this, continuously call a general defrag, each time
+//!			reducing the size of the chunks that are allocated
+//!
+//! @SYMTestExpectedResults
+//! 	1.	The RAM zone under test is not emptied and all the discardable pages contained in it
+//!			have not been discarded.
+//! 	2.	The RAM zone under test is not emptied and all the discardable pages contained in it
+//!			have not been discarded.
+//! 	3.	RAM zones (a) and (b) have been emptied and all the discardable pages contained in them
+//!			have not been discarded.
+//!		4.	The RAM zone under test is emptied
+//! 	5.	Pages are discarded
+//! 	6.	No zones are emptied
+//!		7.	The least preferable zone is skipped but the other zones are defragmented as required.
+//! 	8.	Zones are emptied if the general defrag can succeed
+//---------------------------------------------------------------------------------------------------------------------
+TInt TestGenDefrag()
+	{
+	TInt r = KErrNone;
+	test.Start(_L("Test1: Test General Defrag doesn't discard pages when fixed page in zone to be emptied"));
+	TestStart();
+	gChunkArray1 = new RChunk;
+	gChunkArraySize1 = 1;
+	TUint numFreeInUse = 0;
+	TUint testNo = 1;
+	// We just need 1 movable, 1 discardable and 1 fixed in the zone to ensure it cannot be emptied
+	// as the fixed should block the defrag
+	TInt movAllocPages = 1;
+	TInt fixAllocPages = 1;
+	TInt disAllocPages = 1;
+	TUint zoneIndex;
+	if (GenDefragTest123Setup(movAllocPages, fixAllocPages, disAllocPages, zoneIndex, numFreeInUse, testNo) != KErrNone)
+		{
+		test.Printf(_L("Setup failed - Skipping..\n"));
+		goto skipTest1;
+		}
+	// Call a general defrag and check that no discardable pages were freed.
+	GetOriginalPageCount();
+	r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+	GetAllPageInfo();
+	if (r != KErrNone ||
+		gZoneUtilArray[zoneIndex].iAllocMovable < gOriginalPageCountArray[zoneIndex].iAllocMovable ||
+		gOriginalPageCountArray[zoneIndex].iAllocDiscardable > gZoneUtilArray[zoneIndex].iAllocDiscardable)
+		{
+		test.Printf(_L("Fail: r = %d zoneIndex %d origMov 0x%x curMov 0x%x origDis 0x%x curDis 0x%x\n"), r, zoneIndex,
+						gOriginalPageCountArray[zoneIndex].iAllocMovable, gZoneUtilArray[zoneIndex].iAllocMovable,
+						gOriginalPageCountArray[zoneIndex].iAllocDiscardable, gZoneUtilArray[zoneIndex].iAllocDiscardable);
+		CLEANUP(Ldd.FreeAllFixedPages());
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+skipTest1:
+	// TestEnd() will perform any required clean up.
+	TestEnd();
+	test.Next(_L("Test2: Test General Defrag doesn't discard pages when zone can't be emptied"));
+	TestStart();
+	gChunkArray1 = new RChunk;
+	gChunkArraySize1 = 1;
+	testNo++;
+	// No fixed, but there should be no space for the movable to go to
+	// GenDefragTest123Setup(), will ensure that this is the case
+	// by allocating 1 more movable page than there is free in the in-use zones
+	movAllocPages = 1;
+	fixAllocPages = 0;
+	disAllocPages = 1;
+	if (GenDefragTest123Setup(movAllocPages, fixAllocPages, disAllocPages, zoneIndex, numFreeInUse, testNo) != KErrNone)
+		{
+		test.Printf(_L("Setup failed - Skipping..\n"));
+		goto skipTest2;
+		}
+	// Call a general defrag and check that no discardable pages were freed.
+	GetOriginalPageCount();
+	r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+	GetAllPageInfo();
+	if (r != KErrNone ||
+		gZoneUtilArray[zoneIndex].iAllocMovable < gOriginalPageCountArray[zoneIndex].iAllocMovable ||
+		gOriginalPageCountArray[zoneIndex].iAllocDiscardable > gZoneUtilArray[zoneIndex].iAllocDiscardable)
+		{
+		test.Printf(_L("Fail: r = %d zoneIndex %d origMov 0x%x curMov 0x%x origDis 0x%x curDis 0x%x\n"), r, zoneIndex,
+						gOriginalPageCountArray[zoneIndex].iAllocMovable, gZoneUtilArray[zoneIndex].iAllocMovable,
+						gOriginalPageCountArray[zoneIndex].iAllocDiscardable, gZoneUtilArray[zoneIndex].iAllocDiscardable);
+		CLEANUP(Ldd.FreeAllFixedPages());
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+skipTest2:
+	// TestEnd() will perform any required clean up.
+	TestEnd();
+	test.Next(_L("Test3: Test General Defrag tidies when fixed page in zone to be emptied but other can be emptied"));
+	TestStart();
+	gChunkArray1 = new RChunk;
+	gChunkArraySize1 = 1;
+	gChunkArray2 = new RChunk;
+	gChunkArraySize2 = 1;
+	TUint totalToMove;
+	testNo++;
+	// First use GenDefragTest123Setup() to ensure we place 1 fixed, 1 movable and 1 discardable
+	// in the least preferable zone
+	movAllocPages = 1;
+	fixAllocPages = 1;
+	disAllocPages = 1;
+	TBool zoneFound = EFalse;
+	TUint emptyZoneIndex = 0;
+	if (GenDefragTest123Setup(movAllocPages, fixAllocPages, disAllocPages, zoneIndex, numFreeInUse, testNo) != KErrNone)
+		{
+		test.Printf(_L("Setup failed - Skipping..\n"));
+		goto skipTest3;
+		}
+	// Find an empty zone and place a movable page in it
+	GetAllPageInfo();
+	for (TUint i = 0; i < gZoneCount; i++)
+		{
+		if (gZoneUtilArray[i].iFreePages == gZoneUtilArray[i].iPhysPages)
+			{
+			zoneFound = ETrue;
+			emptyZoneIndex = i;
+			break;
+			}
+		}
+	if (!zoneFound)
+		{
+		test.Printf(_L("Can't find empty zone - Skipping..\n"));
+		goto skipTest3;
+		}
+	// Allocate 1 movable page into the empty zone
+	r = ZoneAllocMovable(gChunkArray2, gChunkArraySize2, emptyZoneIndex, 1);
+	GetAllPageInfo();
+	if (r != KErrNone ||
+		gZoneUtilArray[emptyZoneIndex].iAllocMovable == 0 ||
+		gZoneUtilArray[emptyZoneIndex].iAllocFixed != 0)
+		{
+		test.Printf(_L("Movable pages not allocated or fixed pages allocated. - Skipping...\n"));
+		test.Printf(_L("zone mov 0x%x free 0x%x r =% d\n"),
+					gZoneUtilArray[emptyZoneIndex].iAllocMovable,
+					gZoneUtilArray[emptyZoneIndex].iFreePages, r);
+		goto skipTest3;
+		}
+	// Check that the amount we are allocating can actually be moved into the in-use zones
+	totalToMove = gZoneUtilArray[zoneIndex].iAllocMovable + gZoneUtilArray[zoneIndex].iAllocDiscardable +
+					gZoneUtilArray[emptyZoneIndex].iAllocMovable + gZoneUtilArray[emptyZoneIndex].iAllocDiscardable;
+	// Check the total number of free pages in the in-use zones
+	numFreeInUse = 0;
+	for (TUint index = 0; index < gZoneCount; index++)
+		{
+		if (gZoneUtilArray[index].iFreePages != gZoneUtilArray[index].iPhysPages &&
+			index != zoneIndex && index != emptyZoneIndex)
+			{
+			numFreeInUse += gZoneUtilArray[index].iFreePages;
+			}
+		}
+	if(numFreeInUse < totalToMove)
+		{
+		test.Printf(_L("No space to move pages numFreeInUse = 0x%x totalToMove = 0x%x - Skipping..\n"),
+						numFreeInUse, totalToMove);
+		goto skipTest3;
+		}
+	// Call a general defrag and check that zone is emptied.
+	GetOriginalPageCount();
+	r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+	GetAllPageInfo();
+	if (r != KErrNone ||
+		gZoneUtilArray[zoneIndex].iAllocMovable ||
+		gZoneUtilArray[zoneIndex].iAllocDiscardable ||
+		gZoneUtilArray[emptyZoneIndex].iAllocMovable)
+		{
+		test.Printf(_L("Fail: r = %d zoneIndex %d origMov 0x%x curMov 0x%x origDis 0x%x curDis 0x%x\n"), r, zoneIndex,
+						gOriginalPageCountArray[zoneIndex].iAllocMovable, gZoneUtilArray[zoneIndex].iAllocMovable,
+						gOriginalPageCountArray[zoneIndex].iAllocDiscardable, gZoneUtilArray[zoneIndex].iAllocDiscardable);
+		CLEANUP(Ldd.FreeAllFixedPages());
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+skipTest3:
+	// TestEnd() will perform any required clean up.
+	TestEnd();
+	test.Next(_L("Test4: Test General Defrag moves pages into the next most pref if they don't fit into the most pref"));
+	TestStart();
+	gChunkArray1 = new RChunk;
+	gChunkArraySize1 = 1;
+	testNo++;
+	// No fixed, but there should be no space for the movable to go to
+	// GenDefragTest123Setup(), will ensure that this is the case
+	// by allocating 1 more movable page than there is free in the in-use zones
+	movAllocPages = 1;
+	fixAllocPages = 0;
+	disAllocPages = 1;
+	if (GenDefragTest123Setup(movAllocPages, fixAllocPages, disAllocPages, zoneIndex, numFreeInUse, testNo) != KErrNone)
+		{
+		test.Printf(_L("Setup failed - Skipping..\n"));
+		goto skipTest4;
+		}
+	// Call a general defrag and check that the test zone is emptied.
+	GetOriginalPageCount();
+	r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+	GetAllPageInfo();
+	if (r != KErrNone ||
+		gZoneUtilArray[zoneIndex].iFreePages != gZoneUtilArray[zoneIndex].iPhysPages)
+		{
+		test.Printf(_L("Fail: r = %d zoneIndex %d origMov 0x%x curMov 0x%x origDis 0x%x curDis 0x%x\n"), r, zoneIndex,
+						gOriginalPageCountArray[zoneIndex].iAllocMovable, gZoneUtilArray[zoneIndex].iAllocMovable,
+						gOriginalPageCountArray[zoneIndex].iAllocDiscardable, gZoneUtilArray[zoneIndex].iAllocDiscardable);
+		CLEANUP(Ldd.FreeAllFixedPages());
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+skipTest4:
+	// TestEnd() will perform any required clean up.
+	TestEnd();
+	test.Next(_L("Test5: Defrag memory filled with discardable pages\n"));
+	TestStart();
+	if (gPagedRom)
+		{
+		AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+		FreeMovable(gChunkArray1, gChunkArraySize1);
+		GetAllPageInfo();
+		TInt discardablePages;
+		UpdateRamInfo();
+		r = AllocDiscardable(discardablePages);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		TESTDEBUG(test.Printf(_L("Number of discardable pages = 0x%x\n"), discardablePages >> gPageShift));
+		GetOriginalPageCount();
+		TBool genSucceed = CanGenSucceed();
+		r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+		TESTDEBUG(test.Printf(_L("After calling defrag r = %d\n"), r));
+		if (r != KErrNone)
+			{
+			test.Printf(_L("Fail: r = %d, expected = %d\n"),r,KErrNone);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else if (genSucceed && CheckZonesSwitchedOff() == EFalse)
+			{
+			test.Printf(_L("No Zones Switched off and should have been\n"));
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+		ResetDPCache();
+		}
+	else
+		{
+		test.Printf(_L("Not a paged ROM - Skipping test step\n"));
+		}
+	TestEnd();
+	test.Next(_L("Test6: Defrag memory filled with fixed pages"));
+	TestStart();
+	TESTDEBUG(test.Printf(_L("Filling memory with fixed pages, r = %d\n")));
+	r = Ldd.AllocateFixed(FILL_ALL_FIXED);
+	GetOriginalPageCount();
+	TBool genSucceed = CanGenSucceed();
+	r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+	TESTDEBUG(test.Printf(_L("After calling defrag r = %d\n"), r));
+	// The zones should be full of fixed pages so the general should do nothing.
+	if (r != KErrNone ||
+		genSucceed ||
+		CheckZonesSwitchedOff())
+		{
+		test.Printf(_L("Fail: r = %d, expected = %d, or zone have been emptied\n"), r, KErrNone);
+		CLEANUP(Ldd.FreeAllFixedPages());
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+	Ldd.FreeAllFixedPages();
+	TestEnd();
+	test.Next(_L("Test7: Defrag memory filled with discardable pages when the min cache size is reached\n"));
+	TestStart();
+	if (gPagedRom)
+		{
+		AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+		FreeMovable(gChunkArray1, gChunkArraySize1);
+		GetAllPageInfo();
+		TInt discardablePages;
+		UpdateRamInfo();
+		r = AllocDiscardable(discardablePages);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		TESTDEBUG(test.Printf(_L("Number of discardable pages = 0x%x\n"), discardablePages >> gPageShift));
+		TUint minCacheSize = 0;
+		TUint maxCacheSize = 0;
+		TUint currentCacheSize = 0;
+		DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
+		TUint setMin = maxCacheSize;
+		TUint64 setMax = maxCacheSize;
+		TInt r = DPTest::SetCacheSize(setMin, setMax);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			CLEANUP(ResetDPCache());
+			TEST_FAIL;
+			}
+		TESTDEBUG(test.Printf(_L("After SetCacheSize: minCacheSize = 0x%x, maxCacheSize = 0x%x\n"),
+															setMin >> gPageShift, setMax >> gPageShift));
+		GetOriginalPageCount();
+		genSucceed = CanGenSucceed();
+		r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+		TESTDEBUG(test.Printf(_L("After calling defrag r = %d\n"), r));
+		if (r != KErrNone)
+			{
+			test.Printf(_L("Fail: r = %d, expected = %d\n"),r,KErrNone);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			CLEANUP(ResetDPCache());
+			TEST_FAIL;
+			}
+		else if (genSucceed && CheckZonesSwitchedOff() == EFalse)
+			{
+			test.Printf(_L("No Zones Switched off and should have been\n"));
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			CLEANUP(ResetDPCache());
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+		ResetDPCache();
+		}
+	else
+		{
+		test.Printf(_L("Not a paged ROM - Skipping test step\n"));
+		}
+	TestEnd();
+	test.Next(_L("Test8: Defrag fragmented memory for various smaller chunk sizes"));
+	TInt chunkSize = 0x80000;
+	while (chunkSize >= 0x4000)
+		{
+		test.Printf(_L("chunkSize = %dKB\n"), chunkSize/1024);
+		TestStart();
+		r = AllocMovable(gChunkArray1, gChunkArraySize1, KFillAllMovable, chunkSize, EFalse);
+		r = FreeMovable(gChunkArray1, gChunkArraySize1);
+		GetOriginalPageCount();
+		TBool genSucceed = CanGenSucceed();
+		r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+		TESTDEBUG(test.Printf(_L("After calling defrag r = %d\n"), r));
+		if (r != KErrNone)
+			{
+			test.Printf(_L("Fail: r = %d, expected = %d\n"),r,KErrNone);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else if (genSucceed && CheckZonesSwitchedOff() == EFalse)
+			{
+			test.Printf(_L("No Zones Switched off and should have been\n"));
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+		TestEnd();
+		chunkSize = chunkSize>>1;
+		}
+	test.Next(_L("Test9: Defrag fragmented memory "));
+	TestStart();
+	r = AllocMovable(gChunkArray1, gChunkArraySize1, KFillAllMovable);
+	r = FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetOriginalPageCount();
+	genSucceed = CanGenSucceed();
+	r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+	TESTDEBUG(test.Printf(_L("After calling defrag r = %d\n"), r));
+	if (r != KErrNone)
+		{
+		test.Printf(_L("Fail: r = %d, expected = %d\n"),r,KErrNone);
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		TEST_FAIL;
+		}
+	else if (genSucceed && CheckZonesSwitchedOff() == EFalse)
+		{
+		test.Printf(_L("No Zones Switched off and should have been\n"));
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.End();
+	return KErrNone;
+	}
+//
+// TestGetRamZonePageCount
+//
+//---------------------------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID				KBASE-t_ramdefrag-0529
+//! @SYMTestType				CIT
+//! @SYMTestCaseDesc			Verifying the implementation of the function GetRamZonePageCount()
+//! @SYMPREQ					PREQ308
+//! @SYMTestPriority			High
+//! @SYMTestActions
+//! 	1.	Fragment the memory. Following this, call GetRamZonePageCount() on every zone and verify
+//!			the values with the test HAL functions.
+//! 	2.	Fragment the memory. Following this, call function with an valid aID
+//!
+//! @SYMTestExpectedResults
+//! 	1.	KErrNone
+//! 	2.	KErrArgument
+//---------------------------------------------------------------------------------------------------------------------
+TInt TestGetRamZonePageCount()
+	{
+	test.Start(_L("Test1: Call GetRamZonePageCount() on every zone one after the other"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	for (TUint index = 0; index < gZoneCount; index++)
+		{
+		GetAllPageInfo();
+		TUint zoneID = gZoneConfigArray[index].iZoneId;
+		STestUserSidePageCount pageData;
+		TInt r = Ldd.PageCount(zoneID, &pageData);
+		TESTDEBUG(test.Printf(_L("Page count function r = %d\n"), r));
+		if (r != KErrNone)
+			{
+			test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrNone);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		if (pageData.iFreePages != gZoneUtilArray[index].iFreePages ||
+			pageData.iFixedPages != gZoneUtilArray[index].iAllocFixed ||
+			pageData.iMovablePages != gZoneUtilArray[index].iAllocMovable ||
+			pageData.iDiscardablePages != gZoneUtilArray[index].iAllocDiscardable)
+			{
+			test.Printf(_L("RAM zone page count does not match test HAL page count, Zone %d\n"), zoneID);
+			test.Printf(_L("PgCnt: free = 0x%x, fixed = 0x%x, movable= 0x%x, discard = 0x%x\n"),
+									pageData.iFreePages, pageData.iFixedPages, pageData.iMovablePages, pageData.iDiscardablePages);
+			test.Printf(_L("HalFunc: free = 0x%x, fixed = 0x%x, movable= 0x%x, discard = 0x%x\n"),
+									gZoneUtilArray[index].iFreePages, gZoneUtilArray[index].iAllocFixed,
+									gZoneUtilArray[index].iAllocMovable, gZoneUtilArray[index].iAllocDiscardable);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Zone %d Passed...\n"), zoneID);
+			}
+		TESTDEBUG(test.Printf(_L("iFreePages = 0x%x, iFixedPages = 0x%x, iMovablePages = 0x%x, iDiscardablePages = 0x%x\n"),
+						pageData.iFreePages, pageData.iFixedPages, pageData.iMovablePages, pageData.iDiscardablePages));
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test2: Call GetRamZonePageCount() with an invalid aID "));
+	TestStart();
+	TUint zoneID = KInvalidZoneID;
+	STestUserSidePageCount pageData;
+	TInt r = Ldd.PageCount(zoneID, &pageData);
+	TESTDEBUG(test.Printf(_L("Page count function r = %d\n"), r));
+	if (r != KErrArgument)
+		{
+		test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrArgument);
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+	TestEnd();
+	test.End();
+	return 0;
+	}
+const TUint KIndex2Alloc = 10;
+const TUint KTestMaxPages = 6;
+//
+// DefragMaxPagesSetup
+//
+// Arranges the memory layout in preparation for TestDefragRamMaxPages()
+//
+// WARNING THIS WILL BE UNRELIABLE IF aMaxPages > KIndex2Alloc
+//
+TInt DefragMaxPagesSetup(TInt aPageType, TUint aMaxPages, TUint& aIndex, TUint& aIndex2)
+	{
+	TInt r = KErrNoMemory;
+	// Get the preference order and determine the 2 most preferable zones
+	// that are currently not in use.
+	GetPrefOrder();
+	TUint freeInUsePages = 0;
+	TBool zonesFound = EFalse;
+	for (TUint i = 1; i < gZoneCount; i++)
+		{
+		aIndex = gPrefArray[i];
+		aIndex2 = gPrefArray[i-1];
+		TUint indexFree = gZoneUtilArray[aIndex].iFreePages;
+		TUint index2Free = gZoneUtilArray[aIndex2].iFreePages;
+		if (indexFree == gZoneUtilArray[aIndex].iPhysPages &&
+			index2Free == gZoneUtilArray[aIndex2].iPhysPages &&
+			indexFree >= aMaxPages && index2Free >= KIndex2Alloc &&
+			freeInUsePages >= KIndex2Alloc + aMaxPages)
+			{
+			zonesFound = ETrue;
+			break;
+			}
+		freeInUsePages += index2Free;
+		}
+	// Could suitable RAM zones be found.
+	if (!zonesFound)
+		{
+		test.Printf(_L("Insufficient memory - Skipping test...\n"));
+		return KErrNoMemory;
+		}
+	if (aPageType == BEST_MOVABLE)
+		{
+		// Allocate KIndex2Alloc movable pages to aIndex2
+		r = ZoneAllocMovable(gChunkArray1, gChunkArraySize1, aIndex2, KIndex2Alloc);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("Insufficient memory - Skipping test...\n"));
+			r = KErrNoMemory;
+			goto error;
+			}
+		// Now allow movable pages to be allocated into the least preferable RAM zone under test only.
+		GetAllPageInfo();
+		if (aMaxPages >= gZoneUtilArray[aIndex].iFreePages)
+			{
+			test.Printf(_L("Insufficient memory available - Skipping test...\n"));
+			r = KErrNoMemory;
+			goto error;
+			}
+		// Allocate aMaxPages movable pages to aIndex
+		r = ZoneAllocMovable(gChunkArray2, gChunkArraySize2, aIndex, aMaxPages);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("Insufficient memory - Skipping test...\n"));
+			r = KErrNoMemory;
+			goto error;
+			}
+		// Determine how many free pages there are in the RAM zones more preferable
+		// than the RAM zones under test.
+		GetPrefOrder();
+		freeInUsePages = 0;
+		for (TUint i = 0; i < gZoneCount; i++)
+			{
+			TUint tmpIndex = gPrefArray[i];
+			if (tmpIndex == aIndex2)
+				break;
+			freeInUsePages += gZoneUtilArray[tmpIndex].iFreePages;
+			}
+		// Verify that the RAM layout is still suitable for the test.
+		if (gZoneUtilArray[aIndex].iAllocMovable != aMaxPages ||
+			gZoneUtilArray[aIndex2].iAllocMovable != KIndex2Alloc ||
+			gZoneUtilArray[aIndex].iAllocDiscardable || gZoneUtilArray[aIndex].iAllocFixed ||
+			gZoneUtilArray[aIndex2].iAllocDiscardable || gZoneUtilArray[aIndex2].iAllocFixed ||
+			freeInUsePages < KIndex2Alloc + aMaxPages)
+			{
+			test.Printf(_L("Insufficient memory - Skipping test...\n"));
+			r = KErrNoMemory;
+			goto error;
+			}
+		// now reset all the flags
+		ResetRamZoneFlags();
+		// Perform a general defrag
+		r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, KTestMaxPages);
+		goto exit;
+		}
+	if (aPageType == BEST_DISCARDABLE)
+		{
+		TUint minCacheSize = 0;
+		TUint maxCacheSize = 0;
+		TUint currentCacheSize = 0;
+		DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
+		test.Printf(_L("Original CacheSize: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"),
+									minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift);
+		// Allocate a number of discardable pages to the 2nd least preferable zone under test
+		TInt disPages;
+		r = ZoneAllocDiscard(aIndex2, KIndex2Alloc, disPages);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("ZoneAllocDiscard() r = %d KIndex2Alloc = 0x%x disPages = 0x%x aIndex2 = %d - Skipping test...\n"),
+							r, KIndex2Alloc, disPages, aIndex2);
+			GetAllPageInfo();
+			PrintPageInfo();
+			r = KErrNoMemory;
+			goto error;
+			}
+		TUint discFillBytes = KIndex2Alloc << gPageShift;
+		r = DPTest::SetCacheSize(currentCacheSize + discFillBytes, currentCacheSize + discFillBytes);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("SetCacheSize r = 0x%x currentCacheSize + discFillBytes = 0x%x - Skipping test...\n"),
+							r, currentCacheSize + discFillBytes);
+			GetAllPageInfo();
+			PrintPageInfo();
+			r = KErrNoMemory;
+			goto error;
+			}
+		// Allocate a discardable pages equal to aMaxPages to the least preferable zone under test
+		GetAllPageInfo();
+		if(aMaxPages >= gTotalPageCount.iFreePages)
+			{
+			test.Printf(_L("Insufficient memory available - Skipping test...\n"));
+			r = KErrNoMemory;
+			goto error;
+			}
+		TUint allocPages = aMaxPages + KIndex2Alloc;
+		r = ZoneAllocDiscard(aIndex, aMaxPages, disPages);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("ZoneAllocDiscard() r = %d aMaxPages = 0x%x disPages = 0x%x aIndex = %d - Skipping test...\n"),
+							r, aMaxPages, disPages, aIndex);
+			GetAllPageInfo();
+			PrintPageInfo();
+			r = KErrNoMemory;
+			goto error;
+			}
+		discFillBytes = allocPages << gPageShift;
+		r = DPTest::SetCacheSize(currentCacheSize + discFillBytes, currentCacheSize + discFillBytes);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("SetCacheSize r = %d currentCacheSize + discFillBytes = 0x%x - Skipping test...\n"),
+							r, currentCacheSize + discFillBytes);
+			GetAllPageInfo();
+			PrintPageInfo();
+			r = KErrNoMemory;
+			goto error;
+			}
+		// Determine how many free pages there are in the RAM zones more preferable
+		// than the RAM zones under test.
+		GetPrefOrder();
+		freeInUsePages = 0;
+		for (TUint i = 0; i < gZoneCount; i++)
+			{
+			TUint tmpIndex = gPrefArray[i];
+			if (tmpIndex == aIndex2)
+				break;
+			freeInUsePages += gZoneUtilArray[tmpIndex].iFreePages;
+			}
+		// Verify that the RAM layout is still suitable for the test.
+		if (r != KErrNone || gZoneUtilArray[aIndex].iAllocDiscardable != aMaxPages ||
+			gZoneUtilArray[aIndex2].iAllocDiscardable != KIndex2Alloc ||
+			gZoneUtilArray[aIndex].iAllocMovable || gZoneUtilArray[aIndex].iAllocFixed ||
+			gZoneUtilArray[aIndex2].iAllocMovable || gZoneUtilArray[aIndex2].iAllocFixed ||
+			freeInUsePages < KIndex2Alloc + aMaxPages)
+			{
+			test.Printf(_L("Insufficient memory - Skipping test...\n"));
+			r = KErrNoMemory;
+			goto error;
+			}
+		// now reset all the flags
+		ResetRamZoneFlags();
+		// Perform a general defrag with maxPages = KTestMaxPages
+		r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, KTestMaxPages);
+		goto exit;
+		}
+error:
+	// Reset all the flags
+	ResetRamZoneFlags();
+exit:
+	return r;
+	}
+//
+// TestDefragRamMaxPages
+//
+//---------------------------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID				KBASE-t_ramdefrag-0530
+//! @SYMTestType				CIT
+//! @SYMTestCaseDesc			Verifying the implementation of the function TRamDefragRequest::DefragRam()
+//! @SYMPREQ					PREQ308
+//! @SYMTestPriority			High
+//! @SYMTestActions
+//! 	1.	Call function with invalid aMaxPages
+//! 	2.	Call DefragRam when aMaxPages < number of movable pages in least preferable zone
+//! 	3.	Call DefragRam when aMaxPages > number of movable pages in least preferable zone
+//! 	4.	Call DefragRam when aMaxPages = number of movable pages in least preferable zone
+//! 	5.	Call DefragRam when aMaxPages < number of discardable pages in least preferable zone
+//! 	6.	Call DefragRam when aMaxPages > number of discardable pages in least preferable zone
+//! 	7.	Call DefragRam when aMaxPages = number of discardable pages in least preferable zone
+//!
+//! @SYMTestExpectedResults
+//! 	1.	KErrArgument
+//! 	2.	Least preferable zone and 2nd least preferable zone have not been emptied
+//! 	3.	Least preferable zone has been emptied and 2nd least preferable zone has not been emptied
+//! 	4.	Least preferable zone has been emptied and 2nd least preferable zone not not been emptied
+//! 	5.	Least preferable zone and 2nd least preferable zone have not been emptied
+//! 	6.	Least preferable zone has been emptied and 2nd least preferable zone has not been emptied
+//! 	7.	Least preferable zone has been emptied and 2nd least preferable zone not not been emptied
+//---------------------------------------------------------------------------------------------------------------------
+TInt TestDefragRamMaxPages()
+	{
+	test.Start(_L("Test1: Call DefragRam with invalid aMaxPages "));
+	TestStart();
+	gDefragMaxPages = -1;
+	TInt r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, gDefragMaxPages);
+	TESTDEBUG(test.Printf(_L("After calling defrag r = %d\n"), r));
+	if (r != KErrArgument)
+		{
+		test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrArgument);
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+	TestEnd();
+	test.Next(_L("Test2: Call DefragRam aMaxPages < number of movable pages in least preferable zone "));
+	TestStart();
+	gChunkArray1 = new RChunk;
+	gChunkArraySize1 = 1;
+	gChunkArray2 = new RChunk;
+	gChunkArraySize2 = 1;
+	TUint index = 0;
+	TUint index2 = 0;
+	r = DefragMaxPagesSetup(BEST_MOVABLE, KTestMaxPages + 1, index, index2);
+	if (gZoneUtilArray[index].iAllocFixed > 0 || gZoneUtilArray[index2].iAllocFixed > 0)
+		{// Cannot perform test with fixed pages in least preferable zones
+		test.Printf(_L("Fixed pages in least preferable zone - Skipping...\n"));
+		}
+	else
+		{
+		if (r == KErrNone)
+			{
+			GetAllPageInfo();
+			if (gZoneUtilArray[index].iAllocMovable < KTestMaxPages + 1 ||
+				gZoneUtilArray[index2].iAllocMovable < KIndex2Alloc)
+				{
+				test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
+										index, KTestMaxPages + 1, index2, KIndex2Alloc);
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				CLEANUP(RemoveChunkAlloc(gChunkArray2, gChunkArraySize2));
+				CLEANUP(Ldd.FreeFromAllZones());
+				TEST_FAIL;
+				}
+			// Double check that if DefragRam is called with maxPages = 0, these zones are emptied
+			// if there is free space elsewhere
+			r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, gDefragMaxPages);
+			GetAllPageInfo();
+			if (gTotalPageCount.iFreePages > KIndex2Alloc + KTestMaxPages + 1 &&
+				(gZoneUtilArray[index].iAllocMovable != 0 || gZoneUtilArray[index2].iAllocMovable != 0))
+				{
+				test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
+										index, 0, index2, 0);
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				CLEANUP(RemoveChunkAlloc(gChunkArray2, gChunkArraySize2));
+				CLEANUP(Ldd.FreeFromAllZones());
+				TEST_FAIL;
+				}
+			else
+				{
+				test.Printf(_L("Passed...\n"));
+				}
+			}
+		else
+			{
+			test.Printf(_L("DefragMaxPagesSetup failed r = %d\n"), r);
+			}
+		RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+		RemoveChunkAlloc(gChunkArray2, gChunkArraySize2);
+		}
+	Ldd.FreeFromAllZones();
+	TestEnd();
+	test.Next(_L("Test3: Call DefragRam aMaxPages > number of movable pages in least preferable zone "));
+	TestStart();
+	gChunkArray1 = new RChunk;
+	gChunkArraySize1 = 1;
+	gChunkArray2 = new RChunk;
+	gChunkArraySize2 = 1;
+	r = DefragMaxPagesSetup(BEST_MOVABLE, KTestMaxPages - 1, index, index2);
+	if (gZoneUtilArray[index].iAllocFixed > 0 || gZoneUtilArray[index2].iAllocFixed > 0)
+		{// Cannot perform test with fixed pages in least preferable zones
+		test.Printf(_L("Fixed pages in least preferable zone - Skipping...\n"));
+		}
+	else
+		{
+		if (r == KErrNone)
+			{
+			GetAllPageInfo();
+			if (gZoneUtilArray[index].iAllocMovable != 0)
+				{
+				test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
+										index, 0, index2, KIndex2Alloc);
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				CLEANUP(RemoveChunkAlloc(gChunkArray2, gChunkArraySize2));
+				CLEANUP(Ldd.FreeFromAllZones());
+				TEST_FAIL;
+				}
+			// Double check that if DefragRam is called with maxPages = 0, these zones are emptied
+			// if there is free space elsewhere
+			r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, gDefragMaxPages);
+			GetAllPageInfo();
+			if (gTotalPageCount.iFreePages > KIndex2Alloc + KTestMaxPages - 1 &&
+				(gZoneUtilArray[index].iAllocMovable != 0 || gZoneUtilArray[index2].iAllocMovable != 0))
+				{
+				test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
+										index, 0, index2, 0);
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				CLEANUP(RemoveChunkAlloc(gChunkArray2, gChunkArraySize2));
+				CLEANUP(Ldd.FreeFromAllZones());
+				TEST_FAIL;
+				}
+			else
+				{
+				test.Printf(_L("Passed...\n"));
+				}
+			}
+		else
+			{
+			test.Printf(_L("DefragMaxPagesSetup failed r = %d\n"), r);
+			}
+		RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+		RemoveChunkAlloc(gChunkArray2, gChunkArraySize2);
+		}
+	Ldd.FreeFromAllZones();
+	TestEnd();
+	test.Next(_L("Test4: Call DefragRam aMaxPages = number of movable pages in least preferable zone "));
+	TestStart();
+	gChunkArray1 = new RChunk;
+	gChunkArraySize1 = 1;
+	gChunkArray2 = new RChunk;
+	gChunkArraySize2 = 1;
+	r = DefragMaxPagesSetup(BEST_MOVABLE, KTestMaxPages, index, index2);
+	if (gZoneUtilArray[index].iAllocFixed > 0 || gZoneUtilArray[index2].iAllocFixed > 0)
+		{// Cannot perform test with fixed pages in least preferable zones
+		test.Printf(_L("Fixed pages in least preferable zone - Skipping...\n"));
+		}
+	else
+		{
+		if (r == KErrNone)
+			{
+			GetAllPageInfo();
+			if (gZoneUtilArray[index].iAllocMovable != 0)
+				{
+				test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
+										index, 0, index2, KIndex2Alloc);
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				CLEANUP(RemoveChunkAlloc(gChunkArray2, gChunkArraySize2));
+				CLEANUP(Ldd.FreeFromAllZones());
+				TEST_FAIL;
+				}
+			// Double check that if DefragRam is called with maxPages = 0, these zones are emptied
+			// if there is free space elsewhere
+			r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, gDefragMaxPages);
+			GetAllPageInfo();
+			if (gTotalPageCount.iFreePages > KIndex2Alloc + KTestMaxPages &&
+				(gZoneUtilArray[index].iAllocMovable != 0 || gZoneUtilArray[index2].iAllocMovable != 0))
+				{
+				test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
+										index, 0, index2, 0);
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				CLEANUP(RemoveChunkAlloc(gChunkArray2, gChunkArraySize2));
+				CLEANUP(Ldd.FreeFromAllZones());
+				TEST_FAIL;
+				}
+			else
+				{
+				test.Printf(_L("Passed...\n"));
+				}
+			}
+		else
+			{
+			test.Printf(_L("DefragMaxPagesSetup failed r = %d\n"), r);
+			}
+		RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+		RemoveChunkAlloc(gChunkArray2, gChunkArraySize2);
+		}
+	Ldd.FreeFromAllZones();
+	TestEnd();
+	test.Next(_L("Test5: Call DefragRam aMaxPages < number of discardable pages in least preferable zone "));
+	TestStart();
+	if (gPagedRom)
+		{
+		r = DefragMaxPagesSetup(BEST_DISCARDABLE, KTestMaxPages + 1, index, index2);
+		if (gZoneUtilArray[index].iAllocFixed > 0 || gZoneUtilArray[index2].iAllocFixed > 0)
+			{// Cannot perform test with fixed pages in least preferable zones
+			test.Printf(_L("Fixed pages in least preferable zone - Skipping...\n"));
+			}
+		else
+			{
+			if (r == KErrNone)
+				{
+				GetAllPageInfo();
+				if (gZoneUtilArray[index].iAllocDiscardable < KTestMaxPages + 1 ||
+					gZoneUtilArray[index2].iAllocDiscardable < KIndex2Alloc)
+					{
+					test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
+											index, KTestMaxPages + 1, index2, KIndex2Alloc);
+					CLEANUP(ResetDPCache());
+					CLEANUP(Ldd.FreeFromAllZones());
+					TEST_FAIL;
+					}
+				// Double check that if DefragRam is called with maxPages = 0, these zones are emptied
+				r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, gDefragMaxPages);
+				GetAllPageInfo();
+				if (gZoneUtilArray[index].iAllocDiscardable != 0 ||
+					gZoneUtilArray[index2].iAllocDiscardable != 0)
+					{
+					test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
+											index, 0, index2, 0);
+					CLEANUP(ResetDPCache());
+					CLEANUP(Ldd.FreeFromAllZones());
+					TEST_FAIL;
+					}
+				else
+					{
+					test.Printf(_L("Passed...\n"));
+					}
+				}
+			else
+				{
+				test.Printf(_L("DefragMaxPagesSetup failed r = %d\n"), r);
+				}
+			ResetDPCache();
+			}
+		Ldd.FreeFromAllZones();
+		}
+	else
+		{
+		test.Printf(_L("Not a Paged Rom - Skipping...\n"));
+		}
+	TestEnd();
+	test.Next(_L("Test6: Call DefragRam aMaxPages > number of discardable pages in least preferable zone "));
+	TestStart();
+	if (gPagedRom)
+		{
+		r = DefragMaxPagesSetup(BEST_DISCARDABLE, KTestMaxPages - 1, index, index2);
+		if (gZoneUtilArray[index].iAllocFixed > 0 || gZoneUtilArray[index2].iAllocFixed > 0)
+			{// Cannot perform test with fixed pages in least preferable zones
+			test.Printf(_L("Fixed pages in least preferable zone - Skipping...\n"));
+			}
+		else
+			{
+			if (r == KErrNone)
+				{
+				GetAllPageInfo();
+				if (gZoneUtilArray[index].iAllocDiscardable != 0||
+					gZoneUtilArray[index2].iAllocDiscardable != KIndex2Alloc)
+					{
+					test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
+											index, 0, index2, KIndex2Alloc);
+					CLEANUP(ResetDPCache());
+					CLEANUP(Ldd.FreeFromAllZones());
+					TEST_FAIL;
+					}
+				// Double check that if DefragRam is called with maxPages = 0, these zones are emptied
+				r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, gDefragMaxPages);
+				GetAllPageInfo();
+				if (gZoneUtilArray[index].iAllocDiscardable != 0||
+					gZoneUtilArray[index2].iAllocDiscardable != 0)
+					{
+					test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
+											index, 0, index2, 0);
+					CLEANUP(ResetDPCache());
+					CLEANUP(Ldd.FreeFromAllZones());
+					TEST_FAIL;
+					}
+				else
+					{
+					test.Printf(_L("Passed...\n"));
+					}
+				}
+			else
+				{
+				test.Printf(_L("DefragMaxPagesSetup failed r = %d\n"), r);
+				}
+			ResetDPCache();
+			}
+		Ldd.FreeFromAllZones();
+		}
+	else
+		{
+		test.Printf(_L("Not a Paged Rom - Skipping...\n"));
+		}
+	TestEnd();
+	test.Next(_L("Test4: Call DefragRam aMaxPages = number of discardable pages in least preferable zone "));
+	TestStart();
+	if(gPagedRom)
+		{
+		r = DefragMaxPagesSetup(BEST_DISCARDABLE, KTestMaxPages, index, index2);
+		if (gZoneUtilArray[index].iAllocFixed > 0 || gZoneUtilArray[index2].iAllocFixed > 0)
+			{// Cannot perform test with fixed pages in least preferable zones
+			test.Printf(_L("Fixed pages in least preferable zone - Skipping...\n"));
+			}
+		else
+			{
+			if (r == KErrNone)
+				{
+				GetAllPageInfo();
+				if (gZoneUtilArray[index].iAllocDiscardable != 0||
+					gZoneUtilArray[index2].iAllocDiscardable != KIndex2Alloc)
+					{
+					test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
+											index, 0, index2, KIndex2Alloc);
+					CLEANUP(ResetDPCache());
+					CLEANUP(Ldd.FreeFromAllZones());
+					TEST_FAIL;
+					}
+				// Double check that if DefragRam is called with maxPages = 0, these zones are emptied
+				r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, gDefragMaxPages);
+				GetAllPageInfo();
+				if (gZoneUtilArray[index].iAllocDiscardable != 0||
+					gZoneUtilArray[index2].iAllocDiscardable != 0)
+					{
+					test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
+											index, 0, index2, 0);
+					CLEANUP(ResetDPCache());
+					CLEANUP(Ldd.FreeFromAllZones());
+					TEST_FAIL;
+					}
+				else
+					{
+					test.Printf(_L("Passed...\n"));
+					}
+				}
+			else
+				{
+				test.Printf(_L("DefragMaxPagesSetup failed r = %d\n"), r);
+				}
+			ResetDPCache();
+			}
+		Ldd.FreeFromAllZones();
+		}
+	else
+		{
+		test.Printf(_L("Not a Paged Rom - Skipping...\n"));
+		}
+	TestEnd();
+	test.End();
+	return KErrNone;
+	}
+//
+// TestEmptyRamZone
+//
+//---------------------------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID				KBASE-t_ramdefrag-0531
+//! @SYMTestType				CIT
+//! @SYMTestCaseDesc			Verifying the implementation of the function TRamDefragRequest::EmptyRamZone()
+//! @SYMPREQ					PREQ308
+//! @SYMTestPriority			High
+//! @SYMTestActions
+//! 	1.	Fragment the memory. Call function with a valid aID,
+//! 		i.e. a zone which lies within the range of zones.
+//! 	2.	Fragment the memory. Call function with an invalid aID
+//! 		i.e. a zone which does not exist within the range of zones.
+//! 	3.	Fragment the memory. Following this, call a zone specific defrag on a particular zone.
+//! 		Call the zone specific defrag again on the same zone whilst the other defrag is still
+//!			running on that zone.
+//! 	4.	Fragment the memory. Following this, call the TRamDefragRequest::DefragRam() to perform general defrag.
+//! 		Following this call zone specific defrag whilst the general defrag is still running.
+//! 	5.	Fragment the memory. Following this, call a zone specific defrag on a particular zone.
+//! 		Whilst the zone defrag is running, call a general defrag
+//! 	6:  Fragment the memory. Following this, call the function on specifc zone and
+//! 		at the same time allocate pages to the zone
+//! 	7.	Fragment the memory. Call EmptyRamZone() on every zone one after the other.
+//! 	8.	Fragment the memory. Allocate a couple of fixed pages to a zone that contains movable pages.
+//! 		Following this, Call EmptyRamZone() on that zone.
+//!
+//! @SYMTestExpectedResults
+//! 	1.	KErrNone
+//! 	2.	KErrArgument
+//! 	3.	KErrNone and the zone has been emptied
+//! 	4.	Zone has not been emptied, as the general defrag has already placed pages in the zone
+//! 	5.	Zone has been emptied
+//! 	6.	KErrNone and pages have been allocated in the zone
+//! 	7.	One of the following scenarios should occur:
+//!			a.	If the cache has not reached its minimum size, then all the movable pages should
+//!				be moved from the zone if there are enough free pages in the other zones.
+//!				However, when demand paging is off, all movable pages should be moved from the zone, again if there
+//!				are enough free pages in the other zones.
+//!			b.	If the current size of the cache minus the number of discardable pages in the zone being emptied is
+//!				not less than the minimum cache size, then all the discardable pages should be discarded of.
+//!				However, when demand paging is off, all discardable pages should be removed from
+//!				the zone.
+//! 	8.	KErrNoMemory, however all movable and discardable pages have been moved from the zone
+//---------------------------------------------------------------------------------------------------------------------
+TInt TestEmptyRamZone()
+	{
+	TInt r = KErrNone;
+	TInt r2 = KErrNone;
+	test.Start(_L("Test1: Call EmptyRamZone with valid aID "));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	TUint index = gZoneCount - 1;
+	while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		-- index;
+		}
+	TUint defragZoneID = gZoneConfigArray[index].iZoneId;
+	test.Printf(_L("Zone ID = %d\n"), defragZoneID);
+	if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, defragZoneID);
+		GetAllPageInfo();
+		TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+		if (freeInOthers && (r != KErrNone || !CheckZoneIsOff(index)))
+			{
+			test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrNone);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test2: Call EmptyRamZone with invalid aID "));
+	TestStart();
+	gChunkArray1 = new RChunk;
+	gChunkArraySize1 = 1;
+	defragZoneID = KInvalidZoneID;
+	r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, defragZoneID);
+	if (r != KErrArgument)
+		{
+		test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrArgument);
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+	TestEnd();
+	test.Next(_L("Test3: Call EmptyRamZone twice at the same time "));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	index = gZoneCount - 1;
+	while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		-- index;
+		}
+	defragZoneID = gZoneConfigArray[index].iZoneId;
+	if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		r = gTestThread.Create(gTestThreadName,MultiEmptyZoneThreadFunc,KDefaultStackSize,0x1000,0x1000,(TAny *)defragZoneID);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		gTestThread.Logon(status);
+		gTestThread.Resume();
+		User::After(10);
+		r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, defragZoneID);
+		User::WaitForRequest(status);
+		r2 = status.Int();
+		GetAllPageInfo();
+		TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+		if (r != r2 ||
+			(freeInOthers && (r != KErrNone || r2 != KErrNone || !CheckZoneIsOff(index))))
+			{
+			test.Printf(_L("Fail: r = %d, r2 = %d, expected = %d, or zone %d has not been emptied\n"),
+									r, r2, KErrNone, defragZoneID);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		gTestThread.Close();
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test4: Call general defrag and zone defrag at the same time "));
+	TestStart();
+	TInt waitTime = 10000;
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	index = gZoneCount - 1;
+	while (index > 0 && gZoneUtilArray[index].iAllocFixed > 0)
+		{
+		index--;
+		}
+	defragZoneID = gZoneConfigArray[index].iZoneId;
+	if (index == 0 && gZoneUtilArray[index].iAllocFixed > 0)
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		r = gTestThread.Create(gTestThreadName,MultiGenDefragThreadFunc,KDefaultStackSize,0x1000,0x1000,NULL);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		gTestThread.Logon(status);
+		gTestThread.Resume();
+		User::After(waitTime);
+		TESTDEBUG(test.Printf(_L("Zone defrag running on main thread\n")));
+		r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, defragZoneID);
+		User::WaitForRequest(status);
+		r2 = status.Int();
+		GetAllPageInfo();
+		TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+		if (r2 != KErrNone ||
+			(freeInOthers && (r != KErrNone || !CheckZoneIsOff(index))))
+			{
+			test.Printf(_L("Fail: r = %d, r2 = %d, expected = %d, or zone %d is on unexpectedly\n"),
+							r, r2, KErrNone, defragZoneID);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		gTestThread.Close();
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test5: Call zone defrag and general defrag at the same time "));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	index = gZoneCount - 1;
+	while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		-- index;
+		}
+	defragZoneID = gZoneConfigArray[index].iZoneId;
+	if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		r = gTestThread.Create(gTestThreadName,MultiEmptyZoneThreadFunc,KDefaultStackSize,0x1000,0x1000,(TAny*)defragZoneID);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		gTestThread.Logon(status);
+		gTestThread.Resume();
+		User::After(0);
+		TESTDEBUG(test.Printf(_L("Zone defrag running on main thread\n")));
+		r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, gDefragMaxPages);
+		User::WaitForRequest(status);
+		r2 = status.Int();
+		GetAllPageInfo();
+		TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+		if (r != KErrNone ||
+			(freeInOthers && (r2 != KErrNone || !CheckZoneIsOff(index))))
+			{
+			test.Printf(_L("Fail: r = %d, r2 = %d, expected = %d, or zone 0x%x is on unexpectedly\n"),
+							r, r2, KErrNone, defragZoneID);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		gTestThread.Close();
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test6: Call function TRamDefragRequest::EmptyRamZone on specifc zone and at the same time allocate pages to the zone"));
+	TestStart();
+	TInt pagesAlloc = 1; // Try and allocate just one page whilst trying to empty the zone.
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	index = gZoneCount - 1;
+	while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		-- index;
+		}
+	defragZoneID = gZoneConfigArray[index].iZoneId;
+	if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		TInt numPassed = 0;
+		for (waitTime = 1000; waitTime > 0; waitTime-=10)
+			{
+			r = gTestThread.Create(gTestThreadName,MultiEmptyZoneThreadFunc,KDefaultStackSize,0x1000,0x1000,(TAny*)defragZoneID);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				TEST_FAIL;
+				}
+			gTestThread.Logon(status);
+			gTestThread.Resume();
+			User::After(waitTime);
+			r = Ldd.ZoneAllocDiscontiguous(defragZoneID, pagesAlloc);
+			User::WaitForRequest(status);
+			r2 = status.Int();
+			if (r2 != KErrNone)
+				{
+				test.Printf(_L("Empty was unsuccsessful: r2 = %d, expected = %d\n"), r2, KErrNone);
+				}
+			else if (r != KErrNone)
+				{
+				test.Printf(_L("Fail: r = %d, expected = %d, r2 = %d, expected = %d, zone = 0x%x\n"),
+										r, KErrNone, r2, KErrNone, defragZoneID);
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				CLEANUP(Ldd.FreeAllFixedPages());
+				TEST_FAIL;
+				}
+			else
+				{
+				numPassed ++;
+				}
+			Ldd.FreeAllFixedPages();
+			gTestThread.Close();
+			}
+		if (numPassed > 0)
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test7: Call function TRamDefragRequest::EmptyRamZone on every zone one after the other"));
+	TestStart();
+	Ldd.ResetDriver();
+	for (index = 0; index < gZoneCount; index ++)
+		{
+		// Variables for DP ROM cache sizes
+		TUint minCacheSize = 0;
+		TUint maxCacheSize = 0;
+		TUint currentCacheSize = 0;
+		if (gPagedRom)
+			{
+			DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
+			TESTDEBUG(test.Printf(_L("Original CacheSize: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"),
+										minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift));
+			// Calculate the maximum size available for the DP cache.
+			TUint minZoneFree = KMaxTUint;
+			TUint maxDisFillBytes = 0;
+			GetAllPageInfo();
+			for (TUint i = 0; i < gZoneCount; i++)
+				{
+				maxDisFillBytes += gZoneUtilArray[i].iFreePages;
+				maxDisFillBytes += gZoneUtilArray[i].iAllocDiscardable;
+				if (minZoneFree > gZoneUtilArray[i].iFreePages)
+					minZoneFree = gZoneUtilArray[i].iFreePages;
+				}
+			test.Printf(_L("Free pages 0x%x maxDisFillBytes 0x%x\n"), gTotalPageCount.iFreePages, maxDisFillBytes);
+			maxDisFillBytes <<= gPageShift;
+			r = DPTest::SetCacheSize(maxDisFillBytes, maxDisFillBytes);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
+			TESTDEBUG(test.Printf(_L("CacheSize2: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"),
+										minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift));
+			if (currentCacheSize != maxDisFillBytes)
+				{
+				test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			GetAllPageInfo();
+			test.Printf(_L("Free pages after alloc discardable1 = 0x%x\n"), gTotalPageCount.iFreePages);
+			r = DPTest::SetCacheSize(minZoneFree << gPageShift, maxDisFillBytes);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			// Check all zones have no free pages.
+			GetAllPageInfo();
+			for (TUint i = 0; i < gZoneCount; i++)
+				{
+				if (gZoneUtilArray[i].iFreePages != 0)
+					{
+					test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+					CLEANUP(ResetDPCache());
+					TEST_FAIL;
+					}
+				}
+			}
+		else
+			{
+			// Fragment the RAM with some movable pages
+			AllocMovable(gChunkArray1, gChunkArraySize1, KFillAllMovable);
+			FreeMovable(gChunkArray1, gChunkArraySize1);
+			}
+		TUint zoneID = gZoneConfigArray[index].iZoneId;
+		GetAllPageInfo();
+		TUint origUnknownInZone = gZoneUtilArray[index].iAllocUnknown;
+		TUint origMovInZone = gZoneUtilArray[index].iAllocMovable;
+		TUint origFreeInZone = gZoneUtilArray[index].iFreePages;
+		test.Printf(_L("Zone ID 0x%x - fixedPages = 0x%x, unknownPages = 0x%x, discardablePages = 0x%x movable = 0x%x free = 0x%x\n"),
+						zoneID, gZoneUtilArray[index].iAllocFixed, origUnknownInZone, gZoneUtilArray[index].iAllocDiscardable,
+						origMovInZone, origFreeInZone);
+		r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, zoneID);
+		GetAllPageInfo();
+		TUint unknownPages = gZoneUtilArray[index].iAllocUnknown;
+		TUint discPages = gZoneUtilArray[index].iAllocDiscardable;
+		TUint movablePages = gZoneUtilArray[index].iAllocMovable;
+		TUint freeInOtherZones = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+		if(movablePages && freeInOtherZones)
+			{
+			test.Printf(_L("Fail: Zone ID %x all the movable pages haven't been moved\n"), zoneID);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			CLEANUP(ResetDPCache());
+			TEST_FAIL;
+			}
+		if (origUnknownInZone != unknownPages)
+			{
+			test.Printf(_L("Fail: Zone ID %x unknown pages before and after are not equal\n"), zoneID);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			CLEANUP(ResetDPCache());
+			TEST_FAIL;
+			}
+		if (!gPagedRom)
+			{
+			if (discPages && freeInOtherZones)
+				{
+				test.Printf(_L("Fail: Zone ID %x all the discardable pages haven't been moved\n"), zoneID);
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			}
+		else
+			{
+			DPTest::CacheSize(minCacheSize, maxCacheSize, currentCacheSize);
+			TESTDEBUG(test.Printf(_L("CacheSize3: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"),
+										minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift));
+			// The the discardable pages should have been discarded or moved unless
+			// there is no room in the other zones and the cache size is already at its minimum
+			if (discPages && (freeInOtherZones || currentCacheSize != minCacheSize))
+				{
+				test.Printf(_L("Fail: Zone 0x%x all the discardable pages haven't been moved\n"), zoneID);
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			}
+		test.Printf(_L("Passed...\n"));
+		}
+	// TestEnd() willl cleanup what's required
+	TestEnd();
+	test.Next(_L("Test8: Call function TRamDefragRequest::EmptyRamZone on a zone that contains fixed and movable pages"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	index = gZoneCount - 1;
+	while (index > 0 && (gZoneUtilArray[index].iAllocMovable < 10 || gZoneUtilArray[index].iFreePages < 3))
+		{
+		-- index;
+		}
+	defragZoneID = gZoneConfigArray[index].iZoneId;
+	if (index == 0 && (gZoneUtilArray[index].iAllocMovable < 10 || gZoneUtilArray[index].iFreePages < 3))
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		test.Printf(_L("defragZoneID = 0x%x\n"), defragZoneID);
+		test.Printf(_L("movable = 0x%x discardable = 0x%x\n"),
+						gZoneUtilArray[index].iAllocMovable, gZoneUtilArray[index].iAllocDiscardable);
+		Ldd.ZoneAllocDiscontiguous(defragZoneID, 2); // Allocated 2 fixed pages to ensure that zone cannot be emptied
+		r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, defragZoneID);
+		GetAllPageInfo();
+		TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+		if (r != KErrNoMemory ||
+			(freeInOthers &&
+			(gZoneUtilArray[index].iAllocMovable ||
+			gZoneUtilArray[index].iAllocDiscardable)))
+			{
+			test.Printf(_L("r = %d, expected = %d, or all movable/discardable pages have not been moved"),
+							r, KErrNoMemory);
+			CLEANUP(Ldd.FreeAllFixedPages());
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed..."));
+			}
+		Ldd.FreeAllFixedPages();
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.End();
+	return r;
+	}
+//
+// TestClaimRamZone
+//
+//---------------------------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID				KBASE-t_ramdefrag-0532
+//! @SYMTestType				CIT
+//! @SYMTestCaseDesc			Verifying the implemntation of the function TRamDefragRequest::ClaimRamZone()
+//! @SYMPREQ					PREQ308
+//! @SYMTestPriority			High
+//! @SYMTestActions
+//! 	1.	Fragment the memory. Following this, call function with a valid aID
+//! 	2.	Fragment the memory. Following this, call function with an invalid aID
+//! 	3.	Fragment the memory. Following this, start a zone defrag and whilst this
+//! 		is running, call function on the same zone.
+//! 	4.	Fragment the memory. Following this, start a general defrag and whilst this
+//! 		is running, call function on the same zone.
+//! 	5.	Fragment the memory. Following this, call ClaimRamZone() on a specific zone, whilst at the
+//! 		same time calling ClaimRamZone() on another zone.
+//! 	6:	Fragment the memory. Call function TRamDefragRequest::ClaimRamZone on specifc zone and at the
+//! 		same time allocate pages to the zone
+//!		7.	Fragment the memory. Following this allocate fixed pages to a zone and attempt to claim
+//!			the zone.
+//!		8.	Fragment the memory. Following this call ClaimRamZone() on every zone, one after the other
+//!
+//! @SYMTestExpectedResults
+//! 	1.	KErrNone
+//! 	2.	KErrArgument
+//! 	3.	KErrNone and the zone has been claimed
+//! 	4.	KErrNone and the zone has been claimed
+//! 	5.	KErrNone and both zones have been claimed
+//! 	6.	KErrNoMemory
+//!		7.	KErrNoMemory, all movable and discardable pages have been moved
+//!		8.	One of the following scenarios should occur:
+//!			a.	If the cache has not reached its minimum size and there are no unknown pages in
+//!				the zone, then all the movable pages should be moved from the zone if there are enough free pages
+//!				in the other zones.
+//!				However, when demand paging is off, all movable pages should be moved from the zone, again if there
+//!				are enough free pages in the other zones and if there are no unknown pages in the zone.
+//!			b.	If the current size of the cache minus the number of discardable pages in the zone being emptied is not
+//!				less than the minimum cache size and there are no unknown pages in the zone,
+//!				then all the discardable pages should be discarded of.
+//!				However, when demand paging is off, all discardable pages should be removed from
+//!				the zone if there are no unknown pages in the zone.
+//---------------------------------------------------------------------------------------------------------------------
+TInt TestClaimRamZone()
+	{
+	TInt r = 0;
+	TInt r2 = 0;
+	TUint32 addr = 0;
+	TInt waitTime = 1000;
+	test.Start(_L("Test1: Call function TRamDefragRequest::ClaimRamZone with a valid aID"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	TUint index = gZoneCount - 1;
+	while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		-- index;
+		}
+	TUint defragZoneID = gZoneConfigArray[index].iZoneId;
+	if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, defragZoneID);
+		GetAllPageInfo();
+		TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+		if (freeInOthers && r != KErrNone &&
+			gZoneUtilArray[index].iAllocFixed != gZoneUtilArray[index].iPhysPages)
+			{
+			test.Printf(_L("Fail: Zone 0x%x has not been claimed r %d expected %d\n"), defragZoneID, r, KErrNone);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		addr = gZoneConfigArray[index].iPhysBase;
+		if (r == KErrNone)
+			{
+			r = Ldd.FreeAllFixedPages();
+			}
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test2: Call function TRamDefragRequest::ClaimRamZone with an invalid aID"));
+	TestStart();
+	gChunkArray1 = new RChunk;
+	gChunkArraySize1 = 1;
+	defragZoneID = KInvalidZoneID;
+	r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, defragZoneID);
+	if (r != KErrArgument)
+		{
+		test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrArgument);
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+	TestEnd();
+	test.Next(_L("Test3: Call function TRamDefragRequest::ClaimRamZone when a EmptyRamZone is already running"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	index = gZoneCount - 1;
+	while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		-- index;
+		}
+	defragZoneID = gZoneConfigArray[index].iZoneId;
+	if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		TInt numPassed = 0;
+		for (waitTime = 1000; waitTime > 0; waitTime-=10)
+			{
+			r = gTestThread.Create(gTestThreadName,MultiEmptyZoneThreadFunc,KDefaultStackSize,0x1000,0x1000,(TAny*)defragZoneID);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				TEST_FAIL;
+				}
+			gTestThread.Logon(status);
+			gTestThread.Resume();
+			User::After(waitTime);
+			r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, defragZoneID);
+			User::WaitForRequest(status);
+			r2 = status.Int();
+			GetAllPageInfo();
+			TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+			if (freeInOthers && r != KErrNone && r2 != KErrNone)
+				{
+				test.Printf(_L("Fail: r = %d, r2 = %d, expected = %d, or zone ID 0x%x has not been claimed\n"),
+										r, r2, KErrNone, defragZoneID);
+				if (r == KErrNone)
+					{
+					CLEANUP(r = Ldd.FreeAllFixedPages());
+					}
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				TEST_FAIL;
+				}
+			else
+				{
+				numPassed ++;
+				}
+			if (r == KErrNone)
+				{
+				r = Ldd.FreeAllFixedPages();
+				}
+			gTestThread.Close();
+			}
+		if (numPassed > 0)
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test4: Call function TRamDefragRequest::ClaimRamZone when a general defrag is already running"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	index = gZoneCount - 1;
+	while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		-- index;
+		}
+	if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		defragZoneID = gZoneConfigArray[index].iZoneId;
+		r = gTestThread.Create(gTestThreadName,MultiGenDefragThreadFunc,KDefaultStackSize,0x1000,0x1000,NULL);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		gTestThread.Logon(status);
+		gTestThread.Resume();
+		User::After(waitTime);
+		r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, defragZoneID);
+		User::WaitForRequest(status);
+		r2 = status.Int();
+		if (r != KErrNone)
+			{
+			test.Printf(_L("ClaimZone: r = %d, expected = %d\n"), r, KErrNone);
+			}
+		if (r2 != KErrNone)
+			{
+			test.Printf(_L("General: r2 = %d, expected = %d\n"), r, KErrNone);
+			}
+		GetAllPageInfo();
+		TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+		if (freeInOthers && gZoneUtilArray[index].iAllocFixed != gZoneUtilArray[index].iPhysPages)
+			{
+			test.Printf(_L("Fail: Zone ID 0x%x has not been claimed, r = %d, r2 = %d, expected = %d\n"),
+										defragZoneID, r, r2, KErrNone);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		if (r == KErrNone)
+			{
+			r = Ldd.FreeAllFixedPages();
+			}
+		gTestThread.Close();
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test5: Call function TRamDefragRequest::ClaimRamZone on specifc zone at the same time as calling on another zone"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	index = gZoneCount - 1;
+	while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		-- index;
+		}
+	defragZoneID = gZoneConfigArray[index].iZoneId;
+	test.Printf(_L("index = 0x%x "), index);
+	TUint index2 = gZoneCount - 1;
+	while (	index2 > 0 &&
+			(index == index2 || gZoneUtilArray[index2].iAllocFixed != 0 || gZoneUtilArray[index2].iAllocUnknown != 0))
+		{
+		-- index2;
+		}
+	TUint defragZoneID2 = gZoneConfigArray[index2].iZoneId;
+	test.Printf(_L("index2 = %d\n"), index2);
+	if ((index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0)) ||
+		(index2 == 0 && (index == index2 || gZoneUtilArray[index2].iAllocFixed != 0 || gZoneUtilArray[index2].iAllocUnknown != 0)))
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		r = gTestThread.Create(gTestThreadName,MultiClaimZoneThreadFunc,KDefaultStackSize,0x1000,0x1000,(TAny*)(defragZoneID2));
+		if (r != KErrNone)
+			{
+			test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		gTestThread.Logon(status);
+		gTestThread.Resume();
+		User::After(waitTime);
+		r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, defragZoneID);
+		TESTDEBUG(test.Printf(_L("r = %d\n"), r));
+		User::WaitForRequest(status);
+		r2 = status.Int();
+		GetAllPageInfo();
+		TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+		TUint freeInOthers2 = gTotalPageCount.iFreePages - gZoneUtilArray[index2].iFreePages;
+		if ((freeInOthers && r != KErrNone &&
+			gZoneUtilArray[index].iAllocFixed != gZoneUtilArray[index].iPhysPages) ||
+			(freeInOthers2 && r != KErrNone &&
+			gZoneUtilArray[index2].iAllocFixed != gZoneUtilArray[index2].iPhysPages))
+			{
+			test.Printf(_L("Fail: Zone ID 0x%x or Zone ID 0x%x has not been claimed, r = %d, r2 = %d, expected = %d\n"),
+									defragZoneID, defragZoneID2, r, r2, KErrNone);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		if (r == KErrNone)
+			{
+			r = Ldd.FreeAllFixedPages();
+			}
+		if (r2 == KErrNone)
+			{// Have to free from specific address as RAM zone claimed by other channel.
+			addr = gZoneConfigArray[index2].iPhysBase;
+			r = Ldd.FreeFromAddr(gZoneUtilArray[index2].iAllocFixed, addr);
+			}
+		gTestThread.Close();
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test6: Call function TRamDefragRequest::ClaimRamZone on specifc zone and at the same time allocate pages to the zone"));
+	TestStart();
+	TInt pagesAlloc = 1; // Try and allocate just one page whilst attempting to claim the zone
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	index = gZoneCount - 1;
+	while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		-- index;
+		}
+	if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		GetAllPageInfo();
+		defragZoneID = gZoneConfigArray[index].iZoneId;
+		TInt numPassed = 0;
+		for (waitTime = 1000; waitTime > 0; waitTime-=10)
+			{
+			r = gTestThread.Create(gTestThreadName,MultiClaimZoneThreadFunc,KDefaultStackSize,0x1000,0x1000,(TAny*)defragZoneID);
+			if (r != KErrNone)
+			{
+			test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+			gTestThread.Logon(status);
+			gTestThread.Resume();
+			test(status.Int() == KRequestPending);
+			User::After(waitTime);
+			r = Ldd.ZoneAllocDiscontiguous(defragZoneID, pagesAlloc);
+			TESTDEBUG(test.Printf(_L("r = %d\n"), r));
+			User::WaitForRequest(status);
+			r2 = status.Int();
+			GetAllPageInfo();
+			TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+			if (freeInOthers && r2 != KErrNone)
+				{
+				test.Printf(_L("Claim was unsuccsessful: r2 = %d, expected = %d\n"), r2, KErrNone);
+				}
+			else if (r2 == KErrNone && r != KErrNoMemory)
+				{
+				test.Printf(_L("Fail: r = %d, expected = %d, r2 = %d, expected = %d, zone ID = 0x%x\n"),
+										r, KErrNoMemory, r2, KErrNone, defragZoneID);
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				CLEANUP(Ldd.FreeAllFixedPages());
+				// Free from address as a different channel claimed the RAM zone.
+				addr = gZoneConfigArray[index].iPhysBase;
+				CLEANUP(Ldd.FreeFromAddr(gZoneUtilArray[index].iAllocFixed, addr));
+				TEST_FAIL;
+				}
+			else
+				{
+				numPassed ++;
+				}
+			Ldd.FreeAllFixedPages();
+			GetAllPageInfo();
+			if (r2 == KErrNone)
+				{// Free from address as a different channel claimed the RAM zone.
+				addr = gZoneConfigArray[index].iPhysBase;
+				r = Ldd.FreeFromAddr(gZoneUtilArray[index].iAllocFixed, addr);
+				}
+			gTestThread.Close();
+			}
+		if (numPassed > 0)
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test7: Call function TRamDefragRequest::ClaimRamZone on a zone that contains fixed and movable pages"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	index = gZoneCount - 1;
+	while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0) &&
+			(gZoneUtilArray[index].iAllocMovable < 10 || gZoneUtilArray[index].iFreePages < 3))
+			{
+			-- index;
+			}
+	if (index == 0 && ((gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0) &&
+			(gZoneUtilArray[index].iAllocMovable < 10 || gZoneUtilArray[index].iFreePages < 3)))
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		defragZoneID = gZoneConfigArray[index].iZoneId;
+		TESTDEBUG(test.Printf(_L("defragZoneID = 0x%x\n"), defragZoneID));
+		TESTDEBUG(test.Printf(_L("movable = 0x%x discardable = 0x%x\n"),
+						gZoneUtilArray[index].iAllocMovable, gZoneUtilArray[index].iAllocDiscardable));
+		Ldd.ZoneAllocDiscontiguous(defragZoneID, 2); // Allocated 2 fixed pages to ensure that zone cannot be emptied
+		r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, defragZoneID);
+		GetAllPageInfo();
+		TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+		if (r != KErrNoMemory ||
+			(freeInOthers &&
+			(gZoneUtilArray[index].iAllocMovable ||
+			gZoneUtilArray[index].iAllocDiscardable)))
+			{
+			test.Printf(_L("r = %d, expected = %d, or all movable/discardable pages have not been moved"),
+							r, KErrNoMemory);
+			CLEANUP(Ldd.FreeAllFixedPages());
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		Ldd.FreeAllFixedPages();
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test8: Call function TRamDefragRequest::ClaimRamZone on every zone one after the other"));
+	TestStart();
+	Ldd.ResetDriver();
+	for (index = 0; index < gZoneCount; index ++)
+		{
+		// Variables for DP ROM cache sizes
+		TUint minCacheSize = 0;
+		TUint maxCacheSize = 0;
+		TUint currentCacheSize = 0;
+		if (gPagedRom)
+			{
+			DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
+			TESTDEBUG(test.Printf(_L("Original CacheSize: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"),
+										minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift));
+			// Calculate the maximum size of the DP cache
+			TUint minZoneFree = KMaxTUint;
+			TUint maxDisFillBytes = 0;
+			GetAllPageInfo();
+			for (TUint i = 0; i < gZoneCount; i++)
+				{
+				maxDisFillBytes += gZoneUtilArray[i].iFreePages;
+				maxDisFillBytes += gZoneUtilArray[i].iAllocDiscardable;
+				if (minZoneFree > gZoneUtilArray[i].iFreePages)
+					minZoneFree = gZoneUtilArray[i].iFreePages;
+				}
+			test.Printf(_L("Free pages 0x%x maxDisFillBytes 0x%x\n"), gTotalPageCount.iFreePages, maxDisFillBytes);
+			maxDisFillBytes <<= gPageShift;
+			r = DPTest::SetCacheSize(maxDisFillBytes, maxDisFillBytes);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
+			TESTDEBUG(test.Printf(_L("CacheSize2: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"),
+										minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift));
+			if (currentCacheSize != maxDisFillBytes)
+				{
+				test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			GetAllPageInfo();
+			test.Printf(_L("Free pages after alloc discardable1 = 0x%x\n"), gTotalPageCount.iFreePages);
+			r = DPTest::SetCacheSize(minZoneFree << gPageShift, maxDisFillBytes);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			// Check all zones have no free pages.
+			GetAllPageInfo();
+			for (TUint i = 0; i < gZoneCount; i++)
+				{
+				if (gZoneUtilArray[i].iFreePages != 0)
+					{
+					test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+					CLEANUP(ResetDPCache());
+					TEST_FAIL;
+					}
+				}
+			}
+		else
+			{
+			// Fragment the RAM with some movable pages
+			AllocMovable(gChunkArray1, gChunkArraySize1, KFillAllMovable);
+			FreeMovable(gChunkArray1, gChunkArraySize1);
+			}
+		TUint zoneID = gZoneConfigArray[index].iZoneId;
+		GetAllPageInfo();
+		TUint origUnknownInZone = gZoneUtilArray[index].iAllocUnknown;
+		TUint origMovInZone = gZoneUtilArray[index].iAllocMovable;
+		TUint origFreeInZone = gZoneUtilArray[index].iFreePages;
+		test.Printf(_L("Zone ID 0x%x - fixedPages = 0x%x, unknownPages = 0x%x, discardablePages = 0x%x movable = 0x%x free = 0x%x\n"),
+						zoneID, gZoneUtilArray[index].iAllocFixed, origUnknownInZone, gZoneUtilArray[index].iAllocDiscardable,
+						origMovInZone, origFreeInZone);
+		r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, zoneID);
+		GetAllPageInfo();
+		TUint unknownPages = gZoneUtilArray[index].iAllocUnknown;
+		TUint discPages = gZoneUtilArray[index].iAllocDiscardable;
+		TUint movablePages = gZoneUtilArray[index].iAllocMovable;
+		if (r == KErrNone)
+			{
+			r = Ldd.FreeAllFixedPages();
+			}
+		TUint freeInOtherZones = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+		if (!unknownPages && movablePages && freeInOtherZones)
+			{
+			test.Printf(_L("Fail: Zone ID %x all the movable pages haven't been moved\n"), zoneID);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			CLEANUP(ResetDPCache());
+			TEST_FAIL;
+			}
+		if (origUnknownInZone != unknownPages)
+			{
+			test.Printf(_L("Fail: Zone ID %x unknown pages before and after are not equal\n"), zoneID);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			CLEANUP(ResetDPCache());
+			TEST_FAIL;
+			}
+		if (!gPagedRom)
+			{
+			if (!unknownPages && freeInOtherZones && discPages)
+				{
+				test.Printf(_L("Fail: Zone ID %x all the discardable pages haven't been moved\n"), zoneID);
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			}
+		else
+			{
+			DPTest::CacheSize(minCacheSize, maxCacheSize, currentCacheSize);
+			TESTDEBUG(test.Printf(_L("CacheSize3: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"),
+										minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift));
+			// The the discardable pages should have been discarded or moved unless
+			// there is no room in the other zones and the cache size is already at its minimum
+			if (!unknownPages && discPages && (freeInOtherZones || currentCacheSize != minCacheSize))
+				{
+				test.Printf(_L("Fail: Zone ID 0x%x all the discardable pages haven't been moved\n"), zoneID);
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			}
+		test.Printf(_L("Passed...\n"));
+		}
+	// TestEnd() will cleanup what's required.
+	TestEnd();
+	test.End();
+	return 0;
+	}
+//
+// TestCancelDefrag
+//
+//-----------------------------------------------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID				KBASE-t_ramdefrag-0533
+//! @SYMTestType				CIT
+//! @SYMTestCaseDesc			Verifying the implementation of the function TRamDefragRequest::CancelDefrag()
+//! @SYMPREQ					PREQ308
+//! @SYMTestPriority			High
+//! @SYMTestActions
+//! 	1.	Fragment the memory. Following this, start a general defrag and cancel it
+//! 	2.	Fragment the memory. Following this, start a zone defrag and cancel it
+//! 	3.	Fragment the memory. Following this, start a claim zone and cancel it
+//!
+//! @SYMTestExpectedResults
+//! 	1.	KErrCancel
+//! 	2.	KErrCancel
+//! 	3.	KErrCancel
+//-----------------------------------------------------------------------------------------------------------------------------------------
+TInt TestCancelDefrag()
+	{
+	TInt r = 0;
+	TUint defragZoneID = 0;
+	test.Start(_L("Test1: Call general defrag and cancel it"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	r = Ldd.CheckCancel(DEFRAG_TYPE_GEN);
+	TESTDEBUG(test.Printf(_L("r = %d\n"), r));
+	if (r != KErrCancel)
+		{
+		test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrCancel);
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test2: Call zone defrag and cancel it"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	TUint index = gZoneCount - 1;
+	while (index > 0 &&
+			(gZoneUtilArray[index].iFreePages == gZoneUtilArray[index].iPhysPages ||
+			gZoneUtilArray[index].iAllocFixed !=0 ||
+			gZoneUtilArray[index].iAllocUnknown !=0))
+		{
+		-- index;
+		}
+	if (index == 0 &&
+		(gZoneUtilArray[index].iFreePages == gZoneUtilArray[index].iPhysPages ||
+		gZoneUtilArray[index].iAllocFixed !=0 ||
+		gZoneUtilArray[index].iAllocUnknown !=0))
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		defragZoneID = gZoneConfigArray[index].iZoneId;
+		TESTDEBUG(test.Printf(_L("defragZoneID = 0x%x\n"),defragZoneID));
+		r = Ldd.CheckCancel(DEFRAG_TYPE_EMPTY, defragZoneID);
+		TESTDEBUG(test.Printf(_L("r = %d\n"), r));
+		if (r != KErrCancel)
+			{
+			test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrCancel);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test3: Call Claim RAM Zone and cancel it"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	index = gZoneCount - 1;
+	while (index > 0 &&
+			(gZoneUtilArray[index].iFreePages == gZoneUtilArray[index].iPhysPages ||
+			gZoneUtilArray[index].iAllocFixed !=0 ||
+			gZoneUtilArray[index].iAllocUnknown !=0))
+		{
+		-- index;
+		}
+	defragZoneID = gZoneConfigArray[index].iZoneId;
+	TESTDEBUG(test.Printf(_L("defragZoneID = 0x%x\n"),defragZoneID));
+	if (index == 0 &&
+			(gZoneUtilArray[index].iFreePages == gZoneUtilArray[index].iPhysPages ||
+			gZoneUtilArray[index].iAllocFixed !=0 ||
+			gZoneUtilArray[index].iAllocUnknown !=0))
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		r = Ldd.CheckCancel(DEFRAG_TYPE_CLAIM, defragZoneID);
+		TESTDEBUG(test.Printf(_L("r = %d\n"), r));
+		if (r != KErrCancel)
+			{
+			test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrCancel);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.End();
+	return 0;
+	}
+//
+// TestZoneAllocNoAffect
+//
+// Ensures that fixed page allocations do not affect the movable
+// or discardable page allocations
+//
+TInt TestZoneAllocNoAffect(TInt aZoneAllocType, TInt aPageType)
+	{
+	TInt retVal = KErrNone;
+	TInt r = KErrNone;
+	TInt mostPrefIndex = 0;
+	TUint leastPrefIndex = 0;
+	TUint leastPrefZoneID = 0;
+	TestStart();
+	gChunkArray1 = new RChunk;
+	gChunkArraySize1 = 1;
+	switch(aPageType)
+		{
+		case BEST_MOVABLE:
+			test.Printf(_L("Test Epoc::ZoneAllocPhysicalRam() doesn't affect the allocation of movable pages\n"));
+			break;
+		case BEST_DISCARDABLE:
+			test.Printf(_L("Test Epoc::ZoneAllocPhysicalRam() doesn't affect the allocation of discardable pages\n"));
+			if (!gPagedRom)
+				{
+				test.Printf(_L("Not a paged ROM - Skipping...\n"));
+				goto skipSetup;
+				}
+			break;
+		}
+	// Fist find the zone that movable page allocations should go into
+	// Getting the best movable will be the same for discardable as well
+	mostPrefIndex = GetBestZone(aPageType);
+	if (mostPrefIndex == KErrNotFound)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+		goto skipSetup;
+		}
+	// Get the least pref zone to zone alloc into and ensure it has free pages
+	GetPrefOrder();
+	leastPrefIndex = gPrefArray[gZoneCount - 1];
+	if (gZoneConfigArray[mostPrefIndex].iPref == gZoneConfigArray[leastPrefIndex].iPref)
+		{
+		test.Printf(_L("Zones with same preference - Skipping...\n"));
+		goto skipSetup;
+		}
+	if (leastPrefIndex == (TUint)mostPrefIndex ||
+		gZoneUtilArray[leastPrefIndex].iFreePages == 0)
+		{
+		test.Printf(_L("leastPrefIndex = mostPrefIndex or leastPrefIndex(%d) / mostPrefIndex(%d) has 0 free - Skipping test step...\n"),
+						leastPrefIndex, mostPrefIndex);
+		goto skipSetup;
+		}
+	// Zone alloc 1 fixed page into the least preferable zone
+	leastPrefZoneID = gZoneConfigArray[leastPrefIndex].iZoneId;
+	GetOriginalPageCount();
+	switch(aZoneAllocType)
+		{
+		case Z_ALLOC_DISC:
+			{
+			r = Ldd.ZoneAllocDiscontiguous(leastPrefZoneID, 1);
+			break;
+			}
+		case Z_ALLOC_CONTIG:
+			{
+			r = Ldd.ZoneAllocContiguous(leastPrefZoneID, gPageSize);
+			break;
+			}
+		}
+	GetAllPageInfo();
+	if (r != KErrNone ||
+		gZoneUtilArray[leastPrefIndex].iAllocFixed <= gOriginalPageCountArray[leastPrefIndex].iAllocFixed)
+		{
+		test.Printf(_L("Failed to allocate 1 fixed page to zone index %d r = %d\n"), leastPrefIndex, r);
+		goto skipSetup;
+		}
+	test.Printf(_L("leastPrefIndex = %d mostPrefIndex = %d\n"), leastPrefIndex, mostPrefIndex);
+	switch(aPageType)
+		{
+		case BEST_MOVABLE:
+			// now allocate 1 movable page
+			r = AllocMovable(gChunkArray1, gChunkArraySize1, 1, gPageSize);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("Failed to allocate 1 movable page r = %d\n"), r);
+				goto skipSetup;
+				}
+			break;
+		case BEST_DISCARDABLE:
+			// now allocate 1 discardable page
+			TInt disPages;
+			TUint disBytes = (gTotalPageCount.iDiscardablePages + 1) << gPageShift;
+			r = AllocDiscardable(disPages, disBytes);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("Failed to allocate 1 discardable page r = %d\n"), r);
+				goto skipSetup;
+				}
+			break;
+		}
+	GetAllPageInfo();
+	switch(aPageType)
+		{
+		case BEST_MOVABLE:
+			if (gOriginalPageCountArray[mostPrefIndex].iAllocMovable >= gZoneUtilArray[mostPrefIndex].iAllocMovable ||
+				gOriginalPageCountArray[leastPrefIndex].iAllocMovable < gZoneUtilArray[leastPrefIndex].iAllocMovable)
+				{
+				test.Printf(_L("FAIL: mostPrefIndex(%d) origMov 0x%x curMov 0x%x leastPrefIndex(%d) origMov 0x%x curMov 0x%x\n"),
+								mostPrefIndex, gOriginalPageCountArray[mostPrefIndex].iAllocMovable, gZoneUtilArray[mostPrefIndex].iAllocMovable,
+								leastPrefIndex, gOriginalPageCountArray[leastPrefIndex].iAllocMovable, gZoneUtilArray[leastPrefIndex].iAllocMovable);
+				CLEANUP(Ldd.FreeAllFixedPages());
+				retVal = KErrGeneral;
+				}
+			else
+				{
+				test.Printf(_L("Passed...\n"));
+				}
+			break;
+		case BEST_DISCARDABLE:
+			if (gOriginalPageCountArray[mostPrefIndex].iAllocDiscardable >= gZoneUtilArray[mostPrefIndex].iAllocDiscardable ||
+				gOriginalPageCountArray[leastPrefIndex].iAllocDiscardable < gZoneUtilArray[leastPrefIndex].iAllocDiscardable)
+				{
+				test.Printf(_L("FAIL: mostPrefIndex(%d) origDis 0x%x curDis 0x%x leastPrefIndex(%d) origDis 0x%x curDis 0x%x\n"),
+								mostPrefIndex, gOriginalPageCountArray[mostPrefIndex].iAllocDiscardable, gZoneUtilArray[mostPrefIndex].iAllocDiscardable,
+								leastPrefIndex, gOriginalPageCountArray[leastPrefIndex].iAllocDiscardable, gZoneUtilArray[leastPrefIndex].iAllocDiscardable);
+				CLEANUP(Ldd.FreeAllFixedPages());
+				retVal = KErrGeneral;
+				}
+			else
+				{
+				test.Printf(_L("Passed...\n"));
+				}
+			break;
+		}
+	// This will clean up any fixed pages allocated.
+skipSetup:
+	TestEnd();
+	return retVal;
+	}
+//
+// TestZoneAllocContiguous
+//
+//---------------------------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID				KBASE-t_ramdefrag-0535
+//! @SYMTestType				CIT
+//! @SYMTestCaseDesc			Verifying the contiguous overload of Epoc::ZoneAllocPhysicalRam().
+//! @SYMPREQ					PREQ308
+//! @SYMTestPriority			High
+//! @SYMTestActions
+//! 	1.	Call function with a valid aZoneID.
+//! 	2.	Call function with an invalid aZoneID
+//! 	3.	Call function with aSize > zone size
+//!		4.	Call multiple RAM zone overload of the function with a mix of valid and invalid IDs.
+//!		5.	Call multiple RAM zone overload of the function with contiguous RAM zones and attempt
+//!			to allocate over both RAM zones.
+//!		6.	Call function on a RAM zone that has some non-DP pages allocated into it and ask
+//!			for the whole RAM zone to be filled with fixed pages.
+//!		7.	Get the most preferable zone for movable page allocations (mostPref). Allocate 1 contiguous fixed page
+//!			in the least preferable zone. Following this allocate 1 movable page
+//!		8.	Get the most preferable zone for discardable page allocations (mostPref). Allocate 1 contiguous fixed
+//!			page in the least preferable zone. Following this allocate 1 discardable page
+//!
+//! @SYMTestExpectedResults
+//! 	1.	KErrNone
+//! 	2.	KErrArgument
+//! 	3.	KErrArgument
+//!		4.	KErrArgument
+//!		5.	KErrNone
+//!		6.	KErrNoMemory
+//!		7.	Movable pages are allocated into zone mostPref.
+//!		8.	Discardable pages are allocated into zone mostPref
+//---------------------------------------------------------------------------------------------------------------------
+TInt TestZoneAllocContiguous()
+	{
+	TInt r = 0;
+	test.Start(_L("Test1: Call function Epoc::ZoneAllocPhysicalRam() with a valid aZoneID"));
+	TestStart();
+	const TUint KAllocPages = 2;
+	GetOriginalPageCount();
+	GetAllPageInfo();
+	TUint index = gZoneCount - 1;
+	while (index > 0 && gZoneUtilArray[index].iFreePages < KAllocPages)
+		{
+		-- index;
+		}
+	TUint zoneID = gZoneConfigArray[index].iZoneId;
+	if (index == 0 && gZoneUtilArray[index].iFreePages < KAllocPages)
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		TUint allocBytes = KAllocPages << gPageShift;
+		r = Ldd.ZoneAllocContiguous(zoneID, allocBytes);
+		GetAllPageInfo();
+		if (r == KErrNone &&
+			gZoneUtilArray[index].iAllocFixed - gOriginalPageCountArray[index].iAllocFixed == KAllocPages)
+			{
+			test.Printf(_L("Pass: Correct number of fixed pages allocated to zone ID 0x%x\n"),zoneID);
+			}
+		else
+			{
+			test.Printf(_L("Fail: r = %d, expected = %d, or number of pages allocated is not expected\n"),
+							r, KErrNone);
+			CLEANUP(Ldd.FreeAllFixedPages());
+			TEST_FAIL;
+			}
+		Ldd.FreeAllFixedPages();
+		}
+	TestEnd();
+	test.Next(_L("Test2: Call function Epoc::ZoneAllocPhysicalRam() with an invalid aZoneID"));
+	TestStart();
+	zoneID = KInvalidZoneID;
+	TESTDEBUG(test.Printf(_L("zoneID = 0x%x\n"), zoneID));
+	r = Ldd.ZoneAllocContiguous(zoneID, gPageSize);
+	GetAllPageInfo();
+	if (r == KErrArgument)
+		{
+		test.Printf(_L("Pass: Correct return value\n"));
+		}
+	else
+		{
+		test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrArgument);
+		CLEANUP(Ldd.FreeAllFixedPages());
+		TEST_FAIL;
+		}
+	Ldd.FreeAllFixedPages();
+	TestEnd();
+	test.Next(_L("Test3: Call function Epoc::ZoneAllocPhysicalRam() with aSize > zone size"));
+	TestStart();
+	index = gZoneCount - 1;
+	zoneID = gZoneConfigArray[index].iZoneId;
+	TUint allocBytes = (gZoneUtilArray[index].iPhysPages + 5)  << gPageShift;
+	r = Ldd.ZoneAllocContiguous(zoneID, allocBytes);
+	GetAllPageInfo();
+	if (r == KErrArgument)
+		{
+		test.Printf(_L("Pass: Correct return value and number of pages allocated is correct\n"));
+		}
+	else
+		{
+		test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrArgument);
+		CLEANUP(Ldd.FreeAllFixedPages());
+		TEST_FAIL;
+		}
+	Ldd.FreeAllFixedPages();
+	TestEnd();
+	const TUint KMultiZoneIds = 10;
+	TUint* zoneIdArray = new TUint[KMultiZoneIds];
+	test_NotNull(zoneIdArray);
+	test.Next(_L("Test4: Test Epoc::ZoneAllocPhysicaRam() always fails when at least one ID is invalid"));
+	TestStart();
+	index = gZoneCount - 1;
+	while (index > 0 && gZoneUtilArray[index].iFreePages < KAllocPages)
+		{
+		-- index;
+		}
+	if (index == 0 && gZoneUtilArray[index].iFreePages < KAllocPages)
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		TUint zoneIdSize = 2;
+		zoneIdArray[0] = gZoneConfigArray[index].iZoneId;
+		zoneIdArray[1] = KInvalidZoneID;
+		TUint allocBytes = KAllocPages << gPageShift;
+		r = Ldd.MultiZoneAllocContiguous(zoneIdArray, zoneIdSize, allocBytes);
+		if (r != KErrArgument)
+			{
+			CLEANUP(Ldd.FreeAllFixedPages());
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Pass: Correct return value\n"));
+			}
+		}
+	TestEnd();
+	test.Next(_L("Test5: Test Epoc::ZoneAllocPhysicalRam() can span multiple RAM zones"));
+	TestStart();
+	// Attempt to find to physically contiguous RAM zones where higher addressed
+	// one is empty, relies on RAM zones are returned by HAL functions in
+	// ascending physical address order.
+	GetAllPageInfo();
+	TBool zonesFound = EFalse;
+	index = gZoneCount - 1;
+	for (; index > 1; index--)
+		{
+		if (gZoneUtilArray[index].iFreePages == gZoneUtilArray[index].iPhysPages &&
+			gZoneUtilArray[index-1].iFreePages == gZoneUtilArray[index-1].iPhysPages &&
+			gZoneConfigArray[index].iPhysBase - 1 == gZoneConfigArray[index-1].iPhysEnd)
+			{
+			zonesFound = ETrue;
+			break;
+			}
+		}
+	if (!zonesFound)
+		{
+		test.Printf(_L("Cannot find RAM zones to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		// Allocate one page more than the first RAM zone to force the allocation
+		// to spread over both RAM zones.
+		TUint allocPages = gZoneUtilArray[index-1].iPhysPages + 1;
+		TUint allocBytes = allocPages << gPageShift;
+		// Attempt to find a zone that has less free pages than the allocation
+		// size so we can test that the method continues past too full RAM zones.
+		zonesFound = EFalse;
+		TUint noAllocZone = 0;
+		for (; noAllocZone < gZoneCount; noAllocZone++)
+			{
+			if (allocPages > gZoneUtilArray[noAllocZone].iFreePages &&
+				noAllocZone != index && noAllocZone != index-1)
+				{
+				zonesFound = ETrue;
+				break;
+				}
+			}
+		TUint zoneIds = 2;
+		if (!zonesFound)
+			{
+			zoneIdArray[0] = gZoneConfigArray[index-1].iZoneId;
+			zoneIdArray[1] = gZoneConfigArray[index].iZoneId;
+			}
+		else
+			{// Have a zone that won't meet the allocation so use it
+			TESTDEBUG(test.Printf(_L("noAllocZone ID %x\n"), gZoneConfigArray[noAllocZone].iZoneId));
+			zoneIds++;
+			zoneIdArray[0] = gZoneConfigArray[noAllocZone].iZoneId;
+			zoneIdArray[1] = gZoneConfigArray[index-1].iZoneId;
+			zoneIdArray[2] = gZoneConfigArray[index].iZoneId;
+			}
+		r = Ldd.MultiZoneAllocContiguous(zoneIdArray, zoneIds, allocBytes);
+		GetAllPageInfo();
+		if (r != KErrNone ||
+			gZoneUtilArray[index].iFreePages == gZoneUtilArray[index].iPhysPages ||
+			gZoneUtilArray[index-1].iFreePages == gZoneUtilArray[index-1].iPhysPages)
+			{// The allocation failed.
+			CLEANUP(Ldd.FreeAllFixedPages());
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	// TestEnd() will free the allocation of fixed pages.
+	TestEnd();
+	test.Next(_L("Test6: Test Epoc::ZoneAllocPhysicalRam() returns KErrNoMemory when appropriate"));
+	TestStart();
+	// Attempt to find a RAM zone with some non-discarable pages allocated into it.
+	// (At time of writing discardable pages wouldn't be discarded on demand by
+	// this function but this may be changed in the future as discontiguous case does that).
+	GetAllPageInfo();
+	zonesFound = EFalse;
+	index = gZoneCount - 1;
+	for (; index > 0; index--)
+		{
+		if (gZoneUtilArray[index].iFreePages &&
+			(gZoneUtilArray[index].iAllocMovable || gZoneUtilArray[index].iAllocFixed))
+			{
+			zonesFound = ETrue;
+			break;
+			}
+		}
+	if (!zonesFound)
+		{
+		test.Printf(_L("Cannot find RAM zones to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		// Attempt to allocate the whole of the RAM zone.
+		GetOriginalPageCount();
+		TUint allocBytes = gZoneConfigArray[index].iPhysPages << gPageShift;
+		r = Ldd.ZoneAllocContiguous(gZoneConfigArray[index].iZoneId, allocBytes);
+		// The allocation should have failed and no pages should have
+		// been allocated.
+		GetAllPageInfo();
+		if (r != KErrNoMemory ||
+			gOriginalPageCountArray[index].iFreePages > gZoneUtilArray[index].iFreePages)
+			{
+			CLEANUP(Ldd.FreeAllFixedPages());
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Pass: Correct return value\n"));
+			}
+		}
+	// TestEnd() will free the allocation of fixed pages.
+	TestEnd();
+	delete[] zoneIdArray;
+	test.Next(_L("Test7: Test Epoc::ZoneAllocPhysicalRam() (Contiguous) doesn't affect the allocation of movable pages"));
+	r = TestZoneAllocNoAffect(Z_ALLOC_CONTIG, BEST_MOVABLE);
+	if (r != KErrNone)
+		{
+		TEST_FAIL;
+		}
+	test.Next(_L("Test8: Test Epoc::ZoneAllocPhysicalRam() (Contiguous) doesn't affect the allocation of discardable pages"));
+	r = TestZoneAllocNoAffect(Z_ALLOC_CONTIG, BEST_DISCARDABLE);
+	if (r != KErrNone)
+		{
+		TEST_FAIL;
+		}
+	test.End();
+	return KErrNone;
+	}
+//
+// TestZoneAllocDiscontiguous
+//
+//---------------------------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID				KBASE-t_ramdefrag-0536
+//! @SYMTestType				CIT
+//! @SYMTestCaseDesc			Verifying the discontiguous overload of Epoc::ZoneAllocPhysicalRam().
+//! @SYMPREQ					PREQ308
+//! @SYMTestPriority			High
+//! @SYMTestActions
+//! 	1.	Call function with a valid aZoneID.
+//! 	2.	Call function with an invalid aZoneID
+//! 	3.	Call function with aNumPages > zone size
+//!		4.	Call multiple RAM zone overload of function with a mix of valid and invalid IDs
+//!		5.	Call multiple RAM zone overload of function so that the allocation will have to
+//!			span multiple RAM zones.
+//!		6.	Call function with memory full with DP cache that has reached it's
+//!			minimum cache size.
+//!		7.	Call function with memory not quite full with DP cache that has reached it's
+//!			minimum cache size and with the specified RAM zone full.
+//!		8.	Call function to allocate a whole RAM zone on a RAM zone that has non-discardable
+//!			pages already allocated into it.
+//!		9.	Call function to allocate one less than the whole RAM zone on a RAM zone that has movable
+//!			pages allocated.
+//!		10.	Get the most preferable zone for movable page allocations (mostPref). Allocate 1 discontiguous fixed page
+//!			in the least preferable zone. Following this allocate 1 movable page
+//!		11.	Get the most preferable zone for discardable page allocations (mostPref). Allocate 1 discontiguous fixed
+//!			page in the least preferable zone. Following this allocate 1 discardable page
+//!
+//! @SYMTestExpectedResults
+//! 	1.	KErrNone
+//! 	2.	KErrArgument
+//! 	3.	KErrArgument
+//!		4.	KErrArgument
+//!		5.	KErrNone
+//!		6.	KErrNoMemory
+//!		7.	KErrNone
+//!		8. 	KErrNoMemory
+//!		9.	KErrNone (i.e. the movable pages are shifted out of the way but only those that need to be moved).
+//!		10.	Movable pages are allocated into zone mostPref.
+//!		11.	Discardable pages are allocated into zone mostPref
+//---------------------------------------------------------------------------------------------------------------------
+TInt TestZoneAllocDiscontiguous()
+	{
+	TInt r = KErrNone;
+	test.Start(_L("Test1: Call function Epoc::ZoneAllocPhysicalRam() with a valid aZoneID"));
+	TestStart();
+	const TUint KAllocPages = 5;
+	// Detemine how many extra pages the kernel heap may grow by
+	// as these may need to be accounted for.
+	TUint fixedOverhead = Ldd.GetAllocDiff(KAllocPages);
+	GetOriginalPageCount();
+	GetAllPageInfo();
+	TUint index = gZoneCount - 1;
+	while (index > 0 && gZoneUtilArray[index].iFreePages < KAllocPages)
+		{
+		-- index;
+		}
+	if (gZoneUtilArray[index].iFreePages < KAllocPages || gTotalPageCount.iFreePages < KAllocPages + fixedOverhead)
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		// Allocate KAllocPages discontiguous fixed pages into RAM zone zoneID
+		// and verfiy that the pages were allocated to the correct zone, allow for
+		// extra fixed pages to be allocated as the kernel heap may grow.
+		TUint zoneID = gZoneConfigArray[index].iZoneId;
+		r = Ldd.ZoneAllocDiscontiguous(zoneID, KAllocPages);
+		GetAllPageInfo();
+		if ((r == KErrNone) &&
+			(gZoneUtilArray[index].iAllocFixed >= gOriginalPageCountArray[index].iAllocFixed + KAllocPages))
+			{
+			test.Printf(_L("Pass: Correct return value and number of pages allocated is correct\n"));
+			}
+		else
+			{
+			test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrNone);
+			CLEANUP(Ldd.FreeAllFixedPages());
+			TEST_FAIL;
+			}
+		Ldd.FreeAllFixedPages();
+		}
+	TestEnd();
+	test.Next(_L("Test2: Call function Epoc::ZoneAllocPhysicalRam() with an invalid aZoneID"));
+	TestStart();
+	TUint zoneID = KInvalidZoneID;
+	r = Ldd.ZoneAllocDiscontiguous(zoneID, KAllocPages);
+	GetAllPageInfo();
+	if (r == KErrArgument)
+		{
+		test.Printf(_L("Pass: Correct return value\n"));
+		}
+	else
+		{
+		test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrArgument);
+		CLEANUP(Ldd.FreeAllFixedPages());
+		TEST_FAIL;
+		}
+	Ldd.FreeAllFixedPages();
+	TestEnd();
+	test.Next(_L("Test3: Call function Epoc::ZoneAllocPhysicalRam() when aNumPages > zone size"));
+	TestStart();
+	GetAllPageInfo();
+	index = gZoneCount - 1;
+	zoneID = gZoneConfigArray[index].iZoneId;
+	TUint allocPages = gZoneUtilArray[index].iPhysPages + 1;
+	r = Ldd.ZoneAllocDiscontiguous(zoneID, allocPages);
+	GetAllPageInfo();
+	if (r == KErrArgument)
+		{
+		test.Printf(_L("Pass: Correct return value and number of pages allocated is correct\n"));
+		}
+	else
+		{
+		test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrArgument);
+		CLEANUP(Ldd.FreeAllFixedPages());
+		TEST_FAIL;
+		}
+	Ldd.FreeAllFixedPages();
+	TestEnd();
+	const TUint KMultiZoneIds = 10;
+	TUint* zoneIdArray = new TUint[KMultiZoneIds];
+	test_NotNull(zoneIdArray);
+	test.Next(_L("Test4: Test Epoc::ZoneAllocPhysicaRam() always fails when at least one ID is invalid"));
+	TestStart();
+	TBool zonesFound = EFalse;
+	index = gZoneCount - 1;
+	for (; index > 0; index--)
+		{
+		if (gZoneUtilArray[index].iFreePages >= KAllocPages)
+			{
+			zonesFound = ETrue;
+			break;
+			}
+		}
+	if (!zonesFound)
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		TUint zoneIdSize = 2;
+		zoneIdArray[0] = gZoneConfigArray[index].iZoneId;
+		zoneIdArray[1] = KInvalidZoneID;
+		r = Ldd.MultiZoneAllocDiscontiguous(zoneIdArray, zoneIdSize, KAllocPages);
+		if (r != KErrArgument)
+			{// Make sure we cleanup.
+			CLEANUP(Ldd.FreeAllFixedPages());
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	TestEnd();
+	test.Next(_L("Test5: Test Epoc::ZoneAllocPhysicalRam() can span multiple RAM zones"));
+	TestStart();
+	zonesFound = EFalse;
+	TUint zonesCount = 0;
+	const TUint KTest5Zones = 2;
+	TUint zoneIndices[KTest5Zones];
+	allocPages = 0;
+	// Attempt to find KTest5Zones RAM zones with some free pages,
+	// search in reverse preference order to reduce chances of kernel heap pages
+	// being allocated into the RAM zones under test.
+	GetPrefOrder();
+	index = gZoneCount - 1;
+	for (; index > 0; index--)
+		{
+		TUint prefIndex = gPrefArray[index];
+		if (gZoneUtilArray[prefIndex].iFreePages != 0)
+			{
+			allocPages += gZoneUtilArray[prefIndex].iFreePages;
+			zoneIndices[zonesCount++] = prefIndex;
+			if (zonesCount == KTest5Zones)
+				{
+				zonesFound = ETrue;
+				break;
+				}
+			}
+		}
+	if (!zonesFound)
+		{
+		test.Printf(_L("Cannot find RAM zones to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		// Attempt to find a zone that has less free pages than the allocation
+		// size so we can test that the method continues past too full RAM zones.
+		zonesFound = EFalse;
+		TUint noAllocZone = 0;
+		for (; noAllocZone < gZoneCount; noAllocZone++)
+			{
+			if (allocPages > gZoneUtilArray[noAllocZone].iFreePages &&
+				noAllocZone != zoneIndices[0] && noAllocZone != zoneIndices[1])
+				{
+				zonesFound = ETrue;
+				break;
+				}
+			}
+		if (gPagedRom)
+			{// Fill memory with DP pages to test the allocation will discard
+			// pages when necessary.
+			TInt discard;
+			r = AllocDiscardable(discard);
+			GetAllPageInfo();
+			if (r != KErrNone ||
+				gZoneUtilArray[zoneIndices[0]].iFreePages != 0 ||
+				gZoneUtilArray[zoneIndices[1]].iFreePages != 0)
+				{
+				test.Printf(_L("r %d\n"), r);
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			}
+		TUint zoneIds = KTest5Zones;
+		if (!zonesFound)
+			{
+			zoneIdArray[0] = gZoneConfigArray[zoneIndices[0]].iZoneId;
+			zoneIdArray[1] = gZoneConfigArray[zoneIndices[1]].iZoneId;
+			}
+		else
+			{// Have a zone that won't meet the allocation so use it
+			TESTDEBUG(test.Printf(_L("noAllocZone ID %x\n"), gZoneConfigArray[noAllocZone].iZoneId));
+			zoneIds++;
+			zoneIdArray[0] = gZoneConfigArray[noAllocZone].iZoneId;
+			zoneIdArray[1] = gZoneConfigArray[zoneIndices[0]].iZoneId;
+			zoneIdArray[2] = gZoneConfigArray[zoneIndices[1]].iZoneId;
+			}
+		// Adjust the allocation size for any kernel heap pages that may be
+		// required as they may get allocated into the RAM zones under test.
+		allocPages -= Ldd.GetAllocDiff(allocPages);
+		GetOriginalPageCount();
+		r = Ldd.MultiZoneAllocDiscontiguous(zoneIdArray, zoneIds, allocPages);
+		GetAllPageInfo();
+		if (r != KErrNone ||
+			gZoneUtilArray[zoneIndices[0]].iAllocFixed <= gOriginalPageCountArray[zoneIndices[0]].iAllocFixed ||
+			gZoneUtilArray[zoneIndices[1]].iAllocFixed <= gOriginalPageCountArray[zoneIndices[1]].iAllocFixed)
+			{// The allocation failed.
+			CLEANUP(Ldd.FreeAllFixedPages());
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	// TestEnd() will free the allocation of fixed pages.
+	TestEnd();
+	if (gPagedRom)
+		{
+		test.Next(_L("Test6: Test Epoc::ZoneAllocPhysicalRam() returns KErrNoMemory when DP minimum cache size is hit"));
+		TestStart();
+		GetPrefOrder();
+		TUint zoneFreePages = 0;
+		index = gZoneCount - 1;
+		for (; index > 0; index--)
+			{
+			TUint prefIndex = gPrefArray[index];
+			zoneFreePages = gZoneUtilArray[prefIndex].iFreePages;
+			if (zoneFreePages > 2)
+				{
+				index = prefIndex;
+				zonesFound = ETrue;
+				break;
+				}
+			}
+		if (!zonesFound)
+			{
+			test.Printf(_L("Cannot find RAM zones to perform test, Skipping test step...\n"));
+			}
+		else
+			{
+			// Fill the RAM with DP cache pages and up the minimum cache size so
+			// that the allocation will fail.
+			TInt discardBytes;
+			TInt r = AllocDiscardable(discardBytes, KMaxTUint64, (zoneFreePages - 1) << gPageShift);
+			test_KErrNone(r);
+			// Ensure that the RAM zone under test is full.
+			GetAllPageInfo();
+			if (gZoneUtilArray[index].iFreePages != 0)
+				{
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			r = Ldd.ZoneAllocDiscontiguous(gZoneConfigArray[index].iZoneId, zoneFreePages);
+			if (r != KErrNoMemory)
+				{
+				CLEANUP(Ldd.FreeAllFixedPages());
+				TEST_FAIL;
+				}
+			else
+				{
+				test.Printf(_L("Passed...\n"));
+				}
+			}
+		TestEnd();
+		test.Next(_L("Test7: Test Epoc::ZoneAllocPhysicalRam() replaces DP cache when DP minimum cache size is hit"));
+		TestStart();
+		gChunkArray1 = new RChunk;
+		gChunkArraySize1 = 1;
+		GetPrefOrder();
+		zonesFound = EFalse;
+		for (index = gZoneCount - 1; index > 0 && !zonesFound; index--)
+			{
+			TUint prefIndex = gPrefArray[index];
+			zoneFreePages = gZoneUtilArray[prefIndex].iFreePages;
+			if (zoneFreePages > 1)
+				{
+				// Check there is at least one free page in the other RAM zones.
+				TUint i = 0;
+				for (; i < gZoneCount; i++)
+					{
+					if (i != prefIndex && gZoneUtilArray[i].iFreePages != 0)
+						{
+						index = prefIndex;
+						zonesFound = ETrue;
+						break;
+						}
+					}
+				}
+			}
+		if (!zonesFound)
+			{
+			test.Printf(_L("Cannot find RAM zones to perform test, Skipping test step...\n"));
+			}
+		else
+			{
+			index++;
+			// Attempt to allocate a movable page to create a gap for the DP cache
+			// page to be replaced with.
+			GetOriginalPageCount();
+			r = AllocMovable(gChunkArray1, gChunkArraySize1, 1, gPageSize);
+			GetAllPageInfo();
+			TESTDEBUG(test.Printf(_L("index %d prev free 0x%x cur free 0x%x\n"),
+										index, gOriginalPageCountArray[index].iFreePages, gZoneUtilArray[index].iFreePages));
+			if (r != KErrNone ||
+				gOriginalPageCountArray[index].iFreePages != gZoneUtilArray[index].iFreePages)
+				{// The gap was allocated into the RAM zone under test so can't continue as
+				// the DP cache will attempt to be reallocated into the same RAM zone.
+				test.Printf(_L("Cannot find RAM zones to perform test, Skipping test step...\n"));
+				}
+			else
+				{
+				// Get the ldd to create the array for the fixed page addresses here
+				// so that any kernel heap allocations have already occurred before
+				// memory is filled etc.  Make allocation really large so it will always be enough.
+				r = Ldd.AllocFixedArray(50);
+				// Fill RAM with DP cache pages and free the gap.
+				TInt discardBytes;
+				r = AllocDiscardable(discardBytes, KMaxTUint64, 0);
+				if (r != KErrNone)
+					{
+					CLEANUP(ResetDPCache());
+					TEST_FAIL;
+					}
+				UpdateRamInfo();
+				TInt prevFreeBytes = gFreeRam;
+				RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+				UpdateRamInfo();
+				TInt freedPages = (gFreeRam - prevFreeBytes) >> gPageShift;
+				if (freedPages < 1)
+					{// Something went wrong as should have freed at least one page
+					CLEANUP(ResetDPCache());
+					TEST_FAIL;
+					}
+				TUint extraFreePages = freedPages - 1;
+				// Ensure that the RAM zone under test is full.
+				GetAllPageInfo();
+				if (gZoneUtilArray[index].iFreePages != 0)
+					{
+					CLEANUP(ResetDPCache());
+					TEST_FAIL;
+					}
+				// Allocate from the RAM zone which should force a DP cache
+				// page to be allocated.
+				GetOriginalPageCount();
+				TUint fixedAllocPages = 1 + extraFreePages;
+				r = Ldd.ZoneAllocDiscontiguous2(gZoneConfigArray[index].iZoneId, fixedAllocPages);
+				GetAllPageInfo();
+				if (r != KErrNone ||
+					gOriginalPageCountArray[index].iAllocFixed + fixedAllocPages != gZoneUtilArray[index].iAllocFixed)
+					{
+					test.Printf(_L("r %d index %d alloc 0x%x prevFixed 0x%x curFixed 0x%x\n"), r, index, fixedAllocPages,
+								gOriginalPageCountArray[index].iAllocFixed, gZoneUtilArray[index].iAllocFixed);
+					CLEANUP(Ldd.FreeAllFixedPages());
+					TEST_FAIL;
+					}
+				else
+					{
+					test.Printf(_L("Passed...\n"));
+					}
+				}
+			}
+		// This should cleanup any fixed pages allocated.
+		TestEnd();
+		}
+	test.Next(_L("Test8: Test Epoc::ZoneAllocPhysicalRam() return KErrNoMemory when appropriate"));
+	TestStart();
+	// Search for a RAM zone that has some immovable pages allocated into
+	// it but isn't totally full.
+	GetAllPageInfo();
+	zonesFound = EFalse;
+	for (index = 0; index < gZoneCount; index++)
+		{
+		if (gZoneUtilArray[index].iFreePages &&
+			(gZoneUtilArray[index].iAllocUnknown || gZoneUtilArray[index].iAllocFixed))
+			{
+			zonesFound = ETrue;
+			break;
+			}
+		}
+	if (!zonesFound)
+		{
+		test.Printf(_L("Cannot find RAM zones to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		// Attempt to allocate the whole RAM zone.
+		r = Ldd.ZoneAllocDiscontiguous(gZoneConfigArray[index].iZoneId, gZoneUtilArray[index].iPhysPages);
+		if (r != KErrNoMemory)
+			{
+			test.Printf(_L("FAIL: r %d index %d\n"), r, index);
+			CLEANUP(Ldd.FreeAllFixedPages());
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	TestEnd();
+	test.Next(_L("Test9: Test Epoc::ZoneAllocPhysicalRam() moves the required number of movable pages"));
+	TestStart();
+	TUint allocFixedPages;
+	// Search for a RAM zone that has at least 2 movable pages allocated into it.
+	// Need 2 so that we can move one and leave one.
+	GetAllPageInfo();
+	zonesFound = EFalse;
+	for (index = 0; index < gZoneCount; index++)
+		{
+		if (gZoneUtilArray[index].iAllocMovable > 1)
+			{
+			// Only use this zone if the other RAM zones have enough free space for
+			// the movable page in this zone to be moved to.
+			TUint freeInOther = 0;
+			for (TUint i = 0; i < gZoneCount && !zonesFound; i++)
+				{
+				if (i != index)
+					{
+					freeInOther += gZoneUtilArray[i].iFreePages;
+					}
+				}
+			if (freeInOther >= gZoneUtilArray[index].iAllocMovable)
+				{
+				zonesFound = ETrue;
+				break;
+				}
+			}
+		}
+	if (!zonesFound)
+		{
+		test.Printf(_L("No suitable RAM zone could be found - Skipping...\n"));
+		goto skipTest9;
+		}
+	// Allocate up to one less than the RAM zone size. Do 2 stage fixed allocation
+	// to avoid kernel heap allocations spoiling test setup.
+	r = Ldd.AllocFixedArray(gZoneConfigArray[index].iPhysPages);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("Not enough free RAM to perform test - Skipping...\n"));
+		goto skipTest9;
+		}
+	GetAllPageInfo();
+	if (gZoneUtilArray[index].iAllocMovable < 2)
+		{
+		test.Printf(_L("Expanding kernel heap for phys address array spoiled RAM zone - Skipping...\n"));
+		goto skipTest9;
+		}
+	allocFixedPages =	gZoneUtilArray[index].iAllocMovable +
+						gZoneUtilArray[index].iAllocDiscardable +
+						gZoneUtilArray[index].iFreePages - 1;
+	r = Ldd.ZoneAllocDiscontiguous2(gZoneConfigArray[index].iZoneId, allocFixedPages);
+	if (r != KErrNone || !gZoneUtilArray[index].iAllocMovable)
+		{
+		test.Printf(_L("Fixed not allocated or too many movable moved RAM zone ID%x\n"),
+					gZoneConfigArray[index].iZoneId);
+		CLEANUP(Ldd.FreeAllFixedPages());
+		TEST_FAIL;
+		}
+skipTest9 :
+	// This will clean up any fixed pages allocated.
+	TestEnd();
+	delete[] zoneIdArray;
+	test.Next(_L("Test10: Test Epoc::ZoneAllocPhysicalRam() (Discontiguous) doesn't affect the allocation of movable pages"));
+	r = TestZoneAllocNoAffect(Z_ALLOC_DISC, BEST_MOVABLE);
+	if (r != KErrNone)
+		{
+		TEST_FAIL;
+		}
+	test.Next(_L("Test11: Test Epoc::ZoneAllocPhysicalRam() (Discontiguous) doesn't affect the allocation of discardable pages"));
+	r = TestZoneAllocNoAffect(Z_ALLOC_DISC, BEST_DISCARDABLE);
+	if (r != KErrNone)
+		{
+		TEST_FAIL;
+		}
+	test.End();
+	return KErrNone;
+	}
+//
+// TestFreeZone
+//
+//---------------------------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID				KBASE-t_ramdefrag-0537
+//! @SYMTestType				CIT
+//! @SYMTestCaseDesc			Verifying the function Epoc::FreePhysicalRam()
+//! @SYMPREQ					PREQ308
+//! @SYMTestPriority			High
+//! @SYMTestActions
+//! 	1.	Allocate fixed pages and call function to free all fixed pages allocated.
+//!
+//! @SYMTestExpectedResults
+//! 	1.	KErrNone
+//---------------------------------------------------------------------------------------------------------------------
+TInt TestFreeZone()
+	{
+	TInt r = 0;
+	TUint zoneID = 0;
+	test.Start(_L("Test1: Free allocated pages"));
+	TestStart();
+	TInt pages = 50;
+	GetAllPageInfo();
+	TUint index = gZoneCount - 1;
+	while (index > 0 &&
+			(gZoneUtilArray[index].iAllocFixed != 0 ||
+			gZoneUtilArray[index].iAllocUnknown != 0 ||
+			(TInt)gZoneUtilArray[index].iFreePages < pages))
+		{
+		-- index;
+		}
+	zoneID = gZoneConfigArray[index].iZoneId;
+	if (index == 0 &&
+		(gZoneUtilArray[index].iAllocFixed != 0 ||
+		gZoneUtilArray[index].iAllocUnknown != 0 ||
+		(TInt)gZoneUtilArray[index].iFreePages < pages))
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		TESTDEBUG(test.Printf(_L("Allocating 0x%x pages to zone ID 0x%x\n"), pages, zoneID));
+		r = Ldd.ZoneAllocDiscontiguous(zoneID, pages);
+		GetAllPageInfo();
+		TESTDEBUG(test.Printf(_L("Freeing 0x%x fixed pages\n"), pages));
+		if (r == KErrNone)
+			{
+			r = Ldd.FreeZone(pages);
+			}
+		TESTDEBUG(test.Printf(_L("r = %d\n"), r));
+		if (r == KErrNone)
+			{
+			test.Printf(_L("Pass: Correct return value\n"));
+			}
+		else
+			{
+			test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrNone);
+			TEST_FAIL;
+			}
+		}
+	TestEnd();
+	test.End();
+	return KErrNone;
+	}
+//
+// TestDefragSemMethod
+//
+//---------------------------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID				KBASE-t_ramdefrag-0538
+//! @SYMTestType				CIT
+//! @SYMTestCaseDesc			Verifying the semaphore versions of the various defrag methods
+//! @SYMPREQ					PREQ308
+//! @SYMTestPriority			High
+//! @SYMTestActions
+//! 	1.	Fragment the memory. Following this, call the semaphore variation of DefragRam.
+//! 	2.	Fragment the memory. Following this, call the semaphore variation of EmptyRamZone
+//! 	3.	Fragment the memory. Following this, call the semaphore variation of ClaimRamZone
+//!
+//! @SYMTestExpectedResults
+//! 	1.	1 or more zones have been emptied
+//! 	2.	Zone specified has been emptied
+//! 	3.	Zone has been claimed
+//---------------------------------------------------------------------------------------------------------------------
+TInt TestDefragSemMethod()
+	{
+	TInt r = 0;
+	test.Start(_L("Test1: Call semaphore method of DefragRam"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetOriginalPageCount();
+	TBool genSucceed = CanGenSucceed();
+	r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SEM);
+	if (r != KErrNone ||(genSucceed && CheckZonesSwitchedOff() == EFalse))
+		{
+		test.Printf(_L("Fail: r = %d, or zones have not been swtiched off\n"), r);
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test2: Call semaphore method of EmptyRamZone"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	TUint index = gZoneCount - 1;
+	while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		-- index;
+		}
+	TUint defragZoneID = gZoneConfigArray[index].iZoneId;
+	if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SEM, defragZoneID);
+		GetAllPageInfo();
+		TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+		if (freeInOthers && (r != KErrNone || !CheckZoneIsOff(index)))
+			{
+			test.Printf(_L("Fail: r = %d, or zones has not been swtiched off\n"), r);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	// This will free any allocated memory.
+	TestEnd();
+	test.Next(_L("Test3: Call semaphore method of ClaimRamZone"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	index = gZoneCount - 2;
+	while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		-- index;
+		}
+	defragZoneID = gZoneConfigArray[index].iZoneId;
+	if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SEM, defragZoneID);
+		GetAllPageInfo();
+		TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+		if (CheckZoneIsOff(index) ||
+			(freeInOthers && ( r != KErrNone ||
+			gZoneUtilArray[index].iAllocFixed != gZoneConfigArray[index].iPhysPages)))
+			{
+			test.Printf(_L("Fail: r = %d, or zone ID 0x%x has not been claimed\n"), r, defragZoneID);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		r = Ldd.FreeAllFixedPages();
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.End();
+	return KErrNone;
+	}
+//
+// TestDefragDfcMethod
+//
+//---------------------------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID				KBASE-t_ramdefrag-0539
+//! @SYMTestType				CIT
+//! @SYMTestCaseDesc			Verifying the Dfc versions of the various defrag methods
+//! @SYMPREQ					PREQ308
+//! @SYMTestPriority			High
+//! @SYMTestActions
+//! 	1.	Fragment the memory. Following this, call the Dfc variation of DefragRam.
+//! 	2.	Fragment the memory. Following this, call the Dfc variation of EmptyRamZone
+//! 	3.	Fragment the memory. Following this, call the Dfc variation of ClaimRamZone
+//!
+//! @SYMTestExpectedResults
+//! 	1.	1 or more zones have been emptied
+//! 	2.	Zone specified has been emptied
+//! 	3.	Zone has been claimed
+//---------------------------------------------------------------------------------------------------------------------
+TInt TestDefragDfcMethod()
+	{
+	TInt r = 0;
+	TRequestStatus req;
+	test.Start(_L("Test1: Call Dfc method of DefragRam"));
+	TestStart();
+	GetAllPageInfo();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetOriginalPageCount();
+	TBool genSucceed = CanGenSucceed();
+	r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_DFC, 0, 0, -1, &req);
+	TESTDEBUG(test.Printf(_L("After queueing defrag r = %d\n"), r));
+	User::WaitForRequest(req);
+	r = req.Int();
+	if (r != KErrNone || (genSucceed && CheckZonesSwitchedOff() == EFalse))
+		{
+		test.Printf(_L("Fail: r = %d, or zones have not been swtiched off\n"), r);
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test2: Call Dfc method of EmptyRamZone"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	TUint index = gZoneCount - 1;
+	while (index > 0 &&
+			(gZoneUtilArray[index].iAllocMovable < 10 ||
+			gZoneUtilArray[index].iAllocFixed != 0 ||
+			gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		-- index;
+		}
+	TUint defragZoneID = gZoneConfigArray[index].iZoneId;
+	test.Printf(_L("zone ID = 0x%x\n"), defragZoneID);
+	if (index == 0 &&
+		(gZoneUtilArray[index].iAllocMovable < 10 ||
+		gZoneUtilArray[index].iAllocFixed != 0 ||
+		gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_DFC, defragZoneID, 0, -1, &req);
+		User::WaitForRequest(req);
+		r = req.Int();
+		GetAllPageInfo();
+		TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+		if (freeInOthers && (r != KErrNone || CheckZoneIsOff(index) == EFalse))
+			{
+			test.Printf(_L("Fail: r = %d, or zones have not been swtiched off\n"), r);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	// This will free any allocated memory
+	TestEnd();
+	test.Next(_L("Test3: Call Dfc method of ClaimRamZone"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	index = gZoneCount - 1;
+	while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		-- index;
+		}
+	defragZoneID = gZoneConfigArray[index].iZoneId;
+	if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
+		}
+	else
+		{
+		r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_DFC, defragZoneID, 0, -1, &req);
+		User::WaitForRequest(req);
+		r = req.Int();
+		GetAllPageInfo();
+		TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+		if (CheckZoneIsOff(index) ||
+			(freeInOthers && (r != KErrNone ||
+			gZoneUtilArray[index].iAllocFixed != gZoneConfigArray[index].iPhysPages)))
+			{
+			test.Printf(_L("Fail: r = %d, or zone ID 0x%x has not been claimed\n"), r, defragZoneID);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			if (r == KErrNone)
+				{
+				CLEANUP(Ldd.FreeFromAddr(	gZoneUtilArray[index].iAllocFixed,
+											gZoneConfigArray[index].iPhysBase));
+				}
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		if (r == KErrNone)
+			{
+			Ldd.FreeFromAddr(	gZoneUtilArray[index].iAllocFixed,
+								gZoneConfigArray[index].iPhysBase);
+			}
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.End();
+	return KErrNone;
+	}
+//
+// TestPriorities
+//
+//---------------------------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID				KBASE-t_ramdefrag-0540
+//! @SYMTestType				CIT
+//! @SYMTestCaseDesc			Verifying the priorities of the defrag methods
+//! @SYMPREQ					PREQ308
+//! @SYMTestPriority			High
+//! @SYMTestActions
+//! 	1.	Call DefragRam with a lower invalid priority value, e.g. -2
+//! 	2.	Call DefragRam with a lower invalid priority value, e.g. 100
+//! 	3.	Queue three asynchronous defrags using the Dfc method:
+//! 			a.	First one with the lowest priority, this will start the straight away
+//! 				and will busy the defrag method, causing any other defrag requests to
+//! 				be queued.
+//! 			b.	Queue a defrag with a relatively low priority
+//! 			c.	Queue a defrag with a higher priority than the one queued in (b)
+//! 		Record the order in which the defrags are completed
+//!
+//! @SYMTestExpectedResults
+//! 	1.	KErrArgument
+//! 	2.	KErrArgument
+//! 	3.	(a) will complete first as it started straight away.
+//! 		(b) and (c) were both queued whilst (a) was running,
+//! 		however as (c) has a higher priority, it will complete first -
+//! 		therefore the order returned would be "a,c,b"
+//---------------------------------------------------------------------------------------------------------------------
+TInt TestPriorities()
+	{
+	test.Start(_L("Test1: Call defrag with an invalid lower priority"));
+	TestStart();
+	TInt r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, 0, -2);
+	TESTDEBUG(test.Printf(_L("r = %d\n"), r));
+	if (r != KErrArgument)
+		{
+		test.Printf(_L("Fail: r = %d, not expected\n"), r);
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+	TestEnd();
+	test.Next(_L("Test2: Call defrag with an invalid higher priority"));
+	TestStart();
+	r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, 0, 100);
+	TESTDEBUG(test.Printf(_L("r = %d\n"), r));
+	if (r != KErrArgument)
+		{
+		test.Printf(_L("Fail: r = %d, not expected\n"), r);
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+	TestEnd();
+	if (UserSvr::HalFunction(EHalGroupKernel, EKernelHalNumLogicalCpus, 0, 0) == 1)
+		{// Only test priorities on single core system as this test is not smp safe.
+		test.Next(_L("Test3: Call Dfc method of EmptyRamZone to test priorities"));
+		TestStart();
+		TRequestStatus req;
+		TRequestStatus req2;
+		TRequestStatus req3;
+		TInt expectedOrder = 132; // Priorities set in Device driver
+		AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+		FreeMovable(gChunkArray1, gChunkArraySize1);
+		TUint index = (gZoneCount + 1) / 2;
+		TUint defragZoneID = gZoneConfigArray[index].iZoneId;
+		r = Ldd.CheckPriorities(DEFRAG_TYPE_EMPTY, defragZoneID, &req, &req2, &req3);
+		User::WaitForRequest(req);
+		User::WaitForRequest(req2);
+		User::WaitForRequest(req3);
+		TInt order = Ldd.GetDefragOrder();
+		if (order != expectedOrder)
+			{
+			test.Printf(_L("Fail: order = %d. expected = %d\n"), order, expectedOrder);
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		// This will free any allocated memory
+		TestEnd();
+		}
+	test.End();
+	return KErrNone;
+	}
+//
+// TestFlags
+//
+//---------------------------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID				KBASE-t_ramdefrag-0541
+//! @SYMTestType				CIT
+//! @SYMTestCaseDesc			Verifying that when certain flags are set,
+//! 							only certain types of pages can be allocated to the zone.
+//! @SYMPREQ					PREQ308
+//! @SYMTestPriority			High
+//! @SYMTestActions
+//! 	1.	Set the NoFixed flag in a zone and allocate movable pages
+//! 	2.	Set the NoFixed flag in a zone and allocate fixed pages
+//! 	3.	Set the NoFixed flag in a zone and allocate discardable pages
+//! 	4.	Set the NoFixed flag in a zone and allocate fixed pages to that zone using Epoc::ZoneAllocPhysicalRam()
+//! 	5.	Set the NoFixed flag in a zone and allocate fixed pages by calling TRamDefragRequest::ClaimRamZone()
+//! 	6.	Set the NoMovable flag in a zone and allocate movable pages
+//! 	7.	Set the NoMovable flag in a zone and allocate fixed pages
+//! 	8.	Set the NoMovable flag in a zone and allocate discardable pages
+//! 	9.	Set the NoDiscardable flag in a zone and allocate movable pages
+//! 	10.	Set the NoDiscardable flag in a zone and allocate fixed pages
+//! 	11.	Set the NoDiscardable flag in a zone and allocate discardable pages
+//! 	12.	Set the OnlyDiscardable flag in a zone and allocate movable pages
+//! 	13.	Set the OnlyDiscardable flag in a zone and allocate fixed pages
+//! 	14.	Set the OnlyDiscardable flag in a zone and allocate discardable pages
+//! 	15.	Set the OnlyDiscardable flag in a zone and allocate fixed pages to that zone using Epoc::ZoneAllocPhysicalRam()
+//! 	16.	Set the OnlyDiscardable flag in a zone and allocate fixed pages by calling TRamDefragRequest::ClaimRamZone()
+//! 	17.	Set the NoFurtherAlloc flag in a zone and allocate movable pages
+//! 	18.	Set the NoFurtherAlloc flag in a zone and allocate fixed pages
+//! 	19.	Set the NoFurtherAlloc flag in a zone and allocate discardable pages
+//! 	20.	Set the NoFurtherAlloc flag in a zone and allocate fixed pages to that zone using Epoc::ZoneAllocPhysicalRam()
+//! 	21.	Set the NoFurtherAlloc flag in a zone and allocate fixed pages by calling TRamDefragRequest::ClaimRamZone()
+//!		22.	Set up memory so that the least preferable RAM zone has movable pages + discardable pages > free pages in the most
+//!			preferable zone. Ensure that the discardable pages cannot be discarded and so must be moved. Now set the flag on
+//!			all zones barring the most preferable zone to KRamZoneFlagNoMovable, ensuring that most pref has no flags set.
+//!			Following this call a general defrag.
+//!		23.	Set up memory so that the least preferable RAM zone has movable pages + discardable pages > free pages in the most
+//!			preferable RAM zone. Ensure that the discardable pages cannot be discarded and so must be moved.
+//!			Now set the flag on all zones barring the most preferable zone to KRamZoneFlagNoDiscard, ensuring that
+//!			most preferable RAM zone has no flags set. Following this call a general defrag.
+//!		24. Set up memory so that the least preferable RAM zone has movable pages and discardable pages. Set all the zone
+//!			flags to KRamZoneFlagNoMovable. Following this call a general defrag.
+//!
+//! @SYMTestExpectedResults
+//! 	1.	Movable pages are allocated and no fixed pages allocated
+//! 	2.	No fixed pages have been allocated
+//! 	3.	Discardable pages are allocated and no fixed pages allocated
+//!		4.	KErrNone, flag is ignored with zone specific allocation
+//!		5.	KErrNone, flag is ignored when claiming a zone
+//! 	6.	No movable pages have been allocated
+//! 	7.	Fixed pages allocated, no movable allocated
+//! 	8.	Discardable pages allocated, no movable pages allocated
+//! 	9.	Movable pages allocated, no discardable pages allocated
+//! 	10.	Fixed pages allocated, no discardable allocated
+//! 	11.	No discardable pages allocated
+//! 	12.	No movable pages allocated
+//! 	13.	No fixed pages allocated
+//! 	14.	Discardable pages allocated, no movable or fixed allocated
+//!		15.	KErrNone, flag is ignored with zone specific allocation
+//!		16.	KErrNone, flag is ignored when claiming a zone
+//! 	17.	No moving, fixed or discardable pages allocated
+//! 	18.	No moving, fixed or discardable pages allocated
+//! 	19.	No moving, fixed or discardable pages allocated
+//!		20.	KErrNoMemory, flag is obeyed with zone specific allocation
+//!		21.	KErrNone, flag is ignored when claiming a zone
+//!		22.	Movable pages moved to the most preferable zone, discardable pages moved to next most preferable zone
+//!		23.	Discardable pages moved to most preferable zone, movable pages moved to next next most preferable zone
+//!		24.	No pages are moved from the least preferable zone zone
+//---------------------------------------------------------------------------------------------------------------------
+TInt TestFlags()
+	{
+	TInt r = 0;
+	TUint zoneDefragID = 0;
+	test.Start(_L("Test1: No Fixed Flag, Alloc Movable"));
+	TestStart();
+	TInt index = GetBestZone(BEST_MOVABLE);
+	if (index == KErrNotFound)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+		}
+	else
+		{
+		zoneDefragID = gZoneConfigArray[index].iZoneId;
+		if (SpaceAvailForPageTables(index, KFillAllMovable))
+			{
+			GetOriginalPageCount();
+			r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_FIXED_FLAG);
+			test_KErrNone(r);
+			AllocMovable(gChunkArray1, gChunkArraySize1, KFillAllMovable);
+			GetAllPageInfo();
+			if (gZoneUtilArray[index].iAllocMovable == gOriginalPageCountArray[index].iAllocMovable ||
+				gZoneUtilArray[index].iAllocFixed > gOriginalPageCountArray[index].iAllocFixed)
+				{
+				test.Printf(_L("Fail: Either fixed pages have been allocated or movable pages have not been allocated to zone ID %x\n"), gZoneConfigArray[index].iZoneId);
+				CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+				TEST_FAIL;
+				}
+			else
+				{
+				test.Printf(_L("Passed...\n"));
+				}
+			}
+		else
+			{
+			test.Printf(_L("Skipping...\n"));
+			}
+		}
+	TestEnd();
+	test.Next(_L("Test2: No Fixed Flag, Alloc Fixed"));
+	TestStart();
+	if(gPagedRom)
+		{
+		r = DPTest::SetCacheSize(gOriginalMinCacheSize, gOriginalMinCacheSize);
+		test_KErrNone(r);
+		}
+	// find a zone that has free pages in it to block it
+	GetAllPageInfo();
+	TUint i = 0;
+	for (; i < gZoneCount; i++)
+		{
+		if (gZoneUtilArray[i].iFreePages > 0)
+			{
+			index = i;
+			break;
+			}
+		}
+	if (i == gZoneCount)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+		}
+	else
+		{
+		zoneDefragID = gZoneConfigArray[index].iZoneId;
+		r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_FIXED_FLAG);
+		test_KErrNone(r);
+		GetOriginalPageCount();
+		r = Ldd.AllocateFixed(FILL_ALL_FIXED);
+		GetAllPageInfo();
+		// Ensure that either zone does not contain extra fixed pages
+		if (gZoneUtilArray[index].iAllocFixed > gOriginalPageCountArray[index].iAllocFixed)
+			{
+			test.Printf(_L("Fail: Fixed pages have been allocated into the zone ID 0x%x r = %d\n"), zoneDefragID, r);
+			CLEANUP(Ldd.FreeAllFixedPages());
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	TestEnd();
+	test.Next(_L("Test3: No Fixed Flag, Alloc Discardable"));
+	TestStart();
+	if (gPagedRom)
+		{
+		index = GetBestZone(BEST_DISCARDABLE);
+		if (index == KErrNotFound)
+			{
+			test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+			}
+		else
+			{
+			zoneDefragID = gZoneConfigArray[index].iZoneId;
+			GetOriginalPageCount();
+			r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_FIXED_FLAG);
+			test_KErrNone(r);
+			UpdateRamInfo();
+			TInt discardablePages;
+			r = AllocDiscardable(discardablePages);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+				TEST_FAIL;
+				}
+			GetAllPageInfo();
+			if (gZoneUtilArray[index].iAllocFixed > gOriginalPageCountArray[index].iAllocFixed)
+				{
+				test.Printf(_L("Fail: Fixed pages have been allocated\n"));
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			else
+				{
+				test.Printf(_L("Passed...\n"));
+				}
+			}
+		}
+	else
+		{
+		test.Printf(_L("Not a paged ROM - Skipping test step\n"));
+		}
+	TestEnd();
+	test.Next(_L("Test4: No Fixed Flag, Alloc Fixed using ZoneAllocPhyicalRam"));
+	TestStart();
+	index = GetBestZone(BEST_FIXED);
+	if (index == KErrNotFound)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+		}
+	else
+		{
+		zoneDefragID = gZoneConfigArray[index].iZoneId;
+		GetOriginalPageCount();
+		r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_FIXED_FLAG);
+		test_KErrNone(r);
+		// Just need to try and allocate one page
+		r = Ldd.ZoneAllocDiscontiguous(zoneDefragID, 1);
+		GetAllPageInfo();
+		if (r != KErrNone)
+			{
+			test.Printf(_L("Fail: Fixed pages have not been allocated into the zone\n"));
+			CLEANUP(Ldd.FreeAllFixedPages());
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	TestEnd();
+	test.Next(_L("Test5: No Fixed Flag, Alloc Fixed by attempting to claim zone"));
+	TestStart();
+	GetAllPageInfo();
+	index = 0;
+	while ((TUint)index < gZoneCount && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		index++;
+		}
+	if ((TUint)index == gZoneCount)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+		}
+	else
+		{
+		zoneDefragID = gZoneConfigArray[index].iZoneId;
+		r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_FIXED_FLAG);
+		test_KErrNone(r);
+		r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, zoneDefragID);
+		GetAllPageInfo();
+		TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+		if (freeInOthers && r != KErrNone)
+			{
+			test.Printf(_L("Fail: Claim zone ID 0x%x was unsuccessful, r = %d\n"), zoneDefragID, r);
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	TestEnd();
+//------------------------------------------------------------
+	test.Next(_L("Test6: No Movable Flag, Alloc Movable"));
+	TestStart();
+	index = GetBestZone(BEST_MOVABLE);
+	if (index == KErrNotFound)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+		}
+	else
+		{
+		zoneDefragID = gZoneConfigArray[index].iZoneId;
+		GetOriginalPageCount();
+		r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_MOVE_FLAG);
+		test_KErrNone(r);
+		AllocMovable(gChunkArray1, gChunkArraySize1, KFillAllMovable, KChunkDefaultSize, EFalse);
+		GetAllPageInfo();
+		if (gZoneUtilArray[index].iAllocMovable >  gOriginalPageCountArray[index].iAllocMovable)
+			{
+			test.Printf(_L("Fail: Movable pages have been allocated in the zone\n"));
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	TestEnd();
+	test.Next(_L("Test7: No Movable Flag, Alloc Fixed"));
+	TestStart();
+	if(gPagedRom)
+		{
+		r = DPTest::SetCacheSize(gOriginalMinCacheSize, gOriginalMinCacheSize);
+		test_KErrNone(r);
+		}
+	index = GetBestZone(BEST_FIXED);
+	if (index == KErrNotFound)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+		}
+	else
+		{
+		zoneDefragID = gZoneConfigArray[index].iZoneId;
+		r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_MOVE_FLAG);
+		test_KErrNone(r);
+		GetOriginalPageCount();
+		// Fill up all of RAM with fixed pages.
+		r = Ldd.AllocateFixed(FILL_ALL_FIXED);
+		test.Printf(_L("r = %d\n"), r);
+		GetAllPageInfo();
+		if (gZoneUtilArray[index].iAllocMovable > gOriginalPageCountArray[index].iAllocMovable ||
+			gZoneUtilArray[index].iAllocFixed <= gOriginalPageCountArray[index].iAllocFixed)
+			{
+			test.Printf(_L("Fail: orig mov 0x%x fix 0x%x current mov 0x%x fix 0x%x\n"), gOriginalPageCountArray[index].iAllocMovable,
+						gOriginalPageCountArray[index].iAllocFixed, gZoneUtilArray[index].iAllocMovable, gZoneUtilArray[index].iAllocFixed);
+			CLEANUP(Ldd.FreeAllFixedPages());
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	TestEnd();
+	test.Next(_L("Test8: No Movable Flag, Alloc Discardable"));
+	TestStart();
+	if (gPagedRom)
+		{
+		index = GetBestZone(BEST_DISCARDABLE);
+		if (index == KErrNotFound)
+			{
+			test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+			}
+		else
+			{
+			zoneDefragID = gZoneConfigArray[index].iZoneId;
+			GetOriginalPageCount();
+			r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_MOVE_FLAG);
+			test_KErrNone(r)
+			UpdateRamInfo();
+			TInt discardablePages;
+			r = AllocDiscardable(discardablePages);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+				TEST_FAIL;
+				}
+			GetAllPageInfo();
+			if (gZoneUtilArray[index].iAllocMovable > gOriginalPageCountArray[index].iAllocMovable)
+				{
+				test.Printf(_L("Fail: Movable pages have been allocated into the zone \n"));
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			else
+				{
+				test.Printf(_L("Passed...\n"));
+				}
+			}
+		}
+	else
+		{
+		test.Printf(_L("Not a paged ROM - Skipping test step\n"));
+		}
+	TestEnd();
+//-----------------------------------------------------------------------------------------------
+	test.Next(_L("Test9: No Discardable Flag, Alloc Movable"));
+	TestStart();
+	index = GetBestZone(BEST_MOVABLE);
+	if (index == KErrNotFound)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+		}
+	else
+		{
+		zoneDefragID = gZoneConfigArray[index].iZoneId;
+		GetOriginalPageCount();
+		r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_DISCARD_FLAG);
+		test_KErrNone(r);
+		AllocMovable(gChunkArray1, gChunkArraySize1, KFillAllMovable);
+		GetAllPageInfo();
+		if (gZoneUtilArray[index].iAllocDiscardable > gOriginalPageCountArray[index].iAllocDiscardable ||
+			(gZoneUtilArray[index].iAllocMovable <=  gOriginalPageCountArray[index].iAllocMovable &&
+			gZoneUtilArray[index].iAllocFixed ==  gOriginalPageCountArray[index].iAllocFixed))
+			{
+			test.Printf(_L("Fail: Either discardable pages have been allocated or movable pages have not been allocated\n"));
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	TestEnd();
+	test.Next(_L("Test10: No Discardable Flag, Alloc Fixed"));
+	TestStart();
+	if(gPagedRom)
+		{
+		r = DPTest::SetCacheSize(gOriginalMinCacheSize, gOriginalMinCacheSize);
+		test_KErrNone(r);
+		}
+	index = GetBestZone(BEST_FIXED);
+	if (index == KErrNotFound)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+		}
+	else
+		{
+		zoneDefragID = gZoneConfigArray[index].iZoneId;
+		GetOriginalPageCount();
+		r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_DISCARD_FLAG);
+		test_KErrNone(r);
+		// Fill up all of RAM with fixed pages.
+		r = Ldd.AllocateFixed(FILL_ALL_FIXED);
+		GetAllPageInfo();
+		if (gZoneUtilArray[index].iAllocDiscardable > gOriginalPageCountArray[index].iAllocDiscardable ||
+			gZoneUtilArray[index].iAllocFixed <= gOriginalPageCountArray[index].iAllocFixed)
+			{
+			test.Printf(_L("Fail: Discardable pages have been allocated or fixed pages have not been allocated\n"));
+			CLEANUP(Ldd.FreeAllFixedPages());
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	TestEnd();
+	test.Next(_L("Test11: No Discardable Flag, Alloc Discardable"));
+	TestStart();
+	if (gPagedRom)
+		{
+		index = GetBestZone(BEST_DISCARDABLE);
+		if (index == KErrNotFound)
+			{
+			test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+			}
+		else
+			{
+			zoneDefragID = gZoneConfigArray[index].iZoneId;
+			GetOriginalPageCount();
+			r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_DISCARD_FLAG);
+			test_KErrNone(r);
+			UpdateRamInfo();
+			TInt discardablePages;
+			r = AllocDiscardable(discardablePages);
+			if (r != KErrNoMemory)
+				{// Allocation should fail as no dis flag is set
+				test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+				TEST_FAIL;
+				}
+			GetAllPageInfo();
+			if (gZoneUtilArray[index].iAllocDiscardable > gOriginalPageCountArray[index].iAllocDiscardable)
+				{
+				test.Printf(_L("Fail: Discardable pages have been allocated into the zone\n"));
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			else
+				{
+				test.Printf(_L("Passed...\n"));
+				}
+			}
+		}
+	else
+		{
+		test.Printf(_L("Not a paged ROM - Skipping test step\n"));
+		}
+	TestEnd();
+//-----------------------------------------------------------------------------------------------
+	test.Next(_L("Test12: Only Discardable Flag, Alloc Movable"));
+	TestStart();
+	index = GetBestZone(BEST_MOVABLE);
+	if (index == KErrNotFound)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+		}
+	else
+		{
+		zoneDefragID = gZoneConfigArray[index].iZoneId;
+		GetOriginalPageCount();
+		r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, ONLY_DISCARD_FLAG);
+		test_KErrNone(r);
+		AllocMovable(gChunkArray1, gChunkArraySize1, KFillAllMovable, KChunkDefaultSize, EFalse);
+		GetAllPageInfo();
+		if (gZoneUtilArray[index].iAllocMovable > gOriginalPageCountArray[index].iAllocMovable)
+			{
+			test.Printf(_L("Fail: Movable pages have been allocated\n"));
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	TestEnd();
+	test.Next(_L("Test13: Only Discardable Flag, Alloc Fixed"));
+	TestStart();
+	if(gPagedRom)
+		{
+		r = DPTest::SetCacheSize(gOriginalMinCacheSize, gOriginalMinCacheSize);
+		test_KErrNone(r);
+		}
+	index = GetBestZone(BEST_FIXED);
+	if (index == KErrNotFound)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+		}
+	else
+		{
+		zoneDefragID = gZoneConfigArray[index].iZoneId;
+		GetOriginalPageCount();
+		r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, ONLY_DISCARD_FLAG);
+		test_KErrNone(r);
+		// Fill up all of RAM with fixed pages.
+		r = Ldd.AllocateFixed(FILL_ALL_FIXED);
+		GetAllPageInfo();
+		if (gZoneUtilArray[index].iAllocFixed > gOriginalPageCountArray[index].iAllocFixed)
+			{
+			test.Printf(_L("Fail: Fixed pages have been allocated\n"));
+			CLEANUP(Ldd.FreeAllFixedPages());
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	TestEnd();
+	test.Next(_L("Test14: Only Discardable Flag, Alloc Discardable"));
+	TestStart();
+	if (gPagedRom)
+		{
+		index = GetBestZone(BEST_DISCARDABLE);
+		if (index == KErrNotFound)
+			{
+			test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+			}
+		else
+			{
+			zoneDefragID = gZoneConfigArray[index].iZoneId;
+			GetOriginalPageCount();
+			r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, ONLY_DISCARD_FLAG);
+			test_KErrNone(r);
+			UpdateRamInfo();
+			TInt discardablePages;
+			r = AllocDiscardable(discardablePages);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+				TEST_FAIL;
+				}
+			GetAllPageInfo();
+			if (gZoneUtilArray[index].iAllocMovable > gOriginalPageCountArray[index].iAllocMovable ||
+				gZoneUtilArray[index].iAllocFixed > gOriginalPageCountArray[index].iAllocFixed)
+				{
+				test.Printf(_L("Fail: Pages other than discardable have been allocated\n"));
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			else
+				{
+				test.Printf(_L("Passed...\n"));
+				}
+			}
+		}
+	else
+		{
+		test.Printf(_L("Not a paged ROM - Skipping test step\n"));
+		}
+	TestEnd();
+	test.Next(_L("Test15: Only Discardable Flag, Alloc Fixed using ZoneAllocPhyicalRam"));
+	TestStart();
+	index = GetBestZone(BEST_FIXED);
+	if (index == KErrNotFound)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+		}
+	else
+		{
+		zoneDefragID = gZoneConfigArray[index].iZoneId;
+		GetOriginalPageCount();
+		r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, ONLY_DISCARD_FLAG);
+		test_KErrNone(r);
+		// Just need to try and allocate one page
+		r = Ldd.ZoneAllocDiscontiguous(zoneDefragID, 1);
+		GetAllPageInfo();
+		if (r != KErrNone)
+			{
+			test.Printf(_L("Fail: Fixed pages have not been allocated into zone ID 0x%x\n"), zoneDefragID);
+			CLEANUP(Ldd.FreeAllFixedPages());
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	TestEnd();
+	test.Next(_L("Test16: Only Discardable Flag, Alloc Fixed by attempting to claim zone"));
+	TestStart();
+	GetAllPageInfo();
+	index = 0;
+	while ((TUint)index < gZoneCount && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		index++;
+		}
+	if ((TUint)index == gZoneCount)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+		}
+	else
+		{
+		zoneDefragID = gZoneConfigArray[index].iZoneId;
+		r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, ONLY_DISCARD_FLAG);
+		test_KErrNone(r);
+		r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, zoneDefragID);
+		GetAllPageInfo();
+		TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+		if (freeInOthers && r != KErrNone)
+			{
+			test.Printf(_L("Fail: Claim zone ID 0x%x was unsuccessful, r = %d\n"), zoneDefragID, r);
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	TestEnd();
+//-----------------------------------------------------------------------------------------------
+	test.Next(_L("Test17: No further alloc Flag, Alloc Movable"));
+	TestStart();
+	index = GetBestZone(BEST_MOVABLE);
+	if (index == KErrNotFound)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+		}
+	else
+		{
+		zoneDefragID = gZoneConfigArray[index].iZoneId;
+		GetOriginalPageCount();
+		r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_ALLOC_FLAG);
+		test_KErrNone(r);
+		AllocMovable(gChunkArray1, gChunkArraySize1, KFillAllMovable, KChunkDefaultSize, EFalse);
+		GetAllPageInfo();
+		if (gZoneUtilArray[index].iAllocDiscardable > gOriginalPageCountArray[index].iAllocDiscardable ||
+			gZoneUtilArray[index].iAllocMovable >  gOriginalPageCountArray[index].iAllocMovable ||
+			gZoneUtilArray[index].iAllocFixed > gOriginalPageCountArray[index].iAllocFixed)
+			{
+			test.Printf(_L("Fail: Pages been allocated\n"));
+			CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	TestEnd();
+	test.Next(_L("Test18: No further alloc Flag, Alloc Fixed"));
+	TestStart();
+	if(gPagedRom)
+		{
+		r = DPTest::SetCacheSize(gOriginalMinCacheSize, gOriginalMinCacheSize);
+		test_KErrNone(r);
+		}
+	// Find a zone with free pages and set the flag on this zone
+	// as it will ensure that you cannot fill all of free RAM with fixed pages
+	index = KErrNotFound;
+	GetAllPageInfo();
+	for (TUint i = 0; i < gZoneCount; i++)
+		{
+		if (gZoneUtilArray[i].iFreePages != 0)
+			{
+			index = i;
+			break;
+			}
+		}
+	if (index == KErrNotFound)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+		}
+	else
+		{
+		zoneDefragID = gZoneConfigArray[index].iZoneId;
+		r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_ALLOC_FLAG);
+		test_KErrNone(r);
+		GetOriginalPageCount();
+		r = Ldd.AllocateFixed(FILL_ALL_FIXED);
+		// Ensure memory wasn't filled as it should have hit the blocked zone.
+		GetAllPageInfo();
+		if (r != KErrNoMemory || gZoneUtilArray[index].iAllocFixed > gOriginalPageCountArray[index].iAllocFixed)
+			{
+			test.Printf(_L("Fail: orig fix 0x%x current fix 0x%x\n"), gOriginalPageCountArray[index].iAllocFixed, gZoneUtilArray[index].iAllocFixed);
+			CLEANUP(Ldd.FreeAllFixedPages());
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	TestEnd();
+	test.Next(_L("Test19: No further alloc Flag, Alloc Discardable"));
+	TestStart();
+	if (gPagedRom)
+		{
+		index = GetBestZone(BEST_DISCARDABLE);
+		if (index == KErrNotFound)
+			{
+			test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+			}
+		else
+			{
+			zoneDefragID = gZoneConfigArray[index].iZoneId;
+			GetOriginalPageCount();
+			r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_ALLOC_FLAG);
+			test_KErrNone(r);
+			UpdateRamInfo();
+			TInt discardablePages;
+			r = AllocDiscardable(discardablePages);
+			if (r != KErrNoMemory)
+				{// Allocation should fail as no alloc flag is set
+				test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+				TEST_FAIL;
+				}
+			GetAllPageInfo();
+			if (gZoneUtilArray[index].iAllocDiscardable > gOriginalPageCountArray[index].iAllocDiscardable ||
+				gZoneUtilArray[index].iAllocMovable >  gOriginalPageCountArray[index].iAllocMovable ||
+				gZoneUtilArray[index].iAllocFixed > gOriginalPageCountArray[index].iAllocFixed)
+				{
+				test.Printf(_L("Fail: Pages have been allocated into the zone\n"));
+				CLEANUP(ResetDPCache());
+				TEST_FAIL;
+				}
+			else
+				{
+				test.Printf(_L("Passed...\n"));
+				}
+			}
+		}
+	else
+		{
+		test.Printf(_L("Not a paged ROM - Skipping test step\n"));
+		}
+	TestEnd();
+	test.Next(_L("Test20: No Further Alloc Flag, Alloc Fixed using ZoneAllocPhyicalRam"));
+	TestStart();
+	GetAllPageInfo();
+	index = 0;
+	while ((TUint)index < gZoneCount && (gZoneUtilArray[index].iFreePages == 0 ||
+			gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		index++;
+		}
+	if ((TUint)index == gZoneCount)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+		}
+	else
+		{
+		zoneDefragID = gZoneConfigArray[index].iZoneId;
+		GetOriginalPageCount();
+		r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_ALLOC_FLAG);
+		test_KErrNone(r);
+		// Just need to try and allocate one page
+		r = Ldd.ZoneAllocDiscontiguous(zoneDefragID, 1);
+		GetAllPageInfo();
+		if (r != KErrNoMemory)
+			{
+			test.Printf(_L("Fail: Fixed pages have been allocated into zone ID 0x%x\n"), zoneDefragID);
+			CLEANUP(Ldd.FreeAllFixedPages());
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	TestEnd();
+	test.Next(_L("Test21: No Further Alloc Flag, Alloc Fixed by attempting to claim zone"));
+	TestStart();
+	GetAllPageInfo();
+	index = 0;
+	while ((TUint)index < gZoneCount && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
+		{
+		index++;
+		}
+	if ((TUint)index == gZoneCount)
+		{
+		test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
+		}
+	else
+		{
+		zoneDefragID = gZoneConfigArray[index].iZoneId;
+		r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_ALLOC_FLAG);
+		test_KErrNone(r);
+		r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, zoneDefragID);
+		GetAllPageInfo();
+		TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
+		if (freeInOthers && r != KErrNone)
+			{
+			test.Printf(_L("Fail: Claim zone ID 0x%x was unsuccessful, r = %d\n"), zoneDefragID, r);
+			CLEANUP(ResetRamZoneFlags());
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	TestEnd();
+	TUint mostPrefArrayIndex = 0;
+	TUint mostPrefIndex = 0;
+	TUint leastPrefIndex = 0;
+	const TUint KFreeMostPref = 10;
+	TUint flag = 0;
+	TUint prefIndex;
+	TUint totalFree;
+	for (TUint testStep = 0; testStep < 2; testStep++)
+		{
+		switch(testStep)
+			{
+			case 0:
+				test.Next(_L("Test22: Ensure that the General Defrag looks at the flags 1"));
+				break;
+			case 1:
+				test.Next(_L("Test23: Ensure that the General Defrag looks at the flags 2"));
+				break;
+			}
+		TestStart();
+		gChunkArray1 = new RChunk;
+		gChunkArraySize1 = 1;
+		TUint minCacheSize = 0;
+		TUint maxCacheSize = 0;
+		TUint currentCacheSize = 0;
+		TUint freeNeededInMostPref = 0;
+		if (!gPagedRom)
+			{
+			test.Printf(_L("Not a paged ROM - Skipping...\n"));
+			goto skipTest22;
+			}
+		// Find the most pref zone with free pages
+		r = FindMostPrefWithFree(mostPrefIndex, &mostPrefArrayIndex);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("Cannot find zone with free pages - Skipping...\n"));
+			goto skipTest22;
+			}
+		// Ensure that the least pref zone is empty
+		leastPrefIndex = gPrefArray[gZoneCount - 1];
+		if (gZoneUtilArray[leastPrefIndex].iFreePages != gZoneUtilArray[leastPrefIndex].iPhysPages)
+			{
+			test.Printf(_L("Least pref zone is not empty - Skipping...\n"));
+			goto skipTest22;
+			}
+		// Allocate 1 movable page to the least preferable zone
+		r = ZoneAllocMovable(gChunkArray1, gChunkArraySize1, leastPrefIndex, 1);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("Failed to allocate movable r = %d - Skipping...\n"), r);
+			goto skipTest22;
+			}
+		// Allocate 1 discardable page to the least preferable zone
+		if (gZoneUtilArray[leastPrefIndex].iFreePages != 0)
+			{
+			TInt disPages;
+			r = ZoneAllocDiscard(leastPrefIndex, 1, disPages);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("Failed to allocate discardable pages r = %d - Skipping...\n"), r);
+				goto skipTest22;
+				}
+			// up the minimum cache size so that the pages have to be moved - not discarded
+			DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
+			r = DPTest::SetCacheSize(currentCacheSize, currentCacheSize);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("Failed to set cache size r = %d - Skipping...\n"), r);
+				goto skipTest22;
+				}
+			}
+		else
+			{
+			test.Printf(_L("Least pref zone has no free pages - Skipping...\n"));
+			goto skipTest22;
+			}
+		// Check that the least pref zone has movable and discardable pages in it
+		GetAllPageInfo();
+		if (gZoneUtilArray[leastPrefIndex].iAllocMovable == 0 ||
+			gZoneUtilArray[leastPrefIndex].iAllocDiscardable == 0)
+			{
+			test.Printf(_L("No movable or discardable in least pref zone\n"));
+			PrintPageInfo();
+			goto skipTest22;
+			}
+		ResetRamZoneFlags();
+		// if most pref zone has too many free pages fill up with fixed
+		if (gZoneUtilArray[mostPrefIndex].iFreePages > KFreeMostPref)
+			{
+			TUint allocPages = gZoneUtilArray[mostPrefIndex].iFreePages - KFreeMostPref;
+			r = Ldd.ZoneAllocToMany(mostPrefIndex, allocPages);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("Failed allocate 0x%x fixed to index %d r = %d - Skipping...\n"),
+								allocPages, mostPrefIndex,r);
+				PrintPageInfo();
+				goto skipTest22;
+				}
+			}
+		// if the no. of discardable pages is less than free in most pref increase the min cache size
+		GetAllPageInfo();
+		if (gZoneUtilArray[leastPrefIndex].iAllocDiscardable < gZoneUtilArray[mostPrefIndex].iFreePages)
+			{
+			TUint discDiff = gZoneUtilArray[mostPrefIndex].iFreePages - gZoneUtilArray[leastPrefIndex].iAllocDiscardable;
+			test.Printf(_L("discDiff = 0x%x\n"), discDiff);
+			TInt disPages;
+			if (ZoneAllocDiscard(leastPrefIndex, discDiff, disPages) != KErrNone)
+				{
+				test.Printf(_L("Failed allocate discardable to zone index %d- Skipping...\n"), leastPrefIndex);
+				goto skipTest22;
+				}
+			// up the minimum cache size by the difference as we don't want these pages to be discarded
+			DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
+			r = DPTest::SetCacheSize(currentCacheSize, currentCacheSize);
+			test.Printf(_L("r = %d\n"), r);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("Failed to set cache size r = %d - Skipping...\n"), r);
+				goto skipTest22;
+				}
+			}
+		ResetRamZoneFlags();
+		// if the rest of the zones are either full or empty put a fixed page into the next most pref empty zone
+		GetPrefOrder();
+		prefIndex = 0;
+		totalFree = 0;
+		for (; prefIndex < gZoneCount && totalFree < gZoneUtilArray[leastPrefIndex].iAllocDiscardable; prefIndex++)
+			{// Look for zone that has enough free pages to fit all the discardable
+			TUint zoneIndex = gPrefArray[prefIndex];
+			if (zoneIndex != mostPrefIndex && zoneIndex != leastPrefIndex)
+				{
+				if (gZoneUtilArray[zoneIndex].iFreePages != gZoneUtilArray[zoneIndex].iPhysPages)
+					{
+					totalFree += gZoneUtilArray[zoneIndex].iFreePages;
+					}
+				else
+					{
+					r = Ldd.ZoneAllocToMany(zoneIndex, 1);
+					if (r != KErrNone)
+						{
+						test.Printf(_L("Couldn't alloc fixed to zone index %d - r = %d\n"), zoneIndex, r);
+						goto skipTest22;
+						}
+					GetAllPageInfo();
+					totalFree += gZoneUtilArray[zoneIndex].iFreePages;
+					}
+				}
+			}
+		if (prefIndex >= gZoneCount)
+			{
+			test.Printf(_L("Couldn't find zone\n"));
+			goto skipTest22;
+			}
+		// If the most preferable zone does not have enough free pages, skip
+		freeNeededInMostPref = (testStep == 0) ? gZoneUtilArray[leastPrefIndex].iAllocMovable : gZoneUtilArray[leastPrefIndex].iAllocDiscardable;
+		if (gZoneUtilArray[mostPrefIndex].iFreePages < freeNeededInMostPref)
+			{
+			test.Printf(_L("Free needed in mostPref(%d) = %d, Free available in mostPref = %d - skipping...\n"),
+							mostPrefIndex,freeNeededInMostPref,gZoneUtilArray[mostPrefIndex].iFreePages);
+			goto skipTest22;
+			}
+		GetAllPageInfo();
+		// Set up the RAM zone flags for the test
+		flag = (testStep == 0)? NO_MOVE_FLAG: NO_DISCARD_FLAG;
+		// Set all zones except most pref to KRamZoneFlagNoMovable	or KRamZoneFlagNoDiscard
+		for (TUint index = 0; index < gZoneCount; index++)
+			{
+			TUint zoneID = gZoneConfigArray[index].iZoneId;
+			if (index != mostPrefIndex)
+				{
+				r = Ldd.SetZoneFlag(zoneID, gZoneConfigArray[index].iFlags, flag);
+				if (r != KErrNone)
+					{
+					test.Printf(_L("Failed to set flag r = %d - Skipping...\n"), r);
+					goto skipTest22;
+					}
+				}
+			}
+		GetOriginalPageCount();
+		r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+		GetAllPageInfo();
+		switch(testStep)
+			{
+			case 0:
+				if (r != KErrNone ||
+					gOriginalPageCountArray[mostPrefIndex].iAllocMovable >= gZoneUtilArray[mostPrefIndex].iAllocMovable ||
+					gZoneUtilArray[leastPrefIndex].iFreePages != gZoneUtilArray[leastPrefIndex].iPhysPages)
+					{
+					test.Printf(_L("FAIL:r=%d MostPref(%d): origMov 0x%x curMov 0x%x LeastPref(%d): origMov 0x%x curMov 0x%x origDis 0x%x curDis 0x%x\n"),
+									r, mostPrefIndex, gOriginalPageCountArray[mostPrefIndex].iAllocMovable, gZoneUtilArray[mostPrefIndex].iAllocMovable,
+									leastPrefIndex, gOriginalPageCountArray[leastPrefIndex].iAllocMovable, gZoneUtilArray[leastPrefIndex].iAllocMovable,
+									gOriginalPageCountArray[leastPrefIndex].iAllocDiscardable, gZoneUtilArray[leastPrefIndex].iAllocDiscardable);
+					CLEANUP(Ldd.FreeAllFixedPages());
+					TEST_FAIL;
+					}
+				else
+					{
+					test.Printf(_L("Passed...\n"));
+					}
+				break;
+			case 1:
+				if (r != KErrNone ||
+					gOriginalPageCountArray[mostPrefIndex].iAllocDiscardable >= gZoneUtilArray[mostPrefIndex].iAllocDiscardable ||
+					gZoneUtilArray[leastPrefIndex].iFreePages != gZoneUtilArray[leastPrefIndex].iPhysPages)
+					{
+					test.Printf(_L("FAIL:r=%d MostPref(%d): origMov 0x%x curMov 0x%x LeastPref(%d): origMov 0x%x curMov 0x%x origDis 0x%x curDis 0x%x\n"),
+									r, mostPrefIndex, gOriginalPageCountArray[mostPrefIndex].iAllocMovable, gZoneUtilArray[mostPrefIndex].iAllocMovable,
+									leastPrefIndex, gOriginalPageCountArray[leastPrefIndex].iAllocMovable, gZoneUtilArray[leastPrefIndex].iAllocMovable,
+									gOriginalPageCountArray[leastPrefIndex].iAllocDiscardable, gZoneUtilArray[leastPrefIndex].iAllocDiscardable);
+					CLEANUP(Ldd.FreeAllFixedPages());
+					TEST_FAIL;
+					}
+				else
+					{
+					test.Printf(_L("Passed...\n"));
+					}
+				break;
+			}
+	skipTest22:
+		TestEnd();
+		}
+	test.Next(_L("Test24: Ensure that the General Defrag doesnt move or discard pages if KRamZoneFlagNoMovable set on all zones "));
+	TestStart();
+	gChunkArray1 = new RChunk;
+	gChunkArraySize1 = 1;
+	// Find the most pref zone with free pages
+	GetPrefOrder();
+	TInt disPages = 0;
+	if (FindMostPrefWithFree(mostPrefIndex, &mostPrefArrayIndex) != KErrNone)
+		{
+		test.Printf(_L("Cannot find zone with free pages - Skipping...\n"));
+		goto skipTest24;
+		}
+	// Ensure that the least pref zone has free pages in it
+	leastPrefIndex = gPrefArray[gZoneCount-1];
+	if (gZoneUtilArray[leastPrefIndex].iFreePages == 0)
+		{
+		test.Printf(_L("Least pref zone has no free pages - Skipping...\n"));
+		goto skipTest24;
+		}
+	// Allocate 1 movable page to the least preferable zone
+	r = ZoneAllocMovable(gChunkArray1, gChunkArraySize1, leastPrefIndex, 1);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("Failed to allocate movable page r = %d - Skipping...\n"), r);
+		goto skipTest24;
+		}
+	if (gPagedRom)
+		{
+		TUint minCacheSize = 0;
+		TUint maxCacheSize = 0;
+		TUint currentCacheSize = 0;
+		// Allocate 1 discardable page to the least preferable zone
+		if (gZoneUtilArray[leastPrefIndex].iFreePages != 0)
+			{
+			r = ZoneAllocDiscard(leastPrefIndex, 1, disPages);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("Discardable pages not allocated r= %d\n"), r);
+				}
+			DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
+			r = DPTest::SetCacheSize(currentCacheSize, currentCacheSize);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("Failed to set cache size r = %d - Skipping...\n"), r);
+				goto skipTest24;
+				}
+			}
+		}
+	// Check that the least pref zone has movable and discardable (if allocated) pages in it
+	GetAllPageInfo();
+	if (gZoneUtilArray[leastPrefIndex].iAllocMovable == 0 ||
+		gZoneUtilArray[leastPrefIndex].iAllocDiscardable < (TUint)disPages ||
+		gZoneUtilArray[leastPrefIndex].iAllocMovable > gTotalPageCount.iFreePages - gZoneUtilArray[leastPrefIndex].iFreePages)
+		{
+		test.Printf(_L("No movable in least pref zone or no space for moveable pages to be moved to\n"));
+		PrintPageInfo();
+		goto skipTest24;
+		}
+	ResetRamZoneFlags();
+	GetAllPageInfo();
+	// Now set all zones to KRamZoneFlagNoMovable
+	for (TUint index = 0; index < gZoneCount; index++)
+		{
+		TUint zoneID = gZoneConfigArray[index].iZoneId;
+		r = Ldd.SetZoneFlag(zoneID, gZoneConfigArray[index].iFlags, NO_MOVE_FLAG);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("Failed to set cache size r = %d - Skipping...\n"), r);
+			goto skipTest24;
+			}
+		}
+	GetOriginalPageCount();
+	r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+	GetAllPageInfo();
+	if (r != KErrNone ||
+		gOriginalPageCountArray[leastPrefIndex].iAllocMovable != gZoneUtilArray[leastPrefIndex].iAllocMovable ||
+		gZoneUtilArray[leastPrefIndex].iAllocDiscardable < gOriginalPageCountArray[leastPrefIndex].iAllocDiscardable)
+		{
+		test.Printf(_L("FAIL:r=%d LeastPref(%d): origMov 0x%x curMov 0x%x origDis 0x%x curDis 0x%x\n"),
+						r,leastPrefIndex, gOriginalPageCountArray[leastPrefIndex].iAllocMovable, gZoneUtilArray[leastPrefIndex].iAllocMovable,
+						gOriginalPageCountArray[leastPrefIndex].iAllocDiscardable, gZoneUtilArray[leastPrefIndex].iAllocDiscardable);
+		CLEANUP(ResetRamZoneFlags());
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+skipTest24:
+	TestEnd();
+	test.End();
+	return KErrNone;
+	}
+//
+// Template functions encapsulating ControlIo magic
+//
+template <class C>
+TInt controlIo(RFs &fs, TInt drv, TInt fkn, C &c)
+	{
+TPtr8 ptrC((TUint8 *)&c, sizeof(C), sizeof(C));
+TInt r = fs.ControlIo(drv, fkn, ptrC);
+return r;
+	}
+//
+// FormatMMC
+//
+// Formats the MMC card
+//
+void FormatMMC()
+	{
+	test.Printf(_L("Formatting MMC...\n"));
+	RFs theFs;
+	TBuf<4> driveBuf = _L("D:\\");
+	RFormat format;
+	TInt count;
+	TChar driveLet;
+	TInt r = theFs.Connect();
+	test_KErrNone(r);
+	r = theFs.DriveToChar(gDrive, driveLet);
+	test_KErrNone(r);
+	driveBuf[0] = driveLet;
+	test.Printf(_L("Formatting Drive: %C\n"),(TInt)driveLet);
+	r = format.Open(theFs,driveBuf,EFullFormat,count);
+	test_KErrNone(r);
+	while(count)
+		{
+		TInt r = format.Next(count);
+		test_KErrNone(r);
+		}
+	format.Close();
+	theFs.Close();
+	}
+//
+// FileNameGen
+//
+// Generates file names to create the files
+//
+void FileNameGen(TDes16& aBuffer, TInt aLong, TInt aPos)
+	{
+	TInt padding;
+	TInt i = 0;
+	TBuf16<10> tempbuf;
+	_LIT(KNumber,"%d");
+	tempbuf.Format(KNumber,aPos);
+	padding = aLong-tempbuf.Size()/2;
+	aBuffer = _L("");
+	while(i < padding)
+		{
+		aBuffer.Append('F');
+		i++;
+		}
+	aBuffer.Append(tempbuf);
+	_LIT(KExtension1, ".TXT");
+	aBuffer.Append(KExtension1);
+	}
+//
+// CreateFiles
+//
+// Creates the files to fill part of the read cache
+//
+void CreateFiles(TInt aFiles, TInt aFileSize)
+	{
+	TInt i = 0, r = 0;
+	RFile file;
+	TBuf16<50> directory;
+	TBuf16<50> path;
+	TBuf16<50> buffer(50);
+	directory = gSessionPath;
+	test.Printf(_L("Creating %d files for filling the cache (size %d)\n"), aFiles, aFileSize);
+	// create a big buffer to speed things up
+	HBufC8* bigBuf = NULL;
+	const TInt KBigBufferSize = 32 * 1024;
+	TRAPD(res,bigBuf = HBufC8::NewL(KBigBufferSize));
+	test(res == KErrNone && bigBuf != NULL);
+	TPtr8 bigBufWritePtr(NULL, 0);
+	bigBufWritePtr.Set(bigBuf->Des());
+	// Fill the buffer
+	TChar aC = 'A';
+	for(i = 0; i < KBigBufferSize; i++)
+		{
+		bigBufWritePtr.Append((i%32) + aC);
+		}
+	i = 0;
+	while(i < aFiles)
+		{
+		if (i % 10 == 0)
+			test.Printf(_L("Creating file %d of %d...\r"), i, aFiles);
+		FileNameGen(buffer, 8, i+3) ;
+		path = directory;
+		path.Append(buffer);
+		// delete file first to ensure it's contents are not in the cache (file may be on the closed file queue)
+		r = gTheFs.Delete(path);
+		test(r == KErrNone || r == KErrNotFound);
+		r = file.Create(gTheFs,path,EFileShareAny|EFileWrite|EFileReadDirectIO|EFileWriteDirectIO);
+		if(r == KErrAlreadyExists)
+			r = file.Open(gTheFs,path,EFileShareAny|EFileWrite|EFileReadDirectIO|EFileWriteDirectIO);
+		TInt j = 0;
+		i++;
+		while(j < aFileSize)
+			{
+			bigBufWritePtr.SetLength(Min(KBigBufferSize, aFileSize - j));
+			r = file.Write(bigBufWritePtr);
+			// Running out of disk space is expected for the last file.
+			// Premature "disk full" conditions need to abort.
+			if (r == KErrDiskFull)
+				{
+				test(i == aFiles);
+				break;
+				}
+			test_KErrNone(r);
+			j += bigBufWritePtr.Length();
+			}
+		file.Close();
+		}
+	test.Printf(_L("\nFiles created\n"));
+	delete bigBuf;
+	}
+//
+// FillCache
+//
+// Allocate discardable pages using file system caching
+//
+TInt FillCache(TInt aFiles, TInt aFileSize)
+	{
+	// Fail if files already open
+	test(!gFileCacheRun);
+	TInt i = 0, r = 0;
+	TBuf16<50> directory;
+	TBuf16<50> path;
+	TBuf16<50> buffer(50);
+	HBufC8* buf = NULL;
+	TPtr8 bufPtr(NULL, 0);
+	TRAPD(res,buf = HBufC8::NewL(2));
+	test(res == KErrNone && buf != NULL);
+	bufPtr.Set(buf->Des());
+	TESTDEBUG(test.Printf(_L("Filling the cache\n")));
+	directory = gSessionPath;
+	i = 0;
+	GetAllPageInfo();
+	TESTDEBUG(test.Printf(_L("total disc pages = %d\n"), gTotalPageCount.iDiscardablePages));
+	while(i < aFiles)
+		{
+		FileNameGen(buffer, 8, i+3) ;
+		path = directory;
+		path.Append(buffer);
+		r = gFile[i].Open(gTheFs,path,EFileShareAny|EFileRead|EFileReadBuffered|EFileReadAheadOff);
+		test_KErrNone(r);
+		TInt j = 0;
+		while(j < aFileSize)
+			{
+			r = gFile[i].Read(j,bufPtr);
+			test_KErrNone(r);
+			j += 4 * 1024;
+			}
+		i++;
+		}
+	gFileCacheRun = ETrue;
+	GetAllPageInfo();
+	TESTDEBUG(test.Printf(_L("after - total disc pages = %d\n"), gTotalPageCount.iDiscardablePages));
+	delete buf;
+	TESTDEBUG(test.Printf(_L("Cache filled\n")));
+#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
+	// get number of items on Page Cache
+	TFileCacheStats startPageCacheStats;
+	r = controlIo(gTheFs,gDrive, KControlIoFileCacheStats, startPageCacheStats);
+	test.Printf(_L("control stats r= %d\n"), r);
+	test(r==KErrNone || r == KErrNotSupported);
+	TESTDEBUG(test.Printf(_L("Allocated segment count=%d\n"),startPageCacheStats.iAllocatedSegmentCount));
+#endif
+	// if we do not have any discardable pages then something went
+	// wrong with file caching
+	if (gTotalPageCount.iDiscardablePages == 0)
+		return KErrNotSupported;
+	return KErrNone;
+	}
+//
+// SetUpMMC
+//
+// Sets up the MMC to be used by the test by creating files on the MMC
+//
+void SetUpMMC()
+	{
+	FormatMMC();
+	TInt r = 0;
+	TChar driveToTest;
+	TVolumeInfo volInfo;
+	r = gTheFs.DriveToChar(gDrive, driveToTest);
+	test_KErrNone(r);
+	r = gTheFs.CharToDrive(driveToTest,gDrive);
+	test_KErrNone(r);
+	gSessionPath = _L("?:\\F32-TST\\");
+	gSessionPath[0] = (TUint16) driveToTest;
+	test.Printf(_L("Drive Letter=%C\n"),(TInt)driveToTest);
+	TDriveInfo info;
+	r = gTheFs.Drive(info,gDrive);
+	test_KErrNone(r);
+	r = gTheFs.SetSessionPath(gSessionPath);
+	test_KErrNone(r);
+	r = gTheFs.MkDirAll(gSessionPath);
+	if (r != KErrNone && r != KErrAlreadyExists)
+		{
+		test_KErrNone(r);
+		}
+	r = gTheFs.Volume(volInfo, gDrive);
+	test_KErrNone(r);
+	TInt64 gMediaSize = volInfo.iSize;
+	// This calculation is approximate because the client cannot know
+	// internal allocation mechanisms of the filesystem, i.e. how much
+	// metadata is associated with a file of name X / size Y, whether
+	// space used by such metadata is reflected in TDriveInfo::iSize and
+	// what block/clustersize the filesystem will round filesizes to.
+	// The last file that fills up the drive may therefore be partial
+	// (smaller than this calculation predicts).
+	TInt maxPossibleFiles = gFilesNeededToFillCache;
+	test.Printf(_L("Original files needed = %d\n"), maxPossibleFiles);
+	if(gMediaSize < (KDefaultCacheSize * maxPossibleFiles))
+		{
+		maxPossibleFiles = (gMediaSize - 10) / KDefaultCacheSize;
+		test.Printf(_L("Disk size is smaller - files needed = %d\n"), maxPossibleFiles);
+		}
+	gFilesNeededToFillCache = maxPossibleFiles;
+	CreateFiles(gFilesNeededToFillCache, KDefaultCacheSize);
+	}
+//
+// TestFileCaching
+//
+//---------------------------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID				KBASE-t_ramdefrag-0599
+//! @SYMTestType				CIT
+//! @SYMTestCaseDesc			Verifying that when File System Caching allocates dicardable pages,
+//! 							Defrag and allocation of fixed pages happens correctly.
+//! @SYMPREQ					PREQ308
+//! @SYMTestPriority			High
+//! @SYMTestActions
+//! 	1.	Fill the file system cache to allocate discardable pages
+//! 		following this call EmptyRamZone() in a zone with discardable pages.
+//! 	2.	Fill the file system cache to allocate discardable pages
+//! 		folling this allocate discontiguous fixed pages to a zone
+//! 	3.	Fill the file system cache to allocate discardable pages
+//! 	.	following this allocate discontuguous fixed pages
+//! 	4.	Fill the file system cache to allocate discardable pages
+//! 		following this allocate less than 16 contiguous fixed pages
+//! 	5.	Fill the file system cache to allocate discardable pages
+//! 		following this allocate more than 16 contiguous fixed pages
+//!
+//! @SYMTestExpectedResults
+//! 	1.	Discardable pages are removed
+//! 	2.	KErrNone
+//! 	3.	KErrNone
+//! 	4.	KErrNone and numDiscardablePages != 0
+//! 	5.	KErrNone and numDiscardablePages = 0
+//---------------------------------------------------------------------------------------------------------------------
+TInt TestFileCaching()
+	{
+	const TUint KDisPagesReq = 1;
+	TInt r = KErrNone;
+	TInt allocSize = 0;
+	TUint zoneID = 0;
+	TUint index = 0;
+	TUint minDiscardPages = 0;
+	if (gDrive == KNoRemovableDrive)
+		{
+		test.Start(_L("Cannot find drive to write files to - Skipping FS Caching Tests\n"));
+		test.End();
+		return 0;
+		}
+	r = gTheFs.Connect();
+	test_KErrNone(r);
+	SetUpMMC();
+	RRamDefragFuncTestLdd Ldd2;
+	r = Ldd2.Open();
+	test_KErrNone(r);
+	test.Start(_L("Test1: Test EmptyRamZone() clears file server cache pages"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	r = FillCache(gFilesNeededToFillCache, KDefaultCacheSize);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("File system caching failed - Skipping all file caching tests...\n"));
+		goto skipFileCacheTests;
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	while (index < gZoneCount && gZoneUtilArray[index].iAllocDiscardable < KDisPagesReq)
+		{
+		++ index;
+		}
+	if (index == gZoneCount)
+		{
+		test.Printf(_L("Cannot find zone to perform test on - Skipping test step...\n"));
+		}
+	else
+		{
+		zoneID = gZoneConfigArray[index].iZoneId;
+		r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, zoneID);
+		GetAllPageInfo();
+		if (gZoneUtilArray[index].iAllocDiscardable != 0)
+			{
+			test.Printf(_L("Fail: Zone ID 0x%x has 0x%x discardable pages\n"), zoneID, gZoneUtilArray[index].iAllocDiscardable);
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		}
+	TestEnd();
+	test.Next(_L("Test2: Filling the FS Cache and allocating fixed pages to a zone"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	r = FillCache(gFilesNeededToFillCache, KDefaultCacheSize);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("File system caching failed - Skipping all file caching tests...\n"));
+		goto skipFileCacheTests;
+		}
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	index = 0;
+	while (index < gZoneCount && gZoneUtilArray[index].iAllocDiscardable < KDisPagesReq)
+		{
+		++ index;
+		}
+	if (index == gZoneCount)
+		{
+		test.Printf(_L("Cannot find zone to perform test on - Skipping test step...\n"));
+		}
+	else
+		{
+		zoneID = gZoneConfigArray[index].iZoneId;
+		// Just need to attempt to allocate one more page than there is free in the zone
+		allocSize = gZoneUtilArray[index].iFreePages + 1;
+		test.Printf(_L("Allocating 0x%x fixed pages to zone ID 0x%x.....\n"), allocSize, zoneID);
+		r = Ldd.ZoneAllocDiscontiguous(zoneID, allocSize);
+		test.Printf(_L("r = %d\n"), r);
+		GetAllPageInfo();
+		if (r != KErrNone)
+			{
+			test.Printf(_L("Fail: Fixed pages have not been allocated, r = %d, expected = %d\n"), r, KErrNone);
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		TESTDEBUG(test.Printf(_L("Freeing all Fixed Pages.....\n")));
+		Ldd.FreeAllFixedPages();
+		}
+	TestEnd();
+	test.Next(_L("Test3: Filling the FS Cache and allocating fixed pages"));
+	TestStart();
+	r = FillCache(gFilesNeededToFillCache, KDefaultCacheSize);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("File system caching failed - Skipping all file caching tests...\n"));
+		goto skipFileCacheTests;
+		}
+	GetAllPageInfo();
+	index = 0;
+	while (index < gZoneCount && gZoneUtilArray[index].iAllocDiscardable < KDisPagesReq)
+		{
+		++ index;
+		}
+	if (index == gZoneCount)
+		{
+		test.Printf(_L("Cannot find zone to perform test on - Skipping test step...\n"));
+		}
+	else
+		{
+		zoneID = gZoneConfigArray[index].iZoneId;
+		allocSize = 14;
+		TESTDEBUG(test.Printf(_L("Filling the remaining free pages with fixed pages.....\n")));
+		Ldd.AllocateFixed(gTotalPageCount.iFreePages);
+		test.Printf(_L("Allocating 0x%x fixed pages to zone ID 0x%x.....\n"), allocSize, zoneID);
+		r = Ldd2.AllocateFixed(allocSize);
+		TESTDEBUG(test.Printf(_L("r = %d\n"), r));
+		GetAllPageInfo();
+		if (r != KErrNone)
+			{
+			test.Printf(_L("Fail: Fixed pages have not been allocated, r = %d, expected = %d\n"), r, KErrNone);
+			CLEANUP(Ldd.FreeAllFixedPages());
+			CLEANUP(Ldd2.FreeAllFixedPages());
+			TEST_FAIL;
+			}
+		else
+			{
+			test.Printf(_L("Passed...\n"));
+			}
+		TESTDEBUG(test.Printf(_L("Freeing all Fixed Pages.....\n")));
+		Ldd2.FreeAllFixedPages();
+		}
+	TestEnd();
+	test.Next(_L("Test4: Filling the FS Cache and allocating less than 16 contiguous fixed pages"));
+	TestStart();
+	r = FillCache(gFilesNeededToFillCache, KDefaultCacheSize);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("File system caching failed - Skipping all file caching tests...\n"));
+		goto skipFileCacheTests;
+		}
+	allocSize = 14 << gPageShift;
+	TESTDEBUG(test.Printf(_L("Filling the remaining free pages with fixed pages.....\n")));
+	GetAllPageInfo();
+	// Allocate the fixed array before getting any page counts
+	for (TUint index = 0; index < gZoneCount; index++)
+		{
+		GetAllPageInfo();
+		if (gZoneUtilArray[index].iFreePages)
+			{
+			r = Ldd.ZoneAllocToManyArray(index, gZoneUtilArray[index].iFreePages);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("Failed to allocate fixed array Zone %d r = %d - Skipping...\n"), index,  r);
+				goto SkipTest4;
+				}
+			}
+		}
+	// Now fill all zones with fixed pages, 1 zone at a time
+	// to avoid the discardable pages being disturbed
+	for (TUint index = 0; index < gZoneCount; index++)
+		{
+		GetAllPageInfo();
+		if (gZoneUtilArray[index].iFreePages)
+			{
+			r = Ldd.ZoneAllocToMany2(index, gZoneUtilArray[index].iFreePages);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("Failed to allocate %d fixed to Zone %d r = %d - Skipping...\n"),
+													gZoneUtilArray[index].iFreePages, index,  r);
+				goto SkipTest4;
+				}
+			}
+		}
+	GetAllPageInfo();
+	test.Printf(_L("number of free pages = 0x%x\n"), gTotalPageCount.iFreePages);
+	if (gTotalPageCount.iFreePages ||
+		gTotalPageCount.iDiscardablePages <= (TUint)(allocSize >> gPageShift))
+		{
+		test.Printf(_L("Setup failed - Skipping...\n"));
+		goto SkipTest4;
+		}
+	test.Printf(_L("Allocating 0x%x fixed pages.....\n"), allocSize >> gPageShift);
+	r = Ldd2.AllocContiguous(allocSize);
+	TESTDEBUG(test.Printf(_L("r = %d\n"), r));
+	GetAllPageInfo();
+	if (r != KErrNone || !gTotalPageCount.iDiscardablePages)
+		{
+		test.Printf(_L("Fail: Fixed pages have not been allocated, r = %d, expected = %d\n"), r, KErrNone);
+		CLEANUP(Ldd.FreeAllFixedPages());
+		CLEANUP(Ldd2.FreeAllFixedPages());
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+SkipTest4:
+	TESTDEBUG(test.Printf(_L("Freeing all Fixed Pages.....\n")));
+	Ldd2.FreeAllFixedPages();
+	TestEnd();
+	test.Next(_L("Test5: Filling the FS Cache and allocating more than 16 contiguous fixed pages"));
+	TestStart();
+	// TestEnd() will have reduced any cache pages to minimum so just get current
+	// count of discardable pages.
+	GetAllPageInfo();
+	minDiscardPages = gTotalPageCount.iDiscardablePages;
+	r = FillCache(gFilesNeededToFillCache, KDefaultCacheSize);
+	if (r != KErrNone)
+		{
+		test.Printf(_L("File system caching failed - Skipping all file caching tests...\n"));
+		goto skipFileCacheTests;
+		}
+	allocSize = 18 << gPageShift;
+	TESTDEBUG(test.Printf(_L("Filling the remaining free pages with fixed pages.....\n")));
+	GetAllPageInfo();
+	// Allocate the fixed array before getting any page counts
+	for (TUint index = 0; index < gZoneCount; index++)
+		{
+		GetAllPageInfo();
+		if (gZoneUtilArray[index].iFreePages)
+			{
+			r = Ldd.ZoneAllocToManyArray(index, gZoneUtilArray[index].iFreePages);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("Failed to allocate fixed array Zone %d r = %d - Skipping...\n"), index,  r);
+				goto SkipTest5;
+				}
+			}
+		}
+	// Now fill all zones with fixed pages, 1 zone at a time
+	// to avoid the discardable pages being disturbed
+	for (TUint index = 0; index < gZoneCount; index++)
+		{
+		GetAllPageInfo();
+		if (gZoneUtilArray[index].iFreePages)
+			{
+			r = Ldd.ZoneAllocToMany2(index, gZoneUtilArray[index].iFreePages);
+			if (r != KErrNone)
+				{
+				test.Printf(_L("Failed to allocate %d fixed to Zone %d r = %d - Skipping...\n"),
+													gZoneUtilArray[index].iFreePages, index,  r);
+				goto SkipTest5;
+				}
+			}
+		}
+	GetAllPageInfo();
+	test.Printf(_L("number of free pages = 0x%x\n"), gTotalPageCount.iFreePages);
+	if (gTotalPageCount.iFreePages)
+		{
+		test.Printf(_L("Setup failed - Skipping...\n"));
+		goto SkipTest5;
+		}
+	test.Printf(_L("Allocating 0x%x fixed pages.....\n"), allocSize >> gPageShift);
+	r = Ldd2.AllocContiguous(allocSize);
+	TESTDEBUG(test.Printf(_L("r = %d\n"), r));
+	GetAllPageInfo();
+	if (r != KErrNone || gTotalPageCount.iDiscardablePages != minDiscardPages)
+		{
+		test.Printf(_L("Fail: r = %d, expected = %d - Discardable Pages = 0x%x, expected = %d\n"),
+								r, KErrNone, gTotalPageCount.iDiscardablePages, minDiscardPages);
+		CLEANUP(Ldd.FreeAllFixedPages());
+		CLEANUP(Ldd2.FreeAllFixedPages());
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed...\n"));
+		}
+SkipTest5:
+skipFileCacheTests:
+	TestEnd();
+	TESTDEBUG(test.Printf(_L("Freeing all Fixed Pages.....\n")));
+	Ldd2.FreeAllFixedPages();
+	Ldd2.Close();
+	gTheFs.Close();
+	FormatMMC();
+	test.End();
+	return KErrNone;
+	}
+//
+// TestOneZoneConfig
+//
+//---------------------------------------------------------------------------------------------------------------------
+//! @SYMTestCaseID				KBASE-t_ramdefrag-0600
+//! @SYMTestType				CIT
+//! @SYMTestCaseDesc			Verifying that when only 1 zone is cofigured in the variant, that
+//!								the defrag and allocation of fixed pages happend correctly
+//! @SYMPREQ					PREQ308
+//! @SYMTestPriority			High
+//! @SYMTestActions
+//! 	1.	Fragment the memory and perform a DefragRam
+//! 	2.	Fragment the memory and perform an EmptyZone
+//! 	3.	Fragment the memory and perform a ClaimZone
+//! 	4.	Call ZoneAllocPhysicalRam to allocate discontiguous fixed pages
+//! 	5.	Call ZoneAllocPhysicalRam to allocate contiguous fixed pages
+//!
+//! @SYMTestExpectedResults
+//! 	1.	Number of pages does not differ from the original
+//! 	2.	KErrNoMemroy and discardable pages are discarded of
+//! 	3.	KErrNoMemory
+//! 	4.	KErrNone
+//! 	5.	KErrNone
+//---------------------------------------------------------------------------------------------------------------------
+TInt TestOneZoneConfig()
+	{
+	TInt r = gTheFs.Connect();
+	test_KErrNone(r);
+	if (gDrive != KNoRemovableDrive)
+		{
+		SetUpMMC();
+		}
+	TUint index = 0;
+	GetAllPageInfo();
+	TUint zoneID = gZoneConfigArray[index].iZoneId;
+	test.Printf(_L("Zone ID = 0x%x\n"), zoneID);
+	TUint minCacheSize = 0;
+	TUint maxCacheSize = 0;
+	TUint currentCacheSize = 0;
+	TUint origFree = 0;
+	TUint origUnknown = 0;
+	TUint origFixed = 0;
+	TUint origMovable = 0;
+	TUint origDiscard = 0;
+	TUint origOther = 0;
+	if (gPagedRom)
+		{
+		DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
+		TESTDEBUG(test.Printf(_L("Original CacheSize: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"),
+									minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift));
+		TUint setMin = 60 << gPageShift;
+		TInt setMax = -1;
+		TInt r = DPTest::SetCacheSize(setMin, setMax);
+		if (r != KErrNone)
+			{
+			test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
+			CLEANUP(ResetDPCache());
+			TEST_FAIL;
+			}
+		DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
+		TESTDEBUG(test.Printf(_L("Original CacheSize: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"),
+									minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift));
+		}
+	test.Start(_L("Test1: Fragmenting the memory and performing a general defrag"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	if (gDrive != KNoRemovableDrive)
+		{
+		FillCache(gFilesNeededToFillCache, KDefaultCacheSize);
+		}
+	else
+		{
+		test.Printf(_L("Cannot find drive to write files to - Not allocating discardable pages through FS Caching\n"));
+		}
+	GetAllPageInfo();
+	origFree = gTotalPageCount.iFreePages;
+	origUnknown = gTotalPageCount.iUnknownPages;
+	origFixed = gTotalPageCount.iFixedPages;
+	origMovable = gTotalPageCount.iMovablePages;
+	origDiscard = gTotalPageCount.iDiscardablePages;
+	origOther = gTotalPageCount.iOtherPages;
+	r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+	GetAllPageInfo();
+	if ((origUnknown != gTotalPageCount.iUnknownPages) ||
+		(origFixed != gTotalPageCount.iFixedPages) ||
+		(origMovable != gTotalPageCount.iMovablePages) ||
+		(origDiscard != gTotalPageCount.iDiscardablePages) ||
+		(origOther != gTotalPageCount.iOtherPages))
+		{
+		test.Printf(_L("Fail: Pages after defrag are not equal to those before"));
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed..."));
+		}
+	// This will free any allocated memory
+	TestEnd();
+	test.Next(_L("Test2: Fragmenting the memory and performing an EmptyZone"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	if (gDrive != KNoRemovableDrive)
+		{
+		FillCache(gFilesNeededToFillCache, KDefaultCacheSize);
+		}
+	else
+		{
+		test.Printf(_L("Cannot find drive to write files to - Not allocating discardable pages through FS Caching\n"));
+		}
+	r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, zoneID);
+	if (r != KErrNoMemory || CheckZoneIsOff(index))
+		{
+		test.Printf(_L("Fail: r = %d, expected = -4"), r);
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed..."));
+		}
+	// This will free any allocated memory
+	TestEnd();
+	test.Next(_L("Test3: Fragmenting the memory and performing a ClaimZone"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	if (gDrive != KNoRemovableDrive)
+		{
+		FillCache(gFilesNeededToFillCache, KDefaultCacheSize);
+		}
+	else
+		{
+		test.Printf(_L("Cannot find drive to write files to - Not allocating discardable pages through FS Caching\n"));
+		}
+	GetAllPageInfo();
+	origMovable = gTotalPageCount.iMovablePages;
+	r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, zoneID);
+	GetAllPageInfo();
+	if (r != KErrNoMemory || origMovable != gTotalPageCount.iMovablePages)
+		{
+		test.Printf(_L("Fail: r = %d, expected = -4"), r);
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed..."));
+		}
+	// This will free any allocated memory.
+	TestEnd();
+	test.Next(_L("Test4: Calling ZoneAllocPhysicalRam to allocate discontiguous fixed pages"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	origFree = gTotalPageCount.iFreePages;
+	origUnknown = gTotalPageCount.iUnknownPages;
+	origFixed = gTotalPageCount.iFixedPages;
+	origMovable = gTotalPageCount.iMovablePages;
+	origDiscard = gTotalPageCount.iDiscardablePages;
+	origOther = gTotalPageCount.iOtherPages;
+	r = Ldd.ZoneAllocDiscontiguous(zoneID, (TInt)(origFree / 2));
+	GetAllPageInfo();
+	if (gTotalPageCount.iFixedPages < (origFixed + (origFree / 2)))
+		{
+		test.Printf(_L("Fail: fixed pages = 0x%x, expected >= 0x%x\n"),
+						gTotalPageCount.iFixedPages, (origFixed + (origFree / 2)));
+		CLEANUP(Ldd.FreeAllFixedPages());
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed..."));
+		}
+	Ldd.FreeAllFixedPages();
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	test.Next(_L("Test5: Calling ZoneAllocPhysicalRam to allocate contiguous fixed pages"));
+	TestStart();
+	AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
+	FreeMovable(gChunkArray1, gChunkArraySize1);
+	GetAllPageInfo();
+	origFree = gTotalPageCount.iFreePages;
+	origUnknown = gTotalPageCount.iUnknownPages;
+	origFixed = gTotalPageCount.iFixedPages;
+	origMovable = gTotalPageCount.iMovablePages;
+	origDiscard = gTotalPageCount.iDiscardablePages;
+	origOther = gTotalPageCount.iOtherPages;
+	TInt allocSize = 50 << gPageShift;
+	r = Ldd.ZoneAllocContiguous(zoneID, allocSize);
+	GetAllPageInfo();
+	if (gTotalPageCount.iFixedPages < (origFixed + (allocSize >> gPageShift)))
+		{
+		test.Printf(_L("Fail: fixed pages = 0x%x, expected >= 0x%x\n"),
+							gTotalPageCount.iFixedPages, (origFixed + (allocSize >> gPageShift)));
+		CLEANUP(Ldd.FreeAllFixedPages());
+		CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
+		TEST_FAIL;
+		}
+	else
+		{
+		test.Printf(_L("Passed..."));
+		}
+	Ldd.FreeAllFixedPages();
+	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
+	TestEnd();
+	if (gPagedRom)
+		{
+		test_KErrNone(DPTest::FlushCache());
+		ResetDPCache();
+		}
+	gTheFs.Close();
+	if (gDrive != KNoRemovableDrive)
+		{
+		FormatMMC();
+		}
+	test.End();
+	return KErrNone;
+	}
+//
+// RunDefragTests
+//
+// List of defrag tests to be run
+//
+void RunDefragTests()
+	{
+	test.Start(_L("Testing the moving of pages in a defrag"));
+	TestMovPgsDefrag();
+	test.Next(_L("Verifying the implementation of the function TRamDefragRequest::DefragRam() arg aMaxPages"));
+	TestDefragRamMaxPages();
+	test.Next(_L("Verifying the implementation of the function TRamDefragRequest::EmptyRamZone()"));
+	TestEmptyRamZone();
+	test.Next(_L("Verifying the implementation of the function Epoc::GetRamZonePageCount()"));
+	TestGetRamZonePageCount();
+	test.Next(_L("Verifying the implementation of the function TRamDefragRequest::ClaimRamZone()"));
+	TestClaimRamZone();
+	test.Next(_L("Verifying the implementation of the function TRamDefragRequest::Cancel()"));
+	TestCancelDefrag();
+	test.Next(_L("Verifying that pages are moved correctly"));
+	TestMovingPages();
+	test.Next(_L("Verifying Semaphore Methods of the Defrag"));
+	TestDefragSemMethod();
+	test.Next(_L("Verifying Dfc Methods of the Defrag"));
+	TestDefragDfcMethod();
+	test.Next(_L("Testing priorities"));
+	TestPriorities();
+	test.Next(_L("Testing File System Caching"));
+	if (!gPagedRom)
+		{
+		TestFileCaching();
+		}
+	else
+		{
+		test.Printf(_L("Skipping... \n"));
+		}
+	test.Next(_L("Testing general RAM defrag implementation"));
+	TestGenDefrag();
+	test.End();
+	}
+//
+// RunAllocTests
+//
+// List of allocating tests to be run
+// These tests only need to be executed once
+//
+void RunAllocTests()
+	{
+	test.Start(_L("Verifying the allocating strategies"));
+	TestAllocStrategies();
+	test.Next(_L("Verifying the contiguous overload of Epoc::ZoneAllocPhysicalRam()"));
+	TestZoneAllocContiguous();
+	test.Next(_L("Verifying the discontiguous overload of Epoc::ZoneAllocPhysicalRam()"));
+	TestZoneAllocDiscontiguous();
+	test.Next(_L("Test Free Zone"));
+	TestFreeZone();
+	test.Next(_L("Testing zone flags"));
+	TestFlags();
+	test.End();
+	}
+//
+// E32Main
+//
+// Main entry point.
+//
+TInt E32Main()
+	{
+	test.Title();
+	DeviceDriver(TEST_DRIVER_OPEN);
+	gTotalRamLost = 0;
+	TInt r = TestSetup();
+	if (r != KErrNone)
+		{
+		test.Printf(_L("Test Setup failed, r = %d\n"), r);
+		TestCleanup();
+		return r;
+		}
+	if (gZoneCount == 1)
+		{
+		GetAllPageInfo();
+		test.Start(_L("Zone Count 1..."));
+		TestOneZoneConfig();
+		}
+	else
+		{
+		test.Start(_L("Running Alloc tests"));
+		RunAllocTests();
+		Ldd.ResetDriver();
+		Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+		test.Next(_L("Running Defrag tests"));
+		RunDefragTests();
+		Ldd.ResetDriver();
+		Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
+		}
+	test.Printf(_L("The total number of test steps failed = %d\n"), gTestStepFailed);
+	test_Equal(KErrNone, gTestStepFailed);
+	TestCleanup();
+	DeviceDriver(TEST_DRIVER_CLOSE);
+	test.End();
+	test.Close();
+	return 0;
+	}

changeset 0	a41df078684a
child 33	0173bcd7697c