1 /* |
|
2 * ============================================================================ |
|
3 * Name : testflexperiodic.cpp |
|
4 * Part of : src / testflextimer |
|
5 * Description : STIF test cases for CFlexPeriodic timer. |
|
6 * Version : %version: 1 % |
|
7 * |
|
8 * Copyright © 2010 Nokia Corporation and/or its subsidiary(-ies). |
|
9 * All rights reserved. |
|
10 * This component and the accompanying materials are made available |
|
11 * under the terms of the License "Eclipse Public License v1.0" |
|
12 * which accompanies this distribution, and is available |
|
13 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
14 * |
|
15 * Initial Contributors: |
|
16 * Nokia Corporation - initial contribution. |
|
17 * |
|
18 * Contributors: |
|
19 * Nokia Corporation |
|
20 * ============================================================================ |
|
21 * Template version: 4.1 |
|
22 */ |
|
23 |
|
24 #include <e32debug.h> // for RDebug |
|
25 #include <e32math.h> // for Math::Rand() |
|
26 #include <StifTestInterference.h> |
|
27 #include "testflextimer.h" // for global constants & CB |
|
28 #include "testcflextimer.h" |
|
29 #include "flextimerpanic.h" // for panic constants |
|
30 #include "inheritedcflextimer.h"// CFlexTimer implementation (CB is always TExtendedTestResult*) |
|
31 #include "inheritedcflextimer2.h"// another CFlexTimer implementation (CB is always RArray<TTimerStruct> *list) |
|
32 // ======== LOCAL FUNCTIONS ======== |
|
33 |
|
34 // ======== MEMBER FUNCTIONS ======== |
|
35 |
|
36 const TInt64 KTickResolution( 1000000 / 64 ); |
|
37 const TInt KExtraSlack = 500 * 1000; |
|
38 // --------------------------------------------------------------------------- |
|
39 // Constructor |
|
40 // --------------------------------------------------------------------------- |
|
41 // |
|
42 CTestCFlexTimer::CTestCFlexTimer() |
|
43 { |
|
44 } |
|
45 |
|
46 // --------------------------------------------------------------------------- |
|
47 // Destructor |
|
48 // --------------------------------------------------------------------------- |
|
49 // |
|
50 CTestCFlexTimer::~CTestCFlexTimer() |
|
51 { |
|
52 } |
|
53 // -------------------------------------------------------------------------- |
|
54 // Start timer and delete it. |
|
55 // -------------------------------------------------------------------------- |
|
56 // |
|
57 TInt CTestCFlexTimer::CreateAndDestroyCFlexTimerL( TTestResult& aResult, |
|
58 CTestFlexTimer */*cb*/) |
|
59 { |
|
60 TExtendedTestResult *eResult = new TExtendedTestResult(&aResult); |
|
61 CInheritedCFlexTimer |
|
62 * timer = CInheritedCFlexTimer::NewL(CActive::EPriorityStandard, |
|
63 TCallBack( |
|
64 InheritedFlexTimerCallbackStopSchedulerKErrNone, |
|
65 eResult)); |
|
66 |
|
67 TTimeIntervalMicroSeconds32 expireTime(5 * 1000 * 1000); //5s |
|
68 timer->After(expireTime); |
|
69 CActiveScheduler::Start(); |
|
70 |
|
71 delete timer; |
|
72 timer = NULL; |
|
73 _LIT( KDescription , "Test case passed"); |
|
74 aResult.SetResult(KErrNone, KDescription); |
|
75 delete eResult; |
|
76 return KErrNone; |
|
77 |
|
78 } |
|
79 |
|
80 // -------------------------------------------------------------------------- |
|
81 // Start timer and see that it expires at max time |
|
82 // -------------------------------------------------------------------------- |
|
83 // |
|
84 TInt CTestCFlexTimer::CreateAndExpireCFlexTimerL( TTestResult& aResult, |
|
85 CTestFlexTimer */*cb*/) |
|
86 { |
|
87 TExtendedTestResult *eResult = new TExtendedTestResult(&aResult); |
|
88 CInheritedCFlexTimer |
|
89 * timer = CInheritedCFlexTimer::NewL(CActive::EPriorityStandard, |
|
90 TCallBack( |
|
91 InheritedFlexTimerCallbackStopSchedulerKErrNone, |
|
92 eResult)); |
|
93 |
|
94 // Expire in 5 seconds |
|
95 TTimeIntervalMicroSeconds32 expireTime(5 * 1000 * 1000); |
|
96 |
|
97 // Save current time. |
|
98 TTime utcNow(0); |
|
99 utcNow.UniversalTime(); |
|
100 |
|
101 timer->After(expireTime); |
|
102 |
|
103 // Start scheduler and wait for callback to stop it |
|
104 CActiveScheduler::Start(); |
|
105 //See if CB has failed the case |
|
106 if (eResult->iCaseAlreadyFailed) |
|
107 { |
|
108 delete timer; |
|
109 delete eResult; |
|
110 return KErrNone; |
|
111 } |
|
112 // Get new current time |
|
113 TTime utcNow2(0); |
|
114 utcNow2.UniversalTime(); |
|
115 |
|
116 //Check if timer expiry happened within maxtime to maxtime+accuracy |
|
117 if ((utcNow + expireTime) <= utcNow2 && (utcNow + expireTime |
|
118 + TTimeIntervalMicroSeconds32(KTimerAccuracyMicroSeconds)) |
|
119 > utcNow2) |
|
120 { |
|
121 _LIT( KDescription , "Passed"); |
|
122 aResult.SetResult(KErrNone, KDescription); |
|
123 } |
|
124 else |
|
125 { |
|
126 _LIT( KDescription , "Timer was fired either too early or too late.\n"); |
|
127 aResult.SetResult(KErrGeneral, KDescription); |
|
128 } |
|
129 // Case was executed |
|
130 delete timer; |
|
131 delete eResult; |
|
132 return KErrNone; |
|
133 |
|
134 } |
|
135 |
|
136 // -------------------------------------------------------------------------- |
|
137 // Start two timers and see that they expire at the same time. |
|
138 // -------------------------------------------------------------------------- |
|
139 // |
|
140 TInt CTestCFlexTimer::CreateAndExpireTwoOverlappingAfterTimersL( |
|
141 TTestResult& aResult, CTestFlexTimer */*cb*/) |
|
142 { |
|
143 TTestResult *res1 = new TTestResult(); |
|
144 TTestResult *res2 = new TTestResult(); |
|
145 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
146 TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); |
|
147 eResult1->iTimerID = 1; |
|
148 eResult2->iTimerID = 2; |
|
149 CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( |
|
150 CActive::EPriorityStandard, |
|
151 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
152 eResult1)); |
|
153 CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( |
|
154 CActive::EPriorityStandard, |
|
155 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
156 eResult2)); |
|
157 // Expire in 10 seconds |
|
158 TTimeIntervalMicroSeconds32 expireTime1(10 * 1000 * 1000); |
|
159 //Expire within first timers default window |
|
160 TTimeIntervalMicroSeconds32 expireTime2(static_cast<TInt64> ((10 * 1000 |
|
161 * 1000 - static_cast<float> (10 * 1000 * 1000) |
|
162 * KDefaultWindowMultiplier))); |
|
163 |
|
164 // Save current time |
|
165 TTime utcNow(0); |
|
166 utcNow.UniversalTime(); |
|
167 |
|
168 timer1->After(expireTime1); |
|
169 timer2->After(expireTime2); |
|
170 |
|
171 //Timer to stop active scheduler after timers under test are completed. |
|
172 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
173 p->Start(15 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); |
|
174 // Start scheduler and wait for callback to stop it |
|
175 CActiveScheduler::Start(); |
|
176 delete p; |
|
177 //See if CB has failed the case |
|
178 if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) |
|
179 { |
|
180 if (eResult1->iCaseAlreadyFailed) |
|
181 { |
|
182 aResult.SetResult(eResult1->iTestResult->iResult, |
|
183 eResult1->iTestResult->iResultDes); |
|
184 } |
|
185 else |
|
186 { |
|
187 aResult.SetResult(eResult2->iTestResult->iResult, |
|
188 eResult2->iTestResult->iResultDes); |
|
189 } |
|
190 delete timer1; |
|
191 delete timer2; |
|
192 delete eResult1; |
|
193 delete eResult2; |
|
194 delete res1; |
|
195 delete res2; |
|
196 return KErrNone; |
|
197 } |
|
198 |
|
199 //Check if timers expiry happened within timer2 maxtime to maxtime+accuracy |
|
200 if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) |
|
201 && (utcNow + expireTime2 + TTimeIntervalMicroSeconds32( |
|
202 KTimerAccuracyMicroSeconds)) > TTime( |
|
203 eResult2->iTimerStoppedTime) && |
|
204 |
|
205 (utcNow + expireTime2) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow |
|
206 + expireTime2 + TTimeIntervalMicroSeconds32( |
|
207 KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime)) |
|
208 { |
|
209 _LIT( KDescription , "Passed"); |
|
210 aResult.SetResult(KErrNone, KDescription); |
|
211 } |
|
212 else |
|
213 { |
|
214 _LIT( KDescription , "Some timer was fired either too early or too late.\n"); |
|
215 RDebug::Printf("utcNow = %lld\n", utcNow.Int64()); |
|
216 RDebug::Printf("eResult1->iTimerStoppedTime = %lld\n", |
|
217 eResult1->iTimerStoppedTime); |
|
218 RDebug::Printf("eResult2->iTimerStoppedTime = %lld\n", |
|
219 eResult2->iTimerStoppedTime); |
|
220 aResult.SetResult(KErrGeneral, KDescription); |
|
221 } |
|
222 // Case was executed |
|
223 delete timer1; |
|
224 delete timer2; |
|
225 delete eResult1; |
|
226 delete eResult2; |
|
227 delete res1; |
|
228 delete res2; |
|
229 return KErrNone; |
|
230 |
|
231 } |
|
232 |
|
233 // -------------------------------------------------------------------------- |
|
234 // Start two timers and see that they expire at the same time. 64bit version |
|
235 // -------------------------------------------------------------------------- |
|
236 // |
|
237 TInt CTestCFlexTimer::CreateAndExpireTwoOverlappingAfterTimers64L( |
|
238 TTestResult& aResult, CTestFlexTimer */*cb*/) |
|
239 { |
|
240 TTestResult *res1 = new TTestResult(); |
|
241 TTestResult *res2 = new TTestResult(); |
|
242 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
243 TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); |
|
244 eResult1->iTimerID = 1; |
|
245 eResult2->iTimerID = 2; |
|
246 CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( |
|
247 CActive::EPriorityStandard, |
|
248 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
249 eResult1)); |
|
250 CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( |
|
251 CActive::EPriorityStandard, |
|
252 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
253 eResult2)); |
|
254 // Expire in 10 seconds |
|
255 TTimeIntervalMicroSeconds expireTime1(10 * 1000 * 1000); |
|
256 //Expire within first timers default window |
|
257 TTimeIntervalMicroSeconds expireTime2(static_cast<TInt64> ((10 * 1000 |
|
258 * 1000 - static_cast<float> (10 * 1000 * 1000) |
|
259 * KDefaultWindowMultiplier))); |
|
260 |
|
261 // Save current time |
|
262 TTime utcNow(0); |
|
263 utcNow.UniversalTime(); |
|
264 |
|
265 timer1->After(expireTime1); |
|
266 timer2->After(expireTime2); |
|
267 |
|
268 //Timer to stop active scheduler after timers under test are completed. |
|
269 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
270 p->Start(15 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); |
|
271 // Start scheduler and wait for callback to stop it |
|
272 CActiveScheduler::Start(); |
|
273 delete p; |
|
274 //See if CB has failed the case |
|
275 if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) |
|
276 { |
|
277 if (eResult1->iCaseAlreadyFailed) |
|
278 { |
|
279 aResult.SetResult(eResult1->iTestResult->iResult, |
|
280 eResult1->iTestResult->iResultDes); |
|
281 } |
|
282 else |
|
283 { |
|
284 aResult.SetResult(eResult2->iTestResult->iResult, |
|
285 eResult2->iTestResult->iResultDes); |
|
286 } |
|
287 delete timer1; |
|
288 delete timer2; |
|
289 delete eResult1; |
|
290 delete eResult2; |
|
291 delete res1; |
|
292 delete res2; |
|
293 return KErrNone; |
|
294 } |
|
295 // Get new current time |
|
296 TTime utcNow2(0); |
|
297 utcNow2.UniversalTime(); |
|
298 |
|
299 //Check if timers expiry happened within timer2 maxtime to maxtime+accuracy |
|
300 if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) |
|
301 && (utcNow + expireTime2 + TTimeIntervalMicroSeconds( |
|
302 KTimerAccuracyMicroSeconds)) > TTime( |
|
303 eResult2->iTimerStoppedTime) && |
|
304 |
|
305 (utcNow + expireTime2) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow |
|
306 + expireTime2 + TTimeIntervalMicroSeconds( |
|
307 KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime)) |
|
308 { |
|
309 _LIT( KDescription , "Passed"); |
|
310 aResult.SetResult(KErrNone, KDescription); |
|
311 } |
|
312 else |
|
313 { |
|
314 _LIT( KDescription , "Some timer was fired either too early or too late.\n"); |
|
315 aResult.SetResult(KErrGeneral, KDescription); |
|
316 } |
|
317 // Case was executed |
|
318 delete timer1; |
|
319 delete timer2; |
|
320 delete eResult1; |
|
321 delete eResult2; |
|
322 delete res1; |
|
323 delete res2; |
|
324 return KErrNone; |
|
325 |
|
326 } |
|
327 |
|
328 // -------------------------------------------------------------------------- |
|
329 // Start two timers and see that they expire at their own max time. |
|
330 // -------------------------------------------------------------------------- |
|
331 // |
|
332 TInt CTestCFlexTimer::CreateAndExpireTwoNonOverlappingAfterTimersL( |
|
333 TTestResult& aResult, CTestFlexTimer */*cb*/) |
|
334 { |
|
335 TTestResult *res1 = new TTestResult(); |
|
336 TTestResult *res2 = new TTestResult(); |
|
337 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
338 TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); |
|
339 eResult1->iTimerID = 1; |
|
340 eResult2->iTimerID = 2; |
|
341 CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( |
|
342 CActive::EPriorityStandard, |
|
343 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
344 eResult1)); |
|
345 CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( |
|
346 CActive::EPriorityStandard, |
|
347 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
348 eResult2)); |
|
349 // Expire in 10 seconds |
|
350 TTimeIntervalMicroSeconds32 expireTime1(10 * 1000 * 1000); |
|
351 //Expire one second before first timers window starts |
|
352 TTimeIntervalMicroSeconds32 expireTime2(static_cast<TInt64> ((10 * 1000 |
|
353 * 1000 - static_cast<float> (10 * 1000 * 1000) |
|
354 * KDefaultWindowMultiplier)) - 1 * 1000 * 1000); |
|
355 |
|
356 // Save current time |
|
357 TTime utcNow(0); |
|
358 utcNow.UniversalTime(); |
|
359 |
|
360 timer1->After(expireTime1); |
|
361 timer2->After(expireTime2); |
|
362 |
|
363 //Timer to stop active scheduler after timers under test are completed. |
|
364 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
365 p->Start(15 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); |
|
366 // Start scheduler and wait for callback to stop it |
|
367 CActiveScheduler::Start(); |
|
368 delete p; |
|
369 //See if CB has failed the case |
|
370 if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) |
|
371 { |
|
372 if (eResult1->iCaseAlreadyFailed) |
|
373 { |
|
374 aResult.SetResult(eResult1->iTestResult->iResult, |
|
375 eResult1->iTestResult->iResultDes); |
|
376 } |
|
377 else |
|
378 { |
|
379 aResult.SetResult(eResult2->iTestResult->iResult, |
|
380 eResult2->iTestResult->iResultDes); |
|
381 } |
|
382 delete timer1; |
|
383 delete timer2; |
|
384 delete eResult1; |
|
385 delete eResult2; |
|
386 delete res1; |
|
387 delete res2; |
|
388 return KErrNone; |
|
389 } |
|
390 // Get new current time |
|
391 TTime utcNow2(0); |
|
392 utcNow2.UniversalTime(); |
|
393 |
|
394 //Check if timers expiry happened within at their own max time edge. |
|
395 if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) |
|
396 && (utcNow + expireTime2 + TTimeIntervalMicroSeconds32( |
|
397 KTimerAccuracyMicroSeconds)) > TTime( |
|
398 eResult2->iTimerStoppedTime) && |
|
399 |
|
400 (utcNow + expireTime1) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow |
|
401 + expireTime1 + TTimeIntervalMicroSeconds32( |
|
402 KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime)) |
|
403 { |
|
404 _LIT( KDescription , "Passed"); |
|
405 aResult.SetResult(KErrNone, KDescription); |
|
406 } |
|
407 else |
|
408 { |
|
409 _LIT( KDescription , "Some timer was fired either too early or too late.\n"); |
|
410 aResult.SetResult(KErrGeneral, KDescription); |
|
411 } |
|
412 // Case was executed |
|
413 delete timer1; |
|
414 delete timer2; |
|
415 delete eResult1; |
|
416 delete eResult2; |
|
417 delete res1; |
|
418 delete res2; |
|
419 return KErrNone; |
|
420 |
|
421 } |
|
422 |
|
423 // -------------------------------------------------------------------------- |
|
424 // Start many timers and see that nothing goes wrong when they are expired at rapid sequence |
|
425 // -------------------------------------------------------------------------- |
|
426 // |
|
427 TInt CTestCFlexTimer::HumongousAmountOfTimeridelidilidousL( |
|
428 TTestResult& aResult, CTestFlexTimer */*cb*/) |
|
429 { |
|
430 RDebug::Printf("HugemongousAmountOfTimeridelidilidousL"); |
|
431 // This list will contain all the timer structs, expiry times etc. |
|
432 // First cell will always tell which timer is currently active |
|
433 // active info is transferred from e.g. InheritedCFlexTimer2::RunL to CB function |
|
434 RArray<TTimerStruct> timers; |
|
435 // This CB contains all the logic about timer addition |
|
436 StartTimerAndAddToList( &timers, 2000 ); |
|
437 // CBs stop this after all timers are expired |
|
438 CActiveScheduler::Start(); |
|
439 // Delete CPeriodic that was used to launch new FlexTimers |
|
440 delete timers[0].iStartTimer; |
|
441 _LIT( KDescriptionP , "Passed"); |
|
442 aResult.SetResult(KErrNone, KDescriptionP); |
|
443 // Loop throug list and see if timers fired within limits. |
|
444 // also delete all stuff reserved earlier by StartTimerAndAddToList |
|
445 while (timers.Count()) |
|
446 { |
|
447 // Have fun with reading this. It is not as bad as it looks |
|
448 // Just checks if CB already failed the case |
|
449 // and if timer was launched within its window(default) and timer accuracy |
|
450 if (!(!timers[0].iEResult->iCaseAlreadyFailed |
|
451 && (timers[0].iEResult->iTimerStartedTime |
|
452 + timers[0].iEResult->iTimerExpiryTime |
|
453 - (static_cast<float> (timers[0].iEResult->iTimerExpiryTime) |
|
454 * KDefaultWindowMultiplier) |
|
455 <= timers[0].iEResult->iTimerStoppedTime+KTickResolution) |
|
456 && (timers[0].iEResult->iTimerStartedTime |
|
457 + timers[0].iEResult->iTimerExpiryTime |
|
458 + KTimerAccuracyMicroSeconds) |
|
459 > timers[0].iEResult->iTimerStoppedTime)) |
|
460 { |
|
461 _LIT( KDescription , "Some timer was not fired within its window.\n"); |
|
462 aResult.SetResult(KErrGeneral, KDescription); |
|
463 |
|
464 } |
|
465 delete timers[0].iEResult->iTestResult; |
|
466 delete timers[0].iEResult; |
|
467 delete timers[0].iTimer; |
|
468 timers.Remove(0); |
|
469 } |
|
470 // Case was executed |
|
471 timers.Close(); |
|
472 return KErrNone; |
|
473 } |
|
474 |
|
475 // -------------------------------------------------------------------------- |
|
476 // Start three timers At, AtUTC and After and see that they are treated equally. |
|
477 // -------------------------------------------------------------------------- |
|
478 // |
|
479 TInt CTestCFlexTimer::CreateAndExpireThreeTimersL( TTestResult& aResult, |
|
480 CTestFlexTimer */*cb*/) |
|
481 { |
|
482 TTestResult *res1 = new TTestResult(); |
|
483 TTestResult *res2 = new TTestResult(); |
|
484 TTestResult *res3 = new TTestResult(); |
|
485 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
486 TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); |
|
487 TExtendedTestResult *eResult3 = new TExtendedTestResult(res3); |
|
488 eResult1->iTimerID = 1; |
|
489 eResult2->iTimerID = 2; |
|
490 eResult2->iTimerID = 3; |
|
491 CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( |
|
492 CActive::EPriorityStandard, |
|
493 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
494 eResult1)); |
|
495 CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( |
|
496 CActive::EPriorityStandard, |
|
497 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
498 eResult2)); |
|
499 CInheritedCFlexTimer* timer3 = CInheritedCFlexTimer::NewL( |
|
500 CActive::EPriorityStandard, |
|
501 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
502 eResult3)); |
|
503 // Expire in 10 seconds |
|
504 TTimeIntervalMicroSeconds expireTime1(10 * 1000 * 1000); |
|
505 //Expire within first timers default window |
|
506 TTimeIntervalMicroSeconds expireTime2(9 * 1000 * 1000); |
|
507 TTimeIntervalMicroSeconds expireTime3(3 * 1000 * 1000); // Expire far enough from others |
|
508 |
|
509 // Save current time |
|
510 TTime utcNow(0); |
|
511 utcNow.UniversalTime(); |
|
512 TTime homeNow(0); |
|
513 homeNow.HomeTime(); |
|
514 |
|
515 timer1->After(expireTime1); |
|
516 timer2->At(homeNow + expireTime2); |
|
517 timer3->AtUTC(utcNow + expireTime3); |
|
518 |
|
519 //Timer to stop active scheduler after timers under test are completed. |
|
520 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
521 p->Start(15 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); |
|
522 // Start scheduler and wait for callback to stop it |
|
523 CActiveScheduler::Start(); |
|
524 delete p; |
|
525 //See if CB has failed the case |
|
526 if (eResult1->iCaseAlreadyFailed) |
|
527 { |
|
528 aResult.SetResult( |
|
529 eResult1->iTestResult->iResult, |
|
530 eResult1->iTestResult->iResultDes ); |
|
531 } |
|
532 else if (eResult2->iCaseAlreadyFailed) |
|
533 { |
|
534 aResult.SetResult( |
|
535 eResult2->iTestResult->iResult, |
|
536 eResult2->iTestResult->iResultDes ); |
|
537 } |
|
538 else if (eResult3->iCaseAlreadyFailed) |
|
539 { |
|
540 aResult.SetResult( |
|
541 eResult3->iTestResult->iResult, |
|
542 eResult3->iTestResult->iResultDes ); |
|
543 } |
|
544 |
|
545 // Check if timers expiry happened within limits. |
|
546 // First and second timer at seconds timers max time and third at its own max time. |
|
547 // |
|
548 // Compare results against utcNow due timer's stopped time is UTC. |
|
549 else if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) && |
|
550 (utcNow + expireTime2 + TTimeIntervalMicroSeconds( KTimerAccuracyMicroSeconds)) > TTime( eResult2->iTimerStoppedTime) && |
|
551 |
|
552 (utcNow + expireTime2) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && |
|
553 (utcNow + expireTime2 + TTimeIntervalMicroSeconds( KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime) && |
|
554 |
|
555 (utcNow + expireTime3) <= TTime(eResult3->iTimerStoppedTime+KTickResolution) && |
|
556 (utcNow + expireTime3 + TTimeIntervalMicroSeconds( KTimerAccuracyMicroSeconds)) > TTime( eResult3->iTimerStoppedTime)) |
|
557 { |
|
558 _LIT( KDescription , "Passed"); |
|
559 aResult.SetResult(KErrNone, KDescription); |
|
560 } |
|
561 else |
|
562 { |
|
563 _LIT( KDescription , "Some timer was fired either too early or too late.\n"); |
|
564 aResult.SetResult(KErrGeneral, KDescription); |
|
565 } |
|
566 // Case was executed |
|
567 delete timer1; |
|
568 delete timer2; |
|
569 delete timer3; |
|
570 delete eResult1; |
|
571 delete eResult2; |
|
572 delete eResult3; |
|
573 delete res1; |
|
574 delete res2; |
|
575 delete res3; |
|
576 return KErrNone; |
|
577 } |
|
578 |
|
579 // -------------------------------------------------------------------------- |
|
580 // Start three timers At, AtUTC and After and see that they can be cancelled. |
|
581 // -------------------------------------------------------------------------- |
|
582 // |
|
583 TInt CTestCFlexTimer::NormalCancelL( TTestResult& aResult, CTestFlexTimer */*cb*/) |
|
584 { |
|
585 TTestResult *res1 = new TTestResult(); |
|
586 TTestResult *res2 = new TTestResult(); |
|
587 TTestResult *res3 = new TTestResult(); |
|
588 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
589 TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); |
|
590 TExtendedTestResult *eResult3 = new TExtendedTestResult(res3); |
|
591 eResult1->iTimerID = 0; |
|
592 eResult2->iTimerID = 1; |
|
593 eResult3->iTimerID = 2; |
|
594 CInheritedCFlexTimer2* timer1 = CInheritedCFlexTimer2::NewL( |
|
595 CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult1), 0); |
|
596 CInheritedCFlexTimer2* timer2 = CInheritedCFlexTimer2::NewL( |
|
597 CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult2), 1); |
|
598 CInheritedCFlexTimer2* timer3 = CInheritedCFlexTimer2::NewL( |
|
599 CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult3), 2); |
|
600 // Expire in 10 seconds |
|
601 TTimeIntervalMicroSeconds expireTime1(10 * 1000 * 1000); |
|
602 //just something |
|
603 TTimeIntervalMicroSeconds expireTime2(static_cast<TInt64> ((10 * 1000 |
|
604 * 1000 - static_cast<float> (10 * 1000 * 1000) |
|
605 * KDefaultWindowMultiplier))); |
|
606 TTimeIntervalMicroSeconds expireTime3(7 * 1000 * 1000); // just something |
|
607 RArray<TTimerStruct> timers; |
|
608 TTimerStruct *s1 = new TTimerStruct(); |
|
609 s1->iEResult = eResult1; |
|
610 s1->iTimer = timer1; |
|
611 timers.Append(*s1); |
|
612 TTimerStruct *s2 = new TTimerStruct(); |
|
613 s2->iEResult = eResult2; |
|
614 s2->iTimer = timer2; |
|
615 timers.Append(*s2); |
|
616 TTimerStruct *s3 = new TTimerStruct(); |
|
617 s3->iEResult = eResult3; |
|
618 s3->iTimer = timer3; |
|
619 timers.Append(*s3); |
|
620 // Save current time |
|
621 TTime utcNow(0); |
|
622 utcNow.UniversalTime(); |
|
623 TTime homeNow(0); |
|
624 homeNow.HomeTime(); |
|
625 |
|
626 timer1->After(expireTime1); |
|
627 timer2->At(homeNow + expireTime2); |
|
628 timer3->AtUTC(utcNow + expireTime3); |
|
629 |
|
630 timers[0].iCurrentlyActive = 0; //CB uses this to decide which timer to cancel; |
|
631 |
|
632 //Timer to cancel timers under test and cancel active scheduler |
|
633 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
634 p->Start(15 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( |
|
635 StopActiveScheduler)); |
|
636 CPeriodic *pp = CPeriodic::NewL(EPriorityNormal); |
|
637 s1->iStartTimer = pp; |
|
638 pp->Start(3 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( |
|
639 CancelCFlexTimerArray, &timers)); |
|
640 CPeriodic *ppp = CPeriodic::NewL(EPriorityNormal); |
|
641 s2->iStartTimer = ppp; |
|
642 ppp->Start(4 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( |
|
643 CancelCFlexTimerArray, &timers)); |
|
644 CPeriodic *pppp = CPeriodic::NewL(EPriorityNormal); |
|
645 s3->iStartTimer = pppp; |
|
646 pppp->Start(5 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( |
|
647 CancelCFlexTimerArray, &timers)); |
|
648 // Start scheduler and wait for callback to stop it |
|
649 CActiveScheduler::Start(); |
|
650 delete p; |
|
651 delete pp; |
|
652 delete ppp; |
|
653 delete pppp; |
|
654 delete s1; |
|
655 delete s2; |
|
656 delete s3; |
|
657 _LIT( KDescription , "Passed"); |
|
658 aResult.SetResult(KErrNone, KDescription); |
|
659 //See if CB has failed the case |
|
660 if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed |
|
661 || eResult3->iCaseAlreadyFailed) |
|
662 { |
|
663 if (eResult1->iCaseAlreadyFailed) |
|
664 { |
|
665 aResult.SetResult(eResult1->iTestResult->iResult, |
|
666 eResult1->iTestResult->iResultDes); |
|
667 } |
|
668 if (eResult2->iCaseAlreadyFailed) |
|
669 { |
|
670 aResult.SetResult(eResult2->iTestResult->iResult, |
|
671 eResult2->iTestResult->iResultDes); |
|
672 } |
|
673 else |
|
674 { |
|
675 aResult.SetResult(eResult3->iTestResult->iResult, |
|
676 eResult3->iTestResult->iResultDes); |
|
677 } |
|
678 } |
|
679 delete timer1; |
|
680 delete timer2; |
|
681 delete timer3; |
|
682 delete eResult1; |
|
683 delete eResult2; |
|
684 delete eResult3; |
|
685 delete res1; |
|
686 delete res2; |
|
687 delete res3; |
|
688 return KErrNone; |
|
689 } |
|
690 |
|
691 // -------------------------------------------------------------------------- |
|
692 // Start two timers and see that they expire at the same time. |
|
693 // -------------------------------------------------------------------------- |
|
694 // |
|
695 TInt CTestCFlexTimer::CancelTimerThatWouldHaveTriggeredAnotherTimerL( |
|
696 TTestResult& aResult, CTestFlexTimer */*cb*/) |
|
697 { |
|
698 TTestResult *res1 = new TTestResult(); |
|
699 TTestResult *res2 = new TTestResult(); |
|
700 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
701 TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); |
|
702 eResult1->iTimerID = 1; |
|
703 eResult2->iTimerID = 2; |
|
704 CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( |
|
705 CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult1)); |
|
706 CInheritedCFlexTimer |
|
707 * timer2 = |
|
708 CInheritedCFlexTimer::NewL( |
|
709 CActive::EPriorityStandard, |
|
710 TCallBack( |
|
711 InheritedFlexTimerCallbackKErrNoneMarkTimestampStopScheduler, |
|
712 eResult2)); |
|
713 // Expire in 10 seconds |
|
714 TTimeIntervalMicroSeconds32 expireTime1(10 * 1000 * 1000); |
|
715 //Expire within first timers default window |
|
716 TTimeIntervalMicroSeconds32 expireTime2(static_cast<TInt64> ((10 * 1000 |
|
717 * 1000 - static_cast<float> (10 * 1000 * 1000) |
|
718 * KDefaultWindowMultiplier))); |
|
719 |
|
720 // Save current time |
|
721 TTime utcNow(0); |
|
722 utcNow.UniversalTime(); |
|
723 |
|
724 timer1->After(expireTime1); |
|
725 timer2->After(expireTime2); |
|
726 |
|
727 //Timer to cancel Timer 1 |
|
728 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
729 p->Start(3 * 1000 * 1000, 1000, TCallBack(CancelCFlexTimer, timer1)); |
|
730 // Start scheduler and wait for callback to stop it |
|
731 CActiveScheduler::Start(); |
|
732 delete p; |
|
733 //See if CB has failed the case |
|
734 if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) |
|
735 { |
|
736 if (eResult1->iCaseAlreadyFailed) |
|
737 { |
|
738 aResult.SetResult(eResult1->iTestResult->iResult, |
|
739 eResult1->iTestResult->iResultDes); |
|
740 } |
|
741 else |
|
742 { |
|
743 aResult.SetResult(eResult2->iTestResult->iResult, |
|
744 eResult2->iTestResult->iResultDes); |
|
745 } |
|
746 delete timer1; |
|
747 delete timer2; |
|
748 delete eResult1; |
|
749 delete eResult2; |
|
750 delete res1; |
|
751 delete res2; |
|
752 return KErrNone; |
|
753 } |
|
754 // Get new current time |
|
755 TTime utcNow2(0); |
|
756 utcNow2.UniversalTime(); |
|
757 |
|
758 //Check if timers expiry happened within timer2 maxtime to maxtime+accuracy |
|
759 if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) |
|
760 && (utcNow + expireTime2 + TTimeIntervalMicroSeconds32( |
|
761 KTimerAccuracyMicroSeconds)) > TTime( |
|
762 eResult2->iTimerStoppedTime)) |
|
763 { |
|
764 _LIT( KDescription , "Passed"); |
|
765 aResult.SetResult(KErrNone, KDescription); |
|
766 } |
|
767 else |
|
768 { |
|
769 _LIT( KDescription , "Some timer was fired either too early or too late.\n"); |
|
770 aResult.SetResult(KErrGeneral, KDescription); |
|
771 } |
|
772 // Case was executed |
|
773 delete timer1; |
|
774 delete timer2; |
|
775 delete eResult1; |
|
776 delete eResult2; |
|
777 delete res1; |
|
778 delete res2; |
|
779 return KErrNone; |
|
780 |
|
781 } |
|
782 |
|
783 // -------------------------------------------------------------------------- |
|
784 // Start two timers and see that they expire at the same time. |
|
785 // -------------------------------------------------------------------------- |
|
786 // |
|
787 TInt CTestCFlexTimer::ConfigureCTimerOverlap1L( TTestResult& aResult, |
|
788 CTestFlexTimer */*cb*/) |
|
789 { |
|
790 TTestResult *res1 = new TTestResult(); |
|
791 TTestResult *res2 = new TTestResult(); |
|
792 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
793 TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); |
|
794 eResult1->iTimerID = 1; |
|
795 eResult2->iTimerID = 2; |
|
796 CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( |
|
797 CActive::EPriorityStandard, |
|
798 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
799 eResult1)); |
|
800 CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( |
|
801 CActive::EPriorityStandard, |
|
802 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
803 eResult2)); |
|
804 // Expire in 10 seconds |
|
805 TTimeIntervalMicroSeconds32 expireTime1(16 * 1000 * 1000); |
|
806 TTimeIntervalMicroSeconds32 window1(8 * 1000 * 1000); |
|
807 timer1->Configure(window1); |
|
808 //Expire within first timers default window |
|
809 TTimeIntervalMicroSeconds32 expireTime2(9 * 1000 * 1000); |
|
810 TTimeIntervalMicroSeconds32 window2(1 * 1000 * 1000); |
|
811 timer2->Configure(window2); |
|
812 |
|
813 // Save current time |
|
814 TTime utcNow(0); |
|
815 utcNow.UniversalTime(); |
|
816 |
|
817 timer1->After(expireTime1); |
|
818 timer2->After(expireTime2); |
|
819 |
|
820 //Timer to stop active scheduler after timers under test are completed. |
|
821 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
822 p->Start(17 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); |
|
823 // Start scheduler and wait for callback to stop it |
|
824 CActiveScheduler::Start(); |
|
825 delete p; |
|
826 //See if CB has failed the case |
|
827 if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) |
|
828 { |
|
829 if (eResult1->iCaseAlreadyFailed) |
|
830 { |
|
831 aResult.SetResult(eResult1->iTestResult->iResult, |
|
832 eResult1->iTestResult->iResultDes); |
|
833 } |
|
834 else |
|
835 { |
|
836 aResult.SetResult(eResult2->iTestResult->iResult, |
|
837 eResult2->iTestResult->iResultDes); |
|
838 } |
|
839 delete timer1; |
|
840 delete timer2; |
|
841 delete eResult1; |
|
842 delete eResult2; |
|
843 delete res1; |
|
844 delete res2; |
|
845 return KErrNone; |
|
846 } |
|
847 // Get new current time |
|
848 TTime utcNow2(0); |
|
849 utcNow2.UniversalTime(); |
|
850 |
|
851 //Check if timers expiry happened within timer2 maxtime to maxtime+accuracy |
|
852 if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) |
|
853 && (utcNow + expireTime2 + TTimeIntervalMicroSeconds32( |
|
854 KTimerAccuracyMicroSeconds)) > TTime( |
|
855 eResult2->iTimerStoppedTime) && |
|
856 |
|
857 (utcNow + expireTime2) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow |
|
858 + expireTime2 + TTimeIntervalMicroSeconds32( |
|
859 KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime)) |
|
860 { |
|
861 _LIT( KDescription , "Passed"); |
|
862 aResult.SetResult(KErrNone, KDescription); |
|
863 } |
|
864 else |
|
865 { |
|
866 _LIT( KDescription , "Some timer was fired either too early or too late.\n"); |
|
867 aResult.SetResult(KErrGeneral, KDescription); |
|
868 } |
|
869 // Case was executed |
|
870 delete timer1; |
|
871 delete timer2; |
|
872 delete eResult1; |
|
873 delete eResult2; |
|
874 delete res1; |
|
875 delete res2; |
|
876 return KErrNone; |
|
877 } |
|
878 |
|
879 // -------------------------------------------------------------------------- |
|
880 // Start two timers and see that they expire at the same time. |
|
881 // -------------------------------------------------------------------------- |
|
882 // |
|
883 TInt CTestCFlexTimer::ConfigureCTimerOverlap2L( TTestResult& aResult, |
|
884 CTestFlexTimer */*cb*/) |
|
885 { |
|
886 TTestResult *res1 = new TTestResult(); |
|
887 TTestResult *res2 = new TTestResult(); |
|
888 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
889 TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); |
|
890 eResult1->iTimerID = 1; |
|
891 eResult2->iTimerID = 2; |
|
892 CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( |
|
893 CActive::EPriorityStandard, |
|
894 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
895 eResult1)); |
|
896 CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( |
|
897 CActive::EPriorityStandard, |
|
898 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
899 eResult2)); |
|
900 // Expire in 10 seconds |
|
901 TTimeIntervalMicroSeconds expireTime1(16 * 1000 * 1000); |
|
902 TTimeIntervalMicroSeconds window1(8 * 1000 * 1000); |
|
903 timer1->Configure(window1); |
|
904 //Expire within first timers default window |
|
905 TTimeIntervalMicroSeconds expireTime2(17 * 1000 * 1000); |
|
906 TTimeIntervalMicroSeconds window2(1 * 1000 * 1000); |
|
907 timer2->Configure(window2); |
|
908 |
|
909 // Save current time |
|
910 TTime utcNow(0); |
|
911 utcNow.UniversalTime(); |
|
912 |
|
913 timer1->After(expireTime1); |
|
914 timer2->After(expireTime2); |
|
915 |
|
916 //Timer to stop active scheduler after timers under test are completed. |
|
917 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
918 p->Start(18 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); |
|
919 // Start scheduler and wait for callback to stop it |
|
920 CActiveScheduler::Start(); |
|
921 delete p; |
|
922 //See if CB has failed the case |
|
923 if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) |
|
924 { |
|
925 if (eResult1->iCaseAlreadyFailed) |
|
926 { |
|
927 aResult.SetResult(eResult1->iTestResult->iResult, |
|
928 eResult1->iTestResult->iResultDes); |
|
929 } |
|
930 else |
|
931 { |
|
932 aResult.SetResult(eResult2->iTestResult->iResult, |
|
933 eResult2->iTestResult->iResultDes); |
|
934 } |
|
935 delete timer1; |
|
936 delete timer2; |
|
937 delete eResult1; |
|
938 delete eResult2; |
|
939 delete res1; |
|
940 delete res2; |
|
941 return KErrNone; |
|
942 } |
|
943 // Get new current time |
|
944 TTime utcNow2(0); |
|
945 utcNow2.UniversalTime(); |
|
946 |
|
947 //Check if timers expiry happened within timer1 maxtime to maxtime+accuracy |
|
948 if ((utcNow + expireTime1) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) |
|
949 && (utcNow + expireTime1 + TTimeIntervalMicroSeconds( |
|
950 KTimerAccuracyMicroSeconds)) > TTime( |
|
951 eResult2->iTimerStoppedTime) && |
|
952 |
|
953 (utcNow + expireTime1) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow |
|
954 + expireTime1 + TTimeIntervalMicroSeconds( |
|
955 KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime)) |
|
956 { |
|
957 _LIT( KDescription , "Passed"); |
|
958 aResult.SetResult(KErrNone, KDescription); |
|
959 } |
|
960 else |
|
961 { |
|
962 _LIT( KDescription , "Some timer was fired either too early or too late.\n"); |
|
963 aResult.SetResult(KErrGeneral, KDescription); |
|
964 } |
|
965 // Case was executed |
|
966 delete timer1; |
|
967 delete timer2; |
|
968 delete eResult1; |
|
969 delete eResult2; |
|
970 delete res1; |
|
971 delete res2; |
|
972 return KErrNone; |
|
973 } |
|
974 |
|
975 // -------------------------------------------------------------------------- |
|
976 // Start two timers and see that they expire at the same time. |
|
977 // -------------------------------------------------------------------------- |
|
978 // |
|
979 TInt CTestCFlexTimer::ConfigureCTimerOverlap3L( TTestResult& aResult, |
|
980 CTestFlexTimer */*cb*/) |
|
981 { |
|
982 TTestResult *res1 = new TTestResult(); |
|
983 TTestResult *res2 = new TTestResult(); |
|
984 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
985 TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); |
|
986 eResult1->iTimerID = 1; |
|
987 eResult2->iTimerID = 2; |
|
988 CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( |
|
989 CActive::EPriorityStandard, |
|
990 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
991 eResult1)); |
|
992 CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( |
|
993 CActive::EPriorityStandard, |
|
994 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
995 eResult2)); |
|
996 // Expire in 10 seconds |
|
997 TTimeIntervalMicroSeconds expireTime1(16 * 1000 * 1000); |
|
998 TTimeIntervalMicroSeconds window1(16 * 1000 * 1000); |
|
999 TTimeIntervalMicroSeconds32 zeroWindow(0); |
|
1000 timer1->Configure(zeroWindow); |
|
1001 timer1->Configure(window1); |
|
1002 //Expire within first timers default window |
|
1003 TTimeIntervalMicroSeconds expireTime2(8 * 1000 * 1000); |
|
1004 TTimeIntervalMicroSeconds window2(0); |
|
1005 timer2->Configure(window2); |
|
1006 |
|
1007 // Save current time |
|
1008 TTime utcNow(0); |
|
1009 utcNow.UniversalTime(); |
|
1010 |
|
1011 timer1->After(expireTime1); |
|
1012 timer2->After(expireTime2); |
|
1013 |
|
1014 //Timer to stop active scheduler after timers under test are completed. |
|
1015 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
1016 p->Start(18 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); |
|
1017 // Start scheduler and wait for callback to stop it |
|
1018 CActiveScheduler::Start(); |
|
1019 delete p; |
|
1020 //See if CB has failed the case |
|
1021 if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) |
|
1022 { |
|
1023 if (eResult1->iCaseAlreadyFailed) |
|
1024 { |
|
1025 aResult.SetResult(eResult1->iTestResult->iResult, |
|
1026 eResult1->iTestResult->iResultDes); |
|
1027 } |
|
1028 else |
|
1029 { |
|
1030 aResult.SetResult(eResult2->iTestResult->iResult, |
|
1031 eResult2->iTestResult->iResultDes); |
|
1032 } |
|
1033 delete timer1; |
|
1034 delete timer2; |
|
1035 delete eResult1; |
|
1036 delete eResult2; |
|
1037 delete res1; |
|
1038 delete res2; |
|
1039 return KErrNone; |
|
1040 } |
|
1041 // Get new current time |
|
1042 TTime utcNow2(0); |
|
1043 utcNow2.UniversalTime(); |
|
1044 |
|
1045 //Check if timers expiry happened within timer2 maxtime to maxtime+accuracy |
|
1046 if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) |
|
1047 && (utcNow + expireTime2 + TTimeIntervalMicroSeconds( |
|
1048 KTimerAccuracyMicroSeconds)) > TTime( |
|
1049 eResult2->iTimerStoppedTime) && |
|
1050 |
|
1051 (utcNow + expireTime2) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow |
|
1052 + expireTime2 + TTimeIntervalMicroSeconds( |
|
1053 KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime)) |
|
1054 { |
|
1055 _LIT( KDescription , "Passed"); |
|
1056 aResult.SetResult(KErrNone, KDescription); |
|
1057 } |
|
1058 else |
|
1059 { |
|
1060 _LIT( KDescription , "Some timer was fired either too early or too late.\n"); |
|
1061 aResult.SetResult(KErrGeneral, KDescription); |
|
1062 } |
|
1063 // Case was executed |
|
1064 delete timer1; |
|
1065 delete timer2; |
|
1066 delete eResult1; |
|
1067 delete eResult2; |
|
1068 delete res1; |
|
1069 delete res2; |
|
1070 return KErrNone; |
|
1071 } |
|
1072 |
|
1073 // -------------------------------------------------------------------------- |
|
1074 // Start two timers and see that they expire at their own max time |
|
1075 // -------------------------------------------------------------------------- |
|
1076 // |
|
1077 TInt CTestCFlexTimer::ConfigureCTimerNonOverlap1L( TTestResult& aResult, |
|
1078 CTestFlexTimer */*cb*/) |
|
1079 { |
|
1080 TTestResult *res1 = new TTestResult(); |
|
1081 TTestResult *res2 = new TTestResult(); |
|
1082 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
1083 TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); |
|
1084 eResult1->iTimerID = 1; |
|
1085 eResult2->iTimerID = 2; |
|
1086 CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( |
|
1087 CActive::EPriorityStandard, |
|
1088 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
1089 eResult1)); |
|
1090 CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( |
|
1091 CActive::EPriorityStandard, |
|
1092 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
1093 eResult2)); |
|
1094 // Expire in 10 seconds |
|
1095 TTimeIntervalMicroSeconds expireTime1(16 * 1000 * 1000); |
|
1096 TTimeIntervalMicroSeconds window1(0); |
|
1097 timer1->Configure(window1); |
|
1098 //Expire within first timers default window |
|
1099 TTimeIntervalMicroSeconds expireTime2(15 * 1000 * 1000); |
|
1100 TTimeIntervalMicroSeconds window2(1 * 1000 * 1000); |
|
1101 timer2->Configure(window2); |
|
1102 |
|
1103 // Save current time |
|
1104 TTime utcNow(0); |
|
1105 utcNow.UniversalTime(); |
|
1106 |
|
1107 timer1->After(expireTime1); |
|
1108 timer2->After(expireTime2); |
|
1109 |
|
1110 //Timer to stop active scheduler after timers under test are completed. |
|
1111 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
1112 p->Start(18 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); |
|
1113 // Start scheduler and wait for callback to stop it |
|
1114 CActiveScheduler::Start(); |
|
1115 delete p; |
|
1116 //See if CB has failed the case |
|
1117 if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) |
|
1118 { |
|
1119 if (eResult1->iCaseAlreadyFailed) |
|
1120 { |
|
1121 aResult.SetResult(eResult1->iTestResult->iResult, |
|
1122 eResult1->iTestResult->iResultDes); |
|
1123 } |
|
1124 else |
|
1125 { |
|
1126 aResult.SetResult(eResult2->iTestResult->iResult, |
|
1127 eResult2->iTestResult->iResultDes); |
|
1128 } |
|
1129 delete timer1; |
|
1130 delete timer2; |
|
1131 delete eResult1; |
|
1132 delete eResult2; |
|
1133 delete res1; |
|
1134 delete res2; |
|
1135 return KErrNone; |
|
1136 } |
|
1137 // Get new current time |
|
1138 TTime utcNow2(0); |
|
1139 utcNow2.UniversalTime(); |
|
1140 |
|
1141 //Check if timer expired within their own maxtime to maxtime+accuracy |
|
1142 if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) |
|
1143 && (utcNow + expireTime2 + TTimeIntervalMicroSeconds( |
|
1144 KTimerAccuracyMicroSeconds)) > TTime( |
|
1145 eResult2->iTimerStoppedTime) && |
|
1146 |
|
1147 (utcNow + expireTime1) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow |
|
1148 + expireTime1 + TTimeIntervalMicroSeconds( |
|
1149 KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime)) |
|
1150 { |
|
1151 _LIT( KDescription , "Passed"); |
|
1152 aResult.SetResult(KErrNone, KDescription); |
|
1153 } |
|
1154 else |
|
1155 { |
|
1156 _LIT( KDescription , "Some timer was fired either too early or too late.\n"); |
|
1157 aResult.SetResult(KErrGeneral, KDescription); |
|
1158 } |
|
1159 // Case was executed |
|
1160 delete timer1; |
|
1161 delete timer2; |
|
1162 delete eResult1; |
|
1163 delete eResult2; |
|
1164 delete res1; |
|
1165 delete res2; |
|
1166 return KErrNone; |
|
1167 } |
|
1168 |
|
1169 // -------------------------------------------------------------------------- |
|
1170 // Start two timers and see that they expire at their own max time |
|
1171 // -------------------------------------------------------------------------- |
|
1172 // |
|
1173 TInt CTestCFlexTimer::ConfigureCTimerNonOverlap2L( TTestResult& aResult, |
|
1174 CTestFlexTimer */*cb*/) |
|
1175 { |
|
1176 TTestResult *res1 = new TTestResult(); |
|
1177 TTestResult *res2 = new TTestResult(); |
|
1178 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
1179 TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); |
|
1180 eResult1->iTimerID = 1; |
|
1181 eResult2->iTimerID = 2; |
|
1182 CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( |
|
1183 CActive::EPriorityStandard, |
|
1184 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
1185 eResult1)); |
|
1186 CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( |
|
1187 CActive::EPriorityStandard, |
|
1188 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
1189 eResult2)); |
|
1190 // Expire in 10 seconds |
|
1191 TTimeIntervalMicroSeconds expireTime1(16 * 1000 * 1000); |
|
1192 TTimeIntervalMicroSeconds window1(16 * 1000 * 1000); |
|
1193 timer1->Configure(window1); |
|
1194 window1 = 8 * 1000 * 1000; |
|
1195 timer1->Configure(window1); |
|
1196 //Expire within first timers default window |
|
1197 TTimeIntervalMicroSeconds expireTime2(7 * 1000 * 1000); |
|
1198 TTimeIntervalMicroSeconds window2(4 * 1000 * 1000); |
|
1199 timer2->Configure(window2); |
|
1200 |
|
1201 // Save current time |
|
1202 TTime utcNow(0); |
|
1203 utcNow.UniversalTime(); |
|
1204 |
|
1205 timer1->After(expireTime1); |
|
1206 timer2->After(expireTime2); |
|
1207 |
|
1208 //Timer to stop active scheduler after timers under test are completed. |
|
1209 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
1210 p->Start(18 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); |
|
1211 // Start scheduler and wait for callback to stop it |
|
1212 CActiveScheduler::Start(); |
|
1213 delete p; |
|
1214 //See if CB has failed the case |
|
1215 if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) |
|
1216 { |
|
1217 if (eResult1->iCaseAlreadyFailed) |
|
1218 { |
|
1219 aResult.SetResult(eResult1->iTestResult->iResult, |
|
1220 eResult1->iTestResult->iResultDes); |
|
1221 } |
|
1222 else |
|
1223 { |
|
1224 aResult.SetResult(eResult2->iTestResult->iResult, |
|
1225 eResult2->iTestResult->iResultDes); |
|
1226 } |
|
1227 delete timer1; |
|
1228 delete timer2; |
|
1229 delete eResult1; |
|
1230 delete eResult2; |
|
1231 delete res1; |
|
1232 delete res2; |
|
1233 return KErrNone; |
|
1234 } |
|
1235 // Get new current time |
|
1236 TTime utcNow2(0); |
|
1237 utcNow2.UniversalTime(); |
|
1238 |
|
1239 //Check if timer expired within their own maxtime to maxtime+accuracy |
|
1240 if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) |
|
1241 && (utcNow + expireTime2 + TTimeIntervalMicroSeconds( |
|
1242 KTimerAccuracyMicroSeconds)) > TTime( |
|
1243 eResult2->iTimerStoppedTime) && |
|
1244 |
|
1245 (utcNow + expireTime1) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow |
|
1246 + expireTime1 + TTimeIntervalMicroSeconds( |
|
1247 KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime)) |
|
1248 { |
|
1249 _LIT( KDescription , "Passed"); |
|
1250 aResult.SetResult(KErrNone, KDescription); |
|
1251 } |
|
1252 else |
|
1253 { |
|
1254 _LIT( KDescription , "Some timer was fired either too early or too late.\n"); |
|
1255 aResult.SetResult(KErrGeneral, KDescription); |
|
1256 } |
|
1257 // Case was executed |
|
1258 delete timer1; |
|
1259 delete timer2; |
|
1260 delete eResult1; |
|
1261 delete eResult2; |
|
1262 delete res1; |
|
1263 delete res2; |
|
1264 return KErrNone; |
|
1265 } |
|
1266 |
|
1267 // -------------------------------------------------------------------------- |
|
1268 // Start three timers and see that system time change aborts At & AtUtc timers |
|
1269 // -------------------------------------------------------------------------- |
|
1270 // |
|
1271 TInt CTestCFlexTimer::SystemTimeChangesL( TTestResult& aResult, |
|
1272 CTestFlexTimer */*cb*/) |
|
1273 { |
|
1274 TTestResult *res1 = new TTestResult(); |
|
1275 TTestResult *res2 = new TTestResult(); |
|
1276 TTestResult *res3 = new TTestResult(); |
|
1277 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
1278 TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); |
|
1279 TExtendedTestResult *eResult3 = new TExtendedTestResult(res3); |
|
1280 eResult1->iTimerID = 1; |
|
1281 eResult2->iTimerID = 2; |
|
1282 eResult3->iTimerID = 3; |
|
1283 CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( |
|
1284 CActive::EPriorityStandard, TCallBack( |
|
1285 InheritedFlexTimerCallbackKErrAbort, eResult1)); |
|
1286 CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( |
|
1287 CActive::EPriorityStandard, TCallBack( |
|
1288 InheritedFlexTimerCallbackKErrAbort, eResult2)); |
|
1289 CInheritedCFlexTimer* timer3 = CInheritedCFlexTimer::NewL( |
|
1290 CActive::EPriorityStandard, |
|
1291 TCallBack(InheritedFlexTimerCallbackStopSchedulerKErrNone, |
|
1292 eResult3)); |
|
1293 // Expire in 10, 11 and 12 seconds. One and two are to be aborted |
|
1294 TTimeIntervalMicroSeconds32 expireTime1(10 * 1000 * 1000); |
|
1295 TTimeIntervalMicroSeconds32 expireTime2(11 * 1000 * 1000); |
|
1296 TTimeIntervalMicroSeconds32 expireTime3(12 * 1000 * 1000); |
|
1297 |
|
1298 |
|
1299 // Save current time as ticks. This use case will change system time |
|
1300 // and timestamps will not be exact -- ticks are. |
|
1301 TUint startTicks( User::TickCount() ); |
|
1302 |
|
1303 TTime now, nowUtc; |
|
1304 now.HomeTime(); |
|
1305 nowUtc.UniversalTime(); |
|
1306 |
|
1307 timer1->At(now + expireTime1); |
|
1308 timer2->AtUTC(nowUtc + expireTime2); |
|
1309 timer3->After(expireTime3); |
|
1310 |
|
1311 //Timer to change system time after timers have been running for a while |
|
1312 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
1313 p->Start(5 * 1000 * 1000, 1000, TCallBack(ChangeSystemTime1sAndCancel, p)); |
|
1314 // Start scheduler and wait for callback to stop it |
|
1315 CActiveScheduler::Start(); |
|
1316 delete p; |
|
1317 //See if CB has failed the case |
|
1318 if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed |
|
1319 || eResult3->iCaseAlreadyFailed) |
|
1320 { |
|
1321 if (eResult1->iCaseAlreadyFailed) |
|
1322 { |
|
1323 aResult.SetResult(eResult1->iTestResult->iResult, |
|
1324 eResult1->iTestResult->iResultDes); |
|
1325 } |
|
1326 else if (eResult2->iCaseAlreadyFailed) |
|
1327 { |
|
1328 aResult.SetResult(eResult2->iTestResult->iResult, |
|
1329 eResult2->iTestResult->iResultDes); |
|
1330 } |
|
1331 else |
|
1332 { |
|
1333 aResult.SetResult(eResult3->iTestResult->iResult, |
|
1334 eResult3->iTestResult->iResultDes); |
|
1335 } |
|
1336 delete timer1; |
|
1337 delete timer2; |
|
1338 delete timer3; |
|
1339 delete eResult1; |
|
1340 delete eResult2; |
|
1341 delete eResult3; |
|
1342 delete res1; |
|
1343 delete res2; |
|
1344 delete res3; |
|
1345 return KErrNone; |
|
1346 } |
|
1347 // Get new current time |
|
1348 TUint endTicks( User::TickCount() ); |
|
1349 TInt delay( ( endTicks - startTicks ) * KTickInMicroSeconds ); |
|
1350 |
|
1351 //Check if timers expiry happened within timer3 maxtime to maxtime+accuracy |
|
1352 if ( delay+KTickResolution >= expireTime3.Int() && |
|
1353 delay < expireTime3.Int() + KTimerAccuracyMicroSeconds ) |
|
1354 { |
|
1355 _LIT( KDescription , "Passed"); |
|
1356 aResult.SetResult(KErrNone, KDescription); |
|
1357 } |
|
1358 else |
|
1359 { |
|
1360 _LIT( KDescription , "Some timer was fired either too early or too late.\n"); |
|
1361 aResult.SetResult(KErrGeneral, KDescription); |
|
1362 } |
|
1363 // Case was executed |
|
1364 delete timer1; |
|
1365 delete timer2; |
|
1366 delete timer3; |
|
1367 delete eResult1; |
|
1368 delete eResult2; |
|
1369 delete eResult3; |
|
1370 delete res1; |
|
1371 delete res2; |
|
1372 delete res3; |
|
1373 |
|
1374 return KErrNone; |
|
1375 } |
|
1376 |
|
1377 // -------------------------------------------------------------------------- |
|
1378 // Start three timers and see that time zone change aborts At & AtUtc timers |
|
1379 // -------------------------------------------------------------------------- |
|
1380 // |
|
1381 TInt CTestCFlexTimer::TimeZoneChangesL( TTestResult& aResult, |
|
1382 CTestFlexTimer */*cb*/) |
|
1383 { |
|
1384 TTestResult *res1 = new TTestResult(); |
|
1385 TTestResult *res2 = new TTestResult(); |
|
1386 TTestResult *res3 = new TTestResult(); |
|
1387 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
1388 TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); |
|
1389 TExtendedTestResult *eResult3 = new TExtendedTestResult(res3); |
|
1390 eResult1->iTimerID = 1; |
|
1391 eResult2->iTimerID = 2; |
|
1392 eResult3->iTimerID = 3; |
|
1393 CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( |
|
1394 CActive::EPriorityStandard, TCallBack( |
|
1395 InheritedFlexTimerCallbackKErrAbort, eResult1)); |
|
1396 CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( |
|
1397 CActive::EPriorityStandard, TCallBack( |
|
1398 InheritedFlexTimerCallbackKErrAbort, eResult2)); |
|
1399 CInheritedCFlexTimer* timer3 = CInheritedCFlexTimer::NewL( |
|
1400 CActive::EPriorityStandard, |
|
1401 TCallBack(InheritedFlexTimerCallbackStopSchedulerKErrNone, |
|
1402 eResult3)); |
|
1403 // Expire in 10, 11 and 12 seconds. One and two are to be aborted |
|
1404 TTimeIntervalMicroSeconds32 expireTime1(10 * 1000 * 1000); |
|
1405 TTimeIntervalMicroSeconds32 expireTime2(11 * 1000 * 1000); |
|
1406 TTimeIntervalMicroSeconds32 expireTime3(12 * 1000 * 1000); |
|
1407 |
|
1408 // Save current time as ticks. This use case will change system time |
|
1409 // and timestamps will not be exact -- ticks are. |
|
1410 TUint startTicks( User::TickCount() ); |
|
1411 |
|
1412 TTime now, nowUtc; |
|
1413 now.HomeTime(); |
|
1414 nowUtc.UniversalTime(); |
|
1415 |
|
1416 timer1->At(now + expireTime1); |
|
1417 timer2->AtUTC(nowUtc + expireTime2); |
|
1418 timer3->After(expireTime3); |
|
1419 |
|
1420 //Timer to change system time after timers have been running for a while |
|
1421 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
1422 p->Start(5 * 1000 * 1000, 1000, TCallBack(ChangeTimeZoneAndCancel, p)); |
|
1423 // Start scheduler and wait for callback to stop it |
|
1424 CActiveScheduler::Start(); |
|
1425 delete p; |
|
1426 //See if CB has failed the case |
|
1427 if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed |
|
1428 || eResult3->iCaseAlreadyFailed) |
|
1429 { |
|
1430 if (eResult1->iCaseAlreadyFailed) |
|
1431 { |
|
1432 aResult.SetResult(eResult1->iTestResult->iResult, |
|
1433 eResult1->iTestResult->iResultDes); |
|
1434 } |
|
1435 else if (eResult2->iCaseAlreadyFailed) |
|
1436 { |
|
1437 aResult.SetResult(eResult2->iTestResult->iResult, |
|
1438 eResult2->iTestResult->iResultDes); |
|
1439 } |
|
1440 else |
|
1441 { |
|
1442 aResult.SetResult(eResult3->iTestResult->iResult, |
|
1443 eResult3->iTestResult->iResultDes); |
|
1444 } |
|
1445 delete timer1; |
|
1446 delete timer2; |
|
1447 delete timer3; |
|
1448 delete eResult1; |
|
1449 delete eResult2; |
|
1450 delete eResult3; |
|
1451 delete res1; |
|
1452 delete res2; |
|
1453 delete res3; |
|
1454 return KErrNone; |
|
1455 } |
|
1456 |
|
1457 // Get new current time |
|
1458 TUint endTicks( User::TickCount() ); |
|
1459 TInt delay( ( endTicks - startTicks ) * KTickInMicroSeconds ); |
|
1460 |
|
1461 //Check if timers expiry happened within timer3 maxtime to maxtime+accuracy |
|
1462 if ( delay+KTickResolution >= expireTime3.Int() && |
|
1463 delay < expireTime3.Int() + KTimerAccuracyMicroSeconds ) |
|
1464 { |
|
1465 _LIT( KDescription , "Passed"); |
|
1466 aResult.SetResult(KErrNone, KDescription); |
|
1467 } |
|
1468 else |
|
1469 { |
|
1470 _LIT( KDescription , "Some timer was fired either too early or too late.\n"); |
|
1471 aResult.SetResult(KErrGeneral, KDescription); |
|
1472 } |
|
1473 // Case was executed |
|
1474 delete timer1; |
|
1475 delete timer2; |
|
1476 delete timer3; |
|
1477 delete eResult1; |
|
1478 delete eResult2; |
|
1479 delete eResult3; |
|
1480 delete res1; |
|
1481 delete res2; |
|
1482 delete res3; |
|
1483 |
|
1484 return KErrNone; |
|
1485 } |
|
1486 |
|
1487 // -------------------------------------------------------------------------- |
|
1488 // Start timers with dumbass parameters |
|
1489 // -------------------------------------------------------------------------- |
|
1490 // |
|
1491 TInt CTestCFlexTimer::DumbAssParametersForCTimerL( TTestResult& aResult, |
|
1492 CTestFlexTimer */*cb*/) |
|
1493 { |
|
1494 TTestResult *res = new TTestResult(); |
|
1495 TExtendedTestResult *eResult = new TExtendedTestResult(res); |
|
1496 eResult->iTimerID = 1; |
|
1497 CInheritedCFlexTimer |
|
1498 * timer = CInheritedCFlexTimer::NewL(CActive::EPriorityStandard, |
|
1499 TCallBack( |
|
1500 InheritedFlexTimerCallbackStopSchedulerKErrNone, |
|
1501 eResult)); |
|
1502 |
|
1503 /*32 bit IF called with 1 parameter*/ |
|
1504 /***********************************/ |
|
1505 // Expire in 3 seconds. |
|
1506 TTimeIntervalMicroSeconds32 expireTime(1); |
|
1507 // Save current time |
|
1508 TTime now(0); |
|
1509 now.HomeTime(); |
|
1510 timer->After(expireTime); |
|
1511 // Start scheduler and wait for callback to stop it |
|
1512 CActiveScheduler::Start(); |
|
1513 //See if CB has failed the case |
|
1514 if (eResult->iCaseAlreadyFailed) |
|
1515 { |
|
1516 aResult.SetResult(eResult->iTestResult->iResult, |
|
1517 eResult->iTestResult->iResultDes); |
|
1518 delete timer; |
|
1519 delete eResult; |
|
1520 delete res; |
|
1521 return KErrNone; |
|
1522 } |
|
1523 // Get new current time |
|
1524 TTime now2(0); |
|
1525 now2.HomeTime(); |
|
1526 //Check if timers expiry happened immediately. |
|
1527 if (!((now + expireTime) <= now2 && (now + expireTime |
|
1528 + TTimeIntervalMicroSeconds32(KTimerAccuracyMicroSeconds)) > now2)) |
|
1529 { |
|
1530 _LIT( KDescription , "32 bit After(1) failed.\n"); |
|
1531 aResult.SetResult(KErrGeneral, KDescription); |
|
1532 delete timer; |
|
1533 delete eResult; |
|
1534 delete res; |
|
1535 return KErrNone; |
|
1536 } |
|
1537 |
|
1538 /*32 bit IF called with max parameter*/ |
|
1539 /***********************************/ |
|
1540 expireTime = 0x7FFFFFFF; |
|
1541 now.HomeTime(); |
|
1542 delete timer; |
|
1543 timer = NULL; |
|
1544 timer = CInheritedCFlexTimer::NewL(CActive::EPriorityStandard, TCallBack( |
|
1545 NotCalledCB, eResult)); |
|
1546 timer->After(expireTime); |
|
1547 //Timer to change system time after timers have been running for a while |
|
1548 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
1549 p->Start(5 * 1000 * 1000, 1000, TCallBack( |
|
1550 CancelCFlexTimerAndStopActiveScheduler, timer)); |
|
1551 // Start scheduler and wait for callback to stop it |
|
1552 CActiveScheduler::Start(); |
|
1553 p->Cancel(); |
|
1554 delete p; |
|
1555 //See if CB has failed the case |
|
1556 if (eResult->iCaseAlreadyFailed) |
|
1557 { |
|
1558 aResult.SetResult(eResult->iTestResult->iResult, |
|
1559 eResult->iTestResult->iResultDes); |
|
1560 delete timer; |
|
1561 delete eResult; |
|
1562 delete res; |
|
1563 return KErrNone; |
|
1564 } |
|
1565 |
|
1566 /*64 bit IF called with 1 parameter*/ |
|
1567 /***********************************/ |
|
1568 // Expire in 3 seconds. |
|
1569 TTimeIntervalMicroSeconds expireTime64(1); |
|
1570 // Save current time |
|
1571 now.HomeTime(); |
|
1572 delete timer; |
|
1573 timer = NULL; |
|
1574 timer = CInheritedCFlexTimer::NewL(CActive::EPriorityStandard, TCallBack( |
|
1575 InheritedFlexTimerCallbackStopSchedulerKErrNone, eResult)); |
|
1576 timer->After(expireTime64); |
|
1577 // Start scheduler and wait for callback to stop it |
|
1578 CActiveScheduler::Start(); |
|
1579 //See if CB has failed the case |
|
1580 if (eResult->iCaseAlreadyFailed) |
|
1581 { |
|
1582 aResult.SetResult(eResult->iTestResult->iResult, |
|
1583 eResult->iTestResult->iResultDes); |
|
1584 delete timer; |
|
1585 delete eResult; |
|
1586 delete res; |
|
1587 return KErrNone; |
|
1588 } |
|
1589 // Get new current time |
|
1590 now2.HomeTime(); |
|
1591 //Check if timers expiry happened immediately |
|
1592 if (!((now + expireTime64) <= now2 && (now + expireTime64 |
|
1593 + TTimeIntervalMicroSeconds(KTimerAccuracyMicroSeconds)) > now2)) |
|
1594 { |
|
1595 _LIT( KDescription , "64 bit After(1) failed.\n"); |
|
1596 aResult.SetResult(KErrGeneral, KDescription); |
|
1597 delete timer; |
|
1598 delete eResult; |
|
1599 delete res; |
|
1600 return KErrNone; |
|
1601 } |
|
1602 // Finally if we are here set whole case to passed. |
|
1603 _LIT( KDescription , "Passed"); |
|
1604 aResult.SetResult(KErrNone, KDescription); |
|
1605 delete timer; |
|
1606 delete eResult; |
|
1607 delete res; |
|
1608 return KErrNone; |
|
1609 } |
|
1610 |
|
1611 // -------------------------------------------------------------------------- |
|
1612 // Start timers with dumbass parameters |
|
1613 // -------------------------------------------------------------------------- |
|
1614 // |
|
1615 TInt CTestCFlexTimer::DumbAssParametersForCTimerZero32bitL( TTestResult& aResult, |
|
1616 CTestFlexTimer* /* cb */ ) |
|
1617 { |
|
1618 TTestResult *res = new TTestResult(); |
|
1619 TExtendedTestResult *eResult = new TExtendedTestResult(res); |
|
1620 eResult->iTimerID = 1; |
|
1621 |
|
1622 /*32 bit IF called with 0 parameter*/ |
|
1623 /***********************************/ |
|
1624 const TTimeIntervalMicroSeconds32 kExpireTime32(0); |
|
1625 |
|
1626 // Save current time |
|
1627 TTime startTime; |
|
1628 startTime.HomeTime(); |
|
1629 |
|
1630 CInheritedCFlexTimer *timer = CInheritedCFlexTimer::NewL( |
|
1631 CActive::EPriorityStandard, |
|
1632 TCallBack( InheritedFlexTimerCallbackStopSchedulerKErrNone, eResult ) ); |
|
1633 |
|
1634 timer->After( kExpireTime32 ); |
|
1635 |
|
1636 CActiveScheduler::Start(); // WAIT timer to expire |
|
1637 |
|
1638 TTime endTime; |
|
1639 endTime.HomeTime(); |
|
1640 |
|
1641 TTimeIntervalMicroSeconds delay = endTime.MicroSecondsFrom( startTime ); |
|
1642 |
|
1643 if ( delay.Int64() < kExpireTime32.Int() || |
|
1644 delay.Int64() > kExpireTime32.Int() + KTimerAccuracyMicroSeconds ) |
|
1645 { |
|
1646 aResult.SetResult( KErrGeneral, _L("Wrong expiration") ); |
|
1647 } |
|
1648 else |
|
1649 { |
|
1650 aResult.SetResult( KErrNone, _L("Test case passed") ); |
|
1651 } |
|
1652 |
|
1653 delete timer; |
|
1654 delete eResult; |
|
1655 delete res; |
|
1656 return KErrNone; |
|
1657 } |
|
1658 |
|
1659 // -------------------------------------------------------------------------- |
|
1660 // Start timers with dumbass parameters |
|
1661 // -------------------------------------------------------------------------- |
|
1662 // |
|
1663 TInt CTestCFlexTimer::DumbAssParametersForCTimerZero64bitL( TTestResult& aResult, |
|
1664 CTestFlexTimer* /* cb */ ) |
|
1665 { |
|
1666 TTestResult *res = new TTestResult(); |
|
1667 TExtendedTestResult *eResult = new TExtendedTestResult(res); |
|
1668 eResult->iTimerID = 1; |
|
1669 |
|
1670 /*64 bit IF called with 0 parameter*/ |
|
1671 /***********************************/ |
|
1672 const TTimeIntervalMicroSeconds kExpireTime64(0); |
|
1673 |
|
1674 // Save current time |
|
1675 TTime startTime; |
|
1676 startTime.HomeTime(); |
|
1677 |
|
1678 CInheritedCFlexTimer *timer = CInheritedCFlexTimer::NewL( |
|
1679 CActive::EPriorityStandard, TCallBack(InheritedFlexTimerCallbackStopSchedulerKErrNone, eResult)); |
|
1680 |
|
1681 timer->After(kExpireTime64); |
|
1682 CActiveScheduler::Start(); // WAIT timer to expire |
|
1683 |
|
1684 TTime endTime; |
|
1685 endTime.HomeTime(); |
|
1686 |
|
1687 TTimeIntervalMicroSeconds delay = endTime.MicroSecondsFrom( startTime ); |
|
1688 |
|
1689 if ( delay.Int64()+KTickResolution < kExpireTime64.Int64() || |
|
1690 delay.Int64() > kExpireTime64.Int64() + KTimerAccuracyMicroSeconds ) |
|
1691 { |
|
1692 aResult.SetResult( KErrGeneral, _L("Wrong expiration") ); |
|
1693 } |
|
1694 else |
|
1695 { |
|
1696 aResult.SetResult( KErrNone, _L("Test case passed") ); |
|
1697 } |
|
1698 |
|
1699 delete timer; |
|
1700 delete eResult; |
|
1701 delete res; |
|
1702 return KErrNone; |
|
1703 } |
|
1704 |
|
1705 // -------------------------------------------------------------------------- |
|
1706 // Start timers with dumbass parameters |
|
1707 // -------------------------------------------------------------------------- |
|
1708 // |
|
1709 TInt CTestCFlexTimer::DumbAssParametersForCTimer64MaxL( TTestResult& aResult, |
|
1710 CTestFlexTimer *cb ) |
|
1711 { |
|
1712 TTestResult *res = new TTestResult(); |
|
1713 TExtendedTestResult *eResult = new TExtendedTestResult(res); |
|
1714 eResult->iTimerID = 1; |
|
1715 |
|
1716 /*64 bit IF called with 0x7FFFFFFFFFFFFFFF parameter*/ |
|
1717 /***********************************/ |
|
1718 // This will cause panic |
|
1719 TTimeIntervalMicroSeconds expireTime64(0x7FFFFFFFFFFFFFFF); |
|
1720 // Save current time |
|
1721 TTime now(0); |
|
1722 now.HomeTime(); |
|
1723 CInheritedCFlexTimer *timer = CInheritedCFlexTimer::NewL( |
|
1724 CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); |
|
1725 //Accept panic as passed case |
|
1726 cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, |
|
1727 EFlexTimerServerIllegalTimerValue); |
|
1728 timer->After(expireTime64); |
|
1729 // Start timer that stops active scheduler just in case. |
|
1730 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
1731 p->Start(3 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( |
|
1732 StopActiveScheduler)); |
|
1733 CActiveScheduler::Start(); |
|
1734 delete p; |
|
1735 cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); |
|
1736 _LIT( KDescription , "64 bit After(0x7FFFFFFFFFFFFFFF) failed to panic.\n"); |
|
1737 aResult.SetResult(KErrGeneral, KDescription); |
|
1738 delete timer; |
|
1739 delete eResult; |
|
1740 delete res; |
|
1741 return KErrNone; |
|
1742 } |
|
1743 |
|
1744 // -------------------------------------------------------------------------- |
|
1745 // Start timers with dumbass parameters |
|
1746 // -------------------------------------------------------------------------- |
|
1747 // |
|
1748 TInt CTestCFlexTimer::DumbAssParametersForCTimer64ThreeYearsL( TTestResult& aResult, |
|
1749 CTestFlexTimer *cb ) |
|
1750 { |
|
1751 TTestResult *res = new TTestResult(); |
|
1752 TExtendedTestResult *eResult = new TExtendedTestResult(res); |
|
1753 eResult->iTimerID = 1; |
|
1754 |
|
1755 /*64 bit IF called with 93312000000000 (about three years) parameter*/ |
|
1756 /***********************************/ |
|
1757 // This will cause panic since only two years ahead timers are supported |
|
1758 TTimeIntervalMicroSeconds expireTime64(93312000000000); |
|
1759 // Save current time |
|
1760 TTime now(0); |
|
1761 now.HomeTime(); |
|
1762 CInheritedCFlexTimer *timer = CInheritedCFlexTimer::NewL( |
|
1763 CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); |
|
1764 //Accept panic as passed case |
|
1765 cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, |
|
1766 EFlexTimerServerIllegalTimerValue); |
|
1767 timer->After(expireTime64); |
|
1768 // Start timer that stops active scheduler just in case. |
|
1769 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
1770 p->Start(3 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( |
|
1771 StopActiveScheduler)); |
|
1772 CActiveScheduler::Start(); |
|
1773 delete p; |
|
1774 cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); |
|
1775 _LIT( KDescription , "64 bit After(93312000000000) failed to panic.\n"); |
|
1776 aResult.SetResult(KErrGeneral, KDescription); |
|
1777 delete timer; |
|
1778 delete eResult; |
|
1779 delete res; |
|
1780 return KErrNone; |
|
1781 } |
|
1782 |
|
1783 // -------------------------------------------------------------------------- |
|
1784 // Start one year timer and cancel it. |
|
1785 // -------------------------------------------------------------------------- |
|
1786 // |
|
1787 TInt CTestCFlexTimer::DumbAssParametersForCTimer64OneYearL( TTestResult& aResult, |
|
1788 CTestFlexTimer */*cb*/) |
|
1789 { |
|
1790 RDebug::Printf("DumbAssParametersForCTimer64OneYearL"); |
|
1791 TTestResult *res1 = new TTestResult(); |
|
1792 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
1793 eResult1->iTimerID = 0; |
|
1794 // Expire in 10 seconds |
|
1795 TTimeIntervalMicroSeconds expireTime1( 33312000000000 ); // About on year |
|
1796 //just something |
|
1797 RArray<TTimerStruct> timers; |
|
1798 CInheritedCFlexTimer2* timer1 = CInheritedCFlexTimer2::NewL( |
|
1799 CActive::EPriorityStandard, TCallBack(NotCalledCB, |
|
1800 &timers), 0); |
|
1801 TTimerStruct *s1 = new TTimerStruct(); |
|
1802 s1->iEResult = eResult1; |
|
1803 s1->iTimer = timer1; |
|
1804 timers.Append(*s1); |
|
1805 |
|
1806 timer1->After(expireTime1); |
|
1807 |
|
1808 timers[0].iCurrentlyActive = 0; |
|
1809 |
|
1810 //Timers to cancel timer and stop scheduler. |
|
1811 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
1812 p->Start(7 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( |
|
1813 StopActiveScheduler)); |
|
1814 CPeriodic *pp = CPeriodic::NewL(EPriorityNormal); |
|
1815 s1->iStartTimer = pp; |
|
1816 pp->Start(5 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( |
|
1817 CancelCFlexTimerArray, &timers)); |
|
1818 |
|
1819 // Start scheduler and wait for callback to stop it |
|
1820 CActiveScheduler::Start(); |
|
1821 delete p; delete pp; |
|
1822 delete s1; |
|
1823 _LIT( KDescription , "Passed"); |
|
1824 aResult.SetResult(KErrNone, KDescription); |
|
1825 //See if CB has failed the case |
|
1826 if (eResult1->iCaseAlreadyFailed) |
|
1827 { |
|
1828 aResult.SetResult(eResult1->iTestResult->iResult, |
|
1829 eResult1->iTestResult->iResultDes); |
|
1830 } |
|
1831 |
|
1832 delete timer1; |
|
1833 delete eResult1; |
|
1834 delete res1; |
|
1835 return KErrNone; |
|
1836 } |
|
1837 |
|
1838 // -------------------------------------------------------------------------- |
|
1839 // Start timers with negative value |
|
1840 // -------------------------------------------------------------------------- |
|
1841 // |
|
1842 TInt CTestCFlexTimer::AfterWithNegativeValueL( TTestResult& aResult, |
|
1843 CTestFlexTimer *cb ) |
|
1844 { |
|
1845 TTestResult *res = new TTestResult(); |
|
1846 TExtendedTestResult *eResult = new TExtendedTestResult(res); |
|
1847 eResult->iTimerID = 1; |
|
1848 |
|
1849 // This will cause panic |
|
1850 TTimeIntervalMicroSeconds32 expireTime(-1); |
|
1851 CInheritedCFlexTimer *timer = CInheritedCFlexTimer::NewL( |
|
1852 CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); |
|
1853 //Accept panic as passed case |
|
1854 cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, |
|
1855 EFlexTimerAfterIntervalLessThanZero); |
|
1856 timer->After(expireTime); |
|
1857 CActiveScheduler::Start(); |
|
1858 cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); |
|
1859 _LIT( KDescription , "32 bit After(-1) failed to panic.\n"); |
|
1860 aResult.SetResult(KErrGeneral, KDescription); |
|
1861 delete timer; |
|
1862 delete eResult; |
|
1863 delete res; |
|
1864 return KErrNone; |
|
1865 } |
|
1866 |
|
1867 // -------------------------------------------------------------------------- |
|
1868 // Start timers with negative value |
|
1869 // -------------------------------------------------------------------------- |
|
1870 // |
|
1871 TInt CTestCFlexTimer::AfterWithNegativeValue64L( TTestResult& aResult, |
|
1872 CTestFlexTimer *cb ) |
|
1873 { |
|
1874 TTestResult *res = new TTestResult(); |
|
1875 TExtendedTestResult *eResult = new TExtendedTestResult(res); |
|
1876 eResult->iTimerID = 1; |
|
1877 |
|
1878 // This will cause panic |
|
1879 TTimeIntervalMicroSeconds expireTime(-1); |
|
1880 CInheritedCFlexTimer *timer = CInheritedCFlexTimer::NewL( |
|
1881 CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); |
|
1882 //Accept panic as passed case |
|
1883 cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, |
|
1884 EFlexTimerAfterIntervalLessThanZero); |
|
1885 timer->After(expireTime); |
|
1886 CActiveScheduler::Start(); |
|
1887 cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); |
|
1888 _LIT( KDescription , "64 bit After(-1) failed to panic.\n"); |
|
1889 aResult.SetResult(KErrGeneral, KDescription); |
|
1890 delete timer; |
|
1891 delete eResult; |
|
1892 delete res; |
|
1893 return KErrNone; |
|
1894 } |
|
1895 |
|
1896 |
|
1897 // -------------------------------------------------------------------------- |
|
1898 // Start timers with dumbass parameters |
|
1899 // -------------------------------------------------------------------------- |
|
1900 // |
|
1901 TInt CTestCFlexTimer::AtWithCurrentTimeL( TTestResult& aResult, |
|
1902 CTestFlexTimer* /* cb */ ) |
|
1903 { |
|
1904 TTestResult *res = new TTestResult(); |
|
1905 TExtendedTestResult *eResult = new TExtendedTestResult(res); |
|
1906 eResult->iTimerID = 1; |
|
1907 |
|
1908 TTimeIntervalMicroSeconds expireTime64(0); |
|
1909 CInheritedCFlexTimer *timer = CInheritedCFlexTimer::NewL( |
|
1910 CActive::EPriorityStandard, |
|
1911 TCallBack(InheritedFlexTimerCallbackStopSchedulerKErrNone, eResult)); |
|
1912 |
|
1913 // Save current time |
|
1914 TTime now(0); |
|
1915 now.HomeTime(); |
|
1916 timer->At(now + expireTime64); |
|
1917 CActiveScheduler::Start(); // WAIT timer to expire |
|
1918 |
|
1919 // Analyze results |
|
1920 TTime endTime; |
|
1921 endTime.HomeTime(); |
|
1922 |
|
1923 TTimeIntervalMicroSeconds delay = endTime.MicroSecondsFrom( now ); |
|
1924 |
|
1925 if ( delay.Int64()+KTickResolution < expireTime64.Int64() || |
|
1926 delay.Int64() > expireTime64.Int64() + KTimerAccuracyMicroSeconds ) |
|
1927 { |
|
1928 aResult.SetResult(KErrGeneral, _L("Wrong expiration")); |
|
1929 } |
|
1930 else |
|
1931 { |
|
1932 aResult.SetResult( KErrNone, _L("Test case passed") ); |
|
1933 } |
|
1934 |
|
1935 // Clean up |
|
1936 delete timer; |
|
1937 delete eResult; |
|
1938 delete res; |
|
1939 return KErrNone; |
|
1940 } |
|
1941 |
|
1942 // -------------------------------------------------------------------------- |
|
1943 // Start timers with dumbass parameters |
|
1944 // -------------------------------------------------------------------------- |
|
1945 // |
|
1946 TInt CTestCFlexTimer::AtUTCWithCurrentTimeL( TTestResult& aResult, |
|
1947 CTestFlexTimer* /* cb */ ) |
|
1948 { |
|
1949 TTestResult *res = new TTestResult(); |
|
1950 TExtendedTestResult *eResult = new TExtendedTestResult(res); |
|
1951 eResult->iTimerID = 1; |
|
1952 |
|
1953 TTimeIntervalMicroSeconds expireTime64(0); |
|
1954 CInheritedCFlexTimer *timer = CInheritedCFlexTimer::NewL( |
|
1955 CActive::EPriorityStandard, |
|
1956 TCallBack(InheritedFlexTimerCallbackStopSchedulerKErrNone, eResult)); |
|
1957 |
|
1958 // Save current time |
|
1959 TTime now(0); |
|
1960 now.UniversalTime(); |
|
1961 timer->AtUTC(now + expireTime64); |
|
1962 CActiveScheduler::Start(); // WAIT timer to expire |
|
1963 |
|
1964 // Analyze results |
|
1965 TTime endTime; |
|
1966 endTime.UniversalTime(); |
|
1967 |
|
1968 TTimeIntervalMicroSeconds delay = endTime.MicroSecondsFrom( now ); |
|
1969 |
|
1970 if ( delay.Int64()+KTickResolution < expireTime64.Int64() || |
|
1971 delay.Int64() > expireTime64.Int64() + KTimerAccuracyMicroSeconds ) |
|
1972 { |
|
1973 aResult.SetResult(KErrGeneral, _L("Wrong expiration")); |
|
1974 } |
|
1975 else |
|
1976 { |
|
1977 aResult.SetResult( KErrNone, _L("Test case passed") ); |
|
1978 } |
|
1979 |
|
1980 // Clean up |
|
1981 delete timer; |
|
1982 delete eResult; |
|
1983 delete res; |
|
1984 return KErrNone; |
|
1985 } |
|
1986 |
|
1987 // -------------------------------------------------------------------------- |
|
1988 // Start timers with dumbass parameters |
|
1989 // -------------------------------------------------------------------------- |
|
1990 // |
|
1991 TInt CTestCFlexTimer::AtWithThreeYearsL( TTestResult& aResult, |
|
1992 CTestFlexTimer *cb ) |
|
1993 { |
|
1994 TTestResult *res = new TTestResult(); |
|
1995 TExtendedTestResult *eResult = new TExtendedTestResult(res); |
|
1996 eResult->iTimerID = 1; |
|
1997 |
|
1998 // This will cause panic |
|
1999 TTimeIntervalMicroSeconds expireTime64(93312000000000); |
|
2000 CInheritedCFlexTimer *timer = CInheritedCFlexTimer::NewL( |
|
2001 CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); |
|
2002 //Accept panic as passed case |
|
2003 cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, |
|
2004 EFlexTimerServerIllegalTimerValue); |
|
2005 // Save current time |
|
2006 TTime now(0); |
|
2007 now.HomeTime(); |
|
2008 timer->At(now + expireTime64); |
|
2009 // Start timer that stops active scheduler just in case. |
|
2010 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
2011 p->Start(3 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( |
|
2012 StopActiveScheduler)); |
|
2013 CActiveScheduler::Start(); |
|
2014 delete p; |
|
2015 cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); |
|
2016 _LIT( KDescription , "At(93312000000000) failed to panic.\n"); |
|
2017 aResult.SetResult(KErrGeneral, KDescription); |
|
2018 delete timer; |
|
2019 delete eResult; |
|
2020 delete res; |
|
2021 return KErrNone; |
|
2022 } |
|
2023 |
|
2024 // -------------------------------------------------------------------------- |
|
2025 // Start one year timer and cancel it. |
|
2026 // -------------------------------------------------------------------------- |
|
2027 // |
|
2028 TInt CTestCFlexTimer::AtWithOneYearL( TTestResult& aResult, |
|
2029 CTestFlexTimer */*cb*/) |
|
2030 { |
|
2031 RDebug::Printf("AtWithOneYearL"); |
|
2032 TTestResult *res1 = new TTestResult(); |
|
2033 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
2034 eResult1->iTimerID = 0; |
|
2035 // Expire in 10 seconds |
|
2036 TTimeIntervalMicroSeconds expireTime1( 33312000000000 ); // About on year |
|
2037 //just something |
|
2038 RArray<TTimerStruct> timers; |
|
2039 CInheritedCFlexTimer2* timer1 = CInheritedCFlexTimer2::NewL( |
|
2040 CActive::EPriorityStandard, TCallBack(NotCalledCB, |
|
2041 &timers), 0); |
|
2042 TTimerStruct *s1 = new TTimerStruct(); |
|
2043 s1->iEResult = eResult1; |
|
2044 s1->iTimer = timer1; |
|
2045 timers.Append(*s1); |
|
2046 TTime now(0); |
|
2047 now.HomeTime(); |
|
2048 timer1->At(now + expireTime1); |
|
2049 |
|
2050 timers[0].iCurrentlyActive = 0; |
|
2051 |
|
2052 //Timers to cancel timer and stop scheduler. |
|
2053 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
2054 p->Start(7 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( |
|
2055 StopActiveScheduler)); |
|
2056 CPeriodic *pp = CPeriodic::NewL(EPriorityNormal); |
|
2057 s1->iStartTimer = pp; |
|
2058 pp->Start(5 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( |
|
2059 CancelCFlexTimerArray, &timers)); |
|
2060 |
|
2061 // Start scheduler and wait for callback to stop it |
|
2062 CActiveScheduler::Start(); |
|
2063 delete p; delete pp; |
|
2064 delete s1; |
|
2065 _LIT( KDescription , "Passed"); |
|
2066 aResult.SetResult(KErrNone, KDescription); |
|
2067 //See if CB has failed the case |
|
2068 if (eResult1->iCaseAlreadyFailed) |
|
2069 { |
|
2070 aResult.SetResult(eResult1->iTestResult->iResult, |
|
2071 eResult1->iTestResult->iResultDes); |
|
2072 } |
|
2073 delete timer1; |
|
2074 delete eResult1; |
|
2075 delete res1; |
|
2076 return KErrNone; |
|
2077 } |
|
2078 |
|
2079 // -------------------------------------------------------------------------- |
|
2080 // Call At and AtUTC with time in the past |
|
2081 // -------------------------------------------------------------------------- |
|
2082 // |
|
2083 TInt CTestCFlexTimer::AtWithTimeInThePastL( TTestResult& aResult, |
|
2084 CTestFlexTimer *cb ) |
|
2085 { |
|
2086 RDebug::Printf("AtWithTimeInThePastL"); |
|
2087 TTestResult *res = new TTestResult(); |
|
2088 TExtendedTestResult *eResult = new TExtendedTestResult(res); |
|
2089 |
|
2090 // Expire in the past |
|
2091 TTimeIntervalMicroSeconds expireTime(-1); |
|
2092 CInheritedCFlexTimer* timer = CInheritedCFlexTimer::NewL( |
|
2093 CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); |
|
2094 // Save current time |
|
2095 TTime homeNow(0); |
|
2096 homeNow.HomeTime(); |
|
2097 TTime homeExpireTime(homeNow + expireTime); |
|
2098 //Accept panic as passed case |
|
2099 cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, |
|
2100 EFlexTimerAtIntervalLessThanZero); |
|
2101 timer->At(homeExpireTime); |
|
2102 CActiveScheduler::Start(); |
|
2103 cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); |
|
2104 _LIT( KDescription , "At in the past failed to panic.\n"); |
|
2105 aResult.SetResult(KErrGeneral, KDescription); |
|
2106 delete timer; |
|
2107 delete eResult; |
|
2108 delete res; |
|
2109 return KErrNone; |
|
2110 } |
|
2111 |
|
2112 // -------------------------------------------------------------------------- |
|
2113 // Start timer, expire, cancel, start again and expire |
|
2114 // -------------------------------------------------------------------------- |
|
2115 // |
|
2116 TInt CTestCFlexTimer::CancelExpiredTimerL( TTestResult& aResult, |
|
2117 CTestFlexTimer */*cb*/) |
|
2118 { |
|
2119 TExtendedTestResult *eResult = new TExtendedTestResult(&aResult); |
|
2120 CInheritedCFlexTimer |
|
2121 * timer = CInheritedCFlexTimer::NewL(CActive::EPriorityStandard, |
|
2122 TCallBack( |
|
2123 InheritedFlexTimerCallbackStopSchedulerKErrNone, |
|
2124 eResult)); |
|
2125 |
|
2126 // Expire in 5 seconds |
|
2127 TTimeIntervalMicroSeconds32 expireTime(5 * 1000 * 1000); |
|
2128 |
|
2129 // Save current time. |
|
2130 TTime utcNow(0); |
|
2131 utcNow.UniversalTime(); |
|
2132 |
|
2133 timer->After(expireTime); |
|
2134 |
|
2135 // Start scheduler and wait for callback to stop it |
|
2136 CActiveScheduler::Start(); |
|
2137 // Ignore time and cb stuff |
|
2138 // Cancel timer that just expired |
|
2139 timer->Cancel(); |
|
2140 |
|
2141 // Start timer again |
|
2142 // Save current time. |
|
2143 utcNow.UniversalTime(); |
|
2144 |
|
2145 timer->After(expireTime); |
|
2146 |
|
2147 // Start scheduler and wait for callback to stop it |
|
2148 CActiveScheduler::Start(); |
|
2149 //See if CB has failed the case |
|
2150 if (eResult->iCaseAlreadyFailed) |
|
2151 { |
|
2152 delete timer; |
|
2153 delete eResult; |
|
2154 return KErrNone; |
|
2155 } |
|
2156 // Get new current time |
|
2157 TTime utcNow2(0); |
|
2158 utcNow2.UniversalTime(); |
|
2159 |
|
2160 //Check if timer expiry happened within maxtime to maxtime+accuracy |
|
2161 if ((utcNow + expireTime) <= utcNow2+TTimeIntervalMicroSeconds32(KTickResolution) && (utcNow + expireTime |
|
2162 + TTimeIntervalMicroSeconds32(KTimerAccuracyMicroSeconds)) |
|
2163 > utcNow2) |
|
2164 { |
|
2165 _LIT( KDescription , "Passed"); |
|
2166 aResult.SetResult(KErrNone, KDescription); |
|
2167 } |
|
2168 else |
|
2169 { |
|
2170 _LIT( KDescription , "Timer was fired either too early or too late.\n"); |
|
2171 aResult.SetResult(KErrGeneral, KDescription); |
|
2172 } |
|
2173 // Case was executed |
|
2174 delete timer; |
|
2175 delete eResult; |
|
2176 return KErrNone; |
|
2177 } |
|
2178 |
|
2179 // -------------------------------------------------------------------------- |
|
2180 // Start timer that has left side of the window in the past. |
|
2181 // -------------------------------------------------------------------------- |
|
2182 // |
|
2183 TInt CTestCFlexTimer::ConfigureLeftSideInThePastL( TTestResult& aResult, |
|
2184 CTestFlexTimer */*cb*/) |
|
2185 { |
|
2186 TExtendedTestResult *eResult = new TExtendedTestResult(&aResult); |
|
2187 CInheritedCFlexTimer |
|
2188 * timer = CInheritedCFlexTimer::NewL(CActive::EPriorityStandard, |
|
2189 TCallBack( |
|
2190 InheritedFlexTimerCallbackStopSchedulerKErrNone, |
|
2191 eResult)); |
|
2192 |
|
2193 // Expire in 5 seconds |
|
2194 TTimeIntervalMicroSeconds32 winTime(10 * 1000 * 1000); |
|
2195 TTimeIntervalMicroSeconds32 expireTime(5 * 1000 * 1000); |
|
2196 |
|
2197 // Save current time. |
|
2198 TTime utcNow(0); |
|
2199 utcNow.UniversalTime(); |
|
2200 timer->Configure(winTime); |
|
2201 timer->After(expireTime); |
|
2202 |
|
2203 // Start scheduler and wait for callback to stop it |
|
2204 CActiveScheduler::Start(); |
|
2205 //See if CB has failed the case |
|
2206 if (eResult->iCaseAlreadyFailed) |
|
2207 { |
|
2208 delete timer; |
|
2209 delete eResult; |
|
2210 return KErrNone; |
|
2211 } |
|
2212 // Get new current time |
|
2213 TTime utcNow2(0); |
|
2214 utcNow2.UniversalTime(); |
|
2215 |
|
2216 //Check if timer expiry happened within maxtime to maxtime+accuracy |
|
2217 if ((utcNow + expireTime) <= utcNow2+TTimeIntervalMicroSeconds32(KTickResolution) && (utcNow + expireTime |
|
2218 + TTimeIntervalMicroSeconds32(KTimerAccuracyMicroSeconds)) |
|
2219 > utcNow2) |
|
2220 { |
|
2221 _LIT( KDescription , "Passed"); |
|
2222 aResult.SetResult(KErrNone, KDescription); |
|
2223 } |
|
2224 else |
|
2225 { |
|
2226 _LIT( KDescription , "Timer was fired either too early or too late.\n"); |
|
2227 aResult.SetResult(KErrGeneral, KDescription); |
|
2228 } |
|
2229 // Case was executed |
|
2230 delete timer; |
|
2231 delete eResult; |
|
2232 return KErrNone; |
|
2233 } |
|
2234 |
|
2235 // -------------------------------------------------------------------------- |
|
2236 // Start two timers and see that window works if another is started with left |
|
2237 // side of the window in the past. |
|
2238 // -------------------------------------------------------------------------- |
|
2239 // |
|
2240 TInt CTestCFlexTimer::ConfigureLeftSideInThePastWindowCheckL( |
|
2241 TTestResult& aResult, CTestFlexTimer */*cb*/) |
|
2242 { |
|
2243 TTestResult *res1 = new TTestResult(); |
|
2244 TTestResult *res2 = new TTestResult(); |
|
2245 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
2246 TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); |
|
2247 eResult1->iTimerID = 1; |
|
2248 eResult2->iTimerID = 2; |
|
2249 CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( |
|
2250 CActive::EPriorityStandard, |
|
2251 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
2252 eResult1)); |
|
2253 CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( |
|
2254 CActive::EPriorityStandard, |
|
2255 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
2256 eResult2)); |
|
2257 // Expire in 10 seconds |
|
2258 TTimeIntervalMicroSeconds32 expireTime1(10 * 1000 * 1000); |
|
2259 //Expire within first timers default window |
|
2260 TTimeIntervalMicroSeconds32 expireTime2(9 * 1000 * 1000); |
|
2261 |
|
2262 // Save current time |
|
2263 TTime utcNow(0); |
|
2264 utcNow.UniversalTime(); |
|
2265 |
|
2266 timer1->Configure(TTimeIntervalMicroSeconds(15 * 1000 * 1000)); |
|
2267 timer1->After(expireTime1); |
|
2268 timer2->After(expireTime2); |
|
2269 |
|
2270 //Timer to stop active scheduler after timers under test are completed. |
|
2271 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
2272 p->Start(17 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); |
|
2273 // Start scheduler and wait for callback to stop it |
|
2274 CActiveScheduler::Start(); |
|
2275 delete p; |
|
2276 //See if CB has failed the case |
|
2277 if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) |
|
2278 { |
|
2279 if (eResult1->iCaseAlreadyFailed) |
|
2280 { |
|
2281 aResult.SetResult(eResult1->iTestResult->iResult, |
|
2282 eResult1->iTestResult->iResultDes); |
|
2283 } |
|
2284 else |
|
2285 { |
|
2286 aResult.SetResult(eResult2->iTestResult->iResult, |
|
2287 eResult2->iTestResult->iResultDes); |
|
2288 } |
|
2289 delete timer1; |
|
2290 delete timer2; |
|
2291 delete eResult1; |
|
2292 delete eResult2; |
|
2293 delete res1; |
|
2294 delete res2; |
|
2295 return KErrNone; |
|
2296 } |
|
2297 // Get new current time |
|
2298 TTime utcNow2(0); |
|
2299 utcNow2.UniversalTime(); |
|
2300 |
|
2301 //Check if timers expiry happened within timer2 maxtime to maxtime+accuracy |
|
2302 if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) |
|
2303 && (utcNow + expireTime2 + TTimeIntervalMicroSeconds32( |
|
2304 KTimerAccuracyMicroSeconds)) > TTime( |
|
2305 eResult2->iTimerStoppedTime) && |
|
2306 |
|
2307 (utcNow + expireTime2) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow |
|
2308 + expireTime2 + TTimeIntervalMicroSeconds32( |
|
2309 KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime)) |
|
2310 { |
|
2311 _LIT( KDescription , "Passed"); |
|
2312 aResult.SetResult(KErrNone, KDescription); |
|
2313 } |
|
2314 else |
|
2315 { |
|
2316 _LIT( KDescription , "Some timer was fired either too early or too late.\n"); |
|
2317 aResult.SetResult(KErrGeneral, KDescription); |
|
2318 } |
|
2319 // Case was executed |
|
2320 delete timer1; |
|
2321 delete timer2; |
|
2322 delete eResult1; |
|
2323 delete eResult2; |
|
2324 delete res1; |
|
2325 delete res2; |
|
2326 return KErrNone; |
|
2327 |
|
2328 } |
|
2329 |
|
2330 // -------------------------------------------------------------------------- |
|
2331 // Call Configure 32 bit with Negative window size |
|
2332 // -------------------------------------------------------------------------- |
|
2333 // |
|
2334 TInt CTestCFlexTimer::ConfigureWithNegativeWindowSize32L( |
|
2335 TTestResult& aResult, CTestFlexTimer *cb ) |
|
2336 { |
|
2337 RDebug::Printf("ConfigureWithNegativeWindowSize32L"); |
|
2338 TTestResult *res = new TTestResult(); |
|
2339 TExtendedTestResult *eResult = new TExtendedTestResult(res); |
|
2340 |
|
2341 // negative time |
|
2342 TTimeIntervalMicroSeconds32 confTime(-1); |
|
2343 CInheritedCFlexTimer* timer = CInheritedCFlexTimer::NewL( |
|
2344 CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); |
|
2345 //Accept panic as passed case |
|
2346 cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, |
|
2347 EFlexTimerWindowLessThanZero); |
|
2348 timer->Configure(confTime); |
|
2349 //CActiveScheduler::Start(); |
|
2350 cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); |
|
2351 _LIT( KDescription , "Configure(32) with negative interval failed to panic\n"); |
|
2352 aResult.SetResult(KErrGeneral, KDescription); |
|
2353 delete timer; |
|
2354 delete eResult; |
|
2355 delete res; |
|
2356 return KErrNone; |
|
2357 } |
|
2358 |
|
2359 // -------------------------------------------------------------------------- |
|
2360 // Call Configure 64 bit with Negative window size |
|
2361 // -------------------------------------------------------------------------- |
|
2362 // |
|
2363 TInt CTestCFlexTimer::ConfigureWithNegativeWindowSize64L( |
|
2364 TTestResult& aResult, CTestFlexTimer *cb ) |
|
2365 { |
|
2366 RDebug::Printf("ConfigureWithNegativeWindowSize64L"); |
|
2367 TTestResult *res = new TTestResult(); |
|
2368 TExtendedTestResult *eResult = new TExtendedTestResult(res); |
|
2369 |
|
2370 // negative time |
|
2371 TTimeIntervalMicroSeconds confTime(-1); |
|
2372 CInheritedCFlexTimer* timer = CInheritedCFlexTimer::NewL( |
|
2373 CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); |
|
2374 //Accept panic as passed case |
|
2375 cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, |
|
2376 EFlexTimerWindowLessThanZero); |
|
2377 timer->Configure(confTime); |
|
2378 //CActiveScheduler::Start(); |
|
2379 cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); |
|
2380 _LIT( KDescription , "Configure(64) with negative interval failed to panic\n"); |
|
2381 aResult.SetResult(KErrGeneral, KDescription); |
|
2382 delete timer; |
|
2383 delete eResult; |
|
2384 delete res; |
|
2385 return KErrNone; |
|
2386 } |
|
2387 |
|
2388 // -------------------------------------------------------------------------- |
|
2389 // - |
|
2390 // -------------------------------------------------------------------------- |
|
2391 // |
|
2392 TInt CTestCFlexTimer::ConfigureWithMaxWindow32L( |
|
2393 TTestResult& aResult, CTestFlexTimer* /* cb */ ) |
|
2394 { |
|
2395 RDebug::Printf("ConfigureWithMaxWindow32L"); |
|
2396 TTestResult *res1 = new TTestResult(); |
|
2397 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
2398 eResult1->iTimerID = 0; |
|
2399 TTimeIntervalMicroSeconds32 expireTime1( 0x7FFFFFFF ); |
|
2400 //just something |
|
2401 RArray<TTimerStruct> timers; |
|
2402 CInheritedCFlexTimer2* timer1 = CInheritedCFlexTimer2::NewL( |
|
2403 CActive::EPriorityStandard, TCallBack(NotCalledCB, |
|
2404 &timers), 0); |
|
2405 TTimerStruct *s1 = new TTimerStruct(); |
|
2406 s1->iEResult = eResult1; |
|
2407 s1->iTimer = timer1; |
|
2408 timers.Append(*s1); |
|
2409 timer1->Configure(expireTime1); |
|
2410 timer1->After(expireTime1); |
|
2411 |
|
2412 timers[0].iCurrentlyActive = 0; |
|
2413 |
|
2414 //Timers to cancel timer and stop scheduler. |
|
2415 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
2416 p->Start(7 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( |
|
2417 StopActiveScheduler)); |
|
2418 CPeriodic *pp = CPeriodic::NewL(EPriorityNormal); |
|
2419 s1->iStartTimer = pp; |
|
2420 pp->Start(5 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( |
|
2421 CancelCFlexTimerArray, &timers)); |
|
2422 |
|
2423 // Start scheduler and wait for callback to stop it |
|
2424 CActiveScheduler::Start(); |
|
2425 delete p; delete pp; |
|
2426 delete s1; |
|
2427 _LIT( KDescription , "Passed"); |
|
2428 aResult.SetResult(KErrNone, KDescription); |
|
2429 //See if CB has failed the case |
|
2430 if (eResult1->iCaseAlreadyFailed) |
|
2431 { |
|
2432 aResult.SetResult(eResult1->iTestResult->iResult, |
|
2433 eResult1->iTestResult->iResultDes); |
|
2434 } |
|
2435 delete timer1; |
|
2436 delete eResult1; |
|
2437 delete res1; |
|
2438 return KErrNone; |
|
2439 } |
|
2440 // -------------------------------------------------------------------------- |
|
2441 // - |
|
2442 // -------------------------------------------------------------------------- |
|
2443 // |
|
2444 TInt CTestCFlexTimer::ConfigureWithThreeYearWindow64L( |
|
2445 TTestResult& aResult, CTestFlexTimer *cb ) |
|
2446 { |
|
2447 RDebug::Printf("ConfigureWithThreeYearWindow64L"); |
|
2448 TTestResult *res = new TTestResult(); |
|
2449 TExtendedTestResult *eResult = new TExtendedTestResult(res); |
|
2450 |
|
2451 // negative time |
|
2452 TTimeIntervalMicroSeconds confTime(93312000000000); |
|
2453 CInheritedCFlexTimer* timer = CInheritedCFlexTimer::NewL( |
|
2454 CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); |
|
2455 //Accept panic as passed case |
|
2456 cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, |
|
2457 EFlexTimerServerIllegalTimerValue); |
|
2458 timer->Configure(confTime); |
|
2459 //CActiveScheduler::Start(); |
|
2460 cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); |
|
2461 _LIT( KDescription , "Configure(93312000000000 failed to panic\n"); |
|
2462 aResult.SetResult(KErrGeneral, KDescription); |
|
2463 delete timer; |
|
2464 delete eResult; |
|
2465 delete res; |
|
2466 return KErrNone; |
|
2467 } |
|
2468 |
|
2469 // -------------------------------------------------------------------------- |
|
2470 // - |
|
2471 // -------------------------------------------------------------------------- |
|
2472 // |
|
2473 TInt CTestCFlexTimer::ConfigureWithMaxWindow64L( |
|
2474 TTestResult& aResult, CTestFlexTimer *cb ) |
|
2475 { |
|
2476 RDebug::Printf("ConfigureWithMaxWindow64L"); |
|
2477 TTestResult *res = new TTestResult(); |
|
2478 TExtendedTestResult *eResult = new TExtendedTestResult(res); |
|
2479 |
|
2480 // negative time |
|
2481 TTimeIntervalMicroSeconds confTime(0x7FFFFFFFFFFFFFFF); |
|
2482 CInheritedCFlexTimer* timer = CInheritedCFlexTimer::NewL( |
|
2483 CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); |
|
2484 //Accept panic as passed case |
|
2485 cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, |
|
2486 EFlexTimerServerIllegalTimerValue); |
|
2487 timer->Configure(confTime); |
|
2488 //CActiveScheduler::Start(); |
|
2489 cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); |
|
2490 _LIT( KDescription , "Configure(0x7FFFFFFFFFFFFFFF) failed to panic\n"); |
|
2491 aResult.SetResult(KErrGeneral, KDescription); |
|
2492 delete timer; |
|
2493 delete eResult; |
|
2494 delete res; |
|
2495 return KErrNone; |
|
2496 } |
|
2497 // -------------------------------------------------------------------------- |
|
2498 // Start timer and call configure while it is running |
|
2499 // -------------------------------------------------------------------------- |
|
2500 // |
|
2501 TInt CTestCFlexTimer::ConfigureWhileTimerIsInUseL( TTestResult& aResult, |
|
2502 CTestFlexTimer */*cb*/) |
|
2503 { |
|
2504 RDebug::Printf("ConfigureWhileTimerIsInUseL"); |
|
2505 TTestResult *res1 = new TTestResult(); |
|
2506 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
2507 eResult1->iTimerID = 0; |
|
2508 // Expire in 10 seconds |
|
2509 TTimeIntervalMicroSeconds expireTime1(10 * 1000 * 1000); |
|
2510 //just something |
|
2511 RArray<TTimerStruct> timers; |
|
2512 CInheritedCFlexTimer2* timer1 = CInheritedCFlexTimer2::NewL( |
|
2513 CActive::EPriorityStandard, TCallBack(StopSchedulerKErrNoneArray, |
|
2514 &timers), 0); |
|
2515 TTimerStruct *s1 = new TTimerStruct(); |
|
2516 s1->iEResult = eResult1; |
|
2517 s1->iTimer = timer1; |
|
2518 timers.Append(*s1); |
|
2519 |
|
2520 TTime homeNow(0); |
|
2521 homeNow.HomeTime(); |
|
2522 |
|
2523 timer1->After(expireTime1); |
|
2524 |
|
2525 timers[0].iCurrentlyActive = 0; |
|
2526 |
|
2527 //Timer to call configure while timer is running |
|
2528 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
2529 p->Start(5 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( |
|
2530 ConfigureKErrInUseArray, &timers)); |
|
2531 |
|
2532 // Start scheduler and wait for callback to stop it |
|
2533 CActiveScheduler::Start(); |
|
2534 delete p; |
|
2535 delete s1; |
|
2536 _LIT( KDescription , "Passed"); |
|
2537 aResult.SetResult(KErrNone, KDescription); |
|
2538 //See if CB has failed the case |
|
2539 if (eResult1->iCaseAlreadyFailed) |
|
2540 { |
|
2541 aResult.SetResult(eResult1->iTestResult->iResult, |
|
2542 eResult1->iTestResult->iResultDes); |
|
2543 delete timer1; |
|
2544 delete eResult1; |
|
2545 delete res1; |
|
2546 return KErrNone; |
|
2547 } |
|
2548 TTime homeNow2(0); |
|
2549 homeNow2.HomeTime(); |
|
2550 //Check if timers expiry happened within timer2 maxtime to maxtime+accuracy |
|
2551 if (!((homeNow + expireTime1) <= homeNow2+TTimeIntervalMicroSeconds32(KTickResolution) && (homeNow + expireTime1 |
|
2552 + TTimeIntervalMicroSeconds32(KTimerAccuracyMicroSeconds)) |
|
2553 > homeNow2)) |
|
2554 { |
|
2555 _LIT( KEDescription , "Timer was not fired within limits"); |
|
2556 aResult.SetResult(KErrGeneral, KEDescription); |
|
2557 } |
|
2558 delete timer1; |
|
2559 delete eResult1; |
|
2560 delete res1; |
|
2561 return KErrNone; |
|
2562 } |
|
2563 |
|
2564 // -------------------------------------------------------------------------- |
|
2565 // timer is started twice |
|
2566 // -------------------------------------------------------------------------- |
|
2567 // |
|
2568 TInt CTestCFlexTimer::TimerIsStartedTwiceL( TTestResult& aResult, |
|
2569 CTestFlexTimer *cb ) |
|
2570 { |
|
2571 TTestResult *res1 = new TTestResult(); |
|
2572 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
2573 eResult1->iTimerID = 0; |
|
2574 CInheritedCFlexTimer2* timer1 = CInheritedCFlexTimer2::NewL( |
|
2575 CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult1), 0); |
|
2576 // Expire in 10 seconds |
|
2577 TTimeIntervalMicroSeconds expireTime1(10 * 1000 * 1000); |
|
2578 RArray<TTimerStruct> timers; |
|
2579 TTimerStruct *s1 = new TTimerStruct(); |
|
2580 s1->iEResult = eResult1; |
|
2581 s1->iTimer = timer1; |
|
2582 timers.Append(*s1); |
|
2583 |
|
2584 timer1->After(expireTime1); |
|
2585 timers[0].iCurrentlyActive = 0; //CB uses this to decide which timer to start again; |
|
2586 |
|
2587 //Timer to start timer again |
|
2588 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
2589 p->Start(5 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( |
|
2590 StartTimerAgainArray, &timers)); |
|
2591 // Panic category: "E32USER-CBase" |
|
2592 // Panic reason: 42 (attempt to active CActive when a request is still |
|
2593 // outstanding. |
|
2594 cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, 42); |
|
2595 // Start scheduler and wait for callback to panic it |
|
2596 CActiveScheduler::Start(); |
|
2597 // We should never get here -> fail the case |
|
2598 cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); |
|
2599 delete p; |
|
2600 delete s1; |
|
2601 _LIT( KDescription , "double start failed to panic."); |
|
2602 aResult.SetResult(KErrGeneral, KDescription); |
|
2603 |
|
2604 delete timer1; |
|
2605 delete eResult1; |
|
2606 delete res1; |
|
2607 return KErrNone; |
|
2608 } |
|
2609 |
|
2610 // -------------------------------------------------------------------------- |
|
2611 // See that timer is stoppped with valid reason and stop scheduler |
|
2612 // -------------------------------------------------------------------------- |
|
2613 // |
|
2614 TInt CTestCFlexTimer::InheritedFlexTimerCallbackStopSchedulerKErrNone( |
|
2615 TAny* aArgument ) |
|
2616 { |
|
2617 RDebug::Printf("InheritedFlexTimerCallbackStopSchedulerKErrNone"); |
|
2618 TExtendedTestResult *eRes = |
|
2619 reinterpret_cast<TExtendedTestResult*> (aArgument); |
|
2620 if (eRes->iStatusCode != KErrNone) |
|
2621 { |
|
2622 eRes->iCaseAlreadyFailed = ETrue; |
|
2623 _LIT(KError,"Error: Wrong timer expiry reason\n"); |
|
2624 eRes->iTestResult->SetResult(KErrGeneral, KError); |
|
2625 } |
|
2626 CActiveScheduler::Stop(); |
|
2627 return 1; // nada |
|
2628 } |
|
2629 |
|
2630 // -------------------------------------------------------------------------- |
|
2631 // See that timer is stoppped with valid reason and stop scheduler |
|
2632 // -------------------------------------------------------------------------- |
|
2633 // |
|
2634 TInt CTestCFlexTimer::InheritedFlexTimerCallbackStopSchedulerKErrAbort( |
|
2635 TAny* aArgument ) |
|
2636 { |
|
2637 RDebug::Printf("InheritedFlexTimerCallbackStopSchedulerKErrAbort"); |
|
2638 TExtendedTestResult *eRes = |
|
2639 reinterpret_cast<TExtendedTestResult*> (aArgument); |
|
2640 if (eRes->iStatusCode != KErrAbort) |
|
2641 { |
|
2642 eRes->iCaseAlreadyFailed = ETrue; |
|
2643 _LIT(KError,"Error: Wrong timer expiry reason"); |
|
2644 eRes->iTestResult->SetResult(KErrGeneral, KError); |
|
2645 } |
|
2646 CActiveScheduler::Stop(); |
|
2647 return 1; // nada |
|
2648 } |
|
2649 |
|
2650 // -------------------------------------------------------------------------- |
|
2651 // See that timer is stoppped with valid reason and stop scheduler |
|
2652 // -------------------------------------------------------------------------- |
|
2653 // |
|
2654 TInt CTestCFlexTimer::InheritedFlexTimerCallbackStopSchedulerKErrCancel( |
|
2655 TAny* aArgument ) |
|
2656 { |
|
2657 RDebug::Printf("InheritedFlexTimerCallbackStopSchedulerKErrCancel"); |
|
2658 TExtendedTestResult *eRes = |
|
2659 reinterpret_cast<TExtendedTestResult*> (aArgument); |
|
2660 if (eRes->iStatusCode != KErrCancel) |
|
2661 { |
|
2662 eRes->iCaseAlreadyFailed = ETrue; |
|
2663 _LIT(KError,"Error: Wrong timer expiry reason"); |
|
2664 eRes->iTestResult->SetResult(KErrGeneral, KError); |
|
2665 } |
|
2666 CActiveScheduler::Stop(); |
|
2667 return 1; // nada |
|
2668 } |
|
2669 |
|
2670 // -------------------------------------------------------------------------- |
|
2671 // See that timer is stoppped with valid reason |
|
2672 // -------------------------------------------------------------------------- |
|
2673 // |
|
2674 TInt CTestCFlexTimer::InheritedFlexTimerCallbackKErrNone( TAny* aArgument ) |
|
2675 { |
|
2676 TExtendedTestResult *eRes = |
|
2677 reinterpret_cast<TExtendedTestResult*> (aArgument); |
|
2678 if (eRes->iStatusCode != KErrNone) |
|
2679 { |
|
2680 eRes->iCaseAlreadyFailed = ETrue; |
|
2681 _LIT(KError,"Error: Wrong timer expiry reason"); |
|
2682 eRes->iTestResult->SetResult(KErrGeneral, KError); |
|
2683 } |
|
2684 return 1; // nada |
|
2685 } |
|
2686 |
|
2687 // -------------------------------------------------------------------------- |
|
2688 // See that timer is stoppped with valid reason |
|
2689 // -------------------------------------------------------------------------- |
|
2690 // |
|
2691 TInt CTestCFlexTimer::InheritedFlexTimerCallbackKErrAbort( TAny* aArgument ) |
|
2692 { |
|
2693 TExtendedTestResult *eRes = |
|
2694 reinterpret_cast<TExtendedTestResult*> (aArgument); |
|
2695 if (eRes->iStatusCode != KErrAbort) |
|
2696 { |
|
2697 eRes->iCaseAlreadyFailed = ETrue; |
|
2698 _LIT(KError,"Error: Wrong timer expiry reason"); |
|
2699 eRes->iTestResult->SetResult(KErrGeneral, KError); |
|
2700 } |
|
2701 return 1; // nada |
|
2702 } |
|
2703 |
|
2704 // -------------------------------------------------------------------------- |
|
2705 // See that both timers are stoppped with valid reason and save expiry time |
|
2706 // -------------------------------------------------------------------------- |
|
2707 // |
|
2708 TInt CTestCFlexTimer::InheritedFlexTimerCallbackKErrNoneMarkTimestamp( |
|
2709 TAny* aArgument ) |
|
2710 { |
|
2711 TExtendedTestResult *eRes = |
|
2712 reinterpret_cast<TExtendedTestResult*> (aArgument); |
|
2713 if (eRes->iStatusCode != KErrNone) |
|
2714 { |
|
2715 eRes->iCaseAlreadyFailed = ETrue; |
|
2716 _LIT(KError,"Error: Wrong timer expiry reason"); |
|
2717 eRes->iTestResult->SetResult(KErrGeneral, KError); |
|
2718 } |
|
2719 TTime utcNow(0); |
|
2720 utcNow.UniversalTime(); |
|
2721 eRes->iTimerStoppedTime = utcNow.Int64(); |
|
2722 return 1; // nada |
|
2723 } |
|
2724 |
|
2725 // -------------------------------------------------------------------------- |
|
2726 // See that both timers are stoppped with valid reason and save expiry time |
|
2727 // -------------------------------------------------------------------------- |
|
2728 // |
|
2729 TInt CTestCFlexTimer::InheritedFlexTimerCallbackKErrNoneMarkTimestampStopScheduler( |
|
2730 TAny* aArgument ) |
|
2731 { |
|
2732 TExtendedTestResult *eRes = |
|
2733 reinterpret_cast<TExtendedTestResult*> (aArgument); |
|
2734 if (eRes->iStatusCode != KErrNone) |
|
2735 { |
|
2736 eRes->iCaseAlreadyFailed = ETrue; |
|
2737 _LIT(KError,"Error: Wrong timer expiry reason"); |
|
2738 eRes->iTestResult->SetResult(KErrGeneral, KError); |
|
2739 } |
|
2740 TTime utcNow(0); |
|
2741 utcNow.UniversalTime(); |
|
2742 eRes->iTimerStoppedTime = utcNow.Int64(); |
|
2743 CActiveScheduler::Stop(); |
|
2744 return 1; // nada |
|
2745 } |
|
2746 |
|
2747 // -------------------------------------------------------------------------- |
|
2748 // Stop active scheduler |
|
2749 // -------------------------------------------------------------------------- |
|
2750 // |
|
2751 TInt CTestCFlexTimer::StopActiveScheduler( TAny*/*aArgument*/) |
|
2752 { |
|
2753 CActiveScheduler::Stop(); |
|
2754 return 1; // nada |
|
2755 } |
|
2756 |
|
2757 // -------------------------------------------------------------------------- |
|
2758 // Change system time + 1s and cancel Periodic timer given as parameter |
|
2759 // -------------------------------------------------------------------------- |
|
2760 // |
|
2761 TInt CTestCFlexTimer::ChangeSystemTime1sAndCancel( TAny* aArgument ) |
|
2762 { |
|
2763 RDebug::Printf("ChangeSystemTime1sAndCancel"); |
|
2764 TTime now(0); |
|
2765 now.HomeTime(); |
|
2766 User::SetHomeTime(now + TTimeIntervalMicroSeconds32(1000 * 1000)); |
|
2767 CPeriodic *p = reinterpret_cast<CPeriodic*> (aArgument); |
|
2768 p->Cancel(); |
|
2769 return 1; // nada |
|
2770 } |
|
2771 |
|
2772 // -------------------------------------------------------------------------- |
|
2773 // Change time zone and cancel Periodic timer given as parameter |
|
2774 // -------------------------------------------------------------------------- |
|
2775 // |
|
2776 TInt CTestCFlexTimer::ChangeTimeZoneAndCancel( TAny* aArgument ) |
|
2777 { |
|
2778 RDebug::Printf("ChangeTimeZoneAndCancel"); |
|
2779 TTimeIntervalSeconds currentUtcOffset( User::UTCOffset() ); |
|
2780 User::SetUTCOffset( currentUtcOffset.Int() + 3000 ); |
|
2781 CPeriodic *p = reinterpret_cast<CPeriodic*> (aArgument); |
|
2782 p->Cancel(); |
|
2783 return 1; // nada |
|
2784 } |
|
2785 |
|
2786 // -------------------------------------------------------------------------- |
|
2787 // Change secure time + 1s and cancel Periodic timer given as parameter |
|
2788 // -------------------------------------------------------------------------- |
|
2789 // |
|
2790 TInt CTestCFlexTimer::ChangeSecureTimeAndCancel( TAny* aArgument ) |
|
2791 { |
|
2792 RDebug::Printf("ChangeSecureTimeAndCancel"); |
|
2793 TTime now(0); |
|
2794 now.UniversalTime(); |
|
2795 User::SetUTCTimeSecure(now + TTimeIntervalMicroSeconds32(1000 * 1000)); |
|
2796 CPeriodic *p = reinterpret_cast<CPeriodic*> (aArgument); |
|
2797 p->Cancel(); |
|
2798 return 1; // nada |
|
2799 } |
|
2800 |
|
2801 // -------------------------------------------------------------------------- |
|
2802 // Fail result if this is called |
|
2803 // -------------------------------------------------------------------------- |
|
2804 // |
|
2805 TInt CTestCFlexTimer::NotCalledCB( TAny* aArgument ) |
|
2806 { |
|
2807 TExtendedTestResult *eRes = |
|
2808 reinterpret_cast<TExtendedTestResult*> (aArgument); |
|
2809 eRes->iCaseAlreadyFailed = ETrue; |
|
2810 _LIT(KError,"Error: invalid CB called"); |
|
2811 eRes->iTestResult->SetResult(KErrGeneral, KError); |
|
2812 return 1; //nada |
|
2813 } |
|
2814 |
|
2815 // -------------------------------------------------------------------------- |
|
2816 // Stop active schduler and cancel Periodic timer given as paramter |
|
2817 // -------------------------------------------------------------------------- |
|
2818 // |
|
2819 TInt CTestCFlexTimer::StopSchedulerAndCancel( TAny* aArgument ) |
|
2820 { |
|
2821 CPeriodic *p = reinterpret_cast<CPeriodic*> (aArgument); |
|
2822 p->Cancel(); |
|
2823 CActiveScheduler::Stop(); |
|
2824 return 1; // nada |
|
2825 } |
|
2826 |
|
2827 // -------------------------------------------------------------------------- |
|
2828 // Cancels CFlexTimer given a parameter |
|
2829 // -------------------------------------------------------------------------- |
|
2830 // |
|
2831 TInt CTestCFlexTimer::CancelCFlexTimer( TAny* aArgument ) |
|
2832 { |
|
2833 CFlexTimer *p = reinterpret_cast<CFlexTimer*> (aArgument); |
|
2834 p->Cancel(); |
|
2835 return 1; // nada |
|
2836 } |
|
2837 |
|
2838 // -------------------------------------------------------------------------- |
|
2839 // Cancels CFlexTimer |
|
2840 // -------------------------------------------------------------------------- |
|
2841 // |
|
2842 TInt CTestCFlexTimer::CancelCFlexTimerArray( TAny* aArgument ) |
|
2843 { |
|
2844 RDebug::Printf("CancelCFlexTimerCancelPeriodic"); |
|
2845 RArray<TTimerStruct> *list = |
|
2846 reinterpret_cast<RArray<TTimerStruct>*> (aArgument); |
|
2847 (*list)[(*list)[0].iCurrentlyActive].iTimer->Cancel(); |
|
2848 (*list)[0].iCurrentlyActive += 1; |
|
2849 return 1; // nada |
|
2850 } |
|
2851 // -------------------------------------------------------------------------- |
|
2852 // Cancels CFlexTimer and CPeriodic given a parameter |
|
2853 // -------------------------------------------------------------------------- |
|
2854 // |
|
2855 TInt CTestCFlexTimer::CancelCFlexTimerCancelPeriodic( TAny* aArgument ) |
|
2856 { |
|
2857 RDebug::Printf("CancelCFlexTimerCancelPeriodic"); |
|
2858 RArray<TTimerStruct> *list = |
|
2859 reinterpret_cast<RArray<TTimerStruct>*> (aArgument); |
|
2860 (*list)[(*list)[0].iCurrentlyActive].iTimer->Cancel(); |
|
2861 (*list)[0].iCurrentlyActive += 1; |
|
2862 (*list)[0].iStartTimer->Cancel(); |
|
2863 return 1; // nada |
|
2864 } |
|
2865 // -------------------------------------------------------------------------- |
|
2866 // See that timer is stoppped with valid reason and stop scheduler |
|
2867 // -------------------------------------------------------------------------- |
|
2868 // |
|
2869 TInt CTestCFlexTimer::StopSchedulerKErrNoneArray( TAny* aArgument ) |
|
2870 { |
|
2871 RDebug::Printf("StopSchedulerKErrNoneArray"); |
|
2872 RArray<TTimerStruct> *list = |
|
2873 reinterpret_cast<RArray<TTimerStruct>*> (aArgument); |
|
2874 if ((*list)[(*list)[0].iCurrentlyActive].iEResult->iStatusCode |
|
2875 != KErrNone) |
|
2876 { |
|
2877 (*list)[(*list)[0].iCurrentlyActive].iEResult->iCaseAlreadyFailed |
|
2878 = ETrue; |
|
2879 _LIT(KErrorDes,"Error: Wrong timer expiry reason"); |
|
2880 (*list)[(*list)[0].iCurrentlyActive].iEResult->iTestResult->SetResult( |
|
2881 KErrGeneral, KErrorDes); |
|
2882 } |
|
2883 CActiveScheduler::Stop(); |
|
2884 return 1; // nada |
|
2885 } |
|
2886 |
|
2887 // -------------------------------------------------------------------------- |
|
2888 // Cancels CFlexTimer given a parameter and stops active scheduler |
|
2889 // -------------------------------------------------------------------------- |
|
2890 // |
|
2891 TInt CTestCFlexTimer::CancelCFlexTimerAndStopActiveScheduler( TAny* aArgument ) |
|
2892 { |
|
2893 CFlexTimer *p = reinterpret_cast<CFlexTimer*> (aArgument); |
|
2894 p->Cancel(); |
|
2895 CActiveScheduler::Stop(); |
|
2896 return 1; // nada |
|
2897 } |
|
2898 |
|
2899 // -------------------------------------------------------------------------- |
|
2900 // Callback for StartTimerAndAddToList method. This is hack to enable aTimers |
|
2901 // parameter in StartTimerAndAddToList method. |
|
2902 // -------------------------------------------------------------------------- |
|
2903 // |
|
2904 TInt CTestCFlexTimer::StartTimerAndAddToListCB( TAny* aArgument ) |
|
2905 { |
|
2906 return StartTimerAndAddToList( |
|
2907 reinterpret_cast<RArray<TTimerStruct>*> (aArgument), -1 ); |
|
2908 } |
|
2909 |
|
2910 // -------------------------------------------------------------------------- |
|
2911 // Starts timer and adds it to list given as param |
|
2912 // -------------------------------------------------------------------------- |
|
2913 // |
|
2914 TInt CTestCFlexTimer::StartTimerAndAddToList( |
|
2915 RArray<TTimerStruct>* aList, TInt aTimers ) |
|
2916 { |
|
2917 const TInt KTimerStartInterval = 5 * 1000; //Start new timer every 5ms |
|
2918 const TInt KTimerMaxDelay = 15 * 1000 * 1000; //Timer delay is between 0 and 15 seconds |
|
2919 static TInt numberOfTimers = 0; // How many timers to start |
|
2920 |
|
2921 if (aTimers > 0) |
|
2922 { |
|
2923 numberOfTimers = aTimers; |
|
2924 } |
|
2925 |
|
2926 TTestResult *res = new TTestResult(); |
|
2927 TExtendedTestResult *eResult = new TExtendedTestResult(res); |
|
2928 eResult->iTimerID = aList->Count(); |
|
2929 CInheritedCFlexTimer2* timer = CInheritedCFlexTimer2::NewL( |
|
2930 CActive::EPriorityStandard, |
|
2931 TCallBack(StopTimer, reinterpret_cast<TAny*> (aList)), |
|
2932 eResult->iTimerID); |
|
2933 |
|
2934 // Expire in 0-15s seconds |
|
2935 TInt random = Math::Random() % (KTimerMaxDelay); |
|
2936 TTimeIntervalMicroSeconds expireTime(random); |
|
2937 TTimerStruct *s = new TTimerStruct(); |
|
2938 s->iEResult = eResult; |
|
2939 s->iTimer = timer; |
|
2940 // Save current time |
|
2941 TTime utcNow(0); |
|
2942 utcNow.UniversalTime(); |
|
2943 s->iEResult->iTimerStartedTime = utcNow.Int64(); |
|
2944 s->iEResult->iTimerExpiryTime = expireTime.Int64(); |
|
2945 TInt listerr = aList->Append(*s); |
|
2946 if (KErrNone != listerr) |
|
2947 { |
|
2948 RDebug::Printf("Error: Adding to list failed %d", listerr); |
|
2949 } |
|
2950 (*aList)[0].iTimersRunning += 1; |
|
2951 timer->After(expireTime); |
|
2952 //First time here. Lets start timer to make many timers. |
|
2953 if (aList->Count() == 1) |
|
2954 { |
|
2955 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
2956 p->Start(KTimerStartInterval, KTimerStartInterval, TCallBack( |
|
2957 StartTimerAndAddToListCB, reinterpret_cast<TAny*> (aList) )); |
|
2958 (*aList)[0].iStartTimer = p; |
|
2959 } |
|
2960 RDebug::Printf("StartTimerAndAddToList: timers running %d", |
|
2961 (*aList)[0].iTimersRunning); |
|
2962 RDebug::Printf("StartTimerAndAddToList: list->Count() %d", aList->Count()); |
|
2963 if (aList->Count() == numberOfTimers) |
|
2964 { |
|
2965 ((*aList)[0].iStartTimer->Cancel()); |
|
2966 } |
|
2967 return 1; // nada |
|
2968 } |
|
2969 |
|
2970 // -------------------------------------------------------------------------- |
|
2971 // Starts timer and adds it to list given as param |
|
2972 // -------------------------------------------------------------------------- |
|
2973 // |
|
2974 TInt CTestCFlexTimer::StopTimer( TAny* aArgument ) |
|
2975 { |
|
2976 RArray<TTimerStruct> *list = |
|
2977 reinterpret_cast<RArray<TTimerStruct>*> (aArgument); |
|
2978 RDebug::Printf("StopTimer: timers running %d", (*list)[0].iTimersRunning); |
|
2979 // Save current time |
|
2980 TTime utcNow(0); |
|
2981 utcNow.UniversalTime(); |
|
2982 (*list)[0].iTimersRunning -= 1; |
|
2983 (*list)[(*list)[0].iCurrentlyActive].iEResult->iTimerStoppedTime |
|
2984 = utcNow.Int64(); |
|
2985 if ((*list)[0].iTimersRunning == 0) |
|
2986 { |
|
2987 (*list)[0].iStartTimer->Cancel(); |
|
2988 CActiveScheduler::Stop(); |
|
2989 } |
|
2990 return 1; // nada |
|
2991 } |
|
2992 // -------------------------------------------------------------------------- |
|
2993 // Try to configure timer ans see that correct error code is returned |
|
2994 // -------------------------------------------------------------------------- |
|
2995 // |
|
2996 TInt CTestCFlexTimer::ConfigureKErrInUseArray( TAny* aArgument ) |
|
2997 { |
|
2998 RDebug::Printf("ConfigureKErrInUseArray"); |
|
2999 RArray<TTimerStruct> *list = |
|
3000 reinterpret_cast<RArray<TTimerStruct>*> (aArgument); |
|
3001 TInt error = (*list)[(*list)[0].iCurrentlyActive].iTimer->Configure( |
|
3002 TTimeIntervalMicroSeconds(12 * 1000 * 1000)); |
|
3003 if (KErrInUse != error) |
|
3004 { |
|
3005 (*list)[(*list)[0].iCurrentlyActive].iEResult->iCaseAlreadyFailed |
|
3006 = ETrue; |
|
3007 _LIT(KError,"Error: Wrong return code 64bit if\n"); |
|
3008 (*list)[(*list)[0].iCurrentlyActive].iEResult->iTestResult->SetResult( |
|
3009 KErrGeneral, KError); |
|
3010 return 1; |
|
3011 } |
|
3012 //Try same with 32 bit if |
|
3013 error = (*list)[(*list)[0].iCurrentlyActive].iTimer->Configure( |
|
3014 TTimeIntervalMicroSeconds32(12 * 1000 * 1000)); |
|
3015 if (KErrInUse != error) |
|
3016 { |
|
3017 (*list)[(*list)[0].iCurrentlyActive].iEResult->iCaseAlreadyFailed |
|
3018 = ETrue; |
|
3019 _LIT(KError,"Error: Wrong return code 32bit if\n"); |
|
3020 (*list)[(*list)[0].iCurrentlyActive].iEResult->iTestResult->SetResult( |
|
3021 KErrGeneral, KError); |
|
3022 } |
|
3023 return 1; // nada |
|
3024 } |
|
3025 |
|
3026 // -------------------------------------------------------------------------- |
|
3027 // start timer again |
|
3028 // -------------------------------------------------------------------------- |
|
3029 // |
|
3030 TInt CTestCFlexTimer::StartTimerAgainArray( TAny* aArgument ) |
|
3031 { |
|
3032 RDebug::Printf("StartTimerAgainArray"); |
|
3033 RArray<TTimerStruct> *list = |
|
3034 reinterpret_cast<RArray<TTimerStruct>*> (aArgument); |
|
3035 (*list)[(*list)[0].iCurrentlyActive].iTimer->After( |
|
3036 TTimeIntervalMicroSeconds(12 * 1000 * 1000)); |
|
3037 return 1; // nada |
|
3038 } |
|
3039 // -------------------------------------------------------------------------- |
|
3040 // Start two timers and see that they expire at the same time. |
|
3041 // -------------------------------------------------------------------------- |
|
3042 // |
|
3043 TInt CTestCFlexTimer::CpuLoadCreateAndExpireTwoOverlappingAfterTimersL( |
|
3044 TTestResult& aResult, CTestFlexTimer *cb ) |
|
3045 { |
|
3046 TTestResult *res1 = new TTestResult(); |
|
3047 TTestResult *res2 = new TTestResult(); |
|
3048 TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); |
|
3049 TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); |
|
3050 |
|
3051 |
|
3052 eResult1->iTimerID = 1; |
|
3053 eResult2->iTimerID = 2; |
|
3054 |
|
3055 CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( |
|
3056 CActive::EPriorityStandard, |
|
3057 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
3058 eResult1)); |
|
3059 CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( |
|
3060 CActive::EPriorityStandard, |
|
3061 TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, |
|
3062 eResult2)); |
|
3063 |
|
3064 // Expire in 10 seconds |
|
3065 TTimeIntervalMicroSeconds32 expireTime1(10 * 1000 * 1000); |
|
3066 //Expire within first timers default window |
|
3067 TTimeIntervalMicroSeconds32 expireTime2(static_cast<TInt64> ((10 * 1000 |
|
3068 * 1000 - static_cast<float> (10 * 1000 * 1000) |
|
3069 * KDefaultWindowMultiplier))); |
|
3070 |
|
3071 // Save current time |
|
3072 TTime utcNow(0); |
|
3073 utcNow.UniversalTime(); |
|
3074 |
|
3075 timer1->After(expireTime1); |
|
3076 timer2->After(expireTime2); |
|
3077 |
|
3078 //Timer to stop active scheduler after timers under test are completed. |
|
3079 CPeriodic *p = CPeriodic::NewL(EPriorityNormal); |
|
3080 |
|
3081 p->Start(15 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); |
|
3082 |
|
3083 MSTIFTestInterference* interference = MSTIFTestInterference::NewL( |
|
3084 cb, MSTIFTestInterference::EThread ); |
|
3085 |
|
3086 // Start interference to generate 99% CPU load (100 ms load, 1% idle) |
|
3087 interference->StartL( MSTIFTestInterference::ECpuLoad, 1, 100 ); |
|
3088 // Start scheduler and wait for callback to stop it |
|
3089 CActiveScheduler::Start(); |
|
3090 interference->Stop(); |
|
3091 delete interference; |
|
3092 |
|
3093 delete p; |
|
3094 |
|
3095 // Check results |
|
3096 TInt64 timer1RightWin = |
|
3097 utcNow.Int64() + static_cast<TInt64>(expireTime1.Int()); |
|
3098 TInt64 timer2RightWin = |
|
3099 utcNow.Int64() + static_cast<TInt64>(expireTime2.Int()); |
|
3100 TInt64 timer1LeftWin = timer2RightWin - static_cast<TInt64>( |
|
3101 (static_cast<TReal64>(expireTime1.Int()) * KDefaultWindowMultiplier)); |
|
3102 TInt64 timer2LeftWin = timer2RightWin - static_cast<TInt64>( |
|
3103 (static_cast<TReal64>(expireTime2.Int()) * KDefaultWindowMultiplier)); |
|
3104 TInt64 timer1StopedTime = eResult1->iTimerStoppedTime; |
|
3105 TInt64 timer2StopedTime = eResult2->iTimerStoppedTime; |
|
3106 |
|
3107 //See if Timer 1 Callback has failed the case |
|
3108 if (eResult1->iCaseAlreadyFailed) |
|
3109 { |
|
3110 _LIT( KDescription ,"Timer 1 has failed" ); |
|
3111 aResult.SetResult( KErrGeneral, KDescription ); |
|
3112 } |
|
3113 //See if Timer 2 Callback has failed the case |
|
3114 else if (eResult2->iCaseAlreadyFailed) |
|
3115 { |
|
3116 _LIT( KDescription,"Timer 2 has failed" ); |
|
3117 aResult.SetResult( KErrGeneral, KDescription ); |
|
3118 } |
|
3119 // Check if timer 1 has timed out too early |
|
3120 else if ((timer1StopedTime + KTickResolution) < timer1LeftWin) |
|
3121 { |
|
3122 _LIT( KDescription, "Timer 1 timed out too early" ); |
|
3123 aResult.SetResult( KErrGeneral, KDescription ); |
|
3124 } |
|
3125 // Check if timer 1 has timed out too Late |
|
3126 else if ((timer1StopedTime - KTimerAccuracyMicroSeconds) > timer1RightWin) |
|
3127 { |
|
3128 _LIT( KDescription, "Timer 1 timed out too late" ); |
|
3129 aResult.SetResult( KErrGeneral, KDescription ); |
|
3130 } |
|
3131 // Check if timer 2 has timed out too early |
|
3132 else if ((timer2StopedTime + KTickResolution) < timer2LeftWin) |
|
3133 { |
|
3134 _LIT( KDescription, "Timer 2 timed out too early" ); |
|
3135 aResult.SetResult( KErrGeneral, KDescription ); |
|
3136 } |
|
3137 // Check if timer 2 has timed out too Late |
|
3138 else if ((timer2StopedTime - KTimerAccuracyMicroSeconds - KExtraSlack) > timer2RightWin) |
|
3139 { |
|
3140 _LIT( KDescription, "Timer 2 timed out too late" ); |
|
3141 aResult.SetResult( KErrGeneral, KDescription ); |
|
3142 } |
|
3143 // Check that the timers 1 and 2 timed out at the same time |
|
3144 else if (((timer1StopedTime + KTimerAccuracyMicroSeconds) < timer2StopedTime) || |
|
3145 ((timer1StopedTime - KTimerAccuracyMicroSeconds) > timer2StopedTime)) |
|
3146 { |
|
3147 _LIT( KDescription, "Timers 1 and 2 did not timeout at the same time" ); |
|
3148 aResult.SetResult( KErrGeneral, KDescription ); |
|
3149 } |
|
3150 // Everything was successful |
|
3151 else |
|
3152 { |
|
3153 _LIT( KDescription, "Passed" ); |
|
3154 aResult.SetResult( KErrNone, KDescription ); |
|
3155 } |
|
3156 |
|
3157 // Case was executed |
|
3158 delete timer1; |
|
3159 delete timer2; |
|
3160 delete eResult1; |
|
3161 delete eResult2; |
|
3162 delete res1; |
|
3163 delete res2; |
|
3164 |
|
3165 return KErrNone; |
|
3166 } |
|
3167 // -------------------------------------------------------------------------- |
|
3168 // Start many timers and see that nothing goes wrong when they are expired at rapid sequence |
|
3169 // -------------------------------------------------------------------------- |
|
3170 // |
|
3171 TInt CTestCFlexTimer::CpuLoadManyTimersL( |
|
3172 TTestResult& aResult, CTestFlexTimer *cb ) |
|
3173 { |
|
3174 RDebug::Printf("CpuLoadManyTimersL"); |
|
3175 // This list will contain all the timer structs, expiry times etc. |
|
3176 // First cell will always tell which timer is currently active |
|
3177 // active info is transferred from e.g. InheritedCFlexTimer2::RunL to CB function |
|
3178 RArray<TTimerStruct> timers; |
|
3179 // This CB contains all the logic about timer addition |
|
3180 StartTimerAndAddToList( &timers, 100 ); |
|
3181 |
|
3182 MSTIFTestInterference* interference = MSTIFTestInterference::NewL( |
|
3183 cb, MSTIFTestInterference::EThread ); |
|
3184 // Start interference to generate 99% CPU load (100 ms load, 1% idle) |
|
3185 interference->StartL( MSTIFTestInterference::ECpuLoad, 1, 50 ); |
|
3186 // Start scheduler and wait for callback to stop it |
|
3187 CActiveScheduler::Start(); |
|
3188 interference->Stop(); |
|
3189 delete interference; |
|
3190 |
|
3191 // Delete CPeriodic that was used to launch new FlexTimers |
|
3192 delete timers[0].iStartTimer; |
|
3193 _LIT( KDescriptionP , "Passed"); |
|
3194 aResult.SetResult(KErrNone, KDescriptionP); |
|
3195 // Loop throug list and see if timers fired within limits. |
|
3196 // also delete all stuff reserved earlier by StartTimerAndAddToList |
|
3197 while (timers.Count()) |
|
3198 { |
|
3199 TInt64 rightWin = timers[0].iEResult->iTimerStartedTime + |
|
3200 timers[0].iEResult->iTimerExpiryTime; |
|
3201 TInt64 leftWin = rightWin - |
|
3202 (static_cast<float> (timers[0].iEResult->iTimerExpiryTime) * |
|
3203 KDefaultWindowMultiplier); |
|
3204 TInt64 stopTime = timers[0].iEResult->iTimerStoppedTime; |
|
3205 |
|
3206 // Have fun with reading this. It is not as bad as it looks |
|
3207 // Just checks if CB already failed the case |
|
3208 // and if timer was launched within its window(default) and timer accuracy |
|
3209 if (timers[0].iEResult->iCaseAlreadyFailed) |
|
3210 { |
|
3211 _LIT( KDescription , "Case was failed earlier for unknown reason."); |
|
3212 aResult.SetResult(KErrGeneral, KDescription); |
|
3213 } |
|
3214 // Check if timer has expired before the window has started. |
|
3215 else if((stopTime + KTickResolution) < leftWin) |
|
3216 { |
|
3217 _LIT( KDescription , "Some timer has expired too soon"); |
|
3218 aResult.SetResult(KErrGeneral, KDescription); |
|
3219 } |
|
3220 // Check if timeout has happened too long time after window end. |
|
3221 else if (stopTime > (rightWin + KTimerAccuracyMicroSeconds + KExtraSlack)) |
|
3222 { |
|
3223 _LIT( KDescription , "Some timer has expired too late"); |
|
3224 aResult.SetResult(KErrGeneral, KDescription); |
|
3225 } |
|
3226 delete timers[0].iEResult->iTestResult; |
|
3227 delete timers[0].iEResult; |
|
3228 delete timers[0].iTimer; |
|
3229 timers.Remove(0); |
|
3230 } |
|
3231 // Case was executed |
|
3232 timers.Close(); |
|
3233 return KErrNone; |
|
3234 } |
|
3235 |
|
3236 // ======== GLOBAL FUNCTIONS ======== |
|