|
1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of the License "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // f32test\bench\t_fsropen.cpp |
|
15 // |
|
16 // |
|
17 |
|
18 #include <f32file.h> |
|
19 #include <e32test.h> |
|
20 #include "t_select.h" |
|
21 #include "..\server\t_server.h" |
|
22 #include "t_benchmain.h" |
|
23 |
|
24 GLDEF_D RTest test(_L("File Server Benchmarks, Open File")); |
|
25 |
|
26 //---------------------------------------------------------------------------------------------- |
|
27 //! @SYMTestCaseID PBASE-T_FSROPEN-0275 |
|
28 //! @SYMTestType CIT |
|
29 //! @SYMPREQ PREQ000 |
|
30 //! @SYMTestCaseDesc This test case is measuring performance of the FAT implementation |
|
31 //! @SYMTestActions 0. Expects the files to exist in order to successful execution |
|
32 //! 1. Time the opening and read of 4 Kb of last.txt file in each directory |
|
33 //! 2. Time the opening and read of 4 Kb of last.txt file in each directory |
|
34 //! with two clients accessing the directory |
|
35 //! 3. Time the opening and read of 4 Kb of last.txt file in each directory |
|
36 //! with two clients accessing different directories |
|
37 //! |
|
38 //! @SYMTestExpectedResults Finishes if the system behaves as expected, panics otherwise |
|
39 //! @SYMTestPriority High |
|
40 //! @SYMTestStatus Implemented |
|
41 //---------------------------------------------------------------------------------------------- |
|
42 |
|
43 |
|
44 LOCAL_D RSemaphore client; |
|
45 LOCAL_D const TInt KHeapSize=0x6000; |
|
46 LOCAL_D TBuf8<4096> buf; |
|
47 |
|
48 LOCAL_D TDriveList gDriveList; |
|
49 LOCAL_D TFileName gFindEntryDir; |
|
50 LOCAL_D TBuf<100> gFindDir; |
|
51 |
|
52 LOCAL_D TFileName gFindEntryDir2; |
|
53 LOCAL_D TBuf<100> gFindDir2; |
|
54 |
|
55 // Concurrent thread |
|
56 RThread gSpeedy; |
|
57 RThread gSpeedyII; |
|
58 |
|
59 LOCAL_D TInt ThreadCount=0; |
|
60 |
|
61 _LIT(KDirMultipleName2, "dir%d_%d\\"); |
|
62 |
|
63 /** Find entry in directory |
|
64 |
|
65 */ |
|
66 LOCAL_C TInt FindEntryAccess2(TAny*) |
|
67 { |
|
68 RFs fs; |
|
69 TInt r = fs.Connect(); |
|
70 RTest test(_L("test 2")); |
|
71 |
|
72 r = fs.SetSessionPath(gSessionPath); |
|
73 |
|
74 client.Signal(); |
|
75 |
|
76 FOREVER |
|
77 { |
|
78 TEntry entry; |
|
79 |
|
80 r = fs.Entry(gFindEntryDir2, entry); |
|
81 FailIfError(r); |
|
82 test.Printf(_L("1")); |
|
83 r=fs.Entry(gFindDir2, entry); |
|
84 FailIfError(r); |
|
85 } |
|
86 } |
|
87 |
|
88 /** Starts two concurrent client sessions in the same directory |
|
89 |
|
90 */ |
|
91 LOCAL_C void DoTest(TThreadFunction aFunction) |
|
92 { |
|
93 TBuf<50> buf = _L("Speedy"); |
|
94 buf.AppendNum(ThreadCount++); |
|
95 TInt r = gSpeedy.Create(buf, aFunction, KDefaultStackSize, KHeapSize, KHeapSize, NULL); |
|
96 FailIfError(r); |
|
97 |
|
98 buf = _L("Speedy"); |
|
99 buf.AppendNum(ThreadCount++); |
|
100 r = gSpeedyII.Create(buf, aFunction, KDefaultStackSize, KHeapSize, KHeapSize, NULL); |
|
101 FailIfError(r); |
|
102 |
|
103 gSpeedy.SetPriority(EPriorityLess); |
|
104 gSpeedyII.SetPriority(EPriorityLess); |
|
105 |
|
106 gSpeedy.Resume(); |
|
107 gSpeedyII.Resume(); |
|
108 |
|
109 client.Wait(); |
|
110 client.Wait(); |
|
111 } |
|
112 |
|
113 /** Starts two concurrent client sessions in different directories |
|
114 |
|
115 */ |
|
116 LOCAL_C void DoTest2(TThreadFunction aFunction) |
|
117 { |
|
118 TBuf<50> buf=_L("Speedy"); |
|
119 buf.AppendNum(ThreadCount++); |
|
120 TInt r = gSpeedy.Create(buf, aFunction, KDefaultStackSize, KHeapSize, KHeapSize, NULL); |
|
121 FailIfError(r); |
|
122 |
|
123 buf = _L("Speedy"); |
|
124 buf.AppendNum(ThreadCount++); |
|
125 r = gSpeedyII.Create(buf, FindEntryAccess2, KDefaultStackSize, KHeapSize, KHeapSize, NULL); |
|
126 FailIfError(r); |
|
127 |
|
128 gSpeedy.SetPriority(EPriorityLess); |
|
129 gSpeedyII.SetPriority(EPriorityLess); |
|
130 |
|
131 gSpeedy.Resume(); |
|
132 gSpeedyII.Resume(); |
|
133 |
|
134 client.Wait(); |
|
135 client.Wait(); |
|
136 } |
|
137 |
|
138 /** Kills the concurrent session |
|
139 |
|
140 */ |
|
141 LOCAL_C void DoTestKill() |
|
142 { |
|
143 gSpeedy.Kill(KErrNone); |
|
144 gSpeedy.Close(); |
|
145 |
|
146 gSpeedyII.Kill(KErrNone); |
|
147 gSpeedyII.Close(); |
|
148 } |
|
149 |
|
150 /** Find entry in directory |
|
151 |
|
152 */ |
|
153 LOCAL_C TInt FindEntryAccess(TAny*) |
|
154 { |
|
155 RFs fs; |
|
156 TInt r = fs.Connect(); |
|
157 RTest test(_L("test 2")); |
|
158 |
|
159 fs.SetSessionPath(gSessionPath); |
|
160 |
|
161 client.Signal(); |
|
162 |
|
163 FOREVER |
|
164 { |
|
165 TEntry entry; |
|
166 |
|
167 r = fs.Entry(gFindEntryDir, entry); |
|
168 FailIfError(r); |
|
169 |
|
170 r = fs.Entry(gFindDir,entry); |
|
171 FailIfError(r); |
|
172 } |
|
173 } |
|
174 |
|
175 /** Find last.txt by opening it and with two threads accessing the current directory |
|
176 and looking for the same file |
|
177 |
|
178 @param aN Number of files in the directory |
|
179 @param aStep Test step |
|
180 */ |
|
181 LOCAL_C void FindFileM2(TInt aN, TInt aStep) |
|
182 { |
|
183 TBuf16<100> dir1; |
|
184 TBuf16<100> dir2; |
|
185 TBuf16<100> dir3; |
|
186 TBuf16<100> dirtemp; |
|
187 |
|
188 TInt r = 0; |
|
189 |
|
190 TTime startTime; |
|
191 TTime endTime; |
|
192 TTimeIntervalMicroSeconds timeTaken(0); |
|
193 RFile file; |
|
194 TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1; |
|
195 |
|
196 if(aN <= gFilesLimit) |
|
197 { |
|
198 dir1 = gSessionPath; |
|
199 dir2 = gSessionPath; |
|
200 dir3 = gSessionPath; |
|
201 |
|
202 dirtemp.Format(KDirMultipleName2, 1, aN); |
|
203 dir1.Append(dirtemp); |
|
204 gFindDir = dir1; |
|
205 |
|
206 dirtemp.Format(KDirMultipleName2, 2, aN); |
|
207 dir2.Append(dirtemp); |
|
208 |
|
209 dirtemp.Format(KDirMultipleName2, 3, aN); |
|
210 dir3.Append(dirtemp); |
|
211 |
|
212 dir1.Append(KCommonFile); |
|
213 |
|
214 if(gTypes >= 1) |
|
215 { |
|
216 gFindEntryDir = dir1; |
|
217 DoTest(FindEntryAccess); |
|
218 |
|
219 User::After(200); |
|
220 startTime.HomeTime(); |
|
221 |
|
222 r = file.Open(TheFs, dir1, EFileShareAny|EFileWrite); |
|
223 FailIfError(r); |
|
224 |
|
225 endTime.HomeTime(); |
|
226 |
|
227 DoTestKill(); |
|
228 file.Close(); |
|
229 |
|
230 timeTaken = endTime.MicroSecondsFrom(startTime); |
|
231 timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit); |
|
232 } |
|
233 |
|
234 if(gTypes >= 2) |
|
235 { |
|
236 gFindDir = dir2; |
|
237 dir2.Append(KCommonFile); |
|
238 gFindEntryDir = dir2; |
|
239 |
|
240 DoTest(FindEntryAccess); |
|
241 User::After(200); |
|
242 startTime.HomeTime(); |
|
243 |
|
244 r = file.Open(TheFs, dir2, EFileShareAny|EFileWrite); |
|
245 FailIfError(r); |
|
246 |
|
247 endTime.HomeTime(); |
|
248 |
|
249 DoTestKill(); |
|
250 file.Close(); |
|
251 |
|
252 timeTaken = endTime.MicroSecondsFrom(startTime); |
|
253 timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit); |
|
254 } |
|
255 |
|
256 if(gTypes >= 3) |
|
257 { |
|
258 gFindDir = dir3; |
|
259 dir3.Append(KCommonFile); |
|
260 |
|
261 gFindEntryDir = dir3; |
|
262 DoTest(FindEntryAccess); |
|
263 |
|
264 User::After(200); |
|
265 startTime.HomeTime(); |
|
266 |
|
267 r=file.Open(TheFs, dir3, EFileShareAny|EFileWrite); |
|
268 FailIfError(r); |
|
269 |
|
270 endTime.HomeTime(); |
|
271 DoTestKill(); |
|
272 file.Close(); |
|
273 |
|
274 timeTaken = endTime.MicroSecondsFrom(startTime); |
|
275 timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit); |
|
276 |
|
277 } |
|
278 } |
|
279 |
|
280 PrintResult(aStep, 1, aN); |
|
281 PrintResultTime(aStep, 2, timeTaken1); |
|
282 PrintResultTime(aStep, 3, timeTaken2); |
|
283 PrintResultTime(aStep, 4, timeTaken3); |
|
284 } |
|
285 |
|
286 /** Find last.txt by opening it and without any other process |
|
287 |
|
288 @param aN Number of files in the directory |
|
289 @param aStep Test step |
|
290 */ |
|
291 LOCAL_C void OpenFile(TInt aN, TInt aStep) |
|
292 { |
|
293 TBuf16<100> dir1; |
|
294 TBuf16<100> dir2; |
|
295 TBuf16<100> dir3; |
|
296 TBuf16<100> dirtemp; |
|
297 |
|
298 TInt r = 0; |
|
299 TInt pos = 0; |
|
300 TTime startTime; |
|
301 TTime endTime; |
|
302 TTimeIntervalMicroSeconds timeTaken(0); |
|
303 TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1; |
|
304 RFile file; |
|
305 |
|
306 if(aN <= gFilesLimit) |
|
307 { |
|
308 dir1 = gSessionPath; |
|
309 dir2 = gSessionPath; |
|
310 dir3 = gSessionPath; |
|
311 |
|
312 dirtemp.Format(KDirMultipleName, 1, aN); |
|
313 dir1.Append(dirtemp); |
|
314 |
|
315 dirtemp.Format(KDirMultipleName, 2, aN); |
|
316 dir2.Append(dirtemp); |
|
317 |
|
318 dirtemp.Format(KDirMultipleName, 3, aN); |
|
319 dir3.Append(dirtemp); |
|
320 |
|
321 dir1.Append(KCommonFile); |
|
322 dir2.Append(KCommonFile); |
|
323 dir3.Append(KCommonFile); |
|
324 |
|
325 if(gTypes >= 1) |
|
326 { |
|
327 startTime.HomeTime(); |
|
328 |
|
329 r = file.Open(TheFs, dir1, EFileShareAny|EFileRead); |
|
330 FailIfError(r); |
|
331 r = file.Seek(ESeekStart, pos); |
|
332 FailIfError(r); |
|
333 r = file.Read(buf); |
|
334 FailIfError(r); |
|
335 |
|
336 endTime.HomeTime(); |
|
337 file.Close(); |
|
338 |
|
339 timeTaken = endTime.MicroSecondsFrom(startTime); |
|
340 timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit); |
|
341 |
|
342 } |
|
343 |
|
344 if(gTypes >= 2) |
|
345 { |
|
346 startTime.HomeTime(); |
|
347 |
|
348 r = file.Open(TheFs, dir2, EFileShareAny|EFileRead); |
|
349 FailIfError(r); |
|
350 r = file.Seek(ESeekStart,pos); |
|
351 FailIfError(r); |
|
352 r = file.Read(buf); |
|
353 FailIfError(r); |
|
354 |
|
355 endTime.HomeTime(); |
|
356 |
|
357 file.Close(); |
|
358 |
|
359 timeTaken = endTime.MicroSecondsFrom(startTime); |
|
360 timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit); |
|
361 } |
|
362 |
|
363 if(gTypes >= 3) |
|
364 { |
|
365 startTime.HomeTime(); |
|
366 |
|
367 r = file.Open(TheFs, dir3, EFileShareAny|EFileRead); |
|
368 FailIfError(r); |
|
369 r = file.Seek(ESeekStart, pos); |
|
370 FailIfError(r); |
|
371 r = file.Read(buf); |
|
372 FailIfError(r); |
|
373 |
|
374 endTime.HomeTime(); |
|
375 file.Close(); |
|
376 |
|
377 timeTaken=endTime.MicroSecondsFrom(startTime); |
|
378 timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit); |
|
379 } |
|
380 } |
|
381 |
|
382 PrintResult(aStep, 1, aN); |
|
383 PrintResultTime(aStep, 2, timeTaken1); |
|
384 PrintResultTime(aStep, 3, timeTaken2); |
|
385 PrintResultTime(aStep, 4, timeTaken3); |
|
386 |
|
387 } |
|
388 |
|
389 /** Find last.txt with TFindFile and with two threads accessing the current directory and other one |
|
390 |
|
391 @param aN Number of files in the directory |
|
392 @param aStep Test step |
|
393 */ |
|
394 LOCAL_C void FindFileMD1(TInt aN, TInt aStep) |
|
395 { |
|
396 TBuf16<100> dir1; |
|
397 TBuf16<100> dir2; |
|
398 TBuf16<100> dir3; |
|
399 TBuf16<100> dir4; |
|
400 TBuf16<100> dirtemp; |
|
401 |
|
402 TInt r = 0; |
|
403 TFindFile find(TheFs); |
|
404 TTime startTime; |
|
405 TTime endTime; |
|
406 TTimeIntervalMicroSeconds timeTaken(0); |
|
407 TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1; |
|
408 |
|
409 if(aN <= gFilesLimit) |
|
410 { |
|
411 dir1 = gSessionPath; |
|
412 dir2 = gSessionPath; |
|
413 dir3 = gSessionPath; |
|
414 |
|
415 dirtemp.Format(KDirMultipleName2,1,aN); |
|
416 dir1.Append(dirtemp); |
|
417 |
|
418 gFindDir = dir1; |
|
419 dirtemp.Format(KDirMultipleName, 2, aN); |
|
420 dir2.Append(dirtemp); |
|
421 |
|
422 dirtemp.Format(KDirMultipleName, 3, aN); |
|
423 dir3.Append(dirtemp); |
|
424 |
|
425 dir4=gSessionPath; |
|
426 dirtemp.Format(KDirMultipleName, 3, 300); |
|
427 |
|
428 dir4.Append(dirtemp); |
|
429 gFindDir2 = dir4; |
|
430 |
|
431 dir1.Append(KCommonFile); |
|
432 dir2.Append(KCommonFile); |
|
433 dir3.Append(KCommonFile); |
|
434 dir4.Append(KCommonFile); |
|
435 gFindEntryDir2 = dir4; |
|
436 |
|
437 if(gTypes >= 1) |
|
438 { |
|
439 |
|
440 gFindEntryDir = dir1; |
|
441 |
|
442 dir4.Format(KDirMultipleName, 1, aN); |
|
443 |
|
444 DoTest2(FindEntryAccess); |
|
445 startTime.HomeTime(); |
|
446 |
|
447 r = find.FindByPath(dir1, &dir4); |
|
448 FailIfError(r); |
|
449 |
|
450 endTime.HomeTime(); |
|
451 DoTestKill(); |
|
452 |
|
453 timeTaken = endTime.MicroSecondsFrom(startTime); |
|
454 timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit); |
|
455 } |
|
456 |
|
457 if(gTypes >= 2) |
|
458 { |
|
459 dir4.Format(KDirMultipleName, 2, aN); |
|
460 |
|
461 gFindEntryDir=dir2; |
|
462 |
|
463 DoTest2(FindEntryAccess); |
|
464 |
|
465 startTime.HomeTime(); |
|
466 |
|
467 r = find.FindByPath(dir2,&dir4); |
|
468 FailIfError(r); |
|
469 |
|
470 endTime.HomeTime(); |
|
471 timeTaken = endTime.MicroSecondsFrom(startTime); |
|
472 |
|
473 DoTestKill(); |
|
474 |
|
475 timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit); |
|
476 } |
|
477 |
|
478 if(gTypes >= 3) |
|
479 { |
|
480 dir4.Format(KDirMultipleName, 3, aN); |
|
481 gFindEntryDir = dir3; |
|
482 |
|
483 DoTest2(FindEntryAccess); |
|
484 |
|
485 startTime.HomeTime(); |
|
486 |
|
487 r = find.FindByPath(dir3,&dir4); |
|
488 FailIfError(r); |
|
489 |
|
490 endTime.HomeTime(); |
|
491 DoTestKill(); |
|
492 |
|
493 timeTaken = endTime.MicroSecondsFrom(startTime); |
|
494 timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit); |
|
495 } |
|
496 } |
|
497 |
|
498 PrintResult(aStep, 1, aN); |
|
499 PrintResultTime(aStep, 2, timeTaken1); |
|
500 PrintResultTime(aStep, 3, timeTaken2); |
|
501 PrintResultTime(aStep, 4, timeTaken3); |
|
502 } |
|
503 |
|
504 |
|
505 /** Find last.txt by opening the file and with two threads accessing the current directory and other one |
|
506 |
|
507 @param aN Number of files in the directory |
|
508 @param aStep Test step |
|
509 */ |
|
510 LOCAL_C void FindFileMD2(TInt aN, TInt aStep) |
|
511 { |
|
512 TBuf16<100> dir1; |
|
513 TBuf16<100> dir2; |
|
514 TBuf16<100> dir3; |
|
515 TBuf16<100> dir4; |
|
516 TBuf16<100> dirtemp; |
|
517 |
|
518 TInt r = 0; |
|
519 |
|
520 TTime startTime; |
|
521 TTime endTime; |
|
522 TTimeIntervalMicroSeconds timeTaken(0); |
|
523 TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1; |
|
524 |
|
525 RFile file; |
|
526 |
|
527 if(aN <= gFilesLimit) |
|
528 { |
|
529 dir1 = gSessionPath; |
|
530 dir2 = gSessionPath; |
|
531 dir3 = gSessionPath; |
|
532 dir4 = gSessionPath; |
|
533 |
|
534 dirtemp.Format(KDirMultipleName2, 1, aN); |
|
535 dir1.Append(dirtemp); |
|
536 gFindDir = dir1; |
|
537 |
|
538 dirtemp.Format(KDirMultipleName2, 2, aN); |
|
539 dir2.Append(dirtemp); |
|
540 |
|
541 dirtemp.Format(KDirMultipleName2, 3, aN); |
|
542 dir3.Append(dirtemp); |
|
543 |
|
544 dir1.Append(KCommonFile); |
|
545 gFindEntryDir = dir1; |
|
546 |
|
547 dirtemp.Format(KDirMultipleName, 3, 300); |
|
548 dir4.Append(dirtemp); |
|
549 gFindDir2 = dir4; |
|
550 dir4.Append(KCommonFile); |
|
551 gFindEntryDir2 = dir4; |
|
552 |
|
553 if(gTypes >= 1) |
|
554 { |
|
555 DoTest2(FindEntryAccess); |
|
556 User::After(200); |
|
557 |
|
558 startTime.HomeTime(); |
|
559 |
|
560 r = file.Open(TheFs,dir1,EFileShareAny|EFileWrite); |
|
561 FailIfError(r); |
|
562 |
|
563 endTime.HomeTime(); |
|
564 |
|
565 DoTestKill(); |
|
566 file.Close(); |
|
567 |
|
568 timeTaken = endTime.MicroSecondsFrom(startTime); |
|
569 timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit); |
|
570 } |
|
571 |
|
572 if(gTypes >= 2) |
|
573 { |
|
574 gFindDir = dir2; |
|
575 dir2.Append(KCommonFile); |
|
576 gFindEntryDir = dir2; |
|
577 |
|
578 DoTest2(FindEntryAccess); |
|
579 User::After(200); |
|
580 |
|
581 startTime.HomeTime(); |
|
582 |
|
583 r = file.Open(TheFs, dir2, EFileShareAny|EFileWrite); |
|
584 FailIfError(r); |
|
585 |
|
586 endTime.HomeTime(); |
|
587 |
|
588 DoTestKill(); |
|
589 file.Close(); |
|
590 |
|
591 timeTaken = endTime.MicroSecondsFrom(startTime); |
|
592 timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit); |
|
593 } |
|
594 |
|
595 if(gTypes >= 3) |
|
596 { |
|
597 gFindDir = dir3; |
|
598 dir3.Append(KCommonFile); |
|
599 gFindEntryDir = dir3; |
|
600 DoTest2(FindEntryAccess); |
|
601 |
|
602 User::After(200); |
|
603 startTime.HomeTime(); |
|
604 |
|
605 r = file.Open(TheFs, dir3, EFileShareAny|EFileWrite); |
|
606 FailIfError(r); |
|
607 |
|
608 endTime.HomeTime(); |
|
609 DoTestKill(); |
|
610 file.Close(); |
|
611 |
|
612 timeTaken = endTime.MicroSecondsFrom(startTime); |
|
613 timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit); |
|
614 } |
|
615 } |
|
616 |
|
617 PrintResult(aStep, 1, aN); |
|
618 PrintResultTime(aStep, 2, timeTaken1); |
|
619 PrintResultTime(aStep, 3, timeTaken2); |
|
620 PrintResultTime(aStep, 4, timeTaken3); |
|
621 } |
|
622 |
|
623 /** Times the system when opening a file with multiple clients accessing the directory |
|
624 Precondition: This test expects the drive already filled with files |
|
625 |
|
626 @param aSelector Configuration in case of manual execution |
|
627 */ |
|
628 LOCAL_C TInt TestOpenEntry(TAny* aSelector) |
|
629 { |
|
630 TInt i = 100, r = 0; |
|
631 TInt testStep = 1; |
|
632 TTime startTime; |
|
633 TTime endTime; |
|
634 TTimeIntervalSeconds timeTaken; |
|
635 |
|
636 Validate(aSelector); |
|
637 |
|
638 test.Printf(_L("#~TS_Title_%d,%d: Open and read 4 Kb entry last.txt, RFile::Open \n"), gTestHarness, gTestCase); |
|
639 startTime.HomeTime(); |
|
640 |
|
641 while(i <= KMaxFiles) |
|
642 { |
|
643 if(i == 100 || i == 1000 || i == 5000 || i == 10000) |
|
644 OpenFile(i, testStep++); |
|
645 i += 100; |
|
646 } |
|
647 |
|
648 gTestCase++; |
|
649 |
|
650 endTime.HomeTime(); |
|
651 r = endTime.SecondsFrom(startTime, timeTaken); |
|
652 FailIfError(r); |
|
653 test.Printf(_L("#~TS_Timing_%d,%d=%d\n"), gTestHarness, gTestCase, timeTaken.Int()); |
|
654 |
|
655 return(KErrNone); |
|
656 } |
|
657 |
|
658 /** Times the system when opening a file with multiple clients accessing the directory |
|
659 Precondition: This test expects the drive already filled with files |
|
660 |
|
661 @param aSelector Configuration in case of manual execution |
|
662 */ |
|
663 LOCAL_C TInt TestOpenEntryMultipleClients(TAny* aSelector) |
|
664 { |
|
665 TInt i = 100, r = 0; |
|
666 TInt testStep; |
|
667 TTime startTime; |
|
668 TTime endTime; |
|
669 TTimeIntervalSeconds timeTaken; |
|
670 |
|
671 Validate(aSelector); |
|
672 |
|
673 test.Printf(_L("#~TS_Title_%d,%d: Find entry mult clients accessing same directory, RFile::Open \n"), gTestHarness, gTestCase); |
|
674 startTime.HomeTime(); |
|
675 |
|
676 i = 100; |
|
677 testStep = 1; |
|
678 while(i <= KMaxFiles) |
|
679 { |
|
680 if(i == 100 || i == 1000 || i == 5000 || i == 10000) |
|
681 FindFileM2(i, testStep++); |
|
682 i += 100; |
|
683 } |
|
684 |
|
685 gTestCase++; |
|
686 |
|
687 endTime.HomeTime(); |
|
688 r = endTime.SecondsFrom(startTime, timeTaken); |
|
689 FailIfError(r); |
|
690 test.Printf(_L("#~TS_Timing_%d,%d=%d\n"), gTestHarness, gTestCase, timeTaken.Int()); |
|
691 |
|
692 return(KErrNone); |
|
693 } |
|
694 |
|
695 /** Times the system when opening a file with multiple clients accessing dif directory |
|
696 Precondition: This test expects the drive already filled with files |
|
697 |
|
698 @param aSelector Configuration in case of manual execution |
|
699 */ |
|
700 LOCAL_C TInt TestOpenEntryMultipleClientsDD(TAny* aSelector) |
|
701 { |
|
702 TInt i = 100, r = 0; |
|
703 TInt testStep; |
|
704 TTime startTime; |
|
705 TTime endTime; |
|
706 TTimeIntervalSeconds timeTaken; |
|
707 |
|
708 Validate(aSelector); |
|
709 |
|
710 test.Printf(_L("#~TS_Title_%d,%d: Find entry mult clients accessing dif directory, TFindFile\n"), gTestHarness, gTestCase); |
|
711 startTime.HomeTime(); |
|
712 |
|
713 testStep = 1; |
|
714 while(i <= KMaxFiles) |
|
715 { |
|
716 if(i == 100 || i == 1000 || i == 5000 || i == 10000) |
|
717 FindFileMD1(i, testStep++); |
|
718 i += 100; |
|
719 } |
|
720 |
|
721 gTestCase++; |
|
722 |
|
723 endTime.HomeTime(); |
|
724 r = endTime.SecondsFrom(startTime, timeTaken); |
|
725 FailIfError(r); |
|
726 test.Printf(_L("#~TS_Timing_%d,%d=%d\n"), gTestHarness, gTestCase, timeTaken.Int()); |
|
727 |
|
728 |
|
729 test.Printf(_L("#~TS_Title_%d,%d: Find entry mult clients accessing dif directory, RFile::Open \n"), gTestHarness, gTestCase); |
|
730 startTime.HomeTime(); |
|
731 |
|
732 i = 100; |
|
733 testStep = 1; |
|
734 while(i <= KMaxFiles) |
|
735 { |
|
736 if(i == 100 || i == 1000 || i == 5000 || i == 10000) |
|
737 FindFileMD2(i, testStep++); |
|
738 i += 100; |
|
739 } |
|
740 |
|
741 gTestCase++; |
|
742 |
|
743 endTime.HomeTime(); |
|
744 r = endTime.SecondsFrom(startTime, timeTaken); |
|
745 FailIfError(r); |
|
746 test.Printf(_L("#~TS_Timing_%d,%d=%d\n"), gTestHarness, gTestCase, timeTaken.Int()); |
|
747 |
|
748 return(KErrNone); |
|
749 } |
|
750 |
|
751 /** It goes automatically through all the options |
|
752 |
|
753 @param aSelector Configuration in case of manual execution |
|
754 */ |
|
755 LOCAL_C TInt TestAll(TAny* aSelector) |
|
756 { |
|
757 Validate(aSelector); |
|
758 |
|
759 TestOpenEntry(aSelector); |
|
760 TestOpenEntryMultipleClients(aSelector); |
|
761 TestOpenEntryMultipleClientsDD(aSelector); |
|
762 |
|
763 return(KErrNone); |
|
764 } |
|
765 |
|
766 /** Call all tests |
|
767 |
|
768 */ |
|
769 GLDEF_C void CallTestsL() |
|
770 { |
|
771 TInt r = client.CreateLocal(0); |
|
772 FailIfError(r); |
|
773 |
|
774 CSelectionBox* TheSelector = CSelectionBox::NewL(test.Console()); |
|
775 |
|
776 gFileSize = 8; |
|
777 |
|
778 // Each test case of the suite has an identifyer for parsing purposes of the results |
|
779 gTestHarness = 4; |
|
780 gTestCase = 1; |
|
781 |
|
782 CreateDirWithNFiles(300, 3); |
|
783 PrintHeaders(1, _L("t_fsropen. File Open")); |
|
784 |
|
785 if(gMode == 0) |
|
786 { // Manual |
|
787 gSessionPath=_L("?:\\"); |
|
788 TCallBack createFiles(TestFileCreate, TheSelector); |
|
789 TCallBack openFile(TestOpenEntry, TheSelector); |
|
790 TCallBack openFileMC(TestOpenEntryMultipleClients, TheSelector); |
|
791 TCallBack openFileMCDD(TestOpenEntryMultipleClientsDD, TheSelector); |
|
792 TCallBack allOpen(TestAll,TheSelector); |
|
793 TheSelector->AddDriveSelectorL(TheFs); |
|
794 TheSelector->AddLineL(_L("Create all files"), createFiles); |
|
795 TheSelector->AddLineL(_L("Open random file"), openFile); |
|
796 TheSelector->AddLineL(_L("With mult clients same directory"), openFileMC); |
|
797 TheSelector->AddLineL(_L("With mult clients dif large directories"), openFileMCDD); |
|
798 TheSelector->AddLineL(_L("All options"), allOpen); |
|
799 TheSelector->Run(); |
|
800 } |
|
801 else |
|
802 { // Automatic |
|
803 TestAll(TheSelector); |
|
804 } |
|
805 |
|
806 client.Close(); |
|
807 test.Printf(_L("#~TestEnd_%d\n"), gTestHarness); |
|
808 delete TheSelector; |
|
809 } |