1 // Copyright (c) 2008-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_notifier.cpp

    15 // 

    16 //

    17 

    18 #include <f32file.h>

    19 #include <e32test.h>

    20 #include <e32svr.h>

    21 #include <hal.h>

    22 #include "t_server.h"

    23 #include "t_chlffs.h"

    24 #include "t_notify_plugin.h"

    25 

    26 const TInt KNotificationHeaderSize = (sizeof(TUint16)*2)+(sizeof(TUint));

    27 const TInt KMinNotificationBufferSize = 2*KNotificationHeaderSize + 2*KMaxFileName;

    28 

    29 

    30 RTest test(_L("T_NOTIFIER"));

    31 const TInt KMaxHeapSize = 0x800000;

    32 TInt globalDriveNum;

    33 

    34 void DismountPlugin()

    35 	{

    36 	TheFs.DismountPlugin(KNotifyPluginName);

    37 	TheFs.RemovePlugin(KNotifyPluginFileName);

    38 	}

    39 

    40 inline void safe_test(RTest& aTest, TInt aError, TInt aLine, TText* aName)

    41 	{

    42 	if(aError!=KErrNone)

    43 		{

    44 		test.Printf(_L(": ERROR : %d received on line %d\n"),aError,aLine);

    45 		DismountPlugin();

    46 		aTest.operator()(aError==KErrNone,aLine,(TText*)aName);

    47 		}

    48 	}

    49 

    50 // Used by TestMultipleNotificationsL() to show which line the function is called from

    51 inline void safe_test(RTest& aTest, TInt aError, TInt aLine, TInt aLineCall)

    52 	{

    53 	if(aError != KErrNone)

    54 		{

    55 		aTest.Printf(_L(": ERROR : %d received on line %d\n"), aError, aLine);

    56 		aTest.Printf(_L(": ERROR : Function called from line number: %d\n"), aLineCall);

    57 		aTest.operator()(aError == KErrNone, aLine);

    58 		}

    59 	}

    60 

    61 // Prints out the filename

    62 #define ExpandMe(X)	 L ## X

    63 #define Expand(X)	 ExpandMe(X)

    64 

    65 namespace t_notification

    66 	{

    67 	enum EOperation

    68 		{

    69 		//TFsNotification::ECreate

    70 		EFileReplace,

    71 		EFileCreate,

    72 		EFileCreate_subs,			//Create files in subdir, watch subdirs

    73 		EFileCreate_subs_nowatch,	//Create files in subdir, do not monitor subdirs

    74 		EFileCreate_txt_nowatch,	//Create .txt files in subdir, do not monitor subdirs

    75 		EFileCreate_txt,            //Create .txt files

    76 		EFsMkDir,					//Create directory

    77 		//TFsNotification::EAttribute

    78 		EFileSetAtt,

    79 		EFileSetAtt_subs,			//Set attributes in subdir

    80 		EFileSet,

    81 		EFsSetEntry,

    82 		//TFsNotification::ERename

    83 		EFsReplace,					//Replace file

    84 		EFsRename,					//Rename file

    85 		EFsRename_dir,				//Rename directory

    86 		EFileRename,

    87 		EFileRename_wild,			//Rename file using wildcard name

    88 		//TFsNotification::EDelete

    89 		EFsDelete,					//Delete file

    90 		EFsRmDir,					//Remove directory

    91 		EFsRmDir_nonEmpty,			//Remove non-empty directory, which will return KErrInUse

    92 		EFsRmDir_wild,				//Remove subdirectory using wildcard name

    93 		//TFsNotification::EFileChange

    94 		EFileWrite,

    95 		EFileWrite_samesize,		//Write to file without changing its size

    96 		EFileWrite_async,			//Asynchronous write

    97 		EFileSetSize,

    98 		//TFsNotification::EVolumeName

    99 		ESetVolumeLabel,

   100 		//TFsNotification::EDriveName

   101 		ESetDriveName,

   102 		//TFsNotification::EMediaChange

   103 		EMount,

   104 		EDismount,

   105 		EMountScan,

   106 		EMountDismount,

   107 		EFormat,

   108 		EMediaCardRemoval,

   109 		EMediaCardInsertion,

   110 		ERawDiskWrite,

   111 		//Multiple Filters

   112 		EAllOps1,					//Create/Replace and Delete

   113 		EAllOps2,					//Create/Replace, FileChange(Write) and Delete

   114 		EAllOps3,					//Create/Replace, FileChange(SetSize) and Delete

   115 		EAllOps4,					//Create/Replace, Attribute(SetAtt) and Delete

   116 		EAllOps5,					//Create/Replace and Rename

   117 		EAllOps6,					//VolumeName and DriveName

   118 		ECFileManMove               //Create filex in monitored directory, write 4, move to unmonitored, setsize 8, move back, delete

   119 		};

   120 	}

   121 

   122 // Package filename and semaphore for thread

   123 struct SThreadPackage

   124 	{

   125 	TFileName iFileName;

   126 	RSemaphore iBarrier;

   127 	};

   128 

   129 struct SThreadPackageDualSemaphore

   130 	{

   131 	TFileName iFileName;

   132 	RSemaphore iBarrier;

   133 	RSemaphore iBarrier2;

   134 	};

   135 

   136 struct SThreadPackage2

   137 	{

   138 	TInt iTestCase;

   139 	RSemaphore iBarrier;

   140 	};

   141 

   142 // Used by TestMultipleNotificationsL

   143 struct SThreadPackageMultiple

   144 	{

   145 	TFileName iString; 		//Commonly stores the filename

   146 	TFileName iFileName; 	//Commonly stores the path (not inc filename)

   147 	RSemaphore iBarrier;

   148 	t_notification::EOperation iOperation;

   149 	TFsNotification::TFsNotificationType iNotifyType;

   150 	TInt iIterations;    	//# of times to 'do' something

   151 	TInt iMaxNotifications; //# of notifications expected

   152 	TInt iBufferSize;

   153 	TInt iLineCall;			//Line where the function is called from

   154 	};

   155 

   156 void PrintLine()

   157 	{

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

   159 	}

   160 

   161 

   162 // We should receive an EMediaChange notification even though we did not register for it 

   163 void TestMediaCardNotificationWhenNotRegisteredForIt()

   164 	{

   165 	RFs fs;

   166 	TInt r = fs.Connect();

   167 	test(r==KErrNone);

   168 	

   169 	CFsNotify* notify = NULL;

   170 	TRAP(r,notify= CFsNotify::NewL(fs,KMinNotificationBufferSize));

   171 	

   172 	TBuf<40> path;

   173 	path.Append((TChar)gDriveToTest);

   174 	path.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));

   175 	

   176 	TBuf<20> filename;

   177 	filename.Append(_L("media.change1"));

   178 	

   179 	r = notify->AddNotification((TUint)TFsNotification::ECreate,path,filename);

   180 	test(r==KErrNone);

   181 	

   182 	TRequestStatus status;

   183 	r = notify->RequestNotifications(status);

   184 	test(r==KErrNone);

   185 	

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

   187 	test.Printf(_L("Waiting 10 seconds.\n"));

   188 	test.Printf(_L("This is a MANUAL test, it requires the removal of the media card.\n"));

   189 	test.Printf(_L("PLEASE REMOVE THE MEDIA CARD. (DriveNumber %d)\n"),globalDriveNum);

   190 	test.Printf(_L("Or press Ctrl + F5 on the emulator.\n"));

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

   192 	RTimer timer1;

   193 	r = timer1.CreateLocal();

   194 	test(r == KErrNone);

   195 	TRequestStatus timeout;

   196 	TTimeIntervalMicroSeconds32 time = 10000000;

   197 	timer1.After(timeout,time);

   198 	User::WaitForRequest(timeout,status);

   199 	test(status.Int() != KRequestPending);

   200 	timer1.Cancel();

   201 	timer1.Close();

   202 	

   203 	const TFsNotification* notification = notify->NextNotification();

   204 	test(notification != NULL);

   205 	TFsNotification::TFsNotificationType type = notification->NotificationType();

   206 	test(type == TFsNotification::EMediaChange);

   207 	TBuf<2> drive;

   208 	drive.Append((TChar)gDriveToTest);

   209 	drive.Append(_L(":"));

   210 	TPtrC drivePtr;

   211 	r = notification->Path(drivePtr);

   212 	test(r==KErrNone);

   213 	r = drivePtr.Compare(drive);

   214 	test(r==0);

   215 	

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

   217 	test.Printf(_L("Waiting 10 seconds.\n"));

   218 	test.Printf(_L("This is a MANUAL test, it requires the insertion of the media card.\n"));

   219 	test.Printf(_L("PLEASE INSERT THE MEDIA CARD. (DriveNumber %d)\n"),globalDriveNum);

   220 	test.Printf(_L("Or press Ctrl + F5 on the emulator.\n"));

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

   222 	

   223 	notification = notify->NextNotification();

   224 	if(notification == NULL)

   225 		{

   226 		notify->RequestNotifications(status);

   227 		RTimer timer2;

   228 		r = timer2.CreateLocal();

   229 		test(r == KErrNone);

   230 		TRequestStatus timeout2;

   231 		timer2.After(timeout2,time);

   232 		User::WaitForRequest(timeout2,status);

   233 		test(status.Int() != KRequestPending);

   234 		notification = notify->NextNotification();

   235 		timer2.Cancel();

   236 		timer2.Close();

   237 		}

   238 	test(notification != NULL);

   239 	type = notification->NotificationType();

   240 	test(type == TFsNotification::EMediaChange);

   241 

   242 	delete notify;

   243 	fs.Close();

   244 	}

   245 

   246 // Creates two sessions, removes the first one

   247 // and then checks if the second one still works

   248 TInt TestClientRemovalL()

   249 	{

   250 	RFs fs;

   251 	TInt r = fs.Connect();

   252 	test(r==KErrNone);

   253 	

   254 	CFsNotify* notify1 = NULL;

   255 	CFsNotify* notify2 = NULL;

   256 	TRAP(r,notify1= CFsNotify::NewL(fs,KMinNotificationBufferSize);

   257 		   notify2= CFsNotify::NewL(fs,KMinNotificationBufferSize);

   258 		);

   259 	if(r!=KErrNone)

   260 		{

   261 		delete notify1;

   262 		delete notify2;

   263 		test(r==KErrNone);

   264 		}

   265 	

   266 	TBuf<40> path;

   267 	path.Append((TChar)gDriveToTest);

   268 	path.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));

   269 	

   270 	TBuf<15> filename;

   271 	filename.Append(_L("create.file"));

   272 	

   273 	TBuf<40> fullname;

   274 	fullname.Append(path);

   275 	fullname.Append(filename);

   276 	

   277 	r = notify1->AddNotification((TUint)TFsNotification::ECreate,path,filename);

   278 	test(r==KErrNone);

   279 	r = notify2->AddNotification((TUint)TFsNotification::ECreate,path,filename);

   280 	test(r==KErrNone);

   281 	

   282 	delete notify1; //Delete notify1 and ensure we still get notification on notify2

   283 	

   284 	TRequestStatus status;

   285 	r = notify2->RequestNotifications(status);

   286 	test(r==KErrNone);

   287 	

   288 	RFile file;

   289 	file.Replace(fs,fullname,EFileWrite); //Replace produces Create notification

   290 	file.Close();

   291 	

   292 	RTimer tim;

   293 	r = tim.CreateLocal();

   294 	test(r==KErrNone);

   295 	

   296 	TRequestStatus timStatus;

   297 	TTimeIntervalMicroSeconds32 time = 10000000; //10 seconds

   298 	tim.After(timStatus,time);

   299 	

   300 	User::WaitForRequest(status,timStatus);

   301 	test(status!=KRequestPending);

   302 	

   303 	r = fs.Delete(fullname);

   304 	test(r==KErrNone);

   305 	

   306 	delete notify2;

   307 	tim.Close();

   308 	fs.Close();

   309 	return KErrNone;

   310 	}

   311 

   312 /*

   313  * This tests that u can set and receive notifications in the root

   314  * of a drive.

   315  * 

   316  * (something which was apparently not possible on RFs::NotifyChange)

   317  */

   318 TInt TestRootDriveNotifications()

   319 	{

   320 	test.Next(_L("TestRootDriveNotifications"));

   321 	RFs fs;

   322 	fs.Connect();

   323 	

   324 	CFsNotify* notify = NULL;

   325 	

   326 	TRAPD(r,notify = CFsNotify::NewL(fs,KMinNotificationBufferSize););

   327 	test(r==KErrNone);

   328 	test(notify!=NULL);

   329 	

   330 	TBuf<40> path;

   331 	path.Append((TChar)gDriveToTest);

   332 	path.Append(_L(":\\"));

   333 	

   334 	TBuf<15> filename;

   335 	filename.Append(_L("*"));

   336 	

   337 	r = notify->AddNotification((TUint)TFsNotification::ECreate,path,filename);

   338 	test(r==KErrNone);

   339 	

   340 	TRequestStatus status;

   341 	r = notify->RequestNotifications(status);

   342 	test(r==KErrNone);

   343 	

   344 	RFile file;

   345 	TBuf<40> filePath;

   346 	filePath.Append((TChar)gDriveToTest);

   347 	filePath.Append(_L(":\\file.root"));

   348 	r = file.Replace(fs,filePath,EFileRead);

   349 	test(r==KErrNone);

   350 	file.Close();

   351 	

   352 	TRequestStatus s2;

   353 	RTimer tim;

   354 	test(tim.CreateLocal()==KErrNone);

   355 	TTimeIntervalMicroSeconds32 time = 10000000; //10 seconds

   356 	tim.After(s2,time);

   357 	User::WaitForRequest(status,s2);

   358 	test(status!=KRequestPending);

   359 	

   360 	delete notify;

   361 	notify = NULL;

   362 	tim.Close();

   363 	fs.Close();

   364 	return KErrNone;	

   365 	}

   366 

   367 /*

   368  * Creates and deletes loads of CFsNotify objects and makes sure they're all

   369  * cleaned up afterwards.

   370  */

   371 TInt TestNewDeleteCFsNotify(TInt aIterations)

   372 	{

   373 	RPointerArray<CFsNotify> array;

   374 	TInt inArray = 0;

   375 	TInt r = KErrNone;

   376 	for(TInt i = 0; i < aIterations; i++)

   377 		{

   378 		CFsNotify* notify = NULL;

   379 		TRAP(r,notify = CFsNotify::NewL(TheFs,500));

   380 		if(r==KErrNone)

   381 			{

   382 			test(notify!=NULL);

   383 			r = array.Append(notify);

   384 			if(r==KErrNone)

   385 				{

   386 				inArray++;

   387 				}

   388 			else

   389 				{

   390 				delete notify;

   391 				break;

   392 				}

   393 			}

   394 		else

   395 			{

   396 			break;

   397 			}

   398 		}

   399 	

   400 	for(TInt j = inArray-1; j >= 0; j--)

   401 		{

   402 		CFsNotify* notify = (CFsNotify*)array[j];

   403 		array.Remove(j);

   404 		delete notify;

   405 		}

   406 	

   407 	array.Reset();

   408 	array.Close();

   409 	return KErrNone;

   410 	}

   411 

   412 

   413 /*

   414  * Creates a file

   415  * Used in SimpleTest1L(), TestTwoDoersL() TestTwoWatchersL(), TestCancelNotificationL()

   416  */

   417 TInt SimpleSingleNotificationTFDoer(TAny* aAny)

   418 	{

   419 	SThreadPackageDualSemaphore pkgDoer = *(SThreadPackageDualSemaphore*)aAny;

   420 	RTest simpleTestDoer(_L("SimpleSingleNotificationTFDoer"));

   421 	simpleTestDoer.Start(_L("SimpleSingleNotificationTFDoer"));

   422 	TBuf<40> path;

   423 	path.Append(gDriveToTest);

   424 	path.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));

   425 	path.Append(pkgDoer.iFileName);

   426 	

   427 	//Delete file so we definitely get a create notification

   428 	RFs fs;

   429 	TInt r = fs.Connect();

   430 	safe_test(simpleTestDoer,r,__LINE__,(TText*)Expand("t_notifier.cpp"));

   431 	r = fs.Delete(path);

   432 	if(r==KErrNone || r==KErrPathNotFound || r==KErrNotFound)

   433 		r = KErrNone;

   434 	safe_test(simpleTestDoer,r,__LINE__,(TText*)Expand("t_notifier.cpp"));

   435 	r = fs.MkDirAll(path);

   436 	if(r==KErrNone || r==KErrAlreadyExists)

   437 		r = KErrNone;

   438 	safe_test(simpleTestDoer,r,__LINE__,(TText*)Expand("t_notifier.cpp"));

   439 	

   440 	simpleTestDoer.Printf(_L("SimpleSingleNotificationTFDoer - Create File %S\n"),&path);

   441 	//Create file

   442 	RFile file;

   443 	r = file.Create(fs,path,EFileWrite);	

   444 	safe_test(simpleTestDoer,r,__LINE__,(TText*)Expand("t_notifier.cpp"));

   445 	file.Close();	

   446 

   447 	fs.Close();

   448 	simpleTestDoer.End();

   449 	simpleTestDoer.Close();

   450 	return KErrNone;

   451 	}

   452 

   453 /*

   454  * Watches 1 file creation

   455  * Used in SimpleTest1L()

   456  */

   457 TInt SimpleSingleNotificationTFWatcher(TAny* aAny)

   458 	{

   459 	CTrapCleanup* cleanup;

   460 	cleanup = CTrapCleanup::New();

   461 	RThread thread;

   462 	TUint64 threadId = thread.Id().Id();

   463 	

   464 	SThreadPackage pkgDoer = *(SThreadPackage*)aAny;

   465 	RSemaphore& simpleBarrierTest = pkgDoer.iBarrier;

   466 	

   467 	RTest simpleTestWatcher(_L("SimpleSingleNotificationTFWatcher"));

   468 	simpleTestWatcher.Start(_L("SimpleSingleNotificationTFWatcher"));

   469 	

   470 	RFs fs;

   471 	fs.Connect();

   472 	

   473 	simpleTestWatcher.Printf(_L("SimpleSingleNotificationTFWatcher(%d) - Create CFsNotify\n"),threadId);

   474 	CFsNotify* notify = NULL;

   475 	TRAPD(r,notify = CFsNotify::NewL(fs,100); );

   476 	safe_test(simpleTestWatcher,r,__LINE__,(TText*)Expand("t_notifier.cpp"));

   477 	TBuf<40> path;

   478 	path.Append(gDriveToTest);

   479 	path.Append(_L(":\\F32-TST\\T_NOTIFIER\\")); //len=22

   480 	

   481 	TBuf<20> filename;

   482 	filename.Append(pkgDoer.iFileName);

   483 	

   484 	TBuf<40> fullname;

   485 	fullname.Append(path);

   486 	fullname.Append(filename);

   487 	

   488 	simpleTestWatcher.Printf(_L("SimpleSingleNotificationTFWatcher - Add Notification for %S\n"),&path);

   489 	r = notify->AddNotification((TUint)TFsNotification::ECreate,path,filename);

   490 	safe_test(simpleTestWatcher,r,__LINE__,(TText*)Expand("t_notifier.cpp"));

   491 	TRequestStatus status;

   492 	simpleTestWatcher.Printf(_L("SimpleSingleNotificationTFWatcher(%d) - Request Notifications\n"),threadId);

   493 	r = notify->RequestNotifications(status);

   494 	safe_test(simpleTestWatcher,r,__LINE__,(TText*)Expand("t_notifier.cpp"));

   495 	

   496 	simpleBarrierTest.Signal();

   497 	

   498 	simpleTestWatcher.Printf(_L("SimpleSingleNotificationTFWatcher(%d) - Wait for status to return\n"),threadId);

   499 	User::WaitForRequest(status);

   500 		

   501 	simpleTestWatcher.Printf(_L("(%d) NextNotification\n"),threadId);

   502 	const TFsNotification* notification = notify->NextNotification();

   503 	//Test notification is not null.

   504 	//We should be getting 1 notification.

   505 	if(notification == NULL)

   506 		safe_test(simpleTestWatcher,KErrNotFound,__LINE__,(TText*)Expand("t_notifier.cpp"));

   507 	

   508 	simpleTestWatcher.Printf(_L("(%d) - Notification Type\n"),threadId);

   509 	TFsNotification::TFsNotificationType notificationType = ((TFsNotification*)notification)->NotificationType();

   510 	if(notificationType != TFsNotification::ECreate)

   511 		safe_test(simpleTestWatcher,KErrGeneral,__LINE__,(TText*)Expand("t_notifier.cpp"));

   512 	simpleTestWatcher.Printf(_L("(%d) - Notification Path\n"),threadId);

   513 	TPtrC _pathC;

   514 	((TFsNotification*)notification)->Path(_pathC);

   515 	simpleTestWatcher.Printf(_L("Notification Path = %S\n"),&_pathC);

   516 	TBuf<40> _path;

   517 	_path.Copy(_pathC);

   518 	if(_path.Match(fullname)!=KErrNone)

   519 		safe_test(simpleTestWatcher,KErrBadName,__LINE__,(TText*)Expand("t_notifier.cpp"));

   520 	

   521 	/*

   522 	TInt driveNumber = 0;

   523 	TInt gDriveNum = -1;

   524 	notification->DriveNumber(driveNumber);

   525 	RFs::CharToDrive(_pathC[0],gDriveNum);

   526 	if(driveNumber != gDriveNum)

   527 		safe_test(simpleTestWatcher,KErrBadHandle,__LINE__,(TText*)Expand("t_notifier.cpp"));

   528 	

   529 	TUid uid;

   530 	TUint32 realUID = 0x76543210;

   531 	r = notification->UID(uid);

   532 	safe_test(simpleTestWatcher,r,__LINE__,(TText*)Expand("t_notifier.cpp"));

   533 	safe_test(simpleTestWatcher,(realUID == uid.iUid)==1,__LINE__,(TText*)Expand("t_notifier.cpp"));

   534 	*/

   535 	delete notify;

   536 	fs.Close();

   537 	simpleTestWatcher.End();

   538 	simpleTestWatcher.Close();

   539 	delete cleanup;

   540 	return KErrNone;

   541 	}

   542 

   543 /*

   544  * SimpleTest1L - Runs a simple Create test, gets 1 notification, calls type, path etc and exits

   545  * Two threads: 1 watcher, 1 doer

   546  */

   547 TInt SimpleCreateTestL()

   548 	{

   549 	test.Next(_L("SimpleTest"));

   550 	RFs fs;

   551 	fs.Connect();

   552 	_LIT(KFileName,"simple.create");

   553 	SThreadPackage pkgDoer;

   554 	pkgDoer.iFileName = KFileName;

   555 	

   556 	SThreadPackage watcherPkg;

   557 	watcherPkg.iFileName = KFileName;

   558 	User::LeaveIfError(pkgDoer.iBarrier.CreateLocal(0));

   559 	User::LeaveIfError(watcherPkg.iBarrier.CreateLocal(0));

   560 	RThread watcher;

   561 	RThread doer;

   562 	watcher.Create(_L("Simple1WatcherThread"),SimpleSingleNotificationTFWatcher,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&watcherPkg);

   563 	doer.Create(_L("Simple1DoerThread"),SimpleSingleNotificationTFDoer,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&pkgDoer);

   564 	watcher.Resume();

   565 	watcherPkg.iBarrier.Wait(); //Wait till Watcher has requested notification

   566 	doer.Resume();

   567 	

   568 	TRequestStatus status;

   569 	doer.Logon(status);

   570 	User::WaitForRequest(status);

   571 	test.Printf(_L("SimpleCreateTest - Doer Exit Reason = %d\n"),doer.ExitReason());

   572 	safe_test(test,doer.ExitReason(),__LINE__,(TText*)Expand("t_notifier.cpp"));

   573 	

   574 	RDebug::Print(_L("Line %d"),__LINE__);

   575 	

   576 

   577 	watcher.Logon(status);

   578 	RTimer timer1;

   579 	TInt r = timer1.CreateLocal();

   580 	safe_test(test,r,__LINE__,(TText*)Expand("t_notifier.cpp"));

   581 	TRequestStatus timeout;

   582 	TTimeIntervalMicroSeconds32 time = 10000000;    //10 seconds

   583 	timer1.After(timeout,time);

   584 	User::WaitForRequest(timeout,status);

   585 	test(status.Int() != KRequestPending);

   586 	timer1.Cancel();

   587 	timer1.Close();

   588 

   589 	

   590 //	User::WaitForRequest(status);

   591 	test.Printf(_L("SimpleCreateTest - Watcher Exit Reason = %d\n"),watcher.ExitReason());

   592 	safe_test(test,watcher.ExitReason(),__LINE__,(TText*)Expand("t_notifier.cpp"));

   593 	

   594 	CLOSE_AND_WAIT(doer);

   595 	CLOSE_AND_WAIT(watcher);

   596 	

   597 	pkgDoer.iBarrier.Close();

   598 	watcherPkg.iBarrier.Close();

   599 	fs.Close();

   600 	return KErrNone;

   601 	}

   602 

   603 // Doer thread for TestMultipleNotificationsL

   604 TInt MultipleNotificationTFDoer(TAny* aAny)

   605 	{

   606 	RDebug::Print(_L("MultipleNotificationTFDoer - Start, Line %d"), __LINE__);

   607 	SThreadPackageMultiple pkgDoer = *(SThreadPackageMultiple*)aAny;

   608 	RTest multipleTestDoer(_L("MultipleNotificationTFDoer"));

   609 	multipleTestDoer.Start(_L("Multi-Doer"));

   610 	multipleTestDoer.Printf(_L("MultipleNotificationTFDoer - Line %d"),__LINE__);

   611 	TBuf<40> basepath;

   612 	basepath.Append(gDriveToTest);

   613 	basepath.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));

   614 	

   615 	RThread thread;

   616 	RDebug::Print(_L("MultipleNotificationTFDoer - Line %d"), __LINE__);

   617 	TUint64 threadID = thread.Id().Id();

   618 	RDebug::Print(_L("MultipleNotificationTFDoer - Line %d"), __LINE__);

   619 	

   620 	//Delete file so we definitely get a create notification

   621 	RFs fs;

   622 	TInt r = fs.Connect();

   623 	safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   624 

   625 	TEntry entry;

   626 	TBool wildcard = EFalse;

   627 	TBuf<40> _path;

   628 	_path.Append(basepath);

   629 	_path.Append(pkgDoer.iFileName);

   630 	_path.Append(pkgDoer.iString);

   631 	r = fs.Entry(_path, entry);

   632 	if (pkgDoer.iNotifyType != TFsNotification::EMediaChange &&

   633 		pkgDoer.iNotifyType != TFsNotification::EDriveName &&

   634 		pkgDoer.iNotifyType != TFsNotification::EVolumeName &&

   635 		pkgDoer.iOperation != t_notification::EAllOps6)

   636 		{

   637 		if (r == KErrBadName)

   638 			{

   639 			wildcard = ETrue;

   640 			}

   641 		if(r != KErrNone && r != KErrPathNotFound && r != KErrNotFound && r != KErrBadName)

   642 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   643 		if (r == KErrNone && !entry.IsDir() && pkgDoer.iOperation != t_notification::EFsDelete && !wildcard &&

   644 			pkgDoer.iOperation != t_notification::EFsRmDir && pkgDoer.iOperation != t_notification::EFsRmDir_nonEmpty)

   645 			{

   646 			r = fs.Delete(_path);

   647 			if(r != KErrNone && r != KErrPathNotFound && r != KErrNotFound)

   648 				safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   649 			}

   650 		r = fs.MkDirAll(basepath);

   651 		if(r != KErrNone && r != KErrAlreadyExists)

   652 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   653 		}

   654 	

   655 	multipleTestDoer.Printf(_L("MultipleNotificationTFDoer (%d) - Line %d"),threadID,__LINE__);

   656 	

   657 	switch(pkgDoer.iOperation)

   658 		{

   659 		case t_notification::EFileReplace:

   660 			{

   661 			RFile file;

   662 			//Generate Notification

   663 			multipleTestDoer.Printf(_L("File Replace - (%d)\n"),threadID);

   664 			r = file.Replace(fs,_path,EFileWrite);	//RFile::Replace -> TFsNotification::ECreate

   665 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   666 			file.Close();

   667 			

   668 			r = fs.Delete(_path);

   669 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   670 			break;

   671 			}

   672 		case t_notification::EFileCreate:

   673 		case t_notification::EFileCreate_txt_nowatch:

   674 		case t_notification::EFileCreate_txt:

   675 		case t_notification::EAllOps1:

   676 			{

   677 			multipleTestDoer.Printf(_L("MultipleNotificationTFDoer (%d) - Line %d"),threadID,__LINE__);

   678 			if(wildcard)

   679 				{

   680 				for (TInt i = 0; i < pkgDoer.iIterations; i++)

   681 					{

   682 					multipleTestDoer.Printf(_L("MultipleNotificationTFDoer (%d) - Line %d"),threadID,__LINE__);

   683 					RFile file;

   684 					TBuf<40> path;

   685 					path.Append(basepath);

   686 					path.AppendNum(i);

   687 					if(pkgDoer.iOperation == t_notification::EFileCreate_txt)

   688 						{

   689 						//Create file with different extension (no notification)

   690 						path.Append(_L(".wrg"));

   691 						fs.Delete(path);

   692 						multipleTestDoer.Printf(_L("File Create (wrong extension) - %S (%d)\n"),&path,threadID);

   693 						r = file.Create(fs, path, EFileWrite);

   694 						safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   695 						//Change path to contain file with correct extension (notification occurs)

   696 						path.Replace(path.Length()-3,3,_L("txt"));

   697 						}

   698 					else if(pkgDoer.iOperation == t_notification::EFileCreate_txt_nowatch)

   699 					    {

   700 					    path.Append(_L(".txt"));

   701 					    }

   702 					fs.Delete(path);

   703 					

   704 					multipleTestDoer.Printf(_L("File Create - %S (%d)\n"),&path,threadID);

   705 					r = file.Create(fs, path, EFileWrite);

   706 					safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   707 					file.Close();

   708 					r = fs.Delete(path);

   709 					safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   710 					}

   711 				}

   712 			else

   713 				{

   714 				multipleTestDoer.Printf(_L("MultipleNotificationTFDoer (%d) - Line %d"),threadID,__LINE__);

   715 				for(TInt i = 0; i < pkgDoer.iIterations; i++)

   716 					{

   717 					multipleTestDoer.Printf(_L("MultipleNotificationTFDoer (%d) - Line %d"),threadID,__LINE__);

   718 					RFile file;

   719 					multipleTestDoer.Printf(_L("File Create - %S (%d)\n"),&_path,threadID);

   720 					r = file.Create(fs,_path,EFileWrite);

   721 					safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   722 					file.Close();

   723 					r = fs.Delete(_path);

   724 					safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   725 					}

   726 				}

   727 			break;

   728 			}

   729 		case t_notification::EFileCreate_subs:

   730 		case t_notification::EFileCreate_subs_nowatch:

   731 			{

   732 			if (wildcard)

   733 				{

   734 				for (TInt i = 0; i < pkgDoer.iIterations; i++)

   735 					{

   736 					RFile file;

   737 					TBuf<40> path;

   738 					path.Append(basepath);

   739 					path.Append(_L("SubDir\\"));

   740 					r = fs.MkDirAll(path);

   741 					if(r != KErrNone && r != KErrAlreadyExists)

   742 						safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   743 					path.AppendNum(i);

   744 					fs.Delete(path);

   745 					multipleTestDoer.Printf(_L("File Create - %S (%d)\n"),&path,threadID);

   746 					r = file.Create(fs, path, EFileWrite);

   747 					safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   748 					file.Close();

   749 					r = fs.Delete(path);

   750 					safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   751 					}

   752 				}

   753 			break;

   754 			}

   755 		case t_notification::EFileWrite:

   756 		case t_notification::EAllOps2:

   757 			{

   758 			//Works on single file

   759 			RFile file;

   760 			TBuf<40> path;

   761 			path.Append(basepath);

   762 			path.Append(pkgDoer.iFileName);

   763 			path.Append(pkgDoer.iString);

   764 			r = file.Replace(fs,path,EFileWrite);

   765 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   766 			for(TInt i = 0; i < pkgDoer.iIterations; i++)

   767 				{

   768 				multipleTestDoer.Printf(_L("File Write - %S (%d)\n"),&path,threadID);

   769 				r = file.Write(4*i,_L8("abcd"));

   770 				safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   771                 //If cache is enabled, a notification is received only when the cache is flushed

   772                 //We flush the file to make this a general test

   773 				multipleTestDoer.Printf(_L("File Flush - (%d)\n"),threadID);

   774                 r = file.Flush();

   775                 safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   776 				}

   777 			file.Close();

   778 			r = fs.Delete(path);

   779 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   780 			break;

   781 			}

   782 		case t_notification::EFileWrite_samesize:

   783 			{

   784 			RFile file;

   785 			TBuf<40> path;

   786 			path.Append(basepath);

   787 			path.Append(pkgDoer.iFileName);

   788 			path.Append(pkgDoer.iString);

   789 			r = file.Replace(fs,path,EFileWrite);

   790 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   791 			multipleTestDoer.Printf(_L("File Write - %S (%d)\n"),&path,threadID);

   792 			r = file.Write(0,_L8("abcd"));

   793 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   794 			

   795             //If cache is enabled, a notification is received only when the cache is flushed

   796             //We flush the file to make this a general test

   797             multipleTestDoer.Printf(_L("File Flush - (%d)\n"),threadID);

   798             r = file.Flush();

   799             safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   800             

   801 			for(TInt i = 0; i < pkgDoer.iIterations; i++)

   802 				{

   803 				TBuf<2> toWrite;

   804 				toWrite.AppendNum(i);

   805 				multipleTestDoer.Printf(_L("File Write - %S (%d)\n"),&path,threadID);

   806 				r = file.Write(0,(TDesC8&)toWrite);

   807 				safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   808 				multipleTestDoer.Printf(_L("File Flush - (%d)\n"),threadID);

   809                 r = file.Flush();

   810                 safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   811 				}

   812 			file.Close();

   813 			r = fs.Delete(path);

   814 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   815 			break;

   816 			}

   817 		case t_notification::EFileWrite_async:

   818 			{

   819 			RFile file;

   820 			TBuf<40> path;

   821 			path.Append(basepath);

   822 			path.Append(pkgDoer.iFileName);

   823 			path.Append(pkgDoer.iString);

   824 			r = file.Replace(fs,path,EFileWrite);

   825 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   826 			for(TInt i = 0; i < pkgDoer.iIterations; i++)

   827 				{

   828 				TRequestStatus status;

   829 				file.Write(52*i, _L8("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"), status);			

   830 				User::WaitForRequest(status);

   831 				multipleTestDoer.Printf(_L("File Write Async - %S (%d)\n"),&path,threadID);

   832 				TInt fileSize;

   833 				file.Size(fileSize);

   834 				multipleTestDoer.Printf(_L("File Write Async - FileSize: %d\n"),fileSize);

   835 				multipleTestDoer.Printf(_L("File Flush - (%d)\n"),threadID);

   836                 r = file.Flush();

   837                 safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   838 				}

   839 			file.Close();

   840 			r = fs.Delete(path);

   841 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   842 			break;

   843 			}

   844 		case t_notification::EFileSetSize:

   845 		case t_notification::EAllOps3:

   846 			{

   847 			//Works on single file

   848 			RFile file;

   849 			TBuf<40> path;

   850 			path.Append(basepath);

   851 			path.Append(pkgDoer.iFileName);

   852 			path.Append(pkgDoer.iString);

   853 			r = file.Replace(fs,path,EFileWrite);

   854 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   855 			

   856 			//Increase file size

   857 			for(TInt i = 0; i < pkgDoer.iIterations; i++)

   858 				{

   859 				r = file.SetSize(4*(i+1));

   860 				safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   861 				multipleTestDoer.Printf(_L("File Set Size - %d (%d)\n"),4*(i+1),threadID);

   862 				}

   863 			

   864 			//Decrease file size

   865 			for(TInt j = pkgDoer.iIterations - 2; j >= 0; j--)

   866 				{

   867 				r = file.SetSize(4*(j+1));

   868 				safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   869 				multipleTestDoer.Printf(_L("File Set Size - %d (%d)\n"),4*(j+1),threadID);

   870 				}	

   871 			

   872 			file.Close();	

   873 			r = fs.Delete(path);

   874 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   875 			break;

   876 			}

   877 		case t_notification::EFsReplace:

   878 			{

   879 			TBuf<45> path;

   880 			path.Append(basepath);

   881 			path.Append(pkgDoer.iFileName);

   882 			path.Append(pkgDoer.iString);

   883 			path.AppendNum(0);

   884 			

   885 			RFile tempFile;

   886 			multipleTestDoer.Printf(_L("RFs Replace (Create temp file) - (%d)\n"),threadID);

   887 			r = tempFile.Replace(fs,_path,EFileWrite);

   888 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   889 			tempFile.Close();

   890 			

   891 			multipleTestDoer.Printf(_L("RFs Replace - (%d)\n"),threadID);

   892 			r = fs.Replace(_path,path); //RFs::Replace -> TFsNotification::ERename

   893 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   894 			

   895 			r = fs.Delete(path);

   896 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   897 			break;

   898 			}

   899 		case t_notification::EFsRename:

   900 			{

   901 			TBuf<45> path;

   902 			path.Append(basepath);

   903 			path.Append(pkgDoer.iFileName);

   904 			path.Append(pkgDoer.iString);

   905 			path.AppendNum(0);

   906 	

   907 			RFile file;

   908 			r = file.Replace(fs,_path,EFileWrite);

   909 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   910 			file.Close();

   911 

   912 			multipleTestDoer.Printf(_L("RFs Rename - (%d)\n"),threadID);

   913 			r = fs.Rename(_path,path);

   914 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   915 						

   916 			r = fs.Delete(path);

   917 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   918 			break;

   919 			}

   920 		case t_notification::EFileRename:

   921 		case t_notification::EFileRename_wild:

   922 		case t_notification::EAllOps5:

   923 			{

   924 			TBuf<45> path;

   925 			path.Append(basepath);

   926 			if (!wildcard)

   927 				{

   928 				path.Append(pkgDoer.iFileName);

   929 				path.Append(pkgDoer.iString);

   930 				}

   931 			path.AppendNum(0);

   932 			

   933 			//Delete new path to ensure it does not exist

   934 			r = fs.Delete(path);

   935 			if(r != KErrNone && r != KErrNotFound && r != KErrPathNotFound)

   936 				safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   937 			

   938 			if (wildcard)

   939 				{

   940 				_path.Delete(_path.Length()-1,1);

   941 				_path.AppendNum(9);

   942 				}

   943 			

   944 			RFile file;

   945 			r = file.Replace(fs, _path, EFileWrite);

   946 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   947 

   948 			if (wildcard)

   949 				{

   950 				for(TInt i = 1; i <= pkgDoer.iIterations; i++)

   951 					{

   952 					path.Delete(path.Length()-1,1);

   953 					path.AppendNum(i);

   954 					multipleTestDoer.Printf(_L("File Rename - %S (%d)\n"),&path,threadID);

   955 					r = file.Rename(path);

   956 					safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   957 					}

   958 				}

   959 			else

   960 				{

   961 				multipleTestDoer.Printf(_L("File Rename - (%d)\n"),threadID);

   962 				r = file.Rename(path);

   963 				safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   964 				}

   965 			

   966 			file.Close();

   967 			r = fs.Delete(path);

   968 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   969 			break;

   970 			}

   971 		case t_notification::EFsRename_dir:

   972 			{

   973 			r = fs.MkDirAll(_path);

   974 			if(r != KErrNone && r != KErrAlreadyExists)

   975 				safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   976 			

   977 			TBuf<45> newPath;

   978 			newPath.Copy(_path);

   979 			newPath.Delete(newPath.Length()-1,1);

   980 			newPath.AppendNum(0);

   981 			newPath.Append(KPathDelimiter);

   982 			

   983 			//Delete new path to ensure it does not exist

   984 			r = fs.RmDir(newPath);

   985 			if(r != KErrNone && r != KErrNotFound && r != KErrPathNotFound)

   986 				safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   987 

   988 			multipleTestDoer.Printf(_L("RFs Rename Dir - (%d)\n"),threadID);

   989 			r = fs.Rename(_path,newPath);

   990 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

   991 			break;

   992 			}

   993 		case t_notification::EFsDelete:

   994 			{

   995 			if (wildcard)

   996 				{

   997 				for(TInt i = 0; i < pkgDoer.iIterations; i++)

   998 					{

   999 					//Create/replace file

  1000 					RFile file;

  1001 					TBuf<40> path;

  1002 					path.Append(basepath);

  1003 					r = fs.MkDirAll(path);

  1004 					if(r != KErrNone && r != KErrAlreadyExists)

  1005 						safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1006 					path.AppendNum(i);

  1007 					path.Append(_L(".txt"));

  1008 					r = file.Replace(fs,path,EFileWrite);

  1009 					safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1010 					file.Close();

  1011 					

  1012 					//Delete file

  1013 					multipleTestDoer.Printf(_L("RFs Delete - %S (%d)\n"),&path,threadID);

  1014 					r = fs.Delete(path);

  1015 					safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1016 					

  1017 					//Create file with a different extension which should not produce notifications

  1018 					path.AppendNum(i);

  1019 					r = file.Replace(fs,path,EFileWrite);

  1020 					safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1021 					file.Close();

  1022 					

  1023 					//Delete that file

  1024 					multipleTestDoer.Printf(_L("RFs Delete - %S (%d)\n"),&path,threadID);

  1025 					r = fs.Delete(path);

  1026 					safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1027 					}

  1028 				}

  1029 			else

  1030 				{

  1031 				RFile file;

  1032 				r = file.Replace(fs,_path,EFileWrite); //Make sure file exists

  1033 				safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1034 				file.Close();

  1035 

  1036 				multipleTestDoer.Printf(_L("RFs Delete - (%d)\n"),threadID);

  1037 				r = fs.Delete(_path);

  1038 				safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1039 				}

  1040 			break;

  1041 			}

  1042 		case t_notification::EFileSet:

  1043 			{

  1044 			RFile file;

  1045 			r = file.Replace(fs,_path,EFileWrite);

  1046 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1047 			

  1048 			multipleTestDoer.Printf(_L("File Set - (%d)\n"),threadID);

  1049 			r = file.Set(TTime(0),KEntryAttHidden,KEntryAttReadOnly);

  1050 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1051 			

  1052 			file.Close();

  1053 			break;

  1054 			}

  1055 		case t_notification::EFileSetAtt:

  1056 		case t_notification::EAllOps4:

  1057 			{

  1058 			RFile file;

  1059 			r = file.Replace(fs,_path,EFileWrite);

  1060 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1061 			

  1062 			multipleTestDoer.Printf(_L("File SetAtt - (%d)\n"),threadID);

  1063 			r = file.SetAtt(KEntryAttHidden,KEntryAttReadOnly);

  1064 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1065 			

  1066 			file.Close();

  1067 			r = fs.Delete(_path);

  1068 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1069 			break;

  1070 			}

  1071 		case t_notification::EFileSetAtt_subs:

  1072 			{

  1073 			if (wildcard)

  1074 				{

  1075 				TBuf<40> path;

  1076 				path.Append(basepath);

  1077 				path.Append(_L("SubDir\\"));

  1078 				r = fs.MkDirAll(path);

  1079 				if(r != KErrNone && r != KErrAlreadyExists)

  1080 					safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1081 				

  1082 				//Create/replace files and set their attributes

  1083 				for(TInt i = 0; i < pkgDoer.iIterations; i++)

  1084 					{

  1085 					RFile file;

  1086 					TBuf<40> dirPath;

  1087 					dirPath.Append(path);

  1088 					dirPath.AppendNum(i);

  1089 					dirPath.Append(_L(".ext"));

  1090 					r = file.Replace(fs, dirPath, EFileWrite);

  1091 					safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1092 					

  1093 					multipleTestDoer.Printf(_L("File SetAtt Subs - %d.ext - (%d)\n"),i,threadID);

  1094 					r = file.SetAtt(KEntryAttHidden,KEntryAttReadOnly);

  1095 					safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1096 					

  1097 					file.Close();

  1098 					r = fs.Delete(dirPath);

  1099 					safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1100 					}							

  1101 				}

  1102 			break;

  1103 			}

  1104 		case t_notification::EFsSetEntry:

  1105 			{

  1106 			RFile file;

  1107 			r = file.Replace(fs,_path,EFileWrite);

  1108 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1109 			file.Close();

  1110 

  1111 			multipleTestDoer.Printf(_L("RFs SetEntry - (%d)\n"),threadID);

  1112 			r = fs.SetEntry(_path,TTime(0),KEntryAttHidden,KEntryAttReadOnly);

  1113 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1114 			break;

  1115 			}

  1116 		case t_notification::EDismount:

  1117 			{

  1118 			multipleTestDoer.Printf(_L("DismountFileSystem - (%d)\n"),threadID);

  1119 			r = fs.DismountFileSystem(pkgDoer.iFileName,globalDriveNum);

  1120 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1121 			break;

  1122 			}

  1123 		case t_notification::EMount:

  1124 			{

  1125 			multipleTestDoer.Printf(_L("MountFileSystem - (%d)\n"),threadID);

  1126 			r = fs.MountFileSystem(pkgDoer.iFileName,globalDriveNum);

  1127 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1128 			break;

  1129 			}

  1130 		case t_notification::EMountScan:

  1131 			{

  1132 			multipleTestDoer.Printf(_L("DismountFileSystem - (%d)\n"),threadID);

  1133 			r = fs.DismountFileSystem(pkgDoer.iFileName,globalDriveNum);

  1134 			safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);

  1135 			TBool isMount;