diff -r 000000000000 -r a41df078684a kerneltest/e32test/pccd/t_idrv.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/pccd/t_idrv.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,321 @@
+// 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\pccd\t_idrv.cpp
+// Overview:
+// Tests for the internal RAM drive
+// API Information:
+// TBusLocalDrive
+// Details:
+// - Load a Physical Device Driver for the RAM Media Driver.
+// - Find the internal drive: type == EMediaRam
+// - Display and adjust various drive capabilities, verify results
+// are as expected.
+// - Read and write the drive using various drive sizes, verify results
+// are as expected.
+// - Format the drive, verify results.
+// - Set original size and reformat. 
+// Platforms/Drives/Compatibility:
+// All.
+// Assumptions/Requirement/Pre-requisites:
+// Failures and causes:
+// Base Port information:
+// 
+//
+
+#include <e32test.h>
+#include <e32svr.h>
+#include <e32hal.h>
+#include <e32uid.h>
+#include "../mmu/mmudetect.h"
+#include <f32file.h>
+
+#define PDD_NAME _L("MEDINT")
+
+const TInt KTestDriveLen=0x00040000;	//256K
+const TInt KSmallDriveInc=0x00000400;	//1K
+const TInt KBigDriveLen=0x00100000;		//1M - WINS
+const TInt KTestBufLen=256;
+
+
+RTest test(_L("T_IDRV"));
+
+void Format(TInt aDrive, RFs& aFs)
+//
+// Format current drive
+//
+	{
+	test.Next(_L("Format"));
+	TBuf<4> driveBuf=_L("?:\\");
+	driveBuf[0]=(TText)(aDrive+'A');
+	RFormat format;
+	TInt count;
+	TInt r=format.Open(aFs,driveBuf,EHighDensity,count);
+	test(r==KErrNone);
+	while(count)
+		{
+		TInt r=format.Next(count);
+		test(r==KErrNone);
+		}
+	format.Close();
+	}
+
+GLDEF_C TInt E32Main()
+    {
+
+	test.Title();
+	if (!HaveVirtMem())
+		{
+		test.Printf(_L("Needs MMU\n"));
+		return 0;
+		}
+#if defined(__EPOC32__) && defined(__CPU_X86)
+	test.Printf(_L("Doesn't run on X86\n"));
+#else
+
+	TBusLocalDrive theInternalDrive;
+    TInt msgHandle = KLocalMessageHandle;
+	
+	UserSvr::UnlockRamDrive();
+	
+	test.Printf(_L("Warning - this will destroy internal drive.\r\n"));
+	TChar c= 'C';
+	c.UpperCase();
+	if (c!='C')
+		return(0);
+
+	test.Start(_L("Check loader running"));
+
+	test.Next(_L("Load Internal Ram Media Driver"));
+	TInt r=User::LoadPhysicalDevice(PDD_NAME);
+	test(r==KErrNone || r==KErrAlreadyExists);
+
+	test.Next(_L("Find internal drive"));
+	
+	TDriveInfoV1Buf driveInfoBuf;
+	UserHal::DriveInfo(driveInfoBuf);
+	TDriveInfoV1& driveInfo = driveInfoBuf();
+
+	TInt drive = 0;
+	for ( ; drive < driveInfo.iTotalSupportedDrives; ++drive)
+		{
+		TBool changedFlag;
+		theInternalDrive.Connect(drive, changedFlag);
+
+		TLocalDriveCapsV2 info;
+		TPckg<TLocalDriveCapsV2> infoPckg(info);
+		theInternalDrive.Caps(infoPckg);
+
+		if (info.iType == EMediaRam)
+			{
+			break;
+			}
+
+		theInternalDrive.Disconnect();
+		}
+	test(drive < driveInfo.iTotalSupportedDrives);
+
+	test.Next(_L("Capabilities"));
+	TLocalDriveCapsV2 info;
+	TPckg<TLocalDriveCapsV2> infoPckg(info);
+	test(theInternalDrive.Caps(infoPckg)==KErrNone);
+	TUint saveSize=I64LOW(info.iSize);
+	test(info.iType==EMediaRam);
+	test(info.iBattery==EBatNotSupported);
+	test(info.iDriveAtt==(KDriveAttLocal|KDriveAttInternal));
+	test(info.iMediaAtt==(KMediaAttVariableSize|KMediaAttFormattable));
+	test(info.iFileSystemId==KDriveFileSysFAT);
+
+	test.Printf(_L("Current drive size: %lx\n"),info.iSize);
+
+	test.Next(_L("Set size to zero"));
+	test(theInternalDrive.ReduceSize(0,saveSize)==KErrNone);
+	test(theInternalDrive.Caps(infoPckg)==KErrNone);
+	test(info.iSize==0);
+	test(theInternalDrive.ReduceSize(0,-1)==KErrArgument);
+	test(theInternalDrive.Enlarge(-1)==KErrArgument);
+
+	test.Next(_L("Increase to large size"));
+#if defined (__WINS__)
+	TUint cSize=KBigDriveLen;
+#else
+	TMemoryInfoV1Buf memBuf;
+	TMemoryInfoV1 &mi=memBuf();
+	UserHal::MemoryInfo(memBuf);
+//	TUint cSize=(mi.iTotalRamInBytes-KTestDriveLen); // Leave last 256K - used by Kernel etc.
+//	TUint cSize=mi.iTotalRamInBytes>>1; 			 // Half ram
+//	TUint cSize=mi.iTotalRamInBytes>>2; 			 // Quarter ram
+	TUint cSize=mi.iTotalRamInBytes>>3; 			 // Eighth ram
+#endif
+	test.Printf(_L("(Increasing to %dbytes)\r\n"),cSize);
+	test(theInternalDrive.Enlarge(cSize)==KErrNone);
+//	test(theInternalDrive.Enlarge(cSize-saveSize)==KErrNone); // ???
+	test(theInternalDrive.Caps(infoPckg)==KErrNone);
+	test(I64LOW(info.iSize)==cSize);
+
+	test.Next(_L("Increase by 1K"));
+	cSize+=KSmallDriveInc;
+	test(theInternalDrive.Enlarge(KSmallDriveInc)==KErrNone);
+	test(theInternalDrive.Caps(infoPckg)==KErrNone);
+	test(I64LOW(info.iSize)==cSize);
+
+	test.Next(_L("Reduce to 256K"));
+	test(theInternalDrive.ReduceSize(0,(cSize-KTestDriveLen))==KErrNone);
+	cSize=KTestDriveLen;
+	test(theInternalDrive.Caps(infoPckg)==KErrNone);
+	test(I64LOW(info.iSize)==(TUint)KTestDriveLen);
+
+	test.Next(_L("Write/Read"));
+	TBuf8<KTestBufLen> wrBuf(KTestBufLen),rdBuf;
+	TUint i,j,len;
+	for (i=0 ; i<(TUint)KTestBufLen ; i++)
+		wrBuf[i]=(TUint8)i;
+	for (i=0,j=0;i<(TUint)KTestDriveLen;i+=len,j++)
+		{
+		len=Min(KTestBufLen,(KTestDriveLen-i));
+		rdBuf.Fill(0,len);
+		wrBuf[0]=(TUint8)j;
+		test(theInternalDrive.Write(i,len,&wrBuf,msgHandle,0)==KErrNone);
+ 		test(theInternalDrive.Read(i,len,&rdBuf,msgHandle,0)==KErrNone);
+		wrBuf.SetLength(len);
+  	    test(rdBuf.Compare(wrBuf)==0);
+		}
+
+	test.Next(_L("Reduce size - 256 bytes from start"));
+ 	test(theInternalDrive.ReduceSize(0,KTestBufLen)==KErrNone);
+	test(theInternalDrive.Caps(infoPckg)==KErrNone);
+	cSize-=KTestBufLen;
+	test(I64LOW(info.iSize)==(TUint)cSize);
+	for (i=0,j=1;i<cSize;i+=len,j++)
+		{
+		len=Min(KTestBufLen,(cSize-i));
+		rdBuf.Fill(0,len);
+		wrBuf[0]=(TUint8)j;
+ 		test(theInternalDrive.Read(i,len,&rdBuf,msgHandle,0)==KErrNone);
+		wrBuf.SetLength(len);
+  	    test(rdBuf.Compare(wrBuf)==0);
+		}
+
+	test.Next(_L("Reduce size - (4K+127) bytes from middle"));
+	TInt reduction=((KTestBufLen<<4)+((KTestBufLen>>1)-1)); 
+ 	test(theInternalDrive.ReduceSize(KTestBufLen,reduction)==KErrNone); 
+	test(theInternalDrive.Caps(infoPckg)==KErrNone);
+	cSize-=reduction;
+	test(I64LOW(info.iSize)==(TUint)cSize);
+	TBuf8<KTestBufLen> odBuf(KTestBufLen); // To verify new pattern 
+	for (i=0 ; i<(TUint)KTestBufLen ; i++)
+		{
+		if (i<=(KTestBufLen>>1))
+			odBuf[i]=(TUint8)(i+((KTestBufLen>>1)-1));
+		else
+			odBuf[i]=(TUint8)(i-((KTestBufLen>>1)+1));
+		}
+	for (i=0,j=1;i<cSize;i+=len,j++)
+		{
+		len=Min(KTestBufLen,(cSize-i));
+		rdBuf.Fill(0,len);
+ 		test(theInternalDrive.Read(i,len,&rdBuf,msgHandle,0)==KErrNone);
+		if (j==2)
+			j+=17;
+		if (j==1)
+			{
+			wrBuf[0]=(TUint8)j;
+			wrBuf.SetLength(len);
+  	    	test(rdBuf.Compare(wrBuf)==0);
+			}
+		else
+			{
+			odBuf.SetLength(KTestBufLen);
+			odBuf[((KTestBufLen>>1)+1)]=(TUint8)j;
+			odBuf.SetLength(len);
+  	    	test(rdBuf.Compare(odBuf)==0);
+			}
+		}
+
+	test.Next(_L("Reduce size - (8K-1) bytes from end"));
+	reduction=((KTestBufLen<<5)-1); 
+	test(theInternalDrive.ReduceSize((cSize-reduction),reduction)==KErrNone);
+	test(theInternalDrive.Caps(infoPckg)==KErrNone);
+	cSize-=reduction;
+	test(info.iSize==cSize);
+	for (i=0,j=1;i<cSize;i+=len,j++)
+		{
+		len=Min(KTestBufLen,(cSize-i));
+		rdBuf.Fill(0,len);
+ 		test(theInternalDrive.Read(i,len,&rdBuf,msgHandle,0)==KErrNone);
+		if (j==2)
+			j+=17;
+		if (j==1)
+			{
+			wrBuf[0]=(TUint8)j;
+			wrBuf.SetLength(len);
+  	    	test(rdBuf.Compare(wrBuf)==0);
+			}
+		else
+			{
+			odBuf.SetLength(KTestBufLen);
+			odBuf[((KTestBufLen>>1)+1)]=(TUint8)j;
+			odBuf.SetLength(len);
+  	    	test(rdBuf.Compare(odBuf)==0);
+			}
+		}
+
+	test.Next(_L("Format"));
+	wrBuf.Fill(0,KTestBufLen);
+	TFormatInfo fi;
+	TInt ret;
+	while((ret=theInternalDrive.Format(fi))!=KErrEof)
+		test(ret==KErrNone);
+	for (i=0;i<cSize;i+=len)
+		{
+		len=Min(KTestBufLen,(cSize-i));
+		rdBuf.Fill(0xAA,len);
+ 		test(theInternalDrive.Read(i,len,&rdBuf,msgHandle,0)==KErrNone);
+		wrBuf.SetLength(len);
+  	    test(rdBuf.Compare(wrBuf)==0);
+		}
+
+	test.Next(_L("Restore original size"));
+	TInt sizeDif=cSize-saveSize;
+	if (sizeDif>0)
+		test(theInternalDrive.ReduceSize(0,sizeDif)==KErrNone);
+	else
+		test(theInternalDrive.Enlarge(sizeDif*-1)==KErrNone);
+
+	test.Next(_L("Disconnect from internal drive"));
+	theInternalDrive.Disconnect();
+
+	RFs fs;
+	test(fs.Connect()==KErrNone);
+	for(drive=25 ; drive>=0; --drive)
+		{
+		TDriveInfo info;
+		if(fs.Drive(info,drive)==KErrNone)
+			if(info.iType==EMediaRam)
+				{
+				TBuf<256> text;
+				text.Append(_L("Formatting drive "));
+				text.Append(TText(drive+'A'));
+				text.Append(_L(": ..."));
+				test.Next(text);
+				Format(drive,fs);
+				break;
+				}
+		}
+
+    test.End();
+
+#endif	// x86
+	return(0);
+	}
+