|
1 // Copyright (c) 1998-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_hungfs.cpp |
|
15 // this test will either run with a secure mmc or will simulate a |
|
16 // mmc card. |
|
17 // |
|
18 // |
|
19 |
|
20 |
|
21 #include <f32file.h> |
|
22 #include <e32test.h> |
|
23 #include "t_server.h" |
|
24 |
|
25 GLDEF_D RTest test(_L("T_HUNGFS")); |
|
26 GLREF_D RFs TheFs; |
|
27 |
|
28 LOCAL_D RFile SubFile1; |
|
29 LOCAL_D TInt HungReturnCodeC; |
|
30 |
|
31 LOCAL_D RSemaphore HungSemaphoreC; |
|
32 LOCAL_D TInt HungReturnCodeNC; |
|
33 LOCAL_D RSemaphore HungSemaphoreNC; |
|
34 |
|
35 GLREF_C void Format(TInt aDrive); |
|
36 |
|
37 LOCAL_D const TInt KControlIoLockMount=5; |
|
38 LOCAL_D const TInt KControlIoClearLockMount=6; |
|
39 LOCAL_D const TInt KControlIoCNotifier=7; |
|
40 LOCAL_D const TInt KControlIoClearCNotifier=8; |
|
41 |
|
42 LOCAL_D const TInt KControlIoCancelNCNotifier=KMaxTInt-1; |
|
43 |
|
44 LOCAL_D TBool isSecureMmc; |
|
45 LOCAL_D TFileName gLockedPath; |
|
46 LOCAL_D TFileName gLockedBase; |
|
47 LOCAL_D TInt gLockedDrive; |
|
48 GLREF_D TFileName gSessionPath; |
|
49 LOCAL_D TInt gSessionDrive; |
|
50 |
|
51 TBuf8<16> KPassword8=_L8("abc"); |
|
52 TBuf16<8> KPassword=_L("abc"); |
|
53 _LIT(File1,"file1"); |
|
54 _LIT(File2,"file2"); |
|
55 _LIT(Dir1,"\\dir1\\"); |
|
56 _LIT(NotifyDir,"\\not\\"); |
|
57 _LIT(NotifyDir2,"\\abc\\"); |
|
58 _LIT(HungDirNC,"\\hungnc\\"); |
|
59 _LIT(HungDirC,"\\hungc\\"); |
|
60 |
|
61 LOCAL_D const TInt KHeapSize=0x2000; |
|
62 |
|
63 struct SNonCriticalInfo |
|
64 { |
|
65 TBool iSameSession; |
|
66 TBool iUseRFile; |
|
67 }; |
|
68 |
|
69 LOCAL_C TInt ThreadFunctionNC(TAny* aInfo) |
|
70 // |
|
71 // Thread entry point to put up non-critical notifier |
|
72 // |
|
73 { |
|
74 RFs fs; |
|
75 TInt r; |
|
76 |
|
77 TBuf8<8> mmcBuf; |
|
78 // pad out password if using lockable mmc |
|
79 if(isSecureMmc) |
|
80 { |
|
81 TUint8 pBuf[]={0x61,0x00,0x62,0x00,0x63,00}; |
|
82 mmcBuf.SetLength(6); |
|
83 for(TInt i=0;i<6;++i) |
|
84 mmcBuf[i]=pBuf[i]; |
|
85 } |
|
86 |
|
87 SNonCriticalInfo* info=NULL; |
|
88 if(aInfo!=NULL) |
|
89 info=(SNonCriticalInfo*)aInfo; |
|
90 |
|
91 r=fs.Connect(); |
|
92 |
|
93 if(isSecureMmc) |
|
94 { |
|
95 if(info && info->iSameSession) |
|
96 r=TheFs.LockDrive(gLockedDrive,NULL,mmcBuf,EFalse); |
|
97 else |
|
98 { |
|
99 r=fs.LockDrive(gLockedDrive,NULL,mmcBuf,EFalse); |
|
100 RDebug::Print(_L("l=%d"),r); |
|
101 } |
|
102 } |
|
103 else |
|
104 { |
|
105 if(info && info->iSameSession) |
|
106 r=TheFs.ControlIo(gLockedDrive,KControlIoLockMount,KPassword8); |
|
107 else |
|
108 r=fs.ControlIo(gLockedDrive,KControlIoLockMount,KPassword8); |
|
109 } |
|
110 // UserSvr::ForceRemountMedia(ERemovableMedia0); |
|
111 User::After(300000); |
|
112 HungSemaphoreNC.Signal(); |
|
113 |
|
114 TFileName hungDir=gLockedBase; |
|
115 hungDir+=HungDirNC; |
|
116 if(info && info->iSameSession) |
|
117 r=TheFs.RmDir(hungDir); |
|
118 else if(info && info->iSameSession && info->iUseRFile) |
|
119 { |
|
120 TBuf8<16> buf=_L8("abc"); |
|
121 r=SubFile1.Write(buf); |
|
122 } |
|
123 else |
|
124 { |
|
125 r=fs.RmDir(hungDir); |
|
126 RDebug::Print(_L("rd=%d"),r); |
|
127 } |
|
128 HungReturnCodeNC=r; |
|
129 |
|
130 if(isSecureMmc) |
|
131 { |
|
132 r=fs.UnlockDrive(gLockedDrive,mmcBuf,EFalse); |
|
133 r=fs.ClearPassword(gLockedDrive,mmcBuf); |
|
134 } |
|
135 else |
|
136 r=fs.ControlIo(gLockedDrive,KControlIoClearLockMount,KPassword8); |
|
137 |
|
138 HungSemaphoreNC.Signal(); |
|
139 |
|
140 fs.Close(); |
|
141 |
|
142 return(KErrNone); |
|
143 } |
|
144 |
|
145 LOCAL_C TInt ThreadFunctionC(TAny* aDrive) |
|
146 // |
|
147 // Thread entry point to put up a critical notifier |
|
148 // |
|
149 { |
|
150 RFs fs; |
|
151 TInt r=fs.Connect(); |
|
152 test(r==KErrNone); |
|
153 |
|
154 TInt drive; |
|
155 #if defined(__WINS__) |
|
156 drive=EDriveY; |
|
157 #else |
|
158 drive=EDriveC; |
|
159 #endif |
|
160 // can only get critcal notifer up using ControIo |
|
161 // assumes fat file system running on one of the drives named below |
|
162 r=fs.ControlIo(drive,KControlIoCNotifier); |
|
163 |
|
164 TBool isRemovable=*(TBool*)aDrive; |
|
165 TFileName hungDir=(_L("?:")); |
|
166 #if defined(__WINS__) |
|
167 if(isRemovable) |
|
168 hungDir[0]=(TText)('A'+EDriveX); |
|
169 else |
|
170 hungDir[0]=(TText)('A'+EDriveY); |
|
171 #else |
|
172 if(isRemovable) |
|
173 hungDir[0]=(TText)('A'+EDriveD); |
|
174 else |
|
175 hungDir[0]=(TText)('A'+EDriveC); |
|
176 #endif |
|
177 hungDir+=HungDirC; |
|
178 r=fs.RmDir(hungDir); |
|
179 r=fs.MkDir(hungDir); |
|
180 HungReturnCodeC=r; |
|
181 |
|
182 r=fs.ControlIo(drive,KControlIoClearCNotifier); |
|
183 |
|
184 HungSemaphoreC.Signal(); |
|
185 r=fs.RmDir(hungDir); |
|
186 fs.Close(); |
|
187 return(KErrNone); |
|
188 } |
|
189 |
|
190 LOCAL_C void PutNonCriticalNotifier(TAny* aInfo,RThread& aThread) |
|
191 // |
|
192 // put up a non-critical notifier on a removable media |
|
193 // |
|
194 { |
|
195 TInt r=aThread.Create(_L("ThreadNC"),ThreadFunctionNC,KDefaultStackSize,KMinHeapSize,KMinHeapSize,aInfo); |
|
196 test(r==KErrNone); |
|
197 aThread.SetPriority(EPriorityMore); |
|
198 aThread.Resume(); |
|
199 HungSemaphoreNC.Wait(); |
|
200 User::After(1000000); |
|
201 |
|
202 } |
|
203 |
|
204 LOCAL_C void PutCriticalNotifier(TBool aBool,RThread& aThread) |
|
205 // |
|
206 // put up a critical notifier on the specified drive |
|
207 // |
|
208 { |
|
209 TInt r=aThread.Create(_L("ThreadC"),ThreadFunctionC,KDefaultStackSize,KMinHeapSize,KMinHeapSize,&aBool); |
|
210 test(r==KErrNone); |
|
211 aThread.SetPriority(EPriorityMore); |
|
212 aThread.Resume(); |
|
213 User::After(1000000); |
|
214 } |
|
215 |
|
216 void TestNotifiers() |
|
217 // |
|
218 // Test non-critical notifier is cancelled when the critical notifier is put up |
|
219 // Needs to be carried out on platform with password notifier which handles requests |
|
220 // asynchronously and uses CAtaDisk in fat file system on c: drive ie. not internal ram |
|
221 // drive |
|
222 // |
|
223 { |
|
224 test.Next(_L("TestNotifiers")); |
|
225 if(isSecureMmc) |
|
226 return; |
|
227 RThread threadNC,threadC; |
|
228 PutNonCriticalNotifier(NULL,threadNC); |
|
229 PutCriticalNotifier(EFalse,threadC); |
|
230 // get rid of critical notifier |
|
231 test.Printf(_L("Press cancel on for critcal notifier\n")); |
|
232 test.Printf(_L("Press any character\n")); |
|
233 test.Getch(); |
|
234 TRequestStatus deathStat; |
|
235 threadNC.Logon( deathStat ); |
|
236 HungSemaphoreC.Wait(); |
|
237 // test(HungReturnCodeNC==KErrAbort); |
|
238 TRequestStatus deathStat2; |
|
239 threadC.Logon(deathStat2); |
|
240 HungSemaphoreNC.Wait(); |
|
241 //test(HungReturnCodeNC==KErrLocked); |
|
242 User::WaitForRequest(deathStat2); |
|
243 threadNC.Close(); |
|
244 threadC.Close(); |
|
245 } |
|
246 |
|
247 void TestCriticalFunctions() |
|
248 // |
|
249 // test that only a subset of functions are supported when the critical notifier is up |
|
250 // |
|
251 { |
|
252 test.Next(_L("test functions supported with critical notifier")); |
|
253 // used for EFsSubClose |
|
254 RFile file; |
|
255 TInt r=file.Create(TheFs,File1,EFileShareAny|EFileWrite); |
|
256 test(r==KErrNone||KErrAlreadyExists); |
|
257 if(r==KErrAlreadyExists) |
|
258 { |
|
259 r=file.Open(TheFs,File1,EFileShareAny|EFileWrite); |
|
260 test(r==KErrNone); |
|
261 } |
|
262 TBuf8<16> buf=_L8("abcdefghijklmnop"); |
|
263 r=file.Write(buf); |
|
264 test(r==KErrNone); |
|
265 |
|
266 r=TheFs.MkDir(NotifyDir); |
|
267 test(r==KErrNone); |
|
268 |
|
269 RThread thread; |
|
270 PutCriticalNotifier(ETrue,thread); |
|
271 |
|
272 // test functions that are supported with critical notifier |
|
273 // EFsNotifyChange |
|
274 test.Next(_L("test functions that are supported with critical notifier")); |
|
275 TRequestStatus status; |
|
276 TheFs.NotifyChange(ENotifyAll,status); |
|
277 test(status==KRequestPending); |
|
278 // EFsNotifyChangeCancel |
|
279 TheFs.NotifyChangeCancel(); |
|
280 test(status==KErrCancel); |
|
281 // EFsNotifyChangeEx |
|
282 TheFs.NotifyChange(ENotifyAll,status,gSessionPath); |
|
283 test(status==KRequestPending); |
|
284 // EFsNotifyChangeCancelEx |
|
285 TheFs.NotifyChangeCancel(status); |
|
286 test(status==KErrCancel); |
|
287 // EFsSubClose |
|
288 // difficult to test properly because this does not return an error value |
|
289 file.Close(); |
|
290 |
|
291 // test that notifications are not completed when a critical notifier completes |
|
292 test.Next(_L("test notifications not completed")); |
|
293 TheFs.NotifyChange(ENotifyDisk,status); |
|
294 test(status==KRequestPending); |
|
295 TRequestStatus status2; |
|
296 TheFs.NotifyChange(ENotifyDir,status2,NotifyDir); |
|
297 test(status2==KRequestPending); |
|
298 |
|
299 // test some functions that are not supported when critcical notifier up |
|
300 // EFsFileOpen |
|
301 test.Next(_L("test functions that are not supported with critical notifier")); |
|
302 r=file.Open(TheFs,File2,EFileShareAny); |
|
303 test(r==KErrInUse); |
|
304 // EFsFileCreate |
|
305 r=file.Create(TheFs,File2,EFileShareAny); |
|
306 test(r==KErrInUse); |
|
307 // EFsMkDir |
|
308 r=TheFs.MkDir(Dir1); |
|
309 test(r==KErrInUse); |
|
310 // EFsVolume |
|
311 TVolumeInfo info; |
|
312 r=TheFs.Volume(info,gSessionDrive); |
|
313 test(r==KErrInUse); |
|
314 |
|
315 // get rid of critical notifier |
|
316 test.Printf(_L("Press escape on the critical notifier\n")); |
|
317 TRequestStatus deathStat; |
|
318 thread.Logon(deathStat); |
|
319 HungSemaphoreC.Wait(); |
|
320 test(HungReturnCodeC==KErrAbort); |
|
321 User::WaitForRequest(deathStat); |
|
322 thread.Close(); |
|
323 |
|
324 // test notifiers have not gone off |
|
325 test(status==KRequestPending&&status2==KRequestPending); |
|
326 |
|
327 // test that notification setup on default drive has had the drive changed |
|
328 // to * since the critical notifier was up |
|
329 TFileName notDir=gLockedBase; |
|
330 notDir+=NotifyDir; |
|
331 r=TheFs.MkDir(notDir); |
|
332 test(r==KErrNone); |
|
333 test(status==KRequestPending&&status2==KErrNone); |
|
334 TheFs.NotifyChangeCancel(); |
|
335 test(status==KErrCancel); |
|
336 r=TheFs.Delete(File1); |
|
337 test(r==KErrNone); |
|
338 r=TheFs.RmDir(notDir); |
|
339 test(r==KErrNone); |
|
340 r=TheFs.RmDir(NotifyDir); |
|
341 test(r==KErrNone); |
|
342 } |
|
343 |
|
344 void TestParsingFunctions() |
|
345 // |
|
346 // Test functions that use Parse* and Validate* functions with |
|
347 // non-critical notifier up |
|
348 // |
|
349 { |
|
350 test.Next(_L("TestParsingFunctions")); |
|
351 RThread thread; |
|
352 PutNonCriticalNotifier(NULL,thread); |
|
353 |
|
354 // test on same drive as notifier |
|
355 test.Next(_L("test parsing functions on same drive")); |
|
356 // Using ParseSubst |
|
357 TFileName dir=gLockedBase; |
|
358 dir+=Dir1; |
|
359 TInt r=TheFs.MkDir(dir); |
|
360 test(r==KErrInUse); |
|
361 TFileName file=gLockedPath; |
|
362 file+=File1; |
|
363 RFile f; |
|
364 r=f.Create(TheFs,file,EFileShareAny); |
|
365 test(r==KErrInUse); |
|
366 // Using ParsePathPtr0 |
|
367 r=TheFs.SetSubst(gLockedPath,EDriveO); |
|
368 test(r==KErrInUse); |
|
369 // ValidateDrive |
|
370 TVolumeInfo info; |
|
371 r=TheFs.Volume(info,gLockedDrive); |
|
372 test(r==KErrInUse); |
|
373 |
|
374 TFileName origSessPath; |
|
375 r=TheFs.SessionPath(origSessPath); |
|
376 test(r==KErrNone); |
|
377 |
|
378 // test these work ok |
|
379 r=TheFs.SetSessionPath(gLockedPath); |
|
380 test(r==KErrNone); |
|
381 r=TheFs.SetSessionPath(origSessPath); |
|
382 test(r==KErrNone); |
|
383 |
|
384 // test on different drive from notifier - the session path |
|
385 test.Next(_L("test parsing functions on a different drive")); |
|
386 // Using ParseSubst |
|
387 r=TheFs.MkDir(Dir1); |
|
388 test(r==KErrNone); |
|
389 r=TheFs.RmDir(Dir1); |
|
390 test(r==KErrNone); |
|
391 r=f.Create(TheFs,File1,EFileShareAny); |
|
392 test(r==KErrNone); |
|
393 f.Close(); |
|
394 r=TheFs.Delete(File1); |
|
395 test(r==KErrNone); |
|
396 // Using ParsePathPtr0 |
|
397 r=TheFs.SetSubst(gSessionPath,EDriveO); |
|
398 test(r==KErrNone); |
|
399 r=TheFs.SetSubst(_L(""),EDriveO); |
|
400 test(r==KErrNone); |
|
401 // ValidateDrive |
|
402 r=TheFs.Volume(info,gSessionDrive); |
|
403 test(r==KErrNone); |
|
404 |
|
405 // get rid of non-critical notifier |
|
406 test.Printf(_L("Enter %S on the notifier\n"),&KPassword); |
|
407 |
|
408 TRequestStatus deathStat; |
|
409 thread.Logon( deathStat ); |
|
410 HungSemaphoreNC.Wait(); |
|
411 test(HungReturnCodeNC==KErrNotFound); |
|
412 User::WaitForRequest( deathStat ); |
|
413 thread.Close(); |
|
414 |
|
415 // test.End(); |
|
416 } |
|
417 |
|
418 void TestTFsFunctions() |
|
419 // |
|
420 // test functions that do not use the Parse* and Validate* functions |
|
421 // |
|
422 { |
|
423 test.Next(_L("TestTFsFunctions")); |
|
424 TFileName sessName,lockedName; |
|
425 TInt r=TheFs.FileSystemName(sessName,gSessionDrive); |
|
426 test(r==KErrNone); |
|
427 r=TheFs.FileSystemName(lockedName,gLockedDrive); |
|
428 test(r==KErrNone); |
|
429 |
|
430 RThread thread; |
|
431 PutNonCriticalNotifier(NULL,thread); |
|
432 |
|
433 // test functions on hung drive - should return KErrInUse |
|
434 test.Next(_L("test TFs functions on hung drive")); |
|
435 // TFsDismountFileSystem |
|
436 r=TheFs.DismountFileSystem(lockedName,gLockedDrive); |
|
437 test(r==KErrInUse); |
|
438 // TFsMountFileSystem |
|
439 r=TheFs.MountFileSystem(lockedName,gLockedDrive); |
|
440 test(r==KErrInUse); |
|
441 // TFsFileSystemName |
|
442 r=TheFs.FileSystemName(lockedName,gLockedDrive); |
|
443 test(r==KErrInUse); |
|
444 |
|
445 // test functions on drive other than hung drive |
|
446 test.Next(_L("test TFs functions on drive that is not hung")); |
|
447 // TFsDismountFileSystem |
|
448 #if defined(__WINS__) |
|
449 // bug in TFsMountFileSystem which needs to be fixed before running on EDriveC on WINS |
|
450 if(gSessionDrive!=EDriveC) |
|
451 { |
|
452 #endif |
|
453 r=TheFs.DismountFileSystem(sessName,gSessionDrive); |
|
454 test(r==KErrNone); |
|
455 // TFsMountFileSystem |
|
456 r=TheFs.MountFileSystem(sessName,gSessionDrive); |
|
457 test(r==KErrNone); |
|
458 #if defined(__WINS__) |
|
459 } |
|
460 #endif |
|
461 // TFsFileSystemName |
|
462 TFileName fsName; |
|
463 r=TheFs.FileSystemName(fsName,gSessionDrive); |
|
464 test(r==KErrNone); |
|
465 test(fsName==sessName); |
|
466 |
|
467 // test functions that fail on all drives |
|
468 test.Next(_L("test TFs functions that fail on all drives")); |
|
469 // TFsListOpenFiles |
|
470 CFileList* list=NULL; |
|
471 TOpenFileScan fileScan(TheFs); |
|
472 TRAP(r,fileScan.NextL(list)); |
|
473 test(r==KErrInUse); |
|
474 |
|
475 // test functions that should pass on any drive |
|
476 test.Next(_L("test TFs functions that pass on all drives")); |
|
477 // TFsSetDefaultPath |
|
478 // TFsSetSessionPath |
|
479 r=TheFs.SetSessionPath(gLockedPath); |
|
480 test(r==KErrNone); |
|
481 r=TheFs.SetSessionPath(gSessionPath); |
|
482 test(r==KErrNone); |
|
483 |
|
484 // get rid of non-critical notifier |
|
485 test.Printf(_L("Enter %S on the notifier\n"),&KPassword); |
|
486 TRequestStatus deathStat; |
|
487 thread.Logon( deathStat ); |
|
488 HungSemaphoreNC.Wait(); |
|
489 test(HungReturnCodeNC==KErrNotFound); |
|
490 User::WaitForRequest( deathStat ); |
|
491 thread.Close(); |
|
492 // test.End(); |
|
493 } |
|
494 |
|
495 |
|
496 void TestSubsessions() |
|
497 // |
|
498 // test subsession functions |
|
499 // |
|
500 { |
|
501 test.Next(_L("TestSubsessions")); |
|
502 RThread thread; |
|
503 PutNonCriticalNotifier(NULL,thread); |
|
504 |
|
505 // test that subsessions cannot be opened on a hung drive |
|
506 test.Next(_L("test subsessions cannot be opened on a hung drive")); |
|
507 // EFsFileCreate |
|
508 RFile file; |
|
509 TFileName fileName=gLockedPath; |
|
510 fileName+=File1; |
|
511 TInt r=file.Create(TheFs,fileName,EFileShareAny); |
|
512 test(r==KErrInUse); |
|
513 // EFsFormatOpen |
|
514 RFormat format; |
|
515 TInt count; |
|
516 r=format.Open(TheFs,gLockedPath,EHighDensity,count); |
|
517 test(r==KErrInUse); |
|
518 // EFsDirOpen |
|
519 RDir dir; |
|
520 r=dir.Open(TheFs,gLockedPath,KEntryAttMaskSupported); |
|
521 test(r==KErrInUse); |
|
522 // EFsRawDiskOpen |
|
523 RRawDisk raw; |
|
524 r=raw.Open(TheFs,gLockedDrive); |
|
525 test(r==KErrInUse); |
|
526 |
|
527 // get rid of non-critical notifier |
|
528 test.Printf(_L("Enter %S on the notifier\n"),&KPassword); |
|
529 TRequestStatus deathStat; |
|
530 thread.Logon( deathStat ); |
|
531 HungSemaphoreNC.Wait(); |
|
532 test(HungReturnCodeNC==KErrNotFound); |
|
533 User::WaitForRequest( deathStat ); |
|
534 thread.Close(); |
|
535 |
|
536 // now open the subsessions |
|
537 r=file.Create(TheFs,fileName,EFileShareAny); |
|
538 test(r==KErrNone||KErrAlreadyExists); |
|
539 if(r==KErrAlreadyExists) |
|
540 { |
|
541 r=file.Open(TheFs,fileName,EFileShareAny); |
|
542 test(r==KErrNone); |
|
543 } |
|
544 r=dir.Open(TheFs,gLockedPath,KEntryAttMaskSupported); |
|
545 test(r==KErrNone); |
|
546 |
|
547 // put notifier back up |
|
548 PutNonCriticalNotifier(NULL,thread); |
|
549 |
|
550 // test subsession operations fail on a hung drive |
|
551 test.Next(_L("test subsession operations fail on a hung drive")); |
|
552 // EFsFileRead |
|
553 TBuf8<16> readBuf; |
|
554 r=file.Read(readBuf); |
|
555 test(r==KErrInUse); |
|
556 // subsession should be able to be closed ok |
|
557 file.Close(); |
|
558 // EFsDelete |
|
559 r=TheFs.Delete(fileName); |
|
560 test(r==KErrInUse); |
|
561 // EFsDirRead |
|
562 TEntry entry; |
|
563 r=dir.Read(entry); |
|
564 test(r==KErrInUse); |
|
565 // subsession should be able to be closed ok |
|
566 dir.Close(); |
|
567 |
|
568 // not going to test operations on a drive the is not hung |
|
569 // since this will be tested on other tests |
|
570 |
|
571 // get rid of non-critical notifier |
|
572 test.Printf(_L("Enter %S on the notifier\n"),&KPassword); |
|
573 thread.Logon( deathStat ); |
|
574 HungSemaphoreNC.Wait(); |
|
575 test(HungReturnCodeNC==KErrNotFound); |
|
576 User::WaitForRequest( deathStat ); |
|
577 thread.Close(); |
|
578 |
|
579 r=TheFs.Delete(fileName); |
|
580 test(r==KErrNone); |
|
581 // test.End(); |
|
582 } |
|
583 |
|
584 void TestSameSession() |
|
585 // |
|
586 // Test functions that can and cannot be handled from same session when notifier is up |
|
587 // |
|
588 { |
|
589 test.Next(_L("TestSameSession")); |
|
590 |
|
591 RFile file; |
|
592 TInt r=file.Create(TheFs,File1,EFileWrite); |
|
593 test(r==KErrNone); |
|
594 |
|
595 // put notifier up using TheFs session |
|
596 SNonCriticalInfo info={ETrue,0}; |
|
597 RThread thread; |
|
598 PutNonCriticalNotifier(&info,thread); |
|
599 |
|
600 // test critical functions can be handled |
|
601 test.Next(_L("test critical functions can be handled")); |
|
602 // EFsNotifyChange |
|
603 TRequestStatus status; |
|
604 TheFs.NotifyChange(ENotifyAll,status); |
|
605 test(status==KRequestPending); |
|
606 // EFsNotifyChangeCancel |
|
607 TheFs.NotifyChangeCancel(); |
|
608 test(status==KErrCancel); |
|
609 // EFsNotifyChange again |
|
610 TheFs.NotifyChange(ENotifyAll,status); |
|
611 test(status==KRequestPending); |
|
612 // EFsNotifyChangeCancelEx |
|
613 TheFs.NotifyChangeCancel(status); |
|
614 test(status==KErrCancel); |
|
615 // not going to test EFsSubClose |
|
616 |
|
617 // test other functions are not handled |
|
618 test.Next(_L("test other functions cannot be handled")); |
|
619 // EFsNotifyChangeEx |
|
620 TheFs.NotifyChange(ENotifyAll,status,gSessionPath); |
|
621 test(status==KErrInUse); |
|
622 TFileName defPath; |
|
623 // EFsCheckDisk |
|
624 r=TheFs.CheckDisk(gSessionPath); |
|
625 test(r==KErrInUse); |
|
626 // EFsFileWrite |
|
627 _LIT8(buffer,"abc"); |
|
628 TBuf8<8> buf(buffer); |
|
629 r=file.Write(buf); |
|
630 test(r==KErrInUse); |
|
631 |
|
632 // this file should be able to be closed |
|
633 file.Close(); |
|
634 |
|
635 // get rid of non-critical notifier |
|
636 test.Printf(_L("Enter %S on the notifier\n"),&KPassword); |
|
637 |
|
638 TRequestStatus deathStat; |
|
639 thread.Logon( deathStat ); |
|
640 HungSemaphoreNC.Wait(); |
|
641 test(HungReturnCodeNC==KErrNotFound); |
|
642 User::WaitForRequest( deathStat ); |
|
643 thread.Close(); |
|
644 |
|
645 r=TheFs.Delete(File1); |
|
646 test(r==KErrNone); |
|
647 // test.End(); |
|
648 } |
|
649 |
|
650 void TestSameSubSession() |
|
651 // |
|
652 // test hung file server with same subsession |
|
653 // |
|
654 { |
|
655 _LIT(file1Name,"\\SubFile1"); |
|
656 _LIT(file2Name,"\\SubFile2"); |
|
657 _LIT(file3Name,"\\SubFile3"); |
|
658 _LIT(file4Name,"\\SubFile4"); |
|
659 TFileName origSession; |
|
660 TInt r=TheFs.SessionPath(origSession); |
|
661 test(r==KErrNone); |
|
662 TFileName file1Path(gLockedBase); |
|
663 file1Path+=file1Name; |
|
664 TFileName file2Path(file2Name); |
|
665 TFileName file3Path(gLockedBase); |
|
666 file3Path+=file3Name; |
|
667 TFileName file4Path(file4Name); |
|
668 // create file that will be used to hang file server |
|
669 r=SubFile1.Create(TheFs,file1Path,EFileWrite); |
|
670 test(r==KErrNone); |
|
671 // create file with same session but on different drive |
|
672 RFile subfile2; |
|
673 r=subfile2.Create(TheFs,file2Path,EFileWrite); |
|
674 test(r==KErrNone); |
|
675 // create file on unhung drive and with different session |
|
676 RFs fs2; |
|
677 r=fs2.Connect(); |
|
678 test(r==KErrNone); |
|
679 r=fs2.SetSessionPath(origSession); |
|
680 test(r==KErrNone); |
|
681 RFile subfile3; |
|
682 r=subfile3.Create(fs2,file3Path,EFileWrite); |
|
683 test(r==KErrNone); |
|
684 // create file on unhung drive and with different session |
|
685 RFile subfile4; |
|
686 r=subfile4.Create(fs2,file4Path,EFileWrite); |
|
687 test(r==KErrNone); |
|
688 // in a different thread cause the server to hang using one of the File1 subsession |
|
689 // put notifier up using TheFs session |
|
690 SNonCriticalInfo info={ETrue,ETrue}; |
|
691 RThread thread; |
|
692 PutNonCriticalNotifier(&info,thread); |
|
693 test.Next(_L("test writing to files with hung file server")); |
|
694 // check only file4 can be written to |
|
695 _LIT8(buffer,"abc"); |
|
696 TBuf8<8> buf(buffer); |
|
697 // File1 caused hung file server |
|
698 r=SubFile1.Write(buf); |
|
699 test(r==KErrInUse); |
|
700 // file2 is same session as subsession that caused hung file server |
|
701 r=subfile2.Write(buf); |
|
702 test(r==KErrInUse); |
|
703 // file3 is opened on hung drive |
|
704 r=subfile3.Write(buf); |
|
705 test(r==KErrInUse); |
|
706 // file4 should be ok |
|
707 r=subfile4.Write(buf); |
|
708 test(r==KErrNone); |
|
709 // hard to test EFsSubClose since does not return an error value |
|
710 test.Next(_L("test closing down the subsessions")); |
|
711 subfile4.Close(); |
|
712 // calling close on the same subsession as is hung will cause this subsession |
|
713 // to be closed once the original request is completed |
|
714 SubFile1.Close(); |
|
715 subfile2.Close(); |
|
716 |
|
717 // get rid of non-critical notifier |
|
718 test.Printf(_L("Enter %S on the notifier\n"),&KPassword); |
|
719 TRequestStatus deathStat; |
|
720 thread.Logon( deathStat ); |
|
721 HungSemaphoreNC.Wait(); |
|
722 test(HungReturnCodeNC==KErrNotFound); |
|
723 User::WaitForRequest( deathStat ); |
|
724 thread.Close(); |
|
725 // close remaining files |
|
726 subfile3.Close(); |
|
727 // clean up |
|
728 fs2.Close(); |
|
729 r=TheFs.Delete(file1Path); |
|
730 test(r==KErrNone); |
|
731 r=TheFs.Delete(file2Path); |
|
732 test(r==KErrNone); |
|
733 r=TheFs.Delete(file3Path); |
|
734 test(r==KErrNone); |
|
735 r=TheFs.Delete(file4Path); |
|
736 test(r==KErrNone); |
|
737 } |
|
738 |
|
739 void TestExtendedNotifier() |
|
740 // |
|
741 // |
|
742 // |
|
743 { |
|
744 test.Next(_L("TestExtendedNotifier")); |
|
745 // setup a notification on a removable media |
|
746 test.Next(_L("test with drive specified")); |
|
747 TFileName notDir=gLockedBase; |
|
748 notDir+=NotifyDir; |
|
749 TRequestStatus status; |
|
750 TheFs.NotifyChange(ENotifyAll,status,notDir); |
|
751 test(status==KRequestPending); |
|
752 // now do an operation on c: and test no notification |
|
753 TInt r=TheFs.MkDir(NotifyDir); |
|
754 test(r==KErrNone); |
|
755 r=TheFs.RmDir(NotifyDir); |
|
756 test(r==KErrNone); |
|
757 User::After(1000000); |
|
758 test(status==KRequestPending); |
|
759 TheFs.NotifyChangeCancel(status); |
|
760 test(status==KErrCancel); |
|
761 |
|
762 // now put up the notifier |
|
763 RThread thread; |
|
764 PutNonCriticalNotifier(NULL,thread); |
|
765 |
|
766 // repeat the above notification |
|
767 // setup a notification on a removable media - the drive should be changed |
|
768 // to * since notifier is up |
|
769 test.Next(_L("test with wildcard for drive")); |
|
770 TheFs.NotifyChange(ENotifyAll,status,notDir); |
|
771 test(status==KRequestPending); |
|
772 // test notification does not go off with wrong path |
|
773 r=TheFs.MkDir(NotifyDir2); |
|
774 test(r==KErrNone); |
|
775 r=TheFs.RmDir(NotifyDir2); |
|
776 test(r==KErrNone); |
|
777 test(status==KRequestPending); |
|
778 // now do an operation on c: and test there has been a notification |
|
779 r=TheFs.MkDir(NotifyDir); |
|
780 test(r==KErrNone); |
|
781 r=TheFs.RmDir(NotifyDir); |
|
782 test(r==KErrNone); |
|
783 User::After(1000000); |
|
784 // request should be completed this time |
|
785 test(status==KErrNone); |
|
786 |
|
787 // set up a notification on drive that is not removable |
|
788 // the path should not be changed |
|
789 test.Next(_L("test with non-removable drive")); |
|
790 TheFs.NotifyChange(ENotifyAll,status,notDir); |
|
791 test(status==KRequestPending); |
|
792 TRequestStatus status2; |
|
793 TFileName origSession; |
|
794 r=TheFs.SessionPath(origSession); |
|
795 test(r==KErrNone); |
|
796 RFs fs2; |
|
797 r=fs2.Connect(); |
|
798 test(r==KErrNone); |
|
799 r=fs2.SetSessionPath(origSession); |
|
800 test(r==KErrNone); |
|
801 _LIT(notifyDirZ,"z:\\test\\"); |
|
802 _LIT(notifyDirSess,"\\test\\"); |
|
803 // notifyDirZ already exists, create test dir in session path |
|
804 r=fs2.MkDir(notifyDirSess); |
|
805 test(r==KErrNone); |
|
806 fs2.NotifyChange(ENotifyDir,status2,notifyDirZ); |
|
807 test(status2==KRequestPending); |
|
808 TRequestStatus status3; |
|
809 fs2.NotifyChange(ENotifyDir,status3,notifyDirSess); |
|
810 test(status3==KRequestPending); |
|
811 // now delete session dir and test no notification |
|
812 r=TheFs.RmDir(notifyDirSess); |
|
813 test(r==KErrNone); |
|
814 test(status2==KRequestPending && status3==KErrNone); |
|
815 |
|
816 // get rid of non-critical notifier |
|
817 test.Printf(_L("Enter %S on the notifier\n"),&KPassword); |
|
818 TRequestStatus deathStat; |
|
819 thread.Logon( deathStat ); |
|
820 HungSemaphoreNC.Wait(); |
|
821 test(HungReturnCodeNC==KErrNotFound); |
|
822 User::WaitForRequest( deathStat ); |
|
823 thread.Close(); |
|
824 test(status==KErrNone&&status2==KErrNone); |
|
825 fs2.Close(); |
|
826 |
|
827 test.Next(_L("test extended notification with critical notifier")); |
|
828 RThread threadC; |
|
829 // put a a critical notifier |
|
830 PutCriticalNotifier(ETrue,threadC); |
|
831 // setup extended change notification on session path, drive should be changed to * |
|
832 TheFs.NotifyChange(ENotifyAll,status,NotifyDir); |
|
833 test(status==KRequestPending); |
|
834 // get rid of notifier |
|
835 test.Printf(_L("Press cancel on for critcal notifier\n")); |
|
836 threadC.Logon(deathStat); |
|
837 HungSemaphoreC.Wait(); |
|
838 User::WaitForRequest(deathStat); |
|
839 threadC.Close(); |
|
840 // test that notification has not gone off |
|
841 test(status==KRequestPending); |
|
842 // create directory on locked drive |
|
843 r=TheFs.MkDir(notDir); |
|
844 test(r==KErrNone); |
|
845 // test notifier goes off |
|
846 test(status==KErrNone); |
|
847 r=TheFs.RmDir(notDir); |
|
848 test(r==KErrNone); |
|
849 // get rid of critical notifier |
|
850 } |
|
851 |
|
852 LOCAL_C TBool TestSessionPath() |
|
853 // |
|
854 // |
|
855 // |
|
856 { |
|
857 #if defined(__WINS__) |
|
858 TInt r=TheFs.CharToDrive(gSessionPath[0],gSessionDrive); |
|
859 test(r==KErrNone); |
|
860 if(gSessionDrive==EDriveX) |
|
861 return(EFalse); |
|
862 #else |
|
863 TInt r=TheFs.CharToDrive(gSessionPath[0],gSessionDrive); |
|
864 test(r==KErrNone); |
|
865 TDriveList list; |
|
866 r=TheFs.DriveList(list); |
|
867 test(r==KErrNone); |
|
868 if((list[gSessionDrive])&KDriveAttRemovable) |
|
869 return(EFalse); |
|
870 #endif |
|
871 return(ETrue); |
|
872 } |
|
873 |
|
874 |
|
875 GLDEF_C void CallTestsL() |
|
876 // |
|
877 // Test a hung file server |
|
878 // |
|
879 { |
|
880 if(!IsTestTypeStandard()) |
|
881 return; |
|
882 |
|
883 if(!TestSessionPath()) |
|
884 { |
|
885 test.Printf(_L("Not testing on %S\n"),&gSessionPath); |
|
886 return; |
|
887 } |
|
888 #if defined(__WINS__) |
|
889 gLockedDrive=EDriveX; |
|
890 gLockedPath=_L("?:\\"); |
|
891 gLockedBase=_L("?:"); |
|
892 gLockedPath[0]=gLockedBase[0]=(TText)('A'+gLockedDrive); |
|
893 #else |
|
894 gLockedDrive=EDriveD; |
|
895 gLockedPath=_L("?:\\"); |
|
896 gLockedBase=_L("?:"); |
|
897 gLockedPath[0]=gLockedBase[0]=(TText)('A'+gLockedDrive); |
|
898 #endif |
|
899 |
|
900 test.Printf(_L("Is a secure mmc present? Press y for yes\n")); |
|
901 TChar c=test.Getch(); |
|
902 if(c=='y'||c=='Y') |
|
903 isSecureMmc=ETrue; |
|
904 else |
|
905 isSecureMmc=EFalse; |
|
906 |
|
907 TInt r=HungSemaphoreC.CreateLocal(0); |
|
908 test(r==KErrNone); |
|
909 r=HungSemaphoreNC.CreateLocal(0); |
|
910 test(r==KErrNone); |
|
911 |
|
912 // create sharable session |
|
913 TheFs.ShareAuto(); |
|
914 |
|
915 TestParsingFunctions(); |
|
916 TestTFsFunctions(); |
|
917 TestExtendedNotifier(); |
|
918 TestSubsessions(); |
|
919 // TestNotifiers(); |
|
920 TestCriticalFunctions(); |
|
921 TestSameSession(); |
|
922 TestSameSubSession(); |
|
923 |
|
924 HungSemaphoreC.Close(); |
|
925 HungSemaphoreNC.Close(); |
|
926 } |