// 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_chlffs.cpp

 // 

 //

 #define __E32TEST_EXTENSION__

 #include <f32file.h>

 #include <e32test.h>

 #include <e32hal.h>

 #include <hal.h>

 // Now non-t_main programs need to chk if they are running on lffs,

 #include "t_server.h"

 #include "t_chlffs.h"

 const TInt KInvalidDriveLetter=-1;

 LOCAL_D TInt LFFSdriveNumber=KInvalidDriveLetter;

 LOCAL_D TBool LFFSTesting=EFalse;

 _LIT(KLFFSName,"Lffs");

 LOCAL_C void FormatLFFS(RFs &anFsSession,TDes &aDrive)

 //

 // Format the LFFS drive

 //

 	{

     RFormat format;

     TInt count;

     TInt r;

     test.Printf(_L("Format LFFS drive %S\r\n"), &aDrive);

     r=format.Open(anFsSession,aDrive,EHighDensity,count);

     test.Printf(_L("Format open done. Count = %d\r\n"), count);

     test(r==KErrNone);

     while (count)

 		{

         TInt r=format.Next(count);

     	test.Printf(_L("Format next done. Count = %d\r\n"), count);

         test(r==KErrNone);

     	}

     format.Close();

 	}

 GLDEF_C TBool IsFileSystemLFFS(RFs &aFsSession,TInt aDrive)

 //

 // return true if lffs on aDrive

 //

 	{

 	TFileName f;

 	TInt r=aFsSession.FileSystemName(f,aDrive);

 	test(r==KErrNone || r==KErrNotFound);

 	return (f.CompareF(KLFFSName)==0);

 	}

 GLDEF_C TInt CheckLFFSDriveForPlatform()

 //

 // Check the LFFS drive number for the current platform

 //

 	{

 	TInt lffsDrvNum;

 	TInt uid;

     TInt r=HAL::Get(HAL::EMachineUid,uid);

     test(r==KErrNone);

     if (uid==HAL::EMachineUid_Brutus)

 		{

         lffsDrvNum=EDriveK;

     	test.Printf(_L("Test is running on BRUTUS\r\n"));

 		}

     else if (uid==HAL::EMachineUid_Win32Emulator)

 		{

         lffsDrvNum=EDriveW;

     	test.Printf(_L("Test is running on WINS Pc\r\n"));

 		}

 	else if (uid == HAL::EMachineUid_Integrator)

 		{

 		lffsDrvNum=EDriveK;

 		test.Printf(_L("Test is running on INTEGRATOR\r\n"));

 		}

 	else if (uid == HAL::EMachineUid_Assabet)

 		{

 		lffsDrvNum=EDriveK;

 		test.Printf(_L("Test is running on Assabet\r\n"));

 		}

     else

 		lffsDrvNum=KInvalidDriveLetter;

 	return(lffsDrvNum);

 	}

 GLDEF_C TBool CheckMountLFFS(RFs &anFsSession,TChar aDriveLetter)

 //

 // Check if test to be performed on LFFS drive. Mount the ELFFS.FSY if

 // necessary

 //

 	{

     test.Next(_L("Check if LFFS drive (Mount LFFS if required)"));

 	TInt r,drvNum;

 	TBuf<4> lffsDriveLetter=_L("?:\\");

 	// first check if the lffs is mounted on the drive

 	r=anFsSession.CharToDrive(aDriveLetter,drvNum);

 	test(r==KErrNone);

 	if (IsFileSystemLFFS(anFsSession,drvNum))

 		{

 		lffsDriveLetter[0]=(TText)aDriveLetter;

 		test.Printf(_L("Testing an LFFS drive (%S)"), &lffsDriveLetter);

 		test.Printf(_L("LFFS already mounted on drive %S\r\n"), &lffsDriveLetter);

 		LFFSdriveNumber=drvNum;

 		LFFSTesting=ETrue;

 		return(ETrue);

 		}

 	// check if platform expects lffs to be mounted on specified drive 

 	TInt lffsDrvNum=CheckLFFSDriveForPlatform();

 	if (drvNum!=lffsDrvNum)

 		{

         test.Printf(_L("Not testing an LFFS drive\n"));

         return(EFalse);

     	}

 	lffsDriveLetter[0]=(TText)aDriveLetter;

     test.Printf(_L("Testing an LFFS drive (%S)"), &lffsDriveLetter);

 	LFFSdriveNumber=lffsDrvNum;

 	LFFSTesting=ETrue;

     test.Next(_L("Load device driver: MEDLFS"));

     r=User::LoadPhysicalDevice(_L("MEDLFS"));

     test(r==KErrNone || r==KErrAlreadyExists);

     test.Next(_L("Add file system: ELFFS"));

     r=anFsSession.AddFileSystem(_L("ELFFS"));

     test(r==KErrNone || r==KErrAlreadyExists);

     TFullName name;

     r=anFsSession.FileSystemName(name,LFFSdriveNumber);

     test(r==KErrNone || r==KErrNotFound);

     if (name.MatchF(_L("Lffs")) != 0)

 		{

         // Some other file system is at the "Lffs" drive. 

         if (name.Length() != 0)

 			{

 			// Not allowed to dismount the file system from the drive associated

 			// with the default path - so temporarily change the default path.

             test.Printf(_L("Dismounting %S on drive %S\r\n"), &name, &lffsDriveLetter);

             r=anFsSession.DismountFileSystem(name,LFFSdriveNumber);

             test(r==KErrNone);

 			}

         test.Printf(_L("Mount LFFS on drive %S\r\n"),&lffsDriveLetter);

         r=anFsSession.MountFileSystem(_L("Lffs"), LFFSdriveNumber);

         test.Printf(_L("  Mount result %d\r\n"), r);

         test(r==KErrNone || r==KErrCorrupt || r==KErrNotReady);

         if (r==KErrCorrupt)

 			{

             test.Printf(_L("The volume was corrupt. Formatting...\r\n"));

             FormatLFFS(anFsSession,lffsDriveLetter);

         	}

         else if(r==KErrNotReady)

 			{

             test.Printf(_L("The mount was not ready. Formatting...\r\n"));

             FormatLFFS(anFsSession,lffsDriveLetter);

         	}

         else

 			{

             test.Printf(_L("The volume was mounted OK. Formatting...\r\n"));

             FormatLFFS(anFsSession,lffsDriveLetter); // ???

         	}

     	}

     else

 		{

         test.Printf(_L("LFFS already mounted on drive %S\r\n"), &lffsDriveLetter);

     	}

     return(ETrue);

 	}

 GLDEF_C TBool IsTestingLFFS()

 //

 // Return ETrue if testing LFFS

 //

 	{

     return(LFFSTesting);

 	}

 GLDEF_C void TestingLFFS(TBool aSetting)

 //

 // Set whether testing LFFS or not

 //

 	{

     LFFSTesting=aSetting;

 	}

 GLDEF_C TInt GetDriveLFFS()

 //

 // Return the LFFS drive number

 //

 	{

     return(LFFSdriveNumber);

 	}

 GLDEF_C TBool IsSessionDriveLFFS(RFs& aFs,TChar& aDriveLetter)

 	{

 //

 // Quick method of testing if session drive is LFFS

 //	

 	TBool isLffs;

 	TFileName path;

 	TInt r=aFs.SessionPath(path);

 	test(r==KErrNone);

 	TInt drv;

 	r=RFs::CharToDrive(path[0],drv);

 	test(r==KErrNone);

 	aDriveLetter=path[0];

 	isLffs=IsFileSystemLFFS(aFs,drv);

 	if(isLffs)

 		return(ETrue);

 	// check if platform expects lffs to be mounted on default drive

 	TInt lffsDrv = CheckLFFSDriveForPlatform();

 	if (lffsDrv == KInvalidDriveLetter)

 		{

 		test.Printf(_L("IsSessionDriveLFFS: platform does not support lffs.\r\n"));

 		isLffs = EFalse;

 		}

 	else

 		{

 		TChar curCh=path[0];

 		curCh.LowerCase();

 		TChar lffsCh;								// lffs drv ltr

 		test((r = RFs::DriveToChar(lffsDrv, lffsCh)) == KErrNone);

 		lffsCh.LowerCase();

 		test.Printf(_L("IsSessionDriveLFFS: cur drv = \'%c\', lffs drv = \'%c\'.\n"), (TText) curCh, (TText) lffsCh);

 		isLffs = ((TText) curCh) == ((TText) lffsCh);

 		}

 	return(isLffs);

 	}

 GLDEF_C TBool IsDefaultDriveLFFS()

 //

 // Quick method of testing if running on LFFS for non t_main based tests.

 // 

 	{

 	// check if lffs mounted on default drive

 	TBool isLffs;

 	RFs fs;

 	TInt r=fs.Connect();

 	test(r==KErrNone);

 	TFileName path;

 	r=fs.SessionPath(path);

 	test(r==KErrNone);

 	TInt drv;

 	r=TheFs.CharToDrive(path[0],drv);

 	test(r==KErrNone);

 	isLffs=IsFileSystemLFFS(fs,drv);

 	fs.Close();

 	if(isLffs)

 		return(ETrue);

 	// check if platform expects lffs to be mounted on default drive

 	TInt lffsDrv = CheckLFFSDriveForPlatform();

 	if (lffsDrv == KInvalidDriveLetter)

 		{

 		test.Printf(_L("IsCurrentDriveLFFS: platform does not support lffs.\r\n"));

 		isLffs = EFalse;

 		}

 	else

 		{

 		TChar curCh=path[0];

 		curCh.LowerCase();

 		TChar lffsCh;								// lffs drv ltr

 		test((r = RFs::DriveToChar(lffsDrv, lffsCh)) == KErrNone);

 		lffsCh.LowerCase();

 		test.Printf(_L("IsCurrentDriveLFFS: cur drv = \'%c\', lffs drv = \'%c\'.\n"), (TText) curCh, (TText) lffsCh);

 		isLffs = ((TText) curCh) == ((TText) lffsCh);

 		}

 	return(isLffs);

 	}

 GLDEF_C TBool IsNamedDriveLFFS(RFs &aFsSession,TText aDrv)

 //

 // Quick method of testing if running on LFFS for non t_main based tests.

 // 

 	{

 	TInt d;

 	TInt r=RFs::CharToDrive(aDrv,d);

 	test(r==KErrNone);

 	return(IsFileSystemLFFS(aFsSession,d));

 	}

 GLDEF_C TInt GetLFFSControlModeSize()

 //

 // For LFFS, the media may not exhibit a contiguous data region. This is the case if the 

 // Control Mode Size is non-zero.

 //

 	{

 	TLocalDriveCapsV7 caps;		// V7 to allow for devices exhibiting Control Mode

 	TPckg<TLocalDriveCapsV7> capsPckg(caps);

 	TBusLocalDrive localDrive;

 	TBool lffsMediaFound = EFalse;

 	TBool dumBool = EFalse;		// Arbitrary if LFFS is mounted on non-removable media

 	// Loop to find the local drive for LFFS - this is always of type EMediaFlash

 	for(TInt drvNum=0; drvNum<KMaxLocalDrives; drvNum++)

 		{

 		TInt r=localDrive.Connect(drvNum,dumBool);

 		if(r==KErrNotSupported)

 			continue;		// Local drive not present

 		test_KErrNone(r);

 		r=localDrive.Caps(capsPckg);

 		localDrive.Disconnect();

 		if(r==KErrNotSupported||r==KErrNotReady)

 			continue;		// Local drive not available

 		test_KErrNone(r);

 		if(capsPckg().iType==EMediaFlash)

 			{

 			lffsMediaFound=ETrue;

 			break;

 			}

 		}

 	if(!lffsMediaFound)

 		{

 		test.Printf(_L("GetLFFSControlModeSize: LFFS media not found !\n"));

 		return KErrGeneral;

 		}

 	return (capsPckg().iControlModeSize);

 	}