34 |
35 |
35 GLDEF_D TFileName StartupExeName=_L(""); // initialised at run time |
36 GLDEF_D TFileName StartupExeName=_L(""); // initialised at run time |
36 |
37 |
37 #ifdef _DEBUG |
38 #ifdef _DEBUG |
38 GLREF_D RTest test; |
39 GLREF_D RTest test; |
39 GLDEF_D TInt TheFunctionNumber; |
40 GLDEF_D TInt TheFunctionNumber; // Indicates which test to run |
40 GLDEF_D TInt TheOpNumber; |
41 GLDEF_D TInt TheOpNumber; // Indicates which file operation to be tested |
41 GLDEF_D TInt TheFailCount; |
42 GLDEF_D TInt TheFailCount; |
42 GLDEF_D TBool IsReset; |
43 GLDEF_D TBool IsReset; |
43 GLDEF_D TFileName TestExeName=_L("?:\\T_SCANDR.EXE"); //Renaming it to fit in one root dir entry. |
44 GLDEF_D TFileName TestExeName=_L("?:\\T_SCANDR.EXE"); //Renaming it to fit in one root dir entry. |
44 GLDEF_D TFileName LogFileName=_L("?:\\T_SCANDR.LOG"); //Renaming it to fit in one root dir entry. |
45 GLDEF_D TFileName LogFileName=_L("?:\\T_SCANDR.LOG"); //Renaming it to fit in one root dir entry. |
45 |
46 |
46 const TInt KControlIoWriteFailOn=0; // commands to pass into RFs::ControlIo |
47 const TInt KControlIoWriteFailOn=0; // commands to pass into RFs::ControlIo |
54 const TInt KDirAttrArchive = 0x20; |
55 const TInt KDirAttrArchive = 0x20; |
55 const TInt KDirAttrLongName = KDirAttrReadOnly | KDirAttrHidden | KDirAttrSystem | KDirAttrVolumeId; |
56 const TInt KDirAttrLongName = KDirAttrReadOnly | KDirAttrHidden | KDirAttrSystem | KDirAttrVolumeId; |
56 const TInt KDirAttrLongMask = KDirAttrLongName | KDirAttrDirectory | KDirAttrArchive; |
57 const TInt KDirAttrLongMask = KDirAttrLongName | KDirAttrDirectory | KDirAttrArchive; |
57 const TInt KDirLastLongEntry = 0x40; |
58 const TInt KDirLastLongEntry = 0x40; |
58 |
59 |
59 GLDEF_D TInt WriteFailValue; |
60 GLDEF_D TInt WriteFailValue; // Indicates what error should return from a write failure |
60 |
61 // Value assigned in t_scn32dr2 and t_scn32dr3 |
61 LOCAL_C TFatBootSector BootSector; |
62 LOCAL_C TFatBootSector BootSector; |
62 LOCAL_D RRawDisk TheRawDisk; |
63 LOCAL_D RRawDisk TheRawDisk; |
63 |
64 |
64 static TFatType gDiskType = EInvalid; |
65 static TFatType gDiskType = EInvalid; |
65 |
66 |
77 LOCAL_D TInt gClusterCount; |
78 LOCAL_D TInt gClusterCount; |
78 |
79 |
79 LOCAL_D HBufC8* gFatBuf = NULL; |
80 LOCAL_D HBufC8* gFatBuf = NULL; |
80 LOCAL_D TInt gFatAddr = -1; |
81 LOCAL_D TInt gFatAddr = -1; |
81 |
82 |
82 enum TFatChain {EChainStd,EChainAlternate,EChainBackwards,EChainForwards}; |
83 enum TFatChain |
|
84 { |
|
85 EChainStd, // Cluster chain grows contiguously |
|
86 EChainAlternate, // Cluster chain grows forward but not contiguously |
|
87 EChainBackwards, // Cluster chain first goes backwards(up to 3.5kb for fat16 file) and then forwards |
|
88 EChainForwards // Cluster chain first goes forward (upto 3.5kb for fat16 file) and then backwards |
|
89 }; |
83 |
90 |
84 LOCAL_C TBool IsInternalRam() |
91 LOCAL_C TBool IsInternalRam() |
85 // |
92 // |
86 // Returns true if the selected drive is variable size (i.e. RAM drive) |
93 // Returns true if the selected drive is variable size (i.e. RAM drive) |
87 // |
94 // |
88 { |
95 { |
89 TVolumeInfo v; |
96 TVolumeInfo v; |
90 TInt r=TheFs.Volume(v,gSessionPath[0]-'A'); |
97 TInt r=TheFs.Volume(v,gSessionPath[0]-'A'); |
91 test(r==KErrNone); |
98 test_KErrNone(r); |
92 return(v.iDrive.iMediaAtt&KMediaAttVariableSize); |
99 return(v.iDrive.iMediaAtt&KMediaAttVariableSize); |
93 } |
100 } |
94 |
101 |
95 LOCAL_C void WriteLogFile() |
102 LOCAL_C void WriteLogFile() |
96 // |
103 // |
100 test.Printf(_L("Writelogfile()\n")); |
107 test.Printf(_L("Writelogfile()\n")); |
101 RFile log; |
108 RFile log; |
102 TInt r=log.Open(TheFs,LogFileName,EFileShareExclusive|EFileWrite); |
109 TInt r=log.Open(TheFs,LogFileName,EFileShareExclusive|EFileWrite); |
103 if(r!=KErrNone) |
110 if(r!=KErrNone) |
104 test.Printf(_L("error=%d\n"),r); |
111 test.Printf(_L("error=%d\n"),r); |
105 test(r==KErrNone); |
112 test_KErrNone(r); |
106 TInt size; |
113 TInt size; |
107 r=log.Size(size); |
114 r=log.Size(size); |
108 test(r==KErrNone); |
115 test_KErrNone(r); |
109 TBuf8<16> buf; |
116 TBuf8<16> buf; |
110 buf.SetLength(4); |
117 buf.SetLength(4); |
111 buf[0]=(TUint8)TheFunctionNumber; |
118 buf[0]=(TUint8)TheFunctionNumber; |
112 buf[1]=(TUint8)TheOpNumber; |
119 buf[1]=(TUint8)TheOpNumber; |
113 buf[2]=(TUint8)TheFailCount; |
120 buf[2]=(TUint8)TheFailCount; |
114 buf[3]='\n'; |
121 buf[3]='\n'; |
115 r=log.Write(size,buf,buf.Length()); |
122 r=log.Write(size,buf,buf.Length()); |
116 test(r==KErrNone); |
123 test_KErrNone(r); |
117 test.Printf(_L("Written func=%d,op=%d,fail=%d\n"),TheFunctionNumber,TheOpNumber,TheFailCount); |
124 test.Printf(_L("Written func=%d,op=%d,fail=%d\n"),TheFunctionNumber,TheOpNumber,TheFailCount); |
118 log.Close(); |
125 log.Close(); |
119 } |
126 } |
120 |
127 |
121 LOCAL_C TInt SetWriteFailOn(TInt aFailCount) |
128 LOCAL_C TInt SetWriteFailOn(TInt aFailCount) |
185 /** |
192 /** |
186 Fill media with zeroes from aStartPos to aEndPos |
193 Fill media with zeroes from aStartPos to aEndPos |
187 */ |
194 */ |
188 static void DoZeroFillMedia(TInt64 aStartPos, TInt64 aEndPos, RRawDisk& aWriter) |
195 static void DoZeroFillMedia(TInt64 aStartPos, TInt64 aEndPos, RRawDisk& aWriter) |
189 { |
196 { |
190 test(aStartPos >=0 && aEndPos >=0 && aStartPos < aEndPos); |
197 test(aStartPos >=0 && aEndPos >=0 && aStartPos < aEndPos); |
191 |
198 |
192 if(aStartPos == aEndPos) |
199 if(aStartPos == aEndPos) |
193 return; |
200 return; |
194 |
201 |
195 RBuf8 buf; |
202 RBuf8 buf; |
196 TInt nRes; |
203 TInt nRes; |
197 |
204 |
198 const TUint32 KBufSz=65536*2; //-- buffer with zeroes |
205 const TUint32 KBufSz=65536*2; //-- buffer with zeroes |
199 |
206 |
200 nRes = buf.CreateMax(KBufSz); |
207 nRes = buf.CreateMax(KBufSz); |
201 test(nRes == KErrNone); |
208 test_KErrNone(nRes); |
202 |
209 |
203 buf.FillZ(); |
210 buf.FillZ(); |
204 |
211 |
205 TUint32 rem = (TUint32)(aEndPos - aStartPos); |
212 TUint32 rem = (TUint32)(aEndPos - aStartPos); |
206 while(rem) |
213 while(rem) |
207 { |
214 { |
208 const TUint32 bytesToWrite=Min(rem, KBufSz); |
215 const TUint32 bytesToWrite=Min(rem, KBufSz); |
209 |
216 |
210 TPtrC8 ptr(buf.Ptr(), bytesToWrite); |
217 TPtrC8 ptr(buf.Ptr(), bytesToWrite); |
211 nRes = aWriter.Write(aStartPos, ptr); |
218 nRes = aWriter.Write(aStartPos, ptr); |
212 test(nRes == KErrNone || nRes == KErrDiskFull); |
219 test_Value(nRes, nRes == KErrNone || nRes == KErrDiskFull); |
213 |
220 |
214 aStartPos+=bytesToWrite; |
221 aStartPos+=bytesToWrite; |
215 rem-=bytesToWrite; |
222 rem-=bytesToWrite; |
216 } |
223 } |
217 |
224 |
567 { |
586 { |
568 TBuf16<15> name; |
587 TBuf16<15> name; |
569 ExtractNameString(name, aEntry); |
588 ExtractNameString(name, aEntry); |
570 TInt ord = aEntry[0]; |
589 TInt ord = aEntry[0]; |
571 if (ord & KDirLastLongEntry) |
590 if (ord & KDirLastLongEntry) |
572 RDebug::Print(_L("%5d: %-15S #%-2d LAST"), aNum, &name, ord & ~KDirLastLongEntry); |
591 RDebug::Print(_L("%5d: %-15S #%-2d LAST"), aNum, &MakePrintable(name), ord & ~KDirLastLongEntry); |
573 else |
592 else |
574 RDebug::Print(_L("%5d: %-15S #%-2d"), aNum, &name, ord & ~KDirLastLongEntry); |
593 RDebug::Print(_L("%5d: %-15S #%-2d"), aNum, &MakePrintable(name), ord & ~KDirLastLongEntry); |
575 } |
594 } |
576 else if (!IsValidDirEntry(d)) |
595 else if (!IsValidDirEntry(d)) |
577 return EFalse; |
596 return EFalse; |
578 else |
597 else |
579 { |
598 { |
580 TBuf<11> name; |
599 TBuf<11> name; |
581 name.Copy(d->Name()); |
600 name.Copy(d->Name()); |
582 RDebug::Print(_L("%5d: '%S' %S cluster %d"), |
601 RDebug::Print(_L("%5d: '%S' %S cluster %d"), |
583 aNum, &name, DirAttributes(d->Attributes()), d->StartCluster()); |
602 aNum, &MakePrintable(name), DirAttributes(d->Attributes()), d->StartCluster()); |
584 } |
603 } |
585 return ETrue; |
604 return ETrue; |
586 } |
605 } |
587 |
606 |
588 GLDEF_C void DumpDirCluster(const TUint8* aData, TInt aCluster=0) |
607 GLDEF_C void DumpDirCluster(const TUint8* aData, TInt aCluster=0) |
617 for (TInt cluster = aStart; cluster < aEnd; cluster++) |
636 for (TInt cluster = aStart; cluster < aEnd; cluster++) |
618 { |
637 { |
619 if (GetFatEntry(cluster, aFat) != 0) |
638 if (GetFatEntry(cluster, aFat) != 0) |
620 { |
639 { |
621 HBufC8* buf=HBufC8::New(gBytesPerCluster); |
640 HBufC8* buf=HBufC8::New(gBytesPerCluster); |
622 test(buf!=NULL); |
641 test_NotNull(buf); |
623 TPtr8 ptr=buf->Des(); |
642 TPtr8 ptr=buf->Des(); |
624 TInt r=TheRawDisk.Open(TheFs,gSessionPath[0]-'A'); |
643 TInt r=TheRawDisk.Open(TheFs,gSessionPath[0]-'A'); |
625 test(r==KErrNone); |
644 test_KErrNone(r); |
626 r=TheRawDisk.Read(ClusterToByte(cluster), ptr); |
645 r=TheRawDisk.Read(ClusterToByte(cluster), ptr); |
627 test(r==KErrNone); |
646 test_KErrNone(r); |
628 TheRawDisk.Close(); |
647 TheRawDisk.Close(); |
629 RDebug::Print(_L("Cluster %d @ 0x%08X:"), cluster, ClusterToByte(cluster)); |
648 RDebug::Print(_L("Cluster %d @ 0x%08X:"), cluster, ClusterToByte(cluster)); |
630 DumpDirCluster(ptr.Ptr()); |
649 DumpDirCluster(ptr.Ptr()); |
631 delete buf; |
650 delete buf; |
632 } |
651 } |
990 // |
1009 // |
991 // Deletes entry with aName and corresponding entries created for EChainForward |
1010 // Deletes entry with aName and corresponding entries created for EChainForward |
992 // |
1011 // |
993 { |
1012 { |
994 TInt r=TheFs.Delete(_L("\\fat\\file2")); |
1013 TInt r=TheFs.Delete(_L("\\fat\\file2")); |
995 test(r==KErrNone||r==KErrNotFound); |
1014 test_Value(r, r==KErrNone||r==KErrNotFound); |
996 r=TheFs.Delete(_L("\\fat\\file4")); |
1015 r=TheFs.Delete(_L("\\fat\\file4")); |
997 test(r==KErrNone||r==KErrNotFound); |
1016 test_Value(r, r==KErrNone||r==KErrNotFound); |
998 r=TheFs.Delete(_L("\\fat\\file5")); |
1017 r=TheFs.Delete(_L("\\fat\\file5")); |
999 test(r==KErrNone||r==KErrNotFound); |
1018 test_Value(r, r==KErrNone||r==KErrNotFound); |
1000 if(aIsDir) |
1019 if(aIsDir) |
1001 r=TheFs.RmDir(aName); |
1020 r=TheFs.RmDir(aName); |
1002 else |
1021 else |
1003 r=TheFs.Delete(aName); |
1022 r=TheFs.Delete(aName); |
1004 return r; |
1023 return r; |
1009 // Creates an entry whose cluster chain first goes forward (upto 3.5kb for fat16 file) |
1028 // Creates an entry whose cluster chain first goes forward (upto 3.5kb for fat16 file) |
1010 // and then backwards |
1029 // and then backwards |
1011 // |
1030 // |
1012 { |
1031 { |
1013 TInt r=DeleteForwardEntry(aName,aIsDir); |
1032 TInt r=DeleteForwardEntry(aName,aIsDir); |
1014 test(r==KErrNone||r==KErrNotFound); |
1033 test_Value(r, r==KErrNone||r==KErrNotFound); |
1015 RFile file1,file2,entry; |
1034 RFile file1,file2,entry; |
1016 r=file1.Create(TheFs,_L("\\fat\\file1"),EFileShareAny); |
1035 r=file1.Create(TheFs,_L("\\fat\\file1"),EFileShareAny); |
1017 test(r==KErrNone); |
1036 test_KErrNone(r); |
1018 r=file1.SetSize(EntriesPerFatSector()*gBytesPerCluster); |
1037 r=file1.SetSize(EntriesPerFatSector()*gBytesPerCluster); |
1019 test(r==KErrNone); |
1038 test_KErrNone(r); |
1020 r=file2.Create(TheFs,_L("\\fat\\file2"),EFileShareAny); |
1039 r=file2.Create(TheFs,_L("\\fat\\file2"),EFileShareAny); |
1021 test(r==KErrNone); |
1040 test_KErrNone(r); |
1022 r=file2.SetSize(EntriesPerFatSector()*gBytesPerCluster); |
1041 r=file2.SetSize(EntriesPerFatSector()*gBytesPerCluster); |
1023 test(r==KErrNone); |
1042 test_KErrNone(r); |
1024 if(aIsDir) |
1043 if(aIsDir) |
1025 { |
1044 { |
1026 r=TheFs.MkDir(aName); |
1045 r=TheFs.MkDir(aName); |
1027 if(r!=KErrNone) |
1046 if(r!=KErrNone) |
1028 return(r); |
1047 return(r); |
1031 { |
1050 { |
1032 r=entry.Create(TheFs,aName,EFileShareAny); |
1051 r=entry.Create(TheFs,aName,EFileShareAny); |
1033 if(r!=KErrNone) |
1052 if(r!=KErrNone) |
1034 return(r); |
1053 return(r); |
1035 r=entry.SetSize(1); // ensure entry has start cluster allocated |
1054 r=entry.SetSize(1); // ensure entry has start cluster allocated |
1036 test(r==KErrNone); |
1055 test_KErrNone(r); |
1037 } |
1056 } |
1038 CreateAlternate(_L("\\fat\\file3"),_L("\\fat\\file4")); |
1057 CreateAlternate(_L("\\fat\\file3"),_L("\\fat\\file4")); |
1039 RFile file5; |
1058 RFile file5; |
1040 r=file5.Create(TheFs,_L("\\fat\\file5"),EFileShareAny); |
1059 r=file5.Create(TheFs,_L("\\fat\\file5"),EFileShareAny); |
1041 test(r==KErrNone); |
1060 test_KErrNone(r); |
1042 r=file5.SetSize(EntriesPerFatSector()*gBytesPerCluster*2); |
1061 r=file5.SetSize(EntriesPerFatSector()*gBytesPerCluster*2); |
1043 test(r==KErrNone); |
1062 test_KErrNone(r); |
1044 file1.Close(); |
1063 file1.Close(); |
1045 file2.Close(); |
1064 file2.Close(); |
1046 file5.Close(); |
1065 file5.Close(); |
1047 r=TheFs.Delete(_L("\\fat\\file1")); |
1066 r=TheFs.Delete(_L("\\fat\\file1")); |
1048 test(r==KErrNone); |
1067 test_KErrNone(r); |
1049 r=TheFs.Delete(_L("\\fat\\file3")); |
1068 r=TheFs.Delete(_L("\\fat\\file3")); |
1050 test(r==KErrNone); |
1069 test_KErrNone(r); |
1051 if(aIsDir) |
1070 if(aIsDir) |
1052 ExpandDirectory(aName,aSize); |
1071 ExpandDirectory(aName,aSize); |
1053 else |
1072 else |
1054 { |
1073 { |
1055 r=entry.SetSize(aSize); |
1074 r=entry.SetSize(aSize); |
1056 test(r==KErrNone); |
1075 test_KErrNone(r); |
1057 entry.Close(); |
1076 entry.Close(); |
1058 } |
1077 } |
1059 return(KErrNone); |
1078 return(KErrNone); |
1060 } |
1079 } |
1061 |
1080 |
1204 test.Start(_L("TestRFsDelete")); |
1223 test.Start(_L("TestRFsDelete")); |
1205 FOREVER |
1224 FOREVER |
1206 { |
1225 { |
1207 test.Printf(_L("failCount=%d\n"),failCount); |
1226 test.Printf(_L("failCount=%d\n"),failCount); |
1208 r=CreateEntry(aName,EFalse,aChain,aFileSize); |
1227 r=CreateEntry(aName,EFalse,aChain,aFileSize); |
1209 test(r==KErrNone||r==KErrAlreadyExists); |
1228 test_Value(r, r==KErrNone||r==KErrAlreadyExists); |
1210 if(IsReset) |
1229 if(IsReset) |
1211 { |
1230 { |
1212 ++TheFailCount; |
1231 ++TheFailCount; |
1213 WriteLogFile(); |
1232 WriteLogFile(); |
1214 } |
1233 } |
1215 r=SetWriteFailOn(failCount); |
1234 r=SetWriteFailOn(failCount); |
1216 test(r==KErrNone); |
1235 test_KErrNone(r); |
1217 r=TheFs.Delete(aName); |
1236 r=TheFs.Delete(aName); |
1218 if(r==KErrNone) |
1237 if(r==KErrNone) |
1219 break; |
1238 break; |
1220 test(r==WriteFailValue); |
1239 test_Equal(WriteFailValue,r); |
1221 r=TheFs.ScanDrive(gSessionPath); |
1240 r=TheFs.ScanDrive(gSessionPath); |
1222 test(r==KErrNone); |
1241 test_KErrNone(r); |
1223 r=TheFs.CheckDisk(gSessionPath); |
1242 r=TheFs.CheckDisk(gSessionPath); |
1224 test(r==KErrNone); |
1243 test_KErrNone(r); |
1225 ++failCount; |
1244 ++failCount; |
1226 } |
1245 } |
1227 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1246 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1228 test(r==KErrNone); |
1247 test_KErrNone(r); |
1229 r=TheFs.CheckDisk(gSessionPath); |
1248 r=TheFs.CheckDisk(gSessionPath); |
1230 test(r==KErrNone); |
1249 test_KErrNone(r); |
1231 test(!EntryExists(aName)); |
1250 test(!EntryExists(aName)); |
1232 ++TheOpNumber; |
1251 ++TheOpNumber; |
1233 TheFailCount=0; |
1252 TheFailCount=0; |
1234 } |
1253 } |
1235 |
1254 |
1260 } |
1279 } |
1261 FOREVER |
1280 FOREVER |
1262 { |
1281 { |
1263 test.Printf(_L("failCount=%d\n"),failCount); |
1282 test.Printf(_L("failCount=%d\n"),failCount); |
1264 r=CreateEntry(aName,ETrue,aChain,aDirSize); |
1283 r=CreateEntry(aName,ETrue,aChain,aDirSize); |
1265 test(r==KErrNone||r==KErrAlreadyExists); |
1284 test_Value(r, r==KErrNone||r==KErrAlreadyExists); |
1266 if(IsReset) |
1285 if(IsReset) |
1267 { |
1286 { |
1268 ++TheFailCount; |
1287 ++TheFailCount; |
1269 WriteLogFile(); |
1288 WriteLogFile(); |
1270 } |
1289 } |
1271 r=SetWriteFailOn(failCount); |
1290 r=SetWriteFailOn(failCount); |
1272 test(r==KErrNone); |
1291 test_KErrNone(r); |
1273 r=TheFs.RmDir(aName); |
1292 r=TheFs.RmDir(aName); |
1274 if(r==KErrNone) |
1293 if(r==KErrNone) |
1275 break; |
1294 break; |
1276 test(r==WriteFailValue); |
1295 test_Equal(WriteFailValue,r); |
1277 r=TheFs.ScanDrive(gSessionPath); |
1296 r=TheFs.ScanDrive(gSessionPath); |
1278 RDebug::Print(_L("%6d: ScanDrive = %d"), __LINE__, r); |
1297 RDebug::Print(_L("%6d: ScanDrive = %d"), __LINE__, r); |
1279 if (r != KErrNone) |
1298 if (r != KErrNone) |
1280 { |
1299 { |
1281 RDebug::Print(_L("ScanDrive fail %d"), r); |
1300 RDebug::Print(_L("ScanDrive fail %d"), r); |
1282 DumpFat(); |
1301 DumpFat(); |
1283 DumpData(NULL, 0, 200); |
1302 DumpData(NULL, 0, 200); |
1284 } |
1303 } |
1285 test(r==KErrNone); |
1304 test_KErrNone(r); |
1286 r=TheFs.CheckDisk(gSessionPath); |
1305 r=TheFs.CheckDisk(gSessionPath); |
1287 RDebug::Print(_L("%6d: CheckDisk = %d"), __LINE__, r); |
1306 RDebug::Print(_L("%6d: CheckDisk = %d"), __LINE__, r); |
1288 test(r==KErrNone); |
1307 test_KErrNone(r); |
1289 ++failCount; |
1308 ++failCount; |
1290 } |
1309 } |
1291 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1310 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1292 test(r==KErrNone); |
1311 test_KErrNone(r); |
1293 r=TheFs.CheckDisk(gSessionPath); |
1312 r=TheFs.CheckDisk(gSessionPath); |
1294 test(r==KErrNone); |
1313 test_KErrNone(r); |
1295 test(!EntryExists(aName)); |
1314 test(!EntryExists(aName)); |
1296 ++TheOpNumber; |
1315 ++TheOpNumber; |
1297 TheFailCount=0; |
1316 TheFailCount=0; |
1298 } |
1317 } |
1299 |
1318 |
1307 test.Next(_L("TestRFsMkDir")); |
1326 test.Next(_L("TestRFsMkDir")); |
1308 FOREVER |
1327 FOREVER |
1309 { |
1328 { |
1310 test.Printf(_L("failCount=%d\n"),failCount); |
1329 test.Printf(_L("failCount=%d\n"),failCount); |
1311 r=DeleteEntry(aName,ETrue,EChainStd); |
1330 r=DeleteEntry(aName,ETrue,EChainStd); |
1312 test(r==KErrNone||r==KErrNotFound); |
1331 test_Value(r, r==KErrNone||r==KErrNotFound); |
1313 if(IsReset) |
1332 if(IsReset) |
1314 { |
1333 { |
1315 ++TheFailCount; |
1334 ++TheFailCount; |
1316 WriteLogFile(); |
1335 WriteLogFile(); |
1317 } |
1336 } |
1318 r=SetWriteFailOn(failCount); |
1337 r=SetWriteFailOn(failCount); |
1319 test(r==KErrNone); |
1338 test_KErrNone(r); |
1320 r=TheFs.MkDir(aName); |
1339 r=TheFs.MkDir(aName); |
1321 if(r==KErrNone) |
1340 if(r==KErrNone) |
1322 break; |
1341 break; |
1323 test(r==WriteFailValue); |
1342 test_Equal(WriteFailValue,r); |
1324 r=TheFs.ScanDrive(gSessionPath); |
1343 r=TheFs.ScanDrive(gSessionPath); |
1325 test(r==KErrNone); |
1344 test_KErrNone(r); |
1326 r=TheFs.CheckDisk(gSessionPath); |
1345 r=TheFs.CheckDisk(gSessionPath); |
1327 test(r==KErrNone); |
1346 test_KErrNone(r); |
1328 ++failCount; |
1347 ++failCount; |
1329 } |
1348 } |
1330 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1349 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1331 test(r==KErrNone); |
1350 test_KErrNone(r); |
1332 r=TheFs.CheckDisk(gSessionPath); |
1351 r=TheFs.CheckDisk(gSessionPath); |
1333 test(r==KErrNone); |
1352 test_KErrNone(r); |
1334 test(EntryExists(aName)); |
1353 test(EntryExists(aName)); |
1335 r=DeleteEntry(aName,ETrue,EChainStd); |
1354 r=DeleteEntry(aName,ETrue,EChainStd); |
1336 test(r==KErrNone); |
1355 test_KErrNone(r); |
1337 ++TheOpNumber; |
1356 ++TheOpNumber; |
1338 TheFailCount=0; |
1357 TheFailCount=0; |
1339 } |
1358 } |
1340 |
1359 |
1341 LOCAL_C void TestRFsRename(const TDesC& aOldName,const TDesC& aNewName,TBool aIsDir,TFatChain aChain,TInt aSize) |
1360 LOCAL_C void TestRFsRename(const TDesC& aOldName,const TDesC& aNewName,TBool aIsDir,TFatChain aChain,TInt aSize) |
1349 TEntry oldEntryInfo,newEntryInfo; |
1368 TEntry oldEntryInfo,newEntryInfo; |
1350 FOREVER |
1369 FOREVER |
1351 { |
1370 { |
1352 test.Printf(_L("failCount=%d\n"),failCount); |
1371 test.Printf(_L("failCount=%d\n"),failCount); |
1353 r=CreateEntry(aOldName,aIsDir,aChain,aSize); |
1372 r=CreateEntry(aOldName,aIsDir,aChain,aSize); |
1354 test(r==KErrNone||r==KErrAlreadyExists); |
1373 test_Value(r, r==KErrNone||r==KErrAlreadyExists); |
1355 r=DeleteEntry(aNewName,aIsDir,aChain); |
1374 r=DeleteEntry(aNewName,aIsDir,aChain); |
1356 test(r==KErrNone||r==KErrNotFound); |
1375 test_Value(r, r==KErrNone||r==KErrNotFound); |
1357 GetEntryDetails(aOldName,oldEntryInfo); |
1376 GetEntryDetails(aOldName,oldEntryInfo); |
1358 if(IsReset) |
1377 if(IsReset) |
1359 { |
1378 { |
1360 ++TheFailCount; |
1379 ++TheFailCount; |
1361 WriteLogFile(); |
1380 WriteLogFile(); |
1362 } |
1381 } |
1363 r=SetWriteFailOn(failCount); |
1382 r=SetWriteFailOn(failCount); |
1364 test(r==KErrNone); |
1383 test_KErrNone(r); |
1365 r=TheFs.Rename(aOldName,aNewName); |
1384 r=TheFs.Rename(aOldName,aNewName); |
1366 if(r==KErrNone) |
1385 if(r==KErrNone) |
1367 break; |
1386 break; |
1368 if(r!=WriteFailValue) |
1387 test_Equal(WriteFailValue,r); |
1369 { |
|
1370 test.Printf(_L("r=%d\n"),r); |
|
1371 test(EFalse); |
|
1372 } |
|
1373 test(r==WriteFailValue); |
|
1374 r=TheFs.ScanDrive(gSessionPath); |
1388 r=TheFs.ScanDrive(gSessionPath); |
1375 test(r==KErrNone); |
1389 test_KErrNone(r); |
1376 r=TheFs.CheckDisk(gSessionPath); |
1390 r=TheFs.CheckDisk(gSessionPath); |
1377 test(r==KErrNone); |
1391 test_KErrNone(r); |
1378 // no start cluster if aSize==0 |
1392 // no start cluster if aSize==0 |
1379 if(aSize!=0) |
1393 if(aSize!=0) |
1380 test(OneEntryExists(aOldName,aNewName)); |
1394 test(OneEntryExists(aOldName,aNewName)); |
1381 ++failCount; |
1395 ++failCount; |
1382 } |
1396 } |
1383 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1397 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1384 test(r==KErrNone); |
1398 test_KErrNone(r); |
1385 r=TheFs.CheckDisk(gSessionPath); |
1399 r=TheFs.CheckDisk(gSessionPath); |
1386 test(r==KErrNone); |
1400 test_KErrNone(r); |
1387 test(EntryExists(aNewName) && !EntryExists(aOldName)); |
1401 test(EntryExists(aNewName) && !EntryExists(aOldName)); |
1388 GetEntryDetails(aNewName,newEntryInfo); |
1402 GetEntryDetails(aNewName,newEntryInfo); |
1389 test(IsSameEntryDetails(oldEntryInfo,newEntryInfo)); |
1403 test(IsSameEntryDetails(oldEntryInfo,newEntryInfo)); |
1390 r=DeleteEntry(aNewName,aIsDir,aChain); |
1404 r=DeleteEntry(aNewName,aIsDir,aChain); |
1391 test(r==KErrNone); |
1405 test_KErrNone(r); |
1392 ++TheOpNumber; |
1406 ++TheOpNumber; |
1393 TheFailCount=0; |
1407 TheFailCount=0; |
1394 } |
1408 } |
1395 |
1409 |
1396 LOCAL_C void TestRFsReplace(const TDesC& aOldName, const TDesC& aNewName,TBool aBothExist,TFatChain aChain,TInt aFileSize) |
1410 LOCAL_C void TestRFsReplace(const TDesC& aOldName, const TDesC& aNewName,TBool aBothExist,TFatChain aChain,TInt aFileSize) |
1408 TEntry oldEntryInfo,newEntryInfo; |
1422 TEntry oldEntryInfo,newEntryInfo; |
1409 FOREVER |
1423 FOREVER |
1410 { |
1424 { |
1411 test.Printf(_L("failCount=%d\n"),failCount); |
1425 test.Printf(_L("failCount=%d\n"),failCount); |
1412 r=CreateEntry(aOldName,EFalse,aChain,aFileSize); |
1426 r=CreateEntry(aOldName,EFalse,aChain,aFileSize); |
1413 test(r==KErrNone||r==KErrAlreadyExists); |
1427 test_Value(r, r==KErrNone||r==KErrAlreadyExists); |
1414 if(aBothExist) |
1428 if(aBothExist) |
1415 { |
1429 { |
1416 r=CreateEntry(aNewName,EFalse,aChain,aFileSize); |
1430 r=CreateEntry(aNewName,EFalse,aChain,aFileSize); |
1417 test(r==KErrNone||r==KErrAlreadyExists); |
1431 test_Value(r, r==KErrNone||r==KErrAlreadyExists); |
1418 } |
1432 } |
1419 else |
1433 else |
1420 { |
1434 { |
1421 r=DeleteEntry(aNewName,EFalse,aChain); |
1435 r=DeleteEntry(aNewName,EFalse,aChain); |
1422 test(r==KErrNone||r==KErrNotFound); |
1436 test_Value(r, r==KErrNone||r==KErrNotFound); |
1423 } |
1437 } |
1424 GetEntryDetails(aOldName,oldEntryInfo); |
1438 GetEntryDetails(aOldName,oldEntryInfo); |
1425 if(IsReset) |
1439 if(IsReset) |
1426 { |
1440 { |
1427 ++TheFailCount; |
1441 ++TheFailCount; |
1428 WriteLogFile(); |
1442 WriteLogFile(); |
1429 } |
1443 } |
1430 r=SetWriteFailOn(failCount); |
1444 r=SetWriteFailOn(failCount); |
1431 test(r==KErrNone); |
1445 test_KErrNone(r); |
1432 r=TheFs.Replace(aOldName,aNewName); |
1446 r=TheFs.Replace(aOldName,aNewName); |
1433 if(r==KErrNone) |
1447 if(r==KErrNone) |
1434 break; |
1448 break; |
1435 test(r==WriteFailValue); |
1449 test_Equal(WriteFailValue,r); |
1436 r=TheFs.ScanDrive(gSessionPath); |
1450 r=TheFs.ScanDrive(gSessionPath); |
1437 test(r==KErrNone); |
1451 test_KErrNone(r); |
1438 r=TheFs.CheckDisk(gSessionPath); |
1452 r=TheFs.CheckDisk(gSessionPath); |
1439 test(r==KErrNone); |
1453 test_KErrNone(r); |
1440 if(!aBothExist && aFileSize!=0) |
1454 if(!aBothExist && aFileSize!=0) |
1441 test(OneEntryExists(aOldName,aNewName)); |
1455 test(OneEntryExists(aOldName,aNewName)); |
1442 else if(aBothExist) |
1456 else if(aBothExist) |
1443 test(EntryExists(aOldName)||EntryExists(aNewName)); |
1457 test(EntryExists(aOldName)||EntryExists(aNewName)); |
1444 ++failCount; |
1458 ++failCount; |
1445 } |
1459 } |
1446 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1460 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1447 test(r==KErrNone); |
1461 test_KErrNone(r); |
1448 r=TheFs.CheckDisk(gSessionPath); |
1462 r=TheFs.CheckDisk(gSessionPath); |
1449 test(r==KErrNone); |
1463 test_KErrNone(r); |
1450 test(EntryExists(aNewName) && !EntryExists(aOldName)); |
1464 test(EntryExists(aNewName) && !EntryExists(aOldName)); |
1451 GetEntryDetails(aNewName,newEntryInfo); |
1465 GetEntryDetails(aNewName,newEntryInfo); |
1452 test(IsSameEntryDetails(oldEntryInfo,newEntryInfo)); |
1466 test(IsSameEntryDetails(oldEntryInfo,newEntryInfo)); |
1453 r=DeleteEntry(aNewName,EFalse,aChain); |
1467 r=DeleteEntry(aNewName,EFalse,aChain); |
1454 test(r==KErrNone); |
1468 test_KErrNone(r); |
1455 ++TheOpNumber; |
1469 ++TheOpNumber; |
1456 TheFailCount=0; |
1470 TheFailCount=0; |
1457 } |
1471 } |
1458 |
1472 |
1459 LOCAL_C void TestRFileCreate(const TDesC& aName) |
1473 LOCAL_C void TestRFileCreate(const TDesC& aName) |
1466 test.Next(_L("TestRFileCreate")); |
1480 test.Next(_L("TestRFileCreate")); |
1467 FOREVER |
1481 FOREVER |
1468 { |
1482 { |
1469 test.Printf(_L("failCount=%d\n"),failCount); |
1483 test.Printf(_L("failCount=%d\n"),failCount); |
1470 r=DeleteEntry(aName,EFalse,EChainStd); |
1484 r=DeleteEntry(aName,EFalse,EChainStd); |
1471 test(r==KErrNone||r==KErrNotFound); |
1485 test_Value(r, r==KErrNone||r==KErrNotFound); |
1472 if(IsReset) |
1486 if(IsReset) |
1473 { |
1487 { |
1474 ++TheFailCount; |
1488 ++TheFailCount; |
1475 WriteLogFile(); |
1489 WriteLogFile(); |
1476 } |
1490 } |
1477 r=SetWriteFailOn(failCount); |
1491 r=SetWriteFailOn(failCount); |
1478 test(r==KErrNone); |
1492 test_KErrNone(r); |
1479 RFile file; |
1493 RFile file; |
1480 r=file.Create(TheFs,aName,EFileShareAny); |
1494 r=file.Create(TheFs,aName,EFileShareAny); |
1481 if(r==KErrNone) |
1495 if(r==KErrNone) |
1482 { |
1496 { |
1483 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1497 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1484 test(r==KErrNone); |
1498 test_KErrNone(r); |
1485 file.Close(); |
1499 file.Close(); |
1486 break; |
1500 break; |
1487 } |
1501 } |
1488 test(r==WriteFailValue); |
1502 test_Equal(WriteFailValue,r); |
1489 r=TheFs.ScanDrive(gSessionPath); |
1503 r=TheFs.ScanDrive(gSessionPath); |
1490 test(r==KErrNone); |
1504 test_KErrNone(r); |
1491 r=TheFs.CheckDisk(gSessionPath); |
1505 r=TheFs.CheckDisk(gSessionPath); |
1492 test(r==KErrNone); |
1506 test_KErrNone(r); |
1493 ++failCount; |
1507 ++failCount; |
1494 } |
1508 } |
1495 r=TheFs.CheckDisk(gSessionPath); |
1509 r=TheFs.CheckDisk(gSessionPath); |
1496 test(r==KErrNone); |
1510 test_KErrNone(r); |
1497 test(EntryExists(aName)); |
1511 test(EntryExists(aName)); |
1498 r=DeleteEntry(aName,EFalse,EChainStd); |
1512 r=DeleteEntry(aName,EFalse,EChainStd); |
1499 test(r==KErrNone); |
1513 test_KErrNone(r); |
1500 ++TheOpNumber; |
1514 ++TheOpNumber; |
1501 TheFailCount=0; |
1515 TheFailCount=0; |
1502 } |
1516 } |
1503 |
1517 |
1504 LOCAL_C void TestRFileTemp(const TDesC& aPath) |
1518 LOCAL_C void TestRFileTemp(const TDesC& aPath) |
1517 { |
1531 { |
1518 ++TheFailCount; |
1532 ++TheFailCount; |
1519 WriteLogFile(); |
1533 WriteLogFile(); |
1520 } |
1534 } |
1521 r=SetWriteFailOn(failCount); |
1535 r=SetWriteFailOn(failCount); |
1522 test(r==KErrNone); |
1536 test_KErrNone(r); |
1523 RFile file; |
1537 RFile file; |
1524 r=file.Temp(TheFs,aPath,temp,EFileShareAny); |
1538 r=file.Temp(TheFs,aPath,temp,EFileShareAny); |
1525 if(r==KErrNone) |
1539 if(r==KErrNone) |
1526 { |
1540 { |
1527 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1541 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1528 test(r==KErrNone); |
1542 test_KErrNone(r); |
1529 file.Close(); |
1543 file.Close(); |
1530 break; |
1544 break; |
1531 } |
1545 } |
1532 test(r==WriteFailValue); |
1546 test(r==WriteFailValue); |
1533 r=TheFs.ScanDrive(gSessionPath); |
1547 r=TheFs.ScanDrive(gSessionPath); |
1534 test(r==KErrNone); |
1548 test_KErrNone(r); |
1535 r=TheFs.CheckDisk(gSessionPath); |
1549 r=TheFs.CheckDisk(gSessionPath); |
1536 test(r==KErrNone); |
1550 test_KErrNone(r); |
1537 ++failCount; |
1551 ++failCount; |
1538 } |
1552 } |
1539 r=TheFs.CheckDisk(gSessionPath); |
1553 r=TheFs.CheckDisk(gSessionPath); |
1540 test(r==KErrNone); |
1554 test_KErrNone(r); |
1541 test(EntryExists(temp)); |
1555 test(EntryExists(temp)); |
1542 r=DeleteEntry(temp,EFalse,EChainStd); |
1556 r=DeleteEntry(temp,EFalse,EChainStd); |
1543 test(r==KErrNone); |
1557 test_KErrNone(r); |
1544 ++TheOpNumber; |
1558 ++TheOpNumber; |
1545 TheFailCount=0; |
1559 TheFailCount=0; |
1546 } |
1560 } |
1547 |
1561 |
1548 LOCAL_C void TestRFileRename(const TDesC& aOldName, const TDesC& aNewName,TFatChain aChain,TInt aFileSize) |
1562 LOCAL_C void TestRFileRename(const TDesC& aOldName, const TDesC& aNewName,TFatChain aChain,TInt aFileSize) |
1556 TEntry oldEntryInfo,newEntryInfo; |
1570 TEntry oldEntryInfo,newEntryInfo; |
1557 FOREVER |
1571 FOREVER |
1558 { |
1572 { |
1559 test.Printf(_L("failCount=%d\n"),failCount); |
1573 test.Printf(_L("failCount=%d\n"),failCount); |
1560 r=CreateEntry(aOldName,EFalse,aChain,aFileSize); |
1574 r=CreateEntry(aOldName,EFalse,aChain,aFileSize); |
1561 test(r==KErrNone||r==KErrAlreadyExists); |
1575 test_Value(r, r==KErrNone||r==KErrAlreadyExists); |
1562 r=DeleteEntry(aNewName,EFalse,aChain); |
1576 r=DeleteEntry(aNewName,EFalse,aChain); |
1563 test(r==KErrNone||r==KErrNotFound); |
1577 test_Value(r, r==KErrNone||r==KErrNotFound); |
1564 GetEntryDetails(aOldName,oldEntryInfo); |
1578 GetEntryDetails(aOldName,oldEntryInfo); |
1565 if(IsReset) |
1579 if(IsReset) |
1566 { |
1580 { |
1567 ++TheFailCount; |
1581 ++TheFailCount; |
1568 WriteLogFile(); |
1582 WriteLogFile(); |
1569 } |
1583 } |
1570 RFile file; |
1584 RFile file; |
1571 r=file.Open(TheFs,aOldName,EFileShareExclusive|EFileWrite); |
1585 r=file.Open(TheFs,aOldName,EFileShareExclusive|EFileWrite); |
1572 test(r==KErrNone); |
1586 test_KErrNone(r); |
1573 r=SetWriteFailOn(failCount); |
1587 r=SetWriteFailOn(failCount); |
1574 test(r==KErrNone); |
1588 test_KErrNone(r); |
1575 r=file.Rename(aNewName); |
1589 r=file.Rename(aNewName); |
1576 if(r==KErrNone) |
1590 if(r==KErrNone) |
1577 { |
1591 { |
1578 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1592 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1579 test(r==KErrNone); |
1593 test_KErrNone(r); |
1580 file.Close(); |
1594 file.Close(); |
1581 break; |
1595 break; |
1582 } |
1596 } |
1583 test(r==WriteFailValue); |
1597 test_Equal(WriteFailValue,r); |
1584 file.Close(); |
1598 file.Close(); |
1585 r=TheFs.ScanDrive(gSessionPath); |
1599 r=TheFs.ScanDrive(gSessionPath); |
1586 test(r==KErrNone); |
1600 test_KErrNone(r); |
1587 r=TheFs.CheckDisk(gSessionPath); |
1601 r=TheFs.CheckDisk(gSessionPath); |
1588 test(r==KErrNone); |
1602 test_KErrNone(r); |
1589 if(aFileSize) |
1603 if(aFileSize) |
1590 test(OneEntryExists(aOldName,aNewName)); |
1604 test(OneEntryExists(aOldName,aNewName)); |
1591 ++failCount; |
1605 ++failCount; |
1592 } |
1606 } |
1593 r=TheFs.CheckDisk(gSessionPath); |
1607 r=TheFs.CheckDisk(gSessionPath); |
1594 test(r==KErrNone); |
1608 test_KErrNone(r); |
1595 test(EntryExists(aNewName) && !EntryExists(aOldName)); |
1609 test(EntryExists(aNewName) && !EntryExists(aOldName)); |
1596 GetEntryDetails(aNewName,newEntryInfo); |
1610 GetEntryDetails(aNewName,newEntryInfo); |
1597 test(IsSameEntryDetails(oldEntryInfo,newEntryInfo)); |
1611 test(IsSameEntryDetails(oldEntryInfo,newEntryInfo)); |
1598 r=DeleteEntry(aNewName,EFalse,aChain); |
1612 r=DeleteEntry(aNewName,EFalse,aChain); |
1599 test(r==KErrNone); |
1613 test_KErrNone(r); |
1600 ++TheOpNumber; |
1614 ++TheOpNumber; |
1601 TheFailCount=0; |
1615 TheFailCount=0; |
1602 } |
1616 } |
1603 |
1617 |
1604 LOCAL_C void TestRFileReplace(const TDesC& aName,TBool aAlreadyExists,TFatChain aChain,TInt aFileSize) |
1618 LOCAL_C void TestRFileReplace(const TDesC& aName,TBool aAlreadyExists,TFatChain aChain,TInt aFileSize) |
1613 { |
1627 { |
1614 test.Printf(_L("failCount=%d\n"),failCount); |
1628 test.Printf(_L("failCount=%d\n"),failCount); |
1615 if(aAlreadyExists) |
1629 if(aAlreadyExists) |
1616 { |
1630 { |
1617 r=CreateEntry(aName,EFalse,aChain,aFileSize); |
1631 r=CreateEntry(aName,EFalse,aChain,aFileSize); |
1618 test(r==KErrNone||r==KErrAlreadyExists); |
1632 test_Value(r, r==KErrNone||r==KErrAlreadyExists); |
1619 } |
1633 } |
1620 else |
1634 else |
1621 { |
1635 { |
1622 r=DeleteEntry(aName,EFalse,aChain); |
1636 r=DeleteEntry(aName,EFalse,aChain); |
1623 test(r==KErrNone||r==KErrNotFound); |
1637 test_Value(r, r==KErrNone||r==KErrNotFound); |
1624 } |
1638 } |
1625 if(IsReset) |
1639 if(IsReset) |
1626 { |
1640 { |
1627 ++TheFailCount; |
1641 ++TheFailCount; |
1628 WriteLogFile(); |
1642 WriteLogFile(); |
1629 } |
1643 } |
1630 r=SetWriteFailOn(failCount); |
1644 r=SetWriteFailOn(failCount); |
1631 test(r==KErrNone); |
1645 test_KErrNone(r); |
1632 RFile file; |
1646 RFile file; |
1633 r=file.Replace(TheFs,aName,EFileShareAny); |
1647 r=file.Replace(TheFs,aName,EFileShareAny); |
1634 if(r==KErrNone) |
1648 if(r==KErrNone) |
1635 { |
1649 { |
1636 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1650 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1637 test(r==KErrNone); |
1651 test_KErrNone(r); |
1638 file.Close(); |
1652 file.Close(); |
1639 break; |
1653 break; |
1640 } |
1654 } |
1641 test(r==WriteFailValue); |
1655 test_Equal(WriteFailValue,r); |
1642 r=TheFs.ScanDrive(gSessionPath); |
1656 r=TheFs.ScanDrive(gSessionPath); |
1643 test(r==KErrNone); |
1657 test_KErrNone(r); |
1644 r=TheFs.CheckDisk(gSessionPath); |
1658 r=TheFs.CheckDisk(gSessionPath); |
1645 test(r==KErrNone); |
1659 test_KErrNone(r); |
1646 ++failCount; |
1660 ++failCount; |
1647 } |
1661 } |
1648 r=TheFs.CheckDisk(gSessionPath); |
1662 r=TheFs.CheckDisk(gSessionPath); |
1649 test(r==KErrNone); |
1663 test_KErrNone(r); |
1650 test(EntryExists(aName)); |
1664 test(EntryExists(aName)); |
1651 r=DeleteEntry(aName,EFalse,aChain); |
1665 r=DeleteEntry(aName,EFalse,aChain); |
1652 test(r==KErrNone); |
1666 test_KErrNone(r); |
1653 if(!aAlreadyExists) |
1667 if(!aAlreadyExists) |
1654 { |
1668 { |
1655 ++TheOpNumber; |
1669 ++TheOpNumber; |
1656 TheFailCount=0; |
1670 TheFailCount=0; |
1657 } |
1671 } |
1673 test.Printf(_L("old size=%d new size=%d\n"),aOldFileSize,aNewFileSize); |
1687 test.Printf(_L("old size=%d new size=%d\n"),aOldFileSize,aNewFileSize); |
1674 FOREVER |
1688 FOREVER |
1675 { |
1689 { |
1676 test.Printf(_L("failCount=%d\n"),failCount); |
1690 test.Printf(_L("failCount=%d\n"),failCount); |
1677 r=CreateEntry(aName,EFalse,aChain,aOldFileSize); |
1691 r=CreateEntry(aName,EFalse,aChain,aOldFileSize); |
1678 test(r==KErrNone||r==KErrAlreadyExists); |
1692 test_Value(r, r==KErrNone||r==KErrAlreadyExists); |
1679 if(IsReset) |
1693 if(IsReset) |
1680 { |
1694 { |
1681 ++TheFailCount; |
1695 ++TheFailCount; |
1682 WriteLogFile(); |
1696 WriteLogFile(); |
1683 } |
1697 } |
1684 r=SetWriteFailOn(failCount); |
1698 r=SetWriteFailOn(failCount); |
1685 test(r==KErrNone); |
1699 test_KErrNone(r); |
1686 RFile file; |
1700 RFile file; |
1687 r=file.Open(TheFs,aName,EFileShareAny|EFileWrite); |
1701 r=file.Open(TheFs,aName,EFileShareAny|EFileWrite); |
1688 test(r==KErrNone); |
1702 test_KErrNone(r); |
1689 r=file.SetSize(aNewFileSize); |
1703 r=file.SetSize(aNewFileSize); |
1690 // close the file before testing the return value! |
1704 // close the file before testing the return value! |
1691 file.Close(); |
1705 file.Close(); |
1692 if(r==KErrNone) |
1706 if(r==KErrNone) |
1693 { |
1707 { |
1694 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1708 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1695 test(r==KErrNone); |
1709 test_KErrNone(r); |
1696 file.Close(); |
1710 file.Close(); |
1697 break; |
1711 break; |
1698 } |
1712 } |
1699 file.Close(); |
1713 file.Close(); |
1700 test(r==WriteFailValue); |
1714 test_Equal(WriteFailValue,r); |
1701 r=TheFs.ScanDrive(gSessionPath); |
1715 r=TheFs.ScanDrive(gSessionPath); |
1702 test(r==KErrNone); |
1716 test_KErrNone(r); |
1703 r=TheFs.CheckDisk(gSessionPath); |
1717 r=TheFs.CheckDisk(gSessionPath); |
1704 test(r==KErrNone); |
1718 test_KErrNone(r); |
1705 r=file.Open(TheFs,aName,EFileShareAny|EFileWrite); |
1719 r=file.Open(TheFs,aName,EFileShareAny|EFileWrite); |
1706 test(r==KErrNone); |
1720 test_KErrNone(r); |
1707 TInt size; |
1721 TInt size; |
1708 r=file.Size(size); |
1722 r=file.Size(size); |
1709 test(r==KErrNone); |
1723 test_KErrNone(r); |
1710 test(size==aNewFileSize||size==aOldFileSize); |
1724 test_Value(size, size==aNewFileSize||size==aOldFileSize); |
1711 file.Close(); |
1725 file.Close(); |
1712 ++failCount; |
1726 ++failCount; |
1713 } |
1727 } |
1714 r=TheFs.CheckDisk(gSessionPath); |
1728 r=TheFs.CheckDisk(gSessionPath); |
1715 test(r==KErrNone); |
1729 test_KErrNone(r); |
1716 RFile file; |
1730 RFile file; |
1717 r=file.Open(TheFs,aName,EFileShareAny); |
1731 r=file.Open(TheFs,aName,EFileShareAny); |
1718 test(r==KErrNone); |
1732 test_KErrNone(r); |
1719 TInt fileSize; |
1733 TInt fileSize; |
1720 r=file.Size(fileSize); |
1734 r=file.Size(fileSize); |
1721 test(r==KErrNone); |
1735 test_KErrNone(r); |
1722 test(aNewFileSize==fileSize); |
1736 test_Equal(aNewFileSize,fileSize); |
1723 file.Close(); |
1737 file.Close(); |
1724 r=DeleteEntry(aName,EFalse,aChain); |
1738 r=DeleteEntry(aName,EFalse,aChain); |
1725 test(r==KErrNone); |
1739 test_KErrNone(r); |
1726 ++TheFunctionNumber; |
1740 ++TheFunctionNumber; |
1727 TheFailCount=0; |
1741 TheFailCount=0; |
1728 } |
1742 } |
1729 |
1743 |
1730 LOCAL_C void TestRFileWrite(const TDesC& aName,TFatChain aChain,TInt aFileSize,TInt aPos,TInt aLength) |
1744 LOCAL_C void TestRFileWrite(const TDesC& aName,TFatChain aChain,TInt aFileSize,TInt aPos,TInt aLength) |
1737 test.Next(_L("TestRFileWrite")); |
1751 test.Next(_L("TestRFileWrite")); |
1738 test.Printf(_L("aFileSize=%d,aPos=%d,aLength=%d\n"),aFileSize,aPos,aLength); |
1752 test.Printf(_L("aFileSize=%d,aPos=%d,aLength=%d\n"),aFileSize,aPos,aLength); |
1739 TInt newSize=(aFileSize>=aPos+aLength)?aFileSize:aPos+aLength; |
1753 TInt newSize=(aFileSize>=aPos+aLength)?aFileSize:aPos+aLength; |
1740 HBufC8* desPtr; |
1754 HBufC8* desPtr; |
1741 desPtr=HBufC8::New(aLength); |
1755 desPtr=HBufC8::New(aLength); |
1742 test(desPtr!=NULL); |
1756 test_NotNull(desPtr); |
1743 TPtr8 des=desPtr->Des(); |
1757 TPtr8 des=desPtr->Des(); |
1744 des.SetLength(aLength); |
1758 des.SetLength(aLength); |
1745 InitialiseWriteBuffer(des); |
1759 InitialiseWriteBuffer(des); |
1746 FOREVER |
1760 FOREVER |
1747 { |
1761 { |
1748 test.Printf(_L("failCount=%d\n"),failCount); |
1762 test.Printf(_L("failCount=%d\n"),failCount); |
1749 r=CreateEntry(aName,EFalse,aChain,aFileSize); |
1763 r=CreateEntry(aName,EFalse,aChain,aFileSize); |
1750 test(r==KErrNone||r==KErrAlreadyExists); |
1764 test_Value(r, r==KErrNone||r==KErrAlreadyExists); |
1751 if(IsReset) |
1765 if(IsReset) |
1752 { |
1766 { |
1753 ++TheFailCount; |
1767 ++TheFailCount; |
1754 WriteLogFile(); |
1768 WriteLogFile(); |
1755 } |
1769 } |
1756 r=SetWriteFailOn(failCount); |
1770 r=SetWriteFailOn(failCount); |
1757 test(r==KErrNone); |
1771 test_KErrNone(r); |
1758 RFile file; |
1772 RFile file; |
1759 r=file.Open(TheFs,aName,EFileShareAny|EFileWrite); |
1773 r=file.Open(TheFs,aName,EFileShareAny|EFileWrite); |
1760 test(r==KErrNone); |
1774 test_KErrNone(r); |
1761 r=file.Write(aPos,des,aLength); |
1775 r=file.Write(aPos,des,aLength); |
1762 if(r==KErrNone) |
1776 if(r==KErrNone) |
1763 { |
1777 { |
1764 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1778 r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff); |
1765 test(r==KErrNone); |
1779 test_KErrNone(r); |
1766 file.Close(); |
1780 file.Close(); |
1767 break; |
1781 break; |
1768 } |
1782 } |
1769 test(r==WriteFailValue); |
1783 test_Equal(WriteFailValue,r); |
1770 file.Close(); |
1784 file.Close(); |
1771 r=TheFs.ScanDrive(gSessionPath); |
1785 r=TheFs.ScanDrive(gSessionPath); |
1772 test(r==KErrNone); |
1786 test_KErrNone(r); |
1773 r=TheFs.CheckDisk(gSessionPath); |
1787 r=TheFs.CheckDisk(gSessionPath); |
1774 test(r==KErrNone); |
1788 test_KErrNone(r); |
1775 file.Open(TheFs,aName,EFileShareAny); |
1789 file.Open(TheFs,aName,EFileShareAny); |
1776 test(r==KErrNone); |
1790 test_KErrNone(r); |
1777 TInt fileSize; |
1791 TInt fileSize; |
1778 r=file.Size(fileSize); |
1792 r=file.Size(fileSize); |
1779 // with fair scheduling enabled it's possible for the file |
1793 // with fair scheduling enabled it's possible for the file |
1780 // size to grow even if the write appears to have failed... |
1794 // size to grow even if the write appears to have failed... |
1781 // test(fileSize==aFileSize||fileSize==newSize); |
1795 // test_Value(fileSize, fileSize==aFileSize||fileSize==newSize); |
1782 test(fileSize>=aFileSize && fileSize <= newSize); |
1796 test_Value(fileSize, fileSize>=aFileSize && fileSize <= newSize); |
1783 |
1797 |
1784 file.Close(); |
1798 file.Close(); |
1785 ++failCount; |
1799 ++failCount; |
1786 } |
1800 } |
1787 r=TheFs.CheckDisk(gSessionPath); |
1801 r=TheFs.CheckDisk(gSessionPath); |
1788 test(r==KErrNone); |
1802 test_KErrNone(r); |
1789 RFile file; |
1803 RFile file; |
1790 r=file.Open(TheFs,aName,EFileShareAny); |
1804 r=file.Open(TheFs,aName,EFileShareAny); |
1791 test(r==KErrNone); |
1805 test_KErrNone(r); |
1792 TInt fileSize; |
1806 TInt fileSize; |
1793 r=file.Size(fileSize); |
1807 r=file.Size(fileSize); |
1794 test(r==KErrNone); |
1808 test_KErrNone(r); |
1795 test(newSize==fileSize); |
1809 test_Equal(newSize,fileSize); |
1796 HBufC8* desPtr2; |
1810 HBufC8* desPtr2; |
1797 desPtr2=HBufC8::New(aLength); |
1811 desPtr2=HBufC8::New(aLength); |
1798 test(desPtr2!=NULL); |
1812 test_NotNull(desPtr2); |
1799 TPtr8 des2=desPtr2->Des(); |
1813 TPtr8 des2=desPtr2->Des(); |
1800 des2.SetLength(aLength); |
1814 des2.SetLength(aLength); |
1801 r=file.Read(aPos,des2,des2.Length()); |
1815 r=file.Read(aPos,des2,des2.Length()); |
1802 test(r==KErrNone); |
1816 test_KErrNone(r); |
1803 r=des2.Compare(des); |
1817 r=des2.Compare(des); |
1804 test(r==0); |
1818 test_KErrNone(r); |
1805 file.Close(); |
1819 file.Close(); |
1806 r=DeleteEntry(aName,EFalse,aChain); |
1820 r=DeleteEntry(aName,EFalse,aChain); |
1807 test(r==KErrNone); |
1821 test_KErrNone(r); |
1808 delete desPtr; |
1822 delete desPtr; |
1809 delete desPtr2; |
1823 delete desPtr2; |
1810 ++TheFunctionNumber; |
1824 ++TheFunctionNumber; |
1811 TheFailCount=0; |
1825 TheFailCount=0; |
1812 } |
1826 } |
1971 DoReadBootSector(); |
1985 DoReadBootSector(); |
1972 DumpBootSector(); |
1986 DumpBootSector(); |
1973 ClearDiskData(); |
1987 ClearDiskData(); |
1974 |
1988 |
1975 r=TheFs.SetSessionPath(gSessionPath); |
1989 r=TheFs.SetSessionPath(gSessionPath); |
1976 test(r==KErrNone); |
1990 test_KErrNone(r); |
1977 |
1991 |
1978 switch(TheFunctionNumber) |
1992 switch(TheFunctionNumber) |
1979 { |
1993 { |
1980 case(0):TestOperation0(); |
1994 case(0):TestOperation0(); |
1981 case(1):{ |
1995 case(1):{ |
1982 TestOperation1(); |
1996 TestOperation1(); |
1983 r=TheFs.MkDir(_L("\\fat\\")); |
1997 r=TheFs.MkDir(_L("\\fat\\")); |
1984 test(r==KErrNone); |
1998 test_KErrNone(r); |
1985 r=TheFs.MkDir(_L("\\test\\")); |
1999 r=TheFs.MkDir(_L("\\test\\")); |
1986 test(r==KErrNone); |
2000 test_KErrNone(r); |
1987 r=TheFs.MkDir(_L("\\ANother\\")); |
2001 r=TheFs.MkDir(_L("\\ANother\\")); |
1988 test(r==KErrNone); |
2002 test_KErrNone(r); |
1989 r=TheFs.MkDir(_L("\\test\\subdir1\\")); |
2003 r=TheFs.MkDir(_L("\\test\\subdir1\\")); |
1990 test(r==KErrNone); |
2004 test_KErrNone(r); |
1991 r=TheFs.MkDir(_L("\\test\\subdir2\\")); |
2005 r=TheFs.MkDir(_L("\\test\\subdir2\\")); |
1992 test(r==KErrNone);} |
2006 test_KErrNone(r);} |
1993 case(2):{ |
2007 case(2):{ |
1994 TestOperation2(); |
2008 TestOperation2(); |
1995 // add some filler files |
2009 // add some filler files |
1996 CreateEntry(_L("\\test\\subdir1\\FillerOne"),EFalse,EChainStd,512); |
2010 CreateEntry(_L("\\test\\subdir1\\FillerOne"),EFalse,EChainStd,512); |
1997 CreateEntry(_L("\\test\\subdir1\\FillerTwo"),EFalse,EChainStd,1024);} |
2011 CreateEntry(_L("\\test\\subdir1\\FillerTwo"),EFalse,EChainStd,1024);} |
2035 DeleteEntry(_L("\\test\\subdir1\\FillerFour"),EFalse,EChainStd); |
2049 DeleteEntry(_L("\\test\\subdir1\\FillerFour"),EFalse,EChainStd); |
2036 DeleteEntry(_L("\\ANother\\FillerThree"),EFalse,EChainStd); |
2050 DeleteEntry(_L("\\ANother\\FillerThree"),EFalse,EChainStd); |
2037 DeleteEntry(_L("\\test\\subdir1\\FillerTwo"),EFalse,EChainStd); |
2051 DeleteEntry(_L("\\test\\subdir1\\FillerTwo"),EFalse,EChainStd); |
2038 DeleteEntry(_L("\\test\\subdir1\\FillerOne"),EFalse,EChainStd); |
2052 DeleteEntry(_L("\\test\\subdir1\\FillerOne"),EFalse,EChainStd); |
2039 r=TheFs.RmDir(_L("\\test\\subdir2\\")); |
2053 r=TheFs.RmDir(_L("\\test\\subdir2\\")); |
2040 test(r==KErrNone); |
2054 test_KErrNone(r); |
2041 r=TheFs.RmDir(_L("\\test\\subdir1\\")); |
2055 r=TheFs.RmDir(_L("\\test\\subdir1\\")); |
2042 test(r==KErrNone); |
2056 test_KErrNone(r); |
2043 r=TheFs.RmDir(_L("\\ANother\\")); |
2057 r=TheFs.RmDir(_L("\\ANother\\")); |
2044 test(r==KErrNone); |
2058 test_KErrNone(r); |
2045 r=TheFs.RmDir(_L("\\test\\")); |
2059 r=TheFs.RmDir(_L("\\test\\")); |
2046 test(r==KErrNone); |
2060 test_KErrNone(r); |
2047 r=TheFs.RmDir(_L("\\fat\\")); |
2061 r=TheFs.RmDir(_L("\\fat\\")); |
2048 test(r==KErrNone); |
2062 test_KErrNone(r); |
2049 if (gFatBuf) |
2063 if (gFatBuf) |
2050 { |
2064 { |
2051 delete gFatBuf; |
2065 delete gFatBuf; |
2052 gFatBuf = NULL; |
2066 gFatBuf = NULL; |
2053 } |
2067 } |