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