27 using namespace Fat_Test_Utils; |
27 using namespace Fat_Test_Utils; |
28 |
28 |
29 RTest test(_L("T_FSYS")); |
29 RTest test(_L("T_FSYS")); |
30 |
30 |
31 static void TestFileSystemNames() |
31 static void TestFileSystemNames() |
32 { |
32 { |
33 test.Next(_L("Read file system names for all drives")); |
33 test.Next(_L("Read file system names for all drives")); |
34 TFullName name; |
34 TFullName name; |
35 TInt r; |
35 TInt r; |
36 for(TInt i=EDriveA;i<KMaxDrives;++i) |
36 for(TInt i=EDriveA;i<KMaxDrives;++i) |
37 { |
37 { |
38 r=TheFs.FileSystemName(name,i); |
38 r=TheFs.FileSystemName(name,i); |
39 test(r==KErrNone || r==KErrNotFound); |
39 test(r==KErrNone || r==KErrNotFound); |
40 TChar c; |
40 TChar c; |
41 r=RFs::DriveToChar(i,c); |
41 r=RFs::DriveToChar(i,c); |
42 test(r==KErrNone); |
42 test(r==KErrNone); |
43 if(name.Length()) |
43 if(name.Length()) |
44 test.Printf(_L("File System Name on drive %c is %S\n"),(char)c,&name); |
44 test.Printf(_L("File System Name on drive %c is %S\n"),(char)c,&name); |
45 else |
45 else |
46 test.Printf(_L("No file system on drive %c\n"),(char)c); |
46 test.Printf(_L("No file system on drive %c\n"),(char)c); |
47 } |
47 } |
48 } |
48 } |
49 |
49 |
50 static void CheckDismount(TDesC& aFs,TInt aDrive) |
50 static void CheckDismount(TDesC& aFs,TInt aDrive) |
51 { |
51 { |
52 |
52 |
53 if (aDrive==EDriveC) // ??? Can't test on C: - see below |
53 if (aDrive==EDriveC) // ??? Can't test on C: - see below |
54 return; |
54 return; |
55 TInt r; |
55 TInt r; |
56 TFullName oldSess, newSess; |
56 TFullName oldSess, newSess; |
57 r=TheFs.SessionPath(oldSess); |
57 r=TheFs.SessionPath(oldSess); |
58 test(r==KErrNone); |
58 test(r==KErrNone); |
59 TChar c; |
59 TChar c; |
60 r=TheFs.DriveToChar(aDrive,c); |
60 r=TheFs.DriveToChar(aDrive,c); |
61 test(r==KErrNone); |
61 test(r==KErrNone); |
62 newSess.Append(c); |
62 newSess.Append(c); |
63 newSess.Append(':'); |
63 newSess.Append(':'); |
64 newSess.Append('\\'); |
64 newSess.Append('\\'); |
65 |
65 |
66 TBuf<128> b; |
66 TBuf<128> b; |
67 TDriveInfo di; |
67 TDriveInfo di; |
68 r=TheFs.Drive(di,aDrive); |
68 r=TheFs.Drive(di,aDrive); |
69 test(r==KErrNone); |
69 test(r==KErrNone); |
70 b.Format(_L("Test dismounting of test file system on %c: (DrvAtt:%x MedAtt:%x)"),(TUint)c,di.iDriveAtt,di.iMediaAtt); |
70 b.Format(_L("Test dismounting of test file system on %c: (DrvAtt:%x MedAtt:%x)"),(TUint)c,di.iDriveAtt,di.iMediaAtt); |
71 test.Next(b); |
71 test.Next(b); |
72 |
72 |
73 // Test cannot dismount on rom drive |
73 // Test cannot dismount on rom drive |
74 test.Next(_L("Test cannot dismount on Rom drive")); |
74 test.Next(_L("Test cannot dismount on Rom drive")); |
75 TFullName zName; |
75 TFullName zName; |
76 r=TheFs.FileSystemName(zName,EDriveZ); |
76 r=TheFs.FileSystemName(zName,EDriveZ); |
77 test(r==KErrNone); |
77 test(r==KErrNone); |
78 r=TheFs.DismountFileSystem(zName,EDriveZ); |
78 r=TheFs.DismountFileSystem(zName,EDriveZ); |
79 test.Printf(_L("r=%d"),r); |
79 test.Printf(_L("r=%d"),r); |
80 // NB if paging is enabled on a ROFS partition which is part of the composite file system then the |
80 // NB if paging is enabled on a ROFS partition which is part of the composite file system then the |
81 // likelihood is that there will be a at least one file clamped: in this case there error will be KErrInUse |
81 // likelihood is that there will be a at least one file clamped: in this case there error will be KErrInUse |
82 test(r==KErrAccessDenied || r==KErrInUse); |
82 test(r==KErrAccessDenied || r==KErrInUse); |
83 |
83 |
84 // Test cannot dismount on wrong drive |
84 // Test cannot dismount on wrong drive |
85 test.Next(_L("Test cannot dismount on wrong drive")); |
85 test.Next(_L("Test cannot dismount on wrong drive")); |
86 r=TheFs.DismountFileSystem(aFs,EDriveA); |
86 r=TheFs.DismountFileSystem(aFs,EDriveA); |
87 test(r==KErrNotReady); |
87 test(r==KErrNotReady); |
88 |
88 |
89 // Test cannot dismount with wrong name |
89 // Test cannot dismount with wrong name |
90 test.Next(_L("Test cannot dismount with wrong file system name")); |
90 test.Next(_L("Test cannot dismount with wrong file system name")); |
91 r=TheFs.DismountFileSystem(_L("abc"),aDrive); |
91 r=TheFs.DismountFileSystem(_L("abc"),aDrive); |
92 test(r==KErrNotFound); |
92 test(r==KErrNotFound); |
93 |
93 |
94 // Test cannot dismount with a file open |
94 // Test cannot dismount with a file open |
95 test.Next(_L("Test cannot dismount with a file open")); |
95 test.Next(_L("Test cannot dismount with a file open")); |
96 r=TheFs.SetSessionPath(newSess); |
96 r=TheFs.SetSessionPath(newSess); |
97 RFile file; |
97 RFile file; |
98 r=file.Replace(TheFs,_L("abc"),EFileShareAny); |
98 r=file.Replace(TheFs,_L("abc"),EFileShareAny); |
99 test(r==KErrNone); |
99 test(r==KErrNone); |
100 r=TheFs.SessionPath(newSess); |
100 r=TheFs.SessionPath(newSess); |
101 TBool open; |
101 TBool open; |
102 r=TheFs.IsFileOpen(_L("abc"),open); |
102 r=TheFs.IsFileOpen(_L("abc"),open); |
103 test(r==KErrNone); |
103 test(r==KErrNone); |
104 test(open); |
104 test(open); |
105 r=TheFs.DismountFileSystem(aFs,aDrive); |
105 r=TheFs.DismountFileSystem(aFs,aDrive); |
106 test(r==KErrInUse); |
106 test(r==KErrInUse); |
107 file.Close(); |
107 file.Close(); |
108 |
108 |
109 // Now test dismount works |
109 // Now test dismount works |
110 test.Next(_L("Test dismounts OK")); |
110 test.Next(_L("Test dismounts OK")); |
111 r=TheFs.DismountFileSystem(aFs,aDrive); |
111 r=TheFs.DismountFileSystem(aFs,aDrive); |
112 if(r!=KErrNone) |
112 if(r!=KErrNone) |
113 { |
113 { |
114 test.Printf(_L("Error = %d"),r); |
114 test.Printf(_L("Error = %d"),r); |
115 test(EFalse); |
115 test(EFalse); |
116 } |
116 } |
117 TFullName n; |
117 TFullName n; |
118 r=TheFs.FileSystemName(n,aDrive); |
118 r=TheFs.FileSystemName(n,aDrive); |
119 test(r==KErrNone || r==KErrNotFound); |
119 test(r==KErrNone || r==KErrNotFound); |
120 test(!n.Length()); |
120 test(!n.Length()); |
121 r=file.Replace(TheFs,_L("abc"),EFileShareAny); |
121 r=file.Replace(TheFs,_L("abc"),EFileShareAny); |
122 test(r==KErrNotReady); |
122 test(r==KErrNotReady); |
123 file.Close(); |
123 file.Close(); |
124 |
124 |
125 r=TheFs.MountFileSystem(aFs,aDrive); |
125 r=TheFs.MountFileSystem(aFs,aDrive); |
126 if(r!=KErrNone) |
126 if(r!=KErrNone) |
127 { |
127 { |
128 test.Printf(_L("error = %d\n"),r); |
128 test.Printf(_L("error = %d\n"),r); |
129 test(EFalse); |
129 test(EFalse); |
130 } |
130 } |
131 r=TheFs.FileSystemName(n,aDrive); |
131 r=TheFs.FileSystemName(n,aDrive); |
132 test(r==KErrNone); |
132 test(r==KErrNone); |
133 test(n.Compare(aFs)==0); |
133 test(n.Compare(aFs)==0); |
134 r=file.Replace(TheFs,_L("abc"),EFileShareAny); // ??? bang |
134 r=file.Replace(TheFs,_L("abc"),EFileShareAny); // ??? bang |
135 test(r==KErrNone); |
135 test(r==KErrNone); |
136 file.Close(); |
136 file.Close(); |
137 r=TheFs.SetSessionPath(oldSess); |
137 r=TheFs.SetSessionPath(oldSess); |
138 test(r==KErrNone); |
138 test(r==KErrNone); |
139 } |
139 } |
140 |
140 |
141 static void TestDismountFileSystem(TInt aDrive) |
141 static void TestDismountFileSystem(TInt aDrive) |
142 { |
142 { |
143 |
143 |
144 TInt r; |
144 TInt r; |
145 TFullName name; |
145 TFullName name; |
146 r=TheFs.FileSystemName(name,aDrive); |
146 r=TheFs.FileSystemName(name,aDrive); |
147 test(r==KErrNone || r==KErrNotFound); |
147 test(r==KErrNone || r==KErrNotFound); |
148 if(name.Length()) |
148 if(name.Length()) |
149 CheckDismount(name,aDrive); |
149 CheckDismount(name,aDrive); |
150 } |
150 } |
151 |
151 |
152 #if defined(__EPOC32__) |
152 #if defined(__EPOC32__) |
153 static void TestFileSystem(TInt aDrive) |
153 static void TestFileSystem(TInt aDrive) |
154 // |
154 // |
155 // Mount a new CTestFileSystem on the drive under test |
155 // Mount a new CTestFileSystem on the drive under test |
156 // |
156 // |
157 { |
157 { |
158 TBuf<64> b; |
158 TBuf<64> b; |
159 TChar c; |
159 TChar c; |
160 TInt r=TheFs.DriveToChar(aDrive,c); |
160 TInt r=TheFs.DriveToChar(aDrive,c); |
161 test(r==KErrNone); |
161 test(r==KErrNone); |
162 TDriveInfo di; |
162 TDriveInfo di; |
163 r=TheFs.Drive(di,aDrive); |
163 r=TheFs.Drive(di,aDrive); |
164 test(r==KErrNone); |
164 test(r==KErrNone); |
165 b.Format(_L("Test mounting of test file system on %c: (DrvAtt:%x MedAtt:%x)"),(TUint)c,di.iDriveAtt,di.iMediaAtt); |
165 b.Format(_L("Test mounting of test file system on %c: (DrvAtt:%x MedAtt:%x)"),(TUint)c,di.iDriveAtt,di.iMediaAtt); |
166 test.Next(b); |
166 test.Next(b); |
167 |
167 |
168 test.Next(_L("Test mounting of test file system")); |
168 test.Next(_L("Test mounting of test file system")); |
169 r=TheFs.AddFileSystem(_L("T_TFSYS")); |
169 r=TheFs.AddFileSystem(_L("T_TFSYS")); |
170 if(r!=KErrNone && r!=KErrAlreadyExists) |
170 if(r!=KErrNone && r!=KErrAlreadyExists) |
171 { |
171 { |
172 test.Printf(_L("error=%d"),r); |
172 test.Printf(_L("error=%d"),r); |
173 test(EFalse); |
173 test(EFalse); |
174 } |
174 } |
175 |
175 |
176 |
176 TFullName oldFs; |
177 TFullName oldFs; |
177 r=TheFs.FileSystemName(oldFs,aDrive); |
178 r=TheFs.FileSystemName(oldFs,aDrive); |
178 // TFileName oldFs; |
179 // TFileName oldFs; |
179 // r=TheFs.FileSystemName(oldFs,aDrive); |
180 // r=TheFs.FileSystemName(oldFs,aDrive); |
180 test(r==KErrNone); |
181 test(r==KErrNone); |
181 r=TheFs.DismountFileSystem(oldFs,aDrive); |
182 r=TheFs.DismountFileSystem(oldFs,aDrive); |
182 if(r!=KErrNone) |
183 if(r!=KErrNone) |
183 { |
184 { |
184 test.Printf(_L("Error = %d"),r); |
185 test.Printf(_L("Error = %d"),r); |
185 test(EFalse); |
186 test(EFalse); |
186 } |
187 } |
187 r=TheFs.MountFileSystem(_L("Test"),aDrive); |
188 r=TheFs.MountFileSystem(_L("Test"),aDrive); |
188 test(r==KErrNone); |
189 test(r==KErrNone); |
189 |
190 |
190 TFileName newFs; |
191 TFileName newFs; |
191 r=TheFs.FileSystemName(newFs,aDrive); |
192 r=TheFs.FileSystemName(newFs,aDrive); |
192 test(r==KErrNone); |
193 test(r==KErrNone); |
193 test(newFs.Compare(_L("Test"))==0); |
194 test(newFs.Compare(_L("Test"))==0); |
194 |
195 |
195 // Check attributes |
196 // Check attributes |
196 TDriveInfo info; |
197 TDriveInfo info; |
197 r=TheFs.Drive(info,aDrive); |
198 r=TheFs.Drive(info,aDrive); |
198 test(r==KErrNone); |
199 test(r==KErrNone); |
|
200 |
199 |
201 test.Printf(_L("iType=%d,iBattery=%d,iDriveAtt=%x,iMediaAtt=%x\n"),(TUint)info.iType,\ |
200 test.Printf(_L("iType=%d,iConnectionBusType=%d,iDriveAtt=%x,iMediaAtt=%x\n"),(TUint)info.iType,\ |
202 (TUint)info.iBattery,info.iDriveAtt,info.iMediaAtt); |
201 (TUint)info.iConnectionBusType,info.iDriveAtt,info.iMediaAtt); |
203 |
202 |
204 //Try to remove filesystem without dismounting. |
203 //Try to remove filesystem without dismounting. |
205 r=TheFs.RemoveFileSystem(_L("Test")); |
204 r=TheFs.RemoveFileSystem(_L("Test")); |
206 if(r!=KErrInUse) |
205 if(r!=KErrInUse) |
207 { |
206 { |
208 test.Printf(_L("error=%d"),r); |
207 test.Printf(_L("error=%d"),r); |
209 test(EFalse); |
208 test(EFalse); |
210 } |
209 } |
211 r=TheFs.FileSystemName(newFs,aDrive); |
210 r=TheFs.FileSystemName(newFs,aDrive); |
212 test(r==KErrNone); |
211 test(r==KErrNone); |
213 test(newFs.Compare(_L("Test"))==0); |
212 test(newFs.Compare(_L("Test"))==0); |
214 |
213 |
215 r=TheFs.DismountFileSystem(newFs,aDrive); |
214 r=TheFs.DismountFileSystem(newFs,aDrive); |
216 test(r==KErrNone); |
215 test(r==KErrNone); |
217 |
216 |
218 r=TheFs.MountFileSystem(oldFs,aDrive); |
217 r=TheFs.MountFileSystem(oldFs,aDrive); |
219 test(r==KErrNone); |
218 test(r==KErrNone); |
220 } |
219 } |
221 #endif |
220 #endif |
222 |
221 |
223 static void TestMountInvalidDrive() |
222 static void TestMountInvalidDrive() |
224 // |
223 // |
225 // Attempt to mount FAT on non-local drive |
224 // Attempt to mount FAT on non-local drive |
226 { |
225 { |
227 test.Start(_L("TestMountInvalidDrive")); |
226 test.Start(_L("TestMountInvalidDrive")); |
228 |
227 |
229 TInt r; |
228 TInt r; |
230 |
229 |
231 test.Next(_L("Adding EFAT")); |
230 test.Next(_L("Adding EFAT")); |
232 #ifdef __WINS__ |
231 #ifdef __WINS__ |
233 _LIT(KFsNm, "EFAT"); |
232 _LIT(KFsNm, "EFAT32"); |
234 #else |
233 #else |
235 _LIT(KFsNm, "ELOCAL"); |
234 _LIT(KFsNm, "ELOCAL"); |
236 #endif |
235 #endif |
237 |
236 |
238 r = TheFs.AddFileSystem(KFsNm); |
237 r = TheFs.AddFileSystem(KFsNm); |
239 test.Printf(_L("afs: r = %d\n"), r); |
238 test.Printf(_L("afs: r = %d\n"), r); |
240 test(r == KErrNone || r == KErrAlreadyExists); |
239 test(r == KErrNone || r == KErrAlreadyExists); |
241 test.Next(_L("mounting FAT on drive R")); |
240 test.Next(_L("mounting FAT on drive R")); |
242 r = TheFs.MountFileSystem(KFileSystemName_FAT, EDriveR); |
241 r = TheFs.MountFileSystem(KFileSystemName_FAT, EDriveR); |
243 test(r == KErrArgument); |
242 test(r == KErrArgument); |
244 |
243 |
245 test.End(); |
244 test.End(); |
246 } |
245 } |
247 |
246 |
248 // Additional step for INC083446: Corrupted miniSD not detected as corrupted by phone |
247 // Additional step for INC083446: Corrupted miniSD not detected as corrupted by phone |
249 static void TestMountingBrokenMedia(TInt aDrive) |
248 static void TestMountingBrokenMedia(TInt aDrive) |
250 // |
249 // |
251 // Mount a new CTestFileSystem on the drive under test |
250 // Mount a new CTestFileSystem on the drive under test |
252 // |
251 // |
253 { |
252 { |
254 if (aDrive==EDriveC) // ??? Can't test on C: |
253 if (aDrive==EDriveC) // ??? Can't test on C: |
255 return; |
254 return; |
256 |
255 |
257 TBuf<64> b; |
256 TBuf<64> b; |
258 TChar c; |
257 TChar c; |
259 TInt r=TheFs.DriveToChar(aDrive,c); |
258 TInt r=TheFs.DriveToChar(aDrive,c); |
260 test(r==KErrNone); |
259 test(r==KErrNone); |
261 TDriveInfo di; |
260 TDriveInfo di; |
262 r=TheFs.Drive(di,aDrive); |
261 r=TheFs.Drive(di,aDrive); |
263 test(r==KErrNone); |
262 test(r==KErrNone); |
264 b.Format(_L("Test mounting of test file system on %c: (DrvAtt:%x MedAtt:%x)"),(TUint)c,di.iDriveAtt,di.iMediaAtt); |
263 b.Format(_L("Test mounting of test file system on %c: (DrvAtt:%x MedAtt:%x)"),(TUint)c,di.iDriveAtt,di.iMediaAtt); |
265 test.Next(b); |
264 test.Next(b); |
266 |
265 |
267 test.Next(_L("Test mounting of test file system")); |
266 test.Next(_L("Test mounting of test file system")); |
268 r=TheFs.AddFileSystem(_L("T_TFSYS2")); |
267 r=TheFs.AddFileSystem(_L("T_TFSYS2")); |
269 if(r!=KErrNone && r!=KErrAlreadyExists) |
268 if(r!=KErrNone && r!=KErrAlreadyExists) |
270 { |
269 { |
271 test.Printf(_L("error=%d"),r); |
270 test.Printf(_L("error=%d"),r); |
272 test(EFalse); |
271 test(EFalse); |
273 } |
272 } |
274 |
273 |
275 |
274 TFullName oldFs; |
276 TFullName oldFs; |
275 r=TheFs.FileSystemName(oldFs,aDrive); |
277 r=TheFs.FileSystemName(oldFs,aDrive); |
276 test(r==KErrNone); |
278 test(r==KErrNone); |
277 r=TheFs.DismountFileSystem(oldFs,aDrive); |
279 r=TheFs.DismountFileSystem(oldFs,aDrive); |
278 if(r!=KErrNone) |
280 if(r!=KErrNone) |
279 { |
281 { |
280 test.Printf(_L("Error = %d"),r); |
282 test.Printf(_L("Error = %d"),r); |
281 test(EFalse); |
283 test(EFalse); |
282 } |
284 } |
283 r=TheFs.MountFileSystem(_L("Test2"),aDrive); |
285 r=TheFs.MountFileSystem(_L("Test2"),aDrive); |
284 test(r == KErrCorrupt); |
286 test(r == KErrCorrupt); |
285 |
287 |
286 TFileName newFs; |
288 TFileName newFs; |
287 r=TheFs.FileSystemName(newFs,aDrive); |
289 r=TheFs.FileSystemName(newFs,aDrive); |
288 test(r==KErrNone); |
290 test(r==KErrNone); |
289 test(newFs.Compare(_L("Test2"))==0); |
291 test(newFs.Compare(_L("Test2"))==0); |
290 |
292 |
291 // Get the number of remounts by checking the volume attributes - |
293 // Get the number of remounts by checking the volume attributes - |
292 // T_TFSYS2 hijacks the iBattery member to report back the number of times MountL() has been called |
294 // T_TFSYS2 hijacks the iBattery member to report back the number of times MountL() has been called |
293 TDriveInfo info; |
295 TDriveInfo info; |
294 TInt remounts; |
296 TInt remounts; |
295 r=TheFs.Drive(info,aDrive); |
297 r=TheFs.Drive(info,aDrive); |
296 test(r==KErrNone); |
298 test(r==KErrNone); |
297 test.Printf(_L("iType=%d,iBattery=%d,iDriveAtt=%x,iMediaAtt=%x\n"),(TUint)info.iType,\ |
299 test.Printf(_L("iType=%d,iBattery=%d,iDriveAtt=%x,iMediaAtt=%x\n"),(TUint)info.iType,\ |
298 (TUint)info.iBattery,info.iDriveAtt,info.iMediaAtt); |
300 (TUint)info.iBattery,info.iDriveAtt,info.iMediaAtt); |
299 remounts = (TInt) info.iBattery; |
301 remounts = (TInt) info.iBattery; |
300 test.Printf(_L("Initial remounts = %d"), remounts); |
302 test.Printf(_L("Initial remounts = %d"), remounts); |
301 |
303 |
302 // Make the file server attempt to remount the drive by looking for a non-existant DLL |
304 // Make the file server attempt to remount the drive by looking for a non-existant DLL |
303 // The file server should setop trying to remount the driver after KMaxMountFailures attempts |
305 // The file server should setop trying to remount the driver after KMaxMountFailures attempts |
304 const TInt KMaxMountFailures = 3; // copied from sf_drv.cpp |
306 const TInt KMaxMountFailures = 3; // copied from sf_drv.cpp |
305 const TInt KEntryAttempts = 10; |
307 const TInt KEntryAttempts = 10; |
306 TInt entryAttempts; |
308 TInt entryAttempts; |
307 for (entryAttempts=0; entryAttempts < KEntryAttempts; entryAttempts++) |
309 for (entryAttempts=0; entryAttempts < KEntryAttempts; entryAttempts++) |
308 { |
310 { |
309 TEntry entry; |
311 TEntry entry; |
310 _LIT(KNonExistantFilename, "NONEXISTANT_FILENAME.DLL"); |
312 _LIT(KNonExistantFilename, "NONEXISTANT_FILENAME.DLL"); |
311 r = TheFs.Entry(KNonExistantFilename, entry); |
313 r = TheFs.Entry(KNonExistantFilename, entry); |
312 test(r == KErrCorrupt); |
314 test(r == KErrCorrupt); |
313 } |
315 } |
314 r=TheFs.Drive(info,aDrive); |
316 r=TheFs.Drive(info,aDrive); |
315 test(r==KErrNone); |
317 test(r==KErrNone); |
316 test.Printf(_L("iType=%d,iBattery=%d,iDriveAtt=%x,iMediaAtt=%x\n"),(TUint)info.iType,\ |
318 test.Printf(_L("iType=%d,iBattery=%d,iDriveAtt=%x,iMediaAtt=%x\n"),(TUint)info.iType,\ |
317 (TUint)info.iBattery,info.iDriveAtt,info.iMediaAtt); |
319 (TUint)info.iBattery,info.iDriveAtt,info.iMediaAtt); |
318 remounts = (TInt) info.iBattery; |
320 remounts = (TInt) info.iBattery; |
319 test.Printf(_L("Remounts = %d"), remounts); |
321 test.Printf(_L("Remounts = %d"), remounts); |
320 test(remounts == KMaxMountFailures); |
322 test(remounts == KMaxMountFailures); |
321 |
323 |
322 // simulate a media change to reset failure count |
324 |
323 r = TheFs.RemountDrive(aDrive, NULL, 0); |
325 // simulate a media change to reset failure count |
324 |
326 r = TheFs.RemountDrive(aDrive, NULL, 0); |
325 // now try mounting again & verify the the file server attempts to mount the drive again |
327 |
326 for (entryAttempts=0; entryAttempts < KEntryAttempts; entryAttempts++) |
328 // now try mounting again & verify the the file server attempts to mount the drive again |
327 { |
329 for (entryAttempts=0; entryAttempts < KEntryAttempts; entryAttempts++) |
328 TEntry entry; |
330 { |
329 _LIT(KNonExistantFilename, "NONEXISTANT_FILENAME.DLL"); |
331 TEntry entry; |
330 r = TheFs.Entry(KNonExistantFilename, entry); |
332 _LIT(KNonExistantFilename, "NONEXISTANT_FILENAME.DLL"); |
331 test(r == KErrCorrupt); |
333 r = TheFs.Entry(KNonExistantFilename, entry); |
332 } |
334 test(r == KErrCorrupt); |
333 r=TheFs.Drive(info,aDrive); |
335 } |
334 test(r==KErrNone); |
336 r=TheFs.Drive(info,aDrive); |
335 test.Printf(_L("iType=%d,iBattery=%d,iDriveAtt=%x,iMediaAtt=%x\n"),(TUint)info.iType,\ |
337 test(r==KErrNone); |
336 (TUint)info.iBattery,info.iDriveAtt,info.iMediaAtt); |
338 test.Printf(_L("iType=%d,iBattery=%d,iDriveAtt=%x,iMediaAtt=%x\n"),(TUint)info.iType,\ |
337 remounts = (TInt) info.iBattery; |
339 (TUint)info.iBattery,info.iDriveAtt,info.iMediaAtt); |
338 test.Printf(_L("Remounts = %d"), remounts); |
340 remounts = (TInt) info.iBattery; |
339 test(remounts == KMaxMountFailures * 2); |
341 test.Printf(_L("Remounts = %d"), remounts); |
340 |
342 test(remounts == KMaxMountFailures * 2); |
341 |
343 |
342 |
344 |
343 r=TheFs.DismountFileSystem(newFs,aDrive); |
345 |
344 test(r==KErrNone); |
346 r=TheFs.DismountFileSystem(newFs,aDrive); |
345 r=TheFs.MountFileSystem(oldFs,aDrive); |
347 test(r==KErrNone); |
346 test(r==KErrNone); |
348 r=TheFs.MountFileSystem(oldFs,aDrive); |
347 |
349 test(r==KErrNone); |
348 r=TheFs.RemoveFileSystem(_L("Test2")); |
350 |
349 if(r!=KErrNone) |
351 r=TheFs.RemoveFileSystem(_L("Test2")); |
350 { |
352 if(r!=KErrNone) |
351 test.Printf(_L("error=%d"),r); |
353 { |
352 test(EFalse); |
354 test.Printf(_L("error=%d"),r); |
353 } |
355 test(EFalse); |
354 } |
356 } |
|
357 } |
|
358 |
355 |
359 |
356 |
360 /** |
357 /** |
361 Testing obtaining media serial number for the substituted drives |
358 Testing obtaining media serial number for the substituted drives |
362 */ |
359 */ |
424 //---------------------------------------------------------------------------------------------- |
421 //---------------------------------------------------------------------------------------------- |
425 //! @SYMTestCaseID PBASE-t_fsys-0317 |
422 //! @SYMTestCaseID PBASE-t_fsys-0317 |
426 //! @SYMTestType CIT |
423 //! @SYMTestType CIT |
427 //! @SYMPREQ CR0882 |
424 //! @SYMPREQ CR0882 |
428 //! @SYMTestCaseDesc This test case is testing querying file system sub type name using |
425 //! @SYMTestCaseDesc This test case is testing querying file system sub type name using |
429 //! RFs::QueryVolumeInfoExt() API. |
426 //! RFs::QueryVolumeInfoExt() API. |
430 //! @SYMTestActions 1 querys sub type of file system on volumes mounted with 'Fat' file system |
427 //! @SYMTestActions 1 querys sub type of file system on volumes mounted with 'Fat' file system |
431 //! 2 querys sub type of file system on volumes mounted with 'Lffs' file system |
428 //! 2 querys sub type of file system on volumes mounted with 'Lffs' file system |
432 //! 3 querys sub type of file system on volumes mounted with 'rofs' file system |
429 //! 3 querys sub type of file system on volumes mounted with 'rofs' file system |
433 //! 4 querys sub type of file system on volumes mounted with other file systems |
430 //! 4 querys sub type of file system on volumes mounted with other file systems |
434 //! @SYMTestExpectedResults |
431 //! @SYMTestExpectedResults |
435 //! 1 returned error code should be KErrNone, descriptor should match 'FAT12' or 'FAT16' or 'FAT32' |
432 //! 1 returned error code should be KErrNone, descriptor should match 'FAT12' or 'FAT16' or 'FAT32' |
436 //! 2 returned error code should be KErrNotSupported, descriptor should match 'Lffs' |
433 //! 2 returned error code should be KErrNotSupported, descriptor should match 'Lffs' |
437 //! 3 returned error code should be KErrNotSupported, descriptor should match 'rofs' |
434 //! 3 returned error code should be KErrNotSupported, descriptor should match 'rofs' |
438 //! 4 returned error code should be KErrNotSupported, descriptor length should not be zero |
435 //! 4 returned error code should be KErrNotSupported, descriptor length should not be zero |
439 //! @SYMTestPriority High |
436 //! @SYMTestPriority High |
440 //! @SYMTestStatus Implemented |
437 //! @SYMTestStatus Implemented |
441 //---------------------------------------------------------------------------------------------- |
438 //---------------------------------------------------------------------------------------------- |
442 static void TestFileSystemSubTypeQuery() |
439 static void TestFileSystemSubTypeQuery() |
443 { |
440 { |
444 test.Next(_L("Test querying sub type of the mounted file system")); |
441 test.Next(_L("Test querying sub type of the mounted file system")); |
445 TFSName fsName; |
442 TFSName fsName; |
446 TPckgBuf<TFSName> subName; |
443 TPckgBuf<TFSName> subName; |
447 TInt i, r; |
444 TInt i, r; |
448 TDriveInfo driveInfo; |
445 TDriveInfo driveInfo; |
449 TPckgBuf<TBool> fDrvSyncBuf; |
446 TPckgBuf<TBool> fDrvSyncBuf; |
450 |
447 |
451 |
448 |
452 for(i = EDriveA; i <= EDriveZ; ++i, subName.Zero()) |
449 for(i = EDriveA; i <= EDriveZ; ++i, subName.Zero()) |
453 { |
450 { |
454 r = TheFs.FileSystemName(fsName, i); |
451 r = TheFs.FileSystemName(fsName, i); |
455 if (r == KErrNone) |
452 if (r == KErrNone) |
456 { |
453 { |
457 test.Printf(_L("Tested on drive: %c.\n"), (char)(i+'A')); |
454 test.Printf(_L("Tested on drive: %c.\n"), (char)(i+'A')); |
458 r=TheFs.Drive(driveInfo, i); |
455 r=TheFs.Drive(driveInfo, i); |
459 test(r==KErrNone); |
456 test(r==KErrNone); |
460 |
457 |
461 if (driveInfo.iType==EMediaNotPresent) |
458 if (driveInfo.iType==EMediaNotPresent) |
462 { |
459 { |
463 test.Printf(_L("The media is not present.\n")); |
460 test.Printf(_L("The media is not present.\n")); |
464 r = TheFs.QueryVolumeInfoExt(i, EFileSystemSubType, subName); |
461 r = TheFs.QueryVolumeInfoExt(i, EFileSystemSubType, subName); |
465 test(r == KErrNone || r == KErrNotReady); |
462 test(r == KErrNone || r == KErrNotReady); |
466 } |
463 } |
467 else if (driveInfo.iType==EMediaCdRom) |
464 else if (driveInfo.iType==EMediaCdRom) |
468 { |
465 { |
469 test.Printf(_L("CD ROM with no media will report not ready!\n")); |
466 test.Printf(_L("CD ROM with no media will report not ready!\n")); |
470 r = TheFs.QueryVolumeInfoExt(i, EFileSystemSubType, subName); |
467 r = TheFs.QueryVolumeInfoExt(i, EFileSystemSubType, subName); |
471 test(r == KErrNotReady); |
468 test(r == KErrNotReady); |
472 } |
469 } |
473 else |
470 else |
474 { |
471 { |
475 r = TheFs.QueryVolumeInfoExt(i, EFileSystemSubType, subName); |
472 r = TheFs.QueryVolumeInfoExt(i, EFileSystemSubType, subName); |
476 test_KErrNone(r); |
473 test_KErrNone(r); |
477 |
474 |
478 //-- test EIsDriveSync command |
475 //-- test EIsDriveSync command |
479 r = TheFs.QueryVolumeInfoExt(i, EIsDriveSync, fDrvSyncBuf); |
476 r = TheFs.QueryVolumeInfoExt(i, EIsDriveSync, fDrvSyncBuf); |
480 test(r == KErrNone); |
477 test(r == KErrNone); |
481 if(fDrvSyncBuf()) |
478 if(fDrvSyncBuf()) |
482 test.Printf(_L("The drive is Synchronous.\n")); |
479 test.Printf(_L("The drive is Synchronous.\n")); |
483 else |
480 else |
484 test.Printf(_L("The drive is Asynchronous.\n")); |
481 test.Printf(_L("The drive is Asynchronous.\n")); |
485 |
482 |
486 //----------------- |
483 //----------------- |
487 |
484 |
488 // if Fat, testing returning sub type name |
485 // if Fat, testing returning sub type name |
489 if (fsName.CompareF(KFileSystemName_FAT)==0) |
486 if (fsName.CompareF(KFileSystemName_FAT)==0) |
490 { |
487 { |
491 test(r == KErrNone); |
488 test(r == KErrNone); |
492 test(subName().CompareF(KFSSubType_FAT12)==0 || |
489 test(subName().CompareF(KFSSubType_FAT12)==0 || |
493 subName().CompareF(KFSSubType_FAT16)==0 || |
490 subName().CompareF(KFSSubType_FAT16)==0 || |
494 subName().CompareF(KFSSubType_FAT32)==0); |
491 subName().CompareF(KFSSubType_FAT32)==0); |
495 continue; |
492 continue; |
496 } |
493 } |
497 |
494 |
498 // if Lffs, testing returning file system name |
495 // if Lffs, testing returning file system name |
499 if (fsName.CompareF(_L("Lffs"))==0) |
496 if (fsName.CompareF(_L("Lffs"))==0) |
500 { |
497 { |
501 test(r == KErrNone); |
498 test(r == KErrNone); |
502 test(subName().CompareF(_L("Lffs"))==0); |
499 test(subName().CompareF(_L("Lffs"))==0); |
503 continue; |
500 continue; |
504 } |
501 } |
505 // if rofs, testing returning file system name |
502 // if rofs, testing returning file system name |
506 if (fsName.CompareF(_L("rofs"))==0) |
503 if (fsName.CompareF(_L("rofs"))==0) |
507 { |
504 { |
508 test(r == KErrNone); |
505 test(r == KErrNone); |
509 test(subName().CompareF(_L("rofs"))==0); |
506 test(subName().CompareF(_L("rofs"))==0); |
510 continue; |
507 continue; |
511 } |
508 } |
512 // if Composite, testing returning file system name |
509 // if Composite, testing returning file system name |
513 if (fsName.CompareF(_L("Composite"))==0) |
510 if (fsName.CompareF(_L("Composite"))==0) |
514 { |
511 { |
515 test(r == KErrNone); |
512 test(r == KErrNone); |
516 test(subName().CompareF(_L("Composite"))==0); |
513 test(subName().CompareF(_L("Composite"))==0); |
517 continue; |
514 continue; |
518 } |
515 } |
519 |
516 |
520 // else |
517 // else |
521 test(r == KErrNone); |
518 test(r == KErrNone); |
522 test(subName().Length()!=0); |
519 test(subName().Length()!=0); |
523 |
520 |
524 } |
521 } |
525 } |
522 } |
526 } |
523 } |
527 } |
524 } |
528 |
525 |
529 //---------------------------------------------------------------------------------------------- |
526 //---------------------------------------------------------------------------------------------- |
530 //! @SYMTestCaseID PBASE-t_fsys-0318 |
527 //! @SYMTestCaseID PBASE-t_fsys-0318 |
531 //! @SYMTestType CIT |
528 //! @SYMTestType CIT |
532 //! @SYMPREQ CR0882 |
529 //! @SYMPREQ CR0882 |
533 //! @SYMTestCaseDesc This test case is testing querying file system's cluster size using |
530 //! @SYMTestCaseDesc This test case is testing querying file system's cluster size using |
534 //! RFs::QueryVolumeInfoExt() API. |
531 //! RFs::QueryVolumeInfoExt() API. |
535 //! @SYMTestActions 1 querys cluster size of file system on volumes mounted with 'Fat' file system |
532 //! @SYMTestActions 1 querys cluster size of file system on volumes mounted with 'Fat' file system |
536 //! 2 querys cluster size of file system on volumes mounted with 'Lffs' file system |
533 //! 2 querys cluster size of file system on volumes mounted with 'Lffs' file system |
537 //! 3 querys cluster size of file system on volumes mounted with other file systems |
534 //! 3 querys cluster size of file system on volumes mounted with other file systems |
538 //! @SYMTestExpectedResults |
535 //! @SYMTestExpectedResults |
539 //! 1 returned error code should be KErrNone, cluster size should be non-zero |
536 //! 1 returned error code should be KErrNone, cluster size should be non-zero |
540 //! 2 returned error code should be KErrNone, cluster size should be 512 |
537 //! 2 returned error code should be KErrNone, cluster size should be 512 |
541 //! 3 returned error code should be KErrNone, cluster size should be KErrNotSupported |
538 //! 3 returned error code should be KErrNone, cluster size should be KErrNotSupported |
542 //! @SYMTestPriority High |
539 //! @SYMTestPriority High |
543 //! @SYMTestStatus Implemented |
540 //! @SYMTestStatus Implemented |
544 //---------------------------------------------------------------------------------------------- |
541 //---------------------------------------------------------------------------------------------- |
545 static void TestFileSystemClusterSizeQuery() |
542 static void TestFileSystemClusterSizeQuery() |
546 { |
543 { |
547 test.Next(_L("Test querying cluster size information of the mounted file system")); |
544 test.Next(_L("Test querying cluster size information of the mounted file system")); |
548 TFullName fsName; |
545 TFullName fsName; |
549 TPckgBuf<TVolumeIOParamInfo> ioInfo; |
546 TPckgBuf<TVolumeIOParamInfo> ioInfo; |
550 TInt i, r; |
547 TInt i, r; |
551 TDriveInfo driveInfo; |
548 TDriveInfo driveInfo; |
552 for(i = EDriveA; i <= EDriveZ; ++i) |
549 for(i = EDriveA; i <= EDriveZ; ++i) |
553 { |
550 { |
554 r = TheFs.FileSystemName(fsName, i); |
551 r = TheFs.FileSystemName(fsName, i); |
555 if (r == KErrNone) |
552 if (r == KErrNone) |
556 { |
553 { |
557 test.Printf(_L("Tested on drive: %c.\n"), (char)(i+'A')); |
554 test.Printf(_L("Tested on drive: %c.\n"), (char)(i+'A')); |
558 |
555 |
559 r=TheFs.Drive(driveInfo, i); |
556 r=TheFs.Drive(driveInfo, i); |
560 test(r==KErrNone); |
557 test(r==KErrNone); |
561 // if no media present |
558 // if no media present |
562 if (driveInfo.iType==EMediaNotPresent) |
559 if (driveInfo.iType==EMediaNotPresent) |
563 { |
560 { |
564 r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo); |
|
565 test(r == KErrNone || r == KErrNotReady); |
|
566 } |
|
567 else if (driveInfo.iType==EMediaCdRom) |
|
568 { |
|
569 test.Printf(_L("CD ROM with no media!\n")); |
|
570 r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo); |
561 r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo); |
571 test(r == KErrNone); |
562 test(r == KErrNone || r == KErrNotReady); |
572 } |
563 } |
573 else |
564 else if (driveInfo.iType==EMediaCdRom) |
574 { |
565 { |
575 r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo); |
566 test.Printf(_L("CD ROM with no media!\n")); |
576 test(KErrNone == r); |
567 r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo); |
577 // if Fat |
568 test(r == KErrNone || r == KErrNotReady); |
578 if (fsName.CompareF(KFileSystemName_FAT)==0) |
569 } |
579 { |
570 else |
580 test(ioInfo().iClusterSize != 0); |
571 { |
581 continue; |
572 r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo); |
582 } |
573 test(KErrNone == r); |
583 // else if Lffs |
574 // if Fat |
584 if (fsName.CompareF(_L("Lffs"))==0) |
575 if (fsName.CompareF(KFileSystemName_FAT)==0) |
585 { |
576 { |
586 TBusLocalDrive drive; |
577 test(ioInfo().iClusterSize != 0); |
587 TBool changeFlag = EFalse; |
578 continue; |
588 TInt locDriveNumber; |
579 } |
589 TLocalDriveCaps DriveCaps; |
580 // else if Lffs |
590 TLocalDriveCapsV7 DriveCapsV7; |
581 if (fsName.CompareF(_L("Lffs"))==0) |
591 for(locDriveNumber = 0; locDriveNumber < KMaxLocalDrives; locDriveNumber++) |
582 { |
592 { |
583 TBusLocalDrive drive; |
593 r = drive.Connect(locDriveNumber,changeFlag); |
584 TBool changeFlag = EFalse; |
594 if(r==KErrNone) |
585 TInt locDriveNumber; |
595 { |
586 TLocalDriveCaps DriveCaps; |
596 |
587 TLocalDriveCapsV7 DriveCapsV7; |
597 TPckg<TLocalDriveCaps> capsPckg(DriveCaps); |
588 for(locDriveNumber = 0; locDriveNumber < KMaxLocalDrives; locDriveNumber++) |
598 r=drive.Caps(capsPckg); |
589 { |
599 if((r==KErrNone) && (DriveCaps.iFileSystemId==KDriveFileSysLFFS)) |
590 r = drive.Connect(locDriveNumber,changeFlag); |
600 { |
591 if(r==KErrNone) |
601 break; |
592 { |
602 } |
593 |
603 drive.Disconnect(); |
594 TPckg<TLocalDriveCaps> capsPckg(DriveCaps); |
604 } |
595 r=drive.Caps(capsPckg); |
605 } |
596 if((r==KErrNone) && (DriveCaps.iFileSystemId==KDriveFileSysLFFS)) |
606 TPckg<TLocalDriveCapsV7> capsPckg(DriveCapsV7); |
597 { |
607 r=drive.Caps(capsPckg); |
598 break; |
608 test(r==KErrNone); |
599 } |
609 drive.Disconnect(); |
600 drive.Disconnect(); |
610 if(DriveCapsV7.iObjectModeSize == 0) |
601 } |
611 { |
602 } |
612 test(ioInfo().iClusterSize == 512); |
603 TPckg<TLocalDriveCapsV7> capsPckg(DriveCapsV7); |
613 continue; |
604 r=drive.Caps(capsPckg); |
614 } |
605 test(r==KErrNone); |
615 else |
606 drive.Disconnect(); |
616 { |
607 if(DriveCapsV7.iObjectModeSize == 0) |
617 test((TUint32)(ioInfo().iClusterSize) == DriveCapsV7.iObjectModeSize); |
608 { |
618 continue; |
609 test(ioInfo().iClusterSize == 512); |
619 } |
610 continue; |
620 } |
611 } |
621 // else |
612 else |
622 //-- we can not suggest anything about unknown filesystem, thus do not check the result. |
613 { |
|
614 test((TUint32)(ioInfo().iClusterSize) == DriveCapsV7.iObjectModeSize); |
|
615 continue; |
|
616 } |
|
617 } |
|
618 // else |
|
619 //-- we can not suggest anything about unknown filesystem, thus do not check the result. |
623 //test(ioInfo().iClusterSize == KErrNotSupported); |
620 //test(ioInfo().iClusterSize == KErrNotSupported); |
624 |
621 |
625 } |
622 } |
626 } |
623 } |
627 } |
624 } |
628 } |
625 } |
629 |
626 |
630 //---------------------------------------------------------------------------------------------- |
627 //---------------------------------------------------------------------------------------------- |
631 //! @SYMTestCaseID PBASE-t_fsys-0319 |
628 //! @SYMTestCaseID PBASE-t_fsys-0319 |
632 //! @SYMTestType CIT |
629 //! @SYMTestType CIT |
633 //! @SYMPREQ CR0882 |
630 //! @SYMPREQ CR0882 |
634 //! @SYMTestCaseDesc This test case is testing querying block size of underlying media using |
631 //! @SYMTestCaseDesc This test case is testing querying block size of underlying media using |
635 //! RFs::QueryVolumeInfoExt() API. |
632 //! RFs::QueryVolumeInfoExt() API. |
636 //! @SYMTestActions 1 querys block size on volumes mounted with MMC card type of media |
633 //! @SYMTestActions 1 querys block size on volumes mounted with MMC card type of media |
637 //! 2 querys block size on volumes mounted with RAM type of media |
634 //! 2 querys block size on volumes mounted with RAM type of media |
638 //! 3 querys block size on volumes mounted with NOR flash type of media |
635 //! 3 querys block size on volumes mounted with NOR flash type of media |
639 //! 4 querys block size on volumes mounted with Nand flash (code) type of media |
636 //! 4 querys block size on volumes mounted with Nand flash (code) type of media |
640 //! 5 querys block size on volumes mounted with Nand flash (data) type of media |
637 //! 5 querys block size on volumes mounted with Nand flash (data) type of media |
641 //! @SYMTestExpectedResults |
638 //! @SYMTestExpectedResults |
642 //! 1 returned error code should be KErrNone, block size should be 512 |
639 //! 1 returned error code should be KErrNone, block size should be 512 |
643 //! 2 returned error code should be KErrNone, block size should be KDefaultVolumeBlockSize |
640 //! 2 returned error code should be KErrNone, block size should be KDefaultVolumeBlockSize |
644 //! 3 returned error code should be KErrNone, block size should be KDefaultVolumeBlockSize |
641 //! 3 returned error code should be KErrNone, block size should be KDefaultVolumeBlockSize |
645 //! 4 returned error code should be KErrNone, block size should be 512 |
642 //! 4 returned error code should be KErrNone, block size should be 512 |
646 //! 5 returned error code should be KErrNone, block size should be 512 |
643 //! 5 returned error code should be KErrNone, block size should be 512 |
647 //! @SYMTestPriority High |
644 //! @SYMTestPriority High |
648 //! @SYMTestStatus Implemented |
645 //! @SYMTestStatus Implemented |
649 //---------------------------------------------------------------------------------------------- |
646 //---------------------------------------------------------------------------------------------- |
650 static void TestMediaBlockSizeQuery() |
647 static void TestMediaBlockSizeQuery() |
651 { |
648 { |
652 test.Next(_L("Test querying block size information of the underlying media")); |
649 test.Next(_L("Test querying block size information of the underlying media")); |
653 #if defined(__WINS__) |
650 #if defined(__WINS__) |
654 test.Printf(_L("This test case runs on hardware only")); |
651 test.Printf(_L("This test case runs on hardware only")); |
655 return; |
652 return; |
656 |
653 |
657 #else // test runs on hardware only. |
654 #else // test runs on hardware only. |
658 TFSName fsName; |
655 TFSName fsName; |
659 TPckgBuf<TVolumeIOParamInfo> ioInfo; |
656 TPckgBuf<TVolumeIOParamInfo> ioInfo; |
660 TInt i, r; |
657 TInt i, r; |
661 TDriveInfo driveInfo; |
658 TDriveInfo driveInfo; |
662 for(i = EDriveA; i <= EDriveZ; ++i) |
659 for(i = EDriveA; i <= EDriveZ; ++i) |
663 { |
660 { |
664 r = TheFs.FileSystemName(fsName, i); |
661 r = TheFs.FileSystemName(fsName, i); |
665 if (r == KErrNone) |
662 if (r == KErrNone) |
666 { |
663 { |
667 test.Printf(_L("Tested on drive: %c.\n"), (char)(i+'A')); |
664 test.Printf(_L("Tested on drive: %c.\n"), (char)(i+'A')); |
668 r=TheFs.Drive(driveInfo, i); |
665 r=TheFs.Drive(driveInfo, i); |
669 test(r==KErrNone); |
666 test(r==KErrNone); |
670 // if no media present |
667 // if no media present |
671 if (driveInfo.iType==EMediaNotPresent) |
668 if (driveInfo.iType==EMediaNotPresent) |
672 { |
669 { |
673 r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo); |
670 r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo); |
674 test(r == KErrNone || r == KErrNotReady); |
671 test(r == KErrNone || r == KErrNotReady); |
675 } |
672 } |
676 else |
673 else if (driveInfo.iType==EMediaCdRom) |
677 { |
674 { |
678 r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo); |
675 test.Printf(_L("CD ROM with no media will report not ready!\n")); |
679 test(KErrNone == r); |
676 r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo); |
680 // if MMC, test block size >= 512; |
677 test(r == KErrNotReady); |
681 // (Version 4.3 MMC cards introduce the concept of a "Super Page" which should be used as |
678 } |
682 // guide when calculating the cluster size. For these cards the reported block size may be |
679 else |
683 // any multiple of 512). |
680 { |
684 if ((driveInfo.iType == EMediaHardDisk) && |
681 r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo); |
685 (driveInfo.iDriveAtt & KDriveAttRemovable) && |
682 test(KErrNone == r); |
686 (driveInfo.iDriveAtt & KDriveAttLocal)) |
683 // if MMC, test block size >= 512; |
687 { |
684 // (Version 4.3 MMC cards introduce the concept of a "Super Page" which should be used as |
688 test(ioInfo().iBlockSize >= 512); |
685 // guide when calculating the cluster size. For these cards the reported block size may be |
689 continue; |
686 // any multiple of 512). |
690 } |
687 if ((driveInfo.iType == EMediaHardDisk) && |
691 // if RAM, test block size == 1; |
688 (driveInfo.iDriveAtt & KDriveAttRemovable) && |
692 if ((driveInfo.iType == EMediaRam) && |
689 (driveInfo.iDriveAtt & KDriveAttLocal)) |
693 (driveInfo.iDriveAtt & KDriveAttLocal) && |
690 { |
694 (driveInfo.iDriveAtt & KDriveAttInternal)) |
691 test(ioInfo().iBlockSize >= 512); |
695 { |
692 continue; |
696 test(ioInfo().iBlockSize == 1); |
693 } |
697 continue; |
694 // if RAM, test block size == 1; |
698 } |
695 if ((driveInfo.iType == EMediaRam) && |
699 // if NOR flash, test block size == 512 (default block size); |
696 (driveInfo.iDriveAtt & KDriveAttLocal) && |
700 if ((driveInfo.iType == EMediaFlash) && |
697 (driveInfo.iDriveAtt & KDriveAttInternal)) |
701 (driveInfo.iDriveAtt & KDriveAttLocal) && |
698 { |
702 (driveInfo.iDriveAtt & KDriveAttInternal)) |
699 test(ioInfo().iBlockSize == 1); |
703 { |
700 continue; |
704 TBusLocalDrive drive; |
701 } |
705 TBool changeFlag = EFalse; |
702 // if NOR flash, test block size == 512 (default block size); |
706 TInt locDriveNumber; |
703 if ((driveInfo.iType == EMediaFlash) && |
707 TLocalDriveCaps DriveCaps; |
704 (driveInfo.iDriveAtt & KDriveAttLocal) && |
708 TLocalDriveCapsV7 DriveCapsV7; |
705 (driveInfo.iDriveAtt & KDriveAttInternal)) |
709 for(locDriveNumber = 0; locDriveNumber < KMaxLocalDrives; locDriveNumber++) |
706 { |
710 { |
707 TBusLocalDrive drive; |
711 r = drive.Connect(locDriveNumber,changeFlag); |
708 TBool changeFlag = EFalse; |
712 if(r==KErrNone) |
709 TInt locDriveNumber; |
713 { |
710 TLocalDriveCaps DriveCaps; |
714 TPckg<TLocalDriveCaps> capsPckg(DriveCaps); |
711 TLocalDriveCapsV7 DriveCapsV7; |
715 r=drive.Caps(capsPckg); |
712 for(locDriveNumber = 0; locDriveNumber < KMaxLocalDrives; locDriveNumber++) |
716 if((r==KErrNone) && (DriveCaps.iFileSystemId==KDriveFileSysLFFS)) |
713 { |
717 { |
714 r = drive.Connect(locDriveNumber,changeFlag); |
718 |
715 if(r==KErrNone) |
719 break; |
716 { |
720 } |
717 TPckg<TLocalDriveCaps> capsPckg(DriveCaps); |
721 drive.Disconnect(); |
718 r=drive.Caps(capsPckg); |
722 } |
719 if((r==KErrNone) && (DriveCaps.iFileSystemId==KDriveFileSysLFFS)) |
723 } |
720 { |
724 TPckg<TLocalDriveCapsV7> capsPckg(DriveCapsV7); |
721 break; |
725 r=drive.Caps(capsPckg); |
722 } |
726 test(r==KErrNone); |
723 drive.Disconnect(); |
727 if ((fsName.CompareF(_L("Lffs"))==0) && (DriveCapsV7.iObjectModeSize != 0)) |
724 } |
728 { |
725 } |
729 |
726 TPckg<TLocalDriveCapsV7> capsPckg(DriveCapsV7); |
730 test(ioInfo().iBlockSize == (TInt) DriveCapsV7.iObjectModeSize); |
727 r=drive.Caps(capsPckg); |
731 continue; |
728 test(r==KErrNone); |
732 } |
729 if ((fsName.CompareF(_L("Lffs"))==0) && (DriveCapsV7.iObjectModeSize != 0)) |
733 else |
730 { |
734 { |
731 test(ioInfo().iBlockSize == (TInt) DriveCapsV7.iObjectModeSize); |
735 test(ioInfo().iBlockSize == (TInt) KDefaultVolumeBlockSize); |
732 continue; |
736 continue; |
733 } |
737 } |
734 else |
738 } |
735 { |
739 // if Nand flash (with Fat file system), test block size == 512 (small-block) or 2048 (large-block) |
736 test(ioInfo().iBlockSize == (TInt) KDefaultVolumeBlockSize); |
740 if ((driveInfo.iType == EMediaNANDFlash) && |
737 continue; |
741 (driveInfo.iDriveAtt & KDriveAttLocal) && |
738 } |
742 (driveInfo.iDriveAtt & KDriveAttInternal)) |
739 } |
743 { |
740 // if Nand flash (with Fat file system), test block size == 512 (small-block) or 2048 (large-block) |
744 test(ioInfo().iBlockSize == 512 || ioInfo().iBlockSize == 2048); |
741 if ((driveInfo.iType == EMediaNANDFlash) && |
745 continue; |
742 (driveInfo.iDriveAtt & KDriveAttLocal) && |
746 } |
743 (driveInfo.iDriveAtt & KDriveAttInternal)) |
747 } |
744 { |
748 } |
745 test(ioInfo().iBlockSize == 512 || ioInfo().iBlockSize == 2048); |
749 } |
746 continue; |
750 #endif // __WINS__ |
747 } |
751 } |
748 } |
|
749 } |
|
750 } |
|
751 #endif // __WINS__ |
|
752 } |
752 |
753 |
753 //---------------------------------------------------------------------------------------------- |
754 //---------------------------------------------------------------------------------------------- |
754 //! @SYMTestCaseID PBASE-t_fsys-0320 |
755 //! @SYMTestCaseID PBASE-t_fsys-0320 |
755 //! @SYMTestType CIT |
756 //! @SYMTestType CIT |
756 //! @SYMPREQ CR0882 |
757 //! @SYMPREQ CR0882 |
757 //! @SYMTestCaseDesc This test case is testing wrapper API RFs::FileSystemSubType() has the same |
758 //! @SYMTestCaseDesc This test case is testing wrapper API RFs::FileSystemSubType() has the same |
758 //! behaviours as RFs::QueryVolumeInfoExt() |
759 //! behaviours as RFs::QueryVolumeInfoExt() |
759 //! @SYMTestActions 1 querys file system sub type name by both APIs |
760 //! @SYMTestActions 1 querys file system sub type name by both APIs |
760 //! @SYMTestExpectedResults |
761 //! @SYMTestExpectedResults |
761 //! 1 returned error codes and descriptors of both API should be identical |
762 //! 1 returned error codes and descriptors of both API should be identical |
762 //! @SYMTestPriority High |
763 //! @SYMTestPriority High |
763 //! @SYMTestStatus Implemented |
764 //! @SYMTestStatus Implemented |
764 //---------------------------------------------------------------------------------------------- |
765 //---------------------------------------------------------------------------------------------- |
765 static void TestFileSystemSubType() |
766 static void TestFileSystemSubType() |
766 { |
767 { |
767 test.Next(_L("Test wrapper API RFs::FileSystemSubType()'s behaviour")); |
768 test.Next(_L("Test wrapper API RFs::FileSystemSubType()'s behaviour")); |
768 TFSName fsName; |
769 TFSName fsName; |
769 TPckgBuf<TFSName> subName; |
770 TPckgBuf<TFSName> subName; |
770 TInt r; |
771 TInt r; |
771 TFSName subName1; |
772 TFSName subName1; |
772 TInt r1; |
773 TInt r1; |
773 |
774 |
774 for(TInt i = EDriveA; i <= EDriveZ; ++i) |
775 for(TInt i = EDriveA; i <= EDriveZ; ++i) |
775 { |
776 { |
776 r = TheFs.FileSystemName(fsName, i); |
777 r = TheFs.FileSystemName(fsName, i); |
777 if (r == KErrNone) |
778 if (r == KErrNone) |
778 { |
779 { |
779 test.Printf(_L("Tested on drive: %c.\n"), (char)(i+'A')); |
780 test.Printf(_L("Tested on drive: %c.\n"), (char)(i+'A')); |
780 r = TheFs.QueryVolumeInfoExt(i, EFileSystemSubType, subName); |
781 r = TheFs.QueryVolumeInfoExt(i, EFileSystemSubType, subName); |
781 r1 = TheFs.FileSystemSubType(i, subName1); |
782 r1 = TheFs.FileSystemSubType(i, subName1); |
782 test(r==r1); |
783 test(r==r1); |
783 if (subName().Length()) |
784 if (subName().Length()) |
784 { |
785 { |
785 test(subName().CompareF(subName1)==0); |
786 test(subName().CompareF(subName1)==0); |
786 } |
787 } |
787 else |
788 else |
788 { |
789 { |
789 test(subName1.Length()==0); |
790 test(subName1.Length()==0); |
790 } |
791 } |
791 } |
792 } |
792 } |
793 } |
793 } |
794 } |
794 |
795 |
795 //---------------------------------------------------------------------------------------------- |
796 //---------------------------------------------------------------------------------------------- |
796 //! @SYMTestCaseID PBASE-t_fsys-0321 |
797 //! @SYMTestCaseID PBASE-t_fsys-0321 |
797 //! @SYMTestType CIT |
798 //! @SYMTestType CIT |
798 //! @SYMPREQ CR0882 |
799 //! @SYMPREQ CR0882 |
799 //! @SYMTestCaseDesc This test case is testing wrapper API RFs::VolumeIOParam() has the same |
800 //! @SYMTestCaseDesc This test case is testing wrapper API RFs::VolumeIOParam() has the same |
800 //! behaviours as RFs::QueryVolumeInfoExt() |
801 //! behaviours as RFs::QueryVolumeInfoExt() |
801 //! @SYMTestActions 1 querys volume IO params by both APIs |
802 //! @SYMTestActions 1 querys volume IO params by both APIs |
802 //! @SYMTestExpectedResults |
803 //! @SYMTestExpectedResults |
803 //! 1 returned error codes and IO param values of both API should be identical |
804 //! 1 returned error codes and IO param values of both API should be identical |
804 //! @SYMTestPriority High |
805 //! @SYMTestPriority High |
805 //! @SYMTestStatus Implemented |
806 //! @SYMTestStatus Implemented |
806 //---------------------------------------------------------------------------------------------- |
807 //---------------------------------------------------------------------------------------------- |
807 static void TestVolumeIOParam() |
808 static void TestVolumeIOParam() |
808 { |
809 { |
809 test.Next(_L("Test wrapper API RFs::VolumeIOParam()'s behaviour")); |
810 test.Next(_L("Test wrapper API RFs::VolumeIOParam()'s behaviour")); |
810 TFSName fsName; |
811 TFSName fsName; |
811 TPckgBuf<TVolumeIOParamInfo> ioInfo; |
812 TPckgBuf<TVolumeIOParamInfo> ioInfo; |
812 TInt r; |
813 TInt r; |
813 TVolumeIOParamInfo ioInfo1; |
814 TVolumeIOParamInfo ioInfo1; |
814 TInt r1; |
815 TInt r1; |
815 |
816 |
816 for(TInt i = EDriveA; i <= EDriveZ; ++i) |
817 for(TInt i = EDriveA; i <= EDriveZ; ++i) |
817 { |
818 { |
818 r = TheFs.FileSystemName(fsName, i); |
819 r = TheFs.FileSystemName(fsName, i); |
819 if (r == KErrNone) |
820 if (r == KErrNone) |
820 { |
821 { |
821 test.Printf(_L("Tested on drive: %c.\n"), (char)(i+'A')); |
822 test.Printf(_L("Tested on drive: %c.\n"), (char)(i+'A')); |
822 r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo); |
823 r = TheFs.QueryVolumeInfoExt(i, EIOParamInfo, ioInfo); |
823 r1 = TheFs.VolumeIOParam(i, ioInfo1); |
824 r1 = TheFs.VolumeIOParam(i, ioInfo1); |
824 test(r==r1); |
825 test(r==r1); |
825 test(ioInfo().iBlockSize == ioInfo1.iBlockSize); |
826 test(ioInfo().iBlockSize == ioInfo1.iBlockSize); |
826 test(ioInfo().iClusterSize == ioInfo1.iClusterSize); |
827 test(ioInfo().iClusterSize == ioInfo1.iClusterSize); |
827 test(ioInfo().iRecReadBufSize == ioInfo1.iRecReadBufSize); |
828 test(ioInfo().iRecReadBufSize == ioInfo1.iRecReadBufSize); |
828 test(ioInfo().iRecWriteBufSize == ioInfo1.iRecWriteBufSize); |
829 test(ioInfo().iRecWriteBufSize == ioInfo1.iRecWriteBufSize); |
829 } |
830 } |
830 } |
831 } |
831 } |
832 } |
832 |
833 |
833 |
834 |
834 //---------------------------------------------------------------------------------------------- |
835 //---------------------------------------------------------------------------------------------- |
835 //! @SYMTestCaseID PBASE-t_fsys-0322 |
836 //! @SYMTestCaseID PBASE-t_fsys-0322 |
836 //! @SYMTestType CIT |
837 //! @SYMTestType CIT |
837 //! @SYMPREQ CR0882 |
838 //! @SYMPREQ CR0882 |
838 //! @SYMTestCaseDesc This test case is testing RFs::QueryVolumeInfoExt() API on a testing file system |
839 //! @SYMTestCaseDesc This test case is testing RFs::QueryVolumeInfoExt() API on a testing file system |
839 //! @SYMTestActions 0 mounts testing file system on a certain drive |
840 //! @SYMTestActions 0 mounts testing file system on a certain drive |
840 //! 1 querys file system's sub type name on the drive under testing |
841 //! 1 querys file system's sub type name on the drive under testing |
841 //! 2 querys file system's cluster size on the drive under testing |
842 //! 2 querys file system's cluster size on the drive under testing |
842 //! @SYMTestExpectedResults |
843 //! @SYMTestExpectedResults |
843 //! 1 returned error code should be KErrNone, sub type name should match 'Test3SubType' |
844 //! 1 returned error code should be KErrNone, sub type name should match 'Test3SubType' |
844 //! 2 returned error code should be KErrNone, cluster size should equal 1024 |
845 //! 2 returned error code should be KErrNone, cluster size should equal 1024 |
845 //! @SYMTestPriority High |
846 //! @SYMTestPriority High |
846 //! @SYMTestStatus Implemented |
847 //! @SYMTestStatus Implemented |
847 //---------------------------------------------------------------------------------------------- |
848 //---------------------------------------------------------------------------------------------- |
848 static void TestQueryVolumeInfoExtOnTestFS(TInt aDrive) |
849 static void TestQueryVolumeInfoExtOnTestFS(TInt aDrive) |
849 { |
850 { |
850 if (aDrive==EDriveC) // Can't test on C: |
851 if (aDrive==EDriveC) // Can't test on C: |
851 return; |
852 return; |
852 |
853 |
853 TInt r; |
854 TInt r; |
854 |
855 |
855 test.Printf(_L("Tested on drive: %c.\n"), (char)(aDrive+'A')); |
856 test.Printf(_L("Tested on drive: %c.\n"), (char)(aDrive+'A')); |
856 |
857 |
857 // Mount a new CTestFileSystem on the drive under test |
858 // Mount a new CTestFileSystem on the drive under test |
858 test.Next(_L("Test RFs::QueryVolumeInfoExt() on Testing File System")); |
859 test.Next(_L("Test RFs::QueryVolumeInfoExt() on Testing File System")); |
859 r = TheFs.AddFileSystem(_L("T_TFSYS3")); |
860 r = TheFs.AddFileSystem(_L("T_TFSYS3")); |
860 if (r != KErrNone && r != KErrAlreadyExists) |
861 if (r != KErrNone && r != KErrAlreadyExists) |
861 { |
862 { |
862 test.Printf(_L("error=%d"),r); |
863 test.Printf(_L("error=%d"),r); |
863 test(EFalse); |
864 test(EFalse); |
864 } |
865 } |
865 TFSName oldFs; |
866 TFSName oldFs; |
866 r = TheFs.FileSystemName(oldFs,aDrive); |
867 r = TheFs.FileSystemName(oldFs,aDrive); |
867 test(r==KErrNone); |
868 test(r==KErrNone); |
868 r = TheFs.DismountFileSystem(oldFs,aDrive); |
869 r = TheFs.DismountFileSystem(oldFs,aDrive); |
869 if (r != KErrNone) |
870 if (r != KErrNone) |
870 { |
871 { |
871 test.Printf(_L("Error = %d"),r); |
872 test.Printf(_L("Error = %d"),r); |
872 test(EFalse); |
873 test(EFalse); |
873 } |
874 } |
874 r = TheFs.MountFileSystem(_L("Test3"),aDrive); |
875 r = TheFs.MountFileSystem(_L("Test3"),aDrive); |
875 test(r==KErrNone); |
876 test(r==KErrNone); |
876 TFSName newFs; |
877 TFSName newFs; |
877 r = TheFs.FileSystemName(newFs,aDrive); |
878 r = TheFs.FileSystemName(newFs,aDrive); |
878 test(r==KErrNone); |
879 test(r==KErrNone); |
879 test(newFs.Compare(_L("Test3"))==0); |
880 test(newFs.Compare(_L("Test3"))==0); |
880 |
881 |
881 // Sub type name query: |
882 // Sub type name query: |
882 TPckgBuf<TFSName> subNameP; |
883 TPckgBuf<TFSName> subNameP; |
883 r = TheFs.QueryVolumeInfoExt(aDrive, EFileSystemSubType, subNameP); |
884 r = TheFs.QueryVolumeInfoExt(aDrive, EFileSystemSubType, subNameP); |
884 test(r==KErrNone); |
885 test(r==KErrNone); |
885 test(subNameP() == _L("Test3SubType")); |
886 test(subNameP() == _L("Test3SubType")); |
886 |
887 |
887 // Cluster size querys: |
888 // Cluster size querys: |
888 TPckgBuf<TVolumeIOParamInfo> ioInfoP; |
889 TPckgBuf<TVolumeIOParamInfo> ioInfoP; |
889 r = TheFs.QueryVolumeInfoExt(aDrive, EIOParamInfo, ioInfoP); |
890 r = TheFs.QueryVolumeInfoExt(aDrive, EIOParamInfo, ioInfoP); |
890 test(r==KErrNone); |
891 test(r==KErrNone); |
891 test(ioInfoP().iClusterSize==1024); |
892 test(ioInfoP().iClusterSize==1024); |
892 |
893 |
893 // Mount the original file system back |
894 // Mount the original file system back |
894 r=TheFs.DismountFileSystem(newFs,aDrive); |
895 r=TheFs.DismountFileSystem(newFs,aDrive); |
895 test(r==KErrNone); |
896 test(r==KErrNone); |
896 r=TheFs.MountFileSystem(oldFs,aDrive); |
897 r=TheFs.MountFileSystem(oldFs,aDrive); |
897 test(r==KErrNone); |
898 test(r==KErrNone); |
898 |
899 |
899 r=TheFs.RemoveFileSystem(_L("Test3")); |
900 r=TheFs.RemoveFileSystem(_L("Test3")); |
900 if(r!=KErrNone) |
901 if(r!=KErrNone) |
901 { |
902 { |
902 test.Printf(_L("error=%d"),r); |
903 test.Printf(_L("error=%d"),r); |
903 test(EFalse); |
904 test(EFalse); |
904 } |
905 } |
905 } |
906 } |
906 |
907 |
907 |
908 |
908 //---------------------------------------------------------------------------------------------- |
909 //---------------------------------------------------------------------------------------------- |
909 /** |
910 /** |
910 Test remounting the file system with objects opened. |
911 Test remounting the file system with objects opened. |