diff -r 000000000000 -r 96e5fb8b040d kerneltest/e32test/lffs/t_lfsdrv2.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/lffs/t_lfsdrv2.cpp	Thu Dec 17 09:24:54 2009 +0200
@@ -0,0 +1,1177 @@
+// Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// e32test\lffs\t_lfsdrv2.cpp
+// Test the LFFS Flash media driver
+// 
+//
+
+#include <e32test.h>
+#include <e32svr.h>
+#include <e32hal.h>
+#include <e32uid.h>
+#include <hal.h>
+#include "u32std.h"
+#include "..\misc\prbs.h"
+
+_LIT(KTestName,"T_LFSDRV");
+_LIT(KMediaDriverName,"MEDLFS");
+_LIT(KDot,".");
+_LIT(KSemiColon,";");
+
+RTest test(KTestName);
+TBusLocalDrive Drive;
+TInt DriveNumber;
+TLocalDriveCapsV7 DriveCaps;	// Required for M18 devices
+TBool ChangedFlag;
+TUint32 EbSz;
+TUint32 Size;
+
+const TInt KBufferSize=4096;
+const TInt KBigBufferSize=4096*4;
+TUint8 Buffer[KBigBufferSize];
+
+#ifdef _DEBUG
+/***************************************************
+ * ControlIO command types - for debug builds, only
+ ***************************************************/
+enum TCtrlIoTypes
+	{
+	ECtrlIoRww=0,
+	ECtrlIoTimeout=1
+	};
+// Used only for the ControlIO tests
+#define TYAX_PARTITION_SIZE	0x00200000 	// Partition size for TYAX is 1MB; 2 devices in parallel
+#endif
+
+
+/******************************************************************************
+ * Extra thread for background erase
+ ******************************************************************************/
+struct SEraseInfo
+	{
+	TInt iFirstBlock;
+	TInt iNumBlocks;
+	};
+
+volatile TInt Block;
+TInt EraseThreadFn(TAny* aPtr)
+	{
+	SEraseInfo& e=*(SEraseInfo*)aPtr;
+	TInt r=KErrNone;
+	for (Block=e.iFirstBlock; Block<e.iFirstBlock+e.iNumBlocks; ++Block)
+		{
+		TInt64 pos64 = MAKE_TINT64(0, Block*EbSz);
+		r=Drive.Format(pos64,EbSz);
+		if (r!=KErrNone)
+			return r;
+		}
+	return KErrNone;
+	}
+
+SEraseInfo EraseInfo;
+RThread EraseThread;
+TRequestStatus EraseStatus;
+const TInt KHeapSize=0x4000;
+
+_LIT(KEraseThreadName,"Eraser");
+TInt StartAsyncErase(TInt aFirstBlock, TInt aNumBlocks)
+	{
+	EraseInfo.iFirstBlock=aFirstBlock;
+	EraseInfo.iNumBlocks=aNumBlocks;
+	TInt r=EraseThread.Create(KEraseThreadName,EraseThreadFn,0x4000,KHeapSize,KHeapSize,&EraseInfo,EOwnerThread);
+	if (r!=KErrNone)
+		return r;
+	EraseThread.Logon(EraseStatus);
+	EraseThread.Resume();
+	return KErrNone;
+	}
+
+TInt WaitForAsyncErase()
+	{
+	User::WaitForRequest(EraseStatus);
+	TInt exitType=EraseThread.ExitType();
+	TInt exitReason=EraseThread.ExitReason();
+	TBuf<16> exitCat=EraseThread.ExitCategory();
+	if((exitType!= EExitKill)||(exitReason!=KErrNone))
+		{
+		test.Printf(_L("Async erase error: %d, block %d\n"),EraseStatus.Int(),Block);
+		test.Printf(_L("Thread exit reason: %d,%d,%S\n"),exitType,exitReason,&exitCat);
+		test(0);		
+		}
+	EraseThread.Close();
+
+	TUint32 pos=EraseInfo.iFirstBlock*EbSz;
+	TUint32 endpos=pos+EraseInfo.iNumBlocks*EbSz;
+	test.Printf(_L("\nAsync erase completed; verifying...\n"));
+	for (; pos<endpos; pos+=KBufferSize)
+		{
+		TInt64 pos64 = MAKE_TINT64(0, pos);
+		TPtr8 ptr(Buffer,0,KBufferSize);
+		Mem::FillZ(Buffer,KBufferSize);
+		TInt r=Drive.Read(pos64,KBufferSize,ptr);
+		test(r==KErrNone);
+		test(ptr.Length()==KBufferSize);
+		const TUint32* pB=(const TUint32*)Buffer;
+		const TUint32* pE=(const TUint32*)(Buffer+KBufferSize);
+		while (pB<pE && *pB==0xffffffff) ++pB;
+		if (pB<pE)
+			{
+			test.Printf(_L("ERROR: pos %08x data %08x\n"),((TUint32)pB)-((TUint32)Buffer)+pos,*pB);
+			test(0);
+			}
+		test.Printf(KDot);
+		}
+	test.Printf(_L("\n"));
+	return KErrNone;
+	}
+	
+/******************************************************************************
+ * Extra thread for background write, for use in the read-while-write tests
+ ******************************************************************************/
+TUint seed[2];
+
+TInt WriteThreadFn(TAny* aPtr)
+	{
+	// re-use the struct created for the erase thread
+	SEraseInfo& e=*(SEraseInfo*)aPtr;
+	TInt r=KErrNone;
+	
+	TPtrC8 wptr(Buffer,KBufferSize);
+	TUint32* pB=(TUint32*)Buffer;
+	TUint32* pE=(TUint32*)(Buffer+KBufferSize);
+	while (pB<pE)
+		*pB++=Random(seed);
+
+	for (Block=e.iFirstBlock; Block<e.iFirstBlock+e.iNumBlocks; ++Block)
+		{
+		TInt64 pos64 = MAKE_TINT64(0, Block*EbSz);
+		r=Drive.Write(pos64,wptr);
+		if (r!=KErrNone)
+			return r;
+		}
+	return KErrNone;
+	}
+
+RThread WriteThread;
+TRequestStatus WriteStatus;
+
+_LIT(KWriteThreadName,"Writer");
+TInt StartAsyncWrite(TInt aFirstBlock, TInt aNumBlocks)
+	{
+	// re-use the struct created for the erase thread
+	EraseInfo.iFirstBlock=aFirstBlock;
+	EraseInfo.iNumBlocks=aNumBlocks;
+	TInt r=WriteThread.Create(KWriteThreadName,WriteThreadFn,0x4000,KHeapSize,KHeapSize,&EraseInfo,EOwnerThread);
+	if (r!=KErrNone)
+		return r;
+	WriteThread.Logon(WriteStatus);
+	WriteThread.Resume();
+	return KErrNone;
+	}
+
+TInt WaitForAsyncWrite()
+	{
+	User::WaitForRequest(WriteStatus);
+	TInt exitType=WriteThread.ExitType();
+	TInt exitReason=WriteThread.ExitReason();
+	TBuf<16> exitCat=WriteThread.ExitCategory();
+	if((exitType!= EExitKill)||(exitReason!=KErrNone))
+		{
+		test.Printf(_L("Async Write error: %d, block %d\n"),WriteStatus.Int(),Block);
+		test.Printf(_L("Thread exit reason: %d,%d,%S\n"),exitType,exitReason,&exitCat);
+		test(0);
+		}
+	WriteThread.Close();
+	// No verification performed
+	test.Printf(_L("\n"));
+	return KErrNone;
+	}
+
+/******************************************************************************
+ * Control mode and Object mode test functions
+ ******************************************************************************/
+TInt DoControlModeWriteAndVerify(TUint32 aPattern, TUint32 aStartOffset)
+	{
+	// Writes 4K bytes of a given pattern to the "A" half of programming regions, 
+	// starting at the specified offset, then reads the data back to verify it
+
+		TUint32* pB=(TUint32*)(Buffer);
+		TUint32* pE=(TUint32*)(Buffer + KBufferSize);
+		TInt r=KErrNone;
+
+		// Fill the entire buffer with an initial value
+		while (pB<pE)
+			*pB++= aPattern;
+
+		// In this mode, half the device is available for writing, the other half is reserved;
+		// the available half appears as the first DriveCaps.iControlModeSize bytes, the reserved 
+		// half as the following DriveCaps.iControlModeSize, and this alternating continues.
+		// To perform this discrete-write test, therefore, the data held in Buffer that corresponds
+		// to the reserved area is overwritten with 0xFF; 'writing' this value to the reserved area
+		// has no detrimental effect.
+		TInt i;
+		TUint32 b;
+		pB=(TUint32*)Buffer;
+		for(i=0; i< KBufferSize; i+=(DriveCaps.iControlModeSize*2))
+		{
+			pB = (TUint32 *)((TUint32)pB + DriveCaps.iControlModeSize);
+			for (b=0; b < DriveCaps.iControlModeSize; b+=4)
+			{
+				*pB = 0xFFFFFFFF;
+				pB++;	
+			}
+		}
+		// Write the data
+		for (i=0; i<KBufferSize; i+=(4*DriveCaps.iControlModeSize))
+			{
+			TInt64 pos64(i + aStartOffset);
+			TPtrC8 ptr(Buffer+i,(4*DriveCaps.iControlModeSize));
+			r=Drive.Write(pos64,ptr);
+			test(r==KErrNone);
+			}
+		// Check what has been written
+		Mem::FillZ(Buffer,KBigBufferSize);
+		TPtr8 buf(Buffer,0,KBufferSize);
+		r=Drive.Read(aStartOffset,KBufferSize,buf);
+		test(r==KErrNone);
+		pB=(TUint32*)Buffer;
+		for(i=0; i< KBufferSize; i+=(DriveCaps.iControlModeSize*2))
+			{
+			for (b=0; b< DriveCaps.iControlModeSize; b+=4)
+				{
+				if(*pB++ != aPattern)
+					{ 
+					test.Printf(_L("ERROR: addr %08x data %08x expected %08x\n"),pB,*pB,aPattern);
+					r=KErrCorrupt;
+					break;
+					}
+				}
+			for (b=0; b< DriveCaps.iControlModeSize; b+=4)
+				{
+				if(*pB++ != 0xFFFFFFFF)
+					{ 
+					test.Printf(_L("ERROR: addr %08x data %08x expected 0xFFFFFFFF\n"),pB,*pB);
+					r=KErrCorrupt;
+					break;
+					}
+				}
+			}
+		return r;
+	}
+
+TInt DoObjectModeWriteAndVerify(TUint32 aOffset, TUint32 aSize)
+	{
+	// Writes 'aSize' bytes of a 'random' pattern to the specified offset
+	// then read back and verify
+	TInt r=KErrNone;
+
+	// Check that aSize is valid
+	if(aSize>DriveCaps.iObjectModeSize)
+		{
+		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - aSize=%x is greater than max (%x)\n"),aSize,DriveCaps.iObjectModeSize);
+		return KErrArgument;
+		}
+	// write the data
+	TUint seed[2];
+	seed[0]=0xb17217f8;
+	seed[1]=0;
+	TInt64 pos64 = MAKE_TINT64(0, aOffset);
+	TPtrC8 ptr(Buffer,aSize);
+	TUint32* pB=(TUint32*)Buffer;
+	TUint32* pE=(TUint32*)(Buffer+aSize);
+	while (pB<pE)
+		*pB++=Random(seed);
+	r=Drive.Write(pos64,ptr);
+	if(r!=KErrNone)
+		{
+		return r;
+		}
+	
+	// Read the data back
+	seed[0]=0xb17217f8;
+	seed[1]=0;
+	TPtr8 rptr(Buffer,0,aSize);
+	Mem::FillZ(Buffer,aSize);
+	r=Drive.Read(pos64,aSize,rptr);
+	if(r!=KErrNone)
+		{
+		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - Read returned %d\n"),r);
+		return r;
+		}
+	test((TUint32)(rptr.Length())==aSize);
+
+	// Verify the content
+	pB=(TUint32*)Buffer;
+	pE=(TUint32*)(Buffer+aSize);
+	TUint32 ex=0;
+	while (pB<pE && (ex=Random(seed),*pB==ex)) ++pB;
+	if (pB<pE)
+		{
+		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - addr %08x data %08x expected %08x\n"),pB,*pB,ex);
+		r=KErrCorrupt;
+		}
+	return r;
+	}
+
+
+TInt DoControlModeBoundaryWriteAndVerify()
+	{
+	// 
+	
+	TInt r=KErrNone;
+	//test.Printf(_L("Entering: DoControlModeBoundaryWriteAndVerify - Start Test\n"));
+
+	r=Drive.Format(0,DriveCaps.iEraseBlockSize);
+	test(r==KErrNone);
+	
+	// Program into the last Control mode region in the programming region.
+	TInt64 pos64 = MAKE_TINT64(0, (DriveCaps.iObjectModeSize - (DriveCaps.iControlModeSize*2)));
+	TPtrC8 ptr(Buffer,DriveCaps.iControlModeSize);
+	TUint32* pB=(TUint32*)Buffer;
+	TUint32* pE=(TUint32*)(Buffer+DriveCaps.iControlModeSize);
+	while (pB<pE)
+		*pB++=0xb4b4a5a5;
+	r=Drive.Write(pos64,ptr);
+	if(r!=KErrNone)
+		{
+		test.Printf(_L("ERROR: DoControlModeBoundaryWriteAndVerify - Write 1\n"));
+		return r;
+		}
+
+	// Program into the next programming region starting at the first byte up to the size of the Control Mode Size.
+	pos64 = MAKE_TINT64(0, DriveCaps.iObjectModeSize);
+	r=Drive.Write(pos64,ptr);
+	if(r!=KErrNone)
+		{
+		test.Printf(_L("ERROR: DoControlModeBoundaryWriteAndVerify - Write 2\n"));
+		return r;
+		}
+	
+	// Read the data back from the first program
+	pos64 = MAKE_TINT64(0, (DriveCaps.iObjectModeSize - (DriveCaps.iControlModeSize*2)));
+	TPtr8 rptr(Buffer,0,(TInt)DriveCaps.iControlModeSize);
+	Mem::FillZ(Buffer,DriveCaps.iControlModeSize);
+	r=Drive.Read(pos64,DriveCaps.iControlModeSize,rptr);
+	if(r!=KErrNone)
+		{
+		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - Read returned %d\n"),r);
+		return r;
+		}
+	test((TUint32)(rptr.Length())==DriveCaps.iControlModeSize);
+
+	// Verify the content
+	pB=(TUint32*)Buffer;
+	pE=(TUint32*)(Buffer+DriveCaps.iControlModeSize);
+	TUint32 ex=0xb4b4a5a5;
+	while (pB<pE && (*pB==ex)) ++pB;
+	if (pB<pE)
+		{
+		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - addr %08x data %08x expected %08x\n"),pB,*pB,ex);
+		r=KErrCorrupt;
+		}
+
+   // Read the data back from the second program
+   	pos64 = MAKE_TINT64(0, DriveCaps.iObjectModeSize);
+	TPtr8 rptr2(Buffer,0,((TInt)DriveCaps.iControlModeSize));
+	Mem::FillZ(Buffer,DriveCaps.iControlModeSize);
+	r=Drive.Read(pos64,DriveCaps.iControlModeSize,rptr2);
+	if(r!=KErrNone)
+		{
+		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - Read returned %d\n"),r);
+		return r;
+		}
+	test((TUint32)(rptr2.Length())==DriveCaps.iControlModeSize);
+
+	// Verify the content
+	pB=(TUint32*)Buffer;
+	pE=(TUint32*)(Buffer+DriveCaps.iControlModeSize);
+	ex=0xb4b4a5a5;
+	while (pB<pE && (*pB==ex)) ++pB;
+	if (pB<pE)
+		{
+		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - addr %08x data %08x expected %08x\n"),pB,*pB,ex);
+		r=KErrCorrupt;
+		}
+
+	// Bit Twiddle the last bit of the last Control Mode Region 
+	// Then bit twiddle the first bit of the first control Mode region.
+
+	// Program into the last Control mode region in the programming region.
+	pos64 = MAKE_TINT64(0, (DriveCaps.iObjectModeSize - DriveCaps.iControlModeSize - 4));
+	TPtrC8 ptr2(Buffer,4);
+	TUint32* pC=(TUint32*)Buffer;
+	*pC = 0xFFFFFFFE;
+	r=Drive.Write(pos64,ptr2);
+	if(r!=KErrNone)
+		{
+				test.Printf(_L("ERROR: DoControlModeBoundaryWriteAndVerify - Write 3\n"));
+
+		return r;
+		}
+	
+	// Read the data back from the first program
+	pos64 = MAKE_TINT64(0, (DriveCaps.iObjectModeSize - DriveCaps.iControlModeSize - 4));
+	TPtr8 rptr3(Buffer,0,4);
+	Mem::FillZ(Buffer,4);
+	r=Drive.Read(pos64,4,rptr3);
+	if(r!=KErrNone)
+		{
+		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - Read returned %d\n"),r);
+		return r;
+		}
+	test(rptr3.Length()==4);
+
+	// Verify the content
+	pB=(TUint32*)Buffer;
+	if (*pB != 0xb4b4a5a4)
+		{
+		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - addr %08x data %08x expected 0xb4b4a5a4\n"),pB,*pB);
+		r=KErrCorrupt;
+		}
+
+	// Program into the last Control mode region in the programming region.
+	pos64 = MAKE_TINT64(0, DriveCaps.iObjectModeSize);
+	TPtrC8 ptr3(Buffer,4);
+	pC=(TUint32*)Buffer;
+	*pC = 0x7FFFFFFF;
+	r=Drive.Write(pos64,ptr3);
+	if(r!=KErrNone)
+		{
+				test.Printf(_L("ERROR: DoControlModeBoundaryWriteAndVerify - Write 4\n"));
+
+		return r;
+		}
+	
+	// Read the data back from the first program
+	pos64 = MAKE_TINT64(0, DriveCaps.iObjectModeSize);
+	TPtr8 rptr4(Buffer,0,4);
+	Mem::FillZ(Buffer,4);
+	r=Drive.Read(pos64,4,rptr4);
+	if(r!=KErrNone)
+		{
+		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - Read returned %d\n"),r);
+		return r;
+		}
+	test(rptr4.Length()==4);
+
+	// Verify the content
+	pB=(TUint32*)Buffer;
+	if (*pB != 0x34b4a5a5)
+		{
+		test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - addr %08x data %08x expected 0x34b4a5a5\n"),pB,*pB);
+		r=KErrCorrupt;
+		}
+		
+	return r;
+	}
+
+
+
+
+/******************************************************************************
+ * Main test program
+ ******************************************************************************/
+GLDEF_C TInt E32Main()
+	{
+	test.Title();
+
+/******************************************************************************
+ * Initialisation
+ ******************************************************************************/
+	TDriveInfoV1Buf diBuf;
+	UserHal::DriveInfo(diBuf);
+	TDriveInfoV1 &di=diBuf();
+	test.Start(_L("Test the LFFS media driver"));
+	test.Printf(_L("DRIVES PRESENT  :%d\r\n"),di.iTotalSupportedDrives);
+	test.Printf(_L("C:(1ST) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[0]);
+	test.Printf(_L("D:(2ND) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[1]);
+	test.Printf(_L("E:(3RD) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[2]);
+	test.Printf(_L("F:(4TH) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[3]);
+	test.Printf(_L("G:(5TH) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[4]);
+	test.Printf(_L("H:(6TH) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[5]);
+	test.Printf(_L("I:(7TH) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[6]);
+	test.Printf(_L("J:(8TH) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[7]);
+	test.Printf(_L("K:(9TH) DRIVE NAME  :%- 16S\r\n"),&di.iDriveName[8]);
+
+	test.Printf(_L("\r\nWarning - all data on LFFS drive will be lost.\r\n"));
+	test.Printf(_L("<<<Select drive to continue>>>\r\n"));
+	FOREVER
+		{
+		TChar c=(TUint)test.Getch();
+		c.UpperCase();
+		DriveNumber=((TUint)c)-'C';
+		if (DriveNumber>=0&&DriveNumber<='C'+ 8)
+			break;
+		}
+
+	test.Next(_L("Load media driver"));
+	TInt r=User::LoadPhysicalDevice(KMediaDriverName);
+	test(r==KErrNone || r==KErrAlreadyExists);
+
+	test.Next(_L("Connect to drive"));
+	r=Drive.Connect(DriveNumber,ChangedFlag);
+	test(r==KErrNone);
+	test.Next(_L("Get capabilities"));
+
+	DriveCaps.iControlModeSize=0;	// If test invoked for a chip other than Sibley then this element will not be updated
+	DriveCaps.iObjectModeSize=0;	// If test invoked for a chip other than Sibley then this element will not be updated 
+	TPckg<TLocalDriveCapsV7> capsPckg(DriveCaps);
+  	r=Drive.Caps(capsPckg);
+
+	test(r==KErrNone);
+	test.Printf(_L("Size            : %08x\n"),I64LOW(DriveCaps.iSize));
+	test.Printf(_L("Type            : %d\n"),DriveCaps.iType);
+	test.Printf(_L("BatState        : %d\n"),DriveCaps.iBattery);
+	test.Printf(_L("DriveAtt        : %02x\n"),DriveCaps.iDriveAtt);
+	test.Printf(_L("MediaAtt        : %02x\n"),DriveCaps.iMediaAtt);
+	test.Printf(_L("BaseAddress     : %08x\n"),DriveCaps.iBaseAddress);
+	test.Printf(_L("FileSysID       : %d\n"),DriveCaps.iFileSystemId);
+	test.Printf(_L("Hidden sectors  : %d\n"),DriveCaps.iHiddenSectors);
+	test.Printf(_L("Erase block size: %d\n"),DriveCaps.iEraseBlockSize);
+
+	test.Printf(_L("Partition size: %d\n"),DriveCaps.iPartitionSize);
+	test.Printf(_L("Control Mode size: %d\n"),DriveCaps.iControlModeSize);
+	test.Printf(_L("Object Mode size: %d\n"),DriveCaps.iObjectModeSize);
+	test.Printf(_L("Press any key...\n\n"));
+	test.Getch();
+
+	test(DriveCaps.iDriveAtt==(KDriveAttLocal|KDriveAttInternal));
+	test((DriveCaps.iMediaAtt&KMediaAttFormattable)==(KMediaAttFormattable)); // Apply mask since other flags may be set
+
+#if defined(_DEBUG) && defined(_WINS)
+/******************************************************************************
+ * Simulate device timeout
+ ******************************************************************************/
+	test.Next(_L("Timeout"));
+	EbSz=DriveCaps.iEraseBlockSize;
+	r=Drive.Format(0,EbSz);
+	test(r==KErrNone);
+	r=Drive.ControlIO(ECtrlIoTimeout, NULL, NULL);
+
+	if(r!=KErrNotSupported)
+		{
+		if(r==KErrNone)
+			{
+			// Test timeout behaviour for Write operation
+			TPtrC8 ptr(Buffer,1);
+			r=Drive.Write(0,ptr);
+			test(r==KErrNotReady);
+			// Test condition now cleared, ensure normal operation is OK
+			r=Drive.Write(0,ptr);
+			test(r==KErrNone);
+			// Test timeout behaviour for Format operation
+			r=Drive.ControlIO(ECtrlIoTimeout, NULL, NULL);
+			test(r==KErrNone);
+			r=Drive.Format(0,EbSz);
+			test(r==KErrNotReady);
+			// Cleanup
+			r=Drive.Format(0,EbSz);
+			test(r==KErrNone);
+			}
+		else
+			{
+			test.Printf(_L("Timeout ControlIO failed initialisation\n"));
+			test(0);	// Cannot proceed with this test
+			}
+		}
+	else 
+		{
+		test.Printf(_L("Timeout ControlIO not supported\n"));
+		}
+
+	test.Printf(_L("Press any key...\n"));
+	test.Getch();
+#endif
+
+ /******************************************************************************
+ * Formatting
+ ******************************************************************************/
+	test.Next(_L("Format"));
+	TUint32 pos;
+	EbSz=DriveCaps.iEraseBlockSize;
+	Size=I64LOW(DriveCaps.iSize);
+// Reduce size so test doesn't take forever
+	if (Size>8*EbSz)
+		Size=8*EbSz;
+
+	for (pos=0; pos<Size; pos+=EbSz)
+		{
+		TInt64 pos64 = MAKE_TINT64(0, pos);
+		r=Drive.Format(pos64,EbSz);
+		test(r==KErrNone);
+		test.Printf(KDot);
+		}
+	test.Next(_L("\nVerify"));
+	for (pos=0; pos<Size; pos+=KBufferSize)
+		{
+		TInt64 pos64 = MAKE_TINT64(0, pos);
+		TPtr8 ptr(Buffer,0,KBufferSize);
+		Mem::FillZ(Buffer,KBigBufferSize);
+		r=Drive.Read(pos64,KBufferSize,ptr);
+		test(r==KErrNone);
+		test(ptr.Length()==KBufferSize);
+		const TUint32* pB=(const TUint32*)Buffer;
+		const TUint32* pE=(const TUint32*)(Buffer+KBufferSize);
+		while (pB<pE && *pB==0xffffffff) ++pB;
+		if (pB<pE)
+			{
+			test.Printf(_L("ERROR: addr %08x data %08x\n"),pB,*pB);
+			test(0);
+			}
+		test.Printf(KDot);
+		}
+	test.Printf(_L("\nPress any key...\n\n"));
+	test.Getch();
+
+/******************************************************************************
+ * Large block writes
+ ******************************************************************************/
+	test.Next(_L("Write"));
+	TUint seed[2];
+	seed[0]=0xb17217f8;
+	seed[1]=0;
+	for (pos=0; pos<Size; pos+=KBufferSize)
+		{
+		TInt64 pos64 = MAKE_TINT64(0, pos);
+		TPtrC8 ptr(Buffer,KBufferSize);
+		TUint32* pB=(TUint32*)Buffer;
+		TUint32* pE=(TUint32*)(Buffer+KBufferSize);
+		while (pB<pE)
+			*pB++=Random(seed);
+		r=Drive.Write(pos64,ptr);
+		test(r==KErrNone);
+		test.Printf(KDot);
+		}
+	test.Printf(_L("\n"));
+	test.Next(_L("Verify"));
+	seed[0]=0xb17217f8;
+	seed[1]=0;
+	for (pos=0; pos<Size; pos+=KBufferSize)
+		{
+		TInt64 pos64 = MAKE_TINT64(0, pos);
+		TPtr8 ptr(Buffer,0,KBufferSize);
+		Mem::FillZ(Buffer,KBigBufferSize);
+		r=Drive.Read(pos64,KBufferSize,ptr);
+		test(r==KErrNone);
+		test(ptr.Length()==KBufferSize);
+		const TUint32* pB=(const TUint32*)Buffer;
+		const TUint32* pE=(const TUint32*)(Buffer+KBufferSize);
+		TUint32 ex=0;
+		while (pB<pE && (ex=Random(seed),*pB==ex)) ++pB;
+		if (pB<pE)
+			{
+			test.Printf(_L("ERROR: addr %08x data %08x expected %08x\n"),pB,*pB,ex);
+			test(0);
+			}
+		test.Printf(KDot);
+		}
+
+	test.Printf(_L("\nPress any key...\n\n"));
+	test.Getch();
+
+/******************************************************************************
+ * Single byte writes
+ ******************************************************************************/
+	test.Next(_L("Format first block"));
+	r=Drive.Format(0,EbSz);
+	test(r==KErrNone);
+	test.Next(_L("Single byte writes"));
+	seed[0]=0x317b106f;
+	seed[1]=0;
+	TUint32* pB=(TUint32*)Buffer;
+	TUint32* pE=(TUint32*)(Buffer+KBufferSize);
+	while (pB<pE)
+		*pB++= Random(seed);
+	
+	// For M18 devices, this test requires control mode operation.
+	// In this mode, half the device is available for writing, the other half is reserved;
+	// the available half appears as the first DriveCaps.iControlModeSize bytes, the reserved 
+	// half as the following DriveCaps.iControlModeSize, and this alternating continues.
+	// To perform this discrete-write test, therefore, the data held in Buffer that corresponds
+	// to the reserved area is overwritten with 0xFF; 'writing' this value to the reserved area
+	// has no detrimental effect.
+	TInt i;
+	TUint32 b;
+	if (DriveCaps.iControlModeSize > 0)
+	{
+		pB=(TUint32*)Buffer;
+		for(i=0; i< KBufferSize; i+=(DriveCaps.iControlModeSize*2))
+		{
+			pB = (TUint32 *)((TUint32)pB + DriveCaps.iControlModeSize);
+			for (b=0; b < DriveCaps.iControlModeSize; b+=4)
+			{
+				*pB = 0xFFFFFFFF;
+				pB++;	
+			}
+		}
+	} 
+	
+#if 0
+	// Debug - print content of buffer
+	test.Printf(_L("Content of buffer after inserting 0xFFFFFFFFs follows\n"));
+	i=0;
+	TUint32* verifyPtr=(TUint32*)Buffer;
+	while(i<KBufferSize)
+		{
+		test.Printf(_L("%8x %8X %8X\n"),i+=8,*verifyPtr++,*verifyPtr++);
+		}
+#endif
+	
+	for (i=0; i<KBufferSize; ++i)
+		{
+		TInt64 pos64(i);
+		TPtrC8 ptr(Buffer+i,1);
+		r=Drive.Write(pos64,ptr);
+		test(r==KErrNone);
+		if (!(i%16))
+			test.Printf(KDot);
+		}
+	test.Printf(_L("\n"));
+	test.Next(_L("Verify"));
+	Mem::FillZ(Buffer,KBigBufferSize);
+	TPtr8 buf(Buffer,0,KBufferSize);
+	r=Drive.Read(0,KBufferSize,buf);
+	test(r==KErrNone);
+	seed[0]=0x317b106f;
+	seed[1]=0;
+	pB=(TUint32*)Buffer;
+	TUint32 ex=0;
+	if (DriveCaps.iControlModeSize > 0)
+		{
+		pB=(TUint32*)Buffer;
+		for(i=0; i< KBufferSize; i+=(DriveCaps.iControlModeSize*2))
+			{
+			for (b=0; b< DriveCaps.iControlModeSize; b+=4)
+				{
+				ex=Random(seed);
+				if(*pB++ != ex)
+					{ 
+					test.Printf(_L("ERROR: addr %08x data %08x expected %08x\n"),pB,*pB,ex);
+					break;
+					}
+				}
+			for (b=0; b< DriveCaps.iControlModeSize; b+=4)
+				{
+				ex=Random(seed);
+				if(*pB++ != 0xFFFFFFFF)
+					{ 
+					test.Printf(_L("ERROR: addr %08x data %08x expected 0xFF\n"),pB,*pB);
+					break;
+					}
+				}
+			if (!((i+1)%64))
+				test.Printf(KDot);
+
+			}
+		}
+	else
+		{	
+		while (pB<pE && (ex=Random(seed),*pB==ex)) ++pB;
+		}
+	if (pB<pE)
+		{
+		test.Printf(_L("ERROR: addr %08x data %08x expected %08x\n"),pB,*pB,ex);
+		test(0);
+		}
+
+	test.Printf(_L("Single byte writes OK\n"));
+	
+	test.Printf(_L("Press any key...\n\n"));
+	test.Getch();
+
+/******************************************************************************
+ * Random length writes
+ ******************************************************************************/
+	test.Next(_L("Random length writes"));
+	// Prepare the device (required if control mode is used for M18 devices)
+	// assume that a maximum of 2 blocks is required
+	r=Drive.Format(0,EbSz);
+	r=Drive.Format(DriveCaps.iEraseBlockSize,EbSz);
+
+	seed[0]=0xdeadbeef;
+	seed[1]=0;
+	pB=(TUint32*)Buffer;
+	pE=(TUint32*)(Buffer+KBigBufferSize);
+	while (pB<pE)
+		*pB++=Random(seed);
+	TInt remain=KBigBufferSize;
+	TInt objectModeOffset=0;
+	TUint32 writeCount=0;
+	seed[0]=0xdeadbeef;
+	seed[1]=0;
+	for(writeCount=0; remain && (writeCount<512); writeCount++)
+		{
+		TInt l=1+(Random(seed)&255);	 // random length between 1 and 256
+		if (l>remain)
+			l=remain;
+		TInt pos=0;
+		if(DriveCaps.iObjectModeSize == 0)
+			{
+			pos=KBigBufferSize-remain;
+			}
+		
+		TPtrC8 ptr(Buffer+(KBigBufferSize-remain),l);
+		TInt64 pos64(pos+objectModeOffset);  // Start writes in a new programming region if object mode supported
+		r=Drive.Write(pos64,ptr);
+		test(r==KErrNone);
+		objectModeOffset+=DriveCaps.iObjectModeSize;
+		remain-=l;
+		test.Printf(KDot);
+		}
+	test.Printf(_L("\n"));
+	test.Next(_L("Verify"));
+	Mem::FillZ(Buffer,KBigBufferSize);
+	new (&buf) TPtr8(Buffer,0,KBigBufferSize);
+	if(DriveCaps.iObjectModeSize==0)
+	{
+		r=Drive.Read(0,KBigBufferSize,buf);
+		test(r==KErrNone);
+
+	}
+	else
+	{
+		remain=KBigBufferSize;
+		objectModeOffset=0;
+		
+		while(remain && writeCount)
+			{
+			TInt totalLength=0;
+			TInt l=1+(Random(seed)&255);	 // random length between 1 and 256
+			if (l>remain)
+				l=remain;
+			TPtr8 ptr(Buffer+(totalLength),l);
+			r=Drive.Read(objectModeOffset,l,ptr);
+			test(r==KErrNone);
+			totalLength +=l;
+			remain-=l;
+			writeCount--;
+			test.Printf(KDot);
+			}
+	}
+
+	seed[0]=0xdeadbeef;
+	seed[1]=0;
+	pB=(TUint32*)Buffer;
+	ex=0;
+	if(DriveCaps.iObjectModeSize==0)
+	{
+		while (pB<pE && (ex=Random(seed),*pB==ex)) ++pB;
+		if (pB<pE)
+			{
+			test.Printf(_L("ERROR: addr %08x data %08x expected %08x\n"),pB,*pB,ex);
+	//		test.Getch();
+			test(0);
+			}
+	}
+	
+	r=Drive.Format(0,EbSz);
+	r=Drive.Format(DriveCaps.iEraseBlockSize,EbSz);
+	test.Printf(_L("\nPress any key...\n\n"));
+	test.Getch();
+
+/******************************************************************************
+ * Concurrent read/write/erase
+ ******************************************************************************/
+	test.Printf(_L("Foreground R/W\n"));
+	r=StartAsyncErase(1,Size/EbSz-1);
+	test(r==KErrNone);
+
+	seed[0]=0xb17217f8;
+	seed[1]=0;
+	for (pos=KBufferSize+KBigBufferSize; pos<EbSz; pos+=KBufferSize)
+		{
+		TInt64 pos64 = MAKE_TINT64(0, pos);
+		TPtrC8 wptr(Buffer,KBufferSize);
+		TUint32* pB=(TUint32*)Buffer;
+		TUint32* pE=(TUint32*)(Buffer+KBufferSize);
+		while (pB<pE)
+			*pB++=Random(seed);
+		r=Drive.Write(pos64,wptr);
+		test(r==KErrNone);
+		test.Printf(KDot);
+		Mem::FillZ(Buffer+KBufferSize,KBufferSize);
+		TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);
+		r=Drive.Read(pos64,KBufferSize,rptr);
+		test(r==KErrNone);
+		test(rptr.Length()==KBufferSize);
+		//test(Mem::Compare(Buffer,KBufferSize,Buffer+KBufferSize,KBufferSize)==0);
+		r = Mem::Compare(Buffer,KBufferSize,Buffer+KBufferSize,KBufferSize);
+#if 0
+		if (r!=KErrNone)
+		{
+			pB=(TUint32*)Buffer;
+			pE=(TUint32*)(Buffer+KBufferSize);
+			for(TInt i=0; i < (KBufferSize>>2); i++)
+			{
+			  test.Printf(_L("%d Buffer Content %08x   %08x Flash Content\n"),i, pB[i], pE[i]);			
+			} 
+		}
+#endif
+		test (r==KErrNone);
+		test.Printf(KSemiColon);
+		}
+
+	r=WaitForAsyncErase();
+	test(r==KErrNone);
+
+    r=Drive.Format(0,EbSz);
+	r=Drive.Format(DriveCaps.iEraseBlockSize,EbSz);
+	test.Printf(_L("Press any key...\n\n"));
+	test.Getch();
+
+// Perform the following tests for debug builds, only
+
+#ifdef _DEBUG
+
+/******************************************************************************
+ * Concurrent operations to exercise TYAX Read-While-Write capability
+ * First, show read while write denied when attempting to read from a partition 
+ * that is being written to
+ * Second, show read while write proceeding when reading from a partition other
+ * than that which is being written to
+ ******************************************************************************/
+
+	// Do not perform these tests unless read-while-write is supported
+	if(DriveCaps.iMediaAtt&KMediaAttReadWhileWrite)
+		{	
+		test.Next(_L("Denied read while write"));
+		r=Drive.ControlIO(ECtrlIoRww, NULL, NULL);
+		if(r!=KErrNone)
+			{
+			test.Printf(_L("ControlIO not ready, returned %d\n"), r);
+			test(0);	// Cannot proceed with this test
+			}
+		test.Printf(_L("Press any key...\n"));
+		test.Getch();
+
+		test.Printf(_L("Starting async write for the first RWE/RWW test"));
+		r=StartAsyncWrite(1,3); // Write to the first three blocks, only, to limit duration
+		test(r==KErrNone);
+	
+		// Allow the write thread to be created and ready to run
+		// This will ensure that the driver will have received a write request before the second of the read
+		// requests, below. Following the issue of the ControlIO command, above, the driver will not instigate
+		// the write request until the next (second) read request is received. This is done so that the high priority
+		// driver thread recognises the existence of a read request (from a lower priority test / user thread)
+		// before it executes a sequence of writes to the FLASH device. This is necessary because, although
+		// each write takes a finite amount of time, the poll timer expires so quickly that the driver thread
+		// would not be blocked for a sufficiently long period to allow the read request to be processed. Adopting
+		// the contrived, and artificial, approach of using ControlIO to 'stage' the write allows the read-while-write
+		// capability of the device to be execrised.
+		User::After(1000);	
+
+		test.Printf(_L("Starting concurrent loop for background write\n"));
+		{
+		// First read - this will be performed before the write thread is run, so does
+		// not exercise read while write.
+		TInt64 pos64 = MAKE_TINT64(0,0);
+		TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);
+		test.Printf(_L("Issuing Drive.Read 1\n"));
+		r=Drive.Read(pos64,KBufferSize,rptr); 
+		test(r==KErrNone);
+		test.Printf(KSemiColon);		
+		}
+		{
+		// Second read - to same partition (and block) as the active write
+		// This read should be deferred by the driver
+		TInt64 pos64 = MAKE_TINT64(0, 2*EbSz);
+		TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);
+		test.Printf(_L("Issuing Drive.Read 2\n"));
+		r=Drive.Read(pos64,KBufferSize,rptr); // Should collide with second write
+		test(r==KErrNone);
+		test.Printf(KSemiColon);		
+		}
+		{
+		// Third read - due to the tight poll timer period, this will not be scheduled 
+		// until the write request has completed - so does not exercise read while write.
+		TInt64 pos64 = MAKE_TINT64(0, DriveCaps.iPartitionSize);
+		TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);
+		test.Printf(_L("Issuing Drive.Read 3\n"));
+		r=Drive.Read(pos64,KBufferSize,rptr);
+		test(r==KErrNone);
+		test.Printf(KSemiColon);		
+		}
+
+		r=WaitForAsyncWrite();
+		test(r==KErrNone);
+	
+	///////////////////////////////////////////////////////////////////////////////
+		r=Drive.Format(0,EbSz);
+		r=Drive.Format(DriveCaps.iEraseBlockSize,EbSz);
+		r=Drive.Format((DriveCaps.iEraseBlockSize*2),EbSz);
+		r=Drive.Format((DriveCaps.iEraseBlockSize*3),EbSz);
+		test.Printf(_L("Press any key...\n"));
+		test.Getch();
+		test.Next(_L("Supported read while write"));
+		r=Drive.ControlIO(ECtrlIoRww, NULL, NULL);
+		if(r!=KErrNone)
+			{
+			test.Printf(_L("ControlIO not ready\n"));
+			return r;
+			}
+		test.Printf(_L("Press any key...\n"));
+		test.Getch();
+
+		test.Printf(_L("Starting async write for the second RWE/RWW test"));
+		r=StartAsyncWrite(1,3); // Write to the first three blocks, only, to limit duration
+		test(r==KErrNone);
+
+		// Allow the write thread to be created and ready to run
+		User::After(1000);	
+
+		test.Printf(_L("Starting concurrent loop for background write\n"));
+		{
+		// First read - this will be performed before the write thread is run, so does
+		// not exercise read while write.
+		TInt64 pos64 = MAKE_TINT64(0, DriveCaps.iPartitionSize);
+		TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);
+		test.Printf(_L("Issuing Drive.Read 1\n"));
+		r=Drive.Read(pos64,KBufferSize,rptr); 
+		test(r==KErrNone);
+		test.Printf(KSemiColon);		
+		}
+		{
+		// Second read - to different partition than that targeted by the active write
+		// This read should check the overlap and proceed without being deferred
+		TInt64 pos64 = MAKE_TINT64(0, DriveCaps.iPartitionSize);
+		TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);
+		test.Printf(_L("Issuing Drive.Read 2\n"));
+		r=Drive.Read(pos64,KBufferSize,rptr); // Should collide with second write
+		test(r==KErrNone);
+		test.Printf(KSemiColon);		
+		}
+		{
+		// Third read - due to the tight poll timer period, this will not be scheduled 
+		// until the write request has completed - so does not exercise read while write.
+		TInt64 pos64 = MAKE_TINT64(0, DriveCaps.iPartitionSize);
+		TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);
+		test.Printf(_L("Issuing Drive.Read 3\n"));
+		r=Drive.Read(pos64,KBufferSize,rptr);
+		test(r==KErrNone);
+		test.Printf(KSemiColon);		
+		}
+
+		test.Printf(_L("\nForeground Read OK\n"));
+		r=WaitForAsyncWrite();
+		test(r==KErrNone);
+		}
+#endif		
+
+	// Clean up
+	r=Drive.Format(0,EbSz);
+	r=Drive.Format(DriveCaps.iEraseBlockSize,EbSz);
+	r=Drive.Format((DriveCaps.iEraseBlockSize*2),EbSz);
+	r=Drive.Format((DriveCaps.iEraseBlockSize*3),EbSz);
+
+/*****************************************************************************************************
+	Tests for M18 NOR Flash devices
+
+	These tests assume that object mode and control mode is supported
+ *****************************************************************************************************/
+	if((DriveCaps.iControlModeSize !=0) && (DriveCaps.iObjectModeSize != 0))
+		{
+		// Control mode writes
+		// Prove that control mode writes are supported
+		// This requires that data is formatted such that areas coinciding with the "B" Half of a
+		// programming region are set to all 0xFFs
+		// Write to programming region zero
+		test.Next(_L("\nControl mode writes"));
+
+		r=DoControlModeWriteAndVerify(0xa5a5a5a5, 0);
+		test(r==KErrNone);
+		// Now verify that data written in control mode can be further modified
+		// Do this by ANDing the read-back pattern with a mask that clears particular bits
+		// then write the resulting pattern back to the region
+		r=DoControlModeWriteAndVerify(0x84848484, 0);
+		test(r==KErrNone);
+		// Now verify that data written in control mode can be further modified to all 0x00s
+		// Do this by ANDing the read-back pattern with a mask that clears the remaining bits
+		// then write the resulting pattern back to the region
+		r=DoControlModeWriteAndVerify(0x00000000, 0);
+		test(r==KErrNone);
+		// Erase the block before attempting to re-use the programming region for object mode writing
+		test.Printf(_L("\nErase block 0 before object mode write"));
+		r=Drive.Format(0,EbSz);
+		test(r==KErrNone);
+
+		test.Next(_L("\n(Subsequent) Object mode writes"));
+
+		// Control mode writes
+		// Prove that object mode writes are allowd to an erased block that was previously
+		// used in control mode
+		// Use offset zero and length equal to one-quarter of the allowed object mode size (i.e. one-
+		// quarter of the lengh of the programming region) (The write test, above, wrote an entire region
+		// in object mode)
+		test.Printf(_L("\nObject mode write, object mode size=%d"),DriveCaps.iObjectModeSize);
+		r=DoObjectModeWriteAndVerify(0, (DriveCaps.iObjectModeSize>>2));
+		test(r==KErrNone);
+		// Prove that an attempt to append data to an object mode region fails
+		test.Printf(_L("\nAttempt append to object mode region"));
+		r=DoObjectModeWriteAndVerify((DriveCaps.iObjectModeSize>>2),(DriveCaps.iObjectModeSize>>2));
+		test(r==KErrGeneral);
+		// Erase the block after a failed write and before attempting to re-use for programming
+		test.Printf(_L("\nErase block 0 after failed object mode write"));
+		r=Drive.Format(0,EbSz);
+		test(r==KErrNone);
+
+		test.Next(_L("\n(Subsequent) Object mode writes following an error"));
+
+		// write to a new object mode region after a failed write and before attempting to erase the block
+		// Prove that erase block can be re-written to
+		test.Printf(_L("\nObject mode write following failed write and erase"));
+		r=DoObjectModeWriteAndVerify(0, (DriveCaps.iObjectModeSize>>2));
+		test(r==KErrNone);
+		// Cause a failed object mode write
+		r=DoObjectModeWriteAndVerify(0, (DriveCaps.iObjectModeSize>>2));
+		test(r==KErrGeneral);
+		// the status register has an error.  Attempt to write in a new region and ensure that it succeeds
+		r=DoObjectModeWriteAndVerify(DriveCaps.iObjectModeSize, DriveCaps.iObjectModeSize);
+		test(r==KErrNone);
+
+		test.Next(_L("\n(Subsequent) Control mode writes following previous use in object mode"));
+
+		// Re-use a former object mode region for control mode writes
+		// Erase the block after a failed write and before attempting to re-use for programming
+		r=Drive.Format(0,EbSz);
+		test(r==KErrNone);
+		r=DoControlModeWriteAndVerify(0xa5a5a5a5, 0);
+		test(r==KErrNone);
+		// Verify that data written in control mode can be further modified
+		r=DoControlModeWriteAndVerify(0x84848484, 0);
+		test(r==KErrNone);
+
+		test.Next(_L("\n(Subsequent) Control mode writes following an error"));
+
+		// Test that a control mode write can succeed after a previous error
+		// Use a failed object mode write attempt to the "B" half of a control mode region
+		// to cause the error
+		r=DoObjectModeWriteAndVerify(DriveCaps.iControlModeSize,(DriveCaps.iObjectModeSize>>2));
+		test(r==KErrGeneral);
+		r=DoControlModeWriteAndVerify(0x00000000, 0);
+		test(r==KErrNone);
+
+		test.Next(_L("\nControl mode boundary write test"));
+
+		r=DoControlModeBoundaryWriteAndVerify();
+		test(r==KErrNone);
+
+	}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	test.Printf(_L("Press any key...\n"));
+	test.Getch();
+	test.End();
+	return KErrNone;
+	}