baseport/syborg/svphostfs/fs/svphost.cpp
changeset 2 d55eb581a87c
parent 0 ffa851df0825
equal deleted inserted replaced
1:2fb8b9db1c86 2:d55eb581a87c
       
     1 /*
       
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of the License "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description: f32test\fsstress\t_remote.cpp
       
    15 *
       
    16 */
       
    17 
       
    18 #if !defined(__F32FILE_H__)
       
    19 #include <f32file.h>
       
    20 #endif
       
    21 #if !defined(__E32TEST_H__)
       
    22 #include <e32test.h>
       
    23 #endif
       
    24 #if !defined(__T_STD_H__)
       
    25 #include "t_std.h"
       
    26 #endif
       
    27 #if !defined(__T_REMFSY_H__)
       
    28 #include "t_remfsy.h"
       
    29 #endif
       
    30 
       
    31 GLDEF_D RTest test(_L("T_REMOTE - DEFAULT DRIVE"));
       
    32 GLDEF_D RTest testx(_L("X Drive (WINS) <-> D Drive (MARM)"));
       
    33 GLDEF_D RTest testy(_L("Y Drive (WINS) <-> C Drive (MARM)"));
       
    34 GLDEF_D RTest testq(_L("REMOTE Q Drive"));
       
    35 
       
    36 LOCAL_D TFileName gBatchFile;
       
    37 LOCAL_D TBool gRunByBatch=EFalse;
       
    38 
       
    39 GLDEF_D TFileName gExeFileName(RProcess().FileName());
       
    40 
       
    41 /*
       
    42 INFORMATION - What this test is all about
       
    43 
       
    44 T_REMOTE tests the asynchronous remote file system implementation, introduced in
       
    45 F32 release 110 and refined in release 112.  The test sets up and mounts four drives,
       
    46 the default drive (usually C on WINS and MARM), a remote drive (Q) and two others, on
       
    47 MARM these are C and D, on WINS these are X and Y.  The remote filesystem is the only
       
    48 system treated asynchronously by F32.  
       
    49 
       
    50 The test sets up a thread for each drive and runs a number of tests on each drive.
       
    51 In the remote filesystem case, a dummy filesystem has been implemented, this is built
       
    52 as T_REMFSY.fsy.  The tests are designed to stress a number of fileserver API
       
    53 functions.  The test MultipleSessions() is adapted from another F32 test T_SESSION.
       
    54 It sets up an array of fileserver connections and then uses each connection to run
       
    55 a number of tests - alternating between connections to stress F32 as it does so.  The
       
    56 test should therefore be testing multiple fileserver connections on multiple drives -
       
    57 the remote filesystem running concurrently with the other drives.  There should be
       
    58 no failure or confusion between fileserver sessions.  Each drive has a separate test
       
    59 console which should complete successfully.
       
    60 
       
    61 NOTE: TO RUN THIS CARD SUCCESSFULLY ON MARM A CF CARD IS REQUIRED
       
    62 
       
    63 */
       
    64 
       
    65 LOCAL_C void Test0(RTest& aTest)
       
    66 //
       
    67 //	Scan for open files - no sessions
       
    68 //	
       
    69 	{
       
    70 	aTest.Next(_L("Scan for open files with no sessions open"));
       
    71 	CFileList* list;
       
    72 	TOpenFileScan fileScan(TheFs);
       
    73 	fileScan.NextL(list);
       
    74 	if (list==NULL)
       
    75 		return;
       
    76 	TInt count=list->Count();
       
    77 	if (count==1)
       
    78 		{
       
    79 		gRunByBatch=ETrue;
       
    80 		gBatchFile=(*list)[0].iName;
       
    81 		delete list;
       
    82 		fileScan.NextL(list);
       
    83 		if (list==NULL)
       
    84 			return;
       
    85 		count=list->Count();
       
    86 		}
       
    87 	while (count--)
       
    88 		{
       
    89 		TEntry entry=(*list)[count];
       
    90 		aTest.Printf(_L("%d) EntryName = %S\n"),count,&entry.iName);
       
    91 		}
       
    92 	//aTest.Printf(_L("Test will fail unless files are closed.\n"));
       
    93 	//aTest.Printf(_L("Press any key ...\n"));
       
    94 	//aTest.Getch();
       
    95 	}
       
    96 
       
    97 
       
    98 LOCAL_C void Test1()	
       
    99 //
       
   100 //	This test is only called by default drive
       
   101 //	Test OpenFileScan			
       
   102 //
       
   103 	{
       
   104 	test.Next(_L("Scan for open files - one session only"));
       
   105 
       
   106 	RFile file1,file2,file3;
       
   107 	TFileName fn;
       
   108 	fn = _L("Z:\\TEST\\T_FSRV.CPP");
       
   109 	fn[0] = gExeFileName[0];
       
   110 	TInt r=file1.Open(TheFs,fn,EFileRead|EFileShareReadersOnly);
       
   111 	test(r==KErrNone);
       
   112 	fn = _L("Z:\\TEST\\T_FILE.CPP");
       
   113 	fn[0] = gExeFileName[0];
       
   114 	r=file2.Open(TheFs,fn,EFileRead);
       
   115 	test(r==KErrNone);
       
   116 	fn = _L("Z:\\TEST\\T_FSRV.CPP");
       
   117 	fn[0] = gExeFileName[0];
       
   118 	r=file3.Open(TheFs,fn,EFileRead|EFileShareReadersOnly);
       
   119 	test(r==KErrNone);
       
   120 	
       
   121 	CFileList* list;
       
   122 	TOpenFileScan fileScan(TheFs);
       
   123 	fileScan.NextL(list);
       
   124 
       
   125 	if (gRunByBatch)
       
   126 		{
       
   127 		test(list!=NULL);
       
   128 		test(list->Count()==1);
       
   129 		TEntry entry=(*list)[0];
       
   130 		test(entry.iName.FindF(_L(".BAT"))>=0);
       
   131 		delete list;
       
   132 		fileScan.NextL(list);
       
   133 		}
       
   134 
       
   135 	test(list!=NULL);
       
   136 	TInt count=list->Count();
       
   137 	test(count==3);
       
   138 	TEntry entry=(*list)[0];
       
   139 	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
       
   140 	entry=(*list)[1];
       
   141 	test(entry.iName.FindF(_L("T_FILE.CPP"))>=0);
       
   142 	entry=(*list)[2];
       
   143 	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
       
   144 	TThreadId threadId=fileScan.ThreadId();
       
   145 	RThread current;
       
   146 	TThreadId currentId=current.Id();
       
   147 	test(threadId==currentId);
       
   148 	delete list;
       
   149 
       
   150 	fileScan.NextL(list);
       
   151 	test(list==NULL);
       
   152 
       
   153 	file1.Close();
       
   154 	file2.Close();
       
   155 	file3.Close();
       
   156 	}
       
   157 
       
   158 LOCAL_C void Test2()
       
   159 //
       
   160 // Test openfilescan - empty, full, empty.
       
   161 //
       
   162 	{
       
   163 	test.Next(_L("Scan for open files - empty sessions"));
       
   164 
       
   165 	RFs fs1,fs2,fs3,fs4;
       
   166 	TInt r=fs1.Connect();
       
   167 	test(r==KErrNone);
       
   168 	r=fs2.Connect();
       
   169 	test(r==KErrNone);
       
   170 	r=fs3.Connect();
       
   171 	test(r==KErrNone);
       
   172 	r=fs4.Connect();
       
   173 	test(r==KErrNone);
       
   174 
       
   175 	RFile file1,file2,file3;
       
   176 	TFileName fn;
       
   177 	fn = _L("Z:\\TEST\\T_FSRV.CPP");
       
   178 	fn[0] = gExeFileName[0];
       
   179 	r=file1.Open(fs2,fn,EFileRead|EFileShareReadersOnly);
       
   180 	test(r==KErrNone);
       
   181 	fn = _L("Z:\\TEST\\T_FILE.CPP");
       
   182 	fn[0] = gExeFileName[0];
       
   183 	r=file2.Open(fs2,fn,EFileRead);
       
   184 	test(r==KErrNone);
       
   185 	fn = _L("Z:\\TEST\\T_FSRV.CPP");
       
   186 	fn[0] = gExeFileName[0];
       
   187 	r=file3.Open(fs2,fn,EFileRead|EFileShareReadersOnly);
       
   188 	test(r==KErrNone);
       
   189 	
       
   190 	CFileList* list;
       
   191 	TOpenFileScan fileScan(TheFs);
       
   192 	fileScan.NextL(list);
       
   193 
       
   194 	if (gRunByBatch)
       
   195 		{
       
   196 		test(list!=NULL);
       
   197 		test(list->Count()==1);
       
   198 		TEntry entry=(*list)[0];
       
   199 		test(entry.iName.FindF(_L(".BAT"))>=0);
       
   200 		delete list;
       
   201 		fileScan.NextL(list);
       
   202 		}
       
   203 
       
   204 	test(list!=NULL);
       
   205 	TInt count=list->Count();
       
   206 	test(count==3);
       
   207 	TEntry entry=(*list)[0];
       
   208 	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
       
   209 	entry=(*list)[1];
       
   210 	test(entry.iName.FindF(_L("T_FILE.CPP"))>=0);
       
   211 	entry=(*list)[2];
       
   212 	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
       
   213 	TThreadId threadId=fileScan.ThreadId();
       
   214 	RThread current;
       
   215 	TThreadId currentId=current.Id();
       
   216 	test(threadId==currentId);
       
   217 	delete list;
       
   218 
       
   219 	fileScan.NextL(list);
       
   220 	test(list==NULL);
       
   221 
       
   222 	file1.Close();
       
   223 	file2.Close();
       
   224 	file3.Close();
       
   225 	fs1.Close();
       
   226 	fs2.Close();
       
   227 	fs3.Close();
       
   228 	fs4.Close();
       
   229 	}
       
   230 
       
   231 LOCAL_C void Test3()
       
   232 //
       
   233 // Test openfilescan - empty, full, empty full
       
   234 //
       
   235 	{
       
   236 	test.Next(_L("Scan for open files - multiple sessions"));
       
   237 
       
   238 	RFs fs1,fs2,fs3,fs4;
       
   239 	TInt r=fs1.Connect();
       
   240 	test(r==KErrNone);
       
   241 	r=fs2.Connect();
       
   242 	test(r==KErrNone);
       
   243 	r=fs3.Connect();
       
   244 	test(r==KErrNone);
       
   245 	r=fs4.Connect();
       
   246 	test(r==KErrNone);
       
   247 
       
   248 	RFile file1,file2,file3;
       
   249 	TFileName fn;
       
   250 	fn = _L("Z:\\TEST\\T_FSRV.CPP");
       
   251 	fn[0] = gExeFileName[0];
       
   252 	r=file1.Open(fs2,fn,EFileRead|EFileShareReadersOnly);
       
   253 	test(r==KErrNone);
       
   254 	fn = _L("Z:\\TEST\\T_FILE.CPP");
       
   255 	fn[0] = gExeFileName[0];
       
   256 	r=file2.Open(fs2,fn,EFileRead|EFileShareReadersOnly);
       
   257 	test(r==KErrNone);
       
   258 	fn = _L("Z:\\TEST\\T_FSRV.CPP");
       
   259 	fn[0] = gExeFileName[0];
       
   260 	r=file3.Open(fs2,fn,EFileRead|EFileShareReadersOnly);
       
   261 	test(r==KErrNone);
       
   262 	
       
   263 	r=file1.Open(fs4,fn,EFileRead|EFileShareReadersOnly);
       
   264 	test(r==KErrNone);
       
   265 	fn = _L("Z:\\TEST\\T_FILE.CPP");
       
   266 	fn[0] = gExeFileName[0];
       
   267 	r=file2.Open(fs4,fn,EFileRead|EFileShareReadersOnly);
       
   268 	test(r==KErrNone);
       
   269 	fn = _L("Z:\\TEST\\T_FSRV.CPP");
       
   270 	fn[0] = gExeFileName[0];
       
   271 	r=file3.Open(fs4,fn,EFileRead|EFileShareReadersOnly);
       
   272 	test(r==KErrNone);
       
   273 	
       
   274 	CFileList* list;
       
   275 	TOpenFileScan fileScan(TheFs);
       
   276 	fileScan.NextL(list);
       
   277 
       
   278 	if (gRunByBatch)
       
   279 		{
       
   280 		test(list!=NULL);
       
   281 		test(list->Count()==1);
       
   282 		TEntry entry=(*list)[0];
       
   283 		test(entry.iName.FindF(_L(".BAT"))>=0);
       
   284 		delete list;
       
   285 		fileScan.NextL(list);
       
   286 		}
       
   287 
       
   288 	test(list!=NULL);
       
   289 	TInt count=list->Count();
       
   290 	test(count==3);
       
   291 	TEntry entry=(*list)[0];
       
   292 	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
       
   293 	entry=(*list)[1];
       
   294 	test(entry.iName.FindF(_L("T_FILE.CPP"))>=0);
       
   295 	entry=(*list)[2];
       
   296 	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
       
   297 	TThreadId threadId=fileScan.ThreadId();
       
   298 	RThread current;
       
   299 	TThreadId currentId=current.Id();
       
   300 	test(threadId==currentId);
       
   301 	delete list;
       
   302 
       
   303 	fileScan.NextL(list);
       
   304 	test(list!=NULL);
       
   305 	count=list->Count();
       
   306 	test(count==3);
       
   307 	entry=(*list)[0];
       
   308 	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
       
   309 	entry=(*list)[1];
       
   310 	test(entry.iName.FindF(_L("T_FILE.CPP"))>=0);
       
   311 	entry=(*list)[2];
       
   312 	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
       
   313 	threadId=fileScan.ThreadId();
       
   314 	currentId=current.Id();
       
   315 	test(threadId==currentId);
       
   316 	delete list;
       
   317 
       
   318 	fileScan.NextL(list);
       
   319 	test(list==NULL);
       
   320 
       
   321 	file1.Close();
       
   322 	file2.Close();
       
   323 	file3.Close();
       
   324 	fs1.Close();
       
   325 	fs2.Close();
       
   326 	fs3.Close();
       
   327 	fs4.Close();
       
   328 	}
       
   329 
       
   330 LOCAL_C void Test4()
       
   331 //
       
   332 // Test openfilescan - rdirs, empty, full, empty rdirs.
       
   333 //
       
   334 	{
       
   335 	test.Next(_L("Scan for open files - check RDir sessions are ignored"));
       
   336 
       
   337 	RFs fs1,fs2,fs3,fs4;
       
   338 	TFileName fn;
       
   339 	TInt r=fs1.Connect();
       
   340 	test(r==KErrNone);
       
   341 	r=fs2.Connect();
       
   342 	test(r==KErrNone);
       
   343 	r=fs3.Connect();
       
   344 	test(r==KErrNone);
       
   345 	r=fs4.Connect();
       
   346 	test(r==KErrNone);
       
   347 
       
   348 	RDir dir1,dir2,dir3,dir4;
       
   349 	fn = _L("Z:\\TEST\\*.XDE");
       
   350 	fn[0] = gExeFileName[0];
       
   351 	r=dir1.Open(TheFs,fn,KEntryAttMaskSupported);
       
   352 	test(r==KErrNone);
       
   353 	r=dir2.Open(TheFs,fn,KEntryAttMaskSupported);
       
   354 	test(r==KErrNone);
       
   355 	r=dir3.Open(TheFs,fn,KEntryAttMaskSupported);
       
   356 	test(r==KErrNone);
       
   357 	r=dir4.Open(TheFs,fn,KEntryAttMaskSupported);
       
   358 	test(r==KErrNone);
       
   359 
       
   360 	RFile file1,file2,file3;
       
   361 	fn = _L("Z:\\TEST\\T_FSRV.CPP");
       
   362 	fn[0] = gExeFileName[0];
       
   363 	r=file1.Open(fs2,fn,EFileRead|EFileShareReadersOnly);
       
   364 	test(r==KErrNone);
       
   365 	fn = _L("Z:\\TEST\\T_FILE.CPP");
       
   366 	fn[0] = gExeFileName[0];
       
   367 	r=file2.Open(fs2,fn,EFileRead);
       
   368 	test(r==KErrNone);
       
   369 	fn = _L("Z:\\TEST\\T_FSRV.CPP");
       
   370 	fn[0] = gExeFileName[0];
       
   371 	r=file3.Open(fs2,fn,EFileRead|EFileShareReadersOnly);
       
   372 	test(r==KErrNone);
       
   373 	
       
   374 	RDir dir5,dir6,dir7,dir8;
       
   375 	fn = _L("Z:\\TEST\\*.XDE");
       
   376 	fn[0] = gExeFileName[0];
       
   377 	r=dir5.Open(fs4,fn,KEntryAttMaskSupported);
       
   378 	test(r==KErrNone);
       
   379 	r=dir6.Open(fs4,fn,KEntryAttMaskSupported);
       
   380 	test(r==KErrNone);
       
   381 	r=dir7.Open(fs4,fn,KEntryAttMaskSupported);
       
   382 	test(r==KErrNone);
       
   383 	r=dir8.Open(fs4,fn,KEntryAttMaskSupported);
       
   384 	test(r==KErrNone);
       
   385 
       
   386 	CFileList* list;
       
   387 	TOpenFileScan fileScan(TheFs);
       
   388 	fileScan.NextL(list);
       
   389 
       
   390 	if (gRunByBatch)
       
   391 		{
       
   392 		test(list!=NULL);
       
   393 		test(list->Count()==1);
       
   394 		TEntry entry=(*list)[0];
       
   395 		test(entry.iName.FindF(_L(".BAT"))>=0);
       
   396 		delete list;
       
   397 		fileScan.NextL(list);
       
   398 		}
       
   399 
       
   400 	test(list!=NULL);
       
   401 	TInt count=list->Count();
       
   402 	test(count==3);
       
   403 	TEntry entry=(*list)[0];
       
   404 	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
       
   405 	entry=(*list)[1];
       
   406 	test(entry.iName.FindF(_L("T_FILE.CPP"))>=0);
       
   407 	entry=(*list)[2];
       
   408 	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
       
   409 	TThreadId threadId=fileScan.ThreadId();
       
   410 	RThread current;
       
   411 	TThreadId currentId=current.Id();
       
   412 	test(threadId==currentId);
       
   413 	delete list;
       
   414 
       
   415 	fileScan.NextL(list);
       
   416 	test(list==NULL);
       
   417 
       
   418 	file1.Close();
       
   419 	file2.Close();
       
   420 	file3.Close();
       
   421 	dir1.Close();	dir2.Close();
       
   422 	dir3.Close();	dir4.Close();
       
   423 	dir5.Close();	dir6.Close();
       
   424 	dir7.Close();	dir8.Close();
       
   425 	fs1.Close();	fs2.Close();
       
   426 	fs3.Close();	fs4.Close();
       
   427 	}
       
   428 
       
   429 LOCAL_C void Test5()
       
   430 //
       
   431 // Test OpenFileScan
       
   432 //
       
   433 	{
       
   434 
       
   435 	test.Next(_L("Scan for open files - mixed RDirs and RFiles"));
       
   436 
       
   437 	RFile file1,file2,file3;
       
   438 	TFileName fn;
       
   439 	fn = _L("Z:\\TEST\\T_FSRV.CPP");
       
   440 	fn[0] = gExeFileName[0];
       
   441 	TInt r=file1.Open(TheFs,fn,EFileRead|EFileShareReadersOnly);
       
   442 	test(r==KErrNone);
       
   443 	fn = _L("Z:\\TEST\\T_FILE.CPP");
       
   444 	fn[0] = gExeFileName[0];
       
   445 	r=file2.Open(TheFs,fn,EFileRead);
       
   446 	test(r==KErrNone);
       
   447 	fn = _L("Z:\\TEST\\T_FSRV.CPP");
       
   448 	fn[0] = gExeFileName[0];
       
   449 	r=file3.Open(TheFs,fn,EFileRead|EFileShareReadersOnly);
       
   450 	test(r==KErrNone);
       
   451 	
       
   452 	RDir dir1,dir2,dir3,dir4;
       
   453 	fn = _L("Z:\\TEST\\*.XDE");
       
   454 	fn[0] = gExeFileName[0];
       
   455 	r=dir1.Open(TheFs,fn,KEntryAttMaskSupported);
       
   456 	test(r==KErrNone);
       
   457 	r=dir2.Open(TheFs,fn,KEntryAttMaskSupported);
       
   458 	test(r==KErrNone);
       
   459 	r=dir3.Open(TheFs,fn,KEntryAttMaskSupported);
       
   460 	test(r==KErrNone);
       
   461 	r=dir4.Open(TheFs,fn,KEntryAttMaskSupported);
       
   462 	test(r==KErrNone);
       
   463 
       
   464 	CFileList* list;
       
   465 	TOpenFileScan fileScan(TheFs);
       
   466 	fileScan.NextL(list);
       
   467 
       
   468 	if (gRunByBatch)
       
   469 		{
       
   470 		test(list!=NULL);
       
   471 		test(list->Count()==1);
       
   472 		TEntry entry=(*list)[0];
       
   473 		test(entry.iName.FindF(_L(".BAT"))>=0);
       
   474 		delete list;
       
   475 		fileScan.NextL(list);
       
   476 		}
       
   477 
       
   478 	test(list!=NULL);
       
   479 	TInt count=list->Count();
       
   480 	test(count==3);
       
   481 	TEntry entry=(*list)[0];
       
   482 	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
       
   483 	entry=(*list)[1];
       
   484 	test(entry.iName.FindF(_L("T_FILE.CPP"))>=0);
       
   485 	entry=(*list)[2];
       
   486 	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
       
   487 	TThreadId threadId=fileScan.ThreadId();
       
   488 	RThread current;
       
   489 	TThreadId currentId=current.Id();
       
   490 	test(threadId==currentId);
       
   491 	delete list;
       
   492 
       
   493 	fileScan.NextL(list);
       
   494 	test(list==NULL);
       
   495 
       
   496 	file1.Close();
       
   497 	file2.Close();
       
   498 	file3.Close();
       
   499 	dir1.Close();
       
   500 	dir2.Close();
       
   501 	dir3.Close();
       
   502 	dir4.Close();
       
   503 	}
       
   504 
       
   505 
       
   506 
       
   507 LOCAL_C void MultipleSessions(TInt aDrive, RTest& aTest)
       
   508 //
       
   509 //	Create an array of fileserver sessions
       
   510 //	Create an array of TMultipleSessionTest objects 
       
   511 //
       
   512 	
       
   513 	{
       
   514 #if defined(UNICODE)
       
   515 	const TInt maxNumberSessions=10;	
       
   516 #else
       
   517 	const TInt maxNumberSessions=20;
       
   518 #endif
       
   519 
       
   520 	RFs session[maxNumberSessions];
       
   521 	TMultipleSessionTest testObject[maxNumberSessions];
       
   522 	TInt i=0;
       
   523 	TInt r;
       
   524 
       
   525 	for (; i<maxNumberSessions; i++)
       
   526 		{
       
   527 		r=session[i].Connect();
       
   528 		test(r==KErrNone);
       
   529 		testObject[i].Initialise(session[i]);
       
   530 		testObject[i].SetSessionPath(aDrive);
       
   531 		testObject[i].RunTests(aTest);		//	Run the set of tests for each session
       
   532 		}									//	Leave each session open
       
   533 											
       
   534 
       
   535 	for (i=0; i<(maxNumberSessions-1); i++)
       
   536 		{
       
   537 	//	Alternate tests between open sessions
       
   538 		testObject[i].testSetVolume(aTest);
       
   539 		testObject[i+1].testInitialisation(aTest);
       
   540 		testObject[i].testSubst(aTest);
       
   541 		testObject[i+1].testInitialisation(aTest);
       
   542 		testObject[i].testInitialisation(aTest);
       
   543 		testObject[i].testDriveList(aTest);
       
   544 		testObject[i].MakeAndDeleteFiles(aTest);
       
   545 	//	Close session[i] and check that session[i+1] is OK	
       
   546 		session[i].Close();	
       
   547 		testObject[i+1].testInitialisation(aTest);
       
   548 		testObject[i+1].testSetVolume(aTest);
       
   549 		testObject[i+1].testInitialisation(aTest);
       
   550 		testObject[i+1].testSubst(aTest);
       
   551 		testObject[i+1].testDriveList(aTest);
       
   552 	//	Reconnect session[i]	
       
   553 		r=session[i].Connect();
       
   554 		test(r==KErrNone);
       
   555 		testObject[i].Initialise(session[i]);
       
   556 		testObject[i].SetSessionPath(aDrive);
       
   557 		testObject[i].testSetVolume(aTest);
       
   558 		testObject[i+1].testInitialisation(aTest);
       
   559 		testObject[i].testSubst(aTest);
       
   560 		testObject[i+1].testInitialisation(aTest);
       
   561 		testObject[i].testInitialisation(aTest);
       
   562 		testObject[i].testDriveList(aTest);
       
   563 	//	Close session[i+1] and check that session[i] is OK
       
   564 		session[i+1].Close();	
       
   565 		testObject[i].testInitialisation(aTest);
       
   566 		testObject[i].testSetVolume(aTest);
       
   567 		testObject[i].testInitialisation(aTest);
       
   568 		testObject[i].testSubst(aTest);
       
   569 		testObject[i].testDriveList(aTest);
       
   570 	//	Reconnect session[i+1]	
       
   571 		r=session[i+1].Connect();
       
   572 		test(r==KErrNone);
       
   573 		testObject[i+1].Initialise(session[i+1]);
       
   574 		testObject[i+1].SetSessionPath(aDrive);
       
   575 		testObject[i].testSetVolume(aTest);
       
   576 		testObject[i+1].testInitialisation(aTest);
       
   577 		testObject[i].testSubst(aTest);
       
   578 		testObject[i+1].testInitialisation(aTest);
       
   579 	//	Close session[i] and check that session[i+1] is OK	
       
   580 		session[i].Close();	
       
   581 		testObject[i+1].testInitialisation(aTest);
       
   582 		testObject[i+1].testSetVolume(aTest);
       
   583 		testObject[i+1].testInitialisation(aTest);
       
   584 		testObject[i+1].testSubst(aTest);
       
   585 		testObject[i+1].testDriveList(aTest);
       
   586 		
       
   587 		if (i==maxNumberSessions-1)	//	Tidy up by closing remaining open session
       
   588 			{
       
   589 			session[i+1].Close();	
       
   590 			}
       
   591 		}
       
   592 	}
       
   593 
       
   594 GLDEF_C void CallTestsDefaultL(TInt aDrive)
       
   595 //
       
   596 // Call tests that may leave
       
   597 //
       
   598 	{
       
   599 	Test0(test);
       
   600 	Test1();		
       
   601 	Test2();
       
   602 	Test3();
       
   603 	Test4();
       
   604 	Test5();
       
   605 	MultipleSessions(aDrive,test);
       
   606 	}
       
   607 
       
   608 GLDEF_C void CallTestsXL(TInt aDrive)
       
   609 //
       
   610 // Call tests for drive X
       
   611 //
       
   612 	{
       
   613 	Test0(testx);
       
   614 
       
   615 	RFile file1;
       
   616 	TFileName fn;
       
   617 	fn = _L("Z:\\TEST\\T_FSRV.CPP");
       
   618 	fn[0] = gExeFileName[0];
       
   619 	TInt r=file1.Open(TheFs,fn,EFileRead|EFileShareReadersOnly);
       
   620 	testx(r==KErrNone);
       
   621 	file1.Close();
       
   622 	MultipleSessions(aDrive,testx);
       
   623 	}
       
   624 
       
   625 GLDEF_C void CallTestsYL(TInt aDrive)
       
   626 //
       
   627 // Call tests for drive Y
       
   628 //
       
   629 	{
       
   630 	Test0(testy);
       
   631 
       
   632 	RFile file1;
       
   633 	TFileName fn;
       
   634 	fn = _L("Z:\\TEST\\T_FSRV.CPP");
       
   635 	fn[0] = gExeFileName[0];
       
   636 	TInt r=file1.Open(TheFs,fn,EFileRead|EFileShareReadersOnly);
       
   637 	testy(r==KErrNone);
       
   638 	file1.Close();
       
   639 	MultipleSessions(aDrive,testy);
       
   640 	}
       
   641 
       
   642 GLDEF_C void CallTestsQL(TInt aDrive)
       
   643 //
       
   644 // Call tests for remote drive
       
   645 //
       
   646 	{
       
   647 
       
   648 	Test0(testq);
       
   649 	
       
   650 	testq.Printf(_L("This may take some time.  Please be patient...\n"));
       
   651 	
       
   652 	testq.Next(_L("Test remote drive with multiple sessions"));
       
   653 	MultipleSessions(aDrive,testq);
       
   654 
       
   655 	const TInt numberOfTests=10;
       
   656 	
       
   657 	TPtrC record[numberOfTests];
       
   658 	
       
   659 	TInt i=0;
       
   660 	for (;i<numberOfTests;i++)
       
   661 		{
       
   662 		if (i%2)
       
   663 			record[i].Set(_L("Hubble_Bubble"));
       
   664 		else
       
   665 			record[i].Set(_L("Toil_and_Trouble"));
       
   666 		}
       
   667 	
       
   668 	testq.Next(_L("Create a file 'TEXTFILE.TXT' on the remote drive"));
       
   669 	RFile f;
       
   670 	TInt r=f.Replace(TheFs,_L("TEXTFILE.TXT"),0);
       
   671 	testq(r==KErrNone);
       
   672 	TFileText textFile;
       
   673 	textFile.Set(f);
       
   674 	
       
   675 	testq.Next(_L("Write to 'TEXTFILE.TXT'"));
       
   676 	
       
   677 	for (i=0;i<numberOfTests;i++)
       
   678 		{
       
   679 		r=textFile.Write(record[i]);
       
   680 		testq(r==KErrNone);
       
   681 		testq.Printf(_L("Write %d completed OK\n"),i+1);
       
   682 		}
       
   683 	
       
   684 	f.Close();
       
   685 
       
   686 	RFile file1;
       
   687 	r=file1.Open(TheFs,_L("Q:\\TEST\\T_FSRV.CPP"),EFileRead|EFileShareReadersOnly);
       
   688 	testq(r==KErrNone);
       
   689 	file1.Close();	
       
   690 
       
   691 	}