40 do |
39 do |
41 { |
40 { |
42 r=handsvr.Connect(); |
41 r=handsvr.Connect(); |
43 } |
42 } |
44 while(r==KErrNotFound); |
43 while(r==KErrNotFound); |
45 test_KErrNone(r); |
44 test(r==KErrNone); |
46 r=handsvr.SetTestDrive(drivenum); |
45 r=handsvr.SetTestDrive(drivenum); |
47 test_KErrNone(r); |
46 test(r==KErrNone); |
48 TInt ssh; |
47 TInt ssh; |
49 RFs fs1; |
48 RFs fs1; |
50 TInt fsh = handsvr.GetFileHandle(ssh, EFileRead); |
49 TInt fsh = handsvr.GetFileHandle(ssh, EFileRead); |
51 |
50 |
52 r = fs1.SetReturnedHandle(fsh); |
51 r = fs1.SetReturnedHandle(fsh); |
53 test_KErrNone(r); |
52 test(r==KErrNone); |
54 |
53 |
55 RFile file; |
54 RFile file; |
56 r=file.Adopt(fs1,ssh); |
55 r=file.Adopt(fs1,ssh); |
57 test_KErrNone(r); |
56 test(r==KErrNone); |
58 |
57 |
59 TBuf8<100> rbuf; |
58 TBuf8<100> rbuf; |
60 r=file.Read(0,rbuf); |
59 r=file.Read(0,rbuf); |
61 test_KErrNone(r); |
60 test(r==KErrNone); |
62 |
61 |
63 r=rbuf.CompareF(KTestData1()); |
62 r=rbuf.CompareF(KTestData1()); |
64 test_KErrNone(r); |
63 test(r==KErrNone); |
65 |
64 |
66 r=file.Write(KTestData()); |
65 r=file.Write(KTestData()); |
67 test_Value(r, r==KErrAccessDenied); |
66 test(r==KErrAccessDenied); |
68 |
67 |
69 r=file.ChangeMode(EFileWrite); |
68 r=file.ChangeMode(EFileWrite); |
70 test_Value(r, r==KErrArgument); |
69 test(r==KErrArgument); |
71 |
70 |
72 r=file.Rename(_L("\\newname.txt")); |
71 r=file.Rename(_L("\\newname.txt")); |
73 test_Value(r, r==KErrPermissionDenied || r==KErrAccessDenied); |
72 test(r==KErrPermissionDenied || r==KErrAccessDenied); |
74 |
73 |
75 file.Close(); |
74 file.Close(); |
76 |
75 |
77 fsh = handsvr.GetFileHandle(ssh, EFileRead); |
76 fsh = handsvr.GetFileHandle(ssh, EFileRead); |
78 r = fs1.SetReturnedHandle(fsh); |
77 r = fs1.SetReturnedHandle(fsh); |
79 test_KErrNone(r); |
78 test(r==KErrNone); |
80 |
79 |
81 // Adopt a bad sub-session handle |
80 // Adopt a bad sub-session handle |
82 |
81 |
83 r=file.Adopt(fs1, KNullHandle); |
82 r=file.Adopt(fs1, KNullHandle); |
84 test_Value(r, r==KErrBadHandle); |
83 test(r==KErrBadHandle); |
85 |
84 |
86 r=file.Adopt(fs1, -1); |
85 r=file.Adopt(fs1, -1); |
87 test_Value(r, r==KErrBadHandle); |
86 test(r==KErrBadHandle); |
88 |
87 |
89 |
88 |
90 handsvr.Close(); |
89 handsvr.Close(); |
91 file.Close(); |
90 file.Close(); |
92 RDebug::Print(_L("End Of Tests")); |
91 RDebug::Print(_L("End Of Tests")); |
100 { |
99 { |
101 test.Next(_L("RFile::Duplicate()")); |
100 test.Next(_L("RFile::Duplicate()")); |
102 |
101 |
103 RFs fs; |
102 RFs fs; |
104 TInt r=fs.Connect(); |
103 TInt r=fs.Connect(); |
105 test_KErrNone(r); |
104 test(r==KErrNone); |
106 |
105 |
107 // Check the number of open file handles |
106 // Check the number of open file handles |
108 TInt resCount = fs.ResourceCount(); |
107 TInt resCount = fs.ResourceCount(); |
109 test_Value(resCount, resCount == 0); |
108 test(resCount == 0); |
110 |
109 |
111 // create a file & fill it with data |
110 // create a file & fill it with data |
112 RFile file1; |
111 RFile file1; |
113 r=file1.Replace(fs,KCliFileName,EFileWrite); |
112 r=file1.Replace(fs,KCliFileName,EFileWrite); |
114 test_KErrNone(r); |
113 test(r==KErrNone); |
115 r=file1.Write(KTestData()); |
114 r=file1.Write(KTestData()); |
116 test_KErrNone(r); |
115 test(r==KErrNone); |
117 file1.Close(); |
116 file1.Close(); |
118 |
117 |
119 // open the file for read |
118 // open the file for read |
120 r = file1.Open(fs,KCliFileName,EFileRead); |
119 r = file1.Open(fs,KCliFileName,EFileRead); |
121 test_KErrNone(r); |
120 test(r==KErrNone); |
122 TBuf8<100> rbuf; |
121 TBuf8<100> rbuf; |
123 r = file1.Read(0,rbuf); |
122 r = file1.Read(0,rbuf); |
124 test_KErrNone(r); |
123 test(r==KErrNone); |
125 r=rbuf.CompareF(KTestData); |
124 r=rbuf.CompareF(KTestData); |
126 test_KErrNone(r); |
125 test(r==KErrNone); |
127 |
126 |
128 |
127 |
129 // clone the file |
128 // clone the file |
130 RFile file2; |
129 RFile file2; |
131 r = file2.Duplicate(file1); |
130 r = file2.Duplicate(file1); |
132 test_Value(r, r==0); |
131 test(r==0); |
133 |
132 |
134 // make sure file positions are the same |
133 // make sure file positions are the same |
135 TInt pos1 = 0; |
134 TInt pos1 = 0; |
136 r = file1.Seek(ESeekCurrent, pos1); |
135 r = file1.Seek(ESeekCurrent, pos1); |
137 test_KErrNone(r); |
136 test(r==KErrNone); |
138 TInt pos2 = 0; |
137 TInt pos2 = 0; |
139 r = file2.Seek(ESeekCurrent, pos2); |
138 r = file2.Seek(ESeekCurrent, pos2); |
140 test_KErrNone(r); |
139 test(r==KErrNone); |
141 test_Value(pos1, pos1 == pos2); |
140 test(pos1 == pos2); |
142 |
141 |
143 // change the position on the duplcated file handle & |
142 // change the position on the duplcated file handle & |
144 // verify that the original file handle's position is unchanged |
143 // verify that the original file handle's position is unchanged |
145 TInt oldPos1 = pos1; |
144 TInt oldPos1 = pos1; |
146 |
145 |
147 const TInt newPos2 = 5; |
146 const TInt newPos2 = 5; |
148 pos2 = newPos2; |
147 pos2 = newPos2; |
149 r = file2.Seek(ESeekStart, pos2); |
148 r = file2.Seek(ESeekStart, pos2); |
150 test_KErrNone(r); |
149 test(r==KErrNone); |
151 |
150 |
152 pos1 = 0; |
151 pos1 = 0; |
153 r = file1.Seek(ESeekCurrent, pos1); |
152 r = file1.Seek(ESeekCurrent, pos1); |
154 test_KErrNone(r); |
153 test(r==KErrNone); |
155 test_Value(pos1, pos1 == oldPos1); |
154 test(pos1 == oldPos1); |
156 |
155 |
157 pos2 = 0; |
156 pos2 = 0; |
158 r = file2.Seek(ESeekCurrent, pos2); |
157 r = file2.Seek(ESeekCurrent, pos2); |
159 test_KErrNone(r); |
158 test(r==KErrNone); |
160 test_Value(pos2, pos2 == newPos2); |
159 test(pos2 == newPos2); |
161 test_Value(pos1, pos1 != pos2); |
160 test(pos1 != pos2); |
162 |
161 |
163 // close the parent file and check we can still use the duplicated one. |
162 // close the parent file and check we can still use the duplicated one. |
164 file1.Close(); |
163 file1.Close(); |
165 |
164 |
166 // Check the number of open file handles - should be 1 (the duplicated one) |
165 // Check the number of open file handles - should be 1 (the duplicated one) |
167 resCount = fs.ResourceCount(); |
166 resCount = fs.ResourceCount(); |
168 test_Value(resCount, resCount == 1); |
167 test(resCount == 1); |
169 |
168 |
170 fs.Close(); |
169 fs.Close(); |
171 |
170 |
172 rbuf.FillZ(); |
171 rbuf.FillZ(); |
173 |
172 |
174 // reset to pos 0 |
173 // reset to pos 0 |
175 pos2 = 0; |
174 pos2 = 0; |
176 r = file2.Seek(ESeekStart, pos2); |
175 r = file2.Seek(ESeekStart, pos2); |
177 test_KErrNone(r); |
176 test(r==KErrNone); |
178 |
177 |
179 r=file2.Read(0,rbuf); |
178 r=file2.Read(0,rbuf); |
180 test_KErrNone(r); |
179 test(r==KErrNone); |
181 r=rbuf.CompareF(KTestData); |
180 r=rbuf.CompareF(KTestData); |
182 test_KErrNone(r); |
181 test(r==KErrNone); |
183 file2.Close(); |
182 file2.Close(); |
184 |
183 |
185 // start again - this time we're going to close the duplicated file first |
184 // start again - this time we're going to close the duplicated file first |
186 // and check we can still use the parent file |
185 // and check we can still use the parent file |
187 |
186 |
188 r = fs.Connect(); |
187 r = fs.Connect(); |
189 test_KErrNone(r); |
188 test(r==KErrNone); |
190 |
189 |
191 // Make a note of the number of open resources |
190 // Make a note of the number of open resources |
192 fs.ResourceCountMarkStart(); |
191 fs.ResourceCountMarkStart(); |
193 |
192 |
194 // open the file for read |
193 // open the file for read |
195 r = file1.Open(fs,KCliFileName,EFileRead); |
194 r = file1.Open(fs,KCliFileName,EFileRead); |
196 test_KErrNone(r); |
195 test(r==KErrNone); |
197 |
196 |
198 |
197 |
199 // clone the file & check we can read it |
198 // clone the file & check we can read it |
200 r = file2.Duplicate(file1, EOwnerThread); |
199 r = file2.Duplicate(file1, EOwnerThread); |
201 test_Value(r, r==0); |
200 test(r==0); |
202 rbuf.FillZ(); |
201 rbuf.FillZ(); |
203 r = file2.Read(0,rbuf); |
202 r = file2.Read(0,rbuf); |
204 test_KErrNone(r); |
203 test(r==KErrNone); |
205 r=rbuf.CompareF(KTestData); |
204 r=rbuf.CompareF(KTestData); |
206 test_KErrNone(r); |
205 test(r==KErrNone); |
207 |
206 |
208 |
207 |
209 // close the duplicated file and check we can still use the parent one. |
208 // close the duplicated file and check we can still use the parent one. |
210 file2.Close(); |
209 file2.Close(); |
211 |
210 |
212 rbuf.FillZ(); |
211 rbuf.FillZ(); |
213 |
212 |
214 // check we can read the parent file |
213 // check we can read the parent file |
215 r=file1.Read(0,rbuf); |
214 r=file1.Read(0,rbuf); |
216 test_KErrNone(r); |
215 test(r==KErrNone); |
217 r=rbuf.CompareF(KTestData); |
216 r=rbuf.CompareF(KTestData); |
218 test_KErrNone(r); |
217 test(r==KErrNone); |
219 |
218 |
220 // close the parent |
219 // close the parent |
221 file1.Close(); |
220 file1.Close(); |
222 |
221 |
223 // Check the number of open file handles |
222 // Check the number of open file handles |
224 fs.ResourceCountMarkEnd(); |
223 fs.ResourceCountMarkEnd(); |
225 resCount = fs.ResourceCount(); |
224 resCount = fs.ResourceCount(); |
226 test_Value(resCount, resCount == 0); |
225 test(resCount == 0); |
227 |
226 |
228 fs.Close(); |
227 fs.Close(); |
229 } |
228 } |
230 |
229 |
231 |
230 |
259 // adopt the file handle from FHServer |
258 // adopt the file handle from FHServer |
260 test.Next(_L("RFile::AdoptFromServer()")); |
259 test.Next(_L("RFile::AdoptFromServer()")); |
261 |
260 |
262 RFile file; |
261 RFile file; |
263 r=file.AdoptFromServer(fsh, ssh); |
262 r=file.AdoptFromServer(fsh, ssh); |
264 test_KErrNone(r); |
263 test(r==KErrNone); |
265 |
264 |
266 TBuf8<100> rbuf; |
265 TBuf8<100> rbuf; |
267 r=file.Read(0,rbuf); |
266 r=file.Read(0,rbuf); |
268 test_KErrNone(r); |
267 test(r==KErrNone); |
269 |
268 |
270 // server should write KTestData1 ("Server Write Server Write") to file |
269 // server should write KTestData1 ("Server Write Server Write") to file |
271 r=rbuf.CompareF(KTestData1); |
270 r=rbuf.CompareF(KTestData1); |
272 test_KErrNone(r); |
271 test(r==KErrNone); |
273 |
272 |
274 // reset to pos 0 |
273 // reset to pos 0 |
275 TInt pos = 0; |
274 TInt pos = 0; |
276 r = file.Seek(ESeekStart, pos); |
275 r = file.Seek(ESeekStart, pos); |
277 test_KErrNone(r); |
276 test(r==KErrNone); |
278 |
277 |
279 // overwrite with KTestData ("Client Write Client Write") to file |
278 // overwrite with KTestData ("Client Write Client Write") to file |
280 r=file.Write(KTestData()); |
279 r=file.Write(KTestData()); |
281 test_KErrNone(r); |
280 test(r==KErrNone); |
282 rbuf.FillZ(); |
281 rbuf.FillZ(); |
283 r=file.Read(0,rbuf); |
282 r=file.Read(0,rbuf); |
284 test_KErrNone(r); |
283 test(r==KErrNone); |
285 r=rbuf.CompareF(KTestData); |
284 r=rbuf.CompareF(KTestData); |
286 test_KErrNone(r); |
285 test(r==KErrNone); |
287 |
286 |
288 // !!! Disable platform security tests until we get the new APIs |
287 // !!! Disable platform security tests until we get the new APIs |
289 // r=file.Rename(_L("\\newname.txt")); |
288 // r=file.Rename(_L("\\newname.txt")); |
290 // test_Value(r, r==KErrPermissionDenied); |
289 // test(r==KErrPermissionDenied); |
291 |
290 |
292 test.Next(_L("RFile::Name()")); |
291 test.Next(_L("RFile::Name()")); |
293 |
292 |
294 // retrieve the file name from the server |
293 // retrieve the file name from the server |
295 TFileName name; |
294 TFileName name; |
296 r = file.Name(name); |
295 r = file.Name(name); |
297 test_KErrNone(r); |
296 test(r==KErrNone); |
298 r = name.Compare(KSvrFileName()); |
297 r = name.Compare(KSvrFileName()); |
299 test_Value(r, r==0); |
298 test(r==0); |
300 |
299 |
301 |
300 |
302 test.Next(_L("RFile::Duplicate()")); |
301 test.Next(_L("RFile::Duplicate()")); |
303 RFile file2; |
302 RFile file2; |
304 r = file2.Duplicate(file); |
303 r = file2.Duplicate(file); |
305 test_Value(r, r==0); |
304 test(r==0); |
306 |
305 |
307 |
306 |
308 TInt pos1 = 0; |
307 TInt pos1 = 0; |
309 r = file.Seek(ESeekCurrent, pos1); |
308 r = file.Seek(ESeekCurrent, pos1); |
310 test_KErrNone(r); |
309 test(r==KErrNone); |
311 TInt pos2 = 0; |
310 TInt pos2 = 0; |
312 r = file2.Seek(ESeekCurrent, pos2); |
311 r = file2.Seek(ESeekCurrent, pos2); |
313 test_KErrNone(r); |
312 test(r==KErrNone); |
314 test_Value(pos1, pos1 == pos2); |
313 test(pos1 == pos2); |
315 |
314 |
316 // close the parent file and check we can still use the duplicated one. |
315 // close the parent file and check we can still use the duplicated one. |
317 file.Close(); |
316 file.Close(); |
318 |
317 |
319 rbuf.FillZ(); |
318 rbuf.FillZ(); |
320 |
319 |
321 // reset to pos 0 |
320 // reset to pos 0 |
322 pos2 = 0; |
321 pos2 = 0; |
323 r = file2.Seek(ESeekStart, pos2); |
322 r = file2.Seek(ESeekStart, pos2); |
324 test_KErrNone(r); |
323 test(r==KErrNone); |
325 |
324 |
326 r=file2.Read(0,rbuf); |
325 r=file2.Read(0,rbuf); |
327 test_KErrNone(r); |
326 test(r==KErrNone); |
328 r=rbuf.CompareF(KTestData); |
327 r=rbuf.CompareF(KTestData); |
329 test_KErrNone(r); |
328 test(r==KErrNone); |
330 file2.Close(); |
329 file2.Close(); |
331 } |
330 } |
332 |
331 |
333 |
332 |
334 // Request a test file & test what we can do with it |
333 // Request a test file & test what we can do with it |
338 { |
337 { |
339 TInt r; |
338 TInt r; |
340 |
339 |
341 RFs fs; |
340 RFs fs; |
342 r=fs.Connect(); |
341 r=fs.Connect(); |
343 test_KErrNone(r); |
342 test(r==KErrNone); |
344 r=fs.ShareProtected(); |
343 r=fs.ShareProtected(); |
345 test_KErrNone(r); |
344 test(r==KErrNone); |
346 |
345 |
347 |
346 |
348 // define a filename in our private path |
347 // define a filename in our private path |
349 TPath newPath; |
348 TPath newPath; |
350 fs.PrivatePath(newPath); |
349 fs.PrivatePath(newPath); |
351 TFileName newFileName; |
350 TFileName newFileName; |
352 newFileName = newPath; |
351 newFileName = newPath; |
353 newFileName.Append(_L("newname.txt")); |
352 newFileName.Append(_L("newname.txt")); |
354 |
353 |
355 r=fs.CreatePrivatePath(drivenum); |
354 r=fs.CreatePrivatePath(drivenum); |
356 test_KErrNone(r); |
355 test(r==KErrNone); |
357 r=fs.SetSessionToPrivate(drivenum); |
356 r=fs.SetSessionToPrivate(drivenum); |
358 |
357 |
359 RFileHandleSharer handsvr; |
358 RFileHandleSharer handsvr; |
360 do |
359 do |
361 { |
360 { |
362 r=handsvr.Connect(); |
361 r=handsvr.Connect(); |
363 } |
362 } |
364 while(r==KErrNotFound); |
363 while(r==KErrNotFound); |
365 test_KErrNone(r); |
364 test(r==KErrNone); |
366 |
365 |
367 r=handsvr.SetTestDrive(drivenum); |
366 r=handsvr.SetTestDrive(drivenum); |
368 test_KErrNone(r); |
367 test(r==KErrNone); |
369 |
368 |
370 // Next verify that we can copy a file retrieved from the server |
369 // Next verify that we can copy a file retrieved from the server |
371 // using CFileMan::Copy() |
370 // using CFileMan::Copy() |
372 |
371 |
373 test.Next(_L("CFileMan::Copy()")); |
372 test.Next(_L("CFileMan::Copy()")); |
376 TInt fsh = handsvr.GetFileHandle2(ssh, EFileRead); |
375 TInt fsh = handsvr.GetFileHandle2(ssh, EFileRead); |
377 test (fsh >= 0); |
376 test (fsh >= 0); |
378 |
377 |
379 RFile file; |
378 RFile file; |
380 r=file.AdoptFromServer(fsh, ssh); |
379 r=file.AdoptFromServer(fsh, ssh); |
381 test_KErrNone(r); |
380 test(r==KErrNone); |
382 |
381 |
383 |
382 |
384 CFileMan* fileMan = NULL; |
383 CFileMan* fileMan = NULL; |
385 TRAP(r, fileMan = CFileMan::NewL(fs)); |
384 TRAP(r, fileMan = CFileMan::NewL(fs)); |
386 test_Value(r, r == KErrNone && fileMan != NULL); |
385 test(r == KErrNone && fileMan != NULL); |
387 |
386 |
388 // copy to file, overwrite |
387 // copy to file, overwrite |
389 r = fileMan->Copy(file, newFileName, CFileMan::EOverWrite); |
388 r = fileMan->Copy(file, newFileName, CFileMan::EOverWrite); |
390 test_KErrNone(r); |
389 test(r == KErrNone); |
391 |
390 |
392 // copy to file, don't overwrite |
391 // copy to file, don't overwrite |
393 r = fileMan->Copy(file, newFileName, 0); |
392 r = fileMan->Copy(file, newFileName, 0); |
394 test_Value(r, r == KErrAlreadyExists); |
393 test(r == KErrAlreadyExists); |
395 |
394 |
396 // copy to file, overwrite |
395 // copy to file, overwrite |
397 r = fileMan->Copy(file, newFileName, CFileMan::EOverWrite); |
396 r = fileMan->Copy(file, newFileName, CFileMan::EOverWrite); |
398 test_KErrNone(r); |
397 test(r == KErrNone); |
399 |
398 |
400 // copy to path |
399 // copy to path |
401 r = fileMan->Copy(file, newPath, CFileMan::EOverWrite); |
400 r = fileMan->Copy(file, newPath, CFileMan::EOverWrite); |
402 test_KErrNone(r); |
401 test(r == KErrNone); |
403 |
402 |
404 // copy to file, overwrite, asynchnonous |
403 // copy to file, overwrite, asynchnonous |
405 TRequestStatus status(KRequestPending); |
404 TRequestStatus status(KRequestPending); |
406 r = fileMan->Copy(file, newFileName, CFileMan::EOverWrite, status); |
405 r = fileMan->Copy(file, newFileName, CFileMan::EOverWrite, status); |
407 test_KErrNone(r); |
406 test(r == KErrNone); |
408 User::WaitForRequest(status); |
407 User::WaitForRequest(status); |
409 test_KErrNone(status.Int()); |
408 test(status == KErrNone); |
410 |
409 |
411 |
410 |
412 // Negative tests... |
411 // Negative tests... |
413 TPath newLongPath; |
412 TPath newLongPath; |
414 TInt len; |
413 TInt len; |
417 // when the filename is appended to it |
416 // when the filename is appended to it |
418 newLongPath = newPath; |
417 newLongPath = newPath; |
419 for (len=newLongPath.Length(); len< KMaxPath -4; len = newLongPath.Length()) |
418 for (len=newLongPath.Length(); len< KMaxPath -4; len = newLongPath.Length()) |
420 newLongPath.Append(_L("x\\")); |
419 newLongPath.Append(_L("x\\")); |
421 r = fileMan->Copy(file, newLongPath, CFileMan::EOverWrite); |
420 r = fileMan->Copy(file, newLongPath, CFileMan::EOverWrite); |
422 test_Value(r, r == KErrBadName); |
421 test(r == KErrBadName); |
423 |
422 |
424 // copy to very long but valid path (no filename) which will overflow |
423 // copy to very long but valid path (no filename) which will overflow |
425 // when drive letter is pre-pended to it |
424 // when drive letter is pre-pended to it |
426 newLongPath = newPath; |
425 newLongPath = newPath; |
427 for (len=newLongPath.Length(); len< KMaxPath -2; len = newLongPath.Length()) |
426 for (len=newLongPath.Length(); len< KMaxPath -2; len = newLongPath.Length()) |
428 newLongPath.Append(_L("x\\")); |
427 newLongPath.Append(_L("x\\")); |
429 r = fileMan->Copy(file, newLongPath, CFileMan::EOverWrite); |
428 r = fileMan->Copy(file, newLongPath, CFileMan::EOverWrite); |
430 test_Value(r, r == KErrBadName); |
429 test(r == KErrBadName); |
431 |
430 |
432 // copy to very long but valid path and filename which will overflow |
431 // copy to very long but valid path and filename which will overflow |
433 // when drive letter is pre-pended to it |
432 // when drive letter is pre-pended to it |
434 newLongPath.Append(_L("y")); |
433 newLongPath.Append(_L("y")); |
435 r = fileMan->Copy(file, newLongPath, CFileMan::EOverWrite); |
434 r = fileMan->Copy(file, newLongPath, CFileMan::EOverWrite); |
436 test_Value(r, r == KErrBadName); |
435 test(r == KErrBadName); |
437 |
436 |
438 // copy to badly formed path |
437 // copy to badly formed path |
439 newLongPath = newPath; |
438 newLongPath = newPath; |
440 newLongPath.Append(_L("\\y")); |
439 newLongPath.Append(_L("\\y")); |
441 r = fileMan->Copy(file, newLongPath, CFileMan::EOverWrite); |
440 r = fileMan->Copy(file, newLongPath, CFileMan::EOverWrite); |
442 test_Value(r, r == KErrBadName); |
441 test(r == KErrBadName); |
443 |
442 |
444 // copy to correctly formed path which doesn't exist |
443 // copy to correctly formed path which doesn't exist |
445 newLongPath = newPath; |
444 newLongPath = newPath; |
446 newLongPath.Append(_L("x\\y\\z")); |
445 newLongPath.Append(_L("x\\y\\z")); |
447 r = fileMan->Copy(file, newLongPath, CFileMan::EOverWrite); |
446 r = fileMan->Copy(file, newLongPath, CFileMan::EOverWrite); |
448 test_Value(r, r == KErrPathNotFound); |
447 test(r == KErrPathNotFound); |
449 |
448 |
450 delete fileMan; fileMan = NULL; |
449 delete fileMan; fileMan = NULL; |
451 |
450 |
452 file.Close(); |
451 file.Close(); |
453 |
452 |
460 fsh = handsvr.GetFileHandle2(ssh, TFileMode(EFileShareAny | EFileWrite)); |
459 fsh = handsvr.GetFileHandle2(ssh, TFileMode(EFileShareAny | EFileWrite)); |
461 test (fsh >= 0); |
460 test (fsh >= 0); |
462 |
461 |
463 // adopt the file handle from FHServer |
462 // adopt the file handle from FHServer |
464 r=file.AdoptFromServer(fsh, ssh); |
463 r=file.AdoptFromServer(fsh, ssh); |
465 test_KErrNone(r); |
464 test(r==KErrNone); |
466 |
465 |
467 r=file.Rename(_L("newname.txt")); |
466 r=file.Rename(_L("newname.txt")); |
468 test_Value(r, r==KErrPermissionDenied || r==KErrAccessDenied); |
467 test(r==KErrPermissionDenied || r==KErrAccessDenied); |
469 |
468 |
470 // delete the file before we try to rename anything to it |
469 // delete the file before we try to rename anything to it |
471 r = fs.Delete(newFileName); |
470 r = fs.Delete(newFileName); |
472 test_Value(r, r == KErrNone || r == KErrNotFound); |
471 test(r == KErrNone || r == KErrNotFound); |
473 |
472 |
474 r=file.Rename(newFileName); |
473 r=file.Rename(newFileName); |
475 test_Value(r, r==KErrPermissionDenied || r==KErrAccessDenied); |
474 test(r==KErrPermissionDenied || r==KErrAccessDenied); |
476 |
475 |
477 file.Close(); |
476 file.Close(); |
478 |
477 |
479 |
478 |
480 // Next verify that we CAN rename a file retrieved from the server |
479 // Next verify that we CAN rename a file retrieved from the server |
514 // |
513 // |
515 GLDEF_C void PassFile() |
514 GLDEF_C void PassFile() |
516 { |
515 { |
517 RFs fs; |
516 RFs fs; |
518 TInt r=fs.Connect(); |
517 TInt r=fs.Connect(); |
519 test_KErrNone(r); |
518 test(r==KErrNone); |
520 |
519 |
521 // Check the number of open file handles |
520 // Check the number of open file handles |
522 TInt resCount = fs.ResourceCount(); |
521 TInt resCount = fs.ResourceCount(); |
523 test_Value(resCount, resCount == 0); |
522 test(resCount == 0); |
524 |
523 |
525 r=fs.ShareProtected(); |
524 r=fs.ShareProtected(); |
526 test_KErrNone(r); |
525 test(r==KErrNone); |
527 |
526 |
528 r=fs.CreatePrivatePath(drivenum); |
527 r=fs.CreatePrivatePath(drivenum); |
529 test_KErrNone(r); |
528 test(r==KErrNone); |
530 r=fs.SetSessionToPrivate(drivenum); |
529 r=fs.SetSessionToPrivate(drivenum); |
531 |
530 |
532 |
531 |
533 RFile file1; |
532 RFile file1; |
534 r=file1.Replace(fs,KCliFileName,EFileWrite); |
533 r=file1.Replace(fs,KCliFileName,EFileWrite); |
535 test_KErrNone(r); |
534 test(r==KErrNone); |
536 r=file1.Write(KTestData()); |
535 r=file1.Write(KTestData()); |
537 test_KErrNone(r); |
536 test(r==KErrNone); |
538 file1.Close(); |
537 file1.Close(); |
539 |
538 |
540 RFileHandleSharer handsvr; |
539 RFileHandleSharer handsvr; |
541 do |
540 do |
542 { |
541 { |
543 r=handsvr.Connect(); |
542 r=handsvr.Connect(); |
544 } |
543 } |
545 while(r==KErrNotFound); |
544 while(r==KErrNotFound); |
546 test_KErrNone(r); |
545 test(r==KErrNone); |
547 |
546 |
548 r=handsvr.SetTestDrive(drivenum); |
547 r=handsvr.SetTestDrive(drivenum); |
549 test_KErrNone(r); |
548 test(r==KErrNone); |
550 |
549 |
551 r=fs.SetSessionToPrivate(drivenum); |
550 r=fs.SetSessionToPrivate(drivenum); |
552 test_KErrNone(r); |
551 test(r==KErrNone); |
553 |
552 |
554 r=file1.Open(fs,KCliFileName,EFileRead); |
553 r=file1.Open(fs,KCliFileName,EFileRead); |
555 test_KErrNone(r); |
554 test(r==KErrNone); |
556 |
555 |
557 // pass the file handle to FHServer |
556 // pass the file handle to FHServer |
558 test.Next(_L("RFile::TransferToServer()")); |
557 test.Next(_L("RFile::TransferToServer()")); |
559 |
558 |
560 TIpcArgs ipcArgs; |
559 TIpcArgs ipcArgs; |
597 GLDEF_C void PassInvalidFile() |
596 GLDEF_C void PassInvalidFile() |
598 { |
597 { |
599 |
598 |
600 RFs fs; |
599 RFs fs; |
601 TInt r=fs.Connect(); |
600 TInt r=fs.Connect(); |
602 test_KErrNone(r); |
601 test(r==KErrNone); |
603 |
602 |
604 // Check the number of open file handles |
603 // Check the number of open file handles |
605 TInt resCount = fs.ResourceCount(); |
604 TInt resCount = fs.ResourceCount(); |
606 test_Value(resCount, resCount == 0); |
605 test(resCount == 0); |
607 |
606 |
608 r=fs.ShareProtected(); |
607 r=fs.ShareProtected(); |
609 test_KErrNone(r); |
608 test(r==KErrNone); |
610 |
609 |
611 r=fs.CreatePrivatePath(drivenum); |
610 r=fs.CreatePrivatePath(drivenum); |
612 test_KErrNone(r); |
611 test(r==KErrNone); |
613 r=fs.SetSessionToPrivate(drivenum); |
612 r=fs.SetSessionToPrivate(drivenum); |
614 |
613 |
615 |
614 |
616 RFile file1; |
615 RFile file1; |
617 r=file1.Replace(fs,KCliFileName,EFileWrite); |
616 r=file1.Replace(fs,KCliFileName,EFileWrite); |
618 test_KErrNone(r); |
617 test(r==KErrNone); |
619 r=file1.Write(KTestData()); |
618 r=file1.Write(KTestData()); |
620 test_KErrNone(r); |
619 test(r==KErrNone); |
621 file1.Close(); |
620 file1.Close(); |
622 |
621 |
623 RFileHandleSharer handsvr; |
622 RFileHandleSharer handsvr; |
624 do |
623 do |
625 { |
624 { |
626 r=handsvr.Connect(); |
625 r=handsvr.Connect(); |
627 } |
626 } |
628 while(r==KErrNotFound); |
627 while(r==KErrNotFound); |
629 test_KErrNone(r); |
628 test(r==KErrNone); |
630 |
629 |
631 r=handsvr.SetTestDrive(drivenum); |
630 r=handsvr.SetTestDrive(drivenum); |
632 test_KErrNone(r); |
631 test(r==KErrNone); |
633 |
632 |
634 r=fs.SetSessionToPrivate(drivenum); |
633 r=fs.SetSessionToPrivate(drivenum); |
635 test_KErrNone(r); |
634 test(r==KErrNone); |
636 |
635 |
637 r=file1.Open(fs,KCliFileName,EFileRead); |
636 r=file1.Open(fs,KCliFileName,EFileRead); |
638 test_KErrNone(r); |
637 test(r==KErrNone); |
639 |
638 |
640 // check the resoure count - there should be 1 open file handle |
639 // check the resoure count - there should be 1 open file handle |
641 resCount = fs.ResourceCount(); |
640 resCount = fs.ResourceCount(); |
642 test_Value(resCount, resCount == 1); |
641 test(resCount == 1); |
643 |
642 |
644 // pass an invalid file handle to FHServer |
643 // pass an invalid file handle to FHServer |
645 // by overwriting the IPC slots |
644 // by overwriting the IPC slots |
646 test.Next(_L("PassInvalidFileHandle - RFile::TransferToServer()")); |
645 test.Next(_L("PassInvalidFileHandle - RFile::TransferToServer()")); |
647 |
646 |
650 // Pass a bad RFs handle |
649 // Pass a bad RFs handle |
651 file1.TransferToServer(ipcArgs, 0, 1); |
650 file1.TransferToServer(ipcArgs, 0, 1); |
652 |
651 |
653 // check the resoure count - there should be 2 open file handles |
652 // check the resoure count - there should be 2 open file handles |
654 resCount = fs.ResourceCount(); |
653 resCount = fs.ResourceCount(); |
655 test_Value(resCount, resCount == 2); |
654 test(resCount == 2); |
656 |
655 |
657 ipcArgs.Set(0, 0); // invalidate the RFs handle |
656 ipcArgs.Set(0, 0); // invalidate the RFs handle |
658 r = handsvr.PassInvalidFileHandle(ipcArgs); |
657 r = handsvr.PassInvalidFileHandle(ipcArgs); |
659 test_Value(r, r == KErrBadHandle); |
658 test (r == KErrBadHandle); |
660 |
659 |
661 // Pass a bad RFile handle |
660 // Pass a bad RFile handle |
662 file1.TransferToServer(ipcArgs, 0, 1); |
661 file1.TransferToServer(ipcArgs, 0, 1); |
663 |
662 |
664 // check the resoure count - there should be 3 open file handles |
663 // check the resoure count - there should be 3 open file handles |
665 resCount = fs.ResourceCount(); |
664 resCount = fs.ResourceCount(); |
666 test_Value(resCount, resCount == 3); |
665 test(resCount == 3); |
667 |
666 |
668 ipcArgs.Set(1, 0); // invalidate the RFile handle |
667 ipcArgs.Set(1, 0); // invalidate the RFile handle |
669 r = handsvr.PassInvalidFileHandle(ipcArgs); |
668 r = handsvr.PassInvalidFileHandle(ipcArgs); |
670 test_Value(r, r == KErrBadHandle); |
669 test (r == KErrBadHandle); |
671 |
670 |
672 // Pass bad RFs and RFile handles |
671 // Pass bad RFs and RFile handles |
673 file1.TransferToServer(ipcArgs, 0, 1); |
672 file1.TransferToServer(ipcArgs, 0, 1); |
674 |
673 |
675 // check the resoure count - there should be 4 open file handles |
674 // check the resoure count - there should be 4 open file handles |
676 resCount = fs.ResourceCount(); |
675 resCount = fs.ResourceCount(); |
677 test_Value(resCount, resCount == 4); |
676 test(resCount == 4); |
678 |
677 |
679 |
678 |
680 ipcArgs.Set(0, 0); // invalidate the RFs handle |
679 ipcArgs.Set(0, 0); // invalidate the RFs handle |
681 ipcArgs.Set(1, 0); // invalidate the RFile handle |
680 ipcArgs.Set(1, 0); // invalidate the RFile handle |
682 r = handsvr.PassInvalidFileHandle(ipcArgs); |
681 r = handsvr.PassInvalidFileHandle(ipcArgs); |
683 test_Value(r, r == KErrBadHandle); |
682 test (r == KErrBadHandle); |
684 |
683 |
685 // Close the file |
684 // Close the file |
686 handsvr.Close(); |
685 handsvr.Close(); |
687 file1.Close(); |
686 file1.Close(); |
688 |
687 |
689 // Check the number of open file handles |
688 // Check the number of open file handles |
690 resCount = fs.ResourceCount(); |
689 resCount = fs.ResourceCount(); |
691 test_Value(resCount, resCount == 3); |
690 test(resCount == 3); |
692 |
691 |
693 fs.Close(); |
692 fs.Close(); |
694 } |
693 } |
695 |
694 |
696 |
695 |
701 GLDEF_C void PassFile(RProcess& aProcess) |
700 GLDEF_C void PassFile(RProcess& aProcess) |
702 { |
701 { |
703 |
702 |
704 RFs fs; |
703 RFs fs; |
705 TInt r=fs.Connect(); |
704 TInt r=fs.Connect(); |
706 test_KErrNone(r); |
705 test(r==KErrNone); |
707 |
706 |
708 // Check the number of open file handles |
707 // Check the number of open file handles |
709 TInt resCount = fs.ResourceCount(); |
708 TInt resCount = fs.ResourceCount(); |
710 test_Value(resCount, resCount == 0); |
709 test(resCount == 0); |
711 |
710 |
712 r=fs.ShareProtected(); |
711 r=fs.ShareProtected(); |
713 test_KErrNone(r); |
712 test(r==KErrNone); |
714 |
713 |
715 r=fs.CreatePrivatePath(drivenum); |
714 r=fs.CreatePrivatePath(drivenum); |
716 test_KErrNone(r); |
715 test(r==KErrNone); |
717 r=fs.SetSessionToPrivate(drivenum); |
716 r=fs.SetSessionToPrivate(drivenum); |
718 |
717 |
719 |
718 |
720 RFile file1; |
719 RFile file1; |
721 r=file1.Replace(fs,KCliFileName,EFileWrite); |
720 r=file1.Replace(fs,KCliFileName,EFileWrite); |
722 test_KErrNone(r); |
721 test(r==KErrNone); |
723 r=file1.Write(KTestData()); |
722 r=file1.Write(KTestData()); |
724 test_KErrNone(r); |
723 test(r==KErrNone); |
725 file1.Close(); |
724 file1.Close(); |
726 |
725 |
727 r=file1.Open(fs, KCliFileName, EFileWrite); |
726 r=file1.Open(fs, KCliFileName, EFileWrite); |
728 |
727 |
729 test_KErrNone(r); |
728 test(r==KErrNone); |
730 |
729 |
731 // NB slot 0 is reserved for the command line |
730 // NB slot 0 is reserved for the command line |
732 |
731 |
733 test.Next(_L("RFile::TransferToProcess()")); |
732 test.Next(_L("RFile::TransferToProcess()")); |
734 |
733 |
735 r = file1.TransferToProcess(aProcess, 1, 2); |
734 r = file1.TransferToProcess(aProcess, 1, 2); |
736 |
735 |
737 r = aProcess.SetParameter(3, drivenum); |
736 r = aProcess.SetParameter(3, drivenum); |
738 test_KErrNone(r); |
737 test(r==KErrNone); |
739 |
738 |
740 r=fs.SetSessionToPrivate(drivenum); |
739 r=fs.SetSessionToPrivate(drivenum); |
741 test_KErrNone(r); |
740 test(r==KErrNone); |
742 |
741 |
743 // make sure we can still read from the file |
742 // make sure we can still read from the file |
744 TBuf8<100> rbuf; |
743 TBuf8<100> rbuf; |
745 r=file1.Read(0,rbuf); |
744 r=file1.Read(0,rbuf); |
746 test_KErrNone(r); |
745 test(r==KErrNone); |
747 r=rbuf.CompareF(KTestData()); |
746 r=rbuf.CompareF(KTestData()); |
748 test_KErrNone(r); |
747 test(r==KErrNone); |
749 file1.Close(); |
748 file1.Close(); |
750 |
749 |
751 r=fs.MkDir(_L("C:\\mdir")); |
750 r=fs.MkDir(_L("C:\\mdir")); |
752 test_Value(r, r==KErrNone || r==KErrAlreadyExists); |
751 test(r==KErrNone || r==KErrAlreadyExists); |
753 |
752 |
754 // Check the number of open file handles - |
753 // Check the number of open file handles - |
755 // should be 1 (the one duplicated for the other process) |
754 // should be 1 (the one duplicated for the other process) |
756 resCount = fs.ResourceCount(); |
755 resCount = fs.ResourceCount(); |
757 test_Value(resCount, resCount == 1); |
756 test(resCount == 1); |
758 |
757 |
759 fs.Close(); |
758 fs.Close(); |
760 |
759 |
761 // Start the server thread |
760 // Start the server thread |
762 aProcess.Resume(); |
761 aProcess.Resume(); |
790 RFs::CharToDrive(gDriveToTest,drivenum); |
789 RFs::CharToDrive(gDriveToTest,drivenum); |
791 |
790 |
792 // make sure the session path exists |
791 // make sure the session path exists |
793 RFs fs; |
792 RFs fs; |
794 TInt r = fs.Connect(); |
793 TInt r = fs.Connect(); |
795 test_KErrNone(r); |
794 test(r==KErrNone); |
796 |
795 |
797 TFileName sessionp; |
796 TFileName sessionp; |
798 fs.SessionPath(sessionp); |
797 fs.SessionPath(sessionp); |
799 r = fs.MkDirAll(sessionp); |
798 r = fs.MkDirAll(sessionp); |
800 test_Value(r, r==KErrNone || r==KErrAlreadyExists); |
799 test(r==KErrNone || r==KErrAlreadyExists); |
801 fs.Close(); |
800 fs.Close(); |
802 |
801 |
803 // Remember the number of open handles. Just for a sanity check .... |
802 // Remember the number of open handles. Just for a sanity check .... |
804 TInt start_thc, start_phc; |
803 TInt start_thc, start_phc; |
805 RThread().HandleCount(start_phc, start_thc); |
804 RThread().HandleCount(start_phc, start_thc); |
806 test.Printf(_L("Handles: start_phc %d, start_thc %d\n"), start_phc, start_thc); |
805 test.Printf(_L("Handles: start_phc %d, start_thc %d\n"), start_phc, start_thc); |
807 |
806 |
808 //create test server |
807 //create test server |
809 RProcess p; |
808 RProcess p; |
810 r = p.Create(_L("FHServer.exe"), KNullDesC); |
809 r = p.Create(_L("FHServer.exe"), KNullDesC); |
811 test_KErrNone(r); |
810 test(r==KErrNone); |
812 |
811 |
813 // RFile::Duplicate() tests |
812 // RFile::Duplicate() tests |
814 Duplicate(); |
813 Duplicate(); |
815 |
814 |
816 // Pass RFs/RFile handles to the server using RFile::TransferToProcess() |
815 // Pass RFs/RFile handles to the server using RFile::TransferToProcess() |
870 // Sanity check for open handles |
870 // Sanity check for open handles |
871 TInt end_thc, end_phc; |
871 TInt end_thc, end_phc; |
872 RThread().HandleCount(end_phc, end_thc); |
872 RThread().HandleCount(end_phc, end_thc); |
873 test.Printf(_L("Handles: end_phc %d, end_thc %d\n"), end_phc, end_thc); |
873 test.Printf(_L("Handles: end_phc %d, end_thc %d\n"), end_phc, end_thc); |
874 |
874 |
875 test_Value(start_thc, start_thc == end_thc); |
875 test(start_thc == end_thc); |
876 test_Value(start_phc, start_phc == end_phc); |
876 test(start_phc == end_phc); |
877 |
877 |
878 // and also for pending requests ... |
878 // and also for pending requests ... |
879 test_Value(RThread().RequestCount(), RThread().RequestCount() == 0); |
879 test(RThread().RequestCount() == 0); |
880 |
880 |
881 |
881 |
882 RDebug::Print(_L("End Of Tests")); |
882 RDebug::Print(_L("End Of Tests")); |
883 } |
883 } |
884 |
884 |