| branch | RCL_3 |
| changeset 256 | c1f20ce4abcf |
| parent 0 | a41df078684a |
| child 257 | 3e88ff8f41d5 |
| 249:a179b74831c9 | 256:c1f20ce4abcf |
|---|---|
11 // Contributors: |
11 // Contributors: |
12 // |
12 // |
13 // Description: |
13 // Description: |
14 // |
14 // |
15 |
15 |
16 #define __E32TEST_EXTENSION__ |
|
16 #include <f32file.h> |
17 #include <f32file.h> |
17 #include <e32test.h> |
18 #include <e32test.h> |
18 #include <e32std.h> |
19 #include <e32std.h> |
19 #include <e32std_private.h> |
20 #include <e32std_private.h> |
20 #include <e32svr.h> |
21 #include <e32svr.h> |
85 TRequestStatus aStat1; |
86 TRequestStatus aStat1; |
86 TRequestStatus aStat2; |
87 TRequestStatus aStat2; |
87 TRequestStatus aStat3; |
88 TRequestStatus aStat3; |
88 TRequestStatus aStat4; |
89 TRequestStatus aStat4; |
89 |
90 |
90 TVolumeInfo aVolInfo; |
|
91 |
|
92 TBuf<40> systestfile; |
91 TBuf<40> systestfile; |
93 TBuf<40> pritestfile; |
92 TBuf<40> pritestfile; |
94 TBuf<40> restestfile; |
93 TBuf<40> restestfile; |
95 TBuf<40> systestfile1; |
94 TBuf<40> systestfile1; |
96 TBuf<40> pritestfile1; |
95 TBuf<40> pritestfile1; |
109 // This test case is brought in by INC054580 |
108 // This test case is brought in by INC054580 |
110 // (NTT Renaming sys ¨Cfolder on C -drive on H2 allows user to access sys -files) |
109 // (NTT Renaming sys ¨Cfolder on C -drive on H2 allows user to access sys -files) |
111 // |
110 // |
112 { |
111 { |
113 TInt r = TheFs.Rename(_L("\\sys"), _L("\\sysbad")); |
112 TInt r = TheFs.Rename(_L("\\sys"), _L("\\sysbad")); |
114 test(r == KErrNone); |
113 test_KErrNone(r); |
115 r = TheFs.Rename(_L("\\resource"), _L("\\resourcebad")); |
114 r = TheFs.Rename(_L("\\resource"), _L("\\resourcebad")); |
116 test(r == KErrNone); |
115 test_KErrNone(r); |
117 r = TheFs.Rename(_L("\\sysbad"), _L("\\sys")); |
116 r = TheFs.Rename(_L("\\sysbad"), _L("\\sys")); |
118 test(r == KErrNone); |
117 test_KErrNone(r); |
119 r = TheFs.Rename(_L("\\resourcebad"), _L("\\resource")); |
118 r = TheFs.Rename(_L("\\resourcebad"), _L("\\resource")); |
120 test(r == KErrNone); |
119 test_KErrNone(r); |
121 r = TheFs.Rename(_L("\\private"), _L("\\privatebad")); |
120 r = TheFs.Rename(_L("\\private"), _L("\\privatebad")); |
122 test(r == KErrPermissionDenied); |
121 test_Value(r, r == KErrPermissionDenied); |
123 } |
122 } |
124 |
123 |
125 LOCAL_C void systemRFsTest() |
124 LOCAL_C void systemRFsTest() |
126 // |
125 // |
127 // RFs test on system Directory |
126 // RFs test on system Directory |
133 |
132 |
134 mkdirname.Zero(); |
133 mkdirname.Zero(); |
135 mkdirname.Append(systestname); |
134 mkdirname.Append(systestname); |
136 mkdirname.Append(KMkDirSub); |
135 mkdirname.Append(KMkDirSub); |
137 r=TheFs.MkDirAll(mkdirname); |
136 r=TheFs.MkDirAll(mkdirname); |
138 test(r==KErrNone); |
137 test_KErrNone(r); |
139 |
138 |
140 TheFs.RmDir(mkdirname); |
139 TheFs.RmDir(mkdirname); |
141 test(r==KErrNone); |
140 test_KErrNone(r); |
142 |
141 |
143 r=TheFs.SetSubst(systestname,EDriveO); |
142 r=TheFs.SetSubst(systestname,EDriveO); |
144 test(r==KErrPermissionDenied); |
143 test_Value(r, r == KErrPermissionDenied); |
145 |
144 |
146 r=TheFs.RealName(_L("O:\\File.XXX"),realName); |
145 r=TheFs.RealName(_L("O:\\File.XXX"),realName); |
147 test(r==KErrNone); |
146 test_KErrNone(r); |
148 |
147 |
149 r=TheFs.SetSessionPath(systestname); |
148 r=TheFs.SetSessionPath(systestname); |
150 test(r==KErrPermissionDenied); |
149 test_Value(r, r == KErrPermissionDenied); |
151 |
150 |
152 TheFs.NotifyChange(ENotifyAll,aStat1,systestname); |
151 TheFs.NotifyChange(ENotifyAll,aStat1,systestname); |
153 test(aStat1==KErrPermissionDenied); |
152 test(aStat1==KErrPermissionDenied); |
154 |
153 |
155 systestfile=KSystemPath; |
154 systestfile=KSystemPath; |
160 |
159 |
161 oldName=KOldFile; |
160 oldName=KOldFile; |
162 oldName[0]=(TText)gDriveToTest; |
161 oldName[0]=(TText)gDriveToTest; |
163 |
162 |
164 r=TheFs.GetShortName(systestfile, shortfilename); |
163 r=TheFs.GetShortName(systestfile, shortfilename); |
165 test(r==KErrPermissionDenied || r==KErrNotSupported); |
164 test_Value(r, r == KErrPermissionDenied || r==KErrNotSupported); |
166 |
165 |
167 r=TheFs.GetLongName(systestfile1, longfilename); |
166 r=TheFs.GetLongName(systestfile1, longfilename); |
168 test(r==KErrPermissionDenied || r==KErrNotSupported); |
167 test_Value(r, r == KErrPermissionDenied || r==KErrNotSupported); |
169 |
168 |
170 r=file1.Create(TheFs,oldName,EFileWrite); |
169 r=file1.Create(TheFs,oldName,EFileWrite); |
171 test(r==KErrNone || r==KErrAlreadyExists); |
170 test_Value(r, r == KErrNone || r==KErrAlreadyExists); |
172 file1.Close(); |
171 file1.Close(); |
173 |
172 |
174 r=TheFs.Replace(oldName,systestfile); |
173 r=TheFs.Replace(oldName,systestfile); |
175 test(r==KErrNone); |
174 test_KErrNone(r); |
176 |
175 |
177 r=TheFs.Delete(systestfile1); |
176 r=TheFs.Delete(systestfile1); |
178 test(r==KErrNone || r==KErrNotFound); |
177 test_Value(r, r == KErrNone || r==KErrNotFound); |
179 |
178 |
180 r=TheFs.Rename(systestfile,systestfile1); |
179 r=TheFs.Rename(systestfile,systestfile1); |
181 test(r==KErrNone); |
180 test_KErrNone(r); |
182 |
181 |
183 r=TheFs.Entry(systestfile1,entry); |
182 r=TheFs.Entry(systestfile1,entry); |
184 test(r==KErrPermissionDenied); |
183 test_Value(r, r == KErrPermissionDenied); |
185 |
184 |
186 r=TheFs.SetEntry(systestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly); |
185 r=TheFs.SetEntry(systestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly); |
187 test(r==KErrNone); |
186 test_KErrNone(r); |
188 |
187 |
189 r=TheFs.Delete(systestfile1); |
188 r=TheFs.Delete(systestfile1); |
190 test(r==KErrNone); |
189 test_KErrNone(r); |
191 |
190 |
192 __UHEAP_MARKEND; |
191 __UHEAP_MARKEND; |
193 |
192 |
194 } |
193 } |
195 |
194 |
205 |
204 |
206 mkdirname.Zero(); |
205 mkdirname.Zero(); |
207 mkdirname.Append(restestname); |
206 mkdirname.Append(restestname); |
208 mkdirname.Append(KMkDirSub); |
207 mkdirname.Append(KMkDirSub); |
209 r=TheFs.MkDirAll(mkdirname); |
208 r=TheFs.MkDirAll(mkdirname); |
210 test(r==KErrNone); |
209 test_KErrNone(r); |
211 |
210 |
212 TheFs.RmDir(mkdirname); |
211 TheFs.RmDir(mkdirname); |
213 test(r==KErrNone); |
212 test_KErrNone(r); |
214 |
213 |
215 r=TheFs.SetSubst(restestname,EDriveO); |
214 r=TheFs.SetSubst(restestname,EDriveO); |
216 test(r==KErrPermissionDenied || r==KErrGeneral); |
215 test_Value(r, r == KErrPermissionDenied || r==KErrGeneral); |
217 |
216 |
218 r=TheFs.RealName(_L("O:\\File.XXX"),realName); |
217 r=TheFs.RealName(_L("O:\\File.XXX"),realName); |
219 test(r==KErrNone); |
218 test_KErrNone(r); |
220 |
219 |
221 r=TheFs.SetSessionPath(restestname); |
220 r=TheFs.SetSessionPath(restestname); |
222 test(r==KErrNone); |
221 test_KErrNone(r); |
223 |
222 |
224 TheFs.NotifyChange(ENotifyAll,aStat4,restestname); |
223 TheFs.NotifyChange(ENotifyAll,aStat4,restestname); |
225 test(aStat4==KRequestPending); |
224 test(aStat4==KRequestPending); |
226 |
225 |
227 restestfile=KResourcePath; |
226 restestfile=KResourcePath; |
232 |
231 |
233 oldName=KOldFile; |
232 oldName=KOldFile; |
234 oldName[0]=(TText)gDriveToTest; |
233 oldName[0]=(TText)gDriveToTest; |
235 |
234 |
236 r=TheFs.GetShortName(restestfile, shortfilename); |
235 r=TheFs.GetShortName(restestfile, shortfilename); |
237 test(r==KErrNone || KErrNotFound || r==KErrNotSupported); |
236 // test_Value(r, r == KErrNone || r == KErrNotFound || r==KErrNotSupported); |
237 test(r == KErrNone || KErrNotFound || r==KErrNotSupported); |
|
238 |
238 |
239 r=TheFs.GetLongName(restestfile1, longfilename); |
239 r=TheFs.GetLongName(restestfile1, longfilename); |
240 test(r==KErrNone || KErrNotFound || r==KErrNotSupported); |
240 // test_Value(r, r == KErrNone || r == KErrNotFound || r==KErrNotSupported); |
241 test(r == KErrNone || KErrNotFound || r==KErrNotSupported); |
|
241 |
242 |
242 r=file1.Create(TheFs,oldName,EFileWrite); |
243 r=file1.Create(TheFs,oldName,EFileWrite); |
243 test(r==KErrNone || r==KErrAlreadyExists); |
244 test_Value(r, r == KErrNone || r==KErrAlreadyExists); |
244 file1.Close(); |
245 file1.Close(); |
245 |
246 |
246 r=TheFs.Replace(oldName,restestfile); |
247 r=TheFs.Replace(oldName,restestfile); |
247 test(r==KErrNone); |
248 test_KErrNone(r); |
248 |
249 |
249 r=TheFs.Rename(restestfile,restestfile1); |
250 r=TheFs.Rename(restestfile,restestfile1); |
250 test(r==KErrNone); |
251 test_KErrNone(r); |
251 |
252 |
252 r=TheFs.Entry(restestfile1,entry); |
253 r=TheFs.Entry(restestfile1,entry); |
253 test(r==KErrNone); |
254 test_KErrNone(r); |
254 |
255 |
255 r=TheFs.SetEntry(restestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly); |
256 r=TheFs.SetEntry(restestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly); |
256 test(r==KErrNone); |
257 test_KErrNone(r); |
257 |
258 |
258 r=TheFs.Delete(restestfile1); |
259 r=TheFs.Delete(restestfile1); |
259 test(r==KErrNone); |
260 test_KErrNone(r); |
260 |
261 |
261 __UHEAP_MARK; |
262 __UHEAP_MARK; |
262 |
263 |
263 } |
264 } |
264 |
265 |
276 mkdirname.Zero(); |
277 mkdirname.Zero(); |
277 mkdirname.Append(pritestfalseidname); |
278 mkdirname.Append(pritestfalseidname); |
278 mkdirname.Append(KMkDirSub); |
279 mkdirname.Append(KMkDirSub); |
279 |
280 |
280 r=TheFs.MkDirAll(mkdirname); |
281 r=TheFs.MkDirAll(mkdirname); |
281 test(r==KErrPermissionDenied); |
282 test_Value(r, r == KErrPermissionDenied); |
282 |
283 |
283 r=TheFs.RmDir(mkdirname); |
284 r=TheFs.RmDir(mkdirname); |
284 test(r==KErrPermissionDenied); |
285 test_Value(r, r == KErrPermissionDenied); |
285 |
286 |
286 r=TheFs.SetSubst(pritestfalseidname,EDriveO); |
287 r=TheFs.SetSubst(pritestfalseidname,EDriveO); |
287 test(r==KErrPermissionDenied); |
288 test_Value(r, r == KErrPermissionDenied); |
288 |
289 |
289 r=TheFs.RealName(_L("O:\\File.XXX"),realName); |
290 r=TheFs.RealName(_L("O:\\File.XXX"),realName); |
290 test(r==KErrNone); |
291 test_KErrNone(r); |
291 |
292 |
292 r=TheFs.SetSessionPath(pritestfalseidname); |
293 r=TheFs.SetSessionPath(pritestfalseidname); |
293 test(r==KErrPermissionDenied); |
294 test_Value(r, r == KErrPermissionDenied); |
294 |
295 |
295 TheFs.NotifyChange(ENotifyAll,aStat2,pritestfalseidname); |
296 TheFs.NotifyChange(ENotifyAll,aStat2,pritestfalseidname); |
296 test(r==KErrPermissionDenied); |
297 test_Value(r, r == KErrPermissionDenied); |
297 |
298 |
298 |
299 |
299 pritestfile=KPrivateFalseID; |
300 pritestfile=KPrivateFalseID; |
300 pritestfile[0]=(TText)('A' + gTheDriveNum); |
301 pritestfile[0]=(TText)('A' + gTheDriveNum); |
301 pritestfile1=pritestfile; |
302 pritestfile1=pritestfile; |
304 |
305 |
305 oldName=KOldFile; |
306 oldName=KOldFile; |
306 oldName[0]=(TText)gDriveToTest; |
307 oldName[0]=(TText)gDriveToTest; |
307 |
308 |
308 r=TheFs.GetShortName(pritestfile, shortfilename); |
309 r=TheFs.GetShortName(pritestfile, shortfilename); |
309 test(r==KErrPermissionDenied || r==KErrNotSupported); |
310 test_Value(r, r == KErrPermissionDenied || r==KErrNotSupported); |
310 |
311 |
311 r=TheFs.GetLongName(pritestfile1, longfilename); |
312 r=TheFs.GetLongName(pritestfile1, longfilename); |
312 test(r==KErrPermissionDenied || r==KErrNotSupported); |
313 test_Value(r, r == KErrPermissionDenied || r==KErrNotSupported); |
313 |
314 |
314 r=file1.Create(TheFs,oldName,EFileWrite); |
315 r=file1.Create(TheFs,oldName,EFileWrite); |
315 test(r==KErrNone || r==KErrAlreadyExists); |
316 test_Value(r, r == KErrNone || r==KErrAlreadyExists); |
316 file1.Close(); |
317 file1.Close(); |
317 |
318 |
318 r=TheFs.Replace(oldName,pritestfile); |
319 r=TheFs.Replace(oldName,pritestfile); |
319 test(r==KErrPermissionDenied); |
320 test_Value(r, r == KErrPermissionDenied); |
320 |
321 |
321 r=TheFs.Rename(pritestfile,pritestfile1); |
322 r=TheFs.Rename(pritestfile,pritestfile1); |
322 test(r==KErrPermissionDenied); |
323 test_Value(r, r == KErrPermissionDenied); |
323 |
324 |
324 r=TheFs.Entry(pritestfile1,entry); |
325 r=TheFs.Entry(pritestfile1,entry); |
325 test(r==KErrPermissionDenied); |
326 test_Value(r, r == KErrPermissionDenied); |
326 |
327 |
327 r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly); |
328 r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly); |
328 test(r==KErrPermissionDenied); |
329 test_Value(r, r == KErrPermissionDenied); |
329 |
330 |
330 r=TheFs.Delete(pritestfile1); |
331 r=TheFs.Delete(pritestfile1); |
331 test(r==KErrPermissionDenied); |
332 test_Value(r, r == KErrPermissionDenied); |
332 |
333 |
333 __UHEAP_MARKEND; |
334 __UHEAP_MARKEND; |
334 } |
335 } |
335 |
336 |
336 |
337 |
348 mkdirname.Zero(); |
349 mkdirname.Zero(); |
349 mkdirname.Append(pritestname); |
350 mkdirname.Append(pritestname); |
350 mkdirname.Append(KMkDirSub); |
351 mkdirname.Append(KMkDirSub); |
351 |
352 |
352 r=TheFs.MkDirAll(mkdirname); |
353 r=TheFs.MkDirAll(mkdirname); |
353 test(r==KErrPermissionDenied); |
354 test_Value(r, r == KErrPermissionDenied); |
354 |
355 |
355 r=TheFs.RmDir(mkdirname); |
356 r=TheFs.RmDir(mkdirname); |
356 test(r==KErrPermissionDenied); |
357 test_Value(r, r == KErrPermissionDenied); |
357 |
358 |
358 r=TheFs.SetSubst(pritestname,EDriveO); |
359 r=TheFs.SetSubst(pritestname,EDriveO); |
359 test(r==KErrPermissionDenied); |
360 test_Value(r, r == KErrPermissionDenied); |
360 |
361 |
361 r=TheFs.RealName(_L("O:\\File.XXX"),realName); |
362 r=TheFs.RealName(_L("O:\\File.XXX"),realName); |
362 test(r==KErrNone); |
363 test_KErrNone(r); |
363 |
364 |
364 r=TheFs.SetSessionPath(pritestname); |
365 r=TheFs.SetSessionPath(pritestname); |
365 test(r==KErrPermissionDenied); |
366 test_Value(r, r == KErrPermissionDenied); |
366 |
367 |
367 TheFs.NotifyChange(ENotifyAll,aStat2,pritestname); |
368 TheFs.NotifyChange(ENotifyAll,aStat2,pritestname); |
368 test(r==KErrPermissionDenied); |
369 test_Value(r, r == KErrPermissionDenied); |
369 |
370 |
370 |
371 |
371 pritestfile=KPrivatePath; |
372 pritestfile=KPrivatePath; |
372 pritestfile[0]=(TText)('A' + gTheDriveNum); |
373 pritestfile[0]=(TText)('A' + gTheDriveNum); |
373 pritestfile1=pritestfile; |
374 pritestfile1=pritestfile; |
376 |
377 |
377 oldName=KOldFile; |
378 oldName=KOldFile; |
378 oldName[0]=(TText)gDriveToTest; |
379 oldName[0]=(TText)gDriveToTest; |
379 |
380 |
380 r=TheFs.GetShortName(pritestfile, shortfilename); |
381 r=TheFs.GetShortName(pritestfile, shortfilename); |
381 test(r==KErrPermissionDenied || r==KErrNotSupported); |
382 test_Value(r, r == KErrPermissionDenied || r==KErrNotSupported); |
382 |
383 |
383 r=TheFs.GetLongName(pritestfile1, longfilename); |
384 r=TheFs.GetLongName(pritestfile1, longfilename); |
384 test(r==KErrPermissionDenied || r==KErrNotSupported); |
385 test_Value(r, r == KErrPermissionDenied || r==KErrNotSupported); |
385 |
386 |
386 r=file1.Create(TheFs,oldName,EFileWrite); |
387 r=file1.Create(TheFs,oldName,EFileWrite); |
387 test(r==KErrNone || r==KErrAlreadyExists); |
388 test_Value(r, r == KErrNone || r==KErrAlreadyExists); |
388 file1.Close(); |
389 file1.Close(); |
389 |
390 |
390 r=TheFs.Replace(oldName,pritestfile); |
391 r=TheFs.Replace(oldName,pritestfile); |
391 test(r==KErrPermissionDenied); |
392 test_Value(r, r == KErrPermissionDenied); |
392 |
393 |
393 r=TheFs.Rename(pritestfile,pritestfile1); |
394 r=TheFs.Rename(pritestfile,pritestfile1); |
394 test(r==KErrPermissionDenied); |
395 test_Value(r, r == KErrPermissionDenied); |
395 |
396 |
396 r=TheFs.Entry(pritestfile1,entry); |
397 r=TheFs.Entry(pritestfile1,entry); |
397 test(r==KErrPermissionDenied); |
398 test_Value(r, r == KErrPermissionDenied); |
398 |
399 |
399 r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly); |
400 r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly); |
400 test(r==KErrPermissionDenied); |
401 test_Value(r, r == KErrPermissionDenied); |
401 |
402 |
402 r=TheFs.Delete(pritestfile1); |
403 r=TheFs.Delete(pritestfile1); |
403 test(r==KErrPermissionDenied); |
404 test_Value(r, r == KErrPermissionDenied); |
404 |
405 |
405 __UHEAP_MARKEND; |
406 __UHEAP_MARKEND; |
406 } |
407 } |
407 |
408 |
408 |
409 |
415 |
416 |
416 mkdirname.Zero(); |
417 mkdirname.Zero(); |
417 mkdirname.Append(theprivatepath); |
418 mkdirname.Append(theprivatepath); |
418 mkdirname.Append(KMkDirSub); |
419 mkdirname.Append(KMkDirSub); |
419 r=TheFs.MkDirAll(mkdirname); |
420 r=TheFs.MkDirAll(mkdirname); |
420 test(r==KErrNone); |
421 test_KErrNone(r); |
421 |
422 |
422 r=TheFs.RmDir(mkdirname); |
423 r=TheFs.RmDir(mkdirname); |
423 test(r==KErrNone); |
424 test_KErrNone(r); |
424 |
425 |
425 r=TheFs.SetSubst(theprivatepath,EDriveO); |
426 r=TheFs.SetSubst(theprivatepath,EDriveO); |
426 test(r==KErrPermissionDenied || r==KErrGeneral); // Drive may already be substituted |
427 test_Value(r, r == KErrPermissionDenied || r==KErrGeneral); // Drive may already be substituted |
427 |
428 |
428 r=TheFs.RealName(_L("O:\\File.XXX"),realName); |
429 r=TheFs.RealName(_L("O:\\File.XXX"),realName); |
429 test(r==KErrNone); |
430 test_KErrNone(r); |
430 |
431 |
431 r=TheFs.SetSessionPath(theprivatepath); |
432 r=TheFs.SetSessionPath(theprivatepath); |
432 test(r==KErrNone); |
433 test_KErrNone(r); |
433 |
434 |
434 TheFs.NotifyChange(ENotifyAll,aStat3,theprivatepath); |
435 TheFs.NotifyChange(ENotifyAll,aStat3,theprivatepath); |
435 test(aStat3==KRequestPending); |
436 test(aStat3==KRequestPending); |
436 |
437 |
437 pritestfile=theprivatepath; |
438 pritestfile=theprivatepath; |
442 |
443 |
443 oldName=KOldFile; |
444 oldName=KOldFile; |
444 oldName[0]=(TText)gDriveToTest; |
445 oldName[0]=(TText)gDriveToTest; |
445 |
446 |
446 r=TheFs.GetShortName(pritestfile, shortfilename); |
447 r=TheFs.GetShortName(pritestfile, shortfilename); |
447 test(r==KErrNone || r==KErrNotFound || r==KErrNotSupported); |
448 test_Value(r, r == KErrNone || r==KErrNotFound || r==KErrNotSupported); |
448 |
449 |
449 r=TheFs.GetLongName(pritestfile1, longfilename); |
450 r=TheFs.GetLongName(pritestfile1, longfilename); |
450 test(r==KErrNone || r==KErrNotFound || r==KErrNotSupported); |
451 test_Value(r, r == KErrNone || r==KErrNotFound || r==KErrNotSupported); |
451 |
452 |
452 r=file1.Create(TheFs,oldName,EFileWrite); |
453 r=file1.Create(TheFs,oldName,EFileWrite); |
453 test(r==KErrNone || r==KErrAlreadyExists); |
454 test_Value(r, r == KErrNone || r==KErrAlreadyExists); |
454 file1.Close(); |
455 file1.Close(); |
455 |
456 |
456 r=TheFs.Replace(oldName,pritestfile); |
457 r=TheFs.Replace(oldName,pritestfile); |
457 test(r==KErrNone); |
458 test_KErrNone(r); |
458 |
459 |
459 r=TheFs.Rename(pritestfile,pritestfile1); |
460 r=TheFs.Rename(pritestfile,pritestfile1); |
460 test(r==KErrNone || r==KErrAlreadyExists); |
461 test_Value(r, r == KErrNone || r==KErrAlreadyExists); |
461 |
462 |
462 r=TheFs.Entry(pritestfile1,entry); |
463 r=TheFs.Entry(pritestfile1,entry); |
463 test(r==KErrNone); |
464 test_KErrNone(r); |
464 |
465 |
465 r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly); |
466 r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly); |
466 test(r==KErrNone); |
467 test_KErrNone(r); |
467 |
468 |
468 r=TheFs.Delete(pritestfile1); |
469 r=TheFs.Delete(pritestfile1); |
469 test(r==KErrNone); |
470 test_KErrNone(r); |
470 |
471 |
471 __UHEAP_MARKEND; |
472 __UHEAP_MARKEND; |
472 } |
473 } |
473 |
474 |
474 |
475 |
478 // |
479 // |
479 { |
480 { |
480 __UHEAP_MARK; |
481 __UHEAP_MARK; |
481 |
482 |
482 r=TheFs.SetSessionPath(systestname); |
483 r=TheFs.SetSessionPath(systestname); |
483 test(r==KErrPermissionDenied); |
484 test_Value(r, r == KErrPermissionDenied); |
484 |
485 |
485 r=file1.Temp(TheFs,systestname,fromTemp,EFileWrite); |
486 r=file1.Temp(TheFs,systestname,fromTemp,EFileWrite); |
486 test(r==KErrNone); |
487 test_KErrNone(r); |
487 file1.Close(); |
488 file1.Close(); |
488 |
489 |
489 TBuf<25> sysfilename; |
490 TBuf<25> sysfilename; |
490 sysfilename.Append(systestname); |
491 sysfilename.Append(systestname); |
491 sysfilename.Append(KFileSys); |
492 sysfilename.Append(KFileSys); |
492 |
493 |
493 r=file1.Create(TheFs,sysfilename,EFileWrite); |
494 r=file1.Create(TheFs,sysfilename,EFileWrite); |
494 test(r==KErrNone); |
495 test_KErrNone(r); |
495 file1.Close(); |
496 file1.Close(); |
496 |
497 |
497 r=file1.Open(TheFs,sysfilename,EFileWrite); |
498 r=file1.Open(TheFs,sysfilename,EFileWrite); |
498 test(r==KErrNone); |
499 test_KErrNone(r); |
499 file1.Close(); |
500 file1.Close(); |
500 |
501 |
501 r=file1.Open(TheFs,sysfilename,EFileRead); |
502 r=file1.Open(TheFs,sysfilename,EFileRead); |
502 test(r==KErrPermissionDenied); |
503 test_Value(r, r == KErrPermissionDenied); |
503 file1.Close(); |
504 file1.Close(); |
504 |
505 |
505 r=file1.Replace(TheFs,sysfilename,EFileWrite); |
506 r=file1.Replace(TheFs,sysfilename,EFileWrite); |
506 test(r==KErrNone); |
507 test_KErrNone(r); |
507 |
508 |
508 TBuf<25> sysfilename2; |
509 TBuf<25> sysfilename2; |
509 sysfilename2.Append(systestname); |
510 sysfilename2.Append(systestname); |
510 sysfilename2.Append(KFileSys3); |
511 sysfilename2.Append(KFileSys3); |
511 |
512 |
512 r=file1.Rename(sysfilename2); |
513 r=file1.Rename(sysfilename2); |
513 test(r==KErrNone); |
514 test_KErrNone(r); |
514 file1.Close(); |
515 file1.Close(); |
515 |
516 |
516 TFindFile finder(TheFs); |
517 TFindFile finder(TheFs); |
517 CDir* dir = NULL; |
518 CDir* dir = NULL; |
518 r=finder.FindWildByDir(KWildFile, KWildPath, dir); |
519 r=finder.FindWildByDir(KWildFile, KWildPath, dir); |
519 if (!(r==KErrPermissionDenied)) |
520 if (!(r==KErrPermissionDenied)) |
520 test.Printf(_L("T_DCTCB: test find wildcards r = %d (expected KErrPermissionDenied)\n"), r); |
521 test.Printf(_L("T_DCTCB: test find wildcards r = %d (expected KErrPermissionDenied)\n"), r); |
521 test(r==KErrPermissionDenied); |
522 test_Value(r, r == KErrPermissionDenied); |
522 delete dir; |
523 delete dir; |
523 |
524 |
524 __UHEAP_MARKEND; |
525 __UHEAP_MARKEND; |
525 } |
526 } |
526 |
527 |
530 // |
531 // |
531 { |
532 { |
532 __UHEAP_MARK; |
533 __UHEAP_MARK; |
533 |
534 |
534 r=TheFs.SetSessionPath(restestname); |
535 r=TheFs.SetSessionPath(restestname); |
535 test(r==KErrNone); |
536 test_KErrNone(r); |
536 |
537 |
537 r=file1.Temp(TheFs,restestname,fromTemp,EFileWrite); |
538 r=file1.Temp(TheFs,restestname,fromTemp,EFileWrite); |
538 test(r==KErrNone); |
539 test_KErrNone(r); |
539 file1.Close(); |
540 file1.Close(); |
540 |
541 |
541 r=file1.Create(TheFs,KFileRes,EFileWrite); |
542 r=file1.Create(TheFs,KFileRes,EFileWrite); |
542 test(r==KErrNone); |
543 test_KErrNone(r); |
543 file1.Close(); |
544 file1.Close(); |
544 |
545 |
545 r=file1.Open(TheFs,KFileRes,EFileWrite|EFileShareExclusive ); |
546 r=file1.Open(TheFs,KFileRes,EFileWrite|EFileShareExclusive ); |
546 test(r==KErrNone); |
547 test_KErrNone(r); |
547 |
548 |
548 r=file1.Rename(KFileRes3); |
549 r=file1.Rename(KFileRes3); |
549 test(r==KErrNone); |
550 test_KErrNone(r); |
550 file1.Close(); |
551 file1.Close(); |
551 |
552 |
552 r=file1.Open(TheFs,KFileRes3,EFileShareReadersOrWriters|EFileRead); |
553 r=file1.Open(TheFs,KFileRes3,EFileShareReadersOrWriters|EFileRead); |
553 test(r==KErrNone); |
554 test_KErrNone(r); |
554 file1.Close(); |
555 file1.Close(); |
555 |
556 |
556 r=file1.Open(TheFs,KFileRes3,EFileShareReadersOrWriters|EFileWrite); |
557 r=file1.Open(TheFs,KFileRes3,EFileShareReadersOrWriters|EFileWrite); |
557 test(r==KErrNone); |
558 test_KErrNone(r); |
558 file1.Close(); |
559 file1.Close(); |
559 |
560 |
560 r=file1.Open(TheFs,KFileRes3,EFileShareReadersOnly); |
561 r=file1.Open(TheFs,KFileRes3,EFileShareReadersOnly); |
561 test(r==KErrNone); |
562 test_KErrNone(r); |
562 |
563 |
563 r=file1.ChangeMode(EFileShareExclusive); |
564 r=file1.ChangeMode(EFileShareExclusive); |
564 test(r==KErrNone); |
565 test_KErrNone(r); |
565 file1.Close(); |
566 file1.Close(); |
566 |
567 |
567 r=file1.Replace(TheFs,KFileRes,EFileWrite); |
568 r=file1.Replace(TheFs,KFileRes,EFileWrite); |
568 test(r==KErrNone); |
569 test_KErrNone(r); |
569 file1.Close(); |
570 file1.Close(); |
570 |
571 |
571 __UHEAP_MARKEND; |
572 __UHEAP_MARKEND; |
572 |
573 |
573 } |
574 } |
579 // |
580 // |
580 { |
581 { |
581 __UHEAP_MARK; |
582 __UHEAP_MARK; |
582 |
583 |
583 r=TheFs.SetSessionPath(pritestfalseidname); |
584 r=TheFs.SetSessionPath(pritestfalseidname); |
584 test(r==KErrPermissionDenied); |
585 test_Value(r, r == KErrPermissionDenied); |
585 |
586 |
586 r=file1.Temp(TheFs,pritestfalseidname,fromTemp,EFileWrite); |
587 r=file1.Temp(TheFs,pritestfalseidname,fromTemp,EFileWrite); |
587 test(r==KErrPermissionDenied); |
588 test_Value(r, r == KErrPermissionDenied); |
588 file1.Close(); |
589 file1.Close(); |
589 |
590 |
590 // Since can't set session path create explicit path |
591 // Since can't set session path create explicit path |
591 pritestfile=KPrivateFalseID; |
592 pritestfile=KPrivateFalseID; |
592 pritestfile[0]=(TText)('A' + gTheDriveNum); |
593 pritestfile[0]=(TText)('A' + gTheDriveNum); |
593 pritestfile.Append(KFilePri); |
594 pritestfile.Append(KFilePri); |
594 |
595 |
595 r=file1.Create(TheFs,pritestfile,EFileWrite); |
596 r=file1.Create(TheFs,pritestfile,EFileWrite); |
596 test(r==KErrPermissionDenied); |
597 test_Value(r, r == KErrPermissionDenied); |
597 file1.Close(); |
598 file1.Close(); |
598 |
599 |
599 r=file1.Open(TheFs,pritestfile,EFileWrite); |
600 r=file1.Open(TheFs,pritestfile,EFileWrite); |
600 test(r==KErrPermissionDenied); |
601 test_Value(r, r == KErrPermissionDenied); |
601 file1.Close(); |
602 file1.Close(); |
602 |
603 |
603 r=file1.Open(TheFs,pritestfile,EFileRead); |
604 r=file1.Open(TheFs,pritestfile,EFileRead); |
604 test(r==KErrPermissionDenied); |
605 test_Value(r, r == KErrPermissionDenied); |
605 file1.Close(); |
606 file1.Close(); |
606 |
607 |
607 r=file1.Replace(TheFs,pritestfile,EFileWrite); |
608 r=file1.Replace(TheFs,pritestfile,EFileWrite); |
608 test(r==KErrPermissionDenied); |
609 test_Value(r, r == KErrPermissionDenied); |
609 |
610 |
610 // File does not exist so can't rename it |
611 // File does not exist so can't rename it |
611 /* r=file1.Rename(KFilePri3); |
612 /* r=file1.Rename(KFilePri3); |
612 test(r==KErrAlreadyExists || r==KErrNone); |
613 test_Value(r, r == KErrAlreadyExists || r==KErrNone); |
613 file1.Close(); |
614 file1.Close(); |
614 */ __UHEAP_MARKEND; |
615 */ __UHEAP_MARKEND; |
615 } |
616 } |
616 |
617 |
617 |
618 |
621 // |
622 // |
622 { |
623 { |
623 __UHEAP_MARK; |
624 __UHEAP_MARK; |
624 |
625 |
625 r=TheFs.SetSessionPath(pritestname); |
626 r=TheFs.SetSessionPath(pritestname); |
626 test(r==KErrPermissionDenied); |
627 test_Value(r, r == KErrPermissionDenied); |
627 |
628 |
628 r=file1.Temp(TheFs,pritestname,fromTemp,EFileWrite); |
629 r=file1.Temp(TheFs,pritestname,fromTemp,EFileWrite); |
629 test(r==KErrPermissionDenied); |
630 test_Value(r, r == KErrPermissionDenied); |
630 file1.Close(); |
631 file1.Close(); |
631 |
632 |
632 // Since can't set session path create explicit path |
633 // Since can't set session path create explicit path |
633 pritestfile=KPrivatePath; |
634 pritestfile=KPrivatePath; |
634 pritestfile[0]=(TText)('A' + gTheDriveNum); |
635 pritestfile[0]=(TText)('A' + gTheDriveNum); |
635 pritestfile.Append(KFilePri); |
636 pritestfile.Append(KFilePri); |
636 |
637 |
637 r=file1.Create(TheFs,pritestfile,EFileWrite); |
638 r=file1.Create(TheFs,pritestfile,EFileWrite); |
638 test(r==KErrPermissionDenied); |
639 test_Value(r, r == KErrPermissionDenied); |
639 file1.Close(); |
640 file1.Close(); |
640 |
641 |
641 r=file1.Open(TheFs,pritestfile,EFileWrite); |
642 r=file1.Open(TheFs,pritestfile,EFileWrite); |
642 test(r==KErrPermissionDenied); |
643 test_Value(r, r == KErrPermissionDenied); |
643 file1.Close(); |
644 file1.Close(); |
644 |
645 |
645 r=file1.Open(TheFs,pritestfile,EFileRead); |
646 r=file1.Open(TheFs,pritestfile,EFileRead); |
646 test(r==KErrPermissionDenied); |
647 test_Value(r, r == KErrPermissionDenied); |
647 file1.Close(); |
648 file1.Close(); |
648 |
649 |
649 r=file1.Replace(TheFs,pritestfile,EFileWrite); |
650 r=file1.Replace(TheFs,pritestfile,EFileWrite); |
650 test(r==KErrPermissionDenied); |
651 test_Value(r, r == KErrPermissionDenied); |
651 |
652 |
652 // File does not exist so can't be renamed |
653 // File does not exist so can't be renamed |
653 /* r=file1.Rename(KFilePri3); |
654 /* r=file1.Rename(KFilePri3); |
654 test(r==KErrNone); |
655 test_KErrNone(r); |
655 file1.Close(); |
656 file1.Close(); |
656 */ |
657 */ |
657 __UHEAP_MARKEND; |
658 __UHEAP_MARKEND; |
658 } |
659 } |
659 |
660 |
663 //Rfile Testing with session path set to //Private//UID// |
664 //Rfile Testing with session path set to //Private//UID// |
664 // |
665 // |
665 { |
666 { |
666 __UHEAP_MARK; |
667 __UHEAP_MARK; |
667 r=TheFs.SetSessionToPrivate(gTheDriveNum); |
668 r=TheFs.SetSessionToPrivate(gTheDriveNum); |
668 test(r==KErrNone); |
669 test_KErrNone(r); |
669 |
670 |
670 r=file1.Temp(TheFs,theprivatepath,fromTemp,EFileWrite); |
671 r=file1.Temp(TheFs,theprivatepath,fromTemp,EFileWrite); |
671 test(r==KErrNone); |
672 test_KErrNone(r); |
672 file1.Close(); |
673 file1.Close(); |
673 |
674 |
674 r=file1.Create(TheFs,KFilePri,EFileWrite); |
675 r=file1.Create(TheFs,KFilePri,EFileWrite); |
675 test(r==KErrNone); |
676 test_KErrNone(r); |
676 file1.Close(); |
677 file1.Close(); |
677 |
678 |
678 r=file1.Open(TheFs,KFilePri,EFileWrite); |
679 r=file1.Open(TheFs,KFilePri,EFileWrite); |
679 test(r==KErrNone); |
680 test_KErrNone(r); |
680 file1.Close(); |
681 file1.Close(); |
681 |
682 |
682 r=file1.Open(TheFs,KFilePri,EFileRead); |
683 r=file1.Open(TheFs,KFilePri,EFileRead); |
683 test(r==KErrNone); |
684 test_KErrNone(r); |
684 file1.Close(); |
685 file1.Close(); |
685 |
686 |
686 r=file1.Replace(TheFs,KFilePri,EFileWrite); |
687 r=file1.Replace(TheFs,KFilePri,EFileWrite); |
687 test(r==KErrNone); |
688 test_KErrNone(r); |
688 |
689 |
689 r=file1.Rename(KFilePri3); |
690 r=file1.Rename(KFilePri3); |
690 test(r==KErrNone); |
691 test_KErrNone(r); |
691 file1.Close(); |
692 file1.Close(); |
692 __UHEAP_MARKEND; |
693 __UHEAP_MARKEND; |
693 } |
694 } |
694 |
695 |
695 LOCAL_C void RDirtest() |
696 LOCAL_C void RDirtest() |
702 //system |
703 //system |
703 CDir* dirEntries; |
704 CDir* dirEntries; |
704 TBuf<30> dirNameBuf(KSystemPath); |
705 TBuf<30> dirNameBuf(KSystemPath); |
705 dirNameBuf[0]=(TText)gDriveToTest; |
706 dirNameBuf[0]=(TText)gDriveToTest; |
706 r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal); |
707 r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal); |
707 test(r==KErrPermissionDenied); |
708 test_Value(r, r == KErrPermissionDenied); |
708 dir.Close(); |
709 dir.Close(); |
709 r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries); |
710 r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries); |
710 test(r==KErrPermissionDenied); |
711 test_Value(r, r == KErrPermissionDenied); |
711 dirNameBuf.Zero(); |
712 dirNameBuf.Zero(); |
712 delete dirEntries; |
713 delete dirEntries; |
713 |
714 |
714 //Private |
715 //Private |
715 dirNameBuf=KPrivatePath; |
716 dirNameBuf=KPrivatePath; |
716 dirNameBuf[0]=(TText)gDriveToTest; |
717 dirNameBuf[0]=(TText)gDriveToTest; |
717 r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal); |
718 r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal); |
718 test(r==KErrPermissionDenied); |
719 test_Value(r, r == KErrPermissionDenied); |
719 dir.Close(); |
720 dir.Close(); |
720 r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries); |
721 r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries); |
721 test(r==KErrPermissionDenied); |
722 test_Value(r, r == KErrPermissionDenied); |
722 dirNameBuf.Zero(); |
723 dirNameBuf.Zero(); |
723 delete dirEntries; |
724 delete dirEntries; |
724 |
725 |
725 //Private//falseID |
726 //Private//falseID |
726 dirNameBuf=KPrivateFalseID; |
727 dirNameBuf=KPrivateFalseID; |
727 dirNameBuf[0]=(TText)gDriveToTest; |
728 dirNameBuf[0]=(TText)gDriveToTest; |
728 r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal); |
729 r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal); |
729 test(r==KErrPermissionDenied); |
730 test_Value(r, r == KErrPermissionDenied); |
730 dir.Close(); |
731 dir.Close(); |
731 r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries); |
732 r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries); |
732 test(r==KErrPermissionDenied); |
733 test_Value(r, r == KErrPermissionDenied); |
733 dirNameBuf.Zero(); |
734 dirNameBuf.Zero(); |
734 delete dirEntries; |
735 delete dirEntries; |
735 |
736 |
736 //Private/uid |
737 //Private/uid |
737 TheFs.PrivatePath(dirNameBuf); |
738 TheFs.PrivatePath(dirNameBuf); |
738 dirNameBuf.Insert(0,_L("?:")); |
739 dirNameBuf.Insert(0,_L("?:")); |
739 dirNameBuf[0]=(TText)gDriveToTest; |
740 dirNameBuf[0]=(TText)gDriveToTest; |
740 r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal); |
741 r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal); |
741 test(r==KErrNone); |
742 test_KErrNone(r); |
742 dir.Close(); |
743 dir.Close(); |
743 r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries); |
744 r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries); |
744 test(r==KErrNone); |
745 test_KErrNone(r); |
745 dirNameBuf.Zero(); |
746 dirNameBuf.Zero(); |
746 delete dirEntries; |
747 delete dirEntries; |
747 //Resource |
748 //Resource |
748 dirNameBuf=KResourcePath; |
749 dirNameBuf=KResourcePath; |
749 dirNameBuf[0]=(TText)gDriveToTest; |
750 dirNameBuf[0]=(TText)gDriveToTest; |
750 r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal); |
751 r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal); |
751 test(r==KErrNone); |
752 test_KErrNone(r); |
752 r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries); |
753 r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries); |
753 test(r==KErrNone); |
754 test_KErrNone(r); |
754 dir.Close(); |
755 dir.Close(); |
755 delete dirEntries; |
756 delete dirEntries; |
756 __UHEAP_MARKEND; |
757 __UHEAP_MARKEND; |
757 } |
758 } |
758 |
759 |
762 // Test with tcb capabilities |
763 // Test with tcb capabilities |
763 // |
764 // |
764 { |
765 { |
765 __UHEAP_MARK; |
766 __UHEAP_MARK; |
766 r=TheFs.FileSystemName(fsname,gTheDriveNum); |
767 r=TheFs.FileSystemName(fsname,gTheDriveNum); |
767 test(r==KErrNone); |
768 test_KErrNone(r); |
768 r = DismountFileSystem(TheFs, fsname, gTheDriveNum); |
769 r = DismountFileSystem(TheFs, fsname, gTheDriveNum); |
769 test(r==KErrPermissionDenied); |
770 test_Value(r, r == KErrPermissionDenied); |
770 r = MountFileSystem(TheFs, fsname, gTheDriveNum); |
771 r = MountFileSystem(TheFs, fsname, gTheDriveNum); |
771 test(r==KErrPermissionDenied); |
772 test_Value(r, r == KErrPermissionDenied); |
772 r=TheFs.SetDriveName(gTheDriveNum,KDriveName); |
773 r=TheFs.SetDriveName(gTheDriveNum,KDriveName); |
773 test(r==KErrPermissionDenied); |
774 test_Value(r, r == KErrPermissionDenied); |
774 #ifndef __WINS__ |
775 #ifndef __WINS__ |
775 r=TheFs.SetVolumeLabel(KVolLable, gTheDriveNum); |
776 r=TheFs.SetVolumeLabel(KVolLable, gTheDriveNum); |
776 test(r==KErrPermissionDenied); |
777 test_Value(r, r == KErrPermissionDenied); |
777 #endif |
778 #endif |
778 |
779 |
779 systemRFsTest(); |
780 systemRFsTest(); |
780 ResourceRFsTest(); |
781 ResourceRFsTest(); |
781 privateRFsTest(); |
782 privateRFsTest(); |
798 test(aStat2==KErrPermissionDenied); |
799 test(aStat2==KErrPermissionDenied); |
799 test(aStat3==KErrNone); |
800 test(aStat3==KErrNone); |
800 test(aStat4==KErrNone); |
801 test(aStat4==KErrNone); |
801 |
802 |
802 r=TheFs.SetSessionPath(systestname); |
803 r=TheFs.SetSessionPath(systestname); |
803 test(r==KErrPermissionDenied); |
804 test_Value(r, r == KErrPermissionDenied); |
804 |
805 |
805 //Test RRawDisk class |
806 //Test RRawDisk class |
806 r=rawdisk.Open(TheFs,gTheDriveNum); |
807 r=rawdisk.Open(TheFs,gTheDriveNum); |
807 test(r==KErrNone); |
808 test_KErrNone(r); |
808 rawdisk.Close(); |
809 rawdisk.Close(); |
809 |
810 |
810 RDirtest(); |
811 RDirtest(); |
811 |
812 |
812 #ifdef __WINS__ |
813 #ifdef __WINS__ |
813 if (User::UpperCase(driveBuf[0]) != 'C') |
814 if (User::UpperCase(driveBuf[0]) != 'C') |
814 #endif |
815 #endif |
815 { |
816 { |
816 //Test RFormat class |
817 //Test RFormat class |
817 r=format.Open(TheFs,driveBuf,EHighDensity,count); |
818 r=format.Open(TheFs,driveBuf,EHighDensity,count); |
818 test(r==KErrPermissionDenied); |
819 test_Value(r, r == KErrPermissionDenied); |
819 |
820 |
820 while(count) |
821 while(count) |
821 { |
822 { |
822 TInt r=format.Next(count); |
823 TInt r=format.Next(count); |
823 test(r==KErrNone); |
824 test_KErrNone(r); |
824 } |
825 } |
825 format.Close(); |
826 format.Close(); |
826 } |
827 } |
827 |
828 |
828 driveBuf[0]=(TText)gDriveToTest; |
829 driveBuf[0]=(TText)gDriveToTest; |
829 r=TheFs.ScanDrive(driveBuf); |
830 r=TheFs.ScanDrive(driveBuf); |
830 test((r==KErrPermissionDenied)||(r==KErrNotSupported)); |
831 test_Value(r, (r == KErrPermissionDenied)||(r==KErrNotSupported)); |
831 r=TheFs.CheckDisk(driveBuf); |
832 r=TheFs.CheckDisk(driveBuf); |
832 test((r==KErrPermissionDenied)||(r==KErrNotSupported)); |
833 test_Value(r, (r == KErrPermissionDenied)||(r==KErrNotSupported)); |
833 __UHEAP_MARKEND; |
834 __UHEAP_MARKEND; |
834 } |
835 } |
835 |
836 |
836 LOCAL_C void TestCaps() |
837 LOCAL_C void TestCaps() |
837 // |
838 // |
845 r=RProcess().HasCapability(ECapabilityTCB, __PLATSEC_DIAGNOSTIC_STRING(myDiagMsg)); |
846 r=RProcess().HasCapability(ECapabilityTCB, __PLATSEC_DIAGNOSTIC_STRING(myDiagMsg)); |
846 test(r); |
847 test(r); |
847 |
848 |
848 driveBuf[0]=(TText)gDriveToTest; |
849 driveBuf[0]=(TText)gDriveToTest; |
849 r=TheFs.SessionPath(temp); |
850 r=TheFs.SessionPath(temp); |
850 test(r==KErrNone); |
851 test_KErrNone(r); |
851 test.Printf(_L("Session path: %S"),&temp); |
852 test.Printf(_L("Session path: %S"),&temp); |
852 r=TheFs.CreatePrivatePath(gTheDriveNum); |
853 r=TheFs.CreatePrivatePath(gTheDriveNum); |
853 test(r==KErrNone || r== KErrAlreadyExists); |
854 test_Value(r, r == KErrNone || r== KErrAlreadyExists); |
854 |
855 |
855 TBuf<18> tempPri; |
856 TBuf<18> tempPri; |
856 r=TheFs.PrivatePath(tempPri); |
857 r=TheFs.PrivatePath(tempPri); |
857 test(r==KErrNone); |
858 test_KErrNone(r); |
858 theprivatepath = _L("?:"); |
859 theprivatepath = _L("?:"); |
859 theprivatepath.Append(tempPri); |
860 theprivatepath.Append(tempPri); |
860 |
861 |
861 TestTcbCaps(); |
862 TestTcbCaps(); |
862 |
863 |
863 TFileName thesessionpath; |
864 TFileName thesessionpath; |
864 r=TheFs.SetSessionToPrivate(gTheDriveNum); |
865 r=TheFs.SetSessionToPrivate(gTheDriveNum); |
865 test(r==KErrNone); |
866 test_KErrNone(r); |
866 r=TheFs.SessionPath(thesessionpath); |
867 r=TheFs.SessionPath(thesessionpath); |
867 test(r==KErrNone); |
868 test_KErrNone(r); |
868 test(thesessionpath == theprivatepath); |
869 test(thesessionpath == theprivatepath); |
869 __UHEAP_MARKEND; |
870 __UHEAP_MARKEND; |
870 } |
871 } |
871 |
872 |
872 |
873 |
874 |
875 |
875 LOCAL_C void ScanDir(const TDesC& aName, CDirScan::TScanDirection aDirection, TInt aError) |
876 LOCAL_C void ScanDir(const TDesC& aName, CDirScan::TScanDirection aDirection, TInt aError) |
876 { |
877 { |
877 CDirScan* scanner = NULL; |
878 CDirScan* scanner = NULL; |
878 TRAP(r, scanner = CDirScan::NewL(TheFs)); |
879 TRAP(r, scanner = CDirScan::NewL(TheFs)); |
879 test(r == KErrNone && scanner); |
880 test_Value(r, r == KErrNone && scanner); |
880 |
881 |
881 TRAP(r, scanner->SetScanDataL(aName,KEntryAttDir,ESortByName|EAscending,aDirection)); |
882 TRAP(r, scanner->SetScanDataL(aName,KEntryAttDir,ESortByName|EAscending,aDirection)); |
882 test(r == KErrNone); |
883 test_KErrNone(r); |
883 |
884 |
884 CDir *entryList=NULL; |
885 CDir *entryList=NULL; |
885 for (;;) |
886 for (;;) |
886 { |
887 { |
887 TRAP(r, scanner->NextL(entryList)); |
888 TRAP(r, scanner->NextL(entryList)); |
888 test(r == aError); |
889 test_Value(r, r == aError); |
889 if (entryList==NULL) |
890 if (entryList==NULL) |
890 break; |
891 break; |
891 TInt count=entryList->Count(); |
892 TInt count=entryList->Count(); |
892 while (count--) |
893 while (count--) |
893 { |
894 { |
922 TBuf<30> privatepath; |
923 TBuf<30> privatepath; |
923 r=TheFs.PrivatePath(privatepath); |
924 r=TheFs.PrivatePath(privatepath); |
924 test.Printf(_L("Private Path is=%S"),&privatepath); |
925 test.Printf(_L("Private Path is=%S"),&privatepath); |
925 |
926 |
926 r = TheFs.MkDir(_L("\\Caged\\")); |
927 r = TheFs.MkDir(_L("\\Caged\\")); |
927 test(r==KErrNone || r==KErrAlreadyExists); |
928 test_Value(r, r == KErrNone || r==KErrAlreadyExists); |
928 |
929 |
929 CDir* entryCount=NULL; |
930 CDir* entryCount=NULL; |
930 r=TheFs.GetDir(_L("\\*.*"),KEntryAttNormal,ESortNone,entryCount); |
931 r=TheFs.GetDir(_L("\\*.*"),KEntryAttNormal,ESortNone,entryCount); |
931 test(r==KErrNone); |
932 test_KErrNone(r); |
932 TInt rootCount= entryCount->Count(); |
933 TInt rootCount= entryCount->Count(); |
933 |
934 |
934 delete entryCount; |
935 delete entryCount; |
935 entryCount=NULL; |
936 entryCount=NULL; |
936 |
937 |
937 |
938 |
938 //Testing Copy |
939 //Testing Copy |
939 CDir* entryCount2=NULL; |
940 CDir* entryCount2=NULL; |
940 r=fMan->Copy(_L("\\sys\\"),_L("\\Caged\\")); |
941 r=fMan->Copy(_L("\\sys\\"),_L("\\Caged\\")); |
941 test(r == KErrPermissionDenied); |
942 test_Value(r, r == KErrPermissionDenied); |
942 r=fMan->Copy(_L("\\*"),_L("\\Caged\\")); |
943 r=fMan->Copy(_L("\\*"),_L("\\Caged\\")); |
943 test(r == KErrNone); |
944 test_KErrNone(r); |
944 |
945 |
945 r=TheFs.GetDir(_L("\\Caged\\*.*"),KEntryAttNormal,ESortNone,entryCount2); |
946 r=TheFs.GetDir(_L("\\Caged\\*.*"),KEntryAttNormal,ESortNone,entryCount2); |
946 test(r==KErrNone); |
947 test_KErrNone(r); |
947 TInt cagedCount= entryCount2->Count(); |
948 TInt cagedCount= entryCount2->Count(); |
948 |
949 |
949 test(cagedCount==rootCount); |
950 test(cagedCount==rootCount); |
950 |
951 |
951 delete entryCount2; |
952 delete entryCount2; |
952 entryCount2=NULL; |
953 entryCount2=NULL; |
953 |
954 |
954 r=fMan->Copy(_L("\\private\\two\\moo"),_L("\\private\\two\\mew")); |
955 r=fMan->Copy(_L("\\private\\two\\moo"),_L("\\private\\two\\mew")); |
955 test(r == KErrPermissionDenied); |
956 test_Value(r, r == KErrPermissionDenied); |
956 |
957 |
957 // Create a test file |
958 // Create a test file |
958 RFile testFile; |
959 RFile testFile; |
959 r = testFile.Replace(TheFs, _L("\\capTest"),EFileWrite); |
960 r = testFile.Replace(TheFs, _L("\\capTest"),EFileWrite); |
960 test(r==KErrNone || r==KErrAlreadyExists); |
961 test_Value(r, r == KErrNone || r==KErrAlreadyExists); |
961 testFile.Close(); |
962 testFile.Close(); |
962 |
963 |
963 TFileName name; |
964 TFileName name; |
964 name = privatepath; |
965 name = privatepath; |
965 name.Append(_L("privateFile.tst")); |
966 name.Append(_L("privateFile.tst")); |
966 RFile privateFile; |
967 RFile privateFile; |
967 r = privateFile.Replace(TheFs, name,EFileWrite); |
968 r = privateFile.Replace(TheFs, name,EFileWrite); |
968 test(r==KErrNone || r==KErrAlreadyExists); |
969 test_Value(r, r == KErrNone || r==KErrAlreadyExists); |
969 privateFile.Close(); |
970 privateFile.Close(); |
970 |
971 |
971 |
972 |
972 r=fMan->Copy(_L("\\capTest"),_L("\\private\\two\\moo")); |
973 r=fMan->Copy(_L("\\capTest"),_L("\\private\\two\\moo")); |
973 test(r == KErrPermissionDenied); |
974 test_Value(r, r == KErrPermissionDenied); |
974 r=fMan->Copy(_L("\\capTest"),_L("\\sys\\bin\\moo")); |
975 r=fMan->Copy(_L("\\capTest"),_L("\\sys\\bin\\moo")); |
975 test(r == KErrPathNotFound); |
976 test_Value(r, r == KErrPathNotFound); |
976 r=fMan->Copy(_L("\\sys\\bin\\capTest"),_L("\\sys\\bin\\moo")); |
977 r=fMan->Copy(_L("\\sys\\bin\\capTest"),_L("\\sys\\bin\\moo")); |
977 test(r == KErrPermissionDenied); |
978 test_Value(r, r == KErrPermissionDenied); |
978 r=fMan->Copy(_L("\\capTest"),_L("\\sys\\capTest")); |
979 r=fMan->Copy(_L("\\capTest"),_L("\\sys\\capTest")); |
979 test(r == KErrNone || r==KErrAlreadyExists); |
980 test_Value(r, r == KErrNone || r==KErrAlreadyExists); |
980 r=fMan->Copy(_L("\\sys\\*"),_L("\\")); |
981 r=fMan->Copy(_L("\\sys\\*"),_L("\\")); |
981 test (r==KErrPermissionDenied); |
982 test_Value(r, r == KErrPermissionDenied); |
982 r=fMan->Copy(name,_L("\\sys\\")); |
983 r=fMan->Copy(name,_L("\\sys\\")); |
983 test(r==KErrNone); |
984 test_KErrNone(r); |
984 |
985 |
985 // Testing Move |
986 // Testing Move |
986 r=fMan->Move(_L("\\private\\two\\moo"),_L("\\private\\one\\moo")); |
987 r=fMan->Move(_L("\\private\\two\\moo"),_L("\\private\\one\\moo")); |
987 test(r == KErrPermissionDenied); |
988 test_Value(r, r == KErrPermissionDenied); |
988 r=fMan->Move(_L("\\private\\two\\moo.."),_L("\\private\\one\\moo")); |
989 r=fMan->Move(_L("\\private\\two\\moo.."),_L("\\private\\one\\moo")); |
989 test(r == KErrPermissionDenied); |
990 test_Value(r, r == KErrPermissionDenied); |
990 r=fMan->Move(_L("\\private\\two\\moo"),_L("\\private\\one\\moo..")); |
991 r=fMan->Move(_L("\\private\\two\\moo"),_L("\\private\\one\\moo..")); |
991 test(r == KErrPermissionDenied); |
992 test_Value(r, r == KErrPermissionDenied); |
992 r=fMan->Move(name,_L("\\privateFile.tst")); |
993 r=fMan->Move(name,_L("\\privateFile.tst")); |
993 test(r == KErrNone); |
994 test_KErrNone(r); |
994 r=fMan->Move(_L("\\privateFile.tst"),name); |
995 r=fMan->Move(_L("\\privateFile.tst"),name); |
995 test(r == KErrNone); |
996 test_KErrNone(r); |
996 |
997 |
997 |
998 |
998 // Testing Attribs |
999 // Testing Attribs |
999 r=fMan->Attribs(_L("\\private\\two\\moo"),KEntryAttReadOnly,0,TTime(0)); |
1000 r=fMan->Attribs(_L("\\private\\two\\moo"),KEntryAttReadOnly,0,TTime(0)); |
1000 test(r == KErrPermissionDenied); |
1001 test_Value(r, r == KErrPermissionDenied); |
1001 r=fMan->Attribs(_L("\\private\\moo"),KEntryAttReadOnly,0,TTime(0)); |
1002 r=fMan->Attribs(_L("\\private\\moo"),KEntryAttReadOnly,0,TTime(0)); |
1002 test(r == KErrPermissionDenied); |
1003 test_Value(r, r == KErrPermissionDenied); |
1003 r=fMan->Attribs(name,KEntryAttReadOnly,0,TTime(0)); |
1004 r=fMan->Attribs(name,KEntryAttReadOnly,0,TTime(0)); |
1004 test(r == KErrNone); |
1005 test_KErrNone(r); |
1005 r=fMan->Attribs(name,0,KEntryAttReadOnly,TTime(0)); |
1006 r=fMan->Attribs(name,0,KEntryAttReadOnly,TTime(0)); |
1006 test(r == KErrNone); |
1007 test_KErrNone(r); |
1007 |
1008 |
1008 // Testing Move |
1009 // Testing Move |
1009 r=fMan->Move(_L("\\private\\two\\moo"),_L("\\private\\one\\moo")); |
1010 r=fMan->Move(_L("\\private\\two\\moo"),_L("\\private\\one\\moo")); |
1010 test(r == KErrPermissionDenied); |
1011 test_Value(r, r == KErrPermissionDenied); |
1011 r=fMan->Move(_L("\\private\\two\\moo.."),_L("\\private\\one\\moo")); |
1012 r=fMan->Move(_L("\\private\\two\\moo.."),_L("\\private\\one\\moo")); |
1012 test(r == KErrPermissionDenied); |
1013 test_Value(r, r == KErrPermissionDenied); |
1013 r=fMan->Move(_L("\\private\\two\\moo"),_L("\\private\\one\\moo..")); |
1014 r=fMan->Move(_L("\\private\\two\\moo"),_L("\\private\\one\\moo..")); |
1014 test(r == KErrPermissionDenied); |
1015 test_Value(r, r == KErrPermissionDenied); |
1015 r=fMan->Move(name,_L("\\privateFile.tst")); |
1016 r=fMan->Move(name,_L("\\privateFile.tst")); |
1016 test(r == KErrNone); |
1017 test_KErrNone(r); |
1017 r=fMan->Move(_L("\\privateFile.tst"),name); |
1018 r=fMan->Move(_L("\\privateFile.tst"),name); |
1018 test(r == KErrNone); |
1019 test_KErrNone(r); |
1019 |
1020 |
1020 |
1021 |
1021 // Testing RmDir |
1022 // Testing RmDir |
1022 r=fMan->RmDir(_L("\\private\\")); |
1023 r=fMan->RmDir(_L("\\private\\")); |
1023 test(r == KErrPermissionDenied); |
1024 test_Value(r, r == KErrPermissionDenied); |
1024 r=fMan->RmDir(_L("\\private\\two\\")); |
1025 r=fMan->RmDir(_L("\\private\\two\\")); |
1025 test(r == KErrPermissionDenied); |
1026 test_Value(r, r == KErrPermissionDenied); |
1026 r=fMan->RmDir(_L("\\private\\tw?\\")); |
1027 r=fMan->RmDir(_L("\\private\\tw?\\")); |
1027 test(r == KErrPermissionDenied); |
1028 test_Value(r, r == KErrPermissionDenied); |
1028 r=fMan->RmDir(_L("\\sys\\")); |
1029 r=fMan->RmDir(_L("\\sys\\")); |
1029 test(r == KErrPermissionDenied); |
1030 test_Value(r, r == KErrPermissionDenied); |
1030 |
1031 |
1031 |
1032 |
1032 // Testing Rename |
1033 // Testing Rename |
1033 r=fMan->Rename(_L("\\private\\two\\moo"),_L("\\private\\two\\mew")); |
1034 r=fMan->Rename(_L("\\private\\two\\moo"),_L("\\private\\two\\mew")); |
1034 test(r == KErrPermissionDenied); |
1035 test_Value(r, r == KErrPermissionDenied); |
1035 |
1036 |
1036 // Testing Delete |
1037 // Testing Delete |
1037 r=fMan->Delete(_L("\\private\\two\\test")); |
1038 r=fMan->Delete(_L("\\private\\two\\test")); |
1038 test(r == KErrPermissionDenied); |
1039 test_Value(r, r == KErrPermissionDenied); |
1039 r=fMan->Delete(_L("\\private\\moo")); |
1040 r=fMan->Delete(_L("\\private\\moo")); |
1040 test(r == KErrPermissionDenied); |
1041 test_Value(r, r == KErrPermissionDenied); |
1041 r=fMan->Delete(_L("\\sys\\")); |
1042 r=fMan->Delete(_L("\\sys\\")); |
1042 test(r == KErrPermissionDenied); |
1043 test_Value(r, r == KErrPermissionDenied); |
1043 |
1044 |
1044 //Something that actually exists in Private |
1045 //Something that actually exists in Private |
1045 r=fMan->Rename(name,_L("\\private\\00000001\\moo")); |
1046 r=fMan->Rename(name,_L("\\private\\00000001\\moo")); |
1046 test(r == KErrNone); |
1047 test_KErrNone(r); |
1047 r=fMan->Rename(_L("\\private\\00000001\\moo"),name); |
1048 r=fMan->Rename(_L("\\private\\00000001\\moo"),name); |
1048 test(r == KErrNone); |
1049 test_KErrNone(r); |
1049 r=fMan->Copy(name,_L("\\private\\00000001\\moo")); |
1050 r=fMan->Copy(name,_L("\\private\\00000001\\moo")); |
1050 test(r == KErrNone); |
1051 test_KErrNone(r); |
1051 r=fMan->Delete(_L("\\private\\00000001\\moo")); |
1052 r=fMan->Delete(_L("\\private\\00000001\\moo")); |
1052 test(r == KErrNone); |
1053 test_KErrNone(r); |
1053 |
1054 |
1054 // Clean up the test data |
1055 // Clean up the test data |
1055 r=fMan->RmDir(_L("\\Caged\\")); |
1056 r=fMan->RmDir(_L("\\Caged\\")); |
1056 test(r == KErrNone); |
1057 test_KErrNone(r); |
1057 r=fMan->Delete(_L("\\capTest")); |
1058 r=fMan->Delete(_L("\\capTest")); |
1058 test(r == KErrNone); |
1059 test_KErrNone(r); |
1059 r=fMan->Delete(name); |
1060 r=fMan->Delete(name); |
1060 test(r == KErrNone); |
1061 test_KErrNone(r); |
1061 delete(fMan); |
1062 delete(fMan); |
1062 } |
1063 } |
1063 |
1064 |
1064 // CDirScan tests |
1065 // CDirScan tests |
1065 ScanDir(_L("\\"), CDirScan::EScanUpTree, KErrNone); |
1066 ScanDir(_L("\\"), CDirScan::EScanUpTree, KErrNone); |
1086 if(!(info.iDriveAtt & (KDriveAttRom|KDriveAttRedirected|KDriveAttSubsted|KDriveAttRemovable))) |
1087 if(!(info.iDriveAtt & (KDriveAttRom|KDriveAttRedirected|KDriveAttSubsted|KDriveAttRemovable))) |
1087 { |
1088 { |
1088 test.Printf(_L("Setting %c:"), 'A'+i); |
1089 test.Printf(_L("Setting %c:"), 'A'+i); |
1089 TInt ret = TheFs.SetSystemDrive((TDriveNumber)i); |
1090 TInt ret = TheFs.SetSystemDrive((TDriveNumber)i); |
1090 test.Printf(_L("%d\n"), ret); |
1091 test.Printf(_L("%d\n"), ret); |
1091 test(ret == KErrNone || ret == KErrAlreadyExists); |
1092 test_Value(ret, ret == KErrNone || ret == KErrAlreadyExists); |
1092 if(ret == KErrNone) |
1093 if(ret == KErrNone) |
1093 { |
1094 { |
1094 drive = (TDriveNumber)i; |
1095 drive = (TDriveNumber)i; |
1095 test.Printf(_L("Re-setting %c:"), 'A'+i); |
1096 test.Printf(_L("Re-setting %c:"), 'A'+i); |
1096 ret = TheFs.SetSystemDrive(drive); |
1097 ret = TheFs.SetSystemDrive(drive); |
1097 test.Printf(_L("%d\n"), ret); |
1098 test.Printf(_L("%d\n"), ret); |
1098 test(ret == KErrAlreadyExists); |
1099 test_Value(ret, ret == KErrAlreadyExists); |
1099 } |
1100 } |
1100 } |
1101 } |
1101 } |
1102 } |
1102 } |
1103 } |
1103 } |
1104 } |
1112 // |
1113 // |
1113 { |
1114 { |
1114 test.Next(_L("Delete test directory")); |
1115 test.Next(_L("Delete test directory")); |
1115 CFileMan* fMan=CFileMan::NewL(TheFs); |
1116 CFileMan* fMan=CFileMan::NewL(TheFs); |
1116 TInt r=fMan->RmDir(gSessionPath); |
1117 TInt r=fMan->RmDir(gSessionPath); |
1117 test(r==KErrNone || KErrPathNotFound); |
1118 // test_Value(r, r == KErrNone || r == KErrPathNotFound); |
1119 test(r == KErrNone || KErrPathNotFound); |
|
1118 delete fMan; |
1120 delete fMan; |
1119 } |
1121 } |
1120 |
1122 |
1121 GLDEF_C void CallTestsL(/*TChar aDriveLetter*/) |
1123 GLDEF_C void CallTestsL(/*TChar aDriveLetter*/) |
1122 // |
1124 // |
1136 TBuf<30> sesspath; |
1138 TBuf<30> sesspath; |
1137 sesspath=_L("?:\\"); |
1139 sesspath=_L("?:\\"); |
1138 sesspath[0] = (TText)gDriveToTest; |
1140 sesspath[0] = (TText)gDriveToTest; |
1139 |
1141 |
1140 TInt r= TheFs.SetSessionPath(sesspath); |
1142 TInt r= TheFs.SetSessionPath(sesspath); |
1141 test(r==KErrNone); |
1143 test_KErrNone(r); |
1142 |
1144 |
1143 //cleanup from previous run of this test |
1145 //cleanup from previous run of this test |
1144 TBuf<20> delDir; |
1146 TBuf<20> delDir; |
1145 CFileMan* fMan=CFileMan::NewL(TheFs); |
1147 CFileMan* fMan=CFileMan::NewL(TheFs); |
1146 delDir=KResourcePath; |
1148 delDir=KResourcePath; |
1147 delDir[0]=(TText)gDriveToTest; |
1149 delDir[0]=(TText)gDriveToTest; |
1148 r=fMan->RmDir(delDir); |
1150 r=fMan->RmDir(delDir); |
1149 test(r==KErrNone || KErrNotFound); |
1151 // test_Value(r, r == KErrNone || r == KErrNotFound); |
1152 test(r == KErrNone || KErrNotFound); |
|
1150 delDir=KSystemPath; |
1153 delDir=KSystemPath; |
1151 delDir[0]=(TText)gDriveToTest; |
1154 delDir[0]=(TText)gDriveToTest; |
1152 r=fMan->RmDir(delDir); |
1155 r=fMan->RmDir(delDir); |
1153 test(r==KErrNone || KErrNotFound); |
1156 // test_Value(r, r == KErrNone || r == KErrNotFound); |
1157 test(r == KErrNone || KErrNotFound); |
|
1154 delDir=KPrivatePath; |
1158 delDir=KPrivatePath; |
1155 delDir[0]=(TText)gDriveToTest; |
1159 delDir[0]=(TText)gDriveToTest; |
1156 r=fMan->RmDir(delDir); |
1160 r=fMan->RmDir(delDir); |
1157 test(r==KErrNone || KErrNotFound); |
1161 // test_Value(r, r == KErrNone || r == KErrNotFound); |
1162 test(r == KErrNone || KErrNotFound); |
|
1158 delete fMan; |
1163 delete fMan; |
1159 |
1164 |
1160 //check double mode ie that Defpath still works |
1165 //check double mode ie that Defpath still works |
1161 RFs fs1; |
1166 RFs fs1; |
1162 RFs fs2; |
1167 RFs fs2; |
1163 |
1168 |
1164 r=fs1.Connect(); |
1169 r=fs1.Connect(); |
1165 test(r==KErrNone); |
1170 test_KErrNone(r); |
1166 r=fs1.SessionPath(sesspath); |
1171 r=fs1.SessionPath(sesspath); |
1167 test(r==KErrNone); |
1172 test_KErrNone(r); |
1168 test.Printf(_L("session1 Path=%S"),&sesspath); |
1173 test.Printf(_L("session1 Path=%S"),&sesspath); |
1169 |
1174 |
1170 TBuf<30> privatepath; |
1175 TBuf<30> privatepath; |
1171 r=fs1.SetSessionToPrivate(gTheDriveNum); |
1176 r=fs1.SetSessionToPrivate(gTheDriveNum); |
1172 test(r==KErrNone); |
1177 test_KErrNone(r); |
1173 r=fs1.PrivatePath(privatepath); |
1178 r=fs1.PrivatePath(privatepath); |
1174 test(r==KErrNone); |
1179 test_KErrNone(r); |
1175 r=privatepath.Compare(KExpectedPrivatePath()); |
1180 r=privatepath.Compare(KExpectedPrivatePath()); |
1176 test(r==0); |
1181 test_Value(r, r == 0); |
1177 r=fs1.SessionPath(sesspath); |
1182 r=fs1.SessionPath(sesspath); |
1178 test(r==KErrNone); |
1183 test_KErrNone(r); |
1179 r=privatepath.Compare(sesspath.Mid(KPathPosition)); |
1184 r=privatepath.Compare(sesspath.Mid(KPathPosition)); |
1180 test(r==0); |
1185 test_Value(r, r == 0); |
1181 r=fs1.CreatePrivatePath(gTheDriveNum); |
1186 r=fs1.CreatePrivatePath(gTheDriveNum); |
1182 test(r==KErrNone); |
1187 test_KErrNone(r); |
1183 fs1.Close(); |
1188 fs1.Close(); |
1184 |
1189 |
1185 r=fs2.Connect(); |
1190 r=fs2.Connect(); |
1186 test(r==KErrNone); |
1191 test_KErrNone(r); |
1187 r=fs2.SessionPath(sesspath); |
1192 r=fs2.SessionPath(sesspath); |
1188 test(r==KErrNone); |
1193 test_KErrNone(r); |
1189 test.Printf(_L("session2 Path=%S"),&sesspath); |
1194 test.Printf(_L("session2 Path=%S"),&sesspath); |
1190 fs2.Close(); |
1195 fs2.Close(); |
1191 |
1196 |
1192 TestCaps(); |
1197 TestCaps(); |
1193 TestCaging(); |
1198 TestCaging(); |