// 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\demandpaging\t_tbus_datapaging.cpp

// Functional tests for data paging.

// 002 ???

// 003 ???

//

//! @SYMTestCaseID			KBASE-T_TBUS_DATAPAGING

//! @SYMTestType			UT

//! @SYMPREQ				???

//! @SYMTestCaseDesc		Data Paging functional tests with TBusLocalDrive.

//! @SYMTestActions			001 ???

//! @SYMTestExpectedResults All tests should pass.

//! @SYMTestPriority        High

//! @SYMTestStatus          Implementation on-going

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <dptest.h>

#include <e32hal.h>

#include <u32exec.h>

#include <e32svr.h>

#include <e32panic.h>

#include "u32std.h"

#include <f32file.h>

#include <f32dbg.h>

#include <f32fsys.h>

#include "t_dpcmn.h"

#include "../secure/d_sldd.h"

#include "../mmu/mmudetect.h"

const TInt KMaxLengthOfStoreMapping = 16 + sizeof(TInt32) + KMaxMediaPassword;

const TInt KMaxPersistentStore(TPasswordStore::EMaxPasswordLength+KMaxLengthOfStoreMapping);

typedef TBuf8<KMaxPersistentStore> TPersistentStore;

RChunk gMyChunk;

TUint gOffset = 0;

TUint8* gData = NULL;

const TUint8 KClearValue = 0xed;

const TUint  KChunkSizeInPages = 64;	// 64 * 4096 = 256K

const TInt KTestBufLen=256;

#define __DECLARE_VAR_IN_CHUNK(type, varRef)											\

									type varRef = *(type*) (gData+gOffset);				\

									gOffset += Max(gPageSize, sizeof(type));			\

									test(gOffset <= gPageSize * KChunkSizeInPages);

#define __DECLARE_AND_INIT_VAR_IN_CHUNK(type, var)										\

									type &var = *(type*) (gData+gOffset);				\

									var = type();										\

									gOffset += Max(gPageSize, sizeof(type));			\

									test(gOffset <= gPageSize * KChunkSizeInPages);	

#define __DECLARE_ARRAY_IN_CHUNK(type, var, size)										\

									type *var = (type*) (gData+gOffset);				\

									gOffset += Max(gPageSize, (sizeof(type) * size));	\

									test(gOffset <= gPageSize * KChunkSizeInPages);

#define __FLUSH_AND_CALL_API_METHOD(return, function)									\

											DPTest::FlushCache(); 						\

											return = function;

LOCAL_D RFs TheFs;

TInt gFsDriveNumber	= -1;

TBool gMediaIsRam = EFalse;

RTest test(_L("T_TBUS_DATAPAGING"));

_LIT(KChunkName, "t_datapaging chunk");

const TUint KDriveAttMask = KDriveAttLocal | KDriveAttRom | KDriveAttRemote;

const TUint KMediaAttMask = KMediaAttVariableSize | KMediaAttDualDensity | KMediaAttLockable | KMediaAttLocked | KMediaAttHasPassword  | KMediaAttReadWhileWrite;

void CreatePagedChunk(TInt aSizeInPages, TInt aWipeByte = -1)

	{

	test_Equal(0,gMyChunk.Handle());

	TChunkCreateInfo createInfo;

	TInt size = aSizeInPages * gPageSize;

	createInfo.SetNormal(size, size);

	createInfo.SetPaging(TChunkCreateInfo::EPaged);

	createInfo.SetOwner(EOwnerProcess);

	createInfo.SetGlobal(KChunkName);

	if (aWipeByte != -1)

		createInfo.SetClearByte(aWipeByte);

	test_KErrNone(gMyChunk.Create(createInfo));

	test(gMyChunk.IsPaged()); // this is only ever called if data paging is supported

	gData = gMyChunk.Base();

	}

TInt TestDriveConnectAndCaps(TBusLocalDrive &aDrive, TInt &aLocalDriveNumber)

	{

	test.Next(_L("Test Drive Connect And Caps"));

	__DECLARE_VAR_IN_CHUNK(TInt, &r);

	test.Printf(_L("changeFlag...\n"));

	__DECLARE_VAR_IN_CHUNK(TBool, &changeFlag);

	changeFlag = EFalse;

	test.Printf(_L("call aDrive.Connect()...\n"));	

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.Connect(aLocalDriveNumber,changeFlag));

	test.Printf(_L("r:%d\n"),r);	

	test_Equal(KErrNone, r);

	test.Printf(_L("call aDrive.Caps()...\n"));	

	__DECLARE_VAR_IN_CHUNK(TLocalDriveCapsV5, &driveCaps);

	TPckg<TLocalDriveCapsV5> capsPckg(driveCaps); 

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.Caps(capsPckg));

	test_Equal(KErrNone, r);

	test.Printf(_L("r:%d\n"),r);

	test.Printf(_L("driveCaps.iDriveAtt			:0x%08x\n"), driveCaps.iDriveAtt);

	test.Printf(_L("driveCaps.iSize    			:%ld\n"), driveCaps.iSize);

	test.Printf(_L("driveCaps.iSerialNumLength  :%d\n"), driveCaps.iSerialNumLength);

	return I64LOW(driveCaps.iSize);

	}

void TestDriveSizeRelatedMethods(TBusLocalDrive &aDrive, TInt aNewSize, TInt aOldSize)

	{

	TInt r;

	test.Next(_L("Test Drive Size Related Methods"));

	test.Printf(_L("newDriveSize...\n"));

	__DECLARE_VAR_IN_CHUNK(TInt, &newDriveSize);

	newDriveSize = aNewSize;	

	test.Printf(_L("call aDrive.Enlarge()...\n"));

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.Enlarge(newDriveSize));

	test.Printf(_L("r:%d\n"),r);

	test((KErrNone == r) || (KErrNotSupported == r) || (KErrNotReady == r));

	if(r != KErrNone )

		{

		test.Printf(_L("errInfo...\n"));

		__DECLARE_ARRAY_IN_CHUNK(TUint8, errInfo, KTestBufLen);

		TPtr8 pErrInfoBuff(errInfo, KTestBufLen);

		__FLUSH_AND_CALL_API_METHOD(r, aDrive.GetLastErrorInfo(pErrInfoBuff));

		test.Printf(_L("r:%d\n"),r);

		test((KErrNone == r) || (KErrNotSupported == r));

		}

	test.Printf(_L("call aDrive.ReduceSize()...\n"));	

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.ReduceSize(0, aOldSize));

	test((KErrNone == r) || (KErrNotSupported == r) || (KErrNotReady == r)); 

	}

void TestWriteReadRelatedMethods(TBusLocalDrive &aDrive)

	{

	test.Next(_L("Test Write & Read Related Methods"));

	__DECLARE_VAR_IN_CHUNK(TInt, &r);

	test.Printf(_L("msgHandle...\n"));

	__DECLARE_VAR_IN_CHUNK(TInt, &msgHandle);

	msgHandle = KLocalMessageHandle;

	__DECLARE_VAR_IN_CHUNK(TUint, &i);

	test.Printf(_L("wrBuf...\n"));	

	TBuf8<KTestBufLen> wrBuf(KTestBufLen);

	for (i=0 ; i<(TUint)KTestBufLen ; i++)

		wrBuf[i]=(TUint8)i;

	test.Printf(_L("wrBuf2...\n"));

	__DECLARE_ARRAY_IN_CHUNK(TUint8, wrBuf2, KTestBufLen);

	test.Printf(_L("fill wrBuf2...\n"));

	for (i=0 ; i<(TUint)KTestBufLen ; i++)

		wrBuf2[i]=(TUint8)i;

	TPtr8 pWrBuf2(wrBuf2, KTestBufLen, KTestBufLen);

	test.Printf(_L("rdBuf...\n"));

	TBuf8<KTestBufLen> rdBuf(KTestBufLen);

	test.Printf(_L("rdBuf2...\n"));

	__DECLARE_ARRAY_IN_CHUNK(TUint8, rdBuf2, KTestBufLen);

	TPtr8 pRdBuf2(rdBuf2, KTestBufLen);

	test.Printf(_L("call aDrive.Write()...\n"));	

	rdBuf.Fill(0,KTestBufLen);

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.Write(0,KTestBufLen,&wrBuf,msgHandle,0));

	test_Equal(KErrNone, r);

	test.Printf(_L("call aDrive.Read()...\n"));	

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.Read(0,KTestBufLen,&rdBuf,msgHandle,0));

	test_Equal(KErrNone, r);

	for (i=0 ; i<(TUint)KTestBufLen ; i++)

		test_Equal(wrBuf[i], rdBuf[i]);

	test.Printf(_L("call aDrive.Write()...\n"));	

	pRdBuf2.Fill(0,KTestBufLen);

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.Write(0,pWrBuf2));

	test_Equal(KErrNone, r);

	test.Printf(_L("call aDrive.Read()...\n"));	

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.Read(0,KTestBufLen, pRdBuf2));

	test_Equal(KErrNone, r);

	for (i=0 ; i<(TUint)KTestBufLen ; i++)

		test_Equal(wrBuf2[i], rdBuf2[i]);

	}

void TestPasswordRelatedMethods(TBusLocalDrive &aDrive)

	{

	TInt r;

	test.Next(_L("Test Password Related Methods"));

	//__DECLARE_VAR_IN_CHUNK(TPersistentStore, &wStore);

	TPersistentStore* pstoreAB;

	test((pstoreAB = new TPersistentStore) != 0);

	TPersistentStore& wStore = *pstoreAB;

	//__DECLARE_AND_INIT_VAR_IN_CHUNK(TPersistentStore, wStore);

	// Password related API methods call

	test.Printf(_L("call aDrive.WritePasswordData() to clear passwords...\n"));	

	__DECLARE_VAR_IN_CHUNK(TInt, &passwordStoreLength);

	TBuf8<1> nulSt;

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.WritePasswordData(nulSt));

	test( r == KErrNone);// empty

	test.Printf(_L("call aDrive.PasswordStoreLengthInBytes()...\n"));	

	__FLUSH_AND_CALL_API_METHOD(passwordStoreLength, aDrive.PasswordStoreLengthInBytes());

	test.Printf(_L("passwordStoreLength:%d\n"), passwordStoreLength);

	test_Equal(0, passwordStoreLength);

	test.Printf(_L("call aDrive.ErasePassword()...\n"));	

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.ErasePassword());

	test.Printf(_L("r:%d\n"),r);

	test.Printf(_L("wStore.Size():%d\n"),wStore.Size());

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.WritePasswordData(wStore));

	test.Printf(_L("r:%d\n"),r);

	test((KErrNone == r)); // || (KErrCorrupt == r));		// TO-DO Why Corrupt???

	__FLUSH_AND_CALL_API_METHOD(passwordStoreLength, aDrive.PasswordStoreLengthInBytes());

	test.Printf(_L("passwordStoreLength:%d\n"), passwordStoreLength);

	test((r == KErrNone ?  (wStore.Size() == passwordStoreLength) : (0 == passwordStoreLength) ));

	test.Printf(_L("Set and store a password...\n"));		

	TDes8 &st = wStore;

	TMediaPassword a((const TUint8*) "CID0ccccccccccc#");

	TUint8 passLen[sizeof(TInt32)];

	passLen[0] = 0;

	passLen[1] = 0;

	passLen[2] = 0;

	passLen[3] = 16;

	//test.Printf(_L("Password3:'%S'\n"), &a);

	st.Append(a);

	st.Append(passLen, sizeof(TInt32));

	st.Append(a);

	test.Printf(_L("wStore.Size():%d\n"),wStore.Size());

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.WritePasswordData(wStore));

	test.Printf(_L("r:%d\n"),r);

	test((KErrNone == r));

	__FLUSH_AND_CALL_API_METHOD(passwordStoreLength, aDrive.PasswordStoreLengthInBytes());

	test.Printf(_L("passwordStoreLength:%d\n"), passwordStoreLength);

	test((r == KErrNone ?  (wStore.Size() == passwordStoreLength) : (0 == passwordStoreLength) ));

	test.Printf(_L("call aDrive.ErasePassword()...\n"));	

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.ErasePassword());

	test.Printf(_L("r:%d\n"),r);

	test.Printf(_L("call aDrive.WritePasswordData() to set password again...\n"));	

	test.Printf(_L("wStore.Size():%d\n"),wStore.Size());

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.WritePasswordData(wStore));

	test.Printf(_L("r:%d\n"),r);

	test((KErrNone == r));

	__FLUSH_AND_CALL_API_METHOD(passwordStoreLength, aDrive.PasswordStoreLengthInBytes());

	test.Printf(_L("passwordStoreLength:%d\n"), passwordStoreLength);

	test((r == KErrNone ?  (wStore.Size() == passwordStoreLength) : (0 == passwordStoreLength) ));

	// Finally erase password

	test.Printf(_L("call aDrive.WritePasswordData() to erase password...\n"));		

	wStore.Zero();	// empty password store

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.WritePasswordData(wStore))

	test( r == KErrNone);// Clear

	__FLUSH_AND_CALL_API_METHOD(passwordStoreLength, aDrive.PasswordStoreLengthInBytes());

	test.Printf(_L("passwordStoreLength:%d\n"), passwordStoreLength);

	test((r == KErrNone ?  (wStore.Size() == passwordStoreLength) : (0 == passwordStoreLength) ));

	// Test SetPassword

	TMediaPassword nul(nulSt);

	test.Printf(_L("call aDrive.SetPassword()...\n"));	

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.SetPassword(nul, a, EFalse));

	test.Printf(_L("r:%d\n"),r);

	test_Equal(KErrNone, r);

	// Erase Password

	test.Printf(_L("call aDrive.ErasePassword()...\n"));	

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.ErasePassword());

	test.Printf(_L("r:%d\n"),r);

	test.Printf(_L("call aDrive.SetPassword()...\n"));	

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.SetPassword(nul, a, EFalse));

	test.Printf(_L("r:%d\n"),r);

	test_Equal(KErrNone, r);

	// Erase Clear

	test.Printf(_L("call aDrive.Clear()...\n"));	

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.Clear(a));

	test.Printf(_L("r:%d\n"),r);

	test.Printf(_L("call aDrive.SetPassword() to clear again...\n"));	

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.SetPassword(a, nul, EFalse));

	test.Printf(_L("r:%d\n"),r);

	test_Equal(KErrAccessDenied, r);

	// Finally erase password

	test.Printf(_L("call aDrive.WritePasswordData() to erase password...\n"));		

	wStore.Zero();	// empty password store

	__FLUSH_AND_CALL_API_METHOD(r, aDrive.WritePasswordData(wStore))

	test( r == KErrNone);// Clear

	__FLUSH_AND_CALL_API_METHOD(passwordStoreLength, aDrive.PasswordStoreLengthInBytes());

	test.Printf(_L("passwordStoreLength:%d\n"), passwordStoreLength);

	test((r == KErrNone ?  (wStore.Size() == passwordStoreLength) : (0 == passwordStoreLength) ));

	}

void TestFormatRelatedMethods(TBusLocalDrive &aDrive, TInt aSize )

	{

	test.Next(_L("Test Format Related Methods"));	

	test.Printf(_L("call aDrive.Format(TFormatInfo)...\n"));	

	__DECLARE_AND_INIT_VAR_IN_CHUNK(TFormatInfo, fi);

	__DECLARE_VAR_IN_CHUNK(TInt, &ret);

	__DECLARE_VAR_IN_CHUNK(TInt, &attempt);

	__FLUSH_AND_CALL_API_METHOD(ret, aDrive.Format(fi));

	test.Printf(_L("ret:%d\n"),ret);

	while(ret!=KErrEof)

		{

		if( ret == KErrNotReady )

			{

			attempt = 100;

			while( (ret= aDrive.Format(fi)) == KErrNotReady && --attempt)

				{

				test.Printf(_L("attempt:%d\n"),attempt);

				User::After(1000000);

				}	

			test(attempt);

			}

		else

			{

			test(ret==KErrNone);

			ret= aDrive.Format(fi);	

			}		

		}

	test.Printf(_L("call aDrive.Format(pos, length)...\n"));	

	User::After(1000000);

	__DECLARE_VAR_IN_CHUNK(TInt64, &pos);

	pos = 0;

	__DECLARE_VAR_IN_CHUNK(TInt, &length);

	length = aSize;

	attempt = 100;

	__FLUSH_AND_CALL_API_METHOD(ret, aDrive.Format(pos, length));

	while( ret == KErrNotReady && --attempt)

		{

		User::After(1000000);

		ret= aDrive.Format(pos, length);

		}	

	test(attempt);

	test_Equal(KErrNone, ret);

	test.Printf(_L("End of TestFormatRelatedMethods)...\n"));

	}

void RestoreDriveState(void)

	{

	TBuf<3> bfDrv;

	const TText KDrvLtr = 'A' + gFsDriveNumber;

	bfDrv.Append(KDrvLtr);

	_LIT(KBP, ":\\");

	bfDrv.Append(KBP);

	TheFs.Connect();

	RFormat fmt;

	TInt count;

	test(fmt.Open(TheFs, bfDrv, EHighDensity, count) == KErrNone);

	while (count > 0)

		{

		test.Printf(_L("\rfmt:%d  "), count);

		test(fmt.Next(count) == KErrNone);

		}

	test.Printf(_L("\n"));

	fmt.Close();

	TheFs.Close();

	}

TInt FindDataPagingDrive()

/** 

Find the drive containing a swap partition.

@return		Local drive identifier.

*/

	{

	TInt drive = KErrNotFound;

	test.Printf(_L("Searching for data paging drive:\n"));

	for(TInt i = 0; i < KMaxLocalDrives && drive < 0; ++i)

		{

		RLocalDrive	d;

		TBool change = EFalse;

		if(d.Connect(i, change) == KErrNone)

			{

			TLocalDriveCapsV4			dc;

			TPckg<TLocalDriveCapsV4>	capsPack(dc);

			if(d.Caps(capsPack) == KErrNone)

				{

				if ((dc.iMediaAtt & KMediaAttPageable) &&

					(dc.iPartitionType == KPartitionTypePagedData))

					{

					test.Printf(_L("Found swap partition on local drive %d\n"), i);

					drive = i;

					TPageDeviceInfo pageDeviceInfo;

					TPtr8 pageDeviceInfoBuf((TUint8*) &pageDeviceInfo, sizeof(pageDeviceInfo));

					pageDeviceInfoBuf.FillZ();

					TInt r = d.QueryDevice(RLocalDrive::EQueryPageDeviceInfo, pageDeviceInfoBuf);

					test.Printf(_L("EQueryPageDeviceInfo on local drive %d returned %d\n"), i, r);

					}

				}

			d.Close();

			}

		}

	return drive;

	}

TDes& GetSerialNumber(TLocalDriveCapsV5& aCaps)

	{

	static TBuf16<80> serialNumBuf;

	serialNumBuf.SetLength(0);

	for (TUint n=0; n<aCaps.iSerialNumLength; n+=16)

		{

		for (TUint m=n; m<n+16; m++)

			{

			TBuf16<3> hexBuf;

			hexBuf.Format(_L("%02X "), aCaps.iSerialNum[m]);

			serialNumBuf.Append(hexBuf);

			}

		}

	return serialNumBuf;

	}

TDes& GetSerialNumber(TMediaSerialNumber& aSerialNum)

	{