// 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;