1 // Copyright (c) 1996-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_notify.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 

    24 const TInt KHeapSize=0x200;

    25 

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

    27 const TInt KNotifyChangeAfter=100000;

    28 const TInt KMediaRemountForceMediaChange = 0x00000001;

    29 

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

    31 RSemaphore gSleepThread;

    32 TInt gSocketNumber=0;

    33 TInt SocketToDrive[KMaxPBusSockets];

    34 

    35 //#define __INCLUDE_MANUAL_TESTS__

    36 

    37 void do_check_no_pending_requests(TInt aLine)

    38 	{

    39 	RTimer timer;

    40 	TRequestStatus timerStat;

    41 	timer.CreateLocal();

    42 	timer.After(timerStat, 125000);

    43 	User::WaitForAnyRequest();

    44 	if(timerStat==KRequestPending)

    45 		{

    46 		RDebug::Printf("do_check_no_pending_requests failed at line %d",aLine);

    47 		test(0);

    48 		}

    49 	timer.Close();

    50 	}

    51 #define CHECK_NO_PENDING_REQUESTS do_check_no_pending_requests(__LINE__);

    52 

    53 

    54 TBool CheckDriveRead(TInt aDrive)

    55   //Determines if can connect to local drive number and read

    56 	{

    57     TBusLocalDrive TBLD;

    58     TBool TBLDChangedFlag;

    59 

    60     TInt r = TBLD.Connect(aDrive, TBLDChangedFlag);

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

    62     if (r == KErrNone)

    63 		{

    64         const TInt KSectSize = 512;

    65         TBuf8<KSectSize> sect;

    66         r = TBLD.Read(0, KSectSize, sect);

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

    68         TBLD.Disconnect();

    69 		if(r!=KErrNone)

    70 			return EFalse;

    71 		else

    72 			return ETrue;

    73         }

    74 	 else

    75 		return EFalse;

    76 	}

    77 

    78 void GenerateMediaChange()

    79 	{

    80     TPckgBuf<TInt> pckg;

    81     pckg()=0;

    82 

    83 	RFs fs;

    84 	TInt r = fs.Connect();

    85 	if (r == KErrNone)

    86 		{

    87 		r = fs.RemountDrive(CurrentDrive(), &pckg, (TUint)KMediaRemountForceMediaChange);

    88 		if(r == KErrNotReady)

    89 			{

    90 			r = KErrNone;

    91 			}

    92 		fs.Close();

    93 		}

    94 

    95 	if (r!=KErrNone)

    96 		{

    97 		RProcess me;

    98 		me.Panic(_L("GenMedChg"),r);

    99 		}

   100 	}

   101 

   102 enum TTestCode {ETest1,ETest2,ETest3,ETest4,ETest5,ETest6,ETest7,ETest8,ETest9,ETest10,ETest11,ETest12};

   103 const TUint KGenericEntryChange=0x02;

   104 

   105 static TInt ThreadEntryPoint(TAny* aTestCode)

   106 //

   107 // Thread entry point

   108 //

   109 	{

   110 	RFs fs;

   111 	TInt r=fs.Connect();

   112 	test(r==KErrNone);

   113 	r=fs.SetSessionPath(gSessionPath);

   114 	test(r==KErrNone);

   115 	TTestCode testCode=*(TTestCode*)&aTestCode;

   116 	RFile f;

   117 	switch (testCode)

   118 		{

   119 

   120 	case ETest1:

   121 		r=f.Replace(fs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileStream);

   122 		test(r==KErrNone);

   123 		f.Close();

   124 		break;

   125 

   126 	case ETest2:

   127 		r=f.Replace(fs,_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\Dorothy.doc"),EFileStream);

   128 		test(r==KErrNone);

   129 		f.Close();

   130 		break;

   131 

   132 	case ETest3:

   133 		r=fs.MkDir(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\SCARECROW\\"));

   134 		test((r==KErrNone)||(r==KErrAlreadyExists));

   135 		break;

   136 

   137 	case ETest4:

   138 		{

   139 		TRequestStatus s;

   140 		fs.NotifyChange(ENotifyAll,s);

   141 		test(s==KRequestPending);

   142 		gSleepThread.Signal();

   143 		User::After(100000000);

   144 		}

   145 		break;

   146 

   147 	case ETest5:

   148 		{

   149 		RFile file;

   150 		TInt r=file.Open(fs,_L("\\F32-TST\\NOTIFY\\kangaroo.txt"),EFileRead|EFileWrite);

   151 		test(r==KErrNone);

   152 		r=file.SetSize(sizeof(TCheckedUid));

   153 		test(r==KErrNone);

   154 		r=file.Write(sizeof(TCheckedUid),_L8("012345678912"));

   155 		test(r==KErrNone);

   156 		TBuf8<64> dum;

   157 		r=file.Read(0,dum);

   158 		test(r==KErrNone);

   159 		file.Close();

   160 

   161 		r=file.Open(fs,_L("\\F32-TST\\NOTIFY\\koala.txt"),EFileRead|EFileWrite);

   162 		test(r==KErrNone);

   163 		r=file.SetSize(50);

   164 		test(r==KErrNone);

   165 		r=file.Write(sizeof(TCheckedUid),_L8("ABCDEFGHIJKLMNOPQRSTUVWXYZ"));

   166 		test(r==KErrNone);

   167 		r=file.Read(0,dum);

   168 		test(r==KErrNone);

   169 		file.Close();

   170 

   171 		r=file.Open(fs,_L("\\F32-TST\\NOTIFY\\dingo.txt"),EFileRead|EFileWrite);

   172 		test(r==KErrNone);

   173 		r=file.SetSize(50);

   174 		test(r==KErrNone);

   175 		r=file.Write(sizeof(TCheckedUid),_L8("01234567890123456789"));

   176 		test(r==KErrNone);

   177 		r=file.Read(0,dum);

   178 		test(r==KErrNone);

   179 		file.Close();

   180 		gSleepThread.Signal();

   181 		}

   182 		break;

   183 

   184 	case ETest6:

   185 		{

   186 		GenerateMediaChange();

   187 		User::After(300000);			// Wait for a bit

   188 		gSleepThread.Signal();

   189 		}

   190 		break;

   191 

   192 	case ETest7:

   193 		{

   194 		RFile file;

   195 		TInt r=file.Open(fs,_L("\\F32-TST\\NOTIFY\\NewFILE.TXT"),EFileRead|EFileWrite);

   196 		test(r==KErrNone);

   197 		r=file.Write(_L8("asdfasdfasdf"));

   198 		test(r==KErrNone);

   199 		file.Close();

   200 		gSleepThread.Signal();

   201 		}

   202 		break;

   203 

   204 	case ETest8:

   205 		{

   206 		r=f.Open(fs,_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\WickedWitch.msg"),EFileRead|EFileWrite);

   207 		test(r==KErrNone);

   208 		f.SetSize(500);

   209 		f.Close();

   210 		break;

   211 		}

   212 

   213 	case ETest9:

   214 		{

   215 		TRequestStatus s;

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

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

   218 		test(s==KRequestPending);

   219 		gSleepThread.Signal();

   220 		User::After(100000000);

   221 		}

   222 		break;

   223 	case ETest10:

   224 		{

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

   226 		r=fs.MkDir(path);

   227 		test(r==KErrNone);

   228 		break;

   229 		}

   230 	case ETest11:

   231 		{

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

   233 		RFile file;

   234 		r=file.Replace(fs,path,EFileStream);

   235 		test(r==KErrNone);

   236 		file.Close();

   237 		break;

   238 		}

   239 	case ETest12:

   240 		{

   241 		RFile writer;

   242 		TInt r=writer.Open(fs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileWrite|EFileShareAny);

   243 		test(r==KErrNone);

   244 		TInt i;

   245 		for(i=0; i<10; i++)

   246 			{

   247 			r=writer.Write(_L8("ABCDEFGHIJKLMNOPQRSTUVWXYZ"));

   248 			test(r==KErrNone);

   249 			User::After(1000000);

   250 			}

   251 		writer.Close();

   252 		break;

   253 		}

   254 	default:

   255 		break;

   256 		}

   257 	return KErrNone;

   258 	}

   259 

   260 #if defined (__EPOC32__)//we have no removable media on Emulator yet

   261 static void WaitForMediaChange()

   262 //

   263 // Wait for media driver to register drive is present

   264 //

   265 	{

   266 

   267 	TEntry entry;

   268 	FOREVER

   269 		{

   270 		User::After(10000);

   271 		TInt r=TheFs.Entry(_L("xxxxxxxx"),entry);

   272 		if (r!=KErrNotReady)

   273 			break;

   274 		}

   275 	}

   276 #endif

   277 

   278 static void Test1()

   279 //

   280 // Test notification of an entry change

   281 //

   282 	{

   283 

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

   285 	TRequestStatus reqStat(KRequestPending);

   286 	TRequestStatus thrdStat(KRequestPending);

   287 	TInt r;

   288 	TheFs.NotifyChange(ENotifyEntry,reqStat);

   289 	RThread thread;

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

   291 	test(r==KErrNone);

   292 	thread.Logon(thrdStat);

   293 	thread.Resume();

   294 	User::WaitForRequest(thrdStat);

   295 	test(thrdStat==KErrNone);

   296 	thread.Close();

   297 	User::WaitForRequest(reqStat);

   298 	test(reqStat==KErrNone);

   299 

   300 	RFile file;

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

   302 	test(r==KErrNone);

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

   304 	User::WaitForRequest(reqStat);

   305 	test(reqStat==KErrNone);

   306 	TBuf8<256> buf;

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

   308 	User::WaitForRequest(reqStat);

   309 	test(reqStat==KErrNone);

   310 	file.Close();

   311 

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

   313 	test(r==KErrArgument);

   314 

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

   316 	test(r==KErrArgument);

   317 

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

   319 	test(r==KErrNone);

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

   321 	test(reqStat==KRequestPending);

   322 	file.Close();

   323 	User::WaitForRequest(reqStat);

   324 	test(reqStat==KErrCancel);

   325 

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

   327 	test(r==KErrNone);

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

   329 	test(reqStat==KRequestPending);

   330 	file.ReadCancel(reqStat);

   331 	User::WaitForRequest(reqStat);

   332 	test(reqStat==KErrCancel);

   333 	file.Close();

   334 

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

   336 	test(r==KErrNone);

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

   338 	test(reqStat==KRequestPending);

   339 	file.SetSize(100);

   340 	User::WaitForRequest(reqStat);

   341 	test(reqStat==KErrNone);

   342 	test(buf.Length() == 100);

   343 	file.Close();

   344 

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

   346 	TheFs.NotifyChange(ENotifyEntry,reqStat);

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

   348 	thread.Logon(thrdStat);

   349 	thread.Resume();

   350 	User::WaitForRequest(thrdStat);

   351 	test(thrdStat==KErrNone);

   352 	thread.Close();

   353 	User::WaitForRequest(reqStat);

   354 	if (reqStat!=KErrNone)

   355 		{

   356 		test.Printf(_L("ReqStat=%d\n"),reqStat.Int());

   357 		//test.Getch();

   358 		}

   359 	test(reqStat==KErrNone);

   360 

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

   362 	TheFs.NotifyChange(ENotifyEntry,reqStat);

   363 	TheFs.NotifyChangeCancel();

   364 	User::WaitForRequest(reqStat);

   365 

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

   367 	TheFs.NotifyChange(ENotifyEntry,reqStat);

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

   369 	thread.Logon(thrdStat);

   370 	thread.Resume();

   371 	User::WaitForRequest(thrdStat);

   372 	test(thrdStat==KErrNone);

   373 	thread.Close();

   374 	User::WaitForRequest(reqStat);

   375 	test(reqStat==KErrNone);

   376 	}

   377 

   378 static void Test2()

   379 //

   380 // Test notify for multiple clients

   381 //

   382 	{

   383 

   384 	test.Next(_L("Test notification of multiple clients"));

   385 

   386 	TRequestStatus reqStat1(KRequestPending);

   387 	RFs fs1;

   388 	TInt r=fs1.Connect();

   389 	test(r==KErrNone);

   390 	fs1.NotifyChange(ENotifyEntry,reqStat1);

   391 

   392 	TRequestStatus reqStat2(KRequestPending);

   393 	RFs fs2;

   394 	r=fs2.Connect();

   395 	test(r==KErrNone);

   396 	fs2.NotifyChange(ENotifyEntry,reqStat2);

   397 

   398 	test(reqStat1==KRequestPending);

   399 	test(reqStat2==KRequestPending);

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

   401 	test(r==KErrNone);

   402 	User::WaitForRequest(reqStat1);

   403 	User::WaitForRequest(reqStat2);

   404 	test(reqStat1==KErrNone);

   405 	test(reqStat2==KErrNone);

   406 	}

   407 

   408 static void Test3()

   409 //

   410 // Test notify cancel

   411 //

   412 	{

   413 

   414 	test.Next(_L("Cancel notification"));

   415 	RFs fs1;

   416 	TInt r=fs1.Connect();

   417 	test(r==KErrNone);

   418 

   419 	TRequestStatus status1;

   420 	TRequestStatus status2;

   421 	TRequestStatus status3;

   422 	TRequestStatus status4;

   423 	TRequestStatus status5;

   424 

   425 	fs1.NotifyChange(ENotifyAll,status1);

   426 	fs1.NotifyChange(ENotifyAll,status2);

   427 	fs1.NotifyChange(ENotifyAll,status3);

   428 	fs1.NotifyChange(ENotifyAll,status4);

   429 	fs1.NotifyChange(ENotifyAll,status5);

   430 	test(status1==KRequestPending);

   431 	test(status2==KRequestPending);

   432 	test(status3==KRequestPending);

   433 	test(status4==KRequestPending);

   434 	test(status5==KRequestPending);

   435 

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

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

   438 	fs1.NotifyChangeCancel();

   439 	User::WaitForRequest(status1);

   440 	test(status1==KErrCancel);

   441 	User::WaitForRequest(status2);

   442 	test(status2==KErrCancel);

   443 	User::WaitForRequest(status3);

   444 	test(status3==KErrCancel);

   445 	User::WaitForRequest(status4);

   446 	test(status4==KErrCancel);

   447 	User::WaitForRequest(status5);

   448 	test(status5==KErrCancel);

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

   450 	fs1.NotifyChangeCancel();

   451 

   452 //	Test overloaded function to cancel a single request

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

   454 	fs1.NotifyChange(ENotifyAll,status1);

   455 	fs1.NotifyChange(ENotifyAll,status2);

   456 	fs1.NotifyChange(ENotifyAll,status3);

   457 	fs1.NotifyChange(ENotifyAll,status4);

   458 	fs1.NotifyChange(ENotifyAll,status5);

   459 	test(status1==KRequestPending);

   460 	test(status2==KRequestPending);

   461 	test(status3==KRequestPending);

   462 	test(status4==KRequestPending);

   463 	test(status5==KRequestPending);

   464 

   465 //	Cancel the outstanding request with status5

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

   467 	fs1.NotifyChangeCancel(status5);

   468 	User::WaitForRequest(status5);

   469 	test(status1==KRequestPending);

   470 	test(status2==KRequestPending);

   471 	test(status3==KRequestPending);

   472 	test(status4==KRequestPending);

   473 	test(status5==KErrCancel);

   474 

   475 	fs1.NotifyChangeCancel(status2);

   476 	User::WaitForRequest(status2);

   477 

   478 	test(status1==KRequestPending);

   479 	test(status2==KErrCancel);

   480 	test(status3==KRequestPending);

   481 	test(status4==KRequestPending);

   482 

   483 	fs1.NotifyChangeCancel(status4);

   484 	User::WaitForRequest(status4);

   485 	test(status1==KRequestPending);

   486 	test(status3==KRequestPending);

   487 	test(status4==KErrCancel);

   488 

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

   490 	test(status4==KErrCancel);			//	that has already been cancelled

   491 

   492 	fs1.NotifyChangeCancel(status1);

   493 	User::WaitForRequest(status1);

   494 	test(status1==KErrCancel);

   495 	test(status3==KRequestPending);

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

   497 	test(status1==KErrCancel);			//	that has already been cancelled

   498 

   499 	fs1.NotifyChangeCancel(status3);

   500 	User::WaitForRequest(status3);

   501 	test(status3==KErrCancel);

   502 

   503 	fs1.Close();

   504 	}

   505 

   506 static void Test4()

   507 //

   508 // Test notify client death

   509 //

   510 	{

   511 

   512 	test.Next(_L("Kill client"));

   513 	TInt r=gSleepThread.CreateLocal(0);

   514 	test(r==KErrNone);

   515 	RThread clientThread;

   516 	r=clientThread.Create(_L("ClientThread"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest4);

   517 	if (r!=KErrNone)

   518 		{

   519 		test.Printf(_L(" ERROR: Failed to create clientthread %d\n"),r);

   520 		test(0);

   521 		//test.Getch();

   522 		return;

   523 		}

   524 	clientThread.Resume();

   525 	gSleepThread.Wait();

   526 

   527 	TBool jit = User::JustInTime();

   528 	User::SetJustInTime(EFalse);

   529 	clientThread.Panic(_L("Test client thread panic"),KErrGeneral);

   530 	User::SetJustInTime(jit);

   531 

   532 	clientThread.Close();

   533 

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

   535 	test(r==KErrNone || r==KErrAlreadyExists);

   536 	MakeFile(_L("\\F32-TST\\NOTIFY\\NewFile.Txt"));

   537 	User::After(1000);

   538 	}

   539 

   540 static void Test5()

   541 //

   542 // Test reads and writes do not cause notification

   543 //

   544 	{

   545 

   546 	test.Next(_L("Test reads and writes do not cause notification"));

   547 

   548 

   549 	RFile file;

   550 	TInt r=file.Replace(TheFs,_L("\\F32-TST\\NOTIFY\\kangaroo.txt"),EFileRead|EFileWrite);

   551 	test(r==KErrNone);

   552 	file.Close();

   553 	r=file.Replace(TheFs,_L("\\F32-TST\\NOTIFY\\koala.txt"),EFileRead|EFileWrite);

   554 	test(r==KErrNone);

   555 	file.Close();

   556 	r=file.Replace(TheFs,_L("\\F32-TST\\NOTIFY\\dingo.txt"),EFileRead|EFileWrite);

   557 	test(r==KErrNone);

   558 	file.Close();

   559 

   560 	TRequestStatus reqStat=0;

   561 	TheFs.NotifyChange(ENotifyEntry,reqStat);

   562 	test(reqStat==KRequestPending);

   563 

   564 	r=gSleepThread.CreateLocal(0);

   565 	test(r==KErrNone);

   566 	RThread clientThread;

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

   568 	test(r==KErrNone);

   569 	clientThread.Resume();

   570 	gSleepThread.Wait();

   571 	test(reqStat==KRequestPending);

   572 

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

   574 	test(r==KErrNone);

   575 	User::WaitForRequest(reqStat);

   576 	test(reqStat==KErrNone);

   577 

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

   579 	test(r==KErrNone);

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

   581 	test(r==KErrNone);

   582 

   583 

   584 

   585 	gSleepThread.Close();

   586 	clientThread.Close();

   587 	}

   588 

   589 #if defined (__EPOC32__)//we have no removable media on Emulator yet	.. ??? we do now

   590 static void Test6()

   591 //

   592 //	Test media change notification

   593 //

   594 	{

   595 	TDriveInfo driveInfo;

   596 	TInt r=TheFs.Drive(driveInfo,CurrentDrive());

   597 	test(r==KErrNone);

   598 	// only test on removable media

   599 	if (driveInfo.iDriveAtt&KDriveAttRemovable)

   600         {

   601         TBuf<64> b;

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

   603         test.Next(b);

   604         TRequestStatus reqStat=0;

   605         TInt r;

   606         TheFs.NotifyChange(ENotifyEntry,reqStat);

   607         test(reqStat==KRequestPending);

   608         r=gSleepThread.CreateLocal(0);

   609         test(r==KErrNone);

   610         RThread clientThread;

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

   612         test(r==KErrNone);

   613         clientThread.Resume();

   614         gSleepThread.Wait();

   615         TInt reqInt=reqStat.Int();

   616         test(reqInt==KErrNone);

   617         User::WaitForRequest(reqStat);

   618         WaitForMediaChange();

   619         gSleepThread.Close();

   620         clientThread.Close();

   621         }

   622 	

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

   624         User::After(2000000);

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

   626 	    test(r==KErrNone);

   627 

   628     

   629     }

   630 #endif

   631 

   632 static void Test7()

   633 //

   634 // Test Write to uid region does not trigger notification

   635 //

   636 	{

   637 

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

   639 	TRequestStatus reqStat=0;

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

   641 	TInt r;

   642 	TheFs.NotifyChange(ENotifyEntry,reqStat);

   643 	test(reqStat==KRequestPending);

   644 

   645 	r=gSleepThread.CreateLocal(0);

   646 	test(r==KErrNone);

   647 	RThread clientThread;

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

   649 	test(r==KErrNone);

   650 	clientThread.Resume();

   651 	gSleepThread.Wait();

   652 	test(reqStat==KRequestPending);

   653 

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

   655 	test(r==KErrNone);

   656 

   657 	User::WaitForRequest(reqStat);

   658 

   659 	gSleepThread.Close();

   660 	clientThread.Close();

   661 	}

   662 

   663 #if defined (__EPOC32__)//we have no removable media on Emulator yet

   664 static void MediaChangeExtendedNotification()

   665 //

   666 //	Test media change notification

   667 //	Always notified of media change - regardless of requested TNotifyType

   668 //

   669 	{

   670 	TDriveInfo driveInfo;

   671 	TInt r=TheFs.Drive(driveInfo,CurrentDrive());

   672 	test(r==KErrNone);

   673 	// only test on removable media

   674 	if (driveInfo.iDriveAtt&KDriveAttRemovable)

   675 		{

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

   677 		TRequestStatus reqStat=0;

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

   679 		TInt r;

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

   681 		test(reqStat==KRequestPending);

   682 		r=gSleepThread.CreateLocal(0);

   683 		test(r==KErrNone);

   684 		RThread clientThread;

   685 		gSocketNumber=0;

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

   687 		test(r==KErrNone);

   688 		clientThread.Resume();

   689 		gSleepThread.Wait();

   690 		User::WaitForRequest(reqStat);

   691 		test(reqStat==KErrNone);

   692 		WaitForMediaChange();

   693 		gSleepThread.Close();

   694 		clientThread.Close();

   695 

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

   697         User::After(2000000);

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

   699 	    test(r==KErrNone);

   700 

   701 

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

   703 		test(reqStat==KRequestPending);

   704 		r=gSleepThread.CreateLocal(0);

   705 		test(r==KErrNone);

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

   707 		test(r==KErrNone);

   708 		clientThread.Resume();

   709 		gSleepThread.Wait();

   710 		User::WaitForRequest(reqStat);

   711 		test(reqStat==KErrNone);

   712 		WaitForMediaChange();

   713 		gSleepThread.Close();

   714 		clientThread.Close();

   715 

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

   717         User::After(2000000);

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

   719 	    test(r==KErrNone);

   720 

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

   722 		test(reqStat==KRequestPending);

   723 		r=gSleepThread.CreateLocal(0);

   724 		test(r==KErrNone);

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

   726 		test(r==KErrNone);

   727 		clientThread.Resume();

   728 		gSleepThread.Wait();

   729 		User::WaitForRequest(reqStat);

   730 		test(reqStat==KErrNone);

   731 		WaitForMediaChange();

   732 		gSleepThread.Close();

   733 		clientThread.Close();

   734 

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

   736         User::After(2000000);

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

   738 	    test(r==KErrNone);

   739 

   740 		}

   741 	}

   742 #endif

   743 

   744 static void TestRequestAhead()

   745 //

   746 //	Test extended notification works when path initially does not exist

   747 //

   748 	{

   749 	test.Next(_L("Test Request Ahead"));

   750 //	First a simple example

   751 

   752 	TInt r=TheFs.RmDir(_L("\\F32-TST\\NOTIFY\\BehindTheCurtain\\"));

   753 	test((r==KErrNotFound)||(r==KErrPathNotFound)||(r==KErrNone));

   754 

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

   756 	TRequestStatus reqStat(KRequestPending);

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

   758 	test(reqStat==KRequestPending);

   759 

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

   761 	test(r==KErrNone);

   762 

   763 	User::WaitForRequest(reqStat);

   764 	test(reqStat==KErrNone);

   765 

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

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

   768 	test(reqStat==KRequestPending);

   769 

   770 	RFile file;

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

   772 	test(r==KErrNone);

   773 	file.Close();

   774 

   775 	User::WaitForRequest(reqStat);

   776 	test(reqStat==KErrNone);

   777 

   778 	r=TheFs.Delete(path);

   779 	test(r==KErrNone);

   780 

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

   782 	test(reqStat==KRequestPending);

   783 //	Now cancel the outstanding request

   784 	TheFs.NotifyChangeCancel(reqStat);

   785 	User::WaitForRequest(reqStat);

   786 	test(reqStat==KErrCancel);

   787 

   788 //	Repeat with a ENotifyFile request

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

   790 	test(reqStat==KRequestPending);

   791 

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

   793 	test(r==KErrNone);

   794 	file.Close();

   795 

   796 	User::WaitForRequest(reqStat);

   797 	test(reqStat==KErrNone);

   798 

   799 	r=TheFs.Delete(path);

   800 	test(r==KErrNone);

   801 

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

   803 	test(reqStat==KRequestPending);

   804 //	Now cancel the outstanding request

   805 	TheFs.NotifyChangeCancel(reqStat);

   806 	User::WaitForRequest(reqStat);

   807 	test(reqStat==KErrCancel);

   808 

   809 //	Repeat with an ENotifyAttributes request

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

   811 	test(reqStat==KRequestPending);

   812 

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

   814 	test(r==KErrNone);

   815 	file.Close();

   816 

   817 	User::WaitForRequest(reqStat);

   818 	test(reqStat==KErrNone);	//	Monitoring attributes but informed anyway

   819 

   820 	r=TheFs.Delete(path);

   821 	test(r==KErrNone);

   822 

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

   824 	test(reqStat==KRequestPending);

   825 //	Now cancel the outstanding request

   826 	TheFs.NotifyChangeCancel(reqStat);

   827 	User::WaitForRequest(reqStat);

   828 	test(reqStat==KErrCancel);

   829 

   830 //	Repeat with an ENotifyWrite request

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

   832 	test(reqStat==KRequestPending);

   833 

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

   835 	test(r==KErrNone);

   836 	file.Close();

   837 

   838 	User::WaitForRequest(reqStat);

   839 	test(reqStat==KErrNone);	//	Monitoring file writing but informed anyway

   840 

   841 	r=TheFs.Delete(path);

   842 	test(r==KErrNone);

   843 

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

   845 	test(reqStat==KRequestPending);

   846 //	Now cancel the outstanding request

   847 	TheFs.NotifyChangeCancel(reqStat);

   848 	User::WaitForRequest(reqStat);

   849 	test(reqStat==KErrCancel);

   850 

   851 //	Repeat with an ENotifyDisk request

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

   853 	test(reqStat==KRequestPending);

   854 

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

   856 	test(r==KErrNone);

   857 	file.Close();

   858 

   859 	User::WaitForRequest(reqStat);

   860 	test(reqStat==KErrNone);	//	Monitoring disk activity but informed anyway

   861 

   862 	r=TheFs.Delete(path);

   863 	test(r==KErrNone);

   864 

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

   866 	test(reqStat==KRequestPending);

   867 //	Now cancel the outstanding request

   868 	TheFs.NotifyChangeCancel(reqStat);

   869 	User::WaitForRequest(reqStat);

   870 	test(reqStat==KErrCancel);

   871 

   872 //	Now do much the same with directory monitoring

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

   874 	TheFs.RmDir(path);

   875 

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

   877 	test(reqStat==KRequestPending);

   878 

   879 	TheFs.MkDir(path);

   880 	test(r==KErrNone);

   881 

   882 	User::WaitForRequest(reqStat);

   883 	test(reqStat==KErrNone);

   884 

   885 	TheFs.RmDir(path);

   886 	test(r==KErrNone);

   887 

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

   889 	test(r==KErrNone);

   890 	test(reqStat==KRequestPending);

   891 

   892 //	Now cancel the outstanding request

   893 	TheFs.NotifyChangeCancel(reqStat);

   894 	User::WaitForRequest(reqStat);

   895 	test(reqStat==KErrCancel);

   896 

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

   898 	test(r==KErrNone);

   899 	test(reqStat==KRequestPending);

   900 

   901 //	Get a separate thread to create the directory

   902 	RThread thread;

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

   904 	TRequestStatus thrdStat(KRequestPending);

   905 	thread.Logon(thrdStat);

   906 	thread.Resume();

   907 	thread.Close();

   908 

   909 	User::WaitForRequest(thrdStat);

   910 	test(thrdStat==KErrNone);

   911 	User::WaitForRequest(reqStat);

   912 	test(reqStat==KErrNone);

   913 

   914 	TheFs.RmDir(path);

   915 	test(r==KErrNone);

   916 

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

   918 //	non existent directory that contains it is created

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

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

   921 	test(r==KErrNone);

   922 	test(reqStat==KRequestPending);

   923 

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

   925 	thread.Logon(thrdStat);

   926 	thread.Resume();

   927 	thread.Close();

   928 

   929 	User::WaitForRequest(thrdStat);

   930 	test(thrdStat==KErrNone);

   931 	test(reqStat==KRequestPending);

   932 

   933 //	Now get a thread to create the file

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

   935 	thread.Logon(thrdStat);

   936 	thread.Resume();

   937 	User::WaitForRequest(thrdStat);

   938 	test(thrdStat==KErrNone);

   939 	thread.Close();

   940 

   941 	User::WaitForRequest(reqStat);

   942 	test(reqStat==KErrNone);

   943 

   944 	TheFs.Delete(path);

   945 	test(r==KErrNone);

   946 

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

   948 	test(r==KErrNone);

   949 	test(reqStat==KRequestPending);

   950 

   951 //	Now cancel the outstanding request

   952 	TheFs.NotifyChangeCancel(reqStat);

   953 	User::WaitForRequest(reqStat);

   954 	test(reqStat==KErrCancel);

   955 

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

   957 	TheFs.RmDir(path);

   958 	test(r==KErrNone);

   959 	}

   960 

   961 

   962 static void Test8()

   963 //

   964 // Test extended notification of an entry change

   965 //

   966 	{

   967 //	Test notification of an entry change in directory F32-TST

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

   969 	TRequestStatus reqStat(KRequestPending);

   970 	TRequestStatus thrdStat(KRequestPending);

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

   972 

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

   974 	test(reqStat==KRequestPending);

   975 	RThread thread;

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

   977 	test(r==KErrNone);

   978 	thread.Logon(thrdStat);

   979 	thread.Resume();

   980 	User::WaitForRequest(thrdStat);

   981 	test(thrdStat==KErrNone);

   982 	User::WaitForRequest(reqStat);

   983 	test(reqStat==KErrNone);

   984 	thread.Close();

   985 

   986 //	Repeat the test

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

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

   989 	test(reqStat==KRequestPending);

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

   991 	test(r==KErrNone);

   992 	thread.Logon(thrdStat);

   993 	thread.Resume();

   994 	User::WaitForRequest(thrdStat);

   995 	test(thrdStat==KErrNone);

   996 	User::WaitForRequest(reqStat);

   997 	test(reqStat==KErrNone);

   998 	thread.Close();

   999 

  1000 //	Test it can be cancelled

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

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

  1003 	test(reqStat==KRequestPending);

  1004 	TheFs.NotifyChangeCancel();

  1005 	User::WaitForRequest(reqStat);

  1006 	test(reqStat==KErrCancel);

  1007 

  1008 //	Test it can be notified again

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

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

  1011 	test(reqStat==KRequestPending);

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

  1013 	test(r==KErrNone);

  1014 	thread.Logon(thrdStat);

  1015 	thread.Resume();

  1016 	User::WaitForRequest(thrdStat);

  1017 	test(thrdStat==KErrNone);

  1018 	User::WaitForRequest(reqStat);

  1019 	test(reqStat==KErrNone);

  1020 	thread.Close();

  1021 

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

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

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

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

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

  1027 	test((r==KErrNone)||(r==KErrAlreadyExists));

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

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

  1030 	test(reqStat==KRequestPending);

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

  1032 	test(r==KErrNone);

  1033 	thread.Logon(thrdStat);

  1034 	thread.Resume();

  1035 	User::WaitForRequest(thrdStat);

  1036 	test(thrdStat==KErrNone);

  1037 	User::After(500000);

  1038 	thread.Close();

  1039 	test(reqStat==KRequestPending);

  1040 	TheFs.NotifyChangeCancel();

  1041 	User::WaitForRequest(reqStat);

  1042 	test(reqStat==KErrCancel);

  1043 

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

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

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

  1047 	test(reqStat==KRequestPending);

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

  1049 	test(r==KErrNone);

  1050 	thread.Logon(thrdStat);

  1051 	thread.Resume();

  1052 	User::WaitForRequest(thrdStat);

  1053 	test(thrdStat==KErrNone);

  1054 	User::WaitForRequest(reqStat);

  1055 	test(reqStat==KErrNone);

  1056 	thread.Close();

  1057 

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

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

  1060 	test(reqStat==KRequestPending);

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

  1062 	test(r==KErrNone);

  1063 	thread.Logon(thrdStat);

  1064 	thread.Resume();

  1065 	User::WaitForRequest(thrdStat);

  1066 	test(thrdStat==KErrNone);

  1067 	User::WaitForRequest(reqStat);

  1068 	test(reqStat==KErrNone);

  1069 	thread.Close();

  1070 

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

  1072 	test(reqStat==KRequestPending);

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

  1074 	test(r==KErrNone);

  1075 	User::WaitForRequest(reqStat);

  1076 	test(reqStat==KErrNone);

  1077 

  1078 

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

  1080 	test(r==KErrNone);

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

  1082 	test(r==KErrNone);

  1083 

  1084 //	Test again that notification doesn't occur above the subdirectory being monitored

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

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

  1087 	test((r==KErrNone)||(r==KErrAlreadyExists));

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

  1089 

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

  1091 	test(reqStat==KRequestPending);

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

  1093 	test(r==KErrNone);

  1094 	thread.Logon(thrdStat);

  1095 	thread.Resume();

  1096 	User::WaitForRequest(thrdStat);

  1097 	test(thrdStat==KErrNone);

  1098 	User::After(500000);

  1099 	thread.Close();

  1100 	test(reqStat==KRequestPending);

  1101 	TheFs.NotifyChangeCancel();

  1102 	User::WaitForRequest(reqStat);

  1103 	test(reqStat==KErrCancel);

  1104 

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

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

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

  1108 	test(reqStat==KRequestPending);

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

  1110 	test(r==KErrNone);

  1111 	User::WaitForRequest(reqStat);

  1112 	test(reqStat==KErrNone);

  1113 

  1114 	RFile file;

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

  1116 	test(r==KErrNone);

  1117 	file.Close();

  1118 

  1119 //	Test notification on a specific file

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

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

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

  1123 	test(reqStat==KRequestPending);

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

  1125 	test(r==KErrNone);

  1126 	thread.Logon(thrdStat);

  1127 	thread.Resume();

  1128 	User::WaitForRequest(thrdStat);

  1129 	test(thrdStat==KErrNone);

  1130 	User::WaitForRequest(reqStat);

  1131 	test(reqStat==KErrNone);

  1132 	thread.Close();

  1133 

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