240 TInt64 free2; |
241 TInt64 free2; |
241 TInt64 free1; |
242 TInt64 free1; |
242 TInt64 diff; |
243 TInt64 diff; |
243 |
244 |
244 r=TheFs.GetReserveAccess(gTestDrive); |
245 r=TheFs.GetReserveAccess(gTestDrive); |
245 test(r==KErrPermissionDenied); |
246 test_Value(r, r == KErrPermissionDenied); |
246 |
247 |
247 //make sure nothing odd happens if we didnt already have access |
248 //make sure nothing odd happens if we didnt already have access |
248 r=TheFs.ReleaseReserveAccess(gTestDrive); |
249 r=TheFs.ReleaseReserveAccess(gTestDrive); |
249 test(r==KErrNone); |
250 test_KErrNone(r); |
250 |
251 |
251 |
252 |
252 GetFreeDiskSpace(free2); |
253 GetFreeDiskSpace(free2); |
253 |
254 |
254 r=TheFs.ReserveDriveSpace(gTestDrive,0x1000); |
255 r=TheFs.ReserveDriveSpace(gTestDrive,0x1000); |
255 test(r==KErrNone); |
256 test_KErrNone(r); |
256 |
257 |
257 GetFreeDiskSpace(free1); |
258 GetFreeDiskSpace(free1); |
258 diff = free2 - free1; |
259 diff = free2 - free1; |
259 test(I64INT(diff) > 0xfe0 && I64INT(diff) < 0x1100); |
260 test(I64INT(diff) > 0xfe0 && I64INT(diff) < 0x1100); |
260 |
261 |
261 r=TheFs.GetReserveAccess(gTestDrive); |
262 r=TheFs.GetReserveAccess(gTestDrive); |
262 test(r==KErrNone); |
263 test_KErrNone(r); |
263 |
264 |
264 GetFreeDiskSpace(free1); |
265 GetFreeDiskSpace(free1); |
265 TInt64 temp = free2-free1; |
266 TInt64 temp = free2-free1; |
266 test(I64INT(temp)>(-0x90) && I64INT(temp)<0x90); |
267 test(I64INT(temp)>(-0x90) && I64INT(temp)<0x90); |
267 |
268 |
268 r=TheFs.ReleaseReserveAccess(gTestDrive); |
269 r=TheFs.ReleaseReserveAccess(gTestDrive); |
269 test(r==KErrNone); |
270 test_KErrNone(r); |
270 GetFreeDiskSpace(free1); |
271 GetFreeDiskSpace(free1); |
271 |
272 |
272 diff = free2 - free1; |
273 diff = free2 - free1; |
273 test(I64INT(diff) > 0xfe0 && I64INT(diff) < 0x1100); |
274 test(I64INT(diff) > 0xfe0 && I64INT(diff) < 0x1100); |
274 |
275 |
275 |
276 |
276 //test reallocation of reserved space is possible |
277 //test reallocation of reserved space is possible |
277 r=TheFs.ReserveDriveSpace(gTestDrive,0x2000); |
278 r=TheFs.ReserveDriveSpace(gTestDrive,0x2000); |
278 test(r==KErrNone); |
279 test_KErrNone(r); |
279 |
280 |
280 //test upper limit of reserved space |
281 //test upper limit of reserved space |
281 r=TheFs.ReserveDriveSpace(gTestDrive,0x2000000); |
282 r=TheFs.ReserveDriveSpace(gTestDrive,0x2000000); |
282 test(r==KErrArgument); |
283 test_Value(r, r == KErrArgument); |
283 |
284 |
284 r=TheFs.ReserveDriveSpace(gTestDrive,0); |
285 r=TheFs.ReserveDriveSpace(gTestDrive,0); |
285 test(r==KErrNone); |
286 test_KErrNone(r); |
286 |
287 |
287 r=TheFs.GetReserveAccess(gTestDrive); |
288 r=TheFs.GetReserveAccess(gTestDrive); |
288 test(r==KErrPermissionDenied); |
289 test_Value(r, r == KErrPermissionDenied); |
289 |
290 |
290 //make sure nothing odd happens if we didnt already have access |
291 //make sure nothing odd happens if we didnt already have access |
291 r=TheFs.ReleaseReserveAccess(gTestDrive); |
292 r=TheFs.ReleaseReserveAccess(gTestDrive); |
292 test(r==KErrNone); |
293 test_KErrNone(r); |
293 |
294 |
294 r=TheFs.ReserveDriveSpace(gTestDrive,-45); |
295 r=TheFs.ReserveDriveSpace(gTestDrive,-45); |
295 test(r==KErrArgument); |
296 test_Value(r, r == KErrArgument); |
296 } |
297 } |
297 |
298 |
298 |
299 |
299 static void Test2() |
300 static void Test2() |
300 // |
301 // |
399 GetFreeDiskSpace(free2); |
400 GetFreeDiskSpace(free2); |
400 diff = free1-free2; |
401 diff = free1-free2; |
401 test(I64INT(diff)>0xFA00 && I64INT(diff)<0x103C4); |
402 test(I64INT(diff)>0xFA00 && I64INT(diff)<0x103C4); |
402 |
403 |
403 r = fs1.Connect(); |
404 r = fs1.Connect(); |
404 test(r==KErrNone); |
405 test_KErrNone(r); |
405 |
406 |
406 GetFreeDiskSpace(free1); |
407 GetFreeDiskSpace(free1); |
407 diff= free1-free2; |
408 diff= free1-free2; |
408 test(I64INT(diff)== 0 || I64INT(diff)<0xFA0 ); |
409 test(I64INT(diff)== 0 || I64INT(diff)<0xFA0 ); |
409 |
410 |
410 r=fs1.ReserveDriveSpace(gTestDrive,0x10000); |
411 r=fs1.ReserveDriveSpace(gTestDrive,0x10000); |
411 test(r==KErrNone); |
412 test_KErrNone(r); |
412 |
413 |
413 GetFreeDiskSpace(free2); |
414 GetFreeDiskSpace(free2); |
414 diff = free1 - free2; |
415 diff = free1 - free2; |
415 test(I64INT(diff)>0xFA00 && I64INT(diff)<0x103C4); |
416 test(I64INT(diff)>0xFA00 && I64INT(diff)<0x103C4); |
416 |
417 |
417 // Make sure no reserve space is allocated |
418 // Make sure no reserve space is allocated |
418 r=fs1.ReserveDriveSpace(gTestDrive,0); |
419 r=fs1.ReserveDriveSpace(gTestDrive,0); |
419 test(r==KErrNone); |
420 test_KErrNone(r); |
420 r=fs2.ReserveDriveSpace(gTestDrive,0); |
421 r=fs2.ReserveDriveSpace(gTestDrive,0); |
421 test(r==KErrNone); |
422 test_KErrNone(r); |
422 |
423 |
423 // Now fill up the disk |
424 // Now fill up the disk |
424 FillUpDisk(); |
425 FillUpDisk(); |
425 |
426 |
426 // Should fail as there is no space |
427 // Should fail as there is no space |
427 r=fs1.ReserveDriveSpace(gTestDrive,0x10000); |
428 r=fs1.ReserveDriveSpace(gTestDrive,0x10000); |
428 test(r==KErrDiskFull); |
429 test_Value(r, r == KErrDiskFull); |
429 |
430 |
430 SynchronousClose(fs1); |
431 SynchronousClose(fs1); |
431 SynchronousClose(fs2); |
432 SynchronousClose(fs2); |
432 } |
433 } |
433 |
434 |
463 TBuf<20> buf; |
464 TBuf<20> buf; |
464 buf=KTestFile; |
465 buf=KTestFile; |
465 buf[0]=(TUint16)gCh; |
466 buf[0]=(TUint16)gCh; |
466 |
467 |
467 r=file.Replace(fs, buf, EFileWrite); |
468 r=file.Replace(fs, buf, EFileWrite); |
468 test(r==KErrNone); |
469 test_KErrNone(r); |
469 |
470 |
470 r=file.Write(KTestData()); |
471 r=file.Write(KTestData()); |
471 test(r==KErrNone); |
472 test_KErrNone(r); |
472 |
473 |
473 file.Close(); |
474 file.Close(); |
474 |
475 |
475 r=fs.ReserveDriveSpace(gTestDrive,0x10000); //reserve some disk space |
476 r=fs.ReserveDriveSpace(gTestDrive,0x10000); //reserve some disk space |
476 test(r==KErrNone); |
477 test_KErrNone(r); |
477 |
478 |
478 FillUpDisk(); //fill up the disk |
479 FillUpDisk(); //fill up the disk |
479 |
480 |
480 TVolumeInfo v; //get disk space |
481 TVolumeInfo v; //get disk space |
481 r=fs.Volume(v,gTestDrive); |
482 r=fs.Volume(v,gTestDrive); |
482 test(r==KErrNone); |
483 test_KErrNone(r); |
483 freeA=v.iFree; |
484 freeA=v.iFree; |
484 |
485 |
485 r=fs.GetReserveAccess(gTestDrive); //get access to reserve space |
486 r=fs.GetReserveAccess(gTestDrive); //get access to reserve space |
486 test(r==KErrNone); |
487 test_KErrNone(r); |
487 |
488 |
488 r=fs.Volume(v,gTestDrive); //get disk space |
489 r=fs.Volume(v,gTestDrive); //get disk space |
489 test(r==KErrNone); |
490 test_KErrNone(r); |
490 freeB=v.iFree; |
491 freeB=v.iFree; |
491 |
492 |
492 r=fs.ReleaseReserveAccess(gTestDrive); //release reserve space |
493 r=fs.ReleaseReserveAccess(gTestDrive); //release reserve space |
493 test(r==KErrNone); |
494 test_KErrNone(r); |
494 |
495 |
495 test(freeA == (freeB - 0x10000)); //test difference in space is equal to the amount reserved |
496 test(freeA == (freeB - 0x10000)); //test difference in space is equal to the amount reserved |
496 |
497 |
497 r=fs.Volume(v,gTestDrive); //get disk space |
498 r=fs.Volume(v,gTestDrive); //get disk space |
498 test(r==KErrNone); |
499 test_KErrNone(r); |
499 freeB=v.iFree; |
500 freeB=v.iFree; |
500 test(freeA == freeB); //check reading is still correct |
501 test(freeA == freeB); //check reading is still correct |
501 |
502 |
502 TBuf <20> dir = KDir(); |
503 TBuf <20> dir = KDir(); |
503 dir[0]=(TUint16)gCh; |
504 dir[0]=(TUint16)gCh; |
504 r=fs.MkDir(dir); |
505 r=fs.MkDir(dir); |
505 test(r==KErrDiskFull); |
506 test_Value(r, r == KErrDiskFull); |
506 |
507 |
507 r=fs.MkDirAll(dir); |
508 r=fs.MkDirAll(dir); |
508 test(r==KErrDiskFull); |
509 test_Value(r, r == KErrDiskFull); |
509 |
510 |
510 TFileName temp; |
511 TFileName temp; |
511 TBuf<5> drv = KDrv(); |
512 TBuf<5> drv = KDrv(); |
512 drv[0]=(TUint16)gCh; |
513 drv[0]=(TUint16)gCh; |
513 r=file.Temp(fs, drv, temp, EFileWrite); |
514 r=file.Temp(fs, drv, temp, EFileWrite); |
514 test(r==KErrDiskFull); |
515 test_Value(r, r == KErrDiskFull); |
515 |
516 |
516 r=file.Replace(fs, buf, EFileWrite); |
517 r=file.Replace(fs, buf, EFileWrite); |
517 test(r==KErrDiskFull); |
518 test_Value(r, r == KErrDiskFull); |
518 |
519 |
519 r=file.Create(fs, buf, EFileWrite); |
520 r=file.Create(fs, buf, EFileWrite); |
520 test(r==KErrDiskFull); |
521 test_Value(r, r == KErrDiskFull); |
521 |
522 |
522 r=file.Open(fs, buf, EFileWrite); |
523 r=file.Open(fs, buf, EFileWrite); |
523 test(r==KErrNone); |
524 test_KErrNone(r); |
524 |
525 |
525 r=file.Write(128, KTestData()); |
526 r=file.Write(128, KTestData()); |
526 |
527 |
527 if ((gDriveCacheFlags & EFileCacheWriteOn) && (r == KErrNone)) |
528 if ((gDriveCacheFlags & EFileCacheWriteOn) && (r == KErrNone)) |
528 r = file.Flush(); |
529 r = file.Flush(); |
529 |
530 |
530 test(r==KErrDiskFull); |
531 test_Value(r, r == KErrDiskFull); |
531 |
532 |
532 r=file.SetSize(0x1000); |
533 r=file.SetSize(0x1000); |
533 test(r==KErrDiskFull); |
534 test_Value(r, r == KErrDiskFull); |
534 |
535 |
535 r=file.SetAtt(KEntryAttHidden,0); |
536 r=file.SetAtt(KEntryAttHidden,0); |
536 test(r==KErrDiskFull); |
537 test_Value(r, r == KErrDiskFull); |
537 |
538 |
538 TTime dtime; |
539 TTime dtime; |
539 r=file.SetModified(dtime); |
540 r=file.SetModified(dtime); |
540 test(r==KErrDiskFull); |
541 test_Value(r, r == KErrDiskFull); |
541 |
542 |
542 r=file.Set(dtime,KEntryAttHidden,0); |
543 r=file.Set(dtime,KEntryAttHidden,0); |
543 test(r==KErrDiskFull); |
544 test_Value(r, r == KErrDiskFull); |
544 |
545 |
545 r=file.Rename(buf); |
546 r=file.Rename(buf); |
546 test(r==KErrDiskFull); |
547 test_Value(r, r == KErrDiskFull); |
547 |
548 |
548 file.Close(); |
549 file.Close(); |
549 |
550 |
550 |
551 |
551 // Test that we can create a temporary file & write to it after acquiring reserved access, |
552 // Test that we can create a temporary file & write to it after acquiring reserved access, |
552 r=fs.GetReserveAccess(gTestDrive); //get access to reserve space |
553 r=fs.GetReserveAccess(gTestDrive); //get access to reserve space |
553 test(r==KErrNone); |
554 test_KErrNone(r); |
554 |
555 |
555 r=fs.Volume(v,gTestDrive); //get disk space |
556 r=fs.Volume(v,gTestDrive); //get disk space |
556 test(r==KErrNone); |
557 test_KErrNone(r); |
557 freeA = v.iFree; |
558 freeA = v.iFree; |
558 |
559 |
559 r=file.Temp(fs, drv, temp, EFileWrite); |
560 r=file.Temp(fs, drv, temp, EFileWrite); |
560 test(r==KErrNone); |
561 test_KErrNone(r); |
561 |
562 |
562 r = file.Write(KTestData()); |
563 r = file.Write(KTestData()); |
563 test (r == KErrNone); |
564 test_KErrNone(r); |
564 |
565 |
565 // If write caching is enabled, call RFs::Entry() to flush the file "anonymously" |
566 // If write caching is enabled, call RFs::Entry() to flush the file "anonymously" |
566 if ((gDriveCacheFlags & EFileCacheWriteOn) && (r == KErrNone)) |
567 if ((gDriveCacheFlags & EFileCacheWriteOn) && (r == KErrNone)) |
567 { |
568 { |
568 r = file.Flush(); |
569 r = file.Flush(); |
569 test (r == KErrNone); |
570 test_KErrNone(r); |
570 } |
571 } |
571 |
572 |
572 r=fs.Volume(v,gTestDrive); //get disk space |
573 r=fs.Volume(v,gTestDrive); //get disk space |
573 test(r==KErrNone); |
574 test_KErrNone(r); |
574 freeB = v.iFree; |
575 freeB = v.iFree; |
575 test (freeB < freeA); |
576 test (freeB < freeA); |
576 |
577 |
577 file.Close(); |
578 file.Close(); |
578 |
579 |
579 r=fs.ReleaseReserveAccess(gTestDrive); //release reserve space |
580 r=fs.ReleaseReserveAccess(gTestDrive); //release reserve space |
580 test(r==KErrNone); |
581 test_KErrNone(r); |
581 |
582 |
582 |
583 |
583 TBuf<20> newname =KNewName(); |
584 TBuf<20> newname =KNewName(); |
584 newname[0]=(TUint16)gCh; |
585 newname[0]=(TUint16)gCh; |
585 r=fs.Rename(buf, newname); |
586 r=fs.Rename(buf, newname); |
586 test(r==KErrDiskFull); |
587 test_Value(r, r == KErrDiskFull); |
587 |
588 |
588 r=fs.Replace(buf, newname); |
589 r=fs.Replace(buf, newname); |
589 test(r==KErrDiskFull); |
590 test_Value(r, r == KErrDiskFull); |
590 |
591 |
591 r=fs.SetEntry(buf, dtime, KEntryAttHidden, 0); |
592 r=fs.SetEntry(buf, dtime, KEntryAttHidden, 0); |
592 test(r==KErrDiskFull); |
593 test_Value(r, r == KErrDiskFull); |
593 |
594 |
594 r=fs.CreatePrivatePath(gTestDrive); |
595 r=fs.CreatePrivatePath(gTestDrive); |
595 test(r==KErrDiskFull); |
596 test_Value(r, r == KErrDiskFull); |
596 |
597 |
597 r=fs.SetVolumeLabel(_L("Moooo"), gTestDrive); |
598 r=fs.SetVolumeLabel(_L("Moooo"), gTestDrive); |
598 test(r==KErrDiskFull); |
599 test_Value(r, r == KErrDiskFull); |
599 |
600 |
600 r=fs.SetModified(buf, dtime); |
601 r=fs.SetModified(buf, dtime); |
601 test(r==KErrDiskFull); |
602 test_Value(r, r == KErrDiskFull); |
602 |
603 |
603 SynchronousClose(fs); |
604 SynchronousClose(fs); |
604 } |
605 } |
605 |
606 |
606 |
607 |
739 TInt64 diff(0); |
740 TInt64 diff(0); |
740 RThread t[KNumberThreads]; |
741 RThread t[KNumberThreads]; |
741 TRequestStatus tStat[KNumberThreads]; |
742 TRequestStatus tStat[KNumberThreads]; |
742 |
743 |
743 r=fsess.Connect(); |
744 r=fsess.Connect(); |
744 test(r==KErrNone); |
745 test_KErrNone(r); |
745 |
746 |
746 FormatDrive(); |
747 FormatDrive(); |
747 |
748 |
748 r= fsess.ShareAuto(); |
749 r= fsess.ShareAuto(); |
749 test(r==KErrNone); |
750 test_KErrNone(r); |
750 |
751 |
751 GetFreeDiskSpace(free1); |
752 GetFreeDiskSpace(free1); |
752 |
753 |
753 fsess.ReserveDriveSpace(gTestDrive,0x1000); |
754 fsess.ReserveDriveSpace(gTestDrive,0x1000); |
754 |
755 |
755 r = t[0].Create(_L("Sub_Thread1"),RsrvSpaceThread,KDefaultStackSize,KHeapSize,KHeapSize,&fsess); |
756 r = t[0].Create(_L("Sub_Thread1"),RsrvSpaceThread,KDefaultStackSize,KHeapSize,KHeapSize,&fsess); |
756 test(r==KErrNone); |
757 test_KErrNone(r); |
757 |
758 |
758 t[0].Rendezvous(tStat[0]); |
759 t[0].Rendezvous(tStat[0]); |
759 t[0].Resume(); |
760 t[0].Resume(); |
760 |
761 |
761 User::WaitForRequest(tStat[0]); |
762 User::WaitForRequest(tStat[0]); |
762 |
763 |
763 t[0].Close(); |
764 t[0].Close(); |
764 test(tStat[0]==KErrNone); |
765 test(tStat[0]==KErrNone); |
765 |
766 |
766 r = t[1].Create(_L("Sub_Thread2"),SessCloseThread,KDefaultStackSize,KHeapSize,KHeapSize,&fsess); |
767 r = t[1].Create(_L("Sub_Thread2"),SessCloseThread,KDefaultStackSize,KHeapSize,KHeapSize,&fsess); |
767 test(r==KErrNone); |
768 test_KErrNone(r); |
768 |
769 |
769 t[1].Rendezvous(tStat[1]); |
770 t[1].Rendezvous(tStat[1]); |
770 t[1].Resume(); |
771 t[1].Resume(); |
771 |
772 |
772 User::WaitForRequest(tStat[1]); |
773 User::WaitForRequest(tStat[1]); |
924 TUint att; |
925 TUint att; |
925 TTime time; |
926 TTime time; |
926 |
927 |
927 RFs fs; |
928 RFs fs; |
928 TInt err = fs.Connect(); |
929 TInt err = fs.Connect(); |
929 test(err == KErrNone); |
930 test_KErrNone(err); |
930 |
931 |
931 RFile file; |
932 RFile file; |
932 TBuf<20> fileName; |
933 TBuf<20> fileName; |
933 fileName = KTestFile; |
934 fileName = KTestFile; |
934 fileName[0] = (TUint16)gCh; |
935 fileName[0] = (TUint16)gCh; |
935 |
936 |
936 err = fs.ReserveDriveSpace(gTestDrive,0x10000); |
937 err = fs.ReserveDriveSpace(gTestDrive,0x10000); |
937 test(err == KErrNone); |
938 test_KErrNone(err); |
938 |
939 |
939 err = file.Replace(fs, fileName, EFileWrite); |
940 err = file.Replace(fs, fileName, EFileWrite); |
940 test(err == KErrNone); |
941 test_KErrNone(err); |
941 |
942 |
942 err = file.Write(KTestData); |
943 err = file.Write(KTestData); |
943 test(err == KErrNone); |
944 test_KErrNone(err); |
944 |
945 |
945 err = file.Flush(); |
946 err = file.Flush(); |
946 test(err == KErrNone); |
947 test_KErrNone(err); |
947 |
948 |
948 file.Close(); |
949 file.Close(); |
949 |
950 |
950 err = file.Open(fs, fileName, EFileRead); |
951 err = file.Open(fs, fileName, EFileRead); |
951 test(err == KErrNone); |
952 test_KErrNone(err); |
952 |
953 |
953 err = file.Att(att); |
954 err = file.Att(att); |
954 test(err == KErrNone); |
955 test_KErrNone(err); |
955 |
956 |
956 err = file.Modified(time); |
957 err = file.Modified(time); |
957 test(err == KErrNone); |
958 test_KErrNone(err); |
958 |
959 |
959 file.Close(); |
960 file.Close(); |
960 |
961 |
961 FillUpDisk(); |
962 FillUpDisk(); |
962 |
963 |
963 err = file.Open(fs, fileName, EFileRead); |
964 err = file.Open(fs, fileName, EFileRead); |
964 test(err == KErrNone); |
965 test_KErrNone(err); |
965 |
966 |
966 TUint att1; |
967 TUint att1; |
967 err = file.Att(att1); |
968 err = file.Att(att1); |
968 test(err == KErrNone); |
969 test_KErrNone(err); |
969 test(att1 == att); |
970 test(att1 == att); |
970 |
971 |
971 TTime time1; |
972 TTime time1; |
972 err = file.Modified(time1); |
973 err = file.Modified(time1); |
973 test(err == KErrNone); |
974 test_KErrNone(err); |
974 test(time1 == time); |
975 test(time1 == time); |
975 |
976 |
976 file.Close(); |
977 file.Close(); |
977 fs.Close(); |
978 fs.Close(); |
978 |
979 |
1029 const TUint32 DummyFileLen = (TUint32)(lowRegion / MaxDummyFiles); |
1030 const TUint32 DummyFileLen = (TUint32)(lowRegion / MaxDummyFiles); |
1030 TInt i; |
1031 TInt i; |
1031 for(i=0; i<MaxDummyFiles; ++i) |
1032 for(i=0; i<MaxDummyFiles; ++i) |
1032 { |
1033 { |
1033 nRes = CreateFileX(KBaseFN, i, DummyFileLen); |
1034 nRes = CreateFileX(KBaseFN, i, DummyFileLen); |
1034 test(nRes == KErrNone); |
1035 test_KErrNone(nRes); |
1035 } |
1036 } |
1036 |
1037 |
1037 //-- 3. create a real file that crosses 4G boundary |
1038 //-- 3. create a real file that crosses 4G boundary |
1038 nRes = CreateCheckableStuffedFile(TheFs, KBaseFN, 5*K1MegaByte); |
1039 nRes = CreateCheckableStuffedFile(TheFs, KBaseFN, 5*K1MegaByte); |
1039 test(nRes == KErrNone); |
1040 test_KErrNone(nRes); |
1040 |
1041 |
1041 test.Printf(_L("Verifying the file that crosses 4G boundary.\n")); |
1042 test.Printf(_L("Verifying the file that crosses 4G boundary.\n")); |
1042 |
1043 |
1043 nRes = VerifyCheckableFile(TheFs, KBaseFN); |
1044 nRes = VerifyCheckableFile(TheFs, KBaseFN); |
1044 test(nRes == KErrNone); |
1045 test_KErrNone(nRes); |
1045 |
1046 |
1046 |
1047 |
1047 nRes = TheFs.Delete(KBaseFN); |
1048 nRes = TheFs.Delete(KBaseFN); |
1048 test(nRes == KErrNone); |
1049 test_KErrNone(nRes); |
1049 for(i=0; i<MaxDummyFiles; ++i) |
1050 for(i=0; i<MaxDummyFiles; ++i) |
1050 { |
1051 { |
1051 nRes = DeleteFileX(KBaseFN, i); |
1052 nRes = DeleteFileX(KBaseFN, i); |
1052 test(nRes == KErrNone); |
1053 test_KErrNone(nRes); |
1053 } |
1054 } |
1054 } |
1055 } |
|
1056 |
|
1057 void TestRAMDriveNotification() |
|
1058 { |
|
1059 test.Next(_L("Verifying RFs::ReserveDriveSpace() triggers RFs::NotifyDiskSpace() events")); |
|
1060 |
|
1061 TInt64 freeSpace; |
|
1062 GetFreeDiskSpace(freeSpace); |
|
1063 test.Printf(_L("free space: 0x%Lx bytes\n"), freeSpace); |
|
1064 |
|
1065 // set a notification on half the amount we plan to reserve |
|
1066 TInt reserve = 4096; |
|
1067 TInt64 trigger = freeSpace - 2048; |
|
1068 test.Printf(_L("setting notification for space to fall below: 0x%Lx bytes ... "), trigger); |
|
1069 TRequestStatus stat; |
|
1070 TheFs.NotifyDiskSpace(trigger, gTestDrive, stat); |
|
1071 test_Value(stat.Int(), stat == KRequestPending); |
|
1072 test.Printf(_L("ok\n")); |
|
1073 |
|
1074 // reserve the space and validate that this triggers the notification |
|
1075 test.Printf(_L("reserving 0x%x bytes ..."), reserve); |
|
1076 TInt r = TheFs.ReserveDriveSpace(gTestDrive, reserve); |
|
1077 test_KErrNone(r); |
|
1078 test.Printf(_L("ok\n")); |
|
1079 |
|
1080 test.Printf(_L("validating that the disk space notification triggered ... ")); |
|
1081 User::After(2000000); // 2 seconds should be enough to cause the trigger |
|
1082 test_Value(stat.Int(), stat == KErrNone); |
|
1083 test.Printf(_L("ok\n")); |
|
1084 } |
|
1085 |
|
1086 |
1055 |
1087 |
1056 //----------------------------------------------------------------------------- |
1088 //----------------------------------------------------------------------------- |
1057 |
1089 /** |
1058 GLDEF_C void CallTestsL() |
1090 Test that the reserving some drive space does not takes more space than required. |
|
1091 */ |
|
1092 void Test0() |
|
1093 { |
|
1094 test.Next(_L("test ReserveDriveSpace threshold")); |
|
1095 |
|
1096 TInt nRes; |
|
1097 TVolumeIOParamInfo volIop; |
|
1098 TInt64 freespace=0; |
|
1099 |
|
1100 //-- 1. format the volume |
|
1101 FormatDrive(); |
|
1102 |
|
1103 GetFreeDiskSpace(freespace); |
|
1104 const TInt64 freeSpace1 = freespace; //-- initial amount of free space on the volume |
|
1105 |
|
1106 nRes = TheFs.VolumeIOParam(gTestDrive, volIop); |
|
1107 test_KErrNone(nRes); |
|
1108 const TInt KClusterSz = volIop.iClusterSize; |
|
1109 if(!IsPowerOf2(KClusterSz)) |
|
1110 { |
|
1111 test.Next(_L("The FS hasn't reported a cluster size. The test is inconsistent, skipping")); |
|
1112 return; |
|
1113 } |
|
1114 |
|
1115 //-- reserve exactly 1 cluster worth drive space. |
|
1116 nRes = TheFs.ReserveDriveSpace(gTestDrive, KClusterSz); |
|
1117 test_KErrNone(nRes); |
|
1118 |
|
1119 GetFreeDiskSpace(freespace); |
|
1120 const TInt64 freeSpace2 = freespace; |
|
1121 test((freeSpace1 - freeSpace2) == KClusterSz); |
|
1122 |
|
1123 //-- fill up a drive (it has a reserved space) |
|
1124 FillUpDisk(); |
|
1125 |
|
1126 //-- delete 1 file; |
|
1127 nRes = DeleteFileX(KBaseName, 0); |
|
1128 test_KErrNone(nRes); |
|
1129 |
|
1130 //-- try to create a file with the size that is exacly the same as free space; it should succeed |
|
1131 GetFreeDiskSpace(freespace); |
|
1132 |
|
1133 nRes = CreateEmptyFile(TheFs, _L("\\aaa1"), freespace); |
|
1134 test_KErrNone(nRes); |
|
1135 |
|
1136 GetFreeDiskSpace(freespace); |
|
1137 test(freespace == 0); |
|
1138 |
|
1139 //-- return the drive space to the system |
|
1140 nRes = TheFs.ReserveDriveSpace(gTestDrive,0); |
|
1141 test_KErrNone(nRes); |
|
1142 |
|
1143 //-- release drive space |
|
1144 nRes = TheFs.ReleaseReserveAccess(gTestDrive); |
|
1145 test_KErrNone(nRes); |
|
1146 |
|
1147 GetFreeDiskSpace(freespace); |
|
1148 test(freespace == KClusterSz); |
|
1149 |
|
1150 FormatDrive(); |
|
1151 } |
|
1152 |
|
1153 //----------------------------------------------------------------------------- |
|
1154 void CallTestsL() |
1059 // |
1155 // |
1060 // Do tests relative to session path |
1156 // Do tests relative to session path |
1061 // |
1157 // |
1062 { |
1158 { |
1063 //-- set up console output |
1159 //-- set up console output |
1064 Fat_Test_Utils::SetConsole(test.Console()); |
1160 Fat_Test_Utils::SetConsole(test.Console()); |
1065 |
1161 |
1066 if (UserSvr::DebugMask(2)&0x00000002) // TESTFAST mode set? (for automated test builds) |
1162 // If TESTFAST mode (for automated test builds) is set, don't run LFFS tests. |
1067 if(IsTestingLFFS()) |
1163 if ((UserSvr::DebugMask(2) & 0x00000002) && IsTestingLFFS()) |
1068 { |
1164 { |
1069 // Don't run on LFFS (to increase speed of automated testing) |
1165 test.Printf(_L("TEST NOT RUN FOR LFFS DRIVE")); |
1070 test.Printf(_L("TEST NOT RUN FOR THIS DRIVE")); |
1166 return; |
1071 return; |
1167 } |
1072 } |
|
1073 |
1168 |
1074 //get the number of the drive we are currently testing |
1169 //get the number of the drive we are currently testing |
1075 TInt r=0; |
1170 TInt r=0; |
1076 r=RFs::CharToDrive(gSessionPath[0],gTestDrive); |
1171 r=RFs::CharToDrive(gSessionPath[0],gTestDrive); |
1077 test(r==KErrNone); |
1172 test_KErrNone(r); |
1078 |
1173 |
1079 r=RFs::DriveToChar(gTestDrive,gCh); |
1174 r=RFs::DriveToChar(gTestDrive,gCh); |
1080 test(r==KErrNone); |
1175 test_KErrNone(r); |
1081 |
1176 |
1082 TDriveInfo drv; |
1177 TDriveInfo drv; |
1083 r = TheFs.Drive(drv, gTestDrive); |
1178 r = TheFs.Drive(drv, gTestDrive); |
1084 test(r == KErrNone); |
1179 test_KErrNone(r); |
1085 |
1180 |
1086 if (Is_Win32(TheFs, gTestDrive)) |
1181 |
1087 { |
1182 //-- print drive information |
1088 test.Printf(_L("Skipping on emulator %C: drive\n"), gSessionPath[0]); |
1183 PrintDrvInfo(TheFs, gTestDrive); |
1089 return; |
1184 |
1090 } |
1185 |
1091 |
1186 // do not run the remainder of this test on RAM drive |
1092 // do not run this test on RAM drive |
1187 if (drv.iType == EMediaRam) |
1093 if (drv.iType == EMediaRam) |
1188 { |
1094 { |
1189 TestRAMDriveNotification(); // Test drive space reservations trigger disk space notifications |
1095 test.Printf(_L("Test can't run on RAM drive %C:\n"), gSessionPath[0]); |
1190 test.Printf(_L("Main tests can't run on RAM drive %C:\n"), gSessionPath[0]); |
1096 return; |
1191 return; |
1097 } |
1192 } |
1098 |
1193 |
1099 //-- print drive information |
1194 if (Is_Win32(TheFs, gTestDrive)) |
1100 PrintDrvInfo(TheFs, gTestDrive); |
1195 { |
1101 |
1196 test.Printf(_L("Skipping on emulator %C: drive\n"), gSessionPath[0]); |
1102 Test1(); //General test for new APIs |
1197 return; |
1103 Test2(); //Test to ensure drive and session reserve limits are not exceeded |
1198 } |
|
1199 |
|
1200 Test0(); |
|
1201 Test1(); // General test for new APIs |
|
1202 Test2(); // Test to ensure drive and session reserve limits are not exceeded |
1104 Test3(); |
1203 Test3(); |
1105 Test4(); //test filling the drive and that each checked API fails |
1204 Test4(); // test filling the drive and that each checked API fails |
1106 Test5(); |
1205 Test5(); |
1107 Test6(); |
1206 Test6(); |
1108 Test7(); |
1207 Test7(); |
1109 TestForDEF142554(); |
1208 TestForDEF142554(); |
1110 Test2(); //run this test to check reserves are being cleared correctly |
1209 Test2(); // run this test to check reserves are being cleared correctly |
1111 |
1210 |
1112 TestFAT4G_Boundary(); |
1211 TestFAT4G_Boundary(); |
1113 |
1212 |
1114 TurnAllocFailureOff(); |
1213 TurnAllocFailureOff(); |
1115 } |
1214 } |
1116 |
|
1117 |
|
1118 |
|
1119 |
|