1 // Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // f32test\server\t_fsrv.cpp

    15 // 

    16 //

    17 #define __E32TEST_EXTENSION__

    18 #include <f32file.h>

    19 #include <e32test.h>

    20 #include "t_server.h"

    21 #include "t_chlffs.h"

    22 

    23 #include "f32_test_utils.h"

    24 

    25 using namespace F32_Test_Utils;

    26 

    27 

    28 RTest test(_L("T_FSRV"));

    29 

    30                  

    31 

    32 const TInt KMaxParses=7;

    33 const TInt KHeapSize=0x2000;

    34 TFileName tPath;

    35 TBool gFirstTime=ETrue;

    36 const TInt KMaxVolumeName=11;

    37 

    38 TInt substDrive=0;

    39 

    40 TFileName gTestSessionPath;

    41 

    42 TInt LargeFileSize;

    43 TInt gDrive=-1;

    44 

    45 struct SParse

    46 	{

    47 	const TText* src;

    48 	const TText* rel;

    49 	const TText* def;

    50 	const TText* fullName;

    51 	const TText* drive;

    52 	const TText* path;

    53 	const TText* name;

    54 	const TText* ext;

    55 	};

    56 

    57 struct SParseServer

    58 	{

    59 	const TText* src;

    60 	const TText* rel;

    61 	const TText* fullName;

    62 	const TText* drive;

    63 	const TText* path;

    64 	const TText* name;

    65 	const TText* ext;

    66 	};

    67 

    68 LOCAL_D SParse parse[KMaxParses] =

    69 	{

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

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

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

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

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

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

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

    77 	};

    78 

    79 LOCAL_D SParseServer parseServer[KMaxParses] =

    80 	{

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

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

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

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

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

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

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

    88 	};

    89 

    90 LOCAL_C TInt pathTestThread(TAny*)

    91 //

    92 // The entry point for the producer thread.

    93 //

    94 	{

    95 

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

    97 	test.Title();

    98 

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

   100 	RFs f;

   101 	TInt r=f.Connect();

   102 	test(r==KErrNone);

   103 	r=f.SessionPath(tPath);

   104 	test(r==KErrNone);

   105 	f.Close();

   106 

   107 	return(KErrNone);

   108 	}

   109 

   110 LOCAL_C void printDriveAtt(TInt aDrive,TUint anAtt)

   111 //

   112 // Print a drive attribute.

   113 //

   114 	{

   115 

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

   117 	if (anAtt&KDriveAttLocal)

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

   119 	if (anAtt&KDriveAttRom)

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

   121 	if (anAtt&KDriveAttRedirected)

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

   123 	if (anAtt&KDriveAttSubsted)

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

   125 	if (anAtt&KDriveAttInternal)

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

   127 	if (anAtt&KDriveAttHidden)

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

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

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

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

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

   133 	

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

   135 	}

   136 

   137 LOCAL_C void printDriveInfo(TInt aDrive,TDriveInfo& anInfo)

   138 //

   139 // Print a drive info.

   140 //

   141 	{

   142 

   143 	printDriveAtt(aDrive,anInfo.iDriveAtt);

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

   145 	if (anInfo.iMediaAtt==0)

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

   147 	if (anInfo.iMediaAtt&KMediaAttVariableSize)

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

   149 	if (anInfo.iMediaAtt&KMediaAttDualDensity)

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

   151 	if (anInfo.iMediaAtt&KMediaAttFormattable)

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

   153 	if (anInfo.iMediaAtt&KMediaAttWriteProtected)

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

   155 	test.Printf(_L("\n   BATTERY="));

   156 	switch(anInfo.iBattery)

   157 		{

   158 	case EBatNotSupported: test.Printf(_L("Not supported\n")); break;

   159 	case EBatGood: test.Printf(_L("Good\n")); break;

   160 	case EBatLow: test.Printf(_L("Low\n")); break;

   161 	default:

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

   163 		}

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

   165 	switch(anInfo.iType)

   166 		{

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

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

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

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

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

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

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

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

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

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

   177 	default:

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

   179 		}

   180 	}

   181 	

   182 	

   183 			

   184 	

   185 LOCAL_C void MountRemoteFilesystem()

   186 	{

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

   188 

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

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

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

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

   193 

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

   195 

   196 	

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

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

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

   200 

   201 	}	

   202 

   203 

   204 LOCAL_C void DisMountRemoteFilesystem()	

   205 	{

   206 

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

   208  	

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

   210  	 

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

   212  	

   213  	test(r==KErrNone );

   214 	}

   215 

   216 

   217 LOCAL_C void CreateSubstDrive()

   218 	{

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

   220     

   221     TDriveList driveList;   

   222     TInt i ;

   223       

   224     TInt r=TheFs.SessionPath(gTestSessionPath);

   225 	test(r==KErrNone);  

   226  	

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

   228    	test( r==KErrNone );

   229    

   230 

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

   232       	{

   233     

   234       	if ( driveList[i] == 0) 

   235           	{

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

   237         	substDrive = i;

   238           	break;          

   239           	}

   240       	}

   241            

   242    

   243    	if (substDrive)

   244    		{

   245  		TDriveInfo driveInfo;

   246 		r=TheFs.Drive(driveInfo,substDrive);

   247 		test(r==KErrNone);

   248 	

   249 		if (driveInfo.iDriveAtt==KDriveAttLocal)

   250 			{	

   251 			return;	//	Subst local drives fails

   252 			}

   253 	

   254 		TFileName n;

   255 		r=TheFs.Subst(n,substDrive);

   256 		test(r==KErrNone);

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

   258 		r=TheFs.SetSubst(gTestSessionPath,substDrive);

   259 		test(r==KErrNone);

   260 		r=TheFs.Subst(n,substDrive);

   261 		test(r==KErrNone);

   262 		test(n==gTestSessionPath);   		

   263    		}

   264 

   265 	

   266 	}

   267 

   268 		

   269 LOCAL_C void RemoveSubstDrive()

   270 	{

   271 	 	if( substDrive)

   272 	 		{

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

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

   275 			test(r ==KErrNone);	 		

   276 	 		}

   277 

   278 	}

   279 

   280 

   281 

   282 LOCAL_C void testDriveInfo(TInt aDrive,TDriveInfo& anInfo)

   283 //

   284 // Test the drive info is reasonable

   285 //

   286 	{

   287 

   288 	test(anInfo.iBattery==EBatLow || anInfo.iBattery==EBatGood || anInfo.iBattery==EBatNotSupported);

   289 	

   290 	if (aDrive==EDriveZ)

   291 		{

   292 		if (anInfo.iType==EMediaNotPresent)

   293 			return;

   294 		

   295 		test(anInfo.iMediaAtt==KMediaAttWriteProtected);

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

   297 		test(anInfo.iType==EMediaRom);

   298 		}

   299 

   300 	else if (GetDriveLFFS()==aDrive)

   301 		{

   302         if (anInfo.iType==EMediaNotPresent)

   303             return;

   304 

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

   306         test(anInfo.iType==EMediaFlash);

   307         test(anInfo.iMediaAtt==KMediaAttFormattable);

   308 		}

   309 /*

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

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

   312 		{

   313 		if (anInfo.iType==EMediaNotPresent)

   314 			return;

   315 

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

   317 

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

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

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

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

   322 		}

   323 	

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

   325 		{

   326 		if (anInfo.iType==EMediaNotPresent)

   327 			return;

   328 

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

   330 		test(anInfo.iType==EMediaHardDisk);

   331 		test(anInfo.iMediaAtt & KMediaAttFormattable);

   332 		}

   333 */

   334 	}

   335 

   336 

   337 /*

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

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

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

   341 */

   342 

   343 

   344 LOCAL_C void testDriveList()

   345 //

   346 // Test the drive list.

   347 //

   348 	{

   349 

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

   351 

   352 

   353     TInt err;

   354     TInt drivecount = 0;

   355     TDriveList driveList;

   356     TDriveInfo info;

   357     TUint flags;

   358     TInt removableDriveCount =0;

   359 	TInt nonHiddenRemovableDriveCount =0;

   360 	TInt logicallyRemovableDriveCount =0;

   361     TInt substDriveCount =0;

   362     TInt exclusiveSubstDriveCount =0;

   363 	TInt hiddenDriveCount = 0;

   364 	TInt hiddenOrRemoteDriveCount = 0;

   365     

   366     TInt i ;

   367 

   368   

   369  	//--------------------------------------------- 

   370 	//! @SYMTestCaseID			PBASE-T_FSRV-0544

   371 	//! @SYMTestType			UT 

   372 	//! @SYMREQ					CR909, CR1086

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

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

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

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

   377 	//! @SYMTestPriority		High

   378 	//! @SYMTestStatus			Implemented 

   379 	//--------------------------------------------- 

   380  

   381     

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

   383     

   384     err = TheFs.DriveList(driveList);

   385     test( err == KErrNone );

   386     

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

   388         {

   389         if (driveList[i]) 

   390             {

   391             err = TheFs.Drive(info, i);

   392             test( err == KErrNone );

   393             test( info.iType  !=  EMediaRemote  );

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

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

   396             drivecount++; 

   397             

   398             if( info.iDriveAtt  & KDriveAttRemovable) 

   399            	nonHiddenRemovableDriveCount++;

   400 

   401            	printDriveAtt(i,info.iDriveAtt);

   402             

   403             }

   404     

   405         }

   406         

   407     

   408     TInt nonHiddenNonRemovables = drivecount -  nonHiddenRemovableDriveCount;

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

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

   411 

   412 

   413   

   414  	//--------------------------------------------- 

   415 	//! @SYMTestCaseID			PBASE-T_FSRV-0545

   416 	//! @SYMTestType			UT 

   417 	//! @SYMREQ					CR909, CR1086

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

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

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

   421 	//! @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). 

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

   423 	//! @SYMTestPriority		High

   424 	//! @SYMTestStatus			Implemented 

   425 	//--------------------------------------------- 

   426  

   427 

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

   429       

   430    TInt allDrivecount = 0;

   431    flags = KDriveAttAll;

   432    err = TheFs.DriveList(driveList, flags);

   433 

   434    test( err == KErrNone );

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

   436        {

   437        if (driveList[i]) 

   438            {

   439            err = TheFs.Drive(info,i);

   440            test( err == KErrNone );

   441            allDrivecount++;

   442            

   443            if( info.iDriveAtt  & KDriveAttSubsted ) 

   444            		substDriveCount++;

   445             

   446            if( info.iDriveAtt  == KDriveAttSubsted) 

   447            		exclusiveSubstDriveCount++;

   448 

   449 		   if( info.iDriveAtt  & KDriveAttHidden) 

   450            		hiddenDriveCount++;

   451 

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

   453            		hiddenOrRemoteDriveCount++;

   454 

   455 		   if( info.iDriveAtt  & KDriveAttRemovable) 

   456            		removableDriveCount++;

   457 

   458 			if( info.iDriveAtt  & KDriveAttLogicallyRemovable) 

   459            		logicallyRemovableDriveCount++;

   460 				           	

   461            

   462             printDriveAtt(i,info.iDriveAtt);

   463            }

   464         }  

   465 

   466  	test(allDrivecount == drivecount + hiddenOrRemoteDriveCount);

   467 	test(hiddenOrRemoteDriveCount - hiddenDriveCount == 1);

   468 

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

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

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

   472 

   473 	TInt nonRemovables = drivecount -  removableDriveCount;

   474 	TInt physicallyRemovable = removableDriveCount - logicallyRemovableDriveCount;

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

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

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

   478   

   479   

   480   	//--------------------------------------------- 

   481 	//! @SYMTestCaseID			PBASE-T_FSRV-0546

   482 	//! @SYMTestType			UT 

   483 	//! @SYMREQ					CR909

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

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

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

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

   488 	//! @SYMTestPriority		High

   489 	//! @SYMTestStatus			Implemented 

   490 	//--------------------------------------------- 

   491 

   492  

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

   494 	

   495 	drivecount = 0;

   496 	

   497     flags = KDriveAttRemovable;

   498     err = TheFs.DriveList(driveList, flags);

   499     test( err == KErrNone );

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

   501         {

   502         if (driveList[i]) 

   503             {

   504             err = TheFs.Drive(info, i);

   505             test( err == KErrNone );

   506             test( info.iDriveAtt & KDriveAttRemovable );

   507             drivecount++; 

   508       

   509             printDriveAtt(i,info.iDriveAtt);

   510             }

   511 

   512         }

   513 

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

   515 

   516 

   517   	//--------------------------------------------- 

   518 	//! @SYMTestCaseID			PBASE-T_FSRV-0547

   519 	//! @SYMTestType			UT 

   520 	//! @SYMREQ					CR909

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

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

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

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

   525 	//! @SYMTestPriority		High

   526 	//! @SYMTestStatus			Implemented 

   527 	//--------------------------------------------- 

   528 

   529 

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

   531  	

   532     drivecount = 0;

   533     flags = KDriveAttRemovable | KDriveAttRemote;

   534     err = TheFs.DriveList(driveList, flags);

   535     test( err == KErrNone );

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

   537         {

   538         if (driveList[i]) 

   539             {

   540             err = TheFs.Drive(info, i);

   541             test( err == KErrNone );

   542             test( (info.iDriveAtt & KDriveAttRemovable ) || (info.iDriveAtt & KDriveAttRemote)); 

   543             drivecount++; 

   544            

   545            	printDriveAtt(i,info.iDriveAtt);

   546             

   547             }

   548 

   549         }

   550     test( drivecount == removableDriveCount + 1 );  //contains the remote drive we mounted

   551     

   552 

   553   	//--------------------------------------------- 

   554 	//! @SYMTestCaseID			PBASE-T_FSRV-0548

   555 	//! @SYMTestType			UT 

   556 	//! @SYMREQ					CR909

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

   558 	//!							return drives with certain attributes.

   559 	//! @SYMTestActions			Call DriveList by passing to aFlags a value of KDriveAttExclusive | KDriveAttRemote.

   560 	//! @SYMTestExpectedResults	Check that only the remote drive that was mounted is returned.

   561 	//! @SYMTestPriority		High

   562 	//! @SYMTestStatus			Implemented 

   563 	//--------------------------------------------- 

   564 

   565  	

   566  	test.Printf(_L("Return Exclusively Remote drives \n"));

   567  	

   568  	drivecount = 0;

   569     flags = KDriveAttExclusive | KDriveAttRemote;

   570     TUint match = KDriveAttRemote;

   571     err = TheFs.DriveList(driveList, flags);

   572     test( err == KErrNone );

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

   574         {

   575         if (driveList[i]) 

   576             {

   577             err = TheFs.Drive(info, i);

   578             test( err == KErrNone );

   579             test( (info.iDriveAtt == match)); 

   580             drivecount++;

   581             

   582             printDriveAtt(i,info.iDriveAtt);

   583             }

   584 

   585         }

   586    	test( drivecount == 1 ); //The remote drive we mounted.

   587 

   588 

   589   	//--------------------------------------------- 

   590 	//! @SYMTestCaseID			PBASE-T_FSRV-0549

   591 	//! @SYMTestType			UT 

   592 	//! @SYMREQ					CR909

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

   594 	//!							to be returned with certain attributes.

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

   596 	//! @SYMTestExpectedResults	Check that the remote drive we mounted is included as a non removable one.

   597 	//! @SYMTestPriority		High

   598 	//! @SYMTestStatus			Implemented 

   599 	//--------------------------------------------- 

   600 

   601 	

   602    test.Printf(_L("Exclude Removable\n"));

   603 

   604    drivecount = 0; 	

   605    flags = KDriveAttExclude | KDriveAttRemovable;

   606    err = TheFs.DriveList(driveList, flags);

   607    test( err == KErrNone );

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

   609        {

   610        if (driveList[i]) 

   611            {

   612            err = TheFs.Drive(info, i);

   613            test( err == KErrNone );

   614            test( (!(info.iDriveAtt & KDriveAttRemovable ) )); 

   615            drivecount++;

   616            

   617            printDriveAtt(i,info.iDriveAtt);

   618            }

   619 

   620        }  

   621      test ( drivecount == allDrivecount - removableDriveCount); 

   622 	 test ( drivecount == nonRemovables + hiddenDriveCount + 1) ;   //The remote drive we added is non removable  

   623 

   624 

   625 

   626   	//--------------------------------------------- 

   627 	//! @SYMTestCaseID			PBASE-T_FSRV-0550

   628 	//! @SYMTestType			UT 

   629 	//! @SYMREQ					CR909

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

   631 	//! 					    drives to be returned with certain attributes(as a combination).

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

   633 	//!							KDriveAttExclude | KDriveAttRemovable | KDriveAttRemote. 						

   634 	//! @SYMTestExpectedResults	Test that only the remote drive that was mounted is returned.

   635 	//! @SYMTestPriority		High

   636 	//! @SYMTestStatus			Implemented 

   637 	//--------------------------------------------- 

   638   

   639  

   640  

   641    test.Printf(_L("Exclude Removable and Remote\n"));

   642    

   643    drivecount = 0;

   644    flags = KDriveAttExclude | KDriveAttRemovable | KDriveAttRemote;

   645    err = TheFs.DriveList(driveList, flags);

   646    

   647    test( err == KErrNone );

   648    

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

   650        {

   651        if (driveList[i]) 

   652            {

   653            err = TheFs.Drive(info,i);

   654            test( err == KErrNone );

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

   656            drivecount++;

   657            

   658            printDriveAtt(i,info.iDriveAtt);

   659            }

   660        }

   661    test(drivecount == (allDrivecount - removableDriveCount - 1)  ); // also excluding the removables and the remote drive   

   662   

   663   

   664 

   665 

   666 

   667   	//--------------------------------------------- 

   668 	//! @SYMTestCaseID			PBASE-T_FSRV-0551

   669 	//! @SYMTestType			UT 

   670 	//! @SYMREQ					CR909

   671 	//! @SYMTestCaseDesc		Test RFs::DriveList(TDriveList& aList, TUint aFlags) with substitute drives.  	

   672 	//! @SYMTestActions			Call DriveList by passing to aFlags combinations of attributes that exclude, exclusive or

   673 	//!							not substitute drives.

   674 	//! @SYMTestExpectedResults	Test that only the appropriate drives are returned.

   675 	//! @SYMTestPriority		High

   676 	//! @SYMTestStatus			Implemented 

   677 	//--------------------------------------------- 

   678 

   679 

   680 

   681 	if (substDrive)

   682 		{

   683 

   684 

   685    		test.Printf(_L("Exclude Remote and Substed\n"));

   686    

   687    		drivecount = 0;

   688    		flags = KDriveAttExclude | KDriveAttRemote | KDriveAttSubsted;

   689    		err = TheFs.DriveList(driveList, flags);

   690    

   691    		test( err == KErrNone );

   692    

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

   694        		{

   695        		if (driveList[i]) 

   696            		{

   697            		err = TheFs.Drive(info,i);

   698            		test( err == KErrNone );

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

   700            		drivecount++;

   701            

   702            		printDriveAtt(i,info.iDriveAtt);

   703            		}

   704        		}

   705     	test(drivecount == (allDrivecount - substDriveCount- 1)  );    

   706 

   707 

   708 		

   709    		test.Printf(_L("Exclusively Exclude Substed drives\n"));

   710    

   711    		drivecount = 0;

   712    		flags = KDriveAttExclusive | KDriveAttExclude | KDriveAttSubsted;

   713    		err = TheFs.DriveList(driveList, flags);

   714    

   715    		test( err == KErrNone );

   716    

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

   718        		{

   719        		if (driveList[i]) 

   720            		{

   721            		err = TheFs.Drive(info,i);

   722            		test( err == KErrNone );

   723            		test( info.iDriveAtt != KDriveAttSubsted );

   724            		drivecount++;

   725            

   726            		printDriveAtt(i,info.iDriveAtt);

   727            		}		

   728    		    

   729    		    }

   730     

   731 		test(drivecount == (allDrivecount - exclusiveSubstDriveCount)  );        

   732 		

   733 		}

   734 

   735 

   736   	//--------------------------------------------- 

   737 	//! @SYMTestCaseID			PBASE-T_FSRV-0552

   738 	//! @SYMTestType			UT 

   739 	//! @SYMREQ					CR909

   740 	//! @SYMTestCaseDesc		Test that RFs::DriveList(TDriveList& aList, TUint aFlags) returns the correct value for every

   741 	//!							combination of matching mask.

   742 	//! @SYMTestActions			Call DriveList for every combination of mask and check that the correct value is returned.   

   743 	//!							A structure is used to store the expected value for each combination.

   744 	//! @SYMTestExpectedResults	Test for every combination that only drives with the correct attributes are retruned.

   745 	//! @SYMTestPriority		High

   746 	//! @SYMTestStatus			Implemented 

   747 	//--------------------------------------------- 

   748 

   749    

   750   	test.Printf(_L("Test All Combinations \n"));

   751 

   752 	struct TCombinations

   753 		{

   754 		TUint iMatchMask;			  // The Match Mask to be combined with drive attributes

   755 		TInt  iExpectedResultNoAtts;	  // Expected result when flag used on it's own

   756 		TInt  iExpectedResultWithAtts;  // Expected result when flag used in combination with drive flags

   757 		};

   758 

   759 	TCombinations testCombinations[] = {

   760 		{ 0,														KErrNone,     KErrNone},

   761 		{ KDriveAttAll,												KErrNone,     KErrArgument },

   762 		{ KDriveAttExclude,											KErrArgument, KErrNone },

   763 		{ KDriveAttExclusive,										KErrArgument, KErrNone },

   764 		{ KDriveAttExclude | KDriveAttExclusive,					KErrArgument, KErrNone },

   765 		{ KDriveAttAll	   | KDriveAttExclude,						KErrArgument, KErrArgument },

   766 		{ KDriveAttAll     | KDriveAttExclusive,					KErrArgument, KErrArgument},

   767 		{ KDriveAttAll     | KDriveAttExclude | KDriveAttExclusive, KErrArgument, KErrArgument}};

   768 

   769 	TDriveList fullDriveList;

   770 	err = TheFs.DriveList(fullDriveList, KDriveAttAll);

   771 	test( err == KErrNone );

   772 

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

   774 		{

   775 		if (driveList[i]) 

   776 			{

   777 			err = TheFs.Drive(info,i);

   778 			test( err == KErrNone );

   779 			printDriveAtt(i,info.iDriveAtt);

   780 			}

   781 		}

   782 

   783 	for(TUint matchIdx = 0; matchIdx < sizeof(testCombinations) / sizeof(TCombinations); matchIdx++)

   784 		{

   785 		test.Printf(_L("\nMatch Flags: KDriveAttAll[%c] KDriveAttExclude[%c] KDriveAttExclusive[%c]\n"), testCombinations[matchIdx].iMatchMask & KDriveAttAll       ? 'X' : ' ',

   786 																										 testCombinations[matchIdx].iMatchMask & KDriveAttExclude   ? 'X' : ' ',

   787 																										 testCombinations[matchIdx].iMatchMask & KDriveAttExclusive ? 'X' : ' ');

   788 

   789 		for(TUint testAtt = 0; testAtt <= KMaxTUint8; testAtt++)

   790 			{

   791 			TDriveList newDriveList;

   792 			err = TheFs.DriveList(newDriveList, testCombinations[matchIdx].iMatchMask | testAtt);

   793 	 		

   794 			//test.Printf(_L("            ATT : 0x%08x \n"), testAtt);

   795 			//test.Printf(_L("Expected Result : %d     \n"), testAtt == 0 ? testCombinations[matchIdx].iExpectedResultNoAtts : testCombinations[matchIdx].iExpectedResultWithAtts);

   796 			//test.Printf(_L("  Actual Result : 0x%08x \n"), err);

   797 

   798 			test( err == (testAtt == 0 ? testCombinations[matchIdx].iExpectedResultNoAtts : testCombinations[matchIdx].iExpectedResultWithAtts) );

   799 

   800 			if(err == KErrNone)

   801 				{

   802 				//printDriveAtt(0, testAtt);  //Prints attributes   

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

   804 					{

   805 					TBool expectMatch = EFalse;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             

   806 

   807 					switch(testCombinations[matchIdx].iMatchMask)

   808 						{

   809 						case 0:

   810 							expectMatch = (fullDriveList[i] & testAtt) != 0;                                                                                                                                                           

   811 							break;

   812 

   813 						case KDriveAttAll:

   814 							expectMatch = ETrue;

   815 							break;

   816 

   817 						case KDriveAttExclude :

   818 							expectMatch = (fullDriveList[i] & testAtt) == 0;

   819 							break;

   820 

   821 						case KDriveAttExclusive :

   822 							expectMatch = (fullDriveList[i] == testAtt);

   823 							break;

   824 

   825 						case KDriveAttExclude | KDriveAttExclusive:

   826 							expectMatch = (fullDriveList[i] != testAtt);

   827 							break;

   828 	

   829 						case KDriveAttAll | KDriveAttExclude :

   830 							test(0);	// Invalid - should never get here as this returns KErrArgument for all cases

   831 							break;

   832 

   833 						case KDriveAttAll | KDriveAttExclusive :

   834 							test(0);	// Invalid - should never get here as this returns KErrArgument for all cases

   835 							break;

   836 

   837 						case KDriveAttAll | KDriveAttExclude | KDriveAttExclusive :

   838 							test(0);	// Invalid - should never get here as this returns KErrArgument for all cases

   839 							break;

   840 

   841 						default:

   842 							test.Printf(_L("Unexpected Match Mask %08x"), testCombinations[matchIdx].iMatchMask);

   843 							test(0);

   844 							break;

   845 						}

   846 

   847 					if(expectMatch) 

   848 						{

   849 						//test.Printf(_L(" %c MATCHED OK "), 'A' + i);

   850 						test(newDriveList[i] == fullDriveList[i]);

   851 						}

   852 					else

   853 						{

   854 						/*if(fullDriveList[i] == 0)

   855 							{

   856 							test.Printf(_L(" %c NOT PRESENT "), 'A' + i);

   857 							}

   858 						else

   859 							{

   860 							test.Printf(_L(" %c NOT MATCHED "), 'A' + i);

   861 							}

   862 						*/

   863 						test(newDriveList[i] == 0);

   864 						}

   865 					}

   866 				}

   867 			}

   868 		}

   869 

   870 

   871 

   872 	//--------------------------------------------- 

   873 	//! @SYMTestCaseID			PBASE-T_FSRV-0605

   874 	//! @SYMTestType			UT

   875 	//! @SYMREQ					CR1086

   876 	//! @SYMTestCaseDesc		Test that RFs::DriveList(TDriveList& aList, TUint aFlags) can identify the 

   877 	//!							logically removable drives.

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

   879 	//! @SYMTestExpectedResults	Check that only the logically removable drives specified in estart.txt are returned.

   880 	//! @SYMTestPriority		High

   881 	//! @SYMTestStatus			Implemented

   882 	//--------------------------------------------- 

   883 

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

   885  	

   886  	drivecount = 0;

   887     flags = KDriveAttLogicallyRemovable;

   888     err = TheFs.DriveList(driveList, flags);

   889     test( err == KErrNone );

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

   891         {

   892         if (driveList[i]) 

   893             {

   894             err = TheFs.Drive(info, i);

   895             test( err == KErrNone );

   896             test( info.iDriveAtt & KDriveAttLogicallyRemovable );

   897             drivecount++; 

   898       

   899             printDriveAtt(i,info.iDriveAtt);

   900             }

   901 

   902         }

   903 

   904     test( drivecount == logicallyRemovableDriveCount ); // no logically removable drive was added

   905  

   906 

   907 	test.End();

   908 	}

   909 	

   910 

   911 

   912 

   913 

   914 

   915 

   916 LOCAL_C void testDriveInfo()

   917 //

   918 // Test the drive info.

   919 //

   920 	{

   921 

   922 	test.Start(_L("The drive info"));

   923 	TDriveList list;

   924 	TInt r=TheFs.DriveList(list);

   925 	test(r==KErrNone);

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

   927 		{

   928 		TInt att=list[i];

   929 		if (att)

   930 			{

   931 			TDriveInfo d;

   932 			r=TheFs.Drive(d,i);

   933 			test(r==KErrNone);

   934 			printDriveInfo(i,d);

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

   936 			testDriveInfo(i,d);

   937 			}

   938 		}

   939 

   940 	test.End();

   941 	}

   942 

   943 LOCAL_C void testVolumeInfo()

   944 //

   945 // Test volume info.

   946 //

   947 	{

   948 

   949 	test.Start(_L("The volume info"));

   950 	TDriveList list;

   951 	TInt r=TheFs.DriveList(list);

   952 	test(r==KErrNone);

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

   954 		{

   955 		TVolumeInfo v;

   956 		TDriveInfo d;

   957 		switch (r=TheFs.Volume(v,i))

   958 			{

   959 			case KErrNone:

   960 				printDriveInfo(i,v.iDrive);

   961 				test.Printf(_L("   VOL=\"%S\" ID=%08x\n"),&v.iName,v.iUniqueID);

   962 				test.Printf(_L("   SIZE=%ldK FREE=%ldK\n"),v.iSize/1024,v.iFree/1024);

   963 				break;

   964 			case KErrNotReady:

   965 				r=TheFs.Drive(d, i);

   966 				test_KErrNone(r);

   967 				if (d.iType == EMediaNotPresent)

   968 					test.Printf(_L("%c: Medium not present - cannot perform test.\n"), i + 'A');

   969 				else

   970 					test.Printf(_L("medium found (type %d) but drive %c: not ready\nPrevious test may have hung; else, check hardware.\n"), (TInt)d.iType, i + 'A');

   971 				break;

   972 			case KErrPathNotFound:

   973 				test.Printf(_L("%c: Not Found\n"), i + 'A');

   974 				break;

   975 			case KErrCorrupt:

   976 				test.Printf(_L("%c: Media corruption; previous test may have aborted; else, check hardware\n"), i + 'A');

   977 			default:

   978 				test_KErrNone(r);

   979 			}

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

   981 		}

   982 

   983 	test.End();

   984 	}

   985 

   986 LOCAL_C void testClientParse()

   987 //

   988 // Test the client side parse.

   989 //

   990 	{

   991 

   992 	test.Start(_L("Test client side parsing"));

   993 

   994 	for (TInt i=0;i<KMaxParses;i++)

   995 		{

   996 		TInt r;

   997 		TParse f;

   998 		SParse& p=parse[i];

   999 		TPtrC name(p.src);

  1000 		if (p.rel)

  1001 			{

  1002 			if (p.def)

  1003                 {

  1004                 TPtrC rel(p.rel);

  1005                 TPtrC def(p.def);

  1006 				r=f.Set(name,&rel,&def);

  1007                 }

  1008 			else

  1009                 {

  1010                 TPtrC rel(p.rel);

  1011 				r=f.Set(name,&rel,NULL);

  1012                 }

  1013 			}

  1014 		else

  1015 			r=f.Set(name,NULL,NULL);

  1016 		test(r==KErrNone);

  1017 		test(TPtrC(p.fullName)==f.FullName());

  1018 		test(TPtrC(p.drive)==f.Drive());

  1019 		test(TPtrC(p.path)==f.Path());

  1020 		test(TPtrC(p.name)==f.Name());

  1021 		test(TPtrC(p.ext)==f.Ext());

  1022 		}

  1023 

  1024 	test.End();

  1025 	}

  1026 

  1027 LOCAL_C void testPath()

  1028 //

  1029 // Test the path handling.

  1030 //

  1031 	{

  1032 

  1033 	test.Start(_L("Test path handling"));

  1034 	TFileName p;

  1035 	TInt r=TheFs.SessionPath(p);

  1036 	test(r==KErrNone);

  1037 	test.Printf(_L("SESSION=\"%S\"\n"),&p);

  1038 	r=TheFs.SetSessionPath(_L("A:\\TEST\\"));

  1039 	test(r==KErrNone);

  1040 	r=TheFs.SessionPath(p);

  1041 	test(r==KErrNone);

  1042 	test(p==_L("A:\\TEST\\"));

  1043 	r=TheFs.SetSessionPath(gSessionPath);

  1044 	test(r==KErrNone);

  1045 

  1046 

  1047 	TheFs.SetAllocFailure(gAllocFailOff);

  1048 

  1049 	RThread t;

  1050 	r=t.Create(_L("PathTest"),pathTestThread,KDefaultStackSize,KHeapSize,KHeapSize,NULL);

  1051 	test(r==KErrNone);

  1052 	TRequestStatus tStat;

  1053 	t.Logon(tStat);

  1054 	t.Resume();

  1055 	User::WaitForRequest(tStat);

  1056 	test(tStat==KErrNone);

  1057 	test(r==KErrNone);

  1058 	t.Close();

  1059 

  1060 	TheFs.SetAllocFailure(gAllocFailOn);

  1061 

  1062 	test.End();

  1063 	}

  1064 

  1065 LOCAL_C void testServerParse()

  1066 //

  1067 // Test the client side parse.

  1068 //

  1069 	{

  1070 

  1071 	test.Start(_L("Test server side parsing"));

  1072 

  1073 	TFileName old;

  1074 	TInt r=TheFs.SessionPath(old);

  1075 	test(r==KErrNone);

  1076 	r=TheFs.SetSessionPath(_L("C:\\ABCDEF\\"));

  1077 	test(r==KErrNone);

  1078 	for (TInt i=0;i<KMaxParses;i++)

  1079 		{

  1080 		TInt r;

  1081 		TParse f;

  1082 		SParseServer& p=parseServer[i];

  1083 		TPtrC name(p.src);

  1084 		if (p.rel)

  1085 			r=TheFs.Parse(name,TPtrC(p.rel),f);

  1086 		else

  1087 			r=TheFs.Parse(name,f);

  1088 		test(r==KErrNone);

  1089 		test(TPtrC(p.fullName)==f.FullName());

  1090 		test(TPtrC(p.drive)==f.Drive());

  1091 		test(TPtrC(p.path)==f.Path());

  1092 		test(TPtrC(p.name)==f.Name());

  1093 		test(TPtrC(p.ext)==f.Ext());

  1094 		}

  1095 	r=TheFs.SetSessionPath(old);

  1096 	test(r==KErrNone);

  1097 

  1098 	test.End();

  1099 	}

  1100 

  1101 LOCAL_C void testSubst()

  1102 //

  1103 // Test the substitute functions.

  1104 //

  1105 	{

  1106 

  1107 	test.Printf(_L("Test subst"));

  1108 	TVolumeInfo v;

  1109 	TInt r=TheFs.Volume(v);

  1110 	test(r==KErrNone);

  1111 	TDriveInfo origDI;

  1112 	r=TheFs.Drive(origDI);

  1113 	test(r==KErrNone);

  1114 	

  1115 	TDriveInfo driveInfo;

  1116 	r=TheFs.Drive(driveInfo,EDriveO);

  1117 	test(r==KErrNone);

  1118 	

  1119 	if (driveInfo.iDriveAtt==KDriveAttLocal)

  1120 		{	

  1121 		return;	//	Subst local drives fails

  1122 		}

  1123 	

  1124 	TFileName n;

  1125 	r=TheFs.Subst(n,EDriveO);

  1126 	test(r==KErrNone);

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

  1128 	r=TheFs.SetSubst(gSessionPath,EDriveO);

  1129 	test(r==KErrNone);

  1130 	r=TheFs.Subst(n,EDriveO);

  1131 	test(r==KErrNone);

  1132 	test(n==gSessionPath);

  1133 	TVolumeInfo w;

  1134 	r=TheFs.Volume(w,EDriveO);