// 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.iConnectionBusType==EConnectionBusInternal);

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

 	}