// Copyright (c) 1995-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_fsrv.cpp

// 

//

#define __E32TEST_EXTENSION__

#include <f32file.h>

#include <e32test.h>

#include "t_server.h"

#include "t_chlffs.h"

#include "f32_test_utils.h"

using namespace F32_Test_Utils;

RTest test(_L("T_FSRV"));

const TInt KMaxParses=7;

const TInt KHeapSize=0x2000;

TFileName tPath;

TBool gFirstTime=ETrue;

const TInt KMaxVolumeName=11;

TInt substDrive=0;

TFileName gTestSessionPath;

TInt LargeFileSize;

TInt gDrive=-1;

struct SParse

	{

	const TText* src;

	const TText* rel;

	const TText* def;

	const TText* fullName;

	const TText* drive;

	const TText* path;

	const TText* name;

	const TText* ext;

	};

struct SParseServer

	{

	const TText* src;

	const TText* rel;

	const TText* fullName;

	const TText* drive;

	const TText* path;

	const TText* name;

	const TText* ext;

	};

LOCAL_D SParse parse[KMaxParses] =

	{

	{_S("A:\\PATH\\NAME.EXT"),NULL,NULL,_S("A:\\PATH\\NAME.EXT"),_S("A:"),_S("\\PATH\\"),_S("NAME"),_S(".EXT")},

	{_S("A:\\PATH\\NAME"),NULL,NULL,_S("A:\\PATH\\NAME"),_S("A:"),_S("\\PATH\\"),_S("NAME"),_S("")},

	{_S("A:\\PATH\\"),NULL,NULL,_S("A:\\PATH\\"),_S("A:"),_S("\\PATH\\"),_S(""),_S("")},

	{_S("A:"),NULL,NULL,_S("A:"),_S("A:"),_S(""),_S(""),_S("")},

	{_S(""),NULL,NULL,_S(""),_S(""),_S(""),_S(""),_S("")},

	{_S("A:\\PATH\\NAME"),_S("A:\\ZZZZ\\YYYY.XXX"),NULL,_S("A:\\PATH\\NAME.XXX"),_S("A:"),_S("\\PATH\\"),_S("NAME"),_S(".XXX")},

	{_S("NAME"),_S(".YYY"),_S("A:\\PATH\\"),_S("A:\\PATH\\NAME.YYY"),_S("A:"),_S("\\PATH\\"),_S("NAME"),_S(".YYY")}

	};

LOCAL_D SParseServer parseServer[KMaxParses] =

	{

	{_S("A:\\PATH\\NAME.EXT"),NULL,_S("A:\\PATH\\NAME.EXT"),_S("A:"),_S("\\PATH\\"),_S("NAME"),_S(".EXT")},

	{_S("A:\\PATH\\NAME"),NULL,_S("A:\\PATH\\NAME"),_S("A:"),_S("\\PATH\\"),_S("NAME"),_S("")},

	{_S("A:\\PATH\\"),NULL,_S("A:\\PATH\\"),_S("A:"),_S("\\PATH\\"),_S(""),_S("")},

	{_S("A:"),NULL,_S("A:\\ABCDEF\\"),_S("A:"),_S("\\ABCDEF\\"),_S(""),_S("")},

	{_S(""),NULL,_S("C:\\ABCDEF\\"),_S("C:"),_S("\\ABCDEF\\"),_S(""),_S("")},

	{_S("A:\\PATH\\NAME"),_S("A:\\ZZZZ\\YYYY.XXX"),_S("A:\\PATH\\NAME.XXX"),_S("A:"),_S("\\PATH\\"),_S("NAME"),_S(".XXX")},

	{_S("NAME"),_S(".YYY"),_S("C:\\ABCDEF\\NAME.YYY"),_S("C:"),_S("\\ABCDEF\\"),_S("NAME"),_S(".YYY")}

	};

LOCAL_C TInt pathTestThread(TAny*)

//

// The entry point for the producer thread.

//

	{

	RTest test(_L("Second thread path handling"));

	test.Title();

	test.Start(_L("Path test thread"));

	RFs f;

	TInt r=f.Connect();

	test(r==KErrNone);

	r=f.SessionPath(tPath);

	test(r==KErrNone);

	f.Close();

	return(KErrNone);

	}

LOCAL_C void printDriveAtt(TInt aDrive,TUint anAtt)

//

// Print a drive attribute.

//

	{

	test.Printf(_L("%c: "),aDrive+'A');

	if (anAtt&KDriveAttLocal)

		test.Printf(_L("LOCAL "));

	if (anAtt&KDriveAttRom)

		test.Printf(_L("ROM "));

	if (anAtt&KDriveAttRedirected)

		test.Printf(_L("REDIR "));

	if (anAtt&KDriveAttSubsted)

		test.Printf(_L("SUBST "));

	if (anAtt&KDriveAttInternal)

		test.Printf(_L("INTERNAL "));

	if (anAtt&KDriveAttHidden)

		test.Printf(_L("HIDDEN "));

	if ((anAtt&KDriveAttRemovable) && !(anAtt&KDriveAttLogicallyRemovable))

		test.Printf(_L("PHYSICALLYREMOVABLE "));

	if ((anAtt&KDriveAttRemovable) && (anAtt&KDriveAttLogicallyRemovable))

		test.Printf(_L("LOGICALLYREMOVABLE "));

	test.Printf(_L("\n"));

	}

LOCAL_C void printDriveInfo(TInt aDrive,TDriveInfo& anInfo)

//

// Print a drive info.

//

	{

	printDriveAtt(aDrive,anInfo.iDriveAtt);

	test.Printf(_L("   MEDIA-ATT="));

	if (anInfo.iMediaAtt==0)

		test.Printf(_L("<none>"));

	if (anInfo.iMediaAtt&KMediaAttVariableSize)

		test.Printf(_L("VariableSize "));

	if (anInfo.iMediaAtt&KMediaAttDualDensity)

		test.Printf(_L("DualDensity "));

	if (anInfo.iMediaAtt&KMediaAttFormattable)

		test.Printf(_L("Formattable "));

	if (anInfo.iMediaAtt&KMediaAttWriteProtected)

		test.Printf(_L("WProtected "));

		{

	default:

		test.Printf(_L("Unknown value\n"));

		}

	test.Printf(_L("   MEDIA="));

	switch(anInfo.iType)

		{

	case EMediaNotPresent: test.Printf(_L("Not present\n")); break;

	case EMediaUnknown: test.Printf(_L("Unknown\n")); break;

	case EMediaFloppy: test.Printf(_L("Floppy\n")); break;

	case EMediaHardDisk: test.Printf(_L("Hard disk\n")); break;

	case EMediaCdRom: test.Printf(_L("CD Rom\n")); break;

	case EMediaRam: test.Printf(_L("Ram\n")); break;

	case EMediaFlash: test.Printf(_L("Flash\n")); break;

	case EMediaRom: test.Printf(_L("Rom\n")); break;

	case EMediaRemote: test.Printf(_L("Remote\n")); break;

	case EMediaNANDFlash:  test.Printf(_L("NANDFlash\n")); break;

	default:

		test.Printf(_L("Unknown value\n"));

		}

	}

LOCAL_C void MountRemoteFilesystem()

	{

	test.Next(_L("Mount Remote Drive simulator on Q:"));

	TInt r=TheFs.AddFileSystem(_L("CFAFSDLY"));

	test.Printf(_L("Add remote file system"));

	test.Printf(_L("AddFileSystem returned %d\n"),r);

	test_Value(r, r==KErrNone || r==KErrAlreadyExists);

	r=TheFs.MountFileSystem(_L("DELAYFS"),EDriveQ);

	test.Printf(_L("Mount remote file system"));

	test.Printf(_L("MountFileSystem returned %d\n"),r);

	test_Value(r, r==KErrNone || r==KErrCorrupt || r==KErrNotReady || r==KErrAlreadyExists);

	}	

LOCAL_C void DisMountRemoteFilesystem()	

	{

	test.Printf(_L("Dismounting the remote Drives \n"));

 	TInt r=TheFs.DismountFileSystem(_L("DELAYFS"),EDriveQ);

 	test.Printf(_L("Dismounting the Remote Drive returned %d\n"),r);

 	test(r==KErrNone );

	}

LOCAL_C void CreateSubstDrive()

	{

     test.Printf(_L("Create Substitute Drive \n"));

    TDriveList driveList;   

    TInt i ;

    TInt r=TheFs.SessionPath(gTestSessionPath);

	test(r==KErrNone);  

 	r=TheFs.DriveList(driveList, KDriveAttExclude|KDriveAttLocal);

   	test( r==KErrNone );

   	for ( i = EDriveO; i < KMaxDrives; i++) 

      	{

      	if ( driveList[i] == 0) 

          	{

          	if (i == EDriveQ) continue;  // Q reserved to mount a virtual Remote Drive, as part of the test.

        	substDrive = i;

          	break;          

          	}

      	}

   	if (substDrive)

   		{

 		TDriveInfo driveInfo;

		r=TheFs.Drive(driveInfo,substDrive);

		test(r==KErrNone);

		if (driveInfo.iDriveAtt==KDriveAttLocal)

			{	

			return;	//	Subst local drives fails

			}

		TFileName n;

		r=TheFs.Subst(n,substDrive);

		test(r==KErrNone);

		test(n.Length()==0);	

		r=TheFs.SetSubst(gTestSessionPath,substDrive);

		test(r==KErrNone);

		r=TheFs.Subst(n,substDrive);

		test(r==KErrNone);

		test(n==gTestSessionPath);   		

   		}

	}

LOCAL_C void RemoveSubstDrive()

	{

	 	if( substDrive)

	 		{

	 		test.Printf(_L("Removing Substitute Drive \n"));	 	 

	 		TInt r =TheFs.SetSubst(_L(""),substDrive);	

			test(r ==KErrNone);	 		

	 		}

	}

LOCAL_C void testDriveInfo(TInt aDrive,TDriveInfo& anInfo)

//

// Test the drive info is reasonable

//

	{

	if (aDrive==EDriveZ)

		{

		if (anInfo.iType==EMediaNotPresent)

			return;

		test(anInfo.iMediaAtt==KMediaAttWriteProtected);

		test(anInfo.iDriveAtt==(KDriveAttRom|KDriveAttInternal));

		test(anInfo.iType==EMediaRom);

		}

	else if (GetDriveLFFS()==aDrive)

		{

        if (anInfo.iType==EMediaNotPresent)

            return;

		test(anInfo.iDriveAtt&(KDriveAttLocal|KDriveAttInternal)==KDriveAttLocal|KDriveAttInternal);	// LFFS sets KDriveAttTransaction as well

        test(anInfo.iType==EMediaFlash);

        test(anInfo.iMediaAtt==KMediaAttFormattable);

		}

/*

Why assume certain drive letters can only refer to certain drive types?

	else if (aDrive==EDriveC || aDrive==EDriveY)

		{

		if (anInfo.iType==EMediaNotPresent)

			return;

//		test(anInfo.iDriveAtt==(KDriveAttLocal|KDriveAttInternal));

		test(anInfo.iDriveAtt&(KDriveAttLocal|KDriveAttInternal)==KDriveAttLocal|KDriveAttInternal);	// LFFS sets KDriveAttTransaction as well

		test(anInfo.iType==EMediaRam || anInfo.iType==EMediaFlash);

		if(anInfo.iType==EMediaRam)	test(anInfo.iMediaAtt==(KMediaAttVariableSize|KMediaAttFormattable));

		else if(anInfo.iType==EMediaFlash) test(anInfo.iMediaAtt==KMediaAttFormattable);

		}

	else if (aDrive==EDriveD || aDrive==EDriveX)

		{

		if (anInfo.iType==EMediaNotPresent)

			return;

		test(anInfo.iDriveAtt==(KDriveAttLocal|KDriveAttRemovable));

		test(anInfo.iType==EMediaHardDisk);

		test(anInfo.iMediaAtt & KMediaAttFormattable);

		}

*/

	}

/*

*  The following test has the requirement that the only remote drive is the one we mount 

*  during the test and which doesn't have any other attributes set. If this is not the

* case then the test conditions must be changed, in order for the test to stop failing.

*/

LOCAL_C void testDriveList()

//

// Test the drive list.

//

	{

	test.Start(_L("The drive list\n"));

    TInt err;

    TInt drivecount = 0;

    TDriveList driveList;

    TDriveInfo info;

    TUint flags;

    TInt removableDriveCount =0;

	TInt nonHiddenRemovableDriveCount =0;

	TInt logicallyRemovableDriveCount =0;

    TInt substDriveCount =0;

    TInt exclusiveSubstDriveCount =0;

	TInt hiddenDriveCount = 0;

	TInt hiddenOrRemoteDriveCount = 0;

    TInt i ;

 	//--------------------------------------------- 

	//! @SYMTestCaseID			PBASE-T_FSRV-0544

	//! @SYMTestType			UT 

	//! @SYMREQ					CR909, CR1086

	//! @SYMTestCaseDesc		Test that RFs::DriveList(TDriveList& aList) does not return remote or hidden drives.

	//! @SYMTestActions			Call DriveList to get the drive list.

	//! @SYMTestExpectedResults	Check that no remote or hidden drive was returned. Count the number of drives we got 

	//!							and seperately the number of none hidden removable ones.

	//! @SYMTestPriority		High

	//! @SYMTestStatus			Implemented 

	//--------------------------------------------- 

    test.Printf(_L("Test existing DriveList \n"));

    err = TheFs.DriveList(driveList);

    test( err == KErrNone );

    for ( i = 0; i < KMaxDrives; i++) 

        {

        if (driveList[i]) 

            {

            err = TheFs.Drive(info, i);

            test( err == KErrNone );

            test( info.iType  !=  EMediaRemote  );

            test( !(info.iDriveAtt & KDriveAttRemote ) ); 

			test( !(info.iDriveAtt & KDriveAttHidden ) );

            drivecount++; 

            if( info.iDriveAtt  & KDriveAttRemovable) 

           	nonHiddenRemovableDriveCount++;

           	printDriveAtt(i,info.iDriveAtt);

            }

        }

    TInt nonHiddenNonRemovables = drivecount -  nonHiddenRemovableDriveCount;

	test.Printf(_L("Found %d non hidden non removable drives\n"), nonHiddenNonRemovables);

	test.Printf(_L("Found %d non hidden removable drives \n"),nonHiddenRemovableDriveCount);

 	//--------------------------------------------- 

	//! @SYMTestCaseID			PBASE-T_FSRV-0545

	//! @SYMTestType			UT 

	//! @SYMREQ					CR909, CR1086

	//! @SYMTestCaseDesc		Test that RFs::DriveList(TDriveList& aList, TUint aFlags) can be used to return all

	//! 						available drives, including the remote and the hidden ones.

	//! @SYMTestActions			Call DriveList by passing to aFlags a value of KDriveAttAll.

	//! @SYMTestExpectedResults	Check that the number of drives is increased by the number of hidden and remote drives and also that the number of remote drives is one (one remote drive we mounted). 

	//!							Also count the number of substitute, exclusively substitute, removable, physically removable and logically removable drives.

	//! @SYMTestPriority		High

	//! @SYMTestStatus			Implemented 

	//--------------------------------------------- 

   test.Printf(_L("Return all available drives\n"));

   TInt allDrivecount = 0;

   flags = KDriveAttAll;

   err = TheFs.DriveList(driveList, flags);

   test( err == KErrNone );

   for ( i = 0; i < KMaxDrives; i++) 

       {

       if (driveList[i]) 

           {

           err = TheFs.Drive(info,i);

           test( err == KErrNone );

           allDrivecount++;

           if( info.iDriveAtt  & KDriveAttSubsted ) 

           		substDriveCount++;

           if( info.iDriveAtt  == KDriveAttSubsted) 

           		exclusiveSubstDriveCount++;

		   if( info.iDriveAtt  & KDriveAttHidden) 

           		hiddenDriveCount++;

		   if( info.iDriveAtt  & (KDriveAttHidden|KDriveAttRemote))

           		hiddenOrRemoteDriveCount++;

		   if( info.iDriveAtt  & KDriveAttRemovable) 

           		removableDriveCount++;

			if( info.iDriveAtt  & KDriveAttLogicallyRemovable) 

           		logicallyRemovableDriveCount++;

            printDriveAtt(i,info.iDriveAtt);

           }

        }  

 	test(allDrivecount == drivecount + hiddenOrRemoteDriveCount);

	test(hiddenOrRemoteDriveCount - hiddenDriveCount == 1);

	test.Printf(_L("Found %d substitute drives\n"), substDriveCount);

	test.Printf(_L("Found %d exclusively substitute  drives \n"),exclusiveSubstDriveCount);

	test.Printf(_L("Found %d hidden drives\n"), hiddenDriveCount);

	TInt nonRemovables = drivecount -  removableDriveCount;

	TInt physicallyRemovable = removableDriveCount - logicallyRemovableDriveCount;

	test.Printf(_L("Found %d non removables drives\n"), nonRemovables);

	test.Printf(_L("Found %d physically removable drives \n"),physicallyRemovable);

	test.Printf(_L("Found %d logically removable drives \n"),logicallyRemovableDriveCount);

  	//--------------------------------------------- 

	//! @SYMTestCaseID			PBASE-T_FSRV-0546

	//! @SYMTestType			UT 

	//! @SYMREQ					CR909

	//! @SYMTestCaseDesc		Test that RFs::DriveList(TDriveList& aList, TUint aFlags) can be used to specify

	//! 						certain attributes that drives to be returned should have.

	//! @SYMTestActions			Call DriveList by passing to aFlags a value of KDriveAttRemovable.

	//! @SYMTestExpectedResults	Check that the number of drives returned is the same, since no removable drive was added.

	//! @SYMTestPriority		High

	//! @SYMTestStatus			Implemented 

	//--------------------------------------------- 

    test.Printf(_L("Return only Removable \n"));

	drivecount = 0;

    flags = KDriveAttRemovable;

    err = TheFs.DriveList(driveList, flags);

    test( err == KErrNone );

    for ( i = 0; i < KMaxDrives; i++) 

        {

        if (driveList[i]) 

            {

            err = TheFs.Drive(info, i);

            test( err == KErrNone );

            test( info.iDriveAtt & KDriveAttRemovable );

            drivecount++; 

            printDriveAtt(i,info.iDriveAtt);

            }

        }

    test( drivecount == removableDriveCount ); // no removable drive was added

  	//--------------------------------------------- 

	//! @SYMTestCaseID			PBASE-T_FSRV-0547

	//! @SYMTestType			UT 

	//! @SYMREQ					CR909

	//! @SYMTestCaseDesc		Test that RFs::DriveList(TDriveList& aList, TUint aFlags) can be used to specify

	//! 						certain attributes(as a combination)that drives to be returned should have.

	//! @SYMTestActions			Call DriveList by passing to aFlags a value of KDriveAttRemovable | KDriveAttRemote

	//! @SYMTestExpectedResults	Check that the number of drives is increased by one, since we also allow remote drives.

	//! @SYMTestPriority		High

	//! @SYMTestStatus			Implemented 

	//---------------------------------------------