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

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

