102 // |
103 // |
103 // |
104 // |
104 { |
105 { |
105 TVolumeInfo v; |
106 TVolumeInfo v; |
106 TInt r=TheFs.Volume(v,aDrive); |
107 TInt r=TheFs.Volume(v,aDrive); |
107 test(r==KErrNone); |
108 test_KErrNone(r); |
108 return(v.iFree); |
109 return(v.iFree); |
109 } |
110 } |
110 |
111 |
111 LOCAL_C TInt64 DiskSize(TInt aDrive) |
112 LOCAL_C TInt64 DiskSize(TInt aDrive) |
112 // |
113 // |
113 // |
114 // |
114 // |
115 // |
115 { |
116 { |
116 TVolumeInfo v; |
117 TVolumeInfo v; |
117 TInt r=TheFs.Volume(v,aDrive); |
118 TInt r=TheFs.Volume(v,aDrive); |
118 test(r==KErrNone); |
119 test_KErrNone(r); |
119 return(v.iSize); |
120 return(v.iSize); |
120 } |
121 } |
121 |
122 |
122 // MinimumFileSize() - |
123 // MinimumFileSize() - |
123 // Deduces the minimum space occupied by a file by creating a file of one byte |
124 // Deduces the minimum space occupied by a file by creating a file of one byte |
124 // in length. This should equal the cluster size on FAT volumes. |
125 // in length. This should equal the cluster size on FAT volumes. |
125 // |
126 // |
126 LOCAL_C TInt MinimumFileSize(TInt aDrive) |
127 LOCAL_C TInt MinimumFileSize(TInt aDrive) |
127 { |
128 { |
128 TInt r = TheFs.Delete(KTestFile1); |
129 TInt r = TheFs.Delete(KTestFile1); |
129 test(r==KErrNone || r==KErrNotFound); |
130 test_Value(r, r == KErrNone || r==KErrNotFound); |
130 |
131 |
131 TInt64 freeSpace = FreeDiskSpace(aDrive); |
132 TInt64 freeSpace = FreeDiskSpace(aDrive); |
132 |
133 |
133 RFile file; |
134 RFile file; |
134 |
135 |
135 |
136 |
136 r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite); |
137 r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite); |
137 test(r==KErrNone); |
138 test_KErrNone(r); |
138 |
139 |
139 r = file.Write(TheBuffer,1); |
140 r = file.Write(TheBuffer,1); |
140 test(r==KErrNone); |
141 test_KErrNone(r); |
141 file.Close(); |
142 file.Close(); |
142 TInt64 newSpace = FreeDiskSpace(aDrive); |
143 TInt64 newSpace = FreeDiskSpace(aDrive); |
143 |
144 |
144 r = TheFs.Delete(KTestFile1); |
145 r = TheFs.Delete(KTestFile1); |
145 test(r==KErrNone); |
146 test_KErrNone(r); |
146 |
147 |
147 |
148 |
148 TInt64 minFileSize = freeSpace - newSpace; |
149 TInt64 minFileSize = freeSpace - newSpace; |
149 test (minFileSize >= 0); |
150 test (minFileSize >= 0); |
150 minFileSize = Max(minFileSize, 512); |
151 minFileSize = Max(minFileSize, 512); |
214 test.Printf(_L("inside init++++++++++++++++++++++++++>\n\n\n")); |
215 test.Printf(_L("inside init++++++++++++++++++++++++++>\n\n\n")); |
215 test.Printf(_L("RemovableDrive = %d\n"),RemovableDrive); |
216 test.Printf(_L("RemovableDrive = %d\n"),RemovableDrive); |
216 // initialise removable drive descriptor |
217 // initialise removable drive descriptor |
217 TChar c; |
218 TChar c; |
218 TInt r=RFs::DriveToChar(RemovableDrive,c); |
219 TInt r=RFs::DriveToChar(RemovableDrive,c); |
219 test(r==KErrNone); |
220 test_KErrNone(r); |
220 RemovableDriveBuf[0]=(TText)c; |
221 RemovableDriveBuf[0]=(TText)c; |
221 |
222 |
222 if( !LffsDrive ) |
223 if( !LffsDrive ) |
223 { |
224 { |
224 // and create the default directory |
225 // and create the default directory |
240 Format(EDriveC); |
241 Format(EDriveC); |
241 #endif |
242 #endif |
242 TheDiskSize=DiskSize(KDefaultDrive); |
243 TheDiskSize=DiskSize(KDefaultDrive); |
243 // and set the default directory |
244 // and set the default directory |
244 r=TheFs.MkDirAll(gSessionPath); |
245 r=TheFs.MkDirAll(gSessionPath); |
245 test(r==KErrNone || r==KErrAlreadyExists); |
246 test_Value(r, r == KErrNone || r==KErrAlreadyExists); |
246 |
247 |
247 r=TheFs.Delete(KFileFiller); |
248 r=TheFs.Delete(KFileFiller); |
248 test(r==KErrNone || r==KErrNotFound); |
249 test_Value(r, r == KErrNone || r==KErrNotFound); |
249 r=TheFs.Delete(KTestFile1); |
250 r=TheFs.Delete(KTestFile1); |
250 test(r==KErrNone || r==KErrNotFound); |
251 test_Value(r, r == KErrNone || r==KErrNotFound); |
251 r=TheFs.Delete(KTestFile2); |
252 r=TheFs.Delete(KTestFile2); |
252 test(r==KErrNone || r==KErrNotFound); |
253 test_Value(r, r == KErrNone || r==KErrNotFound); |
253 r=TheFs.RmDir(KTestDir1); |
254 r=TheFs.RmDir(KTestDir1); |
254 test(r==KErrNone || r==KErrNotFound); |
255 test_Value(r, r == KErrNone || r==KErrNotFound); |
255 r=TheFs.RmDir(KTestDir2); |
256 r=TheFs.RmDir(KTestDir2); |
256 test(r==KErrNone || r==KErrNotFound); |
257 test_Value(r, r == KErrNone || r==KErrNotFound); |
257 |
258 |
258 gMinFileSize = MinimumFileSize(drive); |
259 gMinFileSize = MinimumFileSize(drive); |
259 } |
260 } |
260 |
261 |
261 LOCAL_C TInt64 FillDisk(RFile& aFile,TInt64 aNewSpace,TInt aDrive) |
262 LOCAL_C TInt64 FillDisk(RFile& aFile,TInt64 aNewSpace,TInt aDrive) |
351 TInt r; |
352 TInt r; |
352 switch(aTask) |
353 switch(aTask) |
353 { |
354 { |
354 case ETaskMkDir: |
355 case ETaskMkDir: |
355 r=TheFs.RmDir(KTestDir1); |
356 r=TheFs.RmDir(KTestDir1); |
356 test(r==KErrNone); |
357 test_KErrNone(r); |
357 break; |
358 break; |
358 case ETaskRmDir: break; |
359 case ETaskRmDir: break; |
359 case ETaskDelete: break; |
360 case ETaskDelete: break; |
360 case ETaskReplace: |
361 case ETaskReplace: |
361 r=TheFs.Delete(KTestFile2); |
362 r=TheFs.Delete(KTestFile2); |
362 test(r==KErrNone); |
363 test_KErrNone(r); |
363 break; |
364 break; |
364 case ETaskFileReplace: |
365 case ETaskFileReplace: |
365 r=TheFs.Delete(KTestFile1); |
366 r=TheFs.Delete(KTestFile1); |
366 test(r==KErrNone); |
367 test_KErrNone(r); |
367 break; |
368 break; |
368 case ETaskFileWrite: |
369 case ETaskFileWrite: |
369 case ETaskFileWrite4KB: |
370 case ETaskFileWrite4KB: |
370 case ETaskFileWrite64KB: |
371 case ETaskFileWrite64KB: |
371 case ETaskFileSetSize: |
372 case ETaskFileSetSize: |
394 switch(aTask) |
395 switch(aTask) |
395 { |
396 { |
396 case ETaskMkDir: break; |
397 case ETaskMkDir: break; |
397 case ETaskRmDir: |
398 case ETaskRmDir: |
398 r=TheFs.MkDir(KTestDir1); |
399 r=TheFs.MkDir(KTestDir1); |
399 test(r==KErrNone); |
400 test_KErrNone(r); |
400 break; |
401 break; |
401 case ETaskDelete: |
402 case ETaskDelete: |
402 r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite); |
403 r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite); |
403 test(r==KErrNone); |
404 test_KErrNone(r); |
404 if( !LffsDrive ) |
405 if( !LffsDrive ) |
405 { |
406 { |
406 r=file.SetSize(KFileSize1); |
407 r=file.SetSize(KFileSize1); |
407 test(r==KErrNone); |
408 test_KErrNone(r); |
408 } |
409 } |
409 else |
410 else |
410 { |
411 { |
411 // LFFS supports sparse files, so we have to write real data |
412 // LFFS supports sparse files, so we have to write real data |
412 // into the file to ensure that it uses up disk space |
413 // into the file to ensure that it uses up disk space |
414 } |
415 } |
415 file.Close(); |
416 file.Close(); |
416 break; |
417 break; |
417 case ETaskReplace: |
418 case ETaskReplace: |
418 r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite); |
419 r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite); |
419 test(r==KErrNone); |
420 test_KErrNone(r); |
420 if( !LffsDrive ) |
421 if( !LffsDrive ) |
421 { |
422 { |
422 r=file.SetSize(KFileSize1); |
423 r=file.SetSize(KFileSize1); |
423 test(r==KErrNone); |
424 test_KErrNone(r); |
424 } |
425 } |
425 else |
426 else |
426 { |
427 { |
427 WriteToFile( file, KFileSize2 ); |
428 WriteToFile( file, KFileSize2 ); |
428 } |
429 } |
429 file.Close(); |
430 file.Close(); |
430 r=file2.Create(TheFs,KTestFile2,EFileShareAny|EFileWrite); |
431 r=file2.Create(TheFs,KTestFile2,EFileShareAny|EFileWrite); |
431 test(r==KErrNone); |
432 test_KErrNone(r); |
432 if( !LffsDrive ) |
433 if( !LffsDrive ) |
433 { |
434 { |
434 r=file2.SetSize(KFileSize3); |
435 r=file2.SetSize(KFileSize3); |
435 test(r==KErrNone); |
436 test_KErrNone(r); |
436 } |
437 } |
437 else |
438 else |
438 { |
439 { |
439 WriteToFile( file2, gMinFileSize << 4); // 512 * 16 = 8K |
440 WriteToFile( file2, gMinFileSize << 4); // 512 * 16 = 8K |
440 } |
441 } |
441 file2.Close(); |
442 file2.Close(); |
442 break; |
443 break; |
443 case ETaskFileReplace: |
444 case ETaskFileReplace: |
444 r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite); |
445 r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite); |
445 test(r==KErrNone); |
446 test_KErrNone(r); |
446 if( !LffsDrive ) |
447 if( !LffsDrive ) |
447 { |
448 { |
448 r=file.SetSize(KFileSize3*2); |
449 r=file.SetSize(KFileSize3*2); |
449 } |
450 } |
450 else |
451 else |
451 { |
452 { |
452 WriteToFile( file, KFileSize3 ); |
453 WriteToFile( file, KFileSize3 ); |
453 } |
454 } |
454 test(r==KErrNone); |
455 test_KErrNone(r); |
455 file.Close(); |
456 file.Close(); |
456 break; |
457 break; |
457 case ETaskFileWrite: |
458 case ETaskFileWrite: |
458 case ETaskFileWrite4KB: |
459 case ETaskFileWrite4KB: |
459 case ETaskFileWrite64KB: |
460 case ETaskFileWrite64KB: |
460 case ETaskFileSetSize: |
461 case ETaskFileSetSize: |
461 r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite); |
462 r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite); |
462 test(r==KErrNone); |
463 test_KErrNone(r); |
463 file.Close(); |
464 file.Close(); |
464 break; |
465 break; |
465 case ETaskNoChange1: |
466 case ETaskNoChange1: |
466 r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite); |
467 r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite); |
467 test(r==KErrNone); |
468 test_KErrNone(r); |
468 if( !LffsDrive ) |
469 if( !LffsDrive ) |
469 { |
470 { |
470 r=file.SetSize(KFileSize1); |
471 r=file.SetSize(KFileSize1); |
471 test(r==KErrNone); |
472 test_KErrNone(r); |
472 } |
473 } |
473 else |
474 else |
474 { |
475 { |
475 WriteToFile( file, KFileSize1 ); |
476 WriteToFile( file, KFileSize1 ); |
476 } |
477 } |
477 file.Close(); |
478 file.Close(); |
478 break; |
479 break; |
479 case ETaskNoChange2: |
480 case ETaskNoChange2: |
480 r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite); |
481 r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite); |
481 test(r==KErrNone); |
482 test_KErrNone(r); |
482 file.Close(); |
483 file.Close(); |
483 break; |
484 break; |
484 case ETaskFileCreateLffs: |
485 case ETaskFileCreateLffs: |
485 r = TheFs.Delete(KTestFile1); |
486 r = TheFs.Delete(KTestFile1); |
486 break; |
487 break; |
495 // |
496 // |
496 { |
497 { |
497 RTest test(_L("T_DSPACE_ThreadFunction")); |
498 RTest test(_L("T_DSPACE_ThreadFunction")); |
498 RFs fs; |
499 RFs fs; |
499 TInt r=fs.Connect(); |
500 TInt r=fs.Connect(); |
500 test(r==KErrNone); |
501 test_KErrNone(r); |
501 r=fs.SetSessionPath(gSessionPath); |
502 r=fs.SetSessionPath(gSessionPath); |
502 test(r==KErrNone); |
503 test_KErrNone(r); |
503 TThreadTask task=*(TThreadTask*)&aThreadTask; |
504 TThreadTask task=*(TThreadTask*)&aThreadTask; |
504 RFile file; |
505 RFile file; |
505 switch(task) |
506 switch(task) |
506 { |
507 { |
507 case ETaskMkDir: |
508 case ETaskMkDir: |
508 r=fs.MkDir(KTestDir1); |
509 r=fs.MkDir(KTestDir1); |
509 test(r==KErrNone); |
510 test_KErrNone(r); |
510 break; |
511 break; |
511 case ETaskRmDir: |
512 case ETaskRmDir: |
512 r=fs.RmDir(KTestDir1); |
513 r=fs.RmDir(KTestDir1); |
513 test(r==KErrNone); |
514 test_KErrNone(r); |
514 break; |
515 break; |
515 case ETaskDelete: |
516 case ETaskDelete: |
516 r=fs.Delete(KTestFile1); |
517 r=fs.Delete(KTestFile1); |
517 test(r==KErrNone); |
518 test_KErrNone(r); |
518 break; |
519 break; |
519 case ETaskReplace: |
520 case ETaskReplace: |
520 r=fs.Replace(KTestFile1,KTestFile2); |
521 r=fs.Replace(KTestFile1,KTestFile2); |
521 test(r==KErrNone); |
522 test_KErrNone(r); |
522 break; |
523 break; |
523 case ETaskFileReplace: |
524 case ETaskFileReplace: |
524 r=file.Replace(fs,KTestFile1,EFileShareAny|EFileWrite); |
525 r=file.Replace(fs,KTestFile1,EFileShareAny|EFileWrite); |
525 test(r==KErrNone); |
526 test_KErrNone(r); |
526 file.Close(); |
527 file.Close(); |
527 break; |
528 break; |
528 case ETaskFileWrite: |
529 case ETaskFileWrite: |
529 r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite); |
530 r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite); |
530 test(r==KErrNone); |
531 test_KErrNone(r); |
531 #if defined(__WINS__) |
532 #if defined(__WINS__) |
532 WriteToFile( file, gMinFileSize << 4); // 512 * 16 = 8K |
533 WriteToFile( file, gMinFileSize << 4); // 512 * 16 = 8K |
533 #else |
534 #else |
534 WriteToFile( file, gMinFileSize << 1); // 512 * 2 = 1K |
535 WriteToFile( file, gMinFileSize << 1); // 512 * 2 = 1K |
535 #endif |
536 #endif |
536 file.Close(); |
537 file.Close(); |
537 break; |
538 break; |
538 case ETaskFileWrite4KB: |
539 case ETaskFileWrite4KB: |
539 r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite); |
540 r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite); |
540 test(r==KErrNone); |
541 test_KErrNone(r); |
541 WriteToFile(file,gMinFileSize << 3); // 512 * 2^3 = 512 * 8 = 4K |
542 WriteToFile(file,gMinFileSize << 3); // 512 * 2^3 = 512 * 8 = 4K |
542 file.Close(); |
543 file.Close(); |
543 break; |
544 break; |
544 case ETaskFileWrite64KB: |
545 case ETaskFileWrite64KB: |
545 r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite); |
546 r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite); |
546 test(r==KErrNone); |
547 test_KErrNone(r); |
547 WriteToFile(file,gMinFileSize<<7); // 512 * 2^7 = 512 * 128 = 64K |
548 WriteToFile(file,gMinFileSize<<7); // 512 * 2^7 = 512 * 128 = 64K |
548 file.Close(); |
549 file.Close(); |
549 break; |
550 break; |
550 case ETaskFileSetSize: |
551 case ETaskFileSetSize: |
551 r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite); |
552 r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite); |
552 test(r==KErrNone); |
553 test_KErrNone(r); |
553 r=file.SetSize(KFileSize3); |
554 r=file.SetSize(KFileSize3); |
554 file.Close(); |
555 file.Close(); |
555 break; |
556 break; |
556 case ETaskFileCreateLffs: |
557 case ETaskFileCreateLffs: |
557 r=file.Create(fs,KTestFile1,EFileShareAny|EFileWrite); |
558 r=file.Create(fs,KTestFile1,EFileShareAny|EFileWrite); |
558 test(r==KErrNone); |
559 test_KErrNone(r); |
559 file.Close(); |
560 file.Close(); |
560 break; |
561 break; |
561 case ETaskNoChange1: |
562 case ETaskNoChange1: |
562 { |
563 { |
563 r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite); |
564 r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite); |
564 test(r==KErrNone); |
565 test_KErrNone(r); |
565 TTime time; |
566 TTime time; |
566 time.HomeTime(); |
567 time.HomeTime(); |
567 r=file.SetModified(time); |
568 r=file.SetModified(time); |
568 test(r==KErrNone); |
569 test_KErrNone(r); |
569 file.Close(); |
570 file.Close(); |
570 break; |
571 break; |
571 } |
572 } |
572 case ETaskNoChange2: |
573 case ETaskNoChange2: |
573 { |
574 { |
574 TEntry e; |
575 TEntry e; |
575 r=fs.Entry(KTestFile1,e); |
576 r=fs.Entry(KTestFile1,e); |
576 test(r==KErrNone); |
577 test_KErrNone(r); |
577 break; |
578 break; |
578 } |
579 } |
579 case ETaskSpin: |
580 case ETaskSpin: |
580 for(;;) {}; |
581 for(;;) {}; |
581 |
582 |
730 // |
731 // |
731 { |
732 { |
732 // make default directory |
733 // make default directory |
733 _LIT(defaultDir,"C:\\F32-TST\\"); |
734 _LIT(defaultDir,"C:\\F32-TST\\"); |
734 TInt r=TheFs.MkDirAll(defaultDir); |
735 TInt r=TheFs.MkDirAll(defaultDir); |
735 test(r==KErrNone||r==KErrAlreadyExists); |
736 test_Value(r, r == KErrNone||r==KErrAlreadyExists); |
736 // create the filler file |
737 // create the filler file |
737 RFile file; |
738 RFile file; |
738 TFileName fileName=_L("C:"); |
739 TFileName fileName=_L("C:"); |
739 fileName+=KFileFiller; |
740 fileName+=KFileFiller; |
740 r=file.Create(TheFs,fileName,EFileShareAny|EFileWrite); |
741 r=file.Create(TheFs,fileName,EFileShareAny|EFileWrite); |
741 test(r==KErrNone); |
742 test_KErrNone(r); |
742 TInt64 free=FreeDiskSpace(EDriveC); |
743 TInt64 free=FreeDiskSpace(EDriveC); |
743 // use up 16KB |
744 // use up 16KB |
744 FillDisk(file,free-16384,EDriveC); |
745 FillDisk(file,free-16384,EDriveC); |
745 |
746 |
746 // test formatting notifies clients on only specific drive |
747 // test formatting notifies clients on only specific drive |
752 TheFs.NotifyDiskSpace(freeD-1024,RemovableDrive,stat2); |
753 TheFs.NotifyDiskSpace(freeD-1024,RemovableDrive,stat2); |
753 test(stat1==KRequestPending && stat2==KRequestPending); |
754 test(stat1==KRequestPending && stat2==KRequestPending); |
754 RFormat f; |
755 RFormat f; |
755 TInt count; |
756 TInt count; |
756 r=f.Open(TheFs,RemovableDriveBuf,EQuickFormat,count); |
757 r=f.Open(TheFs,RemovableDriveBuf,EQuickFormat,count); |
757 test(r==KErrNone); |
758 test_KErrNone(r); |
758 while(count) |
759 while(count) |
759 { |
760 { |
760 r=f.Next(count); |
761 r=f.Next(count); |
761 test(r==KErrNone); |
762 test_KErrNone(r); |
762 } |
763 } |
763 f.Close(); |
764 f.Close(); |
764 User::After(1000000); |
765 User::After(1000000); |
765 User::WaitForRequest(stat2); |
766 User::WaitForRequest(stat2); |
766 test(stat1==KRequestPending && stat2==KErrNone); |
767 test(stat1==KRequestPending && stat2==KErrNone); |
770 // and create the test directory for the removable drive |
771 // and create the test directory for the removable drive |
771 TFileName fName=_L(""); |
772 TFileName fName=_L(""); |
772 fName+=RemovableDriveBuf; |
773 fName+=RemovableDriveBuf; |
773 fName+=_L("F32-TST\\"); |
774 fName+=_L("F32-TST\\"); |
774 r=TheFs.MkDirAll(fName); |
775 r=TheFs.MkDirAll(fName); |
775 test(r==KErrNone); |
776 test_KErrNone(r); |
776 |
777 |
777 // test that a media change notifies clients on all drives |
778 // test that a media change notifies clients on all drives |
778 test.Next(_L("media change")); |
779 test.Next(_L("media change")); |
779 freeC=FreeDiskSpace(EDriveC); |
780 freeC=FreeDiskSpace(EDriveC); |
780 freeD=FreeDiskSpace(RemovableDrive); |
781 freeD=FreeDiskSpace(RemovableDrive); |
804 |
805 |
805 // test that scandrive notifies clients on only specific drives |
806 // test that scandrive notifies clients on only specific drives |
806 test.Next(_L("scandrive")); |
807 test.Next(_L("scandrive")); |
807 // first test that scandrive does not find any problems on the removable media |
808 // first test that scandrive does not find any problems on the removable media |
808 r=TheFs.ScanDrive(RemovableDriveBuf); |
809 r=TheFs.ScanDrive(RemovableDriveBuf); |
809 test(r==KErrNone); |
810 test_KErrNone(r); |
810 // now set up disk space notification |
811 // now set up disk space notification |
811 freeC=FreeDiskSpace(EDriveC); |
812 freeC=FreeDiskSpace(EDriveC); |
812 freeD=FreeDiskSpace(RemovableDrive); |
813 freeD=FreeDiskSpace(RemovableDrive); |
813 test.Printf(_L("free space on drive %d = 0x%x\n"),EDriveC,freeC); |
814 test.Printf(_L("free space on drive %d = 0x%x\n"),EDriveC,freeC); |
814 test.Printf(_L("free space on drive %d = 0x%x\n"),RemovableDrive,freeD); |
815 test.Printf(_L("free space on drive %d = 0x%x\n"),RemovableDrive,freeD); |
815 TheFs.NotifyDiskSpace(freeC+8192,EDriveC,stat1); |
816 TheFs.NotifyDiskSpace(freeC+8192,EDriveC,stat1); |
816 TheFs.NotifyDiskSpace(freeD-8192,RemovableDrive,stat2); |
817 TheFs.NotifyDiskSpace(freeD-8192,RemovableDrive,stat2); |
817 test(stat1==KRequestPending && stat2==KRequestPending); |
818 test(stat1==KRequestPending && stat2==KRequestPending); |
818 r=TheFs.ScanDrive(RemovableDriveBuf); |
819 r=TheFs.ScanDrive(RemovableDriveBuf); |
819 test(r==KErrNone); |
820 test_KErrNone(r); |
820 User::After(1000000); |
821 User::After(1000000); |
821 User::WaitForRequest(stat2); |
822 User::WaitForRequest(stat2); |
822 test(stat1==KRequestPending && stat2==KErrNone); |
823 test(stat1==KRequestPending && stat2==KErrNone); |
823 TheFs.NotifyDiskSpaceCancel(stat1); |
824 TheFs.NotifyDiskSpaceCancel(stat1); |
824 test(stat1==KErrCancel); |
825 test(stat1==KErrCancel); |
825 |
826 |
826 file.Close(); |
827 file.Close(); |
827 r=TheFs.Delete(fileName); |
828 r=TheFs.Delete(fileName); |
828 test(r==KErrNone); |
829 test_KErrNone(r); |
829 if(gSessionPath[0]!=(TText)'C') |
830 if(gSessionPath[0]!=(TText)'C') |
830 { |
831 { |
831 r=TheFs.RmDir(defaultDir); |
832 r=TheFs.RmDir(defaultDir); |
832 test(r==KErrNone||r==KErrInUse); |
833 test_Value(r, r == KErrNone||r==KErrInUse); |
833 } |
834 } |
834 |
835 |
835 } |
836 } |
836 |
837 |
837 void TestFunctions() |
838 void TestFunctions() |
843 { |
844 { |
844 test.Next(_L("test disk space functions")); |
845 test.Next(_L("test disk space functions")); |
845 // create the filler file |
846 // create the filler file |
846 RFile file; |
847 RFile file; |
847 TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO); |
848 TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO); |
848 test(r==KErrNone); |
849 test_KErrNone(r); |
849 TInt64 newSpace = FreeDiskSpace(KDefaultDrive)-8192; |
850 TInt64 newSpace = FreeDiskSpace(KDefaultDrive)-8192; |
850 FillDisk(file,newSpace,KDefaultDrive); |
851 FillDisk(file,newSpace,KDefaultDrive); |
851 |
852 |
852 // check file write |
853 // check file write |
853 test.Next(_L("check RFile:Write")); |
854 test.Next(_L("check RFile:Write")); |
858 TInt64 threshold=free-200; |
859 TInt64 threshold=free-200; |
859 TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1); |
860 TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1); |
860 test(stat1==KRequestPending); |
861 test(stat1==KRequestPending); |
861 RThread thread; |
862 RThread thread; |
862 r=thread.Create(_L("thread1"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
863 r=thread.Create(_L("thread1"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
863 test(r==KErrNone); |
864 test_KErrNone(r); |
864 thread.Resume(); |
865 thread.Resume(); |
865 User::WaitForRequest(stat1); |
866 User::WaitForRequest(stat1); |
866 test(stat1==KErrNone); |
867 test(stat1==KErrNone); |
867 free=FreeDiskSpace(KDefaultDrive); |
868 free=FreeDiskSpace(KDefaultDrive); |
868 test(free<threshold); |
869 test(free<threshold); |
883 free=FreeDiskSpace(KDefaultDrive); |
884 free=FreeDiskSpace(KDefaultDrive); |
884 threshold=free-100; |
885 threshold=free-100; |
885 TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1); |
886 TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1); |
886 test(stat1==KRequestPending); |
887 test(stat1==KRequestPending); |
887 r=thread.Create(_L("thread2"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
888 r=thread.Create(_L("thread2"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
888 test(r==KErrNone); |
889 test_KErrNone(r); |
889 TRequestStatus deathStat; |
890 TRequestStatus deathStat; |
890 thread.Logon( deathStat ); |
891 thread.Logon( deathStat ); |
891 thread.Resume(); |
892 thread.Resume(); |
892 User::WaitForRequest(stat1); |
893 User::WaitForRequest(stat1); |
893 test(stat1==KErrNone); |
894 test(stat1==KErrNone); |
909 free=FreeDiskSpace(KDefaultDrive); |
910 free=FreeDiskSpace(KDefaultDrive); |
910 threshold=free+100; |
911 threshold=free+100; |
911 TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1); |
912 TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1); |
912 test(stat1==KRequestPending); |
913 test(stat1==KRequestPending); |
913 r=thread.Create(_L("thread3"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
914 r=thread.Create(_L("thread3"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
914 test(r==KErrNone); |
915 test_KErrNone(r); |
915 thread.Logon( deathStat ); |
916 thread.Logon( deathStat ); |
916 thread.Resume(); |
917 thread.Resume(); |
917 |
918 |
918 User::After(1000000); |
919 User::After(1000000); |
919 |
920 |
942 free=FreeDiskSpace(KDefaultDrive); |
943 free=FreeDiskSpace(KDefaultDrive); |
943 threshold=free+300; |
944 threshold=free+300; |
944 TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1); |
945 TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1); |
945 test(stat1==KRequestPending); |
946 test(stat1==KRequestPending); |
946 r=thread.Create(_L("thread4"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
947 r=thread.Create(_L("thread4"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
947 test(r==KErrNone); |
948 test_KErrNone(r); |
948 thread.Logon( deathStat ); |
949 thread.Logon( deathStat ); |
949 thread.Resume(); |
950 thread.Resume(); |
950 User::WaitForRequest(stat1); |
951 User::WaitForRequest(stat1); |
951 test(stat1==KErrNone); |
952 test(stat1==KErrNone); |
952 free=FreeDiskSpace(KDefaultDrive); |
953 free=FreeDiskSpace(KDefaultDrive); |
978 |
979 |
979 TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1); |
980 TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1); |
980 test(stat1==KRequestPending); |
981 test(stat1==KRequestPending); |
981 |
982 |
982 r=thread.Create(_L("thread5"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
983 r=thread.Create(_L("thread5"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
983 test(r==KErrNone); |
984 test_KErrNone(r); |
984 thread.Logon( deathStat ); |
985 thread.Logon( deathStat ); |
985 thread.Resume(); |
986 thread.Resume(); |
986 |
987 |
987 User::After(1000000); |
988 User::After(1000000); |
988 test(stat1==KRequestPending); |
989 test(stat1==KRequestPending); |
1002 free=FreeDiskSpace(KDefaultDrive); |
1003 free=FreeDiskSpace(KDefaultDrive); |
1003 threshold=free+200; |
1004 threshold=free+200; |
1004 TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1); |
1005 TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1); |
1005 test(stat1==KRequestPending); |
1006 test(stat1==KRequestPending); |
1006 r=thread.Create(_L("thread6"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1007 r=thread.Create(_L("thread6"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1007 test(r==KErrNone); |
1008 test_KErrNone(r); |
1008 thread.Logon( deathStat ); |
1009 thread.Logon( deathStat ); |
1009 thread.Resume(); |
1010 thread.Resume(); |
1010 User::WaitForRequest(stat1); |
1011 User::WaitForRequest(stat1); |
1011 //User::After(1000000); |
1012 //User::After(1000000); |
1012 test(stat1==KErrNone); |
1013 test(stat1==KErrNone); |
1031 _LIT(someFile,"X:\\abcdef"); |
1032 _LIT(someFile,"X:\\abcdef"); |
1032 #else |
1033 #else |
1033 TBuf<10> someFile=_L("?:\\abcdef"); |
1034 TBuf<10> someFile=_L("?:\\abcdef"); |
1034 TChar c; |
1035 TChar c; |
1035 TInt r=RFs::DriveToChar(RemovableDrive,c); |
1036 TInt r=RFs::DriveToChar(RemovableDrive,c); |
1036 test(r==KErrNone); |
1037 test_KErrNone(r); |
1037 someFile[0]=(TText)c; |
1038 someFile[0]=(TText)c; |
1038 #endif |
1039 #endif |
1039 _LIT(someDir,"C:\\1234\\"); |
1040 _LIT(someDir,"C:\\1234\\"); |
1040 |
1041 |
1041 r=f2.Create(TheFs,someFile,EFileShareAny|EFileWrite); |
1042 r=f2.Create(TheFs,someFile,EFileShareAny|EFileWrite); |
1042 test(r==KErrNone); |
1043 test_KErrNone(r); |
1043 r=TheFs.MkDir(someDir); |
1044 r=TheFs.MkDir(someDir); |
1044 test(r==KErrNone); |
1045 test_KErrNone(r); |
1045 TRequestStatus stat2; |
1046 TRequestStatus stat2; |
1046 TInt64 freeC=FreeDiskSpace(EDriveC); |
1047 TInt64 freeC=FreeDiskSpace(EDriveC); |
1047 TInt64 freeD=FreeDiskSpace(RemovableDrive); |
1048 TInt64 freeD=FreeDiskSpace(RemovableDrive); |
1048 TheFs.NotifyDiskSpace(freeC-4097,EDriveC,stat1); |
1049 TheFs.NotifyDiskSpace(freeC-4097,EDriveC,stat1); |
1049 TheFs.NotifyDiskSpace(freeD-4097,RemovableDrive,stat2); |
1050 TheFs.NotifyDiskSpace(freeD-4097,RemovableDrive,stat2); |
1050 test(stat1==KRequestPending && stat2==KRequestPending); |
1051 test(stat1==KRequestPending && stat2==KRequestPending); |
1051 // before fix this would result in iTheDrive not being updated in next subsession call |
1052 // before fix this would result in iTheDrive not being updated in next subsession call |
1052 // therefore this could would not result in a disk space notification |
1053 // therefore this could would not result in a disk space notification |
1053 r=f2.SetSize(8192); |
1054 r=f2.SetSize(8192); |
1054 test(r==KErrNone); |
1055 test_KErrNone(r); |
1055 User::After(1000000); |
1056 User::After(1000000); |
1056 User::WaitForRequest(stat2); |
1057 User::WaitForRequest(stat2); |
1057 |
1058 |
1058 if (stat2!=KErrNone) |
1059 if (stat2!=KErrNone) |
1059 test.Printf(_L("stat2=%d\n"),stat2.Int()); |
1060 test.Printf(_L("stat2=%d\n"),stat2.Int()); |
1087 { |
1088 { |
1088 test.Next(_L("test LFFS disk space functions")); |
1089 test.Next(_L("test LFFS disk space functions")); |
1089 // create the filler file |
1090 // create the filler file |
1090 RFile file; |
1091 RFile file; |
1091 TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO); |
1092 TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO); |
1092 test(r==KErrNone); |
1093 test_KErrNone(r); |
1093 TInt64 newSpace = FreeDiskSpace(KDefaultDrive)-8192; |
1094 TInt64 newSpace = FreeDiskSpace(KDefaultDrive)-8192; |
1094 FillDisk(file,newSpace,KDefaultDrive); |
1095 FillDisk(file,newSpace,KDefaultDrive); |
1095 |
1096 |
1096 |
1097 |
1097 // check file create |
1098 // check file create |
1106 TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1); |
1107 TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1); |
1107 TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2); |
1108 TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2); |
1108 test(stat1==KRequestPending && stat2==KRequestPending); |
1109 test(stat1==KRequestPending && stat2==KRequestPending); |
1109 RThread thread; |
1110 RThread thread; |
1110 r=thread.Create(_L("thread7"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1111 r=thread.Create(_L("thread7"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1111 test(r==KErrNone); |
1112 test_KErrNone(r); |
1112 TRequestStatus deathStat; |
1113 TRequestStatus deathStat; |
1113 thread.Logon( deathStat ); |
1114 thread.Logon( deathStat ); |
1114 thread.Resume(); |
1115 thread.Resume(); |
1115 User::WaitForRequest(stat1); |
1116 User::WaitForRequest(stat1); |
1116 test(stat1==KErrNone); |
1117 test(stat1==KErrNone); |
1141 TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1); |
1142 TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1); |
1142 TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2); |
1143 TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2); |
1143 TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3); |
1144 TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3); |
1144 test(stat1==KRequestPending && stat2==KRequestPending && stat3==KRequestPending); |
1145 test(stat1==KRequestPending && stat2==KRequestPending && stat3==KRequestPending); |
1145 r=thread.Create(_L("thread8"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1146 r=thread.Create(_L("thread8"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1146 test(r==KErrNone); |
1147 test_KErrNone(r); |
1147 thread.Logon( deathStat ); |
1148 thread.Logon( deathStat ); |
1148 thread.SetPriority( EPriorityLess ); |
1149 thread.SetPriority( EPriorityLess ); |
1149 thread.Resume(); // start spinning, blocks background thread |
1150 thread.Resume(); // start spinning, blocks background thread |
1150 // request background thread to notify a daft value |
1151 // request background thread to notify a daft value |
1151 TPckgBuf<TInt64> cBuf; |
1152 TPckgBuf<TInt64> cBuf; |
1156 #define ECioBackgroundNotifyDiskSize 10016 |
1157 #define ECioBackgroundNotifyDiskSize 10016 |
1157 r = TheFs.ControlIo(GetDriveLFFS(), ECioBackgroundNotifyDiskSize, cBuf); |
1158 r = TheFs.ControlIo(GetDriveLFFS(), ECioBackgroundNotifyDiskSize, cBuf); |
1158 test( KErrNone==r ); |
1159 test( KErrNone==r ); |
1159 // create a file to force some roll-forward |
1160 // create a file to force some roll-forward |
1160 r=file2.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite); |
1161 r=file2.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite); |
1161 test(r==KErrNone); |
1162 test_KErrNone(r); |
1162 User::WaitForRequest(stat1); |
1163 User::WaitForRequest(stat1); |
1163 test(stat1==KErrNone); |
1164 test(stat1==KErrNone); |
1164 test(stat2==KRequestPending); |
1165 test(stat2==KRequestPending); |
1165 test(stat3==KRequestPending); |
1166 test(stat3==KRequestPending); |
1166 // kill the spinner thread to allow the background thread to execute |
1167 // kill the spinner thread to allow the background thread to execute |
1191 TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1); |
1192 TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1); |
1192 TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2); |
1193 TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2); |
1193 TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3); |
1194 TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3); |
1194 test(stat1==KRequestPending && stat2==KRequestPending && stat3==KRequestPending); |
1195 test(stat1==KRequestPending && stat2==KRequestPending && stat3==KRequestPending); |
1195 r=thread.Create(_L("thread9"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1196 r=thread.Create(_L("thread9"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1196 test(r==KErrNone); |
1197 test_KErrNone(r); |
1197 thread.Logon( deathStat ); |
1198 thread.Logon( deathStat ); |
1198 thread.SetPriority( EPriorityLess ); |
1199 thread.SetPriority( EPriorityLess ); |
1199 thread.Resume(); // start spinning, blocks background thread |
1200 thread.Resume(); // start spinning, blocks background thread |
1200 // create a file to force some roll-forward |
1201 // create a file to force some roll-forward |
1201 r=file2.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite); |
1202 r=file2.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite); |
1202 test(r==KErrNone); |
1203 test_KErrNone(r); |
1203 User::WaitForRequest(stat1); |
1204 User::WaitForRequest(stat1); |
1204 test(stat1==KErrNone); |
1205 test(stat1==KErrNone); |
1205 test(stat2==KRequestPending); |
1206 test(stat2==KRequestPending); |
1206 test(stat3==KRequestPending); |
1207 test(stat3==KRequestPending); |
1207 // kill the spinner thread to allow the background thread to execute |
1208 // kill the spinner thread to allow the background thread to execute |
1234 // |
1235 // |
1235 { |
1236 { |
1236 // create the filler file |
1237 // create the filler file |
1237 RFile file; |
1238 RFile file; |
1238 TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO); |
1239 TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO); |
1239 test(r==KErrNone); |
1240 test_KErrNone(r); |
1240 TInt64 free=FreeDiskSpace(KDefaultDrive); |
1241 TInt64 free=FreeDiskSpace(KDefaultDrive); |
1241 TInt64 freeSpaceLeft = gMinFileSize << 4; // 512 * 2^4 = 512 * 16 = 8K |
1242 TInt64 freeSpaceLeft = gMinFileSize << 4; // 512 * 2^4 = 512 * 16 = 8K |
1242 FillDisk(file,free-freeSpaceLeft,KDefaultDrive); |
1243 FillDisk(file,free-freeSpaceLeft,KDefaultDrive); |
1243 TInt size; |
1244 TInt size; |
1244 r=file.Size(size); |
1245 r=file.Size(size); |
1245 test(r==KErrNone); |
1246 test_KErrNone(r); |
1246 test(size>1024); |
1247 test(size>1024); |
1247 test.Printf(_L("filler file size=0x%x\n"),size); |
1248 test.Printf(_L("filler file size=0x%x\n"),size); |
1248 |
1249 |
1249 // test multiple requests |
1250 // test multiple requests |
1250 test.Next(_L("test multiple requests")); |
1251 test.Next(_L("test multiple requests")); |
1263 TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2); |
1264 TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2); |
1264 TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3); |
1265 TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3); |
1265 test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending); |
1266 test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending); |
1266 RThread thread; |
1267 RThread thread; |
1267 r=thread.Create(_L("thread1"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1268 r=thread.Create(_L("thread1"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1268 test(r==KErrNone); |
1269 test_KErrNone(r); |
1269 TRequestStatus deathStat; |
1270 TRequestStatus deathStat; |
1270 thread.Logon( deathStat ); |
1271 thread.Logon( deathStat ); |
1271 thread.Resume(); |
1272 thread.Resume(); |
1272 User::After(1000000); |
1273 User::After(1000000); |
1273 User::WaitForRequest(stat1); |
1274 User::WaitForRequest(stat1); |
1300 TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1); |
1301 TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1); |
1301 TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2); |
1302 TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2); |
1302 TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3); |
1303 TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3); |
1303 test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending); |
1304 test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending); |
1304 r=thread.Create(_L("thread2"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1305 r=thread.Create(_L("thread2"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1305 test(r==KErrNone); |
1306 test_KErrNone(r); |
1306 thread.Logon( deathStat ); |
1307 thread.Logon( deathStat ); |
1307 thread.Resume(); |
1308 thread.Resume(); |
1308 User::After(10000); |
1309 User::After(10000); |
1309 User::WaitForRequest(stat3); |
1310 User::WaitForRequest(stat3); |
1310 test(stat3==KErrNone && stat1==KRequestPending && stat2==KRequestPending); |
1311 test(stat3==KErrNone && stat1==KRequestPending && stat2==KRequestPending); |
1337 |
1338 |
1338 // test multiple sessions all notified on disk space change |
1339 // test multiple sessions all notified on disk space change |
1339 test.Next(_L("test multiple sessions on same drive")); |
1340 test.Next(_L("test multiple sessions on same drive")); |
1340 RFs ses2,ses3; |
1341 RFs ses2,ses3; |
1341 r=ses2.Connect(); |
1342 r=ses2.Connect(); |
1342 test(r==KErrNone); |
1343 test_KErrNone(r); |
1343 r=ses3.Connect(); |
1344 r=ses3.Connect(); |
1344 test(r==KErrNone); |
1345 test_KErrNone(r); |
1345 r=ses2.SetSessionPath(gSessionPath); |
1346 r=ses2.SetSessionPath(gSessionPath); |
1346 test(r==KErrNone); |
1347 test_KErrNone(r); |
1347 r=ses3.SetSessionPath(gSessionPath); |
1348 r=ses3.SetSessionPath(gSessionPath); |
1348 test(r==KErrNone); |
1349 test_KErrNone(r); |
1349 task=ETaskFileReplace; |
1350 task=ETaskFileReplace; |
1350 InitialiseForThread(task); |
1351 InitialiseForThread(task); |
1351 free=FreeDiskSpace(KDefaultDrive); |
1352 free=FreeDiskSpace(KDefaultDrive); |
1352 test.Printf(_L("free space on default drive = 0x%x\n"),free); |
1353 test.Printf(_L("free space on default drive = 0x%x\n"),free); |
1353 threshold1=free+gMinFileSize; // 512 |
1354 threshold1=free+gMinFileSize; // 512 |
1356 TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1); |
1357 TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1); |
1357 ses2.NotifyDiskSpace(threshold2,KDefaultDrive,stat2); |
1358 ses2.NotifyDiskSpace(threshold2,KDefaultDrive,stat2); |
1358 ses3.NotifyDiskSpace(threshold3,KDefaultDrive,stat3); |
1359 ses3.NotifyDiskSpace(threshold3,KDefaultDrive,stat3); |
1359 test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending); |
1360 test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending); |
1360 r=thread.Create(_L("thread3"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1361 r=thread.Create(_L("thread3"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1361 test(r==KErrNone); |
1362 test_KErrNone(r); |
1362 thread.Logon( deathStat ); |
1363 thread.Logon( deathStat ); |
1363 thread.Resume(); |
1364 thread.Resume(); |
1364 User::After(1000000); |
1365 User::After(1000000); |
1365 User::WaitForRequest(stat1); |
1366 User::WaitForRequest(stat1); |
1366 User::WaitForRequest(stat2); |
1367 User::WaitForRequest(stat2); |
1388 |
1389 |
1389 if( !LffsDrive ) |
1390 if( !LffsDrive ) |
1390 { |
1391 { |
1391 TInt sessionDrive; |
1392 TInt sessionDrive; |
1392 r=RFs::CharToDrive(gSessionPath[0],sessionDrive); |
1393 r=RFs::CharToDrive(gSessionPath[0],sessionDrive); |
1393 test(r==KErrNone); |
1394 test_KErrNone(r); |
1394 if(sessionDrive!=RemovableDrive) |
1395 if(sessionDrive!=RemovableDrive) |
1395 { |
1396 { |
1396 // first create a file on the removable drive |
1397 // first create a file on the removable drive |
1397 RFile file2; |
1398 RFile file2; |
1398 TFileName file2name=RemovableDriveBuf; |
1399 TFileName file2name=RemovableDriveBuf; |
1399 file2name+=_L("F32-TST\\testfile1"); |
1400 file2name+=_L("F32-TST\\testfile1"); |
1400 TheFs.Delete(file2name); |
1401 TheFs.Delete(file2name); |
1401 r=file2.Create(TheFs,file2name,EFileShareAny|EFileWrite); |
1402 r=file2.Create(TheFs,file2name,EFileShareAny|EFileWrite); |
1402 test(r==KErrNone); |
1403 test_KErrNone(r); |
1403 r=file2.SetSize(KFileSize3); |
1404 r=file2.SetSize(KFileSize3); |
1404 test(r==KErrNone); |
1405 test_KErrNone(r); |
1405 // test multiple sessions not notified on disk space change on wrong drive |
1406 // test multiple sessions not notified on disk space change on wrong drive |
1406 test.Next(_L("test multiple sessions on different drives")); |
1407 test.Next(_L("test multiple sessions on different drives")); |
1407 task=ETaskFileReplace; |
1408 task=ETaskFileReplace; |
1408 InitialiseForThread(task); |
1409 InitialiseForThread(task); |
1409 TInt64 freeDef=FreeDiskSpace(KDefaultDrive); |
1410 TInt64 freeDef=FreeDiskSpace(KDefaultDrive); |
1412 threshold2=freeRem + (gMinFileSize << 1); // 1024; |
1413 threshold2=freeRem + (gMinFileSize << 1); // 1024; |
1413 TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1); |
1414 TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1); |
1414 ses2.NotifyDiskSpace(threshold2,RemovableDrive,stat2); |
1415 ses2.NotifyDiskSpace(threshold2,RemovableDrive,stat2); |
1415 test(stat1==KRequestPending&&stat2==KRequestPending); |
1416 test(stat1==KRequestPending&&stat2==KRequestPending); |
1416 r=thread.Create(_L("thread4"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1417 r=thread.Create(_L("thread4"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1417 test(r==KErrNone); |
1418 test_KErrNone(r); |
1418 thread.Logon( deathStat ); |
1419 thread.Logon( deathStat ); |
1419 thread.Resume(); |
1420 thread.Resume(); |
1420 User::After(1000000); |
1421 User::After(1000000); |
1421 User::WaitForRequest(stat1); |
1422 User::WaitForRequest(stat1); |
1422 test(stat1==KErrNone && stat2==KRequestPending); |
1423 test(stat1==KErrNone && stat2==KRequestPending); |
1452 // |
1453 // |
1453 { |
1454 { |
1454 // create the filler file |
1455 // create the filler file |
1455 RFile file; |
1456 RFile file; |
1456 TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO); |
1457 TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO); |
1457 test(r==KErrNone); |
1458 test_KErrNone(r); |
1458 TInt64 free=FreeDiskSpace(KDefaultDrive); |
1459 TInt64 free=FreeDiskSpace(KDefaultDrive); |
1459 FillDisk(file,free-8192,KDefaultDrive); |
1460 FillDisk(file,free-8192,KDefaultDrive); |
1460 TInt size; |
1461 TInt size; |
1461 r=file.Size(size); |
1462 r=file.Size(size); |
1462 test(r==KErrNone); |
1463 test_KErrNone(r); |
1463 test.Printf(_L("filler file size=0x%x\n"),size); |
1464 test.Printf(_L("filler file size=0x%x\n"),size); |
1464 |
1465 |
1465 |
1466 |
1466 // test multiple requests again |
1467 // test multiple requests again |
1467 test.Next(_L("test multiple requests on LFFS") ); |
1468 test.Next(_L("test multiple requests on LFFS") ); |
1478 TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2); |
1479 TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2); |
1479 TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3); |
1480 TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3); |
1480 test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending); |
1481 test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending); |
1481 RThread thread; |
1482 RThread thread; |
1482 r=thread.Create(_L("thread10"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1483 r=thread.Create(_L("thread10"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1483 test(r==KErrNone); |
1484 test_KErrNone(r); |
1484 TRequestStatus deathStat; |
1485 TRequestStatus deathStat; |
1485 thread.Logon( deathStat ); |
1486 thread.Logon( deathStat ); |
1486 // test.Printf(_L("Resuming other thread")); |
1487 // test.Printf(_L("Resuming other thread")); |
1487 thread.Resume(); |
1488 thread.Resume(); |
1488 User::After(10000); |
1489 User::After(10000); |
1509 |
1510 |
1510 |
1511 |
1511 |
1512 |
1512 TInt sessionDrive; |
1513 TInt sessionDrive; |
1513 r=RFs::CharToDrive(gSessionPath[0],sessionDrive); |
1514 r=RFs::CharToDrive(gSessionPath[0],sessionDrive); |
1514 test(r==KErrNone); |
1515 test_KErrNone(r); |
1515 if(sessionDrive!=EDriveC) |
1516 if(sessionDrive!=EDriveC) |
1516 { |
1517 { |
1517 // test multiple sessions not notified on disk space change on wrong drive |
1518 // test multiple sessions not notified on disk space change on wrong drive |
1518 test.Next(_L("test multiple sessions on different drives")); |
1519 test.Next(_L("test multiple sessions on different drives")); |
1519 |
1520 |
1520 RFs ses2,ses3; |
1521 RFs ses2,ses3; |
1521 r=ses2.Connect(); |
1522 r=ses2.Connect(); |
1522 test(r==KErrNone); |
1523 test_KErrNone(r); |
1523 r=ses3.Connect(); |
1524 r=ses3.Connect(); |
1524 test(r==KErrNone); |
1525 test_KErrNone(r); |
1525 r=ses2.SetSessionPath(gSessionPath); |
1526 r=ses2.SetSessionPath(gSessionPath); |
1526 test(r==KErrNone); |
1527 test_KErrNone(r); |
1527 r=ses3.SetSessionPath(gSessionPath); |
1528 r=ses3.SetSessionPath(gSessionPath); |
1528 test(r==KErrNone); |
1529 test_KErrNone(r); |
1529 |
1530 |
1530 // first create a file on the C:\ drive |
1531 // first create a file on the C:\ drive |
1531 RFile file2; |
1532 RFile file2; |
1532 TFileName file2name=_L("C:\\"); |
1533 TFileName file2name=_L("C:\\"); |
1533 file2name+=_L("F32-TST\\"); |
1534 file2name+=_L("F32-TST\\"); |
1534 r=TheFs.MkDir(file2name); |
1535 r=TheFs.MkDir(file2name); |
1535 test( KErrNone==r || KErrAlreadyExists==r ); |
1536 test( KErrNone==r || KErrAlreadyExists==r ); |
1536 file2name+=_L("testfile1"); |
1537 file2name+=_L("testfile1"); |
1537 TheFs.Delete(file2name); |
1538 TheFs.Delete(file2name); |
1538 r=file2.Create(TheFs,file2name,EFileShareAny|EFileWrite); |
1539 r=file2.Create(TheFs,file2name,EFileShareAny|EFileWrite); |
1539 test(r==KErrNone); |
1540 test_KErrNone(r); |
1540 WriteToFile( file2, KFileSize3 ); |
1541 WriteToFile( file2, KFileSize3 ); |
1541 |
1542 |
1542 task=ETaskFileReplace; |
1543 task=ETaskFileReplace; |
1543 InitialiseForThread(task); |
1544 InitialiseForThread(task); |
1544 TInt64 freeLffs=FreeDiskSpace(KDefaultDrive); |
1545 TInt64 freeLffs=FreeDiskSpace(KDefaultDrive); |
1547 threshold2=freeD+1024; |
1548 threshold2=freeD+1024; |
1548 TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1); |
1549 TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1); |
1549 ses2.NotifyDiskSpace(threshold2,EDriveC,stat2); |
1550 ses2.NotifyDiskSpace(threshold2,EDriveC,stat2); |
1550 test(stat1==KRequestPending&&stat2==KRequestPending); |
1551 test(stat1==KRequestPending&&stat2==KRequestPending); |
1551 r=thread.Create(_L("thread11"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1552 r=thread.Create(_L("thread11"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1552 test(r==KErrNone); |
1553 test_KErrNone(r); |
1553 thread.Logon( deathStat ); |
1554 thread.Logon( deathStat ); |
1554 thread.Resume(); |
1555 thread.Resume(); |
1555 User::After(1000000); |
1556 User::After(1000000); |
1556 User::WaitForRequest(stat1); |
1557 User::WaitForRequest(stat1); |
1557 test(stat1==KErrNone && stat2==KRequestPending); |
1558 test(stat1==KErrNone && stat2==KRequestPending); |
1587 // |
1588 // |
1588 { |
1589 { |
1589 // create a filler file |
1590 // create a filler file |
1590 RFile file; |
1591 RFile file; |
1591 TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO); |
1592 TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO); |
1592 test(r==KErrNone); |
1593 test_KErrNone(r); |
1593 TInt64 free=FreeDiskSpace(KDefaultDrive); |
1594 TInt64 free=FreeDiskSpace(KDefaultDrive); |
1594 // use 8KB in filler file |
1595 // use 8KB in filler file |
1595 FillDisk(file,free-8192,KDefaultDrive); |
1596 FillDisk(file,free-8192,KDefaultDrive); |
1596 |
1597 |
1597 // test change notification when no disk space change |
1598 // test change notification when no disk space change |
1606 TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2); |
1607 TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2); |
1607 TheFs.NotifyChange(ENotifyAll,stat3); |
1608 TheFs.NotifyChange(ENotifyAll,stat3); |
1608 test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending); |
1609 test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending); |
1609 RThread thread; |
1610 RThread thread; |
1610 r=thread.Create(_L("thread1"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1611 r=thread.Create(_L("thread1"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1611 test(r==KErrNone); |
1612 test_KErrNone(r); |
1612 TRequestStatus deathStat; |
1613 TRequestStatus deathStat; |
1613 thread.Logon( deathStat ); |
1614 thread.Logon( deathStat ); |
1614 thread.Resume(); |
1615 thread.Resume(); |
1615 User::After(1000000); |
1616 User::After(1000000); |
1616 User::WaitForRequest(stat3); |
1617 User::WaitForRequest(stat3); |
1633 // do an operation that will cause the change notification |
1634 // do an operation that will cause the change notification |
1634 // and disk change notification to be signalled |
1635 // and disk change notification to be signalled |
1635 test.Next(_L(" test change notification and disk space notification")); |
1636 test.Next(_L(" test change notification and disk space notification")); |
1636 RFs session2,session3; |
1637 RFs session2,session3; |
1637 r=session2.Connect(); |
1638 r=session2.Connect(); |
1638 test(r==KErrNone); |
1639 test_KErrNone(r); |
1639 r=session3.Connect(); |
1640 r=session3.Connect(); |
1640 test(r==KErrNone); |
1641 test_KErrNone(r); |
1641 r=session2.SetSessionPath(gSessionPath); |
1642 r=session2.SetSessionPath(gSessionPath); |
1642 test(r==KErrNone); |
1643 test_KErrNone(r); |
1643 r=session3.SetSessionPath(gSessionPath); |
1644 r=session3.SetSessionPath(gSessionPath); |
1644 test(r==KErrNone); |
1645 test_KErrNone(r); |
1645 task=ETaskFileWrite; |
1646 task=ETaskFileWrite; |
1646 InitialiseForThread(task); |
1647 InitialiseForThread(task); |
1647 free=FreeDiskSpace(KDefaultDrive); |
1648 free=FreeDiskSpace(KDefaultDrive); |
1648 threshold1=free-400; |
1649 threshold1=free-400; |
1649 TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1); |
1650 TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1); |
1650 session2.NotifyChange(ENotifyAll,stat2); |
1651 session2.NotifyChange(ENotifyAll,stat2); |
1651 session3.NotifyChange(ENotifyAll,stat3,KTestFile1); |
1652 session3.NotifyChange(ENotifyAll,stat3,KTestFile1); |
1652 test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending); |
1653 test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending); |
1653 r=thread.Create(_L("thread2"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1654 r=thread.Create(_L("thread2"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task); |
1654 test(r==KErrNone); |
1655 test_KErrNone(r); |
1655 thread.Logon( deathStat ); |
1656 thread.Logon( deathStat ); |
1656 thread.Resume(); |
1657 thread.Resume(); |
1657 User::After(1000000); |
1658 User::After(1000000); |
1658 User::WaitForRequest(stat1); |
1659 User::WaitForRequest(stat1); |
1659 User::WaitForRequest(stat2); |
1660 User::WaitForRequest(stat2); |