// Copyright (c) 1998-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:

 // f32test\server\t_pwstr.cpp

 // Tests peripheral bus controller password store.

 // 

 //

 //#include <p32mmc.h>

 #include <e32test.h>

 #include <f32fsys.h>

 #include <e32def.h>

 #include <e32def_private.h>

 #include <e32hal.h>

 // define this macro to autodetect card re-insertion

 #define __AUTO_DETECT_MEDIA_CHANGE__

 const TUint KMMCCIDLength=16;

 class TCID

 	{

 public:

 	inline TCID() {}					// Default constructor

 	inline TCID(const TUint8*);

 	inline TCID& operator=(const TCID&);

 	inline TCID& operator=(const TUint8*);

 	inline TBool operator==(const TCID&) const;

 	inline TBool operator==(const TUint8*) const;

 	inline void Copy(TUint8*) const;		// Copies big endian 16 bytes CID

 	inline TUint8 At(TUint anIndex) const;	// Byte from CID at anIndex

 //private:

 public:

 	TUint8 iData[KMMCCIDLength];		// Big endian 128 bit bitfield representing CID

 	};

 class TMMC

 	{

 public:

 	static inline TUint32 BigEndian32(const TUint8*);

 	static inline void BigEndian4Bytes(TUint8* aPtr, TUint32 aVal);

 	};

 //	--------  class TCID  --------

 inline TCID::TCID(const TUint8* aPtr)

 	{memcpy(&iData[0], aPtr, KMMCCIDLength);}

 inline TCID& TCID::operator=(const TCID& aCID)

 	{memcpy(&iData[0], &aCID.iData[0], KMMCCIDLength); return(*this);}

 inline TCID& TCID::operator=(const TUint8* aPtr)

 	{memcpy(&iData[0], aPtr, KMMCCIDLength); return(*this);}

 inline TBool TCID::operator==(const TCID& aCID) const

 	{return(memcompare(&iData[0],KMMCCIDLength,&aCID.iData[0],KMMCCIDLength)==0);}

 inline TBool TCID::operator==(const TUint8* aPtr) const

 	{return(memcompare(&iData[0],KMMCCIDLength,aPtr,KMMCCIDLength)==0);}

 inline void TCID::Copy(TUint8* aPtr) const

 	{memcpy(aPtr, &iData[0], KMMCCIDLength);}

 inline TUint8 TCID::At(TUint anIndex) const

 	{return(iData[KMMCCIDLength-1-anIndex]);}

 inline TUint32 TMMC::BigEndian32(const TUint8* aPtr)

 	{return( (aPtr[0]<<24) | (aPtr[1]<<16) | (aPtr[2]<<8) | (aPtr[3]) );}

 inline void TMMC::BigEndian4Bytes(TUint8* aPtr, TUint32 aVal)

 	{

 	aPtr[0] = (TUint8)((aVal >> 24) & 0xFF);

 	aPtr[1] = (TUint8)((aVal >> 16) & 0xFF);

 	aPtr[2] = (TUint8)((aVal >> 8) & 0xFF);

 	aPtr[3] = (TUint8)(aVal & 0xFF);

 	}

 // Static data.

 LOCAL_D RTest test(_L("T_PWSTR"));

 LOCAL_D TBusLocalDrive TBLD;

 LOCAL_D TBool TBLDChangedFlag;

 LOCAL_D TInt TBLDNum = -1; 	// Change this to specify the drive under test

 							// e.g. for the lm_pana board when fitted to the

 							// integrator, TBLDNum should be set to 3.

 LOCAL_D TInt RFsDNum = -1;	// File Server Drive number

 struct TTestMapping

 	{

 	TInt iCIDIdx;							// index in CID

 	TInt iPWDIdx;							// index in PWD

 	};

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

 // EMaxPasswordLength is max size of the password store descriptor

 // (which actually contains multiple mappings of CID and passwords)

 const TInt KMaxNumOfStoreEntries= TPasswordStore::EMaxPasswordLength/KMaxLengthOfStoreMapping;

 const TInt KPWDCnt(4);

 LOCAL_C TMediaPassword *PWDs[KPWDCnt];

 //Allocate enough unique CIDs to be able to overflow the store 

 const TInt KCIDCnt(KMaxNumOfStoreEntries+1);

 LOCAL_C TCID *CIDs[KCIDCnt];

 //Let the descriptor be one mapping longer than allowed by the password

 //store to test overflowing it.

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

 typedef TBuf8<KMaxPersistentStore> TPersistentStore;

 LOCAL_C TInt mapSizes[KCIDCnt][KPWDCnt];

 // Static function prototypes.

 LOCAL_C void AllocateTestData();

 LOCAL_C void DeleteTestData();

 LOCAL_C void AllocateCIDs();

 LOCAL_C void DeleteCIDs();

 LOCAL_C void AllocatePasswords();

 LOCAL_C void DeletePasswords();

 LOCAL_C void SetUpMapSizes();

 LOCAL_C void AddMapping(TDes8 &aSt, const TCID *aCID, const TMediaPassword *aPWD);

 LOCAL_C void DumpStore(const TDesC &aName, const TDesC8 &aSt);

 LOCAL_C TBool StoresEqual(const TDesC8 &aSt0, const TDesC8 &aSt1);

 LOCAL_C TBool IsStoreValid(const TDesC8 &aSt);

 LOCAL_C void PrintCID(const TCID &aCID);

 LOCAL_C void ParseStore(const TDesC8 &aStore, CArrayFixSeg<TTestMapping> *aMP);

 LOCAL_C void TestStaticStore();

 LOCAL_C void RemountMedia();

 LOCAL_C void AttemptToUnlock(TMediaPassword &aPWD, TBool aStore = EFalse);

 LOCAL_C void TestLockUnlock();

 LOCAL_C void TestElidePasswords();

 LOCAL_C void TestNullPasswords();

 LOCAL_C void TestControllerStore();

 LOCAL_C TInt AccessDisk();

 LOCAL_C void TestAutoUnlock();

 LOCAL_C void RunTests();

 // Test data

 LOCAL_C void AllocateCIDs()

 //

 // Allocates a set of static global media identifiers on the heap.

 // The identifiers are all exactly 128 bits.

 // Because the test uses only one card, CIDs 1 through 3 can be arbitrary

 // (they are just used to construct store data.)

 // 

 // Format is "CIDXccccccccccc#", where X is the ASCII digit for the index.

 // The CID is stored internally in big endian format.

 // TCID::At(TInt i) returns the i'th byte, i.e. cid >> (i * 8) & 0xff, which

 // is the opposite order to the way they are stored in the array.

 // CIDs are formed in the same way in pp_mmc.cpp, the WINS ASSP layer.

 //

 // For actual card tests, CIDs[0] must correspond to the card's actual CID.

 //

 	{

 #if 1

 	static TUint8 ht0[KMMCCIDLength] =			// CID0

 		{

 		0x06,	0x00,	0x00,	0x31,

 		0x36,	0x4d,	0x20,	0x20,

 		0x20,	0x00,	0xb4,	0xff,

 		0xff,	0xff,	0x63,	0xd9

 		};

 #else

 	static TUint8 ht0[KMMCCIDLength] =			// BPC2

 		{

 		0x06,	0x00,	0x00,	0x31,

 		0x36,	0x4d,	0x20,	0x20,

 		0x20,	0x00,	0x89,	0xff,

 		0xff,	0xff,	0x63,	0xa7

 		};

 #endif

 	test.Start(_L("AllocateCIDs"));

 	TInt i;

 	for (i = 0; i < KCIDCnt; i++)

 		{

 		TUint8 bf[KMMCCIDLength];

 		TUint j;

 		bf[0] = 'C';

 		bf[1] = 'I';

 		bf[2] = 'D';

 		bf[3] = TUint8('0' + i);

 		for (j = 4; j < KMMCCIDLength - 1; j++)

 			bf[j] = 'c';

 		bf[KMMCCIDLength - 1] = '#';

 		if (i == 0)

 			{

 			TUint cidIdx = 0;

 			TLocalDriveCapsV5 driveCaps;

 			TPckg<TLocalDriveCapsV5> driveCapsPkg(driveCaps);	

 			if(TBLD.Caps(driveCapsPkg) == KErrNone)

 				{

 				// V5 of TLocalDriveCapsV5 now contains a serial number

 				// which for MMC cards is defined to be the unique CID

 				if(driveCaps.iSerialNumLength == KMMCCIDLength)

 					{

 					for(cidIdx=0; cidIdx<KMMCCIDLength; cidIdx++)

 						{

 						bf[cidIdx] = driveCaps.iSerialNum[KMMCCIDLength-cidIdx-1];

 						}

 					}

 				}

 			if(cidIdx == KMMCCIDLength)

 				{

 				test((CIDs[i] = new TCID(bf)) != NULL);

 				}

 			else

 				{

 #ifdef __WINS__

 				test((CIDs[i] = new TCID(bf)) != NULL);

 #else

 				test((CIDs[i] = new TCID(ht0)) != NULL);

 #endif

 				}

 			}

 		else

 			{

 			test((CIDs[i] = new TCID(bf)) != NULL);

 			}

 		}

 	test.End();

 	}

 LOCAL_C void DeleteCIDs()

 //

 // Deletes static global media identifiers from the heap.

 //

 	{

 	test.Start(_L("DeleteCIDs"));

 	TInt i;

 	for (i = 0; i < KCIDCnt; i++)

 		delete CIDs[i];

 	test.End();

 	}

 LOCAL_C void AllocatePasswords()

 //

 // Allocates a set of static global TMediaPassword objects on the heap.

 // The passwords range from zero to 16 bytes in length.

 //

 	{

 	test.Start(_L("AllocatePasswords"));

 	TInt i;

 	for (i = 0; i < KPWDCnt; i++)

 		{

 		test((PWDs[i] = new TMediaPassword) != NULL);

 		TInt j;

 		for (j = 0; j < i * 2; j++)

 			PWDs[i]->Append(TChar('a' + i + j));

 		}

 	test.End();

 	}

 LOCAL_C void DeletePasswords()

 //

 // Deletes static global TMediaPassword objects from the heap.

 //

 	{

 	test.Start(_L("DeletePasswords"));

 	TInt i;

 	for (i = 0; i < KPWDCnt; i++)

 		delete PWDs[i];

 	test.End();

 	}

 LOCAL_C void SetUpMapSizes()

 //

 // Initializes static global mapSizes[,] with the persistent store mapping

 // sizes of each CID and password.

 //

 	{

 	test.Start(_L("SetUpMapSizes"));

 	TInt i;

 	for (i = 0; i < KCIDCnt; i++)

 		{

 		TInt j;

 		for (j = 0; j < KPWDCnt; j++)

 			mapSizes[i][j] = KMMCCIDLength + sizeof(TInt32) + PWDs[j]->Length();

 		}

 	test.End();

 	}

 LOCAL_C void AllocateTestData()

 //

 // Allocates all test data objects on the heap.

 //

 	{

 	AllocateCIDs();

 	AllocatePasswords();

 	SetUpMapSizes();

 	}

 LOCAL_C void DeleteTestData()

 //

 // Frees all test data objects on the heap.

 //

 	{

 	DeletePasswords();

 	DeleteCIDs();

 	}

 // Test functions.

 LOCAL_C void TestStaticStore()

 //

 // Tests the non card specific virtual functions in DPeriphBusController.

 //	TInt ReadPasswordData(TDes8 &aBuf);

 //	TInt WritePasswordData(const TDesC8 &aBuf);

 //	TInt PasswordStoreLengthInBytes();

 //

 // store is reset at start of DMMCController::WritePasswordData().

 //

 	{

 	test.Start(_L("TestStore"));

 	// TBuf8<KMaxPersistentStore> is 4 + 4 + 256 bytes, so allocate on heap.

 	TPersistentStore *pwStore;

 	test((pwStore = new TPersistentStore) != NULL);

 	TPersistentStore &wStore = *pwStore;

 	TPersistentStore *prStore;

 	test((prStore = new TPersistentStore) != NULL);

 	TPersistentStore &rStore = *prStore;

 	// WritePasswordData()

 	test.Next(_L("WritePasswordData()"));

 	test(TBLD.WritePasswordData(wStore) == KErrNone);// empty

 	test(TBLD.PasswordStoreLengthInBytes() == 0);

 	AddMapping(wStore, CIDs[1], PWDs[1]);						// exactly one entry

 	test(TBLD.WritePasswordData(wStore) == KErrNone);

 	test(TBLD.PasswordStoreLengthInBytes() == mapSizes[1][1]);

 	AddMapping(wStore, CIDs[2], PWDs[2]);						// exactly two entries

 	test(TBLD.WritePasswordData(wStore) == KErrNone);

 	test(TBLD.PasswordStoreLengthInBytes() == mapSizes[1][1] + mapSizes[2][2]);

 	TInt i;

 	for (i = 0; i < wStore.Length(); i++)						// corrupt (partial)

 		{

 		wStore.SetLength(i);

 		TInt r(TBLD.WritePasswordData(wStore));

 		if (i == 0 || i == mapSizes[0][0] || i == mapSizes[0][0] + mapSizes[1][1])

 			test(r == KErrNone);

 		else

 			test(r == KErrCorrupt && TBLD.PasswordStoreLengthInBytes() == 0);

 		}

 	test.Next(_L("Exceeding password store size"));	

 	wStore.Zero();	// empty password store

 	test(TBLD.WritePasswordData(wStore) == KErrNone);

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

 	const TMediaPassword password(_L8("abcdefghijklmnop")); //Need a max length password (KMaxMediaPassword)

 	for(TInt n=0; n<KCIDCnt; ++n)

 		{

 		AddMapping(wStore, CIDs[n], &password);

 		test.Printf(_L("Mapping:%d store size: %d bytes\n"),n , wStore.Length() );

 		const TInt r = TBLD.WritePasswordData(wStore);

 		test.Printf(_L("WritePasswordData() --> ret=%d\n"), r);

 	 	if(n==KMaxNumOfStoreEntries)

 	 		test(r == KErrOverflow);

 	 	else

 	 		test(r == KErrNone);	

 		}

 	// ReadPasswordData().

 	test.Next(_L("ReadPasswordData()"));

 	wStore.Zero();												// empty

 	test(TBLD.WritePasswordData(wStore) == KErrNone);

 	test(TBLD.ReadPasswordData(rStore) == KErrNone);

 	test(rStore.Length() == 0);

 	AddMapping(wStore, CIDs[1], PWDs[1]);						// exactly one entry

 	test(TBLD.WritePasswordData(wStore) == KErrNone);

 	rStore.SetLength(0);										// lt store len

 	test(TBLD.ReadPasswordData(rStore) == KErrNone);

 	test(rStore.Length() == TBLD.PasswordStoreLengthInBytes());

 																// gt store len

 	rStore.SetLength(TBLD.PasswordStoreLengthInBytes() + 4);

 	test(TBLD.ReadPasswordData(rStore) == 0);

 	test(rStore.Length() == TBLD.PasswordStoreLengthInBytes());

 	TBuf8<2> srStore;											// max lt store len

 	test(TBLD.ReadPasswordData(srStore) == KErrOverflow);

 	// Stress test high turnover with memory failure.

 	test.Next(_L("Memory test"));

 	TInt r;										// error code

 	TInt m;

 	for (m = 1; m < 100; m++)

 		{

 		__KHEAP_SETFAIL(RHeap::EDeterministic, m);

 		TInt j;

 		for (j = 1; j < KCIDCnt - 1; j++)

 			{

 			TInt k;

 			for (k = 1; k < KPWDCnt - 1; k++)

 				{

 				wStore.Zero();

 				AddMapping(wStore, CIDs[j], PWDs[k]);

 				AddMapping(wStore, CIDs[j + 1], PWDs[k + 1]);

 				if ((r = TBLD.WritePasswordData(wStore)) != KErrNone)

 					{

 					test(r == KErrNoMemory);

 					test(TBLD.PasswordStoreLengthInBytes() == 0);

 					}

 				else

 					{

 					test(TBLD.ReadPasswordData(rStore) == KErrNone);

 					test(IsStoreValid(rStore) && StoresEqual(rStore, wStore));

 					}

 				}

 			}

 		__KHEAP_RESET;

 		}	// for (m = 1; m < 16; m++)

 	// Clear the store for subsequent tests.

 	wStore.Zero();

 	test(TBLD.WritePasswordData(wStore) == KErrNone);

 	test(TBLD.PasswordStoreLengthInBytes() == 0);

 	delete prStore;

 	delete pwStore;

 	test.End();

 	}

 LOCAL_C void AddMapping(TDes8 &aSt, const TCID *aCID, const TMediaPassword *aPWD)

 //

 // Adds aCID |-> aPWD mapping to persistent file's store contents.

 //

 	{

 	aSt.SetLength(aSt.Length() + KMMCCIDLength);

 	aCID->Copy(&aSt[aSt.Length() - KMMCCIDLength]);

 	TUint8 lenBuf[sizeof(TInt32)];		// TInt32, big endian

 	TMMC::BigEndian4Bytes(lenBuf, TInt32(aPWD->Length()));

 	aSt.Append(&lenBuf[0], sizeof(TInt32));

 	aSt.Append(*aPWD);

 	}

 LOCAL_C TBool IsStoreValid(const TDesC8 &aSt)

 // 

 // Checks the integrity of the supplied buffer.

 // 

 	{

 	TInt iBIdx;									// buffer index

 	TBool corrupt(EFalse);						// abort flag

 	for (iBIdx = 0; iBIdx < aSt.Length(); /* nop */)

 		{

 		// Enough raw data for CID, PWD_LEN and 1 byte of PWD.

 		corrupt = TUint(aSt.Length() - iBIdx) < KMMCCIDLength + sizeof(TInt32) + 1;

 		if (corrupt)

 			break;

 		// PWD_LEN is valid and enough raw data left for PWD.

 		iBIdx += KMMCCIDLength;

 		const TInt32 pwd_len(TMMC::BigEndian32(aSt.Mid(iBIdx).TDesC8::Ptr()));

 		corrupt = !(

 				(pwd_len <= KMaxMediaPassword)

 			&&	aSt.Length() - iBIdx >= TInt(sizeof(TInt32)) + pwd_len );

 		if (corrupt)

 			break;

 		// skip over PWD_LEN and PWD to next entry.

 		iBIdx += sizeof(TInt32) + pwd_len;

 		}

 	if (corrupt)

 		DumpStore(_L("invalid"), aSt);

 	return ! corrupt;

 	}

 LOCAL_C void PrintCID(const TCID &aCID)

 //

 // Prints the 128 bit CID in big endian format.

 //

 	{

 	test.Printf(_L("CID: "));

 	TInt i;

 	for (i = 0; i < TInt(KMMCCIDLength); i += 4)

 		{

 		TInt j;

 		for (j = i; j < i + 4; ++j)

 			{

 			test.Printf(_L("%02x: %02x "), j, aCID.At(KMMCCIDLength - j - 1));

 			}

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

 		}

 	}

 LOCAL_C void ParseStore(const TDesC8 &aSt, CArrayFixSeg<TTestMapping> *aMP)

 //

 // Fills aMP with the mappings in aSt.

 //

 	{

 	TInt iBIdx;									// buffer index

 	TInt r(KErrNone);							// exit code

 	for (iBIdx = 0; r == KErrNone && iBIdx < aSt.Length(); /* nop */)

 		{

 		// Calculate index for CID.

 		TPtrC8 pCID(aSt.Mid(iBIdx, KMMCCIDLength));	// CID

 		const TCID cid(pCID.Ptr());

 		TInt cidIdx;

 		for (cidIdx = 0; cidIdx < KCIDCnt && !(*(CIDs[cidIdx]) == cid); cidIdx++)

 			{ /* empty. */ }

 		// If invalid CID then print CID with valid CIDs.

 		if (!(cidIdx < KCIDCnt))

 			{

 			test.Printf(_L("ParseStore: invalid CID\n"));

 			PrintCID(cid);

 			TInt i;

 			for (i = 0; i < KCIDCnt; i++)

 				{

 				test.Printf(_L("ParseStore: valid CID %d\n"), i);

 				PrintCID(*CIDs[i]);

 				}

 			test(EFalse);

 			}

 		const TInt32 pwd_len(TMMC::BigEndian32(&aSt[iBIdx + KMMCCIDLength]));

 		// Calculate index for PWD.

 		TMediaPassword pwd;

 		pwd.Copy(&aSt[iBIdx + KMMCCIDLength + sizeof(TInt32)], pwd_len);

 		TInt pwdIdx;

 		for (pwdIdx = 0; pwdIdx < KPWDCnt && *PWDs[pwdIdx] != pwd; pwdIdx++)

 			{ /* empty. */ }

 		test(pwdIdx < KPWDCnt);

 		TTestMapping mp;

 		mp.iCIDIdx = cidIdx;

 		mp.iPWDIdx = pwdIdx;

 		TRAP(r, aMP->InsertL(0, mp));

 		test(r == KErrNone);

 		iBIdx += KMMCCIDLength + sizeof(TInt32) + pwd_len;

 		}

 	}

 LOCAL_C void DumpStore(const TDesC &aName, const TDesC8 &aSt)

 //

 // Prints the contents of the supplied store.

 //

 	{

 	test.Printf(_L("\nstore %S: len = %d\n"), &aName, aSt.Length());

 	TInt i;

 	for (i = 0; i < aSt.Length(); i += 8)

 		{

 		TInt j;

 		for (j = i; j < Min(aSt.Length(), i + 8); j++)

 			test.Printf(_L("%02d: %03d : %02x : %c \n "), j, aSt[j], aSt[j], aSt[j]);

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

 		}

 	}

 LOCAL_C TBool StoresEqual(const TDesC8 &aSt0, const TDesC8 &aSt1)

 //

 // Compares aSt1 with aSt2.  Return value indicates whether or not the

 // stores contain exactly the same mappings, but not necessarily in the

 // same order.

 //

 	{

 	TBool same(EFalse);

 	CArrayFixSeg<TTestMapping> *ramp0, *ramp1;

 	test((ramp0 = new(ELeave) CArrayFixSeg<TTestMapping>(2)) != NULL);

 	test((ramp1 = new(ELeave) CArrayFixSeg<TTestMapping>(2)) != NULL);

 	test(IsStoreValid(aSt0));

 	test(IsStoreValid(aSt1));

 	ParseStore(aSt0, ramp0);

 	ParseStore(aSt1, ramp1);

 	TArray<TTestMapping> a0(ramp0->Array());

 	TArray<TTestMapping> a1(ramp1->Array());

 	if (a0.Count() == a1.Count())

 	// if #a0 == #a1 and a0 <= a1 then a0 == a1.

 		{

 		TBool allInA1(ETrue);

 		TInt i;

 		for (i = 0; allInA1 && i < a0.Count(); i++)

 			{

 			TBool found(EFalse);

 			TInt j;

 			for (j = 0; ! found && j < a0.Count(); j++)

 				{

 				found = (

 						a0[i].iCIDIdx == a1[j].iCIDIdx

 					&&	a0[i].iPWDIdx == a1[j].iPWDIdx );

 				}

 			allInA1 = found;

 			}

 		same = allInA1;

 		}

 	delete ramp1;

 	delete ramp0;

 	if (! same)

 		{

 		DumpStore(_L("0"), aSt0);

 		DumpStore(_L("1"), aSt1);

 		}

 	return same;

 	}

 LOCAL_C void RemountMedia()

 //

 // Forces a media remount and waits for it to take effect.  If the card has a

 // password, it will become locked the next time that it is powered up.

 //

 	{

 //#ifdef __WINS__

 //	TBLD.ForceMediaChange();

 //	UserSvr::ForceRemountMedia(ERemovableMedia0);

 //	User::After(1 * 1000 * 1000);

 //#else

 #ifdef __AUTO_DETECT_MEDIA_CHANGE__

 	RFs fs;

 	test(fs.Connect() == KErrNone);

 	test.Printf(_L("Remove and re-insert card.."));

 	TInt r;

 	do

 		{

 		TRequestStatus status;

 		TDriveUnit driveUnit(RFsDNum);

 		TDriveName driveName = driveUnit.Name();

 		fs.NotifyChange(ENotifyAll, status, driveName);

 		test(status == KRequestPending);

 		User::WaitForRequest(status);

 		test.Printf(_L("\rAccessing card...          \r"));

 		r = AccessDisk();

 		if (r == KErrNotReady)

 			test.Printf(_L("\rRemove and re-insert card.."));

 		if (r != KErrNone && r != KErrNotReady && r != KErrLocked)

 			test.Printf(_L("AccessDisk() returned %d"), r);

 		}

 	while (r == KErrNotReady);

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

 	fs.Close();

 #else

 	// Power down the card so that it is locked the next time it is powered up.

 	test.Printf(_L("Remove and re-insert card.  Press \'z\' when finished.\n"));

 	while (test.Getch() != 'z')

 		{ /* empty. */ }

 #endif

 //#endif

 	}

 LOCAL_C void AttemptToUnlock(TMediaPassword &aPWD, TBool aStore)

 //

 // Tests that the card is locked and then tries to unlock it.

 //

 	{

 	TInt r = AccessDisk();

 	if (r != KErrLocked)

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

 	test(r == KErrLocked);

 	test(TBLD.Unlock(aPWD, aStore) == KErrNone);

 	}

 LOCAL_C void TestLockUnlock()

 //

 // Tests TBusLocalDrive functions for locking / unlocking individual cards.

 // Lock() currently means set password only.  The media must be remounted before it

 // can really be locked.

 //

 //			EPbPswdUnlock		EPbPswdLock			EPbPswdClear

 //			right	wrong		right	wrong		right	wrong	

 // locked	None	AccDen		AccDec	AccDen		AccDen	AccDen	

 // unlocked	AldExst	AldExst		None	AccDec		None	AccDen	

 //

 // Locked means inaccessible, not just has password.

 // 

 	{

 	test.Start(_L("TestLockUnlock"));

 	TMediaPassword nul(*PWDs[0]);

 	TMediaPassword arb1(*PWDs[1]);

 	TMediaPassword arb2(*PWDs[2]);

 	// Clear the password store for when function run on its own.

 	TBuf8<1> nulSt;

 	test(TBLD.WritePasswordData(nulSt) == KErrNone);// empty

 	test(TBLD.PasswordStoreLengthInBytes() == 0);

 	// Give the card an arbitrary password

 	test.Next(_L("assign test password"));

 	test(TBLD.SetPassword(nul, arb1, EFalse) == KErrNone);

 	RemountMedia();												// card is now locked

 	test.Next(_L("lock locked card"));

 	test(TBLD.SetPassword(arb2, arb1, EFalse) == KErrAccessDenied);	// lock locked wrong

 	test(TBLD.SetPassword(arb1, arb1, EFalse) == KErrAccessDenied);	// lock locked right

 	test.Next(_L("unlock locked card"));

 	test(TBLD.Unlock(arb2, EFalse) == KErrAccessDenied);		// unlock locked wrong

 	AttemptToUnlock(arb1);

 	test.Next(_L("unlock unlocked card"));

 	test(TBLD.Unlock(arb1, EFalse) == KErrAlreadyExists);		// unlock unlocked right

 	test(TBLD.Unlock(arb2, EFalse) == KErrAlreadyExists);		// unlock unlocked wrong

 	test.Next(_L("lock unlocked card"));

 	test(TBLD.SetPassword(arb2, arb1, EFalse) == KErrAccessDenied);	// lock unlocked wrong

 	test(TBLD.SetPassword(arb1, arb1, EFalse) == KErrNone);			// lock unlocked right

 	test.Next(_L("clear unlocked card"));

 	test(TBLD.Clear(arb2) == KErrAccessDenied);					// clear unlocked wrong

 	//!!! If clear with wrong password, cannot clear with right password in same

 	// power session (H).

 	RemountMedia();

 	AttemptToUnlock(arb1);

 	test(TBLD.Clear(arb1) == KErrNone);

 	test.Next(_L("assign test password"));

 	test(TBLD.SetPassword(nul, arb1, EFalse) == KErrNone);				// give test password

 	RemountMedia();												// make inaccessible

 	test.Next(_L("clear locked card"));

 	test(TBLD.Clear(arb2) == KErrAccessDenied);					// clear locked wrong

 	test(TBLD.Clear(arb1) == KErrAccessDenied);					// clear locked right

 	// Clear password for subsequent tests.

 	test.Next(_L("clear password"));

 	AttemptToUnlock(arb1);

 	test(TBLD.Clear(arb1) == KErrNone);

 	test(TBLD.WritePasswordData(nulSt) == KErrNone);

 	test(TBLD.PasswordStoreLengthInBytes() == 0);

 	test.End();

 	}

 /**

  * Because MultiMediaCards cannot distinguish where the current password ends

  * and the new password begins, test the media driver can abort those operations

  * that would end up giving the user unexpected passwords.

  * 

  * The stores are directly compared with buffers because they only use one password

  * and the passwords are not part of the standard test data.

  */

 LOCAL_C void TestElidePasswords()

 	{

 	test.Start(_L("TestElidePasswords"));

 	TMediaPassword a((const TUint8*) "a");		TMediaPassword bcxyz((const TUint8*) "bcxyz");

 	TMediaPassword ab((const TUint8*) "ab");	TMediaPassword cxyz((const TUint8*) "cxyz");

 	TMediaPassword abc((const TUint8*) "abc");	TMediaPassword xyz((const TUint8*) "xyz");

 	TPersistentStore* pstoreAB;

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

 	TPersistentStore& storeAB = *pstoreAB;

 	AddMapping(storeAB, CIDs[0], &ab);

 	TPersistentStore* pstoreCXYZ;

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

 	TPersistentStore& storeCXYZ = *pstoreCXYZ;

 	AddMapping(storeCXYZ, CIDs[0], &cxyz);

 	TPersistentStore *pstoreRd;									// scratch for reading

 	test((pstoreRd = new TPersistentStore) != NULL);

 	TPersistentStore& storeRd = *pstoreRd;

 	TBuf8<1> nulSt;

 	test(TBLD.SetPassword(nulSt, ab, ETrue) == KErrNone);

 	RemountMedia();												// card is now locked

 	test(AccessDisk() == KErrNone);

 	test(TBLD.ReadPasswordData(storeRd) == KErrNone);

 	test(storeRd == storeAB);

 	test.Next(_L("current password too short"));

 	test(TBLD.SetPassword(a, bcxyz, ETrue) == KErrAccessDenied);

 	test(AccessDisk() == KErrNone);

 	test(TBLD.ReadPasswordData(storeRd) == KErrNone);

 	test(storeRd == storeAB);

 	test.Next(_L("current password too long"));

 	test(TBLD.SetPassword(abc, xyz, ETrue) == KErrAccessDenied);

 	test(AccessDisk() == KErrNone);

 	test(TBLD.ReadPasswordData(storeRd) == KErrNone);

 	test(storeRd == storeAB);

 	test.Next(_L("current password exactly right"));

 	test(TBLD.SetPassword(ab, cxyz, ETrue) == KErrNone);

 	test(AccessDisk() == KErrNone);

 	test(TBLD.ReadPasswordData(storeRd) == KErrNone);

 	test(storeRd == storeCXYZ);

 	test.Next(_L("clean up for following tests"));

 	test(TBLD.Clear(cxyz) == KErrNone);

 	test(TBLD.WritePasswordData(nulSt) == KErrNone);

 	test(TBLD.PasswordStoreLengthInBytes() == 0);

 	delete pstoreRd;

 	delete pstoreCXYZ;

 	delete pstoreAB;

 	test.End();

 	}

 /**

  * test the special cases where null passwords are used.  These are all failed with

  * KErrAccessDenied by the controller.

  */

 LOCAL_C void TestNullPasswords()

 	{

 	test.Start(_L("TestNullPasswords"));

 	TMediaPassword nul(*PWDs[0]);

 	TMediaPassword arb1(*PWDs[1]);

 	test.Next(_L("card has no password"));

 	test(TBLD.SetPassword(nul, nul, ETrue) == KErrAccessDenied);

 	test(TBLD.Unlock(nul, ETrue) == KErrAlreadyExists);

 	test(TBLD.Clear(nul) == KErrAccessDenied);

 	test.Next(_L("card has password and is unlocked"));

 	test(TBLD.SetPassword(nul, arb1, ETrue) == KErrNone);

 	RemountMedia();

 	test(AccessDisk() == KErrNone);

 	test(TBLD.SetPassword(nul, nul, ETrue) == KErrAccessDenied);

 	test(TBLD.Unlock(nul, ETrue) == KErrAlreadyExists);

 	test(TBLD.Clear(nul) == KErrAccessDenied);

 	test.Next(_L("clean up for following tests"));

 	test(TBLD.Clear(arb1) == KErrNone);

 	TBuf8<1> nulSt;

 	test(TBLD.WritePasswordData(nulSt) == KErrNone);

 	test(TBLD.PasswordStoreLengthInBytes() == 0);

 	test.End();

 	}

 LOCAL_C void TestControllerStore()

 // 

 // Performs standard password functions but stores the mappings in the controller store.

 //

 // + mapping added to store (if not exists)

 // - mapping removed from store (if exists)

 // 

 //			EPbPswdUnlock		EPbPswdLock			EPbPswdClear

 //			right	wrong		right	wrong		right	wrong	

 // locked	None1	AccDen-		AccDec	AccDen		AccDen	AccDen

 // unlocked	AccDen	AccDen		None+	AccDec-		None-	AccDen-

 //

 // Locked means inaccessible, not just has password.

 // When the user supplies a password, the mapping in the password store is not used.

 //

 // 1.	A locked card with the right mapping in the store cannot happen because of the

 //		automatic unlocking mechanism.

 //

 // Tests start with an unlocked card that has no password.

 //

 	{

 	test.Start(_L("TestControllerStore"));

 	test.Next(_L("allocate test data"));

 	TMediaPassword nul(*PWDs[0]);

 	TMediaPassword arb1(*PWDs[1]);

 	TMediaPassword arb2(*PWDs[2]);

 	TPersistentStore *pstoreDef;								// { 3 |-> 3 }

 	test((pstoreDef = new TPersistentStore) != NULL);

 	TPersistentStore &storeDef = *pstoreDef;

 	AddMapping(storeDef, CIDs[3], PWDs[3]);

 	TPersistentStore *pstore0_1;								// { 3 |-> 3, 0 |-> 1 }

 	test((pstore0_1 = new TPersistentStore) != NULL);

 	TPersistentStore &store0_1 = *pstore0_1;

 	AddMapping(store0_1, CIDs[3], PWDs[3]);

 	AddMapping(store0_1, CIDs[0], PWDs[1]);

 	TPersistentStore *pstore0_2;								// { 3 |-> 3, 0 |-> 2 }

 	test((pstore0_2 = new TPersistentStore) != NULL);

 	TPersistentStore &store0_2 = *pstore0_2;

 	AddMapping(store0_2, CIDs[3], PWDs[3]);

 	AddMapping(store0_2, CIDs[0], PWDs[2]);

 	TPersistentStore *pstoreRd;									// temp for reading

 	test((pstoreRd = new TPersistentStore) != NULL);

 	TPersistentStore &storeRd = *pstoreRd;

 	// Give card arbitrary password but do not lock or store.

 	test.Next(_L("assign test password"));

 	test(TBLD.SetPassword(nul, arb1, EFalse) == KErrNone);

 	// Lock

 	// Lock unlocked right out.

 	test.Next(_L("lock unlocked right out"));

 	test(TBLD.WritePasswordData(storeDef) == KErrNone);

 	test(TBLD.SetPassword(arb1, arb1, ETrue) == KErrNone);				// + (0 |-> 1)

 	test(TBLD.ReadPasswordData(storeRd) == KErrNone);

 	test(StoresEqual(storeRd, store0_1));

 	// Lock unlocked right in (different to make sure store modified.)

 	test.Next(_L("lock unlocked right in"));

 	test(TBLD.WritePasswordData(store0_1) == KErrNone);

 	test(TBLD.SetPassword(arb1, arb2, ETrue) == KErrNone);				// - (0 |-> 1) + (0 |-> 2)

 	test(TBLD.ReadPasswordData(storeRd) == KErrNone);

 	test(StoresEqual(storeRd, store0_2));

 	// Lock unlocked wrong out.

 	test.Next(_L("lock unlocked wrong out"));

 	test(TBLD.SetPassword(arb2, arb1, ETrue) == KErrNone);				// restore to arb1

 	test(TBLD.WritePasswordData(storeDef) == KErrNone);

 	test(TBLD.SetPassword(arb2, arb1, ETrue) == KErrAccessDenied);		// not add (0 |-> 1)

 	test(TBLD.ReadPasswordData(storeRd) == KErrNone);

 	test(StoresEqual(storeRd, storeDef));

 	// Lock unlocked wrong in.

 	test.Next(_L("lock unlocked wrong in"));

 	test(TBLD.WritePasswordData(store0_1) == KErrNone);

 	test(TBLD.SetPassword(arb2, arb1, ETrue) == KErrAccessDenied);		// - (0 |-> 1)

 	test(TBLD.ReadPasswordData(storeRd) == KErrNone);

 	test(StoresEqual(storeRd, store0_1));

 	// Unlock

 	// Unlock locked right out.

 	test.Next(_L("unlock locked right out"));

 	test(TBLD.WritePasswordData(storeDef) == KErrNone);

 	RemountMedia();												// make inaccessible

 	AttemptToUnlock(arb1, ETrue);								// + (0 |-> 1)

 	test(TBLD.ReadPasswordData(storeRd) == KErrNone);

 	test(StoresEqual(storeRd, store0_1));

 	// Unlock locked right in - see note 1.

 	// Unlock locked wrong in.

 	test.Next(_L("unlock locked wrong in"));

 	test(TBLD.WritePasswordData(store0_2) == KErrNone);

 	RemountMedia();												// make inaccessible

 	test(TBLD.Unlock(arb2, ETrue) == KErrAccessDenied);			// - (0 |-> 2)

 	test(TBLD.ReadPasswordData(storeRd) == KErrNone);

 	test(StoresEqual(storeRd, storeDef));

 	// Unlock locked wrong out.

 	test.Next(_L("unlock locked wrong out"));

 	test(TBLD.WritePasswordData(storeDef) == KErrNone);

 	RemountMedia();												// make inaccessible

 	test(TBLD.Unlock(arb2, ETrue) == KErrAccessDenied);			// not add (0 |-> 2)

 	test(TBLD.ReadPasswordData(storeRd) == KErrNone);

 	test(StoresEqual(storeRd, storeDef));

 	// Clear

 	// Clear unlocked right out.

 	test.Next(_L("clear unlocked right out"));

 	test(TBLD.WritePasswordData(storeDef) == KErrNone);

 	AttemptToUnlock(arb1);										// make accessible

 	test(TBLD.Clear(arb1) == KErrNone);							// not add (0 |-> 1)

 	test(TBLD.ReadPasswordData(storeRd) == KErrNone);

 	test(StoresEqual(storeRd, storeDef));

 	// Clear unlocked right in.

 	test.Next(_L("clear unlocked right in"));

 	test(TBLD.SetPassword(nul, arb1, EFalse) == KErrNone);				// give password

 	test(TBLD.WritePasswordData(store0_1) == KErrNone);

 	test(TBLD.Clear(arb1) == KErrNone);							// - (0 |-> 2)

 	test(TBLD.ReadPasswordData(storeRd) == KErrNone);

 	test(StoresEqual(storeRd, storeDef));

 	// Clear unlocked wrong out.

 	test.Next(_L("clear unlocked wrong out"));

 	test(TBLD.SetPassword(nul, arb1, EFalse) == KErrNone);				// give password

 	test(TBLD.WritePasswordData(storeDef) == KErrNone);

 	test(TBLD.Clear(arb2) == KErrAccessDenied);					// not add (0 |-> 2)

 	test(TBLD.ReadPasswordData(storeRd) == KErrNone);

 	test(StoresEqual(storeRd, storeDef));

 	// Clear unlocked wrong in.

 	test.Next(_L("clear unlocked wrong in"));

 	test(TBLD.WritePasswordData(store0_1) == KErrNone);

 	test(TBLD.Clear(arb2) == KErrAccessDenied);					// - (0 |-> 2)

 	test(TBLD.ReadPasswordData(storeRd) == KErrNone);

 	test(StoresEqual(storeRd, store0_1));

 	// Clear password for subsequent tests.

 	test.Next(_L("clean up for following tests"));

 	test(TBLD.WritePasswordData(storeDef) == KErrNone);

 	RemountMedia();

 	AttemptToUnlock(arb1);

 	test(TBLD.Clear(arb1) == KErrNone);

 	TBuf8<1> nulSt;

 	test(TBLD.WritePasswordData(nulSt) == KErrNone);

 	test(TBLD.PasswordStoreLengthInBytes() == 0);

 	test.Next(_L("free test data"));

 	delete pstoreRd;

 	delete pstore0_2;

 	delete pstore0_1;

 	delete pstoreDef;

 	test.End();

 	}

 LOCAL_C TInt AccessDisk()

 //

 // Attempts to read the first sector of the removable media to determine whether

 // it is locked.

 //

 	{

 	const TInt KSectSize = 512;

 	TBuf8<KSectSize> sect;						// 8 + 512

 	return TBLD.Read(0, KSectSize, sect);

 	}

 LOCAL_C void TestAutoUnlock()

 //

 // Tests controller internal store unlocking mechanism.

 // A locked card should be transparently unlocked after the peripheral bus is

 // powered up.

 //

 	{

 	test.Start(_L("TestAutoUnlock"));

 	test.Next(_L("allocate test data"));

 	TMediaPassword nul(*PWDs[0]);

 	TMediaPassword arb1(*PWDs[1]);

 	TPersistentStore *pstoreDef;								// { 3 |-> 3 }

 	test((pstoreDef = new TPersistentStore) != NULL);

 	TPersistentStore &storeDef = *pstoreDef;

 	AddMapping(storeDef, CIDs[3], PWDs[3]);

 	TPersistentStore *pstore0_1;								// { 3 |-> 3, 0 |-> 1 }

 	test((pstore0_1 = new TPersistentStore) != NULL);

 	TPersistentStore &store0_1 = *pstore0_1;

 	AddMapping(store0_1, CIDs[3], PWDs[3]);

 	AddMapping(store0_1, CIDs[0], PWDs[1]);

 	TPersistentStore *pstore0_2;								// { 3 |-> 3, 0 |-> 2 }

 	test((pstore0_2 = new TPersistentStore) != NULL);

 	TPersistentStore &store0_2 = *pstore0_2;

 	AddMapping(store0_2, CIDs[3], PWDs[3]);

 	AddMapping(store0_2, CIDs[0], PWDs[2]);

 	TPersistentStore *pstoreRd;									// temp for reading

 	test((pstoreRd = new TPersistentStore) != NULL);

 	TPersistentStore &storeRd = *pstoreRd;

 	test.Next(_L("assign password"));

 	test(TBLD.SetPassword(nul, arb1, EFalse) == KErrNone);				// give password

 	// No mapping in store.

 	test.Next(_L("no mapping in store"));

 	test(TBLD.WritePasswordData(storeDef) == KErrNone);

 	RemountMedia();

 	test(AccessDisk() == KErrLocked);

 	test(TBLD.ReadPasswordData(storeRd) == KErrNone);

 	test(StoresEqual(storeRd, storeDef));

 	// Right mapping in store.

 	test.Next(_L("right mapping in store"));

 	test(TBLD.WritePasswordData(store0_1) == KErrNone);

 	RemountMedia();

 	test(AccessDisk() == KErrNone);

 	test(TBLD.ReadPasswordData(storeRd) == KErrNone);

 	test(StoresEqual(storeRd, store0_1));

 	// Wrong mapping in store - mapping should be removed.

 	test.Next(_L("wrong mapping in store"));

 	test(TBLD.WritePasswordData(store0_2) == KErrNone);

 	RemountMedia();

 	test(AccessDisk() == KErrLocked);

 	test(TBLD.ReadPasswordData(storeRd) == KErrNone);

 	test(StoresEqual(storeRd, storeDef));

 	// Redundant mapping in store.

 	test.Next(_L("redundant mapping in store"));

 	AttemptToUnlock(arb1);

 	test(TBLD.Clear(arb1) == KErrNone);

 	test(TBLD.WritePasswordData(store0_2) == KErrNone);

 	RemountMedia();

 	test(AccessDisk() == KErrNone);

 	test(TBLD.ReadPasswordData(storeRd) == KErrNone);

 	test(StoresEqual(storeRd, storeDef));

 	test.Next(_L("clean up for following tests"));

 	TBuf8<1> nulSt;

 	test(TBLD.WritePasswordData(nulSt) == KErrNone);

 	test(TBLD.PasswordStoreLengthInBytes() == 0);

 	test.Next(_L("free test data"));

 	delete pstoreRd;

 	delete pstore0_2;

 	delete pstore0_1;

 	delete pstoreDef;

 	test.End();

 	}

 LOCAL_C void TestPasswordFile()

 //

 // Additional test added for INC066636

 //

 // Tests that the MMC password file is created in the correct place on the disk

 // as defined by KMediaPWrdFile in f32fsys.h

 //

 // The following test cases are checked:

 //  o  Card can be locked

 //  o  Cannot lock the card or change its password if the wrong password is 

 //     specified

 //  o  Password can be changed

 //  o  Password can be removed

 //

 	{

 	const TInt KDriveNum = RFsDNum;

 	TInt error = KErrNone;

 	test.Start(_L("Testing password file"));

 	test.Next(_L("open connection"));

 	RFs theFs;

 	test(theFs.Connect() == KErrNone);

 	// Now set the first password that we will use

 	test.Next(_L("lock the media card"));	

 	TMediaPassword& nulPWrd = *PWDs[0];

 	TMediaPassword& oldPWrd = *PWDs[1];

 	error = theFs.LockDrive(KDriveNum, nulPWrd, oldPWrd, ETrue);

 	test(KErrNone == error);

 	// Verify that the password file does exist and is in the correct place

 	test.Next(_L("check password file exists"));

 	TEntry theEntry;

 	TBuf<sizeof(KMediaPWrdFile)> mediaPWrdFile(KMediaPWrdFile);

 	mediaPWrdFile[0] = (TUint8) RFs::GetSystemDriveChar();

 	error = theFs.Entry(mediaPWrdFile, theEntry);

 	test (KErrNone == error);

 	// Attempt to set a new password without specifying the current one

 	test.Next(_L("change password failure"));	

 	TMediaPassword& newPWrd = *PWDs[2];

 	error = theFs.LockDrive(KDriveNum, nulPWrd, newPWrd, ETrue);

 	test(KErrAccessDenied == error);

 	// Change the password for a new one...

 	test.Next(_L("change password success"));	

 	error = theFs.LockDrive(KDriveNum, oldPWrd, newPWrd, ETrue);

 	test(KErrNone == error);

 	// Clear the password

 	test.Next(_L("clear the password"));	

 	error = theFs.ClearPassword(KDriveNum, newPWrd);

 	test(KErrNone == error);

 	// Check that the password has been removed from the file

 	// (KMediaPWrdFile should now be zero bytes in size)

 	test.Next(_L("check password removal"));

 	error = theFs.Entry(mediaPWrdFile, theEntry);

 	test (KErrNone == error);

 	test (0 == theEntry.iSize);

 	// Remove the password file

 	test.Next(_L("tidy up"));

 	error = theFs.Delete(mediaPWrdFile);

 	test (KErrNone == error);

 	theFs.Close();

 	test.End();

 	}

 LOCAL_C void TestFormatErase()

 //

 // Additional test added for DEF067976 - MR1: Force Erase of MMC lock UI until complete 

 //

 // Tests that a card can be locked & then force-erased using the new format switch

 //

 // Test modified for INC073653 - RFormat::Open returns KErrNone, even if card is locked

 //

 // RFormat:Open now returns KErrLocked if media is locked (previously this wasn't returned

 // until calling RFormat::Next

 //

 //

 	{

 	TInt r = KErrNone;

 	test.Start(_L("Testing force erase"));

 	test.Next(_L("open connection"));

 	RFs fs;

 	test(fs.Connect() == KErrNone);

 	// Clear the password store for when function run on its own.

 	TBuf8<1> nulSt;

 	test(TBLD.WritePasswordData(nulSt) == KErrNone);// empty

 	test(TBLD.PasswordStoreLengthInBytes() == 0);

 	test.Next(_L("lock card"));

 	// Now set the first password that we will use

 	TMediaPassword& nulPWrd = *PWDs[0];

 	TMediaPassword& oldPWrd = *PWDs[1];

 	r = fs.LockDrive(RFsDNum, nulPWrd, oldPWrd, EFalse);

 	if (r != KErrNone)

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

 	test(r == KErrNone);

 	RemountMedia();		// card is now locked

 	RFormat fmt;

 	TPckgBuf<TInt> stepPkg;

 	TDriveUnit driveUnit(RFsDNum);

 	TDriveName driveName = driveUnit.Name();

 	test.Next(_L("format locked card"));

 	r = fmt.Open(fs, driveName, EHighDensity, stepPkg());

 	if (r != KErrLocked)

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

 	test(r == KErrLocked);

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

 	fmt.Close();

 	_LIT(KLitStars,"********************");

 	test.Next(_L("force erase locked card"));

 	r = fmt.Open(fs, driveName, EHighDensity | EForceErase, stepPkg());

 	if (r != KErrNone)

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

 	test (r == KErrNone);

 	while (stepPkg() > 0)

 		{

 		TRequestStatus status;

 		fmt.Next(stepPkg, status);

 		test (status == KRequestPending || status == KErrNone);

 		User::WaitForRequest(status);

 		TInt length=(100-stepPkg())/5;

 		length=Min(length,20);

 		TPtrC stars=KLitStars().Left(length);

 		test.Printf(_L("\r%S"),&stars);

 		}

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

 	fmt.Close();

 	fs.Close();

 	test.End();

 	}

 LOCAL_C void TestWriteToPasswordStoreUnlocksCard()

 //

 // Additional test added for INC096612 - Writing to password store should unlock the card

 //

 // Tests that a card can be auto-unlocked just by writing to the password store (as this is what 

 // estart does)

 //

 //

 	{

 	TInt r = KErrNone;

 	test.Start(_L("Testing writing to password store unlocks the card"));

 	test.Next(_L("open connection"));

 	RFs fs;

 	test(fs.Connect() == KErrNone);

 	// Clear the password store for when function run on its own.

 	TMediaPassword& nulPWrd = *PWDs[0];

 	TMediaPassword testPassword((const TUint8*) "xyz");

 	test(TBLD.WritePasswordData(nulPWrd) == KErrNone);// empty

 	test(TBLD.PasswordStoreLengthInBytes() == 0);

 	test.Next(_L("lock card"));

 	test.Next(_L("assign test password"));

 	r = TBLD.SetPassword(nulPWrd, testPassword, EFalse);

 	test(r == KErrNone);

 	RemountMedia();		// card is now locked

 	// test Caps() reports that card is locked

 	test.Next(_L("test card is locked"));

 	TLocalDriveCapsV5 driveCaps;

 	TPckg<TLocalDriveCapsV5> driveCapsPkg(driveCaps);	

 	r = TBLD.Caps(driveCapsPkg);

 	test.Printf(_L("Caps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt);

 	test (r == KErrNone);

 	test ((driveCaps.iMediaAtt & KMediaAttLocked) != 0);

 	// Write correct password to store

 	test.Next(_L("write correct password to store"));

 	TPersistentStore *pstoreDef;

 	test((pstoreDef = new TPersistentStore) != NULL);

 	TPersistentStore &storeDef = *pstoreDef;

 	AddMapping(storeDef, CIDs[0], &testPassword);

 	r = TBLD.WritePasswordData(storeDef);

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

 	test(r == KErrNone);

 	// test Caps() reports that card is unlocked

 	test.Next(_L("test card is unlocked"));

 	r = TBLD.Caps(driveCapsPkg);

 	test.Printf(_L("Caps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt);

 	test (r == KErrNone);

 	test ((driveCaps.iMediaAtt & KMediaAttLocked) == 0);

 	// Clear the password, remount and test card is unlocked

 	test.Next(_L("clear password, remount & test card is unlocked"));

 	test.Next(_L("clear the password"));	

 	test(TBLD.Clear(testPassword) == KErrNone);

 	RemountMedia();		

 	test.Next(_L("test card is unlocked"));

 	r = TBLD.Caps(driveCapsPkg);

 	test.Printf(_L("Caps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt);

 	test (r == KErrNone);

 	test ((driveCaps.iMediaAtt & KMediaAttLocked) == 0);

 	delete pstoreDef;

 	pstoreDef = NULL;

 	test.End();

 	}

 LOCAL_C TBool SetupDrivesForPlatform(TInt& aDrive, TInt &aRFsDriveNum)

 /**

  * Finds a suitable drive for the password store test

  *

  * @param aDrive  The number of the local drive to test

  * @return TBool ETrue if a suitable drive is found, EFalse otherwise.

  */

 	{

 	TDriveInfoV1Buf diBuf;

 	UserHal::DriveInfo(diBuf);

 	TDriveInfoV1 &di=diBuf();

 	test.Printf(_L(" iRegisteredDriveBitmask 0x%08X"), di.iRegisteredDriveBitmask);

 	aDrive  = -1;

 	TLocalDriveCapsV5Buf capsBuf;

 	TBusLocalDrive TBLD;

 	TLocalDriveCapsV5& caps = capsBuf();

 	TPtrC8 localSerialNum;

 	TInt registeredDriveNum = 0;

 	for(aDrive=0; aDrive < KMaxLocalDrives; aDrive++)

 		{

 		TInt driveNumberMask = 1 << aDrive;

 		if ((di.iRegisteredDriveBitmask & driveNumberMask) == 0)

 			continue;

 		test.Printf(_L(" Drive %d -  %S\r\n"), aDrive, &di.iDriveName[registeredDriveNum]);

 		// check that the card is readable (so we can ignore for empty card slots)

 		if ((di.iDriveName[registeredDriveNum].MatchF(_L("MultiMediaCard0")) == KErrNone) ||

 		    (di.iDriveName[registeredDriveNum].MatchF(_L("SDIOCard0")) == KErrNone))

 			{

 			TBool TBLDChangedFlag;

 			TInt r = TBLD.Connect(aDrive, TBLDChangedFlag);

 //test.Printf(_L(" Connect returned %d\n"), r);

 			if (r == KErrNone)

 				{

 				r = TBLD.Caps(capsBuf);

 				localSerialNum.Set(caps.iSerialNum, caps.iSerialNumLength);

 				const TInt KSectSize = 512;

 				TBuf8<KSectSize> sect;

 				r = TBLD.Read(0, KSectSize, sect);

 //test.Printf(_L(" Read returned %d\n"), r);

 				TBLD.Disconnect();

 				if (r == KErrNone)

 					break;

 				}

 			}

 		registeredDriveNum++;

 		}

 	if(aDrive == KMaxLocalDrives)

 		{

 		test.Printf(_L(" MMC Drive Not Found\r\n"));

 		return EFalse;

 		}

 	// Work out the file server drive number (which isn't necessarily the same 

 	// as the TBusLocalDrive drive number)

 	RFs theFs;

 	test(theFs.Connect() == KErrNone);

 	TInt i;

 	for (i = EDriveA; i < EDriveZ; i++)

 		{

 		TMediaSerialNumber serialNum;

 	    TInt r = theFs.GetMediaSerialNumber(serialNum, i);

 		TInt len = serialNum.Length();

 		TInt n;

 		for (n=0; n<len; n+=16)

 		{

 		TBuf16<16*3 +1> buf;

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

 				{

 				TBuf16<3> hexBuf;

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

 				buf.Append(hexBuf);

 				}

 		buf.Append(_L("\n"));

 		test.Printf(buf);

 		}

 		if (serialNum.Compare(localSerialNum) == 0)

 			{

 			TVolumeInfo vi;

 	        r = theFs.Volume(vi, i);

 			TBool sizeMatch = (vi.iSize < caps.iSize);

 			if (sizeMatch)

 				{

 				aRFsDriveNum = i;

 				break;

 				}

 			}

 		}

 	if (i == EDriveZ)

 		{

 		test.Printf(_L(" RFs MMC Drive Not Found\r\n"));

 		return EFalse;

 		}

 	theFs.Close();

 	return ETrue;

 	}

 TInt TestLockCard(RFs& aFs, TInt aTheMemoryCardDrive, TMediaPassword &aOldPassword, TMediaPassword& aNewPassword, TBool aStore)

 	{

 	TMediaPassword newPassWord;

     TMediaPassword oldPassWord;

     TInt err=0;

     TDriveInfo dInfo;

     aFs.Drive(dInfo, RFsDNum);

     newPassWord.Append(aNewPassword);

     oldPassWord.Append(aOldPassword);

     test (dInfo.iMediaAtt & KMediaAttLockable);

     err=aFs.LockDrive(RFsDNum, oldPassWord, newPassWord, aStore );

     aFs.Drive(dInfo, aTheMemoryCardDrive);

     return err;   	

 	}

 TInt TestUnlockCard(RFs& aFs, TInt aTheMemoryCardDrive, TMediaPassword& aPassword, TBool aStore)

 	{

 	TMediaPassword oldPw;

 	oldPw.Append(aPassword);

    	TInt err = aFs.UnlockDrive( aTheMemoryCardDrive, oldPw, aStore);

 	return err;

 	}

 TInt TestClearPassword(RFs& aFs, TInt aTheMemoryCardDrive, TMediaPassword& aPassword)

 	{

 	TMediaPassword oldPwd = aPassword;

 	TInt err = aFs.ClearPassword( aTheMemoryCardDrive, oldPwd );

 	return err;

 	}

 TInt ExecuteForcedEraseTestL(RFs& aFs, TInt aTheMemoryCardDrive)

     {

 	TInt err = aFs.ErasePassword( aTheMemoryCardDrive );

 	return err;

     }

 TBool TestLocked(RFs& aFs, TInt aTheMemoryCardDrive)

 	{

     TDriveInfo info;

 	TInt r = aFs.Drive(info, aTheMemoryCardDrive);

 	test (r == KErrNone);

 	return (info.iMediaAtt & KMediaAttLocked)?(TBool)ETrue:(TBool)EFalse;

 	}

 void WaitForPowerDownLock(RFs& aFs, TInt aTheMemoryCardDrive)

 	{

 	test.Printf(_L("Waiting for stack to power down...\n"));

 	TInt n;

 	for (n=0; n<30 && !TestLocked(aFs, aTheMemoryCardDrive); n++)

 		{

 		User::After(1000000);

 		}

 	test(n < 30);

 	test(TestLocked(aFs, aTheMemoryCardDrive));	// should now be locked

 	}

 void WaitForPowerDownUnlock(RFs& /*aFs*/, TInt /*aTheMemoryCardDrive*/)

 	{

 	test.Printf(_L("Allow some time for stack to power down"));

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

     	{

     	User::After(100000);

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

     	}

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

 	}

 /*

 INC103721:

 The MMC Media drivers do not power up the MMC Stack to retrieve card status,

 the following tests ensure that the 'lock status' is correctly returned after a

 stack power down.

 */	

 LOCAL_C void TestPowerDownStatus()

 	{

 	TInt r = KErrNone;

 	TLocalDriveCapsV5 driveCaps;

 	TPckg<TLocalDriveCapsV5> driveCapsPkg(driveCaps);	

 	TMediaPassword password = (TUint8*) "salasana";

 	TMediaPassword oldpassword;

 	test.Start(_L("Testing Power Down Status Reporting"));

 	test.Next(_L("Open Connection"));

 	RFs fs;

 	test(fs.Connect() == KErrNone);

 // Lock card (with password stored) 

 	test.Next(_L("Locking Card - Password Stored"));

 	test.Next(_L("Locking card (Successful)"))	;

 	r = TestLockCard(fs, RFsDNum, oldpassword, password, ETrue);

 	test(r == KErrNone); 

 	test(!TestLocked(fs, RFsDNum));	// not locked yet as stack hasn't powered down

 	test.Next(_L("Card reports unlocked - before PowerDown"));

 	r = TBLD.Caps(driveCapsPkg);

 	test.Printf(_L("\tCaps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt);

 	test (r == KErrNone);

 	test ((driveCaps.iMediaAtt & KMediaAttLocked) == 0);

 	WaitForPowerDownUnlock(fs, RFsDNum);

 	test.Next(_L("Check card reports unlocked - after PowerDown"));

 	r = TBLD.Caps(driveCapsPkg);

 	test.Printf(_L("\tCaps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt);

 	test (r == KErrNone);

 	test ((driveCaps.iMediaAtt & KMediaAttLocked) == 0);

 	test.Next(_L("Clear password (Successful)"));

 	r = TestClearPassword(fs, RFsDNum, password);

 	test(r == KErrNone);

 // Lock card (without password in store)

 	test.Next(_L("Locking card - Password NOT Stored"));

 	test.Next(_L("Locking card (Successful)"));

 	r = TestLockCard(fs, RFsDNum, oldpassword, password, EFalse);

 	test(r == KErrNone); 

 	test(!TestLocked(fs, RFsDNum));	// not locked yet as stack hasn't powered down

 	test.Next(_L("Card is reports Unlocked - before PowerDown"));

 	r = TBLD.Caps(driveCapsPkg);

 	test.Printf(_L("\tCaps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt);

 	test (r == KErrNone);

 	test ((driveCaps.iMediaAtt & KMediaAttLocked) == 0);

 	WaitForPowerDownLock(fs, RFsDNum);

 	test.Next(_L("Card reports Locked - after PowerDown"));

 	r = TBLD.Caps(driveCapsPkg);

 	test.Printf(_L("\tCaps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt);

 	test (r == KErrNone);

 	test ((driveCaps.iMediaAtt & KMediaAttLocked) != 0);

 // Unlock card

 	test.Next(_L("Unlock 'locked' Card - Password Stored"));

 	test.Next(_L("Unlocking card (Successful)"))	;

 	r = TestUnlockCard(fs, RFsDNum, password, ETrue);

 	test(r == KErrNone);

 	test (!TestLocked(fs, RFsDNum)); // not locked as stack hasn't powered down

 	test.Next(_L("Card reports unlocked - before PowerDown"));

 	r = TBLD.Caps(driveCapsPkg);

 	test.Printf(_L("\tCaps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt);

 	test (r == KErrNone);

 	test ((driveCaps.iMediaAtt & KMediaAttLocked) == 0);

 	WaitForPowerDownUnlock(fs, RFsDNum);

 	test.Next(_L("Card reports unlocked - after PowerDown"));

 	r = TBLD.Caps(driveCapsPkg);

 	test.Printf(_L("\tCaps() returned %d , iMediaAtt %08x\n"), r, driveCaps.iMediaAtt);

 	test (r == KErrNone);

 	test ((driveCaps.iMediaAtt & KMediaAttLocked) == 0);

 	test.Next(_L("Clearing Password (Successful)"));

 	r = TestClearPassword(fs, RFsDNum, password);

 	test(r == KErrNone);

 	fs.Close();

 	test.End();

 	}

 LOCAL_C void TestFsLockUnlock()

 	{

 	TInt r = KErrNone;

 	test.Start(_L("Testing RFs APIs"));

 	test.Next(_L("open connection"));

 	RFs fs;

 	test(fs.Connect() == KErrNone);

 	test.Next(_L("test locking card"));

 	TMediaPassword oldpassword;

 	TMediaPassword newpassword = (TUint8*) "salasana";

 	TMediaPassword wrongpwd = (TUint8*) "failtest";

 	r = TestLockCard(fs, RFsDNum, oldpassword, newpassword, EFalse);

 	test(r == KErrNone);

 	test(!TestLocked(fs, RFsDNum));	// not locked yet as stack hasn't powered down

 	test.Next(_L("test unlocking fails if still powered up"));

 	r = TestUnlockCard(fs, RFsDNum, newpassword, EFalse);

 	test(r == KErrAlreadyExists);		// already unlocked (as stack won't have powered down yet)

 	test (!TestLocked(fs, RFsDNum));

 	test.Next(_L("test clearing succeeds if still powered up"));

 	r = TestClearPassword(fs, RFsDNum, newpassword);

 	test(r == KErrNone);

 	test(!TestLocked(fs, RFsDNum));

 	test.Next(_L("test locking card again"));

 	r = TestLockCard(fs, RFsDNum, oldpassword, newpassword, EFalse);

 	test(r == KErrNone);

 	test(!TestLocked(fs, RFsDNum));	// not locked yet as stack hasn't powered down

 	WaitForPowerDownLock(fs, RFsDNum);

 	// DEF111681: CheckDisk is returning bad error code when run on locked SD card

 	// RFs::CheckDisk() should return KErrNone or KErrLocked (not KErrCorrupt) if the card is locked and the 

 	// stack powers down

 	// NB For FAT16 cards, the FAT will be entirely cached so CheckDisk will not actually access the media

 	// so KErrNone will be returned. For FAT32 cards, KErrLocked will be returned.

 	test.Next(_L("test CheckDisk() returns KErrLocked if the card is locked and the stack powered down"));

 	WaitForPowerDownLock(fs, RFsDNum);

 	TFileName sessionPath;

 	sessionPath=_L("?:\\");

 	TChar driveLetter;

 	r = fs.DriveToChar(RFsDNum,driveLetter);

 	test(r==KErrNone);

 	sessionPath[0]=(TText)driveLetter;

 	r = fs.CheckDisk(sessionPath);

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

 	WaitForPowerDownLock(fs, RFsDNum);

 	// DEF111700: Formatting a locked SD/MMC leaves it in a bad state (causes panics later)

 	// This was caused by format calling TDrive::MountMedia(ETrue) and then not dismounting

 	r = fs.RemountDrive(RFsDNum);

 	test (r == KErrNone);

 	RFormat fmt;

 	TPckgBuf<TInt> stepPkg;

 	TDriveUnit driveUnit(RFsDNum);

 	TDriveName driveName = driveUnit.Name();

 	test.Next(_L("format locked card"));

 	r = fmt.Open(fs, driveName, EHighDensity, stepPkg());

 	if (r != KErrLocked)

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

 	test(r == KErrLocked);

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

 	fmt.Close();

 	r = fs.CheckDisk(sessionPath);

 	test(r == KErrLocked);

 	test.Next(_L("test unlocking fails after powered down & unlocked with wrong password"));

 	r = TestUnlockCard(fs, RFsDNum, wrongpwd, EFalse);

 	test(r == KErrAccessDenied);		// unlocked should now fail

 	test.Next(_L("test unlocking succeeds for correct password after powered down & locked"));

 	r = TestUnlockCard(fs, RFsDNum, newpassword, EFalse);

 	test(r == KErrNone);		// unlocked should now succeed

 	test.Next(_L("test unlocking fails after successful unlock"));

 	r = TestUnlockCard(fs, RFsDNum, wrongpwd, EFalse);

 	test(r == KErrAlreadyExists);		// unlocked should now succeed

 	test(!TestLocked(fs, RFsDNum));	// not locked yet as stack hasn't powered down

 	test.Next(_L("test locking card with new password (with wrong password as old password)"));

 	r = TestLockCard(fs, RFsDNum, wrongpwd, newpassword, EFalse);

 	test(r == KErrAccessDenied);

 	test(!TestLocked(fs, RFsDNum));	// not locked yet as stack hasn't powered down

 	test.Next(_L("test locking card with new password (with right password as old password)"));

 	r = TestLockCard(fs, RFsDNum, newpassword, wrongpwd, EFalse);

 	test(r == KErrNone);

 	test(!TestLocked(fs, RFsDNum));	// not locked yet as stack hasn't powered down

 	WaitForPowerDownLock(fs, RFsDNum);

 	test.Next(_L("test clearing fails with wrong password if powered down & locked"));

 	r = TestClearPassword(fs, RFsDNum, newpassword); // Note: we have set the wrong password as the new password

 	test(r == KErrAccessDenied);

 	test(TestLocked(fs, RFsDNum));

 	test.Next(_L("test clearing succeeds with right password if powered down & locked"));

 	r = TestClearPassword(fs, RFsDNum, wrongpwd);

 	test(r == KErrNone);

 	test(!TestLocked(fs, RFsDNum));

 	test.Next(_L("test locking card again"));

 	r = TestLockCard(fs, RFsDNum, oldpassword, newpassword, EFalse);

 	test(r == KErrNone);

 	test(!TestLocked(fs, RFsDNum));		// not locked yet as stack hasn't powered down

 	test.Next(_L("test forced erase fails if still powered up"));

 	r = ExecuteForcedEraseTestL(fs, RFsDNum);

 	test(r == KErrAccessDenied);		// fails because card is not yet locked

 	WaitForPowerDownLock(fs, RFsDNum);

 	test.Next(_L("test forced erase succeeds if powered down & locked"));

 	r = ExecuteForcedEraseTestL(fs, RFsDNum);

 	test(r == KErrNone);

 	fs.Close();

 	test.End();

 	}

 /**

 PDEF104639: Phone automatically reboots when inserting memory card with password. 

 Testing that TheFs.UnlockDrive() results in a notification - and doesn't crash the file server (!)

 */

 void TestUnlockDriveNotifyChange()

 	{

 	RFs fs;

 	test(fs.Connect() == KErrNone);

 	TFileName sessionPath;

 	sessionPath=_L("?:\\");

 	TChar driveLetter;

 	TInt r=fs.DriveToChar(RFsDNum,driveLetter);

 	test(r==KErrNone);

 	sessionPath[0]=(TText)driveLetter;

 	r=fs.SetSessionPath(sessionPath);

 	test(r==KErrNone);

 	TInt nRes;

     TDriveInfo dInfo;

     nRes = fs.Drive(dInfo, RFsDNum);

 	test(nRes == KErrNone);

 	if (!(dInfo.iMediaAtt & KMediaAttLockable))

 		{

 		test.Printf(_L("Drive %d is not lockable %d\n"), RFsDNum);

 		fs.Close();

 		return;

 		}

 	// attempt to lock the drive

 	TMediaPassword oldPassword;

 	TMediaPassword newPassword = (TUint8*) "salasana";

     nRes = fs.LockDrive(RFsDNum, oldPassword, newPassword, EFalse );

 	test(nRes == KErrNone);

 	WaitForPowerDownLock(fs, RFsDNum);

     TRequestStatus reqStatNotify1(KRequestPending);

     //-- set up notifier

     fs.NotifyChange(ENotifyAll, reqStatNotify1, sessionPath);

     test(reqStatNotify1.Int() == KRequestPending);

     //-- unlock the drive

    	nRes = fs.UnlockDrive(RFsDNum, newPassword, EFalse);

 	test.Printf(_L("UnlockDrive() %d reqStatNotify1 %d\n"), nRes, reqStatNotify1.Int());

     //-- check that the notifier worked

     User::WaitForRequest(reqStatNotify1);

     test(reqStatNotify1.Int() == KErrNone);

 	r = TestClearPassword(fs, RFsDNum, newPassword);

 	test(r == KErrNone);

 	test(!TestLocked(fs, RFsDNum));

 	fs.Close();

 	}

 LOCAL_C void RunTests()

 //

 // Main test routine.  Calls other test functions.

 //

 	{

 	__UHEAP_MARK;

 	if(TBLDNum == -1)

 		{

 		if(!SetupDrivesForPlatform(TBLDNum, RFsDNum))

 			{

 			test.Printf(_L("MMC Drive Not Found - Skipping test\r\n"));

 			return;

 			}

 		}

 	test.Next(_L("Connecting TBLD"));

 	test(TBLD.Connect(TBLDNum, TBLDChangedFlag) == KErrNone);

 	test.Next(_L("Allocating test data"));

 	AllocateTestData();

 	test.Next(_L("Testing locking / unlocking using file server APIs"));

 	TestFsLockUnlock();

 	test.Next(_L("Testing Power Down Status Reporting using file server APIs"));

 	TestPowerDownStatus();

     test.Next(_L("Testing RFs::NotifyChange() with RFs::UnlockDrive()"));

 	TestUnlockDriveNotifyChange();

 	test.Next(_L("Forced Erase"));

 	TestFormatErase();

 	test.Next(_L("Testing store management"));

 	TestStaticStore();

 	test.Next(_L("Testing locking functions"));

 	TestLockUnlock();

 	test.Next(_L("Testing Elide Passwords"));

 	TestElidePasswords();

 	test.Next(_L("Testing Null Passwords"));

 	TestNullPasswords();

 	test.Next(_L("Testing controller store"));

 	TestControllerStore();

 	test.Next(_L("Testing auto unlock"));

 	TestAutoUnlock();

 	test.Next(_L("Testing password file"));

 	TestPasswordFile();

 	test.Next(_L("Testing writing a valid password to store unlocks card"));

 	TestWriteToPasswordStoreUnlocksCard();

 	test.Next(_L("Disconnecting TBLD"));

 	TBLD.Disconnect();

 	test.Next(_L("Deleting test data"));

 	DeleteTestData();

 	__UHEAP_MARKEND;

 	}

 TInt E32Main()

 	{

 	test.Title();

 	test.Start(_L("E32Main"));

 	RunTests();

 	test.End();

 	test.Close();

 	return KErrNone;

 	}