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