19 #include <f32file.h>

    19 #include <f32file.h>

    20 #include <e32test.h>

    20 #include <e32test.h>

    21 #include <e32svr.h>

    21 #include <e32svr.h>

    22 #include <hal.h>

    22 #include <hal.h>

    23 #include "t_server.h"

    23 #include "t_server.h"

    24 

    27 

    25 const TInt KHeapSize=0x200;

    28 const TInt KHeapSize=0x200;

    26 

    29 

    27 // wait for a bit since NotifyChange handled asynchronously and SetDriveName synchronously

    30 // wait for a bit since NotifyChange handled asynchronously and SetDriveName synchronously

    28 const TInt KNotifyChangeAfter=100000;

    31 const TInt KNotifyChangeAfter=100000;

   137 

   140 

   138 	case ETest4:

   141 	case ETest4:

   139 		{

   142 		{

   140 		TRequestStatus s;

   143 		TRequestStatus s;

   141 		fs.NotifyChange(ENotifyAll,s);

   144 		fs.NotifyChange(ENotifyAll,s);

   143 		gSleepThread.Signal();

   146 		gSleepThread.Signal();

   144 		User::After(100000000);

   147 		User::After(100000000);

   145 		}

   148 		}

   146 		break;

   149 		break;

   147 

   150 

   214 	case ETest9:

   217 	case ETest9:

   215 		{

   218 		{

   216 		TRequestStatus s;

   219 		TRequestStatus s;

   217 		TFileName path=_L("\\F32-TST\\NOTIFY\\");

   220 		TFileName path=_L("\\F32-TST\\NOTIFY\\");

   218 		fs.NotifyChange(ENotifyAll,s,path);

   221 		fs.NotifyChange(ENotifyAll,s,path);

   220 		gSleepThread.Signal();

   223 		gSleepThread.Signal();

   221 		User::After(100000000);

   224 		User::After(100000000);

   222 		}

   225 		}

   223 		break;

   226 		break;

   224 	case ETest10:

   227 	case ETest10:

   291 	r=thread.Create(_L("MyThread"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest1);

   294 	r=thread.Create(_L("MyThread"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest1);

   292 	test_KErrNone(r);

   295 	test_KErrNone(r);

   293 	thread.Logon(thrdStat);

   296 	thread.Logon(thrdStat);

   294 	thread.Resume();

   297 	thread.Resume();

   295 	User::WaitForRequest(thrdStat);

   298 	User::WaitForRequest(thrdStat);

   297 	thread.Close();

   300 	thread.Close();

   298 	User::WaitForRequest(reqStat);

   301 	User::WaitForRequest(reqStat);

   300 

   303 

   301 	RFile file;

   304 	RFile file;

   302 	r=file.Open(TheFs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileRead|EFileWrite|EFileShareExclusive);

   305 	r=file.Open(TheFs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileRead|EFileWrite|EFileShareExclusive);

   303 	test_KErrNone(r);

   306 	test_KErrNone(r);

   304 	file.Write(_L8("Somewhere over the rainbow..."),reqStat);

   307 	file.Write(_L8("Somewhere over the rainbow..."),reqStat);

   305 	User::WaitForRequest(reqStat);

   308 	User::WaitForRequest(reqStat);

   307 	TBuf8<256> buf;

   310 	TBuf8<256> buf;

   308 	file.Read(0, buf,reqStat);

   311 	file.Read(0, buf,reqStat);

   309 	User::WaitForRequest(reqStat);

   312 	User::WaitForRequest(reqStat);

   311 	file.Close();

   314 	file.Close();

   312 

   315 

   313 	r=file.Open(TheFs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileRead|EFileReadAsyncAll|EFileShareExclusive);

   316 	r=file.Open(TheFs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileRead|EFileReadAsyncAll|EFileShareExclusive);

   314 	test_Value(r, r == KErrArgument);

   317 	test_Value(r, r == KErrArgument);

   315 

   318 

   317 	test_Value(r, r == KErrArgument);

   320 	test_Value(r, r == KErrArgument);

   318 

   321 

   319 	r=file.Open(TheFs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileRead|EFileReadAsyncAll|EFileShareAny);

   322 	r=file.Open(TheFs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileRead|EFileReadAsyncAll|EFileShareAny);

   320 	test_KErrNone(r);

   323 	test_KErrNone(r);

   321 	file.Read(0, buf, 100, reqStat);

   324 	file.Read(0, buf, 100, reqStat);

   326 

   329 

   327 	r=file.Open(TheFs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileRead|EFileReadAsyncAll|EFileShareAny);

   330 	r=file.Open(TheFs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileRead|EFileReadAsyncAll|EFileShareAny);

   328 	test_KErrNone(r);

   331 	test_KErrNone(r);

   329 	file.Read(0, buf, 100, reqStat);

   332 	file.Read(0, buf, 100, reqStat);

   331 	file.ReadCancel(reqStat);

   334 	file.ReadCancel(reqStat);

   332 	User::WaitForRequest(reqStat);

   335 	User::WaitForRequest(reqStat);

   334 	file.Close();

   337 	file.Close();

   335 

   338 

   336 	r=file.Open(TheFs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileRead|EFileReadAsyncAll|EFileWrite|EFileShareAny);

   339 	r=file.Open(TheFs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileRead|EFileReadAsyncAll|EFileWrite|EFileShareAny);

   337 	test_KErrNone(r);

   340 	test_KErrNone(r);

   338 	file.Read(0, buf, 100, reqStat);

   341 	file.Read(0, buf, 100, reqStat);

   340 	file.SetSize(100);

   343 	file.SetSize(100);

   341 	User::WaitForRequest(reqStat);

   344 	User::WaitForRequest(reqStat);

   344 	file.Close();

   347 	file.Close();

   345 

   348 

   346 	test.Next(_L("Repeat Test notification of an entry change"));

   349 	test.Next(_L("Repeat Test notification of an entry change"));

   347 	TheFs.NotifyChange(ENotifyEntry,reqStat);

   350 	TheFs.NotifyChange(ENotifyEntry,reqStat);

   348 	thread.Create(_L("MyThread2"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest1);

   351 	thread.Create(_L("MyThread2"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest1);

   349 	thread.Logon(thrdStat);

   352 	thread.Logon(thrdStat);

   350 	thread.Resume();

   353 	thread.Resume();

   351 	User::WaitForRequest(thrdStat);

   354 	User::WaitForRequest(thrdStat);

   353 	thread.Close();

   356 	thread.Close();

   354 	User::WaitForRequest(reqStat);

   357 	User::WaitForRequest(reqStat);

   361 

   359 

   362 	test.Next(_L("Test Notify cancel"));

   360 	test.Next(_L("Test Notify cancel"));

   363 	TheFs.NotifyChange(ENotifyEntry,reqStat);

   361 	TheFs.NotifyChange(ENotifyEntry,reqStat);

   364 	TheFs.NotifyChangeCancel();

   362 	TheFs.NotifyChangeCancel();

   365 	User::WaitForRequest(reqStat);

   363 	User::WaitForRequest(reqStat);

   368 	TheFs.NotifyChange(ENotifyEntry,reqStat);

   366 	TheFs.NotifyChange(ENotifyEntry,reqStat);

   369 	thread.Create(_L("MyThread3"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest1);

   367 	thread.Create(_L("MyThread3"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest1);

   370 	thread.Logon(thrdStat);

   368 	thread.Logon(thrdStat);

   371 	thread.Resume();

   369 	thread.Resume();

   372 	User::WaitForRequest(thrdStat);

   370 	User::WaitForRequest(thrdStat);

   374 	thread.Close();

   372 	thread.Close();

   375 	User::WaitForRequest(reqStat);

   373 	User::WaitForRequest(reqStat);

   377 	}

   375 	}

   378 

   376 

   379 static void Test2()

   377 static void Test2()

   380 //

   378 //

   381 // Test notify for multiple clients

   379 // Test notify for multiple clients

   394 	RFs fs2;

   392 	RFs fs2;

   395 	r=fs2.Connect();

   393 	r=fs2.Connect();

   396 	test_KErrNone(r);

   394 	test_KErrNone(r);

   397 	fs2.NotifyChange(ENotifyEntry,reqStat2);

   395 	fs2.NotifyChange(ENotifyEntry,reqStat2);

   398 

   396 

   401 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\NEWFILE.TXT"));

   399 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\NEWFILE.TXT"));

   402 	test_KErrNone(r);

   400 	test_KErrNone(r);

   403 	User::WaitForRequest(reqStat1);

   401 	User::WaitForRequest(reqStat1);

   404 	User::WaitForRequest(reqStat2);

   402 	User::WaitForRequest(reqStat2);

   407 	}

   405 	}

   408 

   406 

   409 static void Test3()

   407 static void Test3()

   410 //

   408 //

   411 // Test notify cancel

   409 // Test notify cancel

   426 	fs1.NotifyChange(ENotifyAll,status1);

   424 	fs1.NotifyChange(ENotifyAll,status1);

   427 	fs1.NotifyChange(ENotifyAll,status2);

   425 	fs1.NotifyChange(ENotifyAll,status2);

   428 	fs1.NotifyChange(ENotifyAll,status3);

   426 	fs1.NotifyChange(ENotifyAll,status3);

   429 	fs1.NotifyChange(ENotifyAll,status4);

   427 	fs1.NotifyChange(ENotifyAll,status4);

   430 	fs1.NotifyChange(ENotifyAll,status5);

   428 	fs1.NotifyChange(ENotifyAll,status5);

   436 

   434 

   437 	test.Next(_L("RFs::NotifyCancel()"));

   435 	test.Next(_L("RFs::NotifyCancel()"));

   438 //	Test that one call to RFs::NotifyCancel() cancels all outstanding requests

   436 //	Test that one call to RFs::NotifyCancel() cancels all outstanding requests

   439 	fs1.NotifyChangeCancel();

   437 	fs1.NotifyChangeCancel();

   440 	User::WaitForRequest(status1);

   438 	User::WaitForRequest(status1);

   442 	User::WaitForRequest(status2);

   440 	User::WaitForRequest(status2);

   444 	User::WaitForRequest(status3);

   442 	User::WaitForRequest(status3);

   446 	User::WaitForRequest(status4);

   444 	User::WaitForRequest(status4);

   448 	User::WaitForRequest(status5);

   446 	User::WaitForRequest(status5);

   450 //	Call the cancel function again to check no further action

   448 //	Call the cancel function again to check no further action

   451 	fs1.NotifyChangeCancel();

   449 	fs1.NotifyChangeCancel();

   452 

   450 

   453 //	Test overloaded function to cancel a single request

   451 //	Test overloaded function to cancel a single request

   454 	test.Next(_L("Cancel notification request using function overload"));

   452 	test.Next(_L("Cancel notification request using function overload"));

   455 	fs1.NotifyChange(ENotifyAll,status1);

   453 	fs1.NotifyChange(ENotifyAll,status1);

   456 	fs1.NotifyChange(ENotifyAll,status2);

   454 	fs1.NotifyChange(ENotifyAll,status2);

   457 	fs1.NotifyChange(ENotifyAll,status3);

   455 	fs1.NotifyChange(ENotifyAll,status3);

   458 	fs1.NotifyChange(ENotifyAll,status4);

   456 	fs1.NotifyChange(ENotifyAll,status4);

   459 	fs1.NotifyChange(ENotifyAll,status5);

   457 	fs1.NotifyChange(ENotifyAll,status5);

   465 

   463 

   466 //	Cancel the outstanding request with status5

   464 //	Cancel the outstanding request with status5

   467 	test.Next(_L("RFs::NotifyCancel()"));

   465 	test.Next(_L("RFs::NotifyCancel()"));

   468 	fs1.NotifyChangeCancel(status5);

   466 	fs1.NotifyChangeCancel(status5);

   469 	User::WaitForRequest(status5);

   467 	User::WaitForRequest(status5);

   475 

   473 

   476 	fs1.NotifyChangeCancel(status2);

   474 	fs1.NotifyChangeCancel(status2);

   477 	User::WaitForRequest(status2);

   475 	User::WaitForRequest(status2);

   478 

   476 

   483 

   481 

   484 	fs1.NotifyChangeCancel(status4);

   482 	fs1.NotifyChangeCancel(status4);

   485 	User::WaitForRequest(status4);

   483 	User::WaitForRequest(status4);

   492 

   490 

   493 	fs1.NotifyChangeCancel(status1);

   491 	fs1.NotifyChangeCancel(status1);

   494 	User::WaitForRequest(status1);

   492 	User::WaitForRequest(status1);

   497 	fs1.NotifyChangeCancel(status1);	//	Test no side effects on trying to cancel a request

   495 	fs1.NotifyChangeCancel(status1);	//	Test no side effects on trying to cancel a request

   499 

   497 

   500 	fs1.NotifyChangeCancel(status3);

   498 	fs1.NotifyChangeCancel(status3);

   501 	User::WaitForRequest(status3);

   499 	User::WaitForRequest(status3);

   503 

   501 

   504 	fs1.Close();

   502 	fs1.Close();

   505 	}

   503 	}

   506 

   504 

   507 static void Test4()

   505 static void Test4()

   558 	test_KErrNone(r);

   556 	test_KErrNone(r);

   559 	file.Close();

   557 	file.Close();

   560 

   558 

   561 	TRequestStatus reqStat=0;

   559 	TRequestStatus reqStat=0;

   562 	TheFs.NotifyChange(ENotifyEntry,reqStat);

   560 	TheFs.NotifyChange(ENotifyEntry,reqStat);

   564 

   562 

   565 	r=gSleepThread.CreateLocal(0);

   563 	r=gSleepThread.CreateLocal(0);

   566 	test_KErrNone(r);

   564 	test_KErrNone(r);

   567 	RThread clientThread;

   565 	RThread clientThread;

   568 	r=clientThread.Create(_L("Test5Thread"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest5);

   566 	r=clientThread.Create(_L("Test5Thread"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest5);

   569 	test_KErrNone(r);

   567 	test_KErrNone(r);

   570 	clientThread.Resume();

   568 	clientThread.Resume();

   571 	gSleepThread.Wait();

   569 	gSleepThread.Wait();

   573 

   571 

   574 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\kangaroo.txt"));

   572 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\kangaroo.txt"));

   575 	test_KErrNone(r);

   573 	test_KErrNone(r);

   576 	User::WaitForRequest(reqStat);

   574 	User::WaitForRequest(reqStat);

   578 

   576 

   579 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\koala.txt"));

   577 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\koala.txt"));

   580 	test_KErrNone(r);

   578 	test_KErrNone(r);

   581 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\dingo.txt"));

   579 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\dingo.txt"));

   582 	test_KErrNone(r);

   580 	test_KErrNone(r);

   603         b.Format(_L("Test Media change notification (socket:%d)"),gSocketNumber);

   601         b.Format(_L("Test Media change notification (socket:%d)"),gSocketNumber);

   604         test.Next(b);

   602         test.Next(b);

   605         TRequestStatus reqStat=0;

   603         TRequestStatus reqStat=0;

   606         TInt r;

   604         TInt r;

   607         TheFs.NotifyChange(ENotifyEntry,reqStat);

   605         TheFs.NotifyChange(ENotifyEntry,reqStat);

   609         r=gSleepThread.CreateLocal(0);

   607         r=gSleepThread.CreateLocal(0);

   610         test_KErrNone(r);

   608         test_KErrNone(r);

   611         RThread clientThread;

   609         RThread clientThread;

   612         r=clientThread.Create(_L("Test6Thread"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest6);

   610         r=clientThread.Create(_L("Test6Thread"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest6);

   613         test_KErrNone(r);

   611         test_KErrNone(r);

   614         clientThread.Resume();

   612         clientThread.Resume();

   615         gSleepThread.Wait();

   613         gSleepThread.Wait();

   616         TInt reqInt=reqStat.Int();

   614         TInt reqInt=reqStat.Int();

   618         User::WaitForRequest(reqStat);

   616         User::WaitForRequest(reqStat);

   619         WaitForMediaChange();

   617         WaitForMediaChange();

   620         gSleepThread.Close();

   618         gSleepThread.Close();

   621         clientThread.Close();

   619         clientThread.Close();

   622         }

   620         }

   639 	test.Next(_L("Test Write to uid region does not trigger notification"));

   637 	test.Next(_L("Test Write to uid region does not trigger notification"));

   640 	TRequestStatus reqStat=0;

   638 	TRequestStatus reqStat=0;

   641 	MakeFile(_L("NewFile.TXT"));

   639 	MakeFile(_L("NewFile.TXT"));

   642 	TInt r;

   640 	TInt r;

   643 	TheFs.NotifyChange(ENotifyEntry,reqStat);

   641 	TheFs.NotifyChange(ENotifyEntry,reqStat);

   645 

   643 

   646 	r=gSleepThread.CreateLocal(0);

   644 	r=gSleepThread.CreateLocal(0);

   647 	test_KErrNone(r);

   645 	test_KErrNone(r);

   648 	RThread clientThread;

   646 	RThread clientThread;

   649 	r=clientThread.Create(_L("Test7Thread"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest7);

   647 	r=clientThread.Create(_L("Test7Thread"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest7);

   650 	test_KErrNone(r);

   648 	test_KErrNone(r);

   651 	clientThread.Resume();

   649 	clientThread.Resume();

   652 	gSleepThread.Wait();

   650 	gSleepThread.Wait();

   654 

   652 

   655 	r=TheFs.Delete(_L("Newfile.txt"));

   653 	r=TheFs.Delete(_L("Newfile.txt"));

   656 	test_KErrNone(r);

   654 	test_KErrNone(r);

   657 

   655 

   658 	User::WaitForRequest(reqStat);

   656 	User::WaitForRequest(reqStat);

   677 		test.Next(_L("Test Media change extended notification"));

   675 		test.Next(_L("Test Media change extended notification"));

   678 		TRequestStatus reqStat=0;

   676 		TRequestStatus reqStat=0;

   679 		TFileName path = _L("\\F32-tst\\NOTIFY\\");

   677 		TFileName path = _L("\\F32-tst\\NOTIFY\\");

   680 		TInt r;

   678 		TInt r;

   681 		TheFs.NotifyChange(ENotifyEntry,reqStat,path);

   679 		TheFs.NotifyChange(ENotifyEntry,reqStat,path);

   683 		r=gSleepThread.CreateLocal(0);

   681 		r=gSleepThread.CreateLocal(0);

   684 		test_KErrNone(r);

   682 		test_KErrNone(r);

   685 		RThread clientThread;

   683 		RThread clientThread;

   686 		gSocketNumber=0;

   684 		gSocketNumber=0;

   687 		r=clientThread.Create(_L("Test6Thread1"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest6);	//only generates a media change on removable media

   685 		r=clientThread.Create(_L("Test6Thread1"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest6);	//only generates a media change on removable media

   688 		test_KErrNone(r);

   686 		test_KErrNone(r);

   689 		clientThread.Resume();

   687 		clientThread.Resume();

   690 		gSleepThread.Wait();

   688 		gSleepThread.Wait();

   691 		User::WaitForRequest(reqStat);

   689 		User::WaitForRequest(reqStat);

   693 		WaitForMediaChange();

   691 		WaitForMediaChange();

   694 		gSleepThread.Close();

   692 		gSleepThread.Close();

   695 		clientThread.Close();

   693 		clientThread.Close();

   696 

   694 

   697         //-- it seems that after generating media change the meia driver isn't ready for some time

   695         //-- it seems that after generating media change the meia driver isn't ready for some time

   699 	    r=TheFs.Drive(driveInfo,CurrentDrive());

   697 	    r=TheFs.Drive(driveInfo,CurrentDrive());

   700 	    test_KErrNone(r);

   698 	    test_KErrNone(r);

   701 

   699 

   702 

   700 

   703 		TheFs.NotifyChange(ENotifyDisk,reqStat,path);

   701 		TheFs.NotifyChange(ENotifyDisk,reqStat,path);

   705 		r=gSleepThread.CreateLocal(0);

   703 		r=gSleepThread.CreateLocal(0);

   706 		test_KErrNone(r);

   704 		test_KErrNone(r);

   707 		r=clientThread.Create(_L("Test6Thread2"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest6);

   705 		r=clientThread.Create(_L("Test6Thread2"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest6);

   708 		test_KErrNone(r);

   706 		test_KErrNone(r);

   709 		clientThread.Resume();

   707 		clientThread.Resume();

   710 		gSleepThread.Wait();

   708 		gSleepThread.Wait();

   711 		User::WaitForRequest(reqStat);

   709 		User::WaitForRequest(reqStat);

   713 		WaitForMediaChange();

   711 		WaitForMediaChange();

   714 		gSleepThread.Close();

   712 		gSleepThread.Close();

   715 		clientThread.Close();

   713 		clientThread.Close();

   716 

   714 

   717         //-- it seems that after generating media change the meia driver isn't ready for some time

   715         //-- it seems that after generating media change the meia driver isn't ready for some time

   718         User::After(2000000);

   716         User::After(2000000);

   719 	    r=TheFs.Drive(driveInfo,CurrentDrive());

   717 	    r=TheFs.Drive(driveInfo,CurrentDrive());

   720 	    test_KErrNone(r);

   718 	    test_KErrNone(r);

   721 

   719 

   722 		TheFs.NotifyChange(ENotifyWrite,reqStat,path);

   720 		TheFs.NotifyChange(ENotifyWrite,reqStat,path);

   724 		r=gSleepThread.CreateLocal(0);

   722 		r=gSleepThread.CreateLocal(0);

   725 		test_KErrNone(r);

   723 		test_KErrNone(r);

   726 		r=clientThread.Create(_L("Test6Thread3"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest6);

   724 		r=clientThread.Create(_L("Test6Thread3"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest6);

   727 		test_KErrNone(r);

   725 		test_KErrNone(r);

   728 		clientThread.Resume();

   726 		clientThread.Resume();

   729 		gSleepThread.Wait();

   727 		gSleepThread.Wait();

   730 		User::WaitForRequest(reqStat);

   728 		User::WaitForRequest(reqStat);

   732 		WaitForMediaChange();

   730 		WaitForMediaChange();

   733 		gSleepThread.Close();

   731 		gSleepThread.Close();

   734 		clientThread.Close();

   732 		clientThread.Close();

   735 

   733 

   736         //-- it seems that after generating media change the meia driver isn't ready for some time

   734         //-- it seems that after generating media change the meia driver isn't ready for some time

   754 	test_Value(r, (r == KErrNotFound)||(r==KErrPathNotFound)||(r==KErrNone));

   752 	test_Value(r, (r == KErrNotFound)||(r==KErrPathNotFound)||(r==KErrNone));

   755 

   753 

   756 	TFileName path=_L("\\F32-TST\\NOTIFY\\BehindTheCurtain\\");

   754 	TFileName path=_L("\\F32-TST\\NOTIFY\\BehindTheCurtain\\");

   757 	TRequestStatus reqStat(KRequestPending);

   755 	TRequestStatus reqStat(KRequestPending);

   758 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

   756 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

   760 

   758 

   761 	r=TheFs.MkDir(_L("\\F32-TST\\NOTIFY\\BehindTheCurtain\\"));

   759 	r=TheFs.MkDir(_L("\\F32-TST\\NOTIFY\\BehindTheCurtain\\"));

   762 	test_KErrNone(r);

   760 	test_KErrNone(r);

   763 

   761 

   764 	User::WaitForRequest(reqStat);

   762 	User::WaitForRequest(reqStat);

   766 

   764 

   767 	path=_L("\\F32-TST\\NOTIFY\\BehindTheCurtain\\PayNoAttention.man");

   765 	path=_L("\\F32-TST\\NOTIFY\\BehindTheCurtain\\PayNoAttention.man");

   768 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

   766 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

   770 

   768 

   771 	RFile file;

   769 	RFile file;

   772 	r=file.Replace(TheFs,path,EFileStream);

   770 	r=file.Replace(TheFs,path,EFileStream);

   773 	test_KErrNone(r);

   771 	test_KErrNone(r);

   774 	file.Close();

   772 	file.Close();

   775 

   773 

   776 	User::WaitForRequest(reqStat);

   774 	User::WaitForRequest(reqStat);

   778 

   776 

   779 	r=TheFs.Delete(path);

   777 	r=TheFs.Delete(path);

   780 	test_KErrNone(r);

   778 	test_KErrNone(r);

   781 

   779 

   782 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

   780 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

   784 //	Now cancel the outstanding request

   782 //	Now cancel the outstanding request

   785 	TheFs.NotifyChangeCancel(reqStat);

   783 	TheFs.NotifyChangeCancel(reqStat);

   786 	User::WaitForRequest(reqStat);

   784 	User::WaitForRequest(reqStat);

   788 

   786 

   789 //	Repeat with a ENotifyFile request

   787 //	Repeat with a ENotifyFile request

   790 	TheFs.NotifyChange(ENotifyFile,reqStat,path);

   788 	TheFs.NotifyChange(ENotifyFile,reqStat,path);

   792 

   790 

   793 	r=file.Replace(TheFs,path,EFileStream);

   791 	r=file.Replace(TheFs,path,EFileStream);

   794 	test_KErrNone(r);

   792 	test_KErrNone(r);

   795 	file.Close();

   793 	file.Close();

   796 

   794 

   797 	User::WaitForRequest(reqStat);

   795 	User::WaitForRequest(reqStat);

   799 

   797 

   800 	r=TheFs.Delete(path);

   798 	r=TheFs.Delete(path);

   801 	test_KErrNone(r);

   799 	test_KErrNone(r);

   802 

   800 

   803 	TheFs.NotifyChange(ENotifyFile,reqStat,path);

   801 	TheFs.NotifyChange(ENotifyFile,reqStat,path);

   805 //	Now cancel the outstanding request

   803 //	Now cancel the outstanding request

   806 	TheFs.NotifyChangeCancel(reqStat);

   804 	TheFs.NotifyChangeCancel(reqStat);

   807 	User::WaitForRequest(reqStat);

   805 	User::WaitForRequest(reqStat);

   809 

   807 

   810 //	Repeat with an ENotifyAttributes request

   808 //	Repeat with an ENotifyAttributes request

   811 	TheFs.NotifyChange(ENotifyAttributes,reqStat,path);

   809 	TheFs.NotifyChange(ENotifyAttributes,reqStat,path);

   813 

   811 

   814 	r=file.Replace(TheFs,path,EFileStream);

   812 	r=file.Replace(TheFs,path,EFileStream);

   815 	test_KErrNone(r);

   813 	test_KErrNone(r);

   816 	file.Close();

   814 	file.Close();

   817 

   815 

   818 	User::WaitForRequest(reqStat);

   816 	User::WaitForRequest(reqStat);

   820 

   818 

   821 	r=TheFs.Delete(path);

   819 	r=TheFs.Delete(path);

   822 	test_KErrNone(r);

   820 	test_KErrNone(r);

   823 

   821 

   824 	TheFs.NotifyChange(ENotifyAttributes,reqStat,path);

   822 	TheFs.NotifyChange(ENotifyAttributes,reqStat,path);

   826 //	Now cancel the outstanding request

   824 //	Now cancel the outstanding request

   827 	TheFs.NotifyChangeCancel(reqStat);

   825 	TheFs.NotifyChangeCancel(reqStat);

   828 	User::WaitForRequest(reqStat);

   826 	User::WaitForRequest(reqStat);

   830 

   828 

   831 //	Repeat with an ENotifyWrite request

   829 //	Repeat with an ENotifyWrite request

   832 	TheFs.NotifyChange(ENotifyWrite,reqStat,path);

   830 	TheFs.NotifyChange(ENotifyWrite,reqStat,path);

   834 

   832 

   835 	r=file.Replace(TheFs,path,EFileStream);

   833 	r=file.Replace(TheFs,path,EFileStream);

   836 	test_KErrNone(r);

   834 	test_KErrNone(r);

   837 	file.Close();

   835 	file.Close();

   838 

   836 

   839 	User::WaitForRequest(reqStat);

   837 	User::WaitForRequest(reqStat);

   841 

   839 

   842 	r=TheFs.Delete(path);

   840 	r=TheFs.Delete(path);

   843 	test_KErrNone(r);

   841 	test_KErrNone(r);

   844 

   842 

   845 	TheFs.NotifyChange(ENotifyWrite,reqStat,path);

   843 	TheFs.NotifyChange(ENotifyWrite,reqStat,path);

   847 //	Now cancel the outstanding request

   845 //	Now cancel the outstanding request

   848 	TheFs.NotifyChangeCancel(reqStat);

   846 	TheFs.NotifyChangeCancel(reqStat);

   849 	User::WaitForRequest(reqStat);

   847 	User::WaitForRequest(reqStat);

   851 

   849 

   852 //	Repeat with an ENotifyDisk request

   850 //	Repeat with an ENotifyDisk request

   853 	TheFs.NotifyChange(ENotifyDisk,reqStat,path);

   851 	TheFs.NotifyChange(ENotifyDisk,reqStat,path);

   855 

   853 

   856 	r=file.Replace(TheFs,path,EFileStream);

   854 	r=file.Replace(TheFs,path,EFileStream);

   857 	test_KErrNone(r);

   855 	test_KErrNone(r);

   858 	file.Close();

   856 	file.Close();

   859 

   857 

   860 	User::WaitForRequest(reqStat);

   858 	User::WaitForRequest(reqStat);

   862 

   860 

   863 	r=TheFs.Delete(path);

   861 	r=TheFs.Delete(path);

   864 	test_KErrNone(r);

   862 	test_KErrNone(r);

   865 

   863 

   866 	TheFs.NotifyChange(ENotifyAttributes,reqStat,path);

   864 	TheFs.NotifyChange(ENotifyAttributes,reqStat,path);

   868 //	Now cancel the outstanding request

   866 //	Now cancel the outstanding request

   869 	TheFs.NotifyChangeCancel(reqStat);

   867 	TheFs.NotifyChangeCancel(reqStat);

   870 	User::WaitForRequest(reqStat);

   868 	User::WaitForRequest(reqStat);

   872 

   870 

   873 //	Now do much the same with directory monitoring

   871 //	Now do much the same with directory monitoring

   874 	path=_L("\\F32-TST\\NOTIFY\\BehindTheCurtain\\");

   872 	path=_L("\\F32-TST\\NOTIFY\\BehindTheCurtain\\");

   875 	TheFs.RmDir(path);

   873 	TheFs.RmDir(path);

   876 

   874 

   877 	TheFs.NotifyChange(ENotifyDir,reqStat,path);

   875 	TheFs.NotifyChange(ENotifyDir,reqStat,path);

   879 

   877 

   880 	TheFs.MkDir(path);

   878 	TheFs.MkDir(path);

   881 	test_KErrNone(r);

   879 	test_KErrNone(r);

   882 

   880 

   883 	User::WaitForRequest(reqStat);

   881 	User::WaitForRequest(reqStat);

   885 

   883 

   886 	TheFs.RmDir(path);

   884 	TheFs.RmDir(path);

   887 	test_KErrNone(r);

   885 	test_KErrNone(r);

   888 

   886 

   889 	TheFs.NotifyChange(ENotifyDir,reqStat,path);

   887 	TheFs.NotifyChange(ENotifyDir,reqStat,path);

   890 	test_KErrNone(r);

   888 	test_KErrNone(r);

   892 

   890 

   893 //	Now cancel the outstanding request

   891 //	Now cancel the outstanding request

   894 	TheFs.NotifyChangeCancel(reqStat);

   892 	TheFs.NotifyChangeCancel(reqStat);

   895 	User::WaitForRequest(reqStat);

   893 	User::WaitForRequest(reqStat);

   897 

   895 

   898 	TheFs.NotifyChange(ENotifyDir,reqStat,path);

   896 	TheFs.NotifyChange(ENotifyDir,reqStat,path);

   899 	test_KErrNone(r);

   897 	test_KErrNone(r);

   901 

   899 

   902 //	Get a separate thread to create the directory

   900 //	Get a separate thread to create the directory

   903 	RThread thread;

   901 	RThread thread;

   904 	thread.Create(_L("RequestAheadyThready"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest10);

   902 	thread.Create(_L("RequestAheadyThready"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest10);

   905 	TRequestStatus thrdStat(KRequestPending);

   903 	TRequestStatus thrdStat(KRequestPending);

   906 	thread.Logon(thrdStat);

   904 	thread.Logon(thrdStat);

   907 	thread.Resume();

   905 	thread.Resume();

   908 	thread.Close();

   906 	thread.Close();

   909 

   907 

   910 	User::WaitForRequest(thrdStat);

   908 	User::WaitForRequest(thrdStat);

   914 

   912 

   915 	TheFs.RmDir(path);

   913 	TheFs.RmDir(path);

   916 	test_KErrNone(r);

   914 	test_KErrNone(r);

   917 

   915 

   918 //	Check that notification is not received for a non-existent file if only the previously

   916 //	Check that notification is not received for a non-existent file if only the previously

   919 //	non existent directory that contains it is created

   917 //	non existent directory that contains it is created

   920 	path=_L("\\F32-TST\\NOTIFY\\BehindTheCurtain\\PayNoAttention.man");

   918 	path=_L("\\F32-TST\\NOTIFY\\BehindTheCurtain\\PayNoAttention.man");

   921 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

   919 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

   922 	test_KErrNone(r);

   920 	test_KErrNone(r);

   924 

   922 

   925 	thread.Create(_L("RequestAheadThread"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest10);

   923 	thread.Create(_L("RequestAheadThread"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest10);

   926 	thread.Logon(thrdStat);

   924 	thread.Logon(thrdStat);

   927 	thread.Resume();

   925 	thread.Resume();

   928 	thread.Close();

   926 	thread.Close();

   929 

   927 

   930 	User::WaitForRequest(thrdStat);

   928 	User::WaitForRequest(thrdStat);

   933 

   931 

   934 //	Now get a thread to create the file

   932 //	Now get a thread to create the file

   935 	thread.Create(_L("RequestAhead"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest11);

   933 	thread.Create(_L("RequestAhead"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest11);

   936 	thread.Logon(thrdStat);

   934 	thread.Logon(thrdStat);

   937 	thread.Resume();

   935 	thread.Resume();

   938 	User::WaitForRequest(thrdStat);

   936 	User::WaitForRequest(thrdStat);

   940 	thread.Close();

   938 	thread.Close();

   941 

   939 

   942 	User::WaitForRequest(reqStat);

   940 	User::WaitForRequest(reqStat);

   944 

   942 

   945 	TheFs.Delete(path);

   943 	TheFs.Delete(path);

   946 	test_KErrNone(r);

   944 	test_KErrNone(r);

   947 

   945 

   948 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

   946 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

   949 	test_KErrNone(r);

   947 	test_KErrNone(r);

   951 

   949 

   952 //	Now cancel the outstanding request

   950 //	Now cancel the outstanding request

   953 	TheFs.NotifyChangeCancel(reqStat);

   951 	TheFs.NotifyChangeCancel(reqStat);

   954 	User::WaitForRequest(reqStat);

   952 	User::WaitForRequest(reqStat);

   956 

   954 

   957 	path=_L("\\F32-TST\\NOTIFY\\BehindTheCurtain\\");

   955 	path=_L("\\F32-TST\\NOTIFY\\BehindTheCurtain\\");

   958 	TheFs.RmDir(path);

   956 	TheFs.RmDir(path);

   959 	test_KErrNone(r);

   957 	test_KErrNone(r);

   960 	}

   958 	}

   970 	TRequestStatus reqStat(KRequestPending);

   968 	TRequestStatus reqStat(KRequestPending);

   971 	TRequestStatus thrdStat(KRequestPending);

   969 	TRequestStatus thrdStat(KRequestPending);

   972 	TFileName path=(_L("\\F32-TST\\"));

   970 	TFileName path=(_L("\\F32-TST\\"));

   973 

   971 

   974 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

   972 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

   976 	RThread thread;

   974 	RThread thread;

   977 	TInt r=thread.Create(_L("MyThread"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest1);

   975 	TInt r=thread.Create(_L("MyThread"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest1);

   978 	test_KErrNone(r);

   976 	test_KErrNone(r);

   979 	thread.Logon(thrdStat);

   977 	thread.Logon(thrdStat);

   980 	thread.Resume();

   978 	thread.Resume();

   981 	User::WaitForRequest(thrdStat);

   979 	User::WaitForRequest(thrdStat);

   985 	thread.Close();

   983 	thread.Close();

   986 

   984 

   987 //	Repeat the test

   985 //	Repeat the test

   988 	test.Next(_L("Repeat Test notification of an entry change"));

   986 	test.Next(_L("Repeat Test notification of an entry change"));

   989 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

   987 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

   991 	r=thread.Create(_L("MyThread2"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest1);

   989 	r=thread.Create(_L("MyThread2"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest1);

   992 	test_KErrNone(r);

   990 	test_KErrNone(r);

   993 	thread.Logon(thrdStat);

   991 	thread.Logon(thrdStat);

   994 	thread.Resume();

   992 	thread.Resume();

   995 	User::WaitForRequest(thrdStat);

   993 	User::WaitForRequest(thrdStat);

   999 	thread.Close();

   997 	thread.Close();

  1000 

   998 

  1001 //	Test it can be cancelled

   999 //	Test it can be cancelled

  1002 	test.Next(_L("Test Notify cancel"));

  1000 	test.Next(_L("Test Notify cancel"));

  1003 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1001 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1005 	TheFs.NotifyChangeCancel();

  1003 	TheFs.NotifyChangeCancel();

  1006 	User::WaitForRequest(reqStat);

  1004 	User::WaitForRequest(reqStat);

  1008 

  1006 

  1009 //	Test it can be notified again

  1007 //	Test it can be notified again

  1010 	test.Next(_L("Test notification still works"));

  1008 	test.Next(_L("Test notification still works"));

  1011 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1009 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1013 	r=thread.Create(_L("MyThread3"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest1);

  1011 	r=thread.Create(_L("MyThread3"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest1);

  1014 	test_KErrNone(r);

  1012 	test_KErrNone(r);

  1015 	thread.Logon(thrdStat);

  1013 	thread.Logon(thrdStat);

  1016 	thread.Resume();

  1014 	thread.Resume();

  1017 	User::WaitForRequest(thrdStat);

  1015 	User::WaitForRequest(thrdStat);

  1021 	thread.Close();

  1019 	thread.Close();

  1022 

  1020 

  1023 //	Test notification doesn't occur when a change occurs above the directory monitored

  1021 //	Test notification doesn't occur when a change occurs above the directory monitored

  1024 //	(Notification of rename events occurring above the directory which affect the path

  1022 //	(Notification of rename events occurring above the directory which affect the path

  1025 //	will occur - this is tested for in Test18())

  1023 //	will occur - this is tested for in Test18())

  1026 	test.Next(_L("Test changing above monitored directory"));

  1024 	test.Next(_L("Test changing above monitored directory"));

  1027 	r=TheFs.MkDir(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\"));

  1025 	r=TheFs.MkDir(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\"));

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

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

  1029 	path=_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\");

  1027 	path=_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\");

  1030 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1028 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1032 	r=thread.Create(_L("MyThread4"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest1);

  1030 	r=thread.Create(_L("MyThread4"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest1);

  1033 	test_KErrNone(r);

  1031 	test_KErrNone(r);

  1034 	thread.Logon(thrdStat);

  1032 	thread.Logon(thrdStat);

  1035 	thread.Resume();

  1033 	thread.Resume();

  1036 	User::WaitForRequest(thrdStat);

  1034 	User::WaitForRequest(thrdStat);

  1038 	User::After(500000);

  1036 	User::After(500000);

  1039 	thread.Close();

  1037 	thread.Close();

  1041 	TheFs.NotifyChangeCancel();

  1039 	TheFs.NotifyChangeCancel();

  1042 	User::WaitForRequest(reqStat);

  1040 	User::WaitForRequest(reqStat);

  1044 

  1042 

  1045 //	Test notification occurs when a change is made to the subdirectory monitored

  1043 //	Test notification occurs when a change is made to the subdirectory monitored

  1046 	test.Next(_L("Create a file in monitored subdirectory"));

  1044 	test.Next(_L("Create a file in monitored subdirectory"));

  1047 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1045 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1049 	r=thread.Create(_L("MyThread5"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest2);

  1047 	r=thread.Create(_L("MyThread5"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest2);

  1050 	test_KErrNone(r);

  1048 	test_KErrNone(r);

  1051 	thread.Logon(thrdStat);

  1049 	thread.Logon(thrdStat);

  1052 	thread.Resume();

  1050 	thread.Resume();

  1053 	User::WaitForRequest(thrdStat);

  1051 	User::WaitForRequest(thrdStat);

  1057 	thread.Close();

  1055 	thread.Close();

  1058 

  1056 

  1059 	test.Next(_L("Create a directory in monitored subdirectory"));

  1057 	test.Next(_L("Create a directory in monitored subdirectory"));

  1060 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1058 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1062 	r=thread.Create(_L("MyThread6"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest3);

  1060 	r=thread.Create(_L("MyThread6"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest3);

  1063 	test_KErrNone(r);

  1061 	test_KErrNone(r);

  1064 	thread.Logon(thrdStat);

  1062 	thread.Logon(thrdStat);

  1065 	thread.Resume();

  1063 	thread.Resume();

  1066 	User::WaitForRequest(thrdStat);

  1064 	User::WaitForRequest(thrdStat);

  1070 	thread.Close();

  1068 	thread.Close();

  1071 

  1069 

  1072 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1070 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1074 	r=TheFs.MkDir(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\SCARECROW\\TINMAN\\"));

  1072 	r=TheFs.MkDir(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\SCARECROW\\TINMAN\\"));

  1075 	test_KErrNone(r);

  1073 	test_KErrNone(r);

  1076 	User::WaitForRequest(reqStat);

  1074 	User::WaitForRequest(reqStat);

  1078 

  1076 

  1079 

  1077 

  1080 	r=TheFs.RmDir(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\SCARECROW\\TINMAN\\"));

  1078 	r=TheFs.RmDir(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\SCARECROW\\TINMAN\\"));

  1081 	test_KErrNone(r);

  1079 	test_KErrNone(r);

  1082 	r=TheFs.RmDir(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\SCARECROW\\"));

  1080 	r=TheFs.RmDir(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\SCARECROW\\"));

  1087 	r=TheFs.MkDir(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\"));

  1085 	r=TheFs.MkDir(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\"));

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

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

  1089 	path=_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\");

  1087 	path=_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\");

  1090 

  1088 

  1091 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1089 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1093 	r=thread.Create(_L("MyThread7"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest1);

  1091 	r=thread.Create(_L("MyThread7"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest1);

  1094 	test_KErrNone(r);

  1092 	test_KErrNone(r);

  1095 	thread.Logon(thrdStat);

  1093 	thread.Logon(thrdStat);

  1096 	thread.Resume();

  1094 	thread.Resume();

  1097 	User::WaitForRequest(thrdStat);

  1095 	User::WaitForRequest(thrdStat);

  1099 	User::After(500000);

  1097 	User::After(500000);

  1100 	thread.Close();

  1098 	thread.Close();

  1102 	TheFs.NotifyChangeCancel();

  1100 	TheFs.NotifyChangeCancel();

  1103 	User::WaitForRequest(reqStat);

  1101 	User::WaitForRequest(reqStat);

  1105 

  1103 

  1106 //	Test notification occurs when a change is made to the subdirectory monitored

  1104 //	Test notification occurs when a change is made to the subdirectory monitored

  1107 	test.Next(_L("Delete a file in monitored subdirectory"));

  1105 	test.Next(_L("Delete a file in monitored subdirectory"));

  1108 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1106 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1110 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\Dorothy.doc"));

  1108 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\Dorothy.doc"));

  1111 	test_KErrNone(r);

  1109 	test_KErrNone(r);

  1112 	User::WaitForRequest(reqStat);

  1110 	User::WaitForRequest(reqStat);

  1114 

  1112 

  1115 	RFile file;

  1113 	RFile file;

  1116 	r=file.Replace(TheFs,_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\WickedWitch.msg"),EFileStream);

  1114 	r=file.Replace(TheFs,_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\WickedWitch.msg"),EFileStream);

  1117 	test_KErrNone(r);

  1115 	test_KErrNone(r);

  1118 	file.Close();

  1116 	file.Close();

  1119 

  1117 

  1120 //	Test notification on a specific file

  1118 //	Test notification on a specific file

  1121 	test.Next(_L("Monitor changes to a specific file"));

  1119 	test.Next(_L("Monitor changes to a specific file"));

  1122 	path+=_L("WickedWitch.msg");

  1120 	path+=_L("WickedWitch.msg");

  1123 	TheFs.NotifyChange(ENotifyAll,reqStat,path);

  1121 	TheFs.NotifyChange(ENotifyAll,reqStat,path);

  1125 	r=thread.Create(_L("MyThread8"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest8);

  1123 	r=thread.Create(_L("MyThread8"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest8);

  1126 	test_KErrNone(r);

  1124 	test_KErrNone(r);

  1127 	thread.Logon(thrdStat);

  1125 	thread.Logon(thrdStat);

  1128 	thread.Resume();

  1126 	thread.Resume();

  1129 	User::WaitForRequest(thrdStat);

  1127 	User::WaitForRequest(thrdStat);

  1133 	thread.Close();

  1131 	thread.Close();

  1134 

  1132 

  1135 //	Test notification does not occur if a change is made above the file

  1133 //	Test notification does not occur if a change is made above the file

  1136 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1134 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1138 	thread.Create(_L("MyThread9"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest2);

  1136 	thread.Create(_L("MyThread9"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest2);

  1139 	thread.Logon(thrdStat);

  1137 	thread.Logon(thrdStat);

  1140 	thread.Resume();

  1138 	thread.Resume();

  1141 	User::WaitForRequest(thrdStat);

  1139 	User::WaitForRequest(thrdStat);

  1143 	User::After(500000);

  1141 	User::After(500000);

  1144 	thread.Close();

  1142 	thread.Close();

  1146 	TheFs.NotifyChangeCancel();

  1144 	TheFs.NotifyChangeCancel();

  1147 	User::WaitForRequest(reqStat);

  1145 	User::WaitForRequest(reqStat);

  1149 

  1147 

  1150 //	Test notification occurs when a change is made to the file

  1148 //	Test notification occurs when a change is made to the file

  1151 	test.Next(_L("Delete monitored file"));

  1149 	test.Next(_L("Delete monitored file"));

  1152 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1150 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1154 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\WickedWitch.Msg"));

  1152 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\WickedWitch.Msg"));

  1155 	test_KErrNone(r);

  1153 	test_KErrNone(r);

  1156 	User::WaitForRequest(reqStat);

  1154 	User::WaitForRequest(reqStat);

  1158 

  1156 

  1159 //	Test notification request is now submitted on the non existent path successfully

  1157 //	Test notification request is now submitted on the non existent path successfully

  1160 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1158 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1162 	TheFs.NotifyChangeCancel(reqStat);

  1160 	TheFs.NotifyChangeCancel(reqStat);

  1163 	User::WaitForRequest(reqStat);

  1161 	User::WaitForRequest(reqStat);

  1165 

  1163 

  1166 	path=_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\Dorothy.Doc");

  1164 	path=_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\Dorothy.Doc");

  1167 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1165 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1169 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\Dorothy.Doc"));

  1167 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\Dorothy.Doc"));

  1170 	test_KErrNone(r);

  1168 	test_KErrNone(r);

  1171 	User::WaitForRequest(reqStat);

  1169 	User::WaitForRequest(reqStat);

  1173 

  1171 

  1174 	path=_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\");

  1172 	path=_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\");

  1175 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1173 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1177 	r=TheFs.RmDir(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\"));

  1175 	r=TheFs.RmDir(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\"));

  1178 	test_KErrNone(r);

  1176 	test_KErrNone(r);

  1179 	User::WaitForRequest(reqStat);

  1177 	User::WaitForRequest(reqStat);

  1181 

  1179 

  1182 //	Submit a request for a path which does not yet exist

  1180 //	Submit a request for a path which does not yet exist

  1183 	path=_L("\\F32-TST\\NOTIFY\\GOOD_WITCH\\");

  1181 	path=_L("\\F32-TST\\NOTIFY\\GOOD_WITCH\\");

  1184 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1182 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1186 //	Now create the directory we are waiting on

  1184 //	Now create the directory we are waiting on

  1187 	r=TheFs.MkDir(path);

  1185 	r=TheFs.MkDir(path);

  1188 	test_KErrNone(r);

  1186 	test_KErrNone(r);

  1189 //	Make sure the notification has now been received

  1187 //	Make sure the notification has now been received

  1190 	User::WaitForRequest(reqStat);

  1188 	User::WaitForRequest(reqStat);

  1192 

  1190 

  1193 //	Submit a request for a file which does not yet exist

  1191 //	Submit a request for a file which does not yet exist

  1194 	path=_L("\\F32-TST\\NOTIFY\\GOOD_WITCH\\Red-Shoes.red");

  1192 	path=_L("\\F32-TST\\NOTIFY\\GOOD_WITCH\\Red-Shoes.red");

  1195 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1193 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1197 //	Now create the file we are waiting on

  1195 //	Now create the file we are waiting on

  1198 	r=file.Replace(TheFs,path,EFileStream);

  1196 	r=file.Replace(TheFs,path,EFileStream);

  1199 	test_KErrNone(r);

  1197 	test_KErrNone(r);

  1200 	file.Close();

  1198 	file.Close();

  1201 //	Make sure the notification has now been received

  1199 //	Make sure the notification has now been received

  1202 	User::WaitForRequest(reqStat);

  1200 	User::WaitForRequest(reqStat);

  1204 //	Submit another notification request and delete the file

  1202 //	Submit another notification request and delete the file

  1205 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1203 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1207 	r=TheFs.Delete(path);

  1205 	r=TheFs.Delete(path);

  1208 	test_KErrNone(r);

  1206 	test_KErrNone(r);

  1209 	User::WaitForRequest(reqStat);

  1207 	User::WaitForRequest(reqStat);

  1211 	path=_L("\\F32-TST\\NOTIFY\\GOOD_WITCH\\");

  1209 	path=_L("\\F32-TST\\NOTIFY\\GOOD_WITCH\\");

  1212 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1210 	TheFs.NotifyChange(ENotifyEntry,reqStat,path);

  1214 	r=TheFs.RmDir(path);

  1212 	r=TheFs.RmDir(path);

  1215 	test_KErrNone(r);

  1213 	test_KErrNone(r);

  1216 	User::WaitForRequest(reqStat);

  1214 	User::WaitForRequest(reqStat);

  1218 	// test passing in an empty string

  1216 	// test passing in an empty string

  1219 	TheFs.NotifyChange(ENotifyEntry,reqStat,_L(""));

  1217 	TheFs.NotifyChange(ENotifyEntry,reqStat,_L(""));

  1220 	User::WaitForRequest(reqStat);

  1218 	User::WaitForRequest(reqStat);

  1222 	}

  1220 	}

  1223 

  1221 

  1224 static void Test9()

  1222 static void Test9()

  1225 //

  1223 //

  1226 // Test notify for multiple clients

  1224 // Test notify for multiple clients

  1294 	test_KErrNone(r);

  1292 	test_KErrNone(r);

  1295 	r=fs6.SetSessionPath(gSessionPath);

  1293 	r=fs6.SetSessionPath(gSessionPath);

  1296 	test_KErrNone(r);

  1294 	test_KErrNone(r);

  1297 	fs6.NotifyChange(ENotifyEntry,reqStat6,path6);

  1295 	fs6.NotifyChange(ENotifyEntry,reqStat6,path6);

  1298 

  1296 

  1305 

  1303 

  1306 //	Make a change a the top level and check that only the session monitoring

  1304 //	Make a change a the top level and check that only the session monitoring

  1307 //	that level is notified

  1305 //	that level is notified

  1308 	test.Next(_L("Test only client monitoring top level is notified"));

  1306 	test.Next(_L("Test only client monitoring top level is notified"));

  1309 	r=file.Replace(TheFs,_L("\\F32-TST\\NewFile.txt"),EFileStream);

  1307 	r=file.Replace(TheFs,_L("\\F32-TST\\NewFile.txt"),EFileStream);

  1310 	test_KErrNone(r);

  1308 	test_KErrNone(r);

  1311 	file.Close();

  1309 	file.Close();

  1312 	User::WaitForRequest(reqStat1);

  1310 	User::WaitForRequest(reqStat1);

  1318 	User::WaitForRequest(reqStat6);

  1316 	User::WaitForRequest(reqStat6);

  1320 

  1318 

  1321 	r=TheFs.Delete(_L("\\F32-TST\\NewFile.txt"));

  1319 	r=TheFs.Delete(_L("\\F32-TST\\NewFile.txt"));

  1322 	test_KErrNone(r);

  1320 	test_KErrNone(r);

  1323 

  1321 

  1324 //	Renew the notify request at the top level and make a change one step lower

  1322 //	Renew the notify request at the top level and make a change one step lower

  1325 	fs1.NotifyChange(ENotifyEntry,reqStat1,path1);

  1323 	fs1.NotifyChange(ENotifyEntry,reqStat1,path1);

  1326 	fs6.NotifyChange(ENotifyEntry,reqStat6,path6);

  1324 	fs6.NotifyChange(ENotifyEntry,reqStat6,path6);

  1329 

  1327 

  1330 	test.Next(_L("Test clients monitoring levels 1 and 2 are notified"));

  1328 	test.Next(_L("Test clients monitoring levels 1 and 2 are notified"));

  1331 	r=file.Replace(TheFs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileStream);

  1329 	r=file.Replace(TheFs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileStream);

  1332 	test_KErrNone(r);

  1330 	test_KErrNone(r);

  1333 	file.Close();

  1331 	file.Close();

  1334 

  1332 

  1335 	User::WaitForRequest(reqStat1);

  1333 	User::WaitForRequest(reqStat1);

  1336 	User::WaitForRequest(reqStat2);

  1334 	User::WaitForRequest(reqStat2);

  1342 	User::WaitForRequest(reqStat6);

  1340 	User::WaitForRequest(reqStat6);

  1344 

  1342 

  1345 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\NewFile.txt"));

  1343 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\NewFile.txt"));

  1346 	test_KErrNone(r);

  1344 	test_KErrNone(r);

  1347 

  1345 

  1348 //	Renew the notify request at the top and second levels and make a change

  1346 //	Renew the notify request at the top and second levels and make a change

  1349 //	one step lower still

  1347 //	one step lower still

  1350 	fs1.NotifyChange(ENotifyEntry,reqStat1,path1);

  1348 	fs1.NotifyChange(ENotifyEntry,reqStat1,path1);

  1351 	fs2.NotifyChange(ENotifyEntry,reqStat2,path2);

  1349 	fs2.NotifyChange(ENotifyEntry,reqStat2,path2);

  1352 	fs6.NotifyChange(ENotifyEntry,reqStat6,path6);

  1350 	fs6.NotifyChange(ENotifyEntry,reqStat6,path6);

  1356 

  1354 

  1357 	test.Next(_L("Test clients monitoring levels 1,2 and 3 are notified"));

  1355 	test.Next(_L("Test clients monitoring levels 1,2 and 3 are notified"));

  1358 	r=file.Replace(TheFs,_L("\\F32-TST\\NOTIFY\\ANIMAL\\NewFile.txt"),EFileStream);

  1356 	r=file.Replace(TheFs,_L("\\F32-TST\\NOTIFY\\ANIMAL\\NewFile.txt"),EFileStream);

  1359 	test_KErrNone(r);

  1357 	test_KErrNone(r);

  1360 	file.Close();

  1358 	file.Close();

  1361 

  1359 

  1362 	User::WaitForRequest(reqStat1);

  1360 	User::WaitForRequest(reqStat1);

  1363 	User::WaitForRequest(reqStat2);

  1361 	User::WaitForRequest(reqStat2);

  1364 	User::WaitForRequest(reqStat3);

  1362 	User::WaitForRequest(reqStat3);

  1370 	User::WaitForRequest(reqStat6);

  1368 	User::WaitForRequest(reqStat6);

  1372 

  1370 

  1373 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\ANIMAL\\NewFile.txt"));

  1371 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\ANIMAL\\NewFile.txt"));

  1374 	test_KErrNone(r);

  1372 	test_KErrNone(r);

  1375 

  1373 

  1376 //	Renew the notify request at the top, second and third levels and make a change

  1374 //	Renew the notify request at the top, second and third levels and make a change

  1377 //	one step lower still

  1375 //	one step lower still

  1378 	fs1.NotifyChange(ENotifyEntry,reqStat1,path1);

  1376 	fs1.NotifyChange(ENotifyEntry,reqStat1,path1);

  1379 	fs2.NotifyChange(ENotifyEntry,reqStat2,path2);

  1377 	fs2.NotifyChange(ENotifyEntry,reqStat2,path2);

  1380 	fs3.NotifyChange(ENotifyEntry,reqStat3,path3);

  1378 	fs3.NotifyChange(ENotifyEntry,reqStat3,path3);

  1381 	fs6.NotifyChange(ENotifyEntry,reqStat6,path6);

  1379 	fs6.NotifyChange(ENotifyEntry,reqStat6,path6);

  1386 

  1384 

  1387 	test.Next(_L("Test clients monitoring levels 1 - 4 are notified"));

  1385 	test.Next(_L("Test clients monitoring levels 1 - 4 are notified"));

  1388 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\ANIMAL\\cat.txt"));

  1386 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\ANIMAL\\cat.txt"));

  1389 	test_KErrNone(r);

  1387 	test_KErrNone(r);

  1390 	User::WaitForRequest(reqStat1);

  1388 	User::WaitForRequest(reqStat1);

  1391 	User::WaitForRequest(reqStat2);

  1389 	User::WaitForRequest(reqStat2);

  1392 	User::WaitForRequest(reqStat3);

  1390 	User::WaitForRequest(reqStat3);

  1393 	User::WaitForRequest(reqStat4);

  1391 	User::WaitForRequest(reqStat4);

  1399 	User::WaitForRequest(reqStat6);

  1397 	User::WaitForRequest(reqStat6);

  1401 

  1399 

  1402 //	Renew the notify request at the top, second and third levels and on the file deleted above

  1400 //	Renew the notify request at the top, second and third levels and on the file deleted above

  1403 //	which will be successful, but will not complete (for obvious reasons)

  1401 //	which will be successful, but will not complete (for obvious reasons)

  1404 

  1402 

  1405 //	Make a change one step lower still

  1403 //	Make a change one step lower still

  1406 	fs1.NotifyChange(ENotifyEntry,reqStat1,path1);

  1404 	fs1.NotifyChange(ENotifyEntry,reqStat1,path1);

  1407 	fs2.NotifyChange(ENotifyEntry,reqStat2,path2);

  1405 	fs2.NotifyChange(ENotifyEntry,reqStat2,path2);

  1408 	fs3.NotifyChange(ENotifyEntry,reqStat3,path3);

  1406 	fs3.NotifyChange(ENotifyEntry,reqStat3,path3);

  1409 	fs6.NotifyChange(ENotifyEntry,reqStat6,path6);

  1407 	fs6.NotifyChange(ENotifyEntry,reqStat6,path6);

  1410 	fs4.NotifyChange(ENotifyEntry,reqStat4,path4);

  1408 	fs4.NotifyChange(ENotifyEntry,reqStat4,path4);

  1416 

  1414 

  1417 	test.Next(_L("Test clients monitoring levels 1 - 3 and 5 are notified"));

  1415 	test.Next(_L("Test clients monitoring levels 1 - 3 and 5 are notified"));

  1418 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\ANIMAL\\dog.txt"));

  1416 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\ANIMAL\\dog.txt"));

  1419 	test_KErrNone(r);

  1417 	test_KErrNone(r);

  1420 	User::WaitForRequest(reqStat1);

  1418 	User::WaitForRequest(reqStat1);

  1421 	User::WaitForRequest(reqStat2);

  1419 	User::WaitForRequest(reqStat2);

  1422 	User::WaitForRequest(reqStat3);

  1420 	User::WaitForRequest(reqStat3);

  1423 //	Don't wait for reqStat4

  1421 //	Don't wait for reqStat4

  1424 	User::WaitForRequest(reqStat5);

  1422 	User::WaitForRequest(reqStat5);

  1425 	User::WaitForRequest(reqStat6);

  1423 	User::WaitForRequest(reqStat6);

  1432 

  1430 

  1433 	fs4.NotifyChangeCancel(reqStat4);

  1431 	fs4.NotifyChangeCancel(reqStat4);

  1434 	User::WaitForRequest(reqStat4);

  1432 	User::WaitForRequest(reqStat4);

  1436 //	Renew the notify request at the top, second and third levels and attempt to renew

  1434 //	Renew the notify request at the top, second and third levels and attempt to renew

  1437 //	the request on the files deleted above (which will fail).

  1435 //	the request on the files deleted above (which will fail).

  1438 

  1436 

  1439 	test.Next(_L("Test clients monitoring levels 1 - 3 are notified"));

  1437 	test.Next(_L("Test clients monitoring levels 1 - 3 are notified"));

  1440 	fs1.NotifyChange(ENotifyEntry,reqStat1,path1);

  1438 	fs1.NotifyChange(ENotifyEntry,reqStat1,path1);

  1441 	fs2.NotifyChange(ENotifyEntry,reqStat2,path2);

  1439 	fs2.NotifyChange(ENotifyEntry,reqStat2,path2);

  1442 	fs3.NotifyChange(ENotifyEntry,reqStat3,path3);

  1440 	fs3.NotifyChange(ENotifyEntry,reqStat3,path3);

  1443 	fs4.NotifyChange(ENotifyEntry,reqStat4,path4);

  1441 	fs4.NotifyChange(ENotifyEntry,reqStat4,path4);

  1444 	fs6.NotifyChange(ENotifyEntry,reqStat6,path6);

  1442 	fs6.NotifyChange(ENotifyEntry,reqStat6,path6);

  1445 	fs5.NotifyChange(ENotifyEntry,reqStat5,path5);

  1443 	fs5.NotifyChange(ENotifyEntry,reqStat5,path5);

  1452 

  1450 

  1453 	r=TheFs.RmDir(_L("\\F32-TST\\NOTIFY\\ANIMAL\\"));

  1451 	r=TheFs.RmDir(_L("\\F32-TST\\NOTIFY\\ANIMAL\\"));

  1454 	test_KErrNone(r);

  1452 	test_KErrNone(r);

  1455 	User::WaitForRequest(reqStat1);

  1453 	User::WaitForRequest(reqStat1);

  1456 	User::WaitForRequest(reqStat2);

  1454 	User::WaitForRequest(reqStat2);

  1457 	User::WaitForRequest(reqStat3);

  1455 	User::WaitForRequest(reqStat3);

  1463 	User::WaitForRequest(reqStat6);

  1461 	User::WaitForRequest(reqStat6);

  1465 

  1463 

  1466 //	Renew the notify request at the top and second levels on the third level

  1464 //	Renew the notify request at the top and second levels on the third level

  1467 //	which was removed - it'll succeed but won't complete.

  1465 //	which was removed - it'll succeed but won't complete.

  1468 

  1466 

  1469 	test.Next(_L("Test clients monitoring levels 1 and 2 are notified"));

  1467 	test.Next(_L("Test clients monitoring levels 1 and 2 are notified"));

  1471 	fs1.NotifyChange(ENotifyEntry,reqStat1,path1);

  1469 	fs1.NotifyChange(ENotifyEntry,reqStat1,path1);

  1472 	fs2.NotifyChange(ENotifyEntry,reqStat2,path2);

  1470 	fs2.NotifyChange(ENotifyEntry,reqStat2,path2);

  1473 	fs3.NotifyChange(ENotifyEntry,reqStat3,path3);

  1471 	fs3.NotifyChange(ENotifyEntry,reqStat3,path3);

  1474 	fs6.NotifyChange(ENotifyEntry,reqStat6,path6);

  1472 	fs6.NotifyChange(ENotifyEntry,reqStat6,path6);

  1475 

  1473 

  1482 

  1480 

  1483 	fs1.NotifyChangeCancel();

  1481 	fs1.NotifyChangeCancel();

  1484 	fs2.NotifyChangeCancel();

  1482 	fs2.NotifyChangeCancel();

  1485 

  1483 

  1486 	fs1.Close();

  1484 	fs1.Close();

  1523 	fs1.NotifyChange(ENotifyAll,status1,path);

  1521 	fs1.NotifyChange(ENotifyAll,status1,path);

  1524 	fs1.NotifyChange(ENotifyAll,status2,path);

  1522 	fs1.NotifyChange(ENotifyAll,status2,path);

  1525 	fs1.NotifyChange(ENotifyAll,status3,path);

  1523 	fs1.NotifyChange(ENotifyAll,status3,path);

  1526 	fs1.NotifyChange(ENotifyAll,status4,path);

  1524 	fs1.NotifyChange(ENotifyAll,status4,path);

  1527 	fs1.NotifyChange(ENotifyAll,status5,path);

  1525 	fs1.NotifyChange(ENotifyAll,status5,path);

  1533 

  1531 

  1534 	test.Next(_L("RFs::NotifyCancel()"));

  1532 	test.Next(_L("RFs::NotifyCancel()"));

  1535 //	Test that one call to RFs::NotifyCancel() cancels all outstanding requests

  1533 //	Test that one call to RFs::NotifyCancel() cancels all outstanding requests

  1536 	fs1.NotifyChangeCancel();

  1534 	fs1.NotifyChangeCancel();

  1537 	User::WaitForRequest(status1);

  1535 	User::WaitForRequest(status1);

  1539 	User::WaitForRequest(status2);

  1537 	User::WaitForRequest(status2);

  1541 	User::WaitForRequest(status3);

  1539 	User::WaitForRequest(status3);

  1543 	User::WaitForRequest(status4);

  1541 	User::WaitForRequest(status4);

  1545 	User::WaitForRequest(status5);

  1543 	User::WaitForRequest(status5);

  1547 //	Call the cancel function again to check no further action

  1545 //	Call the cancel function again to check no further action

  1548 	fs1.NotifyChangeCancel();

  1546 	fs1.NotifyChangeCancel();

  1549 

  1547 

  1550 //	Test overloaded function to cancel a single request

  1548 //	Test overloaded function to cancel a single request

  1551 	test.Next(_L("Cancel notification request using function overload"));

  1549 	test.Next(_L("Cancel notification request using function overload"));

  1552 	fs1.NotifyChange(ENotifyAll,status1,path);

  1550 	fs1.NotifyChange(ENotifyAll,status1,path);

  1553 	fs1.NotifyChange(ENotifyAll,status2,path);

  1551 	fs1.NotifyChange(ENotifyAll,status2,path);

  1554 	fs1.NotifyChange(ENotifyAll,status3,path);

  1552 	fs1.NotifyChange(ENotifyAll,status3,path);

  1555 	fs1.NotifyChange(ENotifyAll,status4,path);

  1553 	fs1.NotifyChange(ENotifyAll,status4,path);

  1556 	fs1.NotifyChange(ENotifyAll,status5,path);

  1554 	fs1.NotifyChange(ENotifyAll,status5,path);

  1562 

  1560 

  1563 //	Cancel the outstanding request with status5

  1561 //	Cancel the outstanding request with status5

  1564 	test.Next(_L("RFs::NotifyCancel()"));

  1562 	test.Next(_L("RFs::NotifyCancel()"));

  1565 	fs1.NotifyChangeCancel(status5);

  1563 	fs1.NotifyChangeCancel(status5);

  1566 	User::WaitForRequest(status5);

  1564 	User::WaitForRequest(status5);

  1572 

  1570 

  1573 	r=TheFs.MkDir(_L("\\F32-TST\\TROPICANA\\"));

  1571 	r=TheFs.MkDir(_L("\\F32-TST\\TROPICANA\\"));

  1574 	test_KErrNone(r);

  1572 	test_KErrNone(r);

  1579 

  1577 

  1580 	fs1.NotifyChangeCancel(status2);

  1578 	fs1.NotifyChangeCancel(status2);

  1581 	User::WaitForRequest(status2);

  1579 	User::WaitForRequest(status2);

  1582 

  1580 

  1587 

  1585 

  1588 	r=TheFs.RmDir(_L("\\F32-TST\\TROPICANA\\"));

  1586 	r=TheFs.RmDir(_L("\\F32-TST\\TROPICANA\\"));

  1589 	test_KErrNone(r);

  1587 	test_KErrNone(r);

  1593 

  1591 

  1594 	fs1.NotifyChangeCancel(status4);

  1592 	fs1.NotifyChangeCancel(status4);

  1595 	User::WaitForRequest(status4);

  1593 	User::WaitForRequest(status4);

  1599 

  1597 

  1600 	fs1.NotifyChangeCancel(status4);	//	Test no side effects on trying to cancel a request

  1598 	fs1.NotifyChangeCancel(status4);	//	Test no side effects on trying to cancel a request

  1602 

  1600 

  1603 	fs1.NotifyChangeCancel(status1);

  1601 	fs1.NotifyChangeCancel(status1);

  1604 	User::WaitForRequest(status1);

  1602 	User::WaitForRequest(status1);

  1607 	fs1.NotifyChangeCancel(status1);	//	Test no side effects on trying to cancel a request

  1605 	fs1.NotifyChangeCancel(status1);	//	Test no side effects on trying to cancel a request

  1609 

  1607 

  1610 	fs1.NotifyChangeCancel(status3);

  1608 	fs1.NotifyChangeCancel(status3);

  1611 	User::WaitForRequest(status3);

  1609 	User::WaitForRequest(status3);

  1613 

  1611 

  1614 	fs1.Close();

  1612 	fs1.Close();

  1615 	}

  1613 	}

  1616 

  1614 

  1617 static void Test11()

  1615 static void Test11()

  1691 	test_KErrNone(r);

  1689 	test_KErrNone(r);

  1692 	r=fs3.SetSessionPath(gSessionPath);

  1690 	r=fs3.SetSessionPath(gSessionPath);

  1693 	test_KErrNone(r);

  1691 	test_KErrNone(r);

  1694 	fs3.NotifyChange(ENotifyEntry,reqStat3,path);

  1692 	fs3.NotifyChange(ENotifyEntry,reqStat3,path);

  1695 

  1693 

  1699 

  1697 

  1700 	r=gSleepThread.CreateLocal(0);

  1698 	r=gSleepThread.CreateLocal(0);

  1701 	test_KErrNone(r);

  1699 	test_KErrNone(r);

  1702 	RThread thread1;

  1700 	RThread thread1;

  1703 	r=thread1.Create(_L("TestThread1"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest5);

  1701 	r=thread1.Create(_L("TestThread1"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest5);

  1704 	test_KErrNone(r);

  1702 	test_KErrNone(r);

  1705 	thread1.Resume();

  1703 	thread1.Resume();

  1706 	gSleepThread.Wait();

  1704 	gSleepThread.Wait();

  1707 

  1705 

  1711 

  1709 

  1712 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\kangaroo.txt"));

  1710 	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\kangaroo.txt"));

  1713 	test_KErrNone(r);

  1711 	test_KErrNone(r);

  1714 	User::WaitForRequest(reqStat1);

  1712 	User::WaitForRequest(reqStat1);

  1715 	User::WaitForRequest(reqStat2);

  1713 	User::WaitForRequest(reqStat2);

  1716 	User::WaitForRequest(reqStat3);

  1714 	User::WaitForRequest(reqStat3);

  1720 

  1718 

  1721 	gSleepThread.Close();

  1719 	gSleepThread.Close();

  1722 	thread1.Close();

  1720 	thread1.Close();

  1723 

  1721 

  1724 	test.Next(_L("Test reads and writes do cause notification under ENotifyAll"));

  1722 	test.Next(_L("Test reads and writes do cause notification under ENotifyAll"));

  1728 

  1726 

  1729 	fs1.NotifyChange(ENotifyAll,reqStat1,path);

  1727 	fs1.NotifyChange(ENotifyAll,reqStat1,path);

  1730 	fs2.NotifyChange(ENotifyAll,reqStat2,path);

  1728 	fs2.NotifyChange(ENotifyAll,reqStat2,path);

  1731 	fs3.NotifyChange(ENotifyAll,reqStat3,path);

  1729 	fs3.NotifyChange(ENotifyAll,reqStat3,path);