// 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 <e32svr.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));