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 GLDEF_C void CallTestsL() |
1059 // |
1091 // |
1060 // Do tests relative to session path |
1092 // Do tests relative to session path |
1061 // |
1093 // |
1062 { |
1094 { |
1063 //-- set up console output |
1095 //-- set up console output |
1064 Fat_Test_Utils::SetConsole(test.Console()); |
1096 Fat_Test_Utils::SetConsole(test.Console()); |
1065 |
1097 |
1066 if (UserSvr::DebugMask(2)&0x00000002) // TESTFAST mode set? (for automated test builds) |
1098 // If TESTFAST mode (for automated test builds) is set, don't run LFFS tests. |
1067 if(IsTestingLFFS()) |
1099 if ((UserSvr::DebugMask(2) & 0x00000002) && IsTestingLFFS()) |
1068 { |
1100 { |
1069 // Don't run on LFFS (to increase speed of automated testing) |
1101 test.Printf(_L("TEST NOT RUN FOR LFFS DRIVE")); |
1070 test.Printf(_L("TEST NOT RUN FOR THIS DRIVE")); |
1102 return; |
1071 return; |
1103 } |
1072 } |
|
1073 |
1104 |
1074 //get the number of the drive we are currently testing |
1105 //get the number of the drive we are currently testing |
1075 TInt r=0; |
1106 TInt r=0; |
1076 r=RFs::CharToDrive(gSessionPath[0],gTestDrive); |
1107 r=RFs::CharToDrive(gSessionPath[0],gTestDrive); |
1077 test(r==KErrNone); |
1108 test_KErrNone(r); |
1078 |
1109 |
1079 r=RFs::DriveToChar(gTestDrive,gCh); |
1110 r=RFs::DriveToChar(gTestDrive,gCh); |
1080 test(r==KErrNone); |
1111 test_KErrNone(r); |
1081 |
1112 |
1082 TDriveInfo drv; |
1113 TDriveInfo drv; |
1083 r = TheFs.Drive(drv, gTestDrive); |
1114 r = TheFs.Drive(drv, gTestDrive); |
1084 test(r == KErrNone); |
1115 test_KErrNone(r); |
1085 |
1116 |
1086 if (Is_Win32(TheFs, gTestDrive)) |
1117 |
1087 { |
1118 //-- print drive information |
1088 test.Printf(_L("Skipping on emulator %C: drive\n"), gSessionPath[0]); |
1119 PrintDrvInfo(TheFs, gTestDrive); |
1089 return; |
1120 |
1090 } |
1121 |
1091 |
1122 // do not run the remainder of this test on RAM drive |
1092 // do not run this test on RAM drive |
1123 if (drv.iType == EMediaRam) |
1093 if (drv.iType == EMediaRam) |
1124 { |
1094 { |
1125 TestRAMDriveNotification(); // Test drive space reservations trigger disk space notifications |
1095 test.Printf(_L("Test can't run on RAM drive %C:\n"), gSessionPath[0]); |
1126 test.Printf(_L("Main tests can't run on RAM drive %C:\n"), gSessionPath[0]); |
1096 return; |
1127 return; |
1097 } |
1128 } |
1098 |
1129 |
1099 //-- print drive information |
1130 if (Is_Win32(TheFs, gTestDrive)) |
1100 PrintDrvInfo(TheFs, gTestDrive); |
1131 { |
1101 |
1132 test.Printf(_L("Skipping on emulator %C: drive\n"), gSessionPath[0]); |
1102 Test1(); //General test for new APIs |
1133 return; |
1103 Test2(); //Test to ensure drive and session reserve limits are not exceeded |
1134 } |
|
1135 |
|
1136 Test1(); // General test for new APIs |
|
1137 Test2(); // Test to ensure drive and session reserve limits are not exceeded |
1104 Test3(); |
1138 Test3(); |
1105 Test4(); //test filling the drive and that each checked API fails |
1139 Test4(); // test filling the drive and that each checked API fails |
1106 Test5(); |
1140 Test5(); |
1107 Test6(); |
1141 Test6(); |
1108 Test7(); |
1142 Test7(); |
1109 TestForDEF142554(); |
1143 TestForDEF142554(); |
1110 Test2(); //run this test to check reserves are being cleared correctly |
1144 Test2(); // run this test to check reserves are being cleared correctly |
1111 |
1145 |
1112 TestFAT4G_Boundary(); |
1146 TestFAT4G_Boundary(); |
1113 |
1147 |
1114 TurnAllocFailureOff(); |
1148 TurnAllocFailureOff(); |
1115 } |
1149 } |
1116 |
|
1117 |
|
1118 |
|
1119 |
|