|
1 // Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of the License "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // e32test/domainmgr/t_domain_monitor.cpp |
|
15 // Overview: |
|
16 // Domain manager transition monitoring feature implementation tests |
|
17 // |
|
18 // API Information: |
|
19 // RDmDomain, RDmDomainManager CDmDomain, CDmDomainManager,CDmDomanKeepAlive |
|
20 // |
|
21 // - Domain member deferral and acknowledgments tests |
|
22 // - Domain manager policy interface tests |
|
23 // - Domain member deferral requests Platsec capability checking tests |
|
24 // |
|
25 // Platforms/Drives/Compatibility: |
|
26 // All. |
|
27 // Assumptions/Requirement/Pre-requisites: |
|
28 // Failures and causes: |
|
29 // Base Port information: |
|
30 // |
|
31 |
|
32 #define __E32TEST_EXTENSION__ |
|
33 |
|
34 #include <e32test.h> |
|
35 #include <e32ldr_private.h> |
|
36 |
|
37 #include <domainobserver.h> |
|
38 |
|
39 #include "domainpolicytest.h" |
|
40 |
|
41 #include "t_domain.h" |
|
42 |
|
43 |
|
44 RTest test(_L(" T_DOMAIN_MONITOR ")); |
|
45 |
|
46 |
|
47 /** |
|
48 Domain member deferral requests PlatSec capability checking tests. |
|
49 */ |
|
50 _LIT(KSecuritySlavePath1, "t_dmslave_nocaps.exe"); |
|
51 _LIT(KSecuritySlavePath2, "t_dmslave_wdd.exe"); |
|
52 _LIT(KSecuritySlavePath3, "t_dmslave_protsrv.exe"); |
|
53 |
|
54 class CDmTestPlatSec : public CActive, public MDmTest |
|
55 { |
|
56 public: |
|
57 CDmTestPlatSec(TPtrC aFileName); |
|
58 ~CDmTestPlatSec() |
|
59 { |
|
60 Cancel(); |
|
61 iManager.Close(); |
|
62 } |
|
63 // from CActive |
|
64 void RunL(); |
|
65 // from MDmTest |
|
66 void Perform(); |
|
67 void Release(); |
|
68 TInt TransitionNotification(MDmDomainMember&) |
|
69 { |
|
70 test(0); |
|
71 return KErrNone; |
|
72 } |
|
73 void TransitionRequestComplete() |
|
74 {} |
|
75 private: |
|
76 // from CActive |
|
77 virtual void DoCancel() |
|
78 { |
|
79 test(0); |
|
80 } |
|
81 private: |
|
82 RDmDomainManager iManager; |
|
83 const TPtrC iFileName; |
|
84 }; |
|
85 |
|
86 |
|
87 CDmTestPlatSec::CDmTestPlatSec(TPtrC aFileName) |
|
88 : CActive(CActive::EPriorityStandard), iFileName(aFileName) |
|
89 {} |
|
90 |
|
91 |
|
92 void CDmTestPlatSec::Perform() |
|
93 { |
|
94 test.Next(_L("CDmTestPlatSec")); |
|
95 |
|
96 // 1. Set up test hierarchy/domain & join it |
|
97 TInt r = RDmDomainManager::AddDomainHierarchy(KDmHierarchyIdTestV2); |
|
98 test_KErrNone(r); |
|
99 r = iManager.Connect(KDmHierarchyIdTestV2); |
|
100 test_KErrNone(r); |
|
101 |
|
102 // 2. Create a child process |
|
103 RProcess proc; |
|
104 r = proc.Create(iFileName, KNullDesC); |
|
105 test_KErrNone(r); |
|
106 |
|
107 // Start process & wait until child has set up itself (3. & 4.) |
|
108 TRequestStatus status; |
|
109 proc.Rendezvous(status); |
|
110 proc.Resume(); |
|
111 User::WaitForRequest(status); |
|
112 test_KErrNone(status.Int()); |
|
113 |
|
114 // 5. Transition test domain to some other state (child: 6. & 7.) |
|
115 CActiveScheduler::Add(this); |
|
116 iManager.RequestDomainTransition(KDmIdTestA, EShutdownNonCritical, ETraverseDefault, iStatus); |
|
117 CActive::SetActive(); |
|
118 CActiveScheduler::Start(); |
|
119 |
|
120 // Child processes do: TC 3.1, 3.2, 3.3 |
|
121 |
|
122 CLOSE_AND_WAIT(proc); |
|
123 } |
|
124 |
|
125 |
|
126 void CDmTestPlatSec::RunL() |
|
127 { |
|
128 RDebug::Printf("CDmTestPlatSec::RunL(): %d", iStatus.Int()); |
|
129 CActiveScheduler::Stop(); |
|
130 } |
|
131 |
|
132 |
|
133 void CDmTestPlatSec::Release() |
|
134 { |
|
135 delete this; |
|
136 } |
|
137 |
|
138 |
|
139 /** |
|
140 Checks that upon transition acknowledgment, outstanding deferral is |
|
141 completed with KErrCompletion. |
|
142 */ |
|
143 class CDmDeferralTestCompletion : public CDmDeferralTest, public MDeferringMember |
|
144 { |
|
145 public: |
|
146 CDmDeferralTestCompletion(TDmHierarchyId aId, TDmDomainState aState) |
|
147 : CDmDeferralTest(aId, aState) |
|
148 {} |
|
149 |
|
150 ~CDmDeferralTestCompletion() |
|
151 { |
|
152 delete iKeepAlive; |
|
153 } |
|
154 |
|
155 void DoPerform() |
|
156 { |
|
157 test.Next(_L("CDmDeferralTestCompletion\n")); |
|
158 |
|
159 iMember = new CDmTestMember(iHierarchyId, KDmIdTestA, 0, this); |
|
160 test_NotNull(iMember); |
|
161 |
|
162 iKeepAlive = new CTestKeepAlive(iMember->iDomain); |
|
163 test_NotNull(iKeepAlive); |
|
164 |
|
165 iManager.RequestSystemTransition(iState, ETraverseChildrenFirst, CActive::iStatus); |
|
166 } |
|
167 |
|
168 void HandleEndOfDeferrals(TInt aError) |
|
169 { |
|
170 test.Printf(_L("End of deferrals\n")); |
|
171 |
|
172 // This is the test (TC 1.1.1.2.1): |
|
173 |
|
174 test_Equal(KErrCompletion, aError); |
|
175 } |
|
176 |
|
177 TInt TransitionNotification(MDmDomainMember& /*aDomainMember*/) |
|
178 { |
|
179 iKeepAlive->BeginDeferrals(this, 1); |
|
180 return KErrNone; |
|
181 } |
|
182 |
|
183 void TransitionRequestComplete() |
|
184 { |
|
185 } |
|
186 private: |
|
187 CTestKeepAlive* iKeepAlive; |
|
188 }; |
|
189 |
|
190 |
|
191 /** |
|
192 Checks that after deferring a given number of times, the deferral |
|
193 after fails with KErrNotSupported. |
|
194 */ |
|
195 class CDmDeferralTestKErrNotSupported : public CDmDeferralTest, public MDeferringMember |
|
196 { |
|
197 public: |
|
198 /** |
|
199 @param aCount Number of deferrals to attempt |
|
200 */ |
|
201 CDmDeferralTestKErrNotSupported(TDmHierarchyId aId, TDmDomainState aState, TInt aCount) |
|
202 : CDmDeferralTest(aId, aState), iCount(aCount) |
|
203 {} |
|
204 |
|
205 ~CDmDeferralTestKErrNotSupported() |
|
206 { |
|
207 delete iKeepAlive; |
|
208 } |
|
209 |
|
210 // from CDmDeferralTest |
|
211 void DoPerform() |
|
212 { |
|
213 test.Next(_L("CDmDeferralTestKErrNotSupported\n")); |
|
214 test.Printf(_L("CDmDeferralTestKErrNotSupported: Hierachy %d, state %d, attempt %d deferrals\n"), |
|
215 iHierarchyId, iState, iCount); |
|
216 |
|
217 iMember = new CDmTestMember(iHierarchyId, KDmIdTestA, 0, this); |
|
218 test_NotNull(iMember); |
|
219 |
|
220 iKeepAlive = new CTestKeepAlive(iMember->iDomain); |
|
221 test_NotNull(iKeepAlive); |
|
222 |
|
223 iManager.RequestSystemTransition(iState, ETraverseChildrenFirst, CActive::iStatus); |
|
224 } |
|
225 |
|
226 // from MDeferringMember |
|
227 void HandleEndOfDeferrals(TInt aError) |
|
228 { |
|
229 iMember->Acknowledge(); |
|
230 |
|
231 test.Printf(_L("CDmDeferralTestKErrNotSupported: End of deferrals %d\n"), aError); |
|
232 // This is the test (TC 1.1.1.3.1, TC 1.1.1.3.2, TC 1.1.1.3.3): |
|
233 test_Equal(KErrNotSupported, aError); |
|
234 } |
|
235 |
|
236 // from MDmTest |
|
237 TInt TransitionNotification(MDmDomainMember& /*aDomainMember*/) |
|
238 { |
|
239 iKeepAlive->BeginDeferrals(this, iCount); |
|
240 return KErrAbort; // Don't acknowledge yet |
|
241 } |
|
242 |
|
243 void TransitionRequestComplete() |
|
244 { |
|
245 RDebug::Printf("CDmDeferralTestKErrNotSupported::TransitionRequestComplete()"); |
|
246 test_KErrNone(iStatus.Int()); |
|
247 } |
|
248 private: |
|
249 CTestKeepAlive* iKeepAlive; |
|
250 const TInt iCount; |
|
251 }; |
|
252 |
|
253 /** |
|
254 DeferAcknowledgement() with status KErrNone. |
|
255 |
|
256 1: Client receives notification, defers once and then acknowledges after the |
|
257 next notification |
|
258 2: Client receives notification, defers twice and then acknowledges after |
|
259 the next notification |
|
260 3: Client receives notification, defers once and then fails to acknowledge |
|
261 */ |
|
262 class CDmDeferralTestKErrNone : public CDmDeferralTest, public MDeferringMember |
|
263 { |
|
264 public: |
|
265 CDmDeferralTestKErrNone(TDmHierarchyId aId, TDmDomainState aState, |
|
266 TInt aDeferrals, TBool aAcknowledge); |
|
267 ~CDmDeferralTestKErrNone(); |
|
268 // from CDmDeferralTest |
|
269 void DoPerform(); |
|
270 // from MDmTest |
|
271 TInt TransitionNotification(MDmDomainMember& aDomainMember); |
|
272 void TransitionRequestComplete(); |
|
273 // from MDeferringMember |
|
274 void HandleEndOfDeferrals(TInt aError); |
|
275 |
|
276 private: |
|
277 CTestKeepAlive* iKeepAlive; |
|
278 const TInt iDeferrals; |
|
279 const TBool iAcknowledge; |
|
280 }; |
|
281 |
|
282 |
|
283 CDmDeferralTestKErrNone::CDmDeferralTestKErrNone(TDmHierarchyId aId, |
|
284 TDmDomainState aState, |
|
285 TInt aDeferrals, |
|
286 TBool aAcknowledge) |
|
287 : CDmDeferralTest(aId, aState), |
|
288 iDeferrals(aDeferrals), |
|
289 iAcknowledge(aAcknowledge) |
|
290 {} |
|
291 |
|
292 |
|
293 CDmDeferralTestKErrNone::~CDmDeferralTestKErrNone() |
|
294 { |
|
295 delete iKeepAlive; |
|
296 } |
|
297 |
|
298 |
|
299 void CDmDeferralTestKErrNone::DoPerform() |
|
300 { |
|
301 test.Next(_L("CDmDeferralTestKErrNone")); |
|
302 |
|
303 iMember = new CDmTestMember(iHierarchyId, KDmIdTestCAA, 0, this); |
|
304 test_NotNull(iMember); |
|
305 |
|
306 iKeepAlive = new CTestKeepAlive(iMember->iDomain); |
|
307 test_NotNull(iKeepAlive); |
|
308 |
|
309 iManager.RequestSystemTransition(iState, ETraverseDefault, CActive::iStatus); |
|
310 } |
|
311 |
|
312 |
|
313 void CDmDeferralTestKErrNone::HandleEndOfDeferrals(TInt aError) |
|
314 { |
|
315 test.Printf(_L("HandleEndOfDeferrals(): %d\n"), aError); |
|
316 |
|
317 // This is the test (TC 1.1.1.1.1, TC 1.1.1.1.2 , TC 1.1.1.1.3): |
|
318 |
|
319 test_Equal(KErrNone, aError); |
|
320 |
|
321 if (iAcknowledge) |
|
322 { |
|
323 RDebug::Printf(" Calling AcknowledgeLastState()"); |
|
324 iMember->iDomain.AcknowledgeLastState(); |
|
325 } |
|
326 } |
|
327 |
|
328 |
|
329 TInt CDmDeferralTestKErrNone::TransitionNotification(MDmDomainMember&) |
|
330 { |
|
331 iKeepAlive->BeginDeferrals(this, iDeferrals); |
|
332 // don't acknowledge yet |
|
333 return KErrAbort; |
|
334 } |
|
335 |
|
336 |
|
337 void CDmDeferralTestKErrNone::TransitionRequestComplete() |
|
338 { |
|
339 } |
|
340 |
|
341 |
|
342 /** |
|
343 Test mix of deferral and non-deferral clients (1.3) |
|
344 |
|
345 1: Three clients receive notification. |
|
346 2: One makes three deferrals and then acknowledges after the next notification |
|
347 3: The other two non-deferral clients acknowledge without making a deferral |
|
348 */ |
|
349 class CDmDeferralMixed : public CDmDeferralTest, public MDeferringMember |
|
350 { |
|
351 public: |
|
352 CDmDeferralMixed(TDmHierarchyId aId, TDmDomainState aState, TInt aDeferrals, TBool aAcknowledge, TBool aDelayAck); |
|
353 ~CDmDeferralMixed(); |
|
354 // from CDmDeferralTest |
|
355 void DoPerform(); |
|
356 // from MDmTest |
|
357 TInt TransitionNotification(MDmDomainMember& aDomainMember); |
|
358 void TransitionRequestComplete(); |
|
359 // from MDeferringMember |
|
360 void HandleEndOfDeferrals(TInt aError); |
|
361 |
|
362 private: |
|
363 CTestKeepAlive* iKeepAlive; |
|
364 CDmTestMember* iMixedDeferralTestMember[2]; |
|
365 const TInt iDeferrals; |
|
366 const TBool iAcknowledge; |
|
367 TBool iDoneDeferral; |
|
368 const TBool iDelayAck; |
|
369 TBool iNonMemberAck[2]; |
|
370 MDmDomainMember* iFirstMemberToCompleteAddr; |
|
371 }; |
|
372 |
|
373 CDmDeferralMixed::CDmDeferralMixed(TDmHierarchyId aId, |
|
374 TDmDomainState aState, |
|
375 TInt aDeferrals, |
|
376 TBool aAcknowledge, |
|
377 TBool aDelayAck) |
|
378 :CDmDeferralTest(aId, aState), |
|
379 iDeferrals(aDeferrals), |
|
380 iAcknowledge(aAcknowledge), |
|
381 iDelayAck(aDelayAck) |
|
382 { |
|
383 iDoneDeferral=EFalse; |
|
384 iFirstMemberToCompleteAddr = NULL; |
|
385 iNonMemberAck[0]=EFalse; |
|
386 iNonMemberAck[1]=EFalse; |
|
387 } |
|
388 |
|
389 CDmDeferralMixed::~CDmDeferralMixed() |
|
390 { |
|
391 delete iKeepAlive; |
|
392 delete iMixedDeferralTestMember[0]; |
|
393 delete iMixedDeferralTestMember[1]; |
|
394 } |
|
395 |
|
396 void CDmDeferralMixed::DoPerform() |
|
397 { |
|
398 test.Next(_L("CDmDeferralMixed")); |
|
399 |
|
400 // Attach three test members to the same domain (KDmIdTestCAA). One of the test |
|
401 // member is a deferring member while the other two are non deferring members. |
|
402 iMember = new CDmTestMember(iHierarchyId, KDmIdTestCAA, 0, this); |
|
403 test_NotNull(iMember); |
|
404 |
|
405 iMixedDeferralTestMember[0] = new CDmTestMember(iHierarchyId, KDmIdTestCAA, 0, this); |
|
406 test_NotNull(iMixedDeferralTestMember[0]); |
|
407 |
|
408 iMixedDeferralTestMember[1] = new CDmTestMember(iHierarchyId, KDmIdTestCAA, 0, this); |
|
409 test_NotNull(iMixedDeferralTestMember[1]); |
|
410 |
|
411 iManager.RequestSystemTransition(iState, ETraverseDefault, CActive::iStatus); |
|
412 } |
|
413 |
|
414 void CDmDeferralMixed::HandleEndOfDeferrals(TInt aError) |
|
415 { |
|
416 test.Printf(_L("HandleEndOfDeferrals(): %d\n"), aError); |
|
417 test_Equal(KErrNone, aError); |
|
418 if (iAcknowledge) |
|
419 { |
|
420 RDebug::Printf(" Calling AcknowledgeLastState()"); |
|
421 //iFirstMemberToCompleteAddr is the first member to complete and is deferred |
|
422 static_cast<CDmTestMember*>(iFirstMemberToCompleteAddr)->iDomain.AcknowledgeLastState(); |
|
423 iDoneDeferral = ETrue; |
|
424 } |
|
425 } |
|
426 |
|
427 TInt CDmDeferralMixed::TransitionNotification(MDmDomainMember& aDomainMember) |
|
428 { |
|
429 RDebug::Printf("CDmDeferralMixed::TransitionNotification()"); |
|
430 |
|
431 // if first member to complete, take note of this member and defer. |
|
432 if (iFirstMemberToCompleteAddr == NULL) |
|
433 { |
|
434 iFirstMemberToCompleteAddr = &aDomainMember; // Get address of first member to complete |
|
435 iKeepAlive = new CTestKeepAlive(static_cast<CDmTestMember*>(iFirstMemberToCompleteAddr)->iDomain); |
|
436 test_NotNull(iKeepAlive); |
|
437 } |
|
438 |
|
439 if ( (!iDoneDeferral) && (&aDomainMember == iFirstMemberToCompleteAddr) ) // Defer |
|
440 { |
|
441 //TC 1.3.1 Define a client to defer 3 times and then acknowledge and include 2 non deferring clients |
|
442 test.Printf(_L("CDmDeferralMixed Attempting %d deferrals\n"), iDeferrals); |
|
443 iKeepAlive->BeginDeferrals(this, iDeferrals); |
|
444 return KErrAbort;// don't acknowledge yet |
|
445 } |
|
446 else if (iNonMemberAck[0]== EFalse) |
|
447 {//One of the two non deferring clients which acknowledges without any delay |
|
448 iNonMemberAck[0]= ETrue; |
|
449 test.Printf(_L("CDmDeferralMixed acknowledging iMixedDeferralTestMember - 1 \n")); |
|
450 return KErrNone; // Non deferral memeber acknowledges on time |
|
451 } |
|
452 else if (iNonMemberAck[1]== EFalse ) |
|
453 {//One of the two non deferring clients which acknowledges with and without a delay based on the state of iDelayAck |
|
454 iNonMemberAck[1]= ETrue; |
|
455 if(!iDelayAck) |
|
456 { |
|
457 test.Printf(_L("CDmDeferralMixed acknowledging iMixedDeferralTestMember - 2 \n")); |
|
458 return KErrNone; // Non deferral member acknowledges on time |
|
459 } |
|
460 else |
|
461 { |
|
462 test.Printf(_L("CDmDeferralMixed delaying acknowledgement for iMixedDeferralTestMember - 2 \n")); |
|
463 //TC 1.3.2 - 1 fails to acknowledge in time |
|
464 return KErrAbort; // Delay acknowlegdement |
|
465 } |
|
466 } |
|
467 test(EFalse); |
|
468 //default |
|
469 return KErrNone; |
|
470 } |
|
471 |
|
472 void CDmDeferralMixed::TransitionRequestComplete() |
|
473 { |
|
474 RDebug::Printf("CDmDeferralMixed::TransitionRequestComplete()"); |
|
475 } |
|
476 |
|
477 /////////////////////////////////////////////// CDmKeepAlive Test cases /////////////////////////////////////////////// |
|
478 |
|
479 //------------------------------------------------- |
|
480 // Domain member deferral and acknowledgments tests |
|
481 //------------------------------------------------- |
|
482 |
|
483 class MDomainMemberTests; |
|
484 class CDomainMemberKeepAlive; |
|
485 const TUint KMembersMax = 32; |
|
486 |
|
487 // Policy related service functions user by the CDmDomainKeepAlive tests |
|
488 SDmStateSpecV1 Get0DeferralState() |
|
489 { |
|
490 TUint i = 0; |
|
491 for (i=0; i<StateSpecificationSize; i++) |
|
492 { |
|
493 if(StateSpecification[i].iDeferralLimit != 0) |
|
494 continue; |
|
495 return StateSpecification[i]; |
|
496 } |
|
497 |
|
498 // We could not find any state that has a 0 deferral specified in the policy |
|
499 test(0); |
|
500 return StateSpecification[i]; // get rid of compiler warnings |
|
501 } |
|
502 |
|
503 // Get the first minimal deferral state from the policy greater than 0 |
|
504 SDmStateSpecV1 GetMinDeferralState() |
|
505 { |
|
506 SDmStateSpecV1 maxState, minState; |
|
507 maxState = StateSpecification[0]; |
|
508 minState = StateSpecification[0]; |
|
509 |
|
510 for (TUint i=0; i<StateSpecificationSize; i++) |
|
511 { |
|
512 if(StateSpecification[i].iDeferralLimit != 0) |
|
513 { |
|
514 if(StateSpecification[i].iDeferralLimit > maxState.iDeferralLimit) |
|
515 maxState = StateSpecification[i]; |
|
516 if(StateSpecification[i].iDeferralLimit < minState.iDeferralLimit) |
|
517 { |
|
518 minState = StateSpecification[i]; |
|
519 } |
|
520 else if(minState.iDeferralLimit == 0) |
|
521 minState = StateSpecification[i]; |
|
522 } |
|
523 continue; |
|
524 } |
|
525 |
|
526 test.Printf(_L("minState's TimeoutMs = %d , count = %d\n"), minState.iTimeoutMs, minState.iDeferralLimit ); |
|
527 |
|
528 // Test whether there exists atleast one minimal deferral state that is greater than 0 deferrals and less than max deferrals |
|
529 test(minState.iDeferralLimit > 0 && minState.iDeferralLimit < maxState.iDeferralLimit); |
|
530 return minState; |
|
531 } |
|
532 |
|
533 // Get the max deferral state from the policy. This is a simple function that always gets the first max deferral from the list |
|
534 // The parameter aContinueOnError is used to get a state eith maximum deferral that has the policy error as |
|
535 // ETransitionFailureContinue or ETransitionFailureStop |
|
536 SDmStateSpecV1 GetMaxDeferralState(TBool aContinueOnError = EFalse) |
|
537 { |
|
538 SDmStateSpecV1 aState; |
|
539 aState = StateSpecification[0]; |
|
540 |
|
541 TUint i; |
|
542 for (i=0; i<StateSpecificationSize; i++) |
|
543 { |
|
544 const SDmStateSpecV1& spec = StateSpecification[i]; |
|
545 |
|
546 if((spec.iDeferralLimit > aState.iDeferralLimit) && |
|
547 (spec.iFailurePolicy == aContinueOnError ? ETransitionFailureContinue : ETransitionFailureStop)) |
|
548 { |
|
549 aState = StateSpecification[i]; |
|
550 } |
|
551 } |
|
552 |
|
553 // Check that a suitable state was found |
|
554 test(aState.iFailurePolicy == aContinueOnError ? ETransitionFailureContinue : ETransitionFailureStop); |
|
555 |
|
556 test.Printf(_L("Max deferrral state's TimeoutMs = %d , count = %d, failure policy %d\n"), aState.iTimeoutMs, aState.iDeferralLimit, aState.iFailurePolicy); |
|
557 return aState; |
|
558 } |
|
559 |
|
560 // CDmDomainKeepAliveTest test |
|
561 //------------------------------------------------- |
|
562 // Domain member deferral and acknowledgments tests |
|
563 //------------------------------------------------- |
|
564 class CDmDomainKeepAliveTest : public CActive, public MDmTest |
|
565 { |
|
566 public: |
|
567 // from CActive |
|
568 void RunL(); |
|
569 |
|
570 // from MDmTest |
|
571 void Perform(); |
|
572 void Release(); |
|
573 TInt TransitionNotification(MDmDomainMember& aDomainMember); |
|
574 void TransitionRequestComplete() {}; |
|
575 |
|
576 // for the individual tests to handle |
|
577 void HandleTransitionL(CDomainMemberKeepAlive* aDmMember); |
|
578 TInt HandleDeferralError(TInt aError); |
|
579 |
|
580 CDmDomainKeepAliveTest() : CActive(CActive::EPriorityStandard) {} |
|
581 void SetExpectedValues(TInt aTestNotificationsExpected, TInt aTransitionsExpected); |
|
582 void ValidateTestResults(); |
|
583 void RequestSystemTransition(TDmDomainState aTestState, TDmTraverseDirection aDirection); |
|
584 void DoAsynMemberAck(); |
|
585 void CancelTransition(); |
|
586 protected: |
|
587 // from CActive |
|
588 virtual void DoCancel(); |
|
589 |
|
590 private: |
|
591 void Init(MDomainMemberTests* aTest); |
|
592 void UnInit(); |
|
593 |
|
594 private: |
|
595 CDomainMemberKeepAlive* iTestMembers[KMembersMax]; |
|
596 RDmDomainManager iTestDomainManager; |
|
597 |
|
598 MDomainMemberTests* iCurrentTest; |
|
599 |
|
600 public: |
|
601 static TUint gTestMemberCount; |
|
602 static TUint gLeafMemberCount; |
|
603 TInt iTestNotifications; |
|
604 TInt iTestNotificationsExpected; |
|
605 |
|
606 TInt iTransitionsCompleted; |
|
607 TInt iTransitionsExpected; |
|
608 }; |
|
609 |
|
610 // CDomainMemberKeepAlive |
|
611 class CDomainMemberKeepAlive : public CDmDomainKeepAlive, public MDmDomainMember |
|
612 { |
|
613 public: |
|
614 static CDomainMemberKeepAlive* NewL(TDmHierarchyId aHierarchy, TDmDomainId aId, TUint32 aOrdinal, MDomainMemberTests*); |
|
615 ~CDomainMemberKeepAlive(); |
|
616 |
|
617 // from CDmDomainKeepAlive |
|
618 TInt HandleDeferralError(TInt aError); |
|
619 void HandleTransitionL(); |
|
620 |
|
621 // from MDmDomainMember |
|
622 inline TDmHierarchyId HierarchyId() {return iHierarchy;}; |
|
623 inline TDmDomainId DomainId() {return iId;}; |
|
624 inline TDmDomainState State() {return iState;}; |
|
625 inline TInt Status() {return iStatus.Int();}; |
|
626 inline TUint32 Ordinal() {return iOrdinal;}; |
|
627 inline TInt Notifications() {return iNotifications;}; |
|
628 static TInt TimerCallback(TAny* obj); |
|
629 void DoAsynHandleTransition(const TTimeIntervalMicroSeconds32 aInterval); |
|
630 private: |
|
631 CDomainMemberKeepAlive(TDmHierarchyId aHierarchy, TDmDomainId aId, TUint32 aOrdinal, MDomainMemberTests*); |
|
632 |
|
633 public: |
|
634 // used only for test cases TC 1.1.2.2.2, TC 1.1.2.3.1 and TC 1.1.2.3.2 where DoAsynMemberAck is used |
|
635 TBool iShouldAck; |
|
636 |
|
637 private: |
|
638 TDmHierarchyId iHierarchy; |
|
639 TDmDomainId iId; |
|
640 TDmDomainState iState; |
|
641 TUint32 iOrdinal; |
|
642 MDomainMemberTests* iTest; |
|
643 TUint iNotifications; |
|
644 |
|
645 CPeriodic* iTimer; |
|
646 }; |
|
647 |
|
648 class MDomainMemberTests |
|
649 { |
|
650 public: |
|
651 virtual void Perform() = 0; |
|
652 virtual void Release() = 0; |
|
653 virtual void HandleTransitionL(CDomainMemberKeepAlive* aDmMember) = 0; |
|
654 virtual TInt HandleDeferralError(TInt aError) = 0; |
|
655 virtual void DoAsynHandleTransition(CDomainMemberKeepAlive*) {}; |
|
656 virtual void DoAsynMemberAck(CDomainMemberKeepAlive*) {}; |
|
657 public: |
|
658 TDmDomainState iTestState; |
|
659 }; |
|
660 |
|
661 CDomainMemberKeepAlive* CDomainMemberKeepAlive::NewL(TDmHierarchyId aHierarchy, TDmDomainId aId, TUint32 aOrdinal, MDomainMemberTests* aTest) |
|
662 { |
|
663 CDomainMemberKeepAlive* self=new (ELeave) CDomainMemberKeepAlive(aHierarchy, aId, aOrdinal, aTest); |
|
664 CleanupStack::PushL(self); |
|
665 self->ConstructL(); |
|
666 |
|
667 self->RequestTransitionNotification(); |
|
668 |
|
669 CleanupStack::Pop(); |
|
670 return self; |
|
671 } |
|
672 |
|
673 CDomainMemberKeepAlive::~CDomainMemberKeepAlive() |
|
674 { |
|
675 delete iTimer; |
|
676 Cancel(); |
|
677 } |
|
678 |
|
679 CDomainMemberKeepAlive::CDomainMemberKeepAlive(TDmHierarchyId aHierarchy, TDmDomainId aId, TUint32 aOrdinal, MDomainMemberTests* aTest): |
|
680 CDmDomainKeepAlive(aHierarchy, aId), iShouldAck(EFalse), |
|
681 iHierarchy(aHierarchy), iId(aId), iOrdinal(aOrdinal), iTest(aTest) |
|
682 { |
|
683 } |
|
684 |
|
685 TInt CDomainMemberKeepAlive::HandleDeferralError(TInt aError) |
|
686 { |
|
687 TInt r = KErrNone; |
|
688 |
|
689 TBuf16<4> buf; |
|
690 GetDomainDesc(Ordinal(), buf); |
|
691 test.Printf(_L("HandleDeferralError domain = %S, error = %d\n"), &buf, aError); |
|
692 |
|
693 r = iTest->HandleDeferralError(aError); |
|
694 return r; |
|
695 } |
|
696 |
|
697 void CDomainMemberKeepAlive::HandleTransitionL() |
|
698 { |
|
699 iShouldAck = ETrue; |
|
700 iNotifications++; |
|
701 iTest->HandleTransitionL(this); |
|
702 } |
|
703 |
|
704 TInt CDomainMemberKeepAlive::TimerCallback(TAny* obj) |
|
705 { |
|
706 CDomainMemberKeepAlive* member = static_cast<CDomainMemberKeepAlive*>(obj); |
|
707 |
|
708 TBuf16<4> buf; |
|
709 GetDomainDesc(member->Ordinal(), buf); |
|
710 |
|
711 test.Printf(_L("Member asynchronous transition handler, domain = %S\n"), &buf); |
|
712 |
|
713 member->iTest->DoAsynHandleTransition(member); |
|
714 member->iTimer->Cancel(); |
|
715 return KErrNone; |
|
716 } |
|
717 |
|
718 void CDomainMemberKeepAlive::DoAsynHandleTransition(const TTimeIntervalMicroSeconds32 aInterval) |
|
719 { |
|
720 iTimer = CPeriodic::NewL(CActive::EPriorityHigh); |
|
721 |
|
722 TCallBack callback(TimerCallback, this); |
|
723 iTimer->Start(aInterval, aInterval, callback); |
|
724 } |
|
725 |
|
726 //////////////////////////////////////////////////////////////////////////////////// |
|
727 // TC 1.1.2.1.1 (with deferral count 0) // |
|
728 //////////////////////////////////////////////////////////////////////////////////// |
|
729 class TestTransitionWithDeferral0 : public MDomainMemberTests // TC 1.1.2.1.1 (with deferral count 0) |
|
730 { |
|
731 public: |
|
732 TestTransitionWithDeferral0(CDmDomainKeepAliveTest& aTester) : iTester(aTester) {} |
|
733 // from MDmKeepAliveTest |
|
734 void Perform(); |
|
735 void Release(); |
|
736 void HandleTransitionL(CDomainMemberKeepAlive* aDmMember); |
|
737 TInt HandleDeferralError(TInt aError); |
|
738 |
|
739 private: |
|
740 CDmDomainKeepAliveTest& iTester; |
|
741 }; |
|
742 |
|
743 void TestTransitionWithDeferral0::Perform() |
|
744 { |
|
745 test.Printf(_L("****************TestTransitionWithDeferral0****************\n")); |
|
746 test.Next(_L("Test state transition that has 0 deferral")); |
|
747 test.Printf(_L("Acknowleding immediately......\n")); |
|
748 |
|
749 iTester.SetExpectedValues(iTester.gTestMemberCount, 1); |
|
750 |
|
751 SDmStateSpecV1 aStateSpec = Get0DeferralState(); |
|
752 |
|
753 iTestState = aStateSpec.iState; |
|
754 |
|
755 // request a system transition |
|
756 iTester.RequestSystemTransition(iTestState, ETraverseChildrenFirst); |
|
757 test.Printf(_L("Requested system transition\n")); |
|
758 |
|
759 // wait for test transitions to complete |
|
760 CActiveScheduler::Start(); |
|
761 test.Printf(_L("....transition completed\n")); |
|
762 |
|
763 iTester.ValidateTestResults(); |
|
764 } |
|
765 |
|
766 void TestTransitionWithDeferral0::Release() |
|
767 { |
|
768 delete this; |
|
769 } |
|
770 |
|
771 void TestTransitionWithDeferral0::HandleTransitionL(CDomainMemberKeepAlive* aDmMember) |
|
772 { |
|
773 TInt ackError = iTester.TransitionNotification(*aDmMember); |
|
774 aDmMember->GetState(); |
|
775 |
|
776 aDmMember->AcknowledgeLastState(ackError); |
|
777 } |
|
778 |
|
779 TInt TestTransitionWithDeferral0::HandleDeferralError(TInt aError) |
|
780 { |
|
781 // Since this test case expects 0 deferral, the KErrNotSupported will happen which is expected |
|
782 test(aError == KErrNotSupported); |
|
783 return KErrNone; |
|
784 } |
|
785 |
|
786 //////////////////////////////////////////////////////////////////////////////////// |
|
787 // TC 1.1.2.1.1 (with max deferral count - ack after n deferrals // |
|
788 //////////////////////////////////////////////////////////////////////////////////// |
|
789 class TestAckWithinDeferral : public MDomainMemberTests |
|
790 { |
|
791 public: |
|
792 TestAckWithinDeferral(CDmDomainKeepAliveTest& aTester) : iTester(aTester) {} |
|
793 // from MDmKeepAliveTest |
|
794 void Perform(); |
|
795 void Release(); |
|
796 void HandleTransitionL(CDomainMemberKeepAlive* aDmMember); |
|
797 TInt HandleDeferralError(TInt aError); |
|
798 void DoAsynHandleTransition(CDomainMemberKeepAlive* aDmMember); |
|
799 private: |
|
800 CDmDomainKeepAliveTest& iTester; |
|
801 TUint iTransitionTime; |
|
802 }; |
|
803 |
|
804 void TestAckWithinDeferral::Perform() |
|
805 { |
|
806 test.Printf(_L("****************TestAckWithinDeferral****************\n")); |
|
807 test.Next(_L("Test state transition that has deferral > 0")); |
|
808 test.Printf(_L("Acknowleding immediately......\n")); |
|
809 |
|
810 iTester.SetExpectedValues(iTester.gTestMemberCount, 1); |
|
811 |
|
812 SDmStateSpecV1 aStateSpec = GetMaxDeferralState(); |
|
813 |
|
814 iTestState = aStateSpec.iState; |
|
815 iTransitionTime = aStateSpec.iTimeoutMs * aStateSpec.iDeferralLimit / 2; |
|
816 |
|
817 // request a system transition |
|
818 iTester.RequestSystemTransition(iTestState, ETraverseChildrenFirst); |
|
819 test.Printf(_L("Requested system transition\n")); |
|
820 |
|
821 // wait for test transitions to complete |
|
822 CActiveScheduler::Start(); |
|
823 test.Printf(_L(".......transition completed\n")); |
|
824 |
|
825 iTester.ValidateTestResults(); |
|
826 } |
|
827 |
|
828 void TestAckWithinDeferral::Release() |
|
829 { |
|
830 delete this; |
|
831 } |
|
832 |
|
833 void TestAckWithinDeferral::HandleTransitionL(CDomainMemberKeepAlive* aDmMember) |
|
834 { |
|
835 iTester.TransitionNotification(*aDmMember); |
|
836 |
|
837 aDmMember->GetState(); |
|
838 |
|
839 const TTimeIntervalMicroSeconds32 KInterval = iTransitionTime * 1000; // policy defines in millisec - convert it to microsec |
|
840 |
|
841 aDmMember->DoAsynHandleTransition(KInterval); |
|
842 } |
|
843 |
|
844 TInt TestAckWithinDeferral::HandleDeferralError(TInt aError) |
|
845 { |
|
846 // Since this test case expects acknowledging within the deferral, the KErrCompletion will happen which is expected |
|
847 test_Equal(KErrCompletion, aError); |
|
848 return KErrNone; |
|
849 } |
|
850 |
|
851 /* By now atleast 3 deferrals should have got finished */ |
|
852 void TestAckWithinDeferral::DoAsynHandleTransition(CDomainMemberKeepAlive* aDmMember) |
|
853 { |
|
854 aDmMember->AcknowledgeLastState(KErrNone); |
|
855 } |
|
856 |
|
857 //////////////////////////////////////////////////////////////////////////////////// |
|
858 // TC 1.1.2.2.1 (But still ongoing with other domain) // |
|
859 //////////////////////////////////////////////////////////////////////////////////// |
|
860 class TestAckAfterDomainDeferralExpiry : public MDomainMemberTests |
|
861 { |
|
862 public: |
|
863 TestAckAfterDomainDeferralExpiry(CDmDomainKeepAliveTest& aTester) : iTester(aTester) {} |
|
864 // from MDmKeepAliveTest |
|
865 void Perform(); |
|
866 void Release(); |
|
867 void HandleTransitionL(CDomainMemberKeepAlive* aDmMember); |
|
868 TInt HandleDeferralError(TInt aError); |
|
869 void DoAsynHandleTransition(CDomainMemberKeepAlive* aDmMember); |
|
870 private: |
|
871 CDmDomainKeepAliveTest& iTester; |
|
872 TUint iTransitionTime; |
|
873 }; |
|
874 |
|
875 void TestAckAfterDomainDeferralExpiry::Perform() |
|
876 { |
|
877 test.Printf(_L("****************TestAckAfterDomainDeferralExpiry****************\n")); |
|
878 test.Next(_L("Test client that does not acknowledge within the allowed number of deferrals ")); |
|
879 test.Printf(_L("but which then acknowledges while transition still ongoing (in other domain)\n")); |
|
880 |
|
881 iTester.SetExpectedValues(iTester.gTestMemberCount, 1); |
|
882 |
|
883 SDmStateSpecV1 aStateSpec = GetMaxDeferralState(ETrue); |
|
884 |
|
885 iTestState = aStateSpec.iState; |
|
886 iTransitionTime = aStateSpec.iTimeoutMs * aStateSpec.iDeferralLimit * 2; |
|
887 |
|
888 // request a system transition |
|
889 iTester.RequestSystemTransition(iTestState, ETraverseChildrenFirst); |
|
890 test.Printf(_L("Requested system transition\n")); |
|
891 |
|
892 // wait for test transitions to complete |
|
893 CActiveScheduler::Start(); |
|
894 test.Printf(_L(".......transition completed\n")); |
|
895 |
|
896 iTester.ValidateTestResults(); |
|
897 } |
|
898 |
|
899 void TestAckAfterDomainDeferralExpiry::Release() |
|
900 { |
|
901 delete this; |
|
902 } |
|
903 |
|
904 void TestAckAfterDomainDeferralExpiry::HandleTransitionL(CDomainMemberKeepAlive* aDmMember) |
|
905 { |
|
906 iTester.TransitionNotification(*aDmMember); |
|
907 |
|
908 aDmMember->GetState(); |
|
909 |
|
910 const TTimeIntervalMicroSeconds32 KInterval = iTransitionTime * 1000; // policy defines in millisec - convert it to microsec |
|
911 |
|
912 aDmMember->DoAsynHandleTransition(KInterval); |
|
913 } |
|
914 |
|
915 TInt TestAckAfterDomainDeferralExpiry::HandleDeferralError(TInt aError) |
|
916 { |
|
917 // We expect the KErrNotSupported happens after expiring the deferral counts |
|
918 test(aError == KErrNotSupported); |
|
919 return KErrNone; |
|
920 } |
|
921 |
|
922 /* By the time this function is called the server would have transitioned this member |
|
923 under the domain and would have moved on to the next domain */ |
|
924 void TestAckAfterDomainDeferralExpiry::DoAsynHandleTransition(CDomainMemberKeepAlive* aDmMember) |
|
925 { |
|
926 aDmMember->AcknowledgeLastState(KErrNone); |
|
927 } |
|
928 |
|
929 //////////////////////////////////////////////////////////////////////////////////// |
|
930 // TC 1.1.2.2.2 // |
|
931 //////////////////////////////////////////////////////////////////////////////////// |
|
932 class TestAckAfterTransitionCompletes : public MDomainMemberTests |
|
933 { |
|
934 public: |
|
935 TestAckAfterTransitionCompletes(CDmDomainKeepAliveTest& aTester) : iTester(aTester) {} |
|
936 // from MDmKeepAliveTest |
|
937 void Perform(); |
|
938 void Release(); |
|
939 void HandleTransitionL(CDomainMemberKeepAlive* aDmMember); |
|
940 TInt HandleDeferralError(TInt aError); |
|
941 void DoAsynMemberAck(CDomainMemberKeepAlive* aDmMember); |
|
942 private: |
|
943 CDmDomainKeepAliveTest& iTester; |
|
944 TInt iExpectedErrorCode; |
|
945 }; |
|
946 |
|
947 void TestAckAfterTransitionCompletes::Perform() |
|
948 { |
|
949 test.Printf(_L("****************TestAckAfterTransitionCompletes****************\n")); |
|
950 |
|
951 test.Next(_L("Test client that does not acknowledge within the allowed number of deferrals ")); |
|
952 test.Printf(_L("but which then acknowledges while transition has completed\n")); |
|
953 |
|
954 iTester.SetExpectedValues(iTester.gTestMemberCount, 1); |
|
955 |
|
956 SDmStateSpecV1 aStateSpec = GetMaxDeferralState(ETrue); |
|
957 |
|
958 iTestState = aStateSpec.iState; |
|
959 |
|
960 // request a system transition |
|
961 iTester.RequestSystemTransition(iTestState, ETraverseChildrenFirst); |
|
962 test.Printf(_L("Requested system transition\n")); |
|
963 |
|
964 // wait for test transitions to complete |
|
965 CActiveScheduler::Start(); |
|
966 test.Printf(_L(".......transition completed\n")); |
|
967 |
|
968 iTester.ValidateTestResults(); |
|
969 |
|
970 iTester.DoAsynMemberAck(); |
|
971 } |
|
972 |
|
973 void TestAckAfterTransitionCompletes::Release() |
|
974 { |
|
975 delete this; |
|
976 } |
|
977 |
|
978 void TestAckAfterTransitionCompletes::HandleTransitionL(CDomainMemberKeepAlive* aDmMember) |
|
979 { |
|
980 iTester.TransitionNotification(*aDmMember); |
|
981 aDmMember->GetState(); |
|
982 } |
|
983 |
|
984 void TestAckAfterTransitionCompletes::DoAsynMemberAck(CDomainMemberKeepAlive* aDmMember) |
|
985 { |
|
986 aDmMember->AcknowledgeLastState(KErrNone); |
|
987 } |
|
988 |
|
989 TInt TestAckAfterTransitionCompletes::HandleDeferralError(TInt aError) |
|
990 { |
|
991 test(aError == KErrNotSupported); |
|
992 return KErrNone; |
|
993 } |
|
994 |
|
995 //////////////////////////////////////////////////////////////////////////////////// |
|
996 // TC 1.1.2.2.3 and TC 1.1.2.2.4 // |
|
997 //////////////////////////////////////////////////////////////////////////////////// |
|
998 class TestAckPrevTransAfterNewTransStart : public MDomainMemberTests |
|
999 { |
|
1000 public: |
|
1001 TestAckPrevTransAfterNewTransStart(CDmDomainKeepAliveTest& aTester, TBool aAckPrevTran) : |
|
1002 iShouldAck(EFalse), iAckPrevTran(aAckPrevTran), iTester(aTester) {} |
|
1003 // from MDmKeepAliveTest |
|
1004 void Perform(); |
|
1005 void Release(); |
|
1006 void HandleTransitionL(CDomainMemberKeepAlive* aDmMember); |
|
1007 TInt HandleDeferralError(TInt aError); |
|
1008 |
|
1009 private: |
|
1010 TBool iShouldAck; |
|
1011 TBool iAckPrevTran; |
|
1012 CDmDomainKeepAliveTest& iTester; |
|
1013 }; |
|
1014 |
|
1015 void TestAckPrevTransAfterNewTransStart::Perform() |
|
1016 { |
|
1017 if(iAckPrevTran) |
|
1018 { |
|
1019 test.Printf(_L("**************** TestAckPrevTransAfterNewTransStart (Ack Previous Transition after new transition started) ****************\n")); |
|
1020 test.Next(_L("Test client that does not acknowledge within the allowed number of deferrals ")); |
|
1021 test.Printf(_L("but which then acknowledges while next new transition has started\n")); |
|
1022 } |
|
1023 else |
|
1024 { |
|
1025 test.Printf(_L("**************** TestAckPrevTransAfterNewTransStart (Never Ack Previous Transition) ****************\n")); |
|
1026 test.Next(_L("Test client that does not acknowledge within the allowed number of deferrals ")); |
|
1027 test.Printf(_L("but which never acknowledges and continues handling next transition\n")); |
|
1028 } |
|
1029 |
|
1030 iTester.SetExpectedValues(iTester.gTestMemberCount, 1); |
|
1031 |
|
1032 SDmStateSpecV1 aStateSpec = GetMaxDeferralState(ETrue); |
|
1033 |
|
1034 iTestState = aStateSpec.iState; |
|
1035 |
|
1036 // request a system transition |
|
1037 iTester.RequestSystemTransition(iTestState, ETraverseChildrenFirst); |
|
1038 test.Printf(_L("Requested system transition\n")); |
|
1039 |
|
1040 // wait for test transitions to complete |
|
1041 CActiveScheduler::Start(); |
|
1042 test.Printf(_L("....transition completed\n")); |
|
1043 |
|
1044 iTester.ValidateTestResults(); |
|
1045 |
|
1046 if(iAckPrevTran) |
|
1047 test.Printf(_L("Now request another transition for which the domain members should ack both transitions)\n")); |
|
1048 else |
|
1049 test.Printf(_L("Now request another transition for which the domain members should ack only the last transitions)\n")); |
|
1050 |
|
1051 iTester.SetExpectedValues(iTester.gTestMemberCount*2, 2); |
|
1052 aStateSpec = GetMinDeferralState(); |
|
1053 iTestState = aStateSpec.iState; |
|
1054 |
|
1055 iShouldAck = ETrue; |
|
1056 // request a system transition |
|
1057 iTester.RequestSystemTransition(iTestState, ETraverseChildrenFirst); |
|
1058 test.Printf(_L("Requested system transition\n")); |
|
1059 |
|
1060 // wait for test transitions to complete |
|
1061 CActiveScheduler::Start(); |
|
1062 test.Printf(_L("....transition completed\n")); |
|
1063 |
|
1064 iTester.ValidateTestResults(); |
|
1065 } |
|
1066 |
|
1067 void TestAckPrevTransAfterNewTransStart::Release() |
|
1068 { |
|
1069 delete this; |
|
1070 } |
|
1071 |
|
1072 void TestAckPrevTransAfterNewTransStart::HandleTransitionL(CDomainMemberKeepAlive* aDmMember) |
|
1073 { |
|
1074 TInt ackError = iTester.TransitionNotification(*aDmMember); |
|
1075 if(iShouldAck == EFalse) |
|
1076 { |
|
1077 aDmMember->GetState(); |
|
1078 // request another notification (even if we didn't acknowledge the last one) |
|
1079 aDmMember->RequestTransitionNotification(); |
|
1080 test.Printf(_L("....Return without acknowledging\n")); |
|
1081 return; |
|
1082 } |
|
1083 |
|
1084 if(iAckPrevTran) |
|
1085 { |
|
1086 test.Printf(_L("....Acknowledge the first transition\n")); |
|
1087 /* First ack the previous notification */ |
|
1088 aDmMember->AcknowledgeLastState(ackError); |
|
1089 } |
|
1090 else |
|
1091 { |
|
1092 test.Printf(_L("Skipping to acknowledge the first transition...\n")); |
|
1093 /* We are not going to ack the previous notification handled in the above if condition |
|
1094 Intentionally not acking and continuing to do a GetState to handle the next notification */ |
|
1095 } |
|
1096 |
|
1097 test.Printf(_L("Acknowledge the second transition\n")); |
|
1098 /* Now handle the current notification */ |
|
1099 aDmMember->GetState(); |
|
1100 aDmMember->AcknowledgeLastState(ackError); |
|
1101 } |
|
1102 |
|
1103 TInt TestAckPrevTransAfterNewTransStart::HandleDeferralError(TInt aError) |
|
1104 { |
|
1105 if(!iShouldAck) |
|
1106 test(aError == KErrNotSupported); |
|
1107 else |
|
1108 test_Equal(KErrCompletion, aError); |
|
1109 |
|
1110 return KErrNone; |
|
1111 } |
|
1112 |
|
1113 //////////////////////////////////////////////////////////////////////////////////// |
|
1114 // TC 1.1.2.3.1 and TC 1.1.2.3.2 // |
|
1115 //////////////////////////////////////////////////////////////////////////////////// |
|
1116 class TestCancelTransitonWithMemberAck : public MDomainMemberTests |
|
1117 { |
|
1118 public: |
|
1119 TestCancelTransitonWithMemberAck(CDmDomainKeepAliveTest& aTester, TInt aErrorCode) : |
|
1120 iTester(aTester), iCancelCount(0), iErrorCode(aErrorCode) {} |
|
1121 // from MDmKeepAliveTest |
|
1122 void Perform(); |
|
1123 void Release(); |
|
1124 void HandleTransitionL(CDomainMemberKeepAlive* aDmMember); |
|
1125 TInt HandleDeferralError(TInt aError); |
|
1126 void DoAsynMemberAck(CDomainMemberKeepAlive* aDmMember); |
|
1127 static TInt CancelTransitionTimerCallback(TAny* obj); |
|
1128 static TInt DelayTimerCallback(TAny* obj); |
|
1129 void StopScheduler(); |
|
1130 private: |
|
1131 CDmDomainKeepAliveTest& iTester; |
|
1132 TUint iTransitionTime; |
|
1133 TUint iCancelCount; |
|
1134 TInt iErrorCode; |
|
1135 CPeriodic *iCancelTransitionTimer; |
|
1136 CPeriodic *iDelayTimer; |
|
1137 }; |
|
1138 |
|
1139 TInt TestCancelTransitonWithMemberAck::CancelTransitionTimerCallback(TAny* obj) |
|
1140 { |
|
1141 TestCancelTransitonWithMemberAck* thisTest = static_cast<TestCancelTransitonWithMemberAck*>(obj); |
|
1142 |
|
1143 thisTest->iTester.CancelTransition(); |
|
1144 thisTest->iCancelTransitionTimer->Cancel(); |
|
1145 return KErrNone; |
|
1146 } |
|
1147 |
|
1148 TInt TestCancelTransitonWithMemberAck::DelayTimerCallback(TAny* obj) |
|
1149 { |
|
1150 TestCancelTransitonWithMemberAck* thisTest = static_cast<TestCancelTransitonWithMemberAck*>(obj); |
|
1151 |
|
1152 thisTest->iDelayTimer->Cancel(); |
|
1153 thisTest->StopScheduler(); |
|
1154 return KErrNone; |
|
1155 } |
|
1156 |
|
1157 void TestCancelTransitonWithMemberAck::StopScheduler() |
|
1158 { |
|
1159 CActiveScheduler::Stop(); |
|
1160 } |
|
1161 |
|
1162 void TestCancelTransitonWithMemberAck::Perform() |
|
1163 { |
|
1164 test.Printf(_L("****************TestCancelTransitonWithMemberAck****************\n")); |
|
1165 test.Next(_L("Test state transition cancelation....")); |
|
1166 test.Printf(_L("that acknowledes KErrNone......\n")); |
|
1167 |
|
1168 iTester.SetExpectedValues(iTester.gLeafMemberCount, 1); |
|
1169 |
|
1170 SDmStateSpecV1 aStateSpec = GetMaxDeferralState(); |
|
1171 |
|
1172 iTestState = aStateSpec.iState; |
|
1173 iTransitionTime = aStateSpec.iTimeoutMs * aStateSpec.iDeferralLimit / 2; |
|
1174 |
|
1175 // request a system transition |
|
1176 iTester.RequestSystemTransition(iTestState, ETraverseChildrenFirst); |
|
1177 test.Printf(_L("Requested system transition\n")); |
|
1178 |
|
1179 iCancelTransitionTimer = CPeriodic::NewL(CActive::EPriorityHigh); |
|
1180 |
|
1181 TCallBack cancelCb(CancelTransitionTimerCallback, this); |
|
1182 iCancelTransitionTimer->Start(aStateSpec.iTimeoutMs, aStateSpec.iTimeoutMs, cancelCb); |
|
1183 |
|
1184 // wait for test transitions to complete |
|
1185 CActiveScheduler::Start(); |
|
1186 test.Printf(_L("....transition cancelled\n")); |
|
1187 |
|
1188 iDelayTimer = CPeriodic::NewL(CActive::EPriorityStandard); |
|
1189 |
|
1190 TCallBack delayCb(DelayTimerCallback, this); |
|
1191 TUint delayTime = iTransitionTime * 3; |
|
1192 iDelayTimer->Start(delayTime, delayTime, delayCb); |
|
1193 |
|
1194 CActiveScheduler::Start(); |
|
1195 test.Printf(_L("........expected members got cancelation notified\n")); |
|
1196 |
|
1197 iTester.DoAsynMemberAck(); |
|
1198 |
|
1199 iTester.ValidateTestResults(); |
|
1200 } |
|
1201 |
|
1202 void TestCancelTransitonWithMemberAck::Release() |
|
1203 { |
|
1204 delete iDelayTimer; |
|
1205 delete iCancelTransitionTimer; |
|
1206 delete this; |
|
1207 } |
|
1208 |
|
1209 void TestCancelTransitonWithMemberAck::HandleTransitionL(CDomainMemberKeepAlive* aDmMember) |
|
1210 { |
|
1211 iTester.TransitionNotification(*aDmMember); |
|
1212 |
|
1213 aDmMember->GetState(); |
|
1214 } |
|
1215 |
|
1216 TInt TestCancelTransitonWithMemberAck::HandleDeferralError(TInt aError) |
|
1217 { |
|
1218 // KErrNotReady is possible if the cancellation |
|
1219 // ocurred in between member deferrrals |
|
1220 test(aError == KErrCancel || aError == KErrNotReady); |
|
1221 test(++iCancelCount <= iTester.gLeafMemberCount); |
|
1222 return KErrNone; |
|
1223 } |
|
1224 |
|
1225 void TestCancelTransitonWithMemberAck::DoAsynMemberAck(CDomainMemberKeepAlive* aDmMember) |
|
1226 { |
|
1227 aDmMember->AcknowledgeLastState(iErrorCode); |
|
1228 } |
|
1229 |
|
1230 //////////////////////////////////////////////////////////////////////////////////// |
|
1231 // TC 1.1.2.3.3 // |
|
1232 //////////////////////////////////////////////////////////////////////////////////// |
|
1233 class TestCancelTransitonNeverAck : public MDomainMemberTests // TC1.1.2.3.3 |
|
1234 { |
|
1235 public: |
|
1236 TestCancelTransitonNeverAck(CDmDomainKeepAliveTest& aTester) : iTester(aTester), iCancelCount(0), iShouldAck(EFalse){} |
|
1237 // from MDmKeepAliveTest |
|
1238 void Perform(); |
|
1239 void Release(); |
|
1240 void HandleTransitionL(CDomainMemberKeepAlive* aDmMember); |
|
1241 TInt HandleDeferralError(TInt aError); |
|
1242 static TInt CancelTransitionTimerCallback(TAny* obj); |
|
1243 static TInt DelayTimerCallback(TAny* obj); |
|
1244 void StopScheduler(); |
|
1245 private: |
|
1246 CDmDomainKeepAliveTest& iTester; |
|
1247 TUint iTransitionTime; |
|
1248 TUint iCancelCount; |
|
1249 TBool iShouldAck; |
|
1250 CPeriodic *iCancelTransitionTimer; |
|
1251 CPeriodic *iDelayTimer; |
|
1252 }; |
|
1253 |
|
1254 TInt TestCancelTransitonNeverAck::CancelTransitionTimerCallback(TAny* obj) |
|
1255 { |
|
1256 TestCancelTransitonNeverAck* thisTest = static_cast<TestCancelTransitonNeverAck*>(obj); |
|
1257 |
|
1258 thisTest->iTester.CancelTransition(); |
|
1259 thisTest->iCancelTransitionTimer->Cancel(); |
|
1260 return KErrNone; |
|
1261 } |
|
1262 |
|
1263 TInt TestCancelTransitonNeverAck::DelayTimerCallback(TAny* obj) |
|
1264 { |
|
1265 TestCancelTransitonNeverAck* thisTest = static_cast<TestCancelTransitonNeverAck*>(obj); |
|
1266 |
|
1267 thisTest->iDelayTimer->Cancel(); |
|
1268 thisTest->StopScheduler(); |
|
1269 return KErrNone; |
|
1270 } |
|
1271 |
|
1272 void TestCancelTransitonNeverAck::StopScheduler() |
|
1273 { |
|
1274 CActiveScheduler::Stop(); |
|
1275 } |
|
1276 |
|
1277 void TestCancelTransitonNeverAck::Perform() |
|
1278 { |
|
1279 test.Printf(_L("****************TestCancelTransitonNeverAck****************\n")); |
|
1280 test.Next(_L("Test state transition cancelation....")); |
|
1281 test.Printf(_L("that never acknowledes ......\n")); |
|
1282 |
|
1283 iTester.SetExpectedValues(iTester.gLeafMemberCount, 1); |
|
1284 |
|
1285 SDmStateSpecV1 aStateSpec = GetMaxDeferralState(); |
|
1286 |
|
1287 iTestState = aStateSpec.iState; |
|
1288 iTransitionTime = aStateSpec.iTimeoutMs * aStateSpec.iDeferralLimit / 2; |
|
1289 |
|
1290 // request a system transition |
|
1291 iTester.RequestSystemTransition(iTestState, ETraverseChildrenFirst); |
|
1292 test.Printf(_L("Requested system transition\n")); |
|
1293 |
|
1294 iCancelTransitionTimer = CPeriodic::NewL(CActive::EPriorityHigh); |
|
1295 |
|
1296 TCallBack cancelCb(CancelTransitionTimerCallback, this); |
|
1297 iCancelTransitionTimer->Start(iTransitionTime, iTransitionTime, cancelCb); |
|
1298 |
|
1299 // wait for test transitions to complete |
|
1300 CActiveScheduler::Start(); |
|
1301 test.Printf(_L("....transition cancelled\n")); |
|
1302 |
|
1303 iDelayTimer = CPeriodic::NewL(CActive::EPriorityStandard); |
|
1304 |
|
1305 TCallBack delayCb(DelayTimerCallback, this); |
|
1306 TUint delayTime = iTransitionTime * 3; |
|
1307 iDelayTimer->Start(delayTime, delayTime, delayCb); |
|
1308 |
|
1309 CActiveScheduler::Start(); |
|
1310 test.Printf(_L("........expected members got cancelation notified\n")); |
|
1311 |
|
1312 iTester.ValidateTestResults(); |
|
1313 |
|
1314 test.Printf(_L("Now request another transition for which the domain members should ack only the last transitions)\n")); |
|
1315 |
|
1316 iTester.SetExpectedValues(iTester.gTestMemberCount + iTester.gLeafMemberCount, 2); |
|
1317 aStateSpec = GetMinDeferralState(); |
|
1318 |
|
1319 iTestState = aStateSpec.iState; |
|
1320 |
|
1321 iShouldAck = ETrue; |
|
1322 // request a system transition |
|
1323 iTester.RequestSystemTransition(iTestState, ETraverseChildrenFirst); |
|
1324 test.Printf(_L("Requested system transition\n")); |
|
1325 |
|
1326 // wait for test transitions to complete |
|
1327 CActiveScheduler::Start(); |
|
1328 test.Printf(_L(".......transition completed\n")); |
|
1329 |
|
1330 iTester.ValidateTestResults(); |
|
1331 } |
|
1332 |
|
1333 void TestCancelTransitonNeverAck::Release() |
|
1334 { |
|
1335 delete iDelayTimer; |
|
1336 delete iCancelTransitionTimer; |
|
1337 delete this; |
|
1338 } |
|
1339 |
|
1340 void TestCancelTransitonNeverAck::HandleTransitionL(CDomainMemberKeepAlive* aDmMember) |
|
1341 { |
|
1342 TInt ackError = iTester.TransitionNotification(*aDmMember); |
|
1343 |
|
1344 if(iShouldAck == EFalse) |
|
1345 { |
|
1346 aDmMember->GetState(); |
|
1347 |
|
1348 // request another notification (even if we didn't acknowledge the last one) |
|
1349 aDmMember->RequestTransitionNotification(); |
|
1350 test.Printf(_L("Return without acknowledging...\n")); |
|
1351 return; |
|
1352 } |
|
1353 |
|
1354 test.Printf(_L("Skipping to acknowledge the first transition...\n")); |
|
1355 /* We are not going to ack the previous notification handled in the above if condition |
|
1356 Intentionally not acking and continuing to do a GetState to handle the next notification */ |
|
1357 |
|
1358 test.Printf(_L("Acknowledge the second transition...\n")); |
|
1359 /* Now handle the current notification */ |
|
1360 aDmMember->GetState(); |
|
1361 aDmMember->AcknowledgeLastState(ackError); |
|
1362 } |
|
1363 |
|
1364 TInt TestCancelTransitonNeverAck::HandleDeferralError(TInt aError) |
|
1365 { |
|
1366 if(!iShouldAck) |
|
1367 { |
|
1368 // KErrNotReady is possible if the cancellation |
|
1369 // ocurred in between member deferrrals |
|
1370 test(aError == KErrCancel || aError == KErrNotReady); |
|
1371 } |
|
1372 else |
|
1373 test_Equal(KErrCompletion, aError); |
|
1374 |
|
1375 if(aError == KErrCancel || (aError == KErrNotReady && !iShouldAck)) |
|
1376 test(++iCancelCount <= iTester.gLeafMemberCount); |
|
1377 |
|
1378 return KErrNone; |
|
1379 } |
|
1380 |
|
1381 //////////////////////////////////////////////////////////////////////////////////// |
|
1382 // CDmDomainKeepAliveTest // |
|
1383 //////////////////////////////////////////////////////////////////////////////////// |
|
1384 void CDmDomainKeepAliveTest::Init(MDomainMemberTests* aTest) |
|
1385 { |
|
1386 TInt r = RDmDomainManager::AddDomainHierarchy(KDmHierarchyIdTestV2); |
|
1387 test_KErrNone(r); |
|
1388 |
|
1389 r = iTestDomainManager.Connect(KDmHierarchyIdTestV2); |
|
1390 test_KErrNone(r); |
|
1391 |
|
1392 iTransitionsCompleted = 0; |
|
1393 iTestNotifications = 0; |
|
1394 gTestMemberCount = 0; |
|
1395 gLeafMemberCount = 0; |
|
1396 |
|
1397 // Add some test hierarchy members |
|
1398 test_TRAP(iTestMembers[gTestMemberCount++] = CDomainMemberKeepAlive::NewL(KDmHierarchyIdTestV2, KDmIdRoot, ORDINAL_FROM_DOMAINID0(KDmIdRoot), aTest)); |
|
1399 |
|
1400 test_TRAP(iTestMembers[gTestMemberCount++] = CDomainMemberKeepAlive::NewL(KDmHierarchyIdTestV2, KDmIdRoot, ORDINAL_FROM_DOMAINID0(KDmIdRoot), aTest)); |
|
1401 |
|
1402 // row 1 |
|
1403 test_TRAP(iTestMembers[gTestMemberCount++] = CDomainMemberKeepAlive::NewL(KDmHierarchyIdTestV2, KDmIdTestA, ORDINAL_FROM_DOMAINID1(KDmIdRoot, KDmIdTestA), aTest)); |
|
1404 |
|
1405 test_TRAP(iTestMembers[gTestMemberCount++] = CDomainMemberKeepAlive::NewL(KDmHierarchyIdTestV2, KDmIdTestB, ORDINAL_FROM_DOMAINID1(KDmIdRoot, KDmIdTestB), aTest)); |
|
1406 |
|
1407 test_TRAP(iTestMembers[gTestMemberCount++] = CDomainMemberKeepAlive::NewL(KDmHierarchyIdTestV2, KDmIdTestC, ORDINAL_FROM_DOMAINID1(KDmIdRoot, KDmIdTestC), aTest)); |
|
1408 |
|
1409 // row2 |
|
1410 test_TRAP(iTestMembers[gTestMemberCount++] = CDomainMemberKeepAlive::NewL(KDmHierarchyIdTestV2, KDmIdTestAA, ORDINAL_FROM_DOMAINID2(KDmIdRoot, KDmIdTestA, KDmIdTestAA), aTest)); |
|
1411 gLeafMemberCount++; |
|
1412 |
|
1413 test_TRAP(iTestMembers[gTestMemberCount++] = CDomainMemberKeepAlive::NewL(KDmHierarchyIdTestV2, KDmIdTestAB, ORDINAL_FROM_DOMAINID2(KDmIdRoot, KDmIdTestA, KDmIdTestAB), aTest)); |
|
1414 |
|
1415 test_TRAP(iTestMembers[gTestMemberCount++] = CDomainMemberKeepAlive::NewL(KDmHierarchyIdTestV2, KDmIdTestBA, ORDINAL_FROM_DOMAINID2(KDmIdRoot, KDmIdTestB, KDmIdTestBA), aTest)); |
|
1416 gLeafMemberCount++; |
|
1417 |
|
1418 test_TRAP(iTestMembers[gTestMemberCount++] = CDomainMemberKeepAlive::NewL(KDmHierarchyIdTestV2, KDmIdTestCA, ORDINAL_FROM_DOMAINID2(KDmIdRoot, KDmIdTestC, KDmIdTestCA), aTest)); |
|
1419 |
|
1420 // row 3 |
|
1421 test_TRAP(iTestMembers[gTestMemberCount++] = CDomainMemberKeepAlive::NewL(KDmHierarchyIdTestV2, KDmIdTestABA, ORDINAL_FROM_DOMAINID3(KDmIdRoot, KDmIdTestA, KDmIdTestAB, KDmIdTestABA), aTest)); |
|
1422 gLeafMemberCount++; |
|
1423 |
|
1424 test_TRAP(iTestMembers[gTestMemberCount++] = CDomainMemberKeepAlive::NewL(KDmHierarchyIdTestV2, KDmIdTestABB, ORDINAL_FROM_DOMAINID3(KDmIdRoot, KDmIdTestA, KDmIdTestAB, KDmIdTestABB), aTest)); |
|
1425 gLeafMemberCount++; |
|
1426 |
|
1427 test_TRAP(iTestMembers[gTestMemberCount++] = CDomainMemberKeepAlive::NewL(KDmHierarchyIdTestV2, KDmIdTestCAA, ORDINAL_FROM_DOMAINID3(KDmIdRoot, KDmIdTestC, KDmIdTestCA, KDmIdTestCAA), aTest)); |
|
1428 gLeafMemberCount++; |
|
1429 |
|
1430 } |
|
1431 |
|
1432 void CDmDomainKeepAliveTest::SetExpectedValues(TInt aTestNotificationsExpected, TInt aTransitionsExpected) |
|
1433 { |
|
1434 iTestNotificationsExpected = aTestNotificationsExpected; |
|
1435 iTransitionsExpected = aTransitionsExpected; |
|
1436 } |
|
1437 |
|
1438 void CDmDomainKeepAliveTest::ValidateTestResults() |
|
1439 { |
|
1440 test.Printf(_L("ValidateResults().....\n")); |
|
1441 |
|
1442 test.Printf(_L("iTestNotifications = %d iTestNotificationsExpected = %d\n"), iTestNotifications , |
|
1443 iTestNotificationsExpected); |
|
1444 test(iTestNotifications == iTestNotificationsExpected); |
|
1445 } |
|
1446 |
|
1447 void CDmDomainKeepAliveTest::UnInit() |
|
1448 { |
|
1449 iTestDomainManager.Close(); |
|
1450 |
|
1451 // cleanup |
|
1452 |
|
1453 for (TUint i = 0; i<gTestMemberCount; i++) |
|
1454 delete iTestMembers[i]; |
|
1455 } |
|
1456 |
|
1457 void CDmDomainKeepAliveTest::RequestSystemTransition(TDmDomainState aTestState, TDmTraverseDirection aDirection) |
|
1458 { |
|
1459 iTestDomainManager.RequestSystemTransition(aTestState, aDirection, CActive::iStatus); |
|
1460 CActive::SetActive(); |
|
1461 } |
|
1462 |
|
1463 void CDmDomainKeepAliveTest::Perform() |
|
1464 { |
|
1465 __UHEAP_MARK; |
|
1466 |
|
1467 CActiveScheduler::Add(this); |
|
1468 |
|
1469 MDomainMemberTests* tests[] = |
|
1470 { |
|
1471 new TestTransitionWithDeferral0(*this), // TC 1.1.2.1.1 (with deferral count 0) |
|
1472 new TestAckWithinDeferral(*this), // TC 1.1.2.1.1 (with max deferral count) |
|
1473 new TestAckAfterDomainDeferralExpiry(*this), // TC 1.1.2.2.1 (But still ongoing with other domain) |
|
1474 new TestAckAfterTransitionCompletes(*this), // TC 1.1.2.2.2 |
|
1475 new TestAckPrevTransAfterNewTransStart(*this, ETrue), // TC 1.1.2.2.3 |
|
1476 new TestAckPrevTransAfterNewTransStart(*this, EFalse), // TC 1.1.2.2.4 |
|
1477 new TestCancelTransitonWithMemberAck(*this, KErrNone), // TC1.1.2.3.1 |
|
1478 new TestCancelTransitonWithMemberAck(*this, KErrCompletion), // TC1.1.2.3.2 |
|
1479 new TestCancelTransitonNeverAck(*this), // TC1.1.2.3.3 |
|
1480 }; |
|
1481 |
|
1482 for (unsigned int i = 0; i < sizeof(tests)/sizeof(*tests); ++i) |
|
1483 { |
|
1484 test(tests[i] != NULL); |
|
1485 Init(tests[i]); |
|
1486 iCurrentTest = tests[i]; |
|
1487 tests[i]->Perform(); |
|
1488 tests[i]->Release(); |
|
1489 UnInit(); |
|
1490 } |
|
1491 __UHEAP_MARKEND; |
|
1492 } |
|
1493 |
|
1494 void CDmDomainKeepAliveTest::DoAsynMemberAck() |
|
1495 { |
|
1496 for (TUint i = 0; i<gTestMemberCount; i++) |
|
1497 { |
|
1498 if(iTestMembers[i]->iShouldAck) |
|
1499 { |
|
1500 TBuf16<4> buf; |
|
1501 GetDomainDesc(iTestMembers[i]->Ordinal(), buf); |
|
1502 test.Printf(_L("Request current test to ack %S.......\n"), &buf); |
|
1503 iCurrentTest->DoAsynMemberAck(iTestMembers[i]); |
|
1504 iTestMembers[i]->iShouldAck = EFalse; |
|
1505 } |
|
1506 } |
|
1507 } |
|
1508 |
|
1509 void CDmDomainKeepAliveTest::CancelTransition() |
|
1510 { |
|
1511 iTestDomainManager.CancelTransition(); |
|
1512 } |
|
1513 |
|
1514 // This handles a transition notification from a test domain member. |
|
1515 TInt CDmDomainKeepAliveTest::TransitionNotification(MDmDomainMember& aDomainMember) |
|
1516 { |
|
1517 TInt status = aDomainMember.Status(); |
|
1518 |
|
1519 iTestNotifications++; |
|
1520 |
|
1521 test (aDomainMember.HierarchyId() == KDmHierarchyIdTestV2); |
|
1522 |
|
1523 TBuf16<4> buf; |
|
1524 GetDomainDesc(aDomainMember.Ordinal(), buf); |
|
1525 |
|
1526 test.Printf(_L("TransitionNotification Hierarchy = %d, domain = %S, iOrdinal = 0x%08X, state = 0x%x, status = %d\n"), |
|
1527 aDomainMember.HierarchyId(), &buf, aDomainMember.Ordinal(), aDomainMember.State(), status); |
|
1528 |
|
1529 return KErrNone; |
|
1530 } |
|
1531 |
|
1532 void CDmDomainKeepAliveTest::RunL() |
|
1533 { |
|
1534 iTransitionsCompleted++; |
|
1535 |
|
1536 TInt error = iStatus.Int(); |
|
1537 |
|
1538 test.Printf(_L("CDmDomainKeepAliveTest::RunL() error = %d, iTransitionsCompleted %d iTransitionsExpected %d\n"), |
|
1539 error, iTransitionsCompleted, iTransitionsExpected); |
|
1540 |
|
1541 if (iTransitionsCompleted == iTransitionsExpected) |
|
1542 CActiveScheduler::Stop(); |
|
1543 } |
|
1544 |
|
1545 void CDmDomainKeepAliveTest::DoCancel() |
|
1546 { |
|
1547 test(0); |
|
1548 } |
|
1549 |
|
1550 void CDmDomainKeepAliveTest::Release() |
|
1551 { |
|
1552 delete this; |
|
1553 } |
|
1554 |
|
1555 |
|
1556 TUint CDmDomainKeepAliveTest::gTestMemberCount = 0; |
|
1557 TUint CDmDomainKeepAliveTest::gLeafMemberCount = 0; |
|
1558 |
|
1559 |
|
1560 /** |
|
1561 DeferAcknowledgement() with status KErrServerBusy. |
|
1562 |
|
1563 Client receives notification, defers once and then defers again before the |
|
1564 next notification. |
|
1565 */ |
|
1566 class ActiveMember : public CActive |
|
1567 { |
|
1568 public: |
|
1569 ActiveMember(CDmTestMember* aMember) |
|
1570 : CActive(CActive::EPriorityHigh), iMember(aMember) |
|
1571 { |
|
1572 CActiveScheduler::Add(this); |
|
1573 } |
|
1574 ~ActiveMember() |
|
1575 { |
|
1576 Cancel(); |
|
1577 } |
|
1578 void Defer() |
|
1579 { |
|
1580 iMember->iDomain.DeferAcknowledgement(iStatus); |
|
1581 SetActive(); |
|
1582 } |
|
1583 void DoCancel() |
|
1584 { |
|
1585 iMember->iDomain.CancelDeferral(); |
|
1586 } |
|
1587 protected: |
|
1588 CDmTestMember* const iMember; |
|
1589 }; |
|
1590 |
|
1591 |
|
1592 class TestServerBusy : public ActiveMember |
|
1593 { |
|
1594 public: |
|
1595 TestServerBusy(CDmTestMember* aMember); |
|
1596 ~TestServerBusy(); |
|
1597 void PrimeTimer(); |
|
1598 private: |
|
1599 void RunL(); |
|
1600 private: |
|
1601 RTimer iTimer; |
|
1602 TBool iDeferred; |
|
1603 const TInt iInstance; |
|
1604 static TInt iInstances; |
|
1605 }; |
|
1606 |
|
1607 TInt TestServerBusy::iInstances = 0; |
|
1608 |
|
1609 |
|
1610 TestServerBusy::TestServerBusy(CDmTestMember* aMember) |
|
1611 : ActiveMember(aMember), iDeferred(EFalse), iInstance(++iInstances) |
|
1612 { |
|
1613 const TInt r = iTimer.CreateLocal(); |
|
1614 test_KErrNone(r); |
|
1615 } |
|
1616 |
|
1617 |
|
1618 TestServerBusy::~TestServerBusy() |
|
1619 { |
|
1620 Cancel(); |
|
1621 iTimer.Close(); |
|
1622 iInstances--; |
|
1623 } |
|
1624 |
|
1625 |
|
1626 void TestServerBusy::PrimeTimer() |
|
1627 { |
|
1628 // let the timers fire at different times (first one in 1ms, second one in |
|
1629 // 50ms) |
|
1630 const TTimeIntervalMicroSeconds32 t = (iInstance == 1) ? 1000 : 50000; |
|
1631 iTimer.After(iStatus, t); |
|
1632 SetActive(); |
|
1633 } |
|
1634 |
|
1635 |
|
1636 void TestServerBusy::RunL() |
|
1637 { |
|
1638 RDebug::Printf("TestServerBusy(#%d)::RunL(): %d", iInstance, iStatus.Int()); |
|
1639 if (!iDeferred) |
|
1640 { |
|
1641 iDeferred = ETrue; |
|
1642 Defer(); |
|
1643 } |
|
1644 else if (iInstance == 2) |
|
1645 { |
|
1646 // This is the test (TC 1.1.1.7.1): |
|
1647 test_Equal(KErrServerBusy, iStatus.Int()); |
|
1648 } |
|
1649 else if (iInstance == 1) |
|
1650 { |
|
1651 // Acknowledge at last |
|
1652 test_KErrNone(iStatus.Int()); |
|
1653 iMember->Acknowledge(); |
|
1654 } |
|
1655 else |
|
1656 test(0); |
|
1657 } |
|
1658 |
|
1659 |
|
1660 class CDmDeferralTestKErrServerBusy : public CDmDeferralTest |
|
1661 { |
|
1662 public: |
|
1663 CDmDeferralTestKErrServerBusy(TDmHierarchyId aId, TDmDomainState aState); |
|
1664 ~CDmDeferralTestKErrServerBusy(); |
|
1665 // from CDmDeferralTest |
|
1666 void DoPerform(); |
|
1667 // from MDmTest |
|
1668 TInt TransitionNotification(MDmDomainMember& aDomainMember); |
|
1669 void TransitionRequestComplete(); |
|
1670 private: |
|
1671 TestServerBusy* iDeferral1; |
|
1672 TestServerBusy* iDeferral2; |
|
1673 }; |
|
1674 |
|
1675 |
|
1676 CDmDeferralTestKErrServerBusy::CDmDeferralTestKErrServerBusy(TDmHierarchyId aId, |
|
1677 TDmDomainState aState) |
|
1678 : CDmDeferralTest(aId, aState) |
|
1679 { |
|
1680 } |
|
1681 |
|
1682 |
|
1683 CDmDeferralTestKErrServerBusy::~CDmDeferralTestKErrServerBusy() |
|
1684 { |
|
1685 delete iDeferral1; |
|
1686 delete iDeferral2; |
|
1687 } |
|
1688 |
|
1689 |
|
1690 void CDmDeferralTestKErrServerBusy::DoPerform() |
|
1691 { |
|
1692 test.Next(_L("CDmDeferralTestKErrServerBusy")); |
|
1693 |
|
1694 iMember = new CDmTestMember(iHierarchyId, KDmIdTestCAA, 0, this); |
|
1695 test_NotNull(iMember); |
|
1696 |
|
1697 iDeferral1 = new TestServerBusy(iMember); |
|
1698 test_NotNull(iDeferral1); |
|
1699 iDeferral2 = new TestServerBusy(iMember); |
|
1700 test_NotNull(iDeferral2); |
|
1701 |
|
1702 iManager.RequestSystemTransition(iState, ETraverseDefault, CActive::iStatus); |
|
1703 } |
|
1704 |
|
1705 |
|
1706 TInt CDmDeferralTestKErrServerBusy::TransitionNotification(MDmDomainMember&) |
|
1707 { |
|
1708 RDebug::Printf("CDmDeferralTestKErrServerBusy::TransitionNotification()"); |
|
1709 |
|
1710 iDeferral1->PrimeTimer(); |
|
1711 |
|
1712 iDeferral2->PrimeTimer(); |
|
1713 |
|
1714 // don't acknowledge yet |
|
1715 return KErrAbort; |
|
1716 } |
|
1717 |
|
1718 |
|
1719 void CDmDeferralTestKErrServerBusy::TransitionRequestComplete() |
|
1720 { |
|
1721 RDebug::Printf("CDmDeferralTestKErrServerBusy::TransitionRequestComplete()"); |
|
1722 } |
|
1723 |
|
1724 |
|
1725 /** |
|
1726 DeferAcknowledgement() with status KErrCancel. |
|
1727 |
|
1728 1. Client receives notification, defers once and then cancels before the next |
|
1729 notification. |
|
1730 2. Client receives notification, cancels deferral without one outstanding. |
|
1731 */ |
|
1732 class TestCancel : public ActiveMember |
|
1733 { |
|
1734 public: |
|
1735 TestCancel(CDmTestMember* aMember) |
|
1736 : ActiveMember(aMember) |
|
1737 { |
|
1738 } |
|
1739 void RunL() |
|
1740 { |
|
1741 RDebug::Printf("TestCancel::RunL(): %d", iStatus.Int()); |
|
1742 |
|
1743 // This is the test (TC 1.1.1.4.1): |
|
1744 test_Equal(KErrCancel, iStatus.Int()); |
|
1745 |
|
1746 // Acknowledge at last |
|
1747 iMember->Acknowledge(); |
|
1748 } |
|
1749 }; |
|
1750 |
|
1751 |
|
1752 class CDmDeferralTestKErrCancel : public CDmDeferralTest |
|
1753 { |
|
1754 public: |
|
1755 CDmDeferralTestKErrCancel(TDmHierarchyId aId, TDmDomainState aState, TBool aDeferFirst); |
|
1756 ~CDmDeferralTestKErrCancel(); |
|
1757 // from CDmDeferralTest |
|
1758 void DoPerform(); |
|
1759 // from MDmTest |
|
1760 TInt TransitionNotification(MDmDomainMember& aDomainMember); |
|
1761 void TransitionRequestComplete(); |
|
1762 private: |
|
1763 TestCancel* iCancel; |
|
1764 const TBool iDeferFirst; |
|
1765 }; |
|
1766 |
|
1767 |
|
1768 CDmDeferralTestKErrCancel::CDmDeferralTestKErrCancel(TDmHierarchyId aId, |
|
1769 TDmDomainState aState, |
|
1770 TBool aDeferFirst) |
|
1771 : CDmDeferralTest(aId, aState), iDeferFirst(aDeferFirst) |
|
1772 { |
|
1773 } |
|
1774 |
|
1775 |
|
1776 CDmDeferralTestKErrCancel::~CDmDeferralTestKErrCancel() |
|
1777 { |
|
1778 delete iCancel; |
|
1779 } |
|
1780 |
|
1781 |
|
1782 void CDmDeferralTestKErrCancel::DoPerform() |
|
1783 { |
|
1784 test.Next(_L("CDmDeferralTestKErrCancel")); |
|
1785 |
|
1786 iMember = new CDmTestMember(iHierarchyId, KDmIdTestABA, 0, this); |
|
1787 test_NotNull(iMember); |
|
1788 |
|
1789 iCancel = new TestCancel(iMember); |
|
1790 test_NotNull(iCancel); |
|
1791 |
|
1792 iManager.RequestSystemTransition(iState, ETraverseDefault, CActive::iStatus); |
|
1793 } |
|
1794 |
|
1795 |
|
1796 TInt CDmDeferralTestKErrCancel::TransitionNotification(MDmDomainMember&) |
|
1797 { |
|
1798 RDebug::Printf("CDmDeferralTestKErrCancel::TransitionNotification()"); |
|
1799 |
|
1800 if (iDeferFirst) |
|
1801 { |
|
1802 // Test case 1: First ask for a deferral... |
|
1803 iCancel->Defer(); |
|
1804 } |
|
1805 |
|
1806 // Test cases 1 & 2: Cancel deferral request. |
|
1807 |
|
1808 // RDmDomainSession::CancelDeferral() checks if |
|
1809 // RSessionBase::SendReceive(EDmStateCancelDeferral) returned KErrNone; |
|
1810 // if not it will panic the client. (TC 1.1.1.4.2) |
|
1811 |
|
1812 iMember->iDomain.CancelDeferral(); |
|
1813 |
|
1814 if (iDeferFirst) |
|
1815 { |
|
1816 // don't acknowledge yet (RunL() will) |
|
1817 return KErrAbort; |
|
1818 } |
|
1819 else |
|
1820 { |
|
1821 return KErrNone; |
|
1822 } |
|
1823 } |
|
1824 |
|
1825 |
|
1826 void CDmDeferralTestKErrCancel::TransitionRequestComplete() |
|
1827 { |
|
1828 RDebug::Printf("CDmDeferralTestKErrCancel::TransitionRequestComplete()"); |
|
1829 } |
|
1830 |
|
1831 |
|
1832 /** |
|
1833 DeferAcknowledgement() with status KErrNotReady. |
|
1834 |
|
1835 1. Client defers before a transition notification. |
|
1836 2. Client receives notification, defers once and then defers again after the |
|
1837 next notification. |
|
1838 */ |
|
1839 class TestNotReady : public ActiveMember |
|
1840 { |
|
1841 public: |
|
1842 TestNotReady(CDmTestMember* aMember) |
|
1843 : ActiveMember(aMember) |
|
1844 { |
|
1845 } |
|
1846 void RunL() |
|
1847 { |
|
1848 RDebug::Printf("TestNotReady::RunL(): %d", iStatus.Int()); |
|
1849 |
|
1850 // This is the test (TC 1.1.1.5.1): |
|
1851 test_Equal(KErrNotReady, iStatus.Int()); |
|
1852 |
|
1853 CActiveScheduler::Stop(); |
|
1854 } |
|
1855 }; |
|
1856 |
|
1857 |
|
1858 class CDmDeferralTestKErrNotReady : public CDmDeferralTest |
|
1859 { |
|
1860 public: |
|
1861 CDmDeferralTestKErrNotReady(TDmHierarchyId aId, TDmDomainState aState); |
|
1862 ~CDmDeferralTestKErrNotReady(); |
|
1863 // from CDmDeferralTest |
|
1864 void DoPerform(); |
|
1865 // from MDmTest |
|
1866 TInt TransitionNotification(MDmDomainMember& aDomainMember); |
|
1867 void TransitionRequestComplete(); |
|
1868 private: |
|
1869 TestNotReady* iNotReady; |
|
1870 }; |
|
1871 |
|
1872 |
|
1873 CDmDeferralTestKErrNotReady::CDmDeferralTestKErrNotReady(TDmHierarchyId aId, |
|
1874 TDmDomainState aState) |
|
1875 : CDmDeferralTest(aId, aState) |
|
1876 { |
|
1877 } |
|
1878 |
|
1879 |
|
1880 CDmDeferralTestKErrNotReady::~CDmDeferralTestKErrNotReady() |
|
1881 { |
|
1882 delete iNotReady; |
|
1883 } |
|
1884 |
|
1885 |
|
1886 void CDmDeferralTestKErrNotReady::DoPerform() |
|
1887 { |
|
1888 test.Next(_L("CDmDeferralTestKErrNotReady")); |
|
1889 |
|
1890 iMember = new CDmTestMember(iHierarchyId, KDmIdTestABA, 0, this); |
|
1891 test_NotNull(iMember); |
|
1892 |
|
1893 iNotReady = new TestNotReady(iMember); |
|
1894 test_NotNull(iNotReady); |
|
1895 |
|
1896 iNotReady->Defer(); |
|
1897 CActiveScheduler::Start(); |
|
1898 |
|
1899 iManager.RequestSystemTransition(iState, ETraverseDefault, CActive::iStatus); |
|
1900 } |
|
1901 |
|
1902 |
|
1903 TInt CDmDeferralTestKErrNotReady::TransitionNotification(MDmDomainMember&) |
|
1904 { |
|
1905 RDebug::Printf("CDmDeferralTestKErrNotReady::TransitionNotification()"); |
|
1906 |
|
1907 // don't acknowledge yet |
|
1908 return KErrAbort; |
|
1909 } |
|
1910 |
|
1911 |
|
1912 void CDmDeferralTestKErrNotReady::TransitionRequestComplete() |
|
1913 { |
|
1914 RDebug::Printf("CDmDeferralTestKErrNotReady::TransitionRequestComplete()"); |
|
1915 |
|
1916 TRequestStatus status; |
|
1917 iMember->iDomain.DeferAcknowledgement(status); |
|
1918 User::WaitForRequest(status); |
|
1919 |
|
1920 RDebug::Printf("Deferral status: %d", status.Int()); |
|
1921 |
|
1922 // This is the test (TC 1.1.1.5.2): |
|
1923 test_Equal(KErrNotReady, status.Int()); |
|
1924 |
|
1925 } |
|
1926 |
|
1927 |
|
1928 /** |
|
1929 Policy interface tests - negative tests. |
|
1930 |
|
1931 1. Ordinals return null or error. |
|
1932 2. Structure returned contains invalid values. |
|
1933 */ |
|
1934 class CDmPolicyInterfaceTest : public MDmTest |
|
1935 { |
|
1936 public: |
|
1937 void Perform(); |
|
1938 void Release(); |
|
1939 TInt TransitionNotification(MDmDomainMember&) |
|
1940 { |
|
1941 return KErrNone; |
|
1942 } |
|
1943 void TransitionRequestComplete() |
|
1944 {} |
|
1945 }; |
|
1946 |
|
1947 |
|
1948 void CDmPolicyInterfaceTest::Perform() |
|
1949 { |
|
1950 test.Next(_L("CDmPolicyInterfaceTest")); |
|
1951 |
|
1952 // In domainpolicy95.dll ordinal 4 (DmPolicy::GetStateSpec) returns an |
|
1953 // error. This will lead to the failure of the following call, which will |
|
1954 // also execute the destructors of classes CDmHierarchy and |
|
1955 // CHierarchySettings. |
|
1956 TInt r = RDmDomainManager::AddDomainHierarchy(KDmHierarchyIdTestV2_95); |
|
1957 |
|
1958 // This is the test (TC 1.4.2.1): |
|
1959 test_Equal(KDmErrBadDomainSpec, r); |
|
1960 |
|
1961 // domainpolicy94.dll contains garbage values in the SDmStateSpecV1 struct. |
|
1962 r = RDmDomainManager::AddDomainHierarchy(KDmHierarchyIdTestV2_94); |
|
1963 |
|
1964 // This is the test (TC 1.4.2.2): |
|
1965 test_Equal(KDmErrBadDomainSpec, r); |
|
1966 } |
|
1967 |
|
1968 |
|
1969 void CDmPolicyInterfaceTest::Release() |
|
1970 { |
|
1971 delete this; |
|
1972 } |
|
1973 |
|
1974 |
|
1975 /////////////////////// Failure Policy Tests ////////////////////////////////// |
|
1976 // 2.4 [M] Domain Controller DC5 (different failure policies for different |
|
1977 // system state transitions) |
|
1978 // * TC 2.4.1 Create V2 policy where some states are "stop" and some are |
|
1979 // "continue" on failure, get member(s) to fail |
|
1980 // |
|
1981 |
|
1982 class CDmFailurePolicyTest : public CActive, public MDmTest |
|
1983 { |
|
1984 public: |
|
1985 CDmFailurePolicyTest(TDmDomainState aState, TDmTransitionFailurePolicy aPolicy); |
|
1986 ~CDmFailurePolicyTest(); |
|
1987 |
|
1988 // from CActive |
|
1989 void RunL(); |
|
1990 |
|
1991 // from MDmTest |
|
1992 void Perform(); |
|
1993 void Release(); |
|
1994 TInt TransitionNotification(MDmDomainMember&); |
|
1995 void TransitionRequestComplete() |
|
1996 {} |
|
1997 |
|
1998 private: |
|
1999 // from CActive |
|
2000 virtual void DoCancel() |
|
2001 { test(0); } |
|
2002 |
|
2003 private: |
|
2004 RDmDomainManager iManager; |
|
2005 CDmTestMember* iMembers[2]; |
|
2006 |
|
2007 TDmDomainState iDmState; |
|
2008 TDmTransitionFailurePolicy iFailPolicy; |
|
2009 }; |
|
2010 |
|
2011 |
|
2012 CDmFailurePolicyTest::CDmFailurePolicyTest(TDmDomainState aState, TDmTransitionFailurePolicy aPolicy) |
|
2013 : CActive(CActive::EPriorityStandard), iDmState(aState), iFailPolicy(aPolicy) |
|
2014 { |
|
2015 iMembers[0] = iMembers[1] = 0; |
|
2016 } |
|
2017 |
|
2018 CDmFailurePolicyTest::~CDmFailurePolicyTest() |
|
2019 { |
|
2020 Cancel(); |
|
2021 for (int i = 0; i < 2; i++) |
|
2022 delete iMembers[i], iMembers[i]= 0; |
|
2023 iManager.Close(); |
|
2024 } |
|
2025 |
|
2026 void CDmFailurePolicyTest::Perform() |
|
2027 { |
|
2028 test.Next(_L("CDmFailurePolicyTest")); |
|
2029 |
|
2030 RDebug::Printf("CDmFailurePolicyTest::Perform: iFailPolicy(%d)", iFailPolicy); |
|
2031 |
|
2032 // 1. Set up test hierarchy/domain & join it |
|
2033 TInt r = RDmDomainManager::AddDomainHierarchy(KDmHierarchyIdTestV2); |
|
2034 test_KErrNone(r); |
|
2035 r = iManager.Connect(KDmHierarchyIdTestV2); |
|
2036 test_KErrNone(r); |
|
2037 |
|
2038 // 2. Create the two members needed for this test. First does not ackn. |
|
2039 iMembers[0] = new CDmTestMember(KDmHierarchyIdTestV2, KDmIdTestB, (iFailPolicy<<8)+0, this); |
|
2040 test_NotNull(iMembers[0]); |
|
2041 iMembers[1] = new CDmTestMember(KDmHierarchyIdTestV2, KDmIdTestBA, (iFailPolicy<<8)+1, this); |
|
2042 test_NotNull(iMembers[1]); |
|
2043 |
|
2044 // 3. Initiate state transition from iInitState to iDmState |
|
2045 CActiveScheduler::Add(this); |
|
2046 iManager.RequestDomainTransition(KDmIdTestB, iDmState, ETraverseParentsFirst, iStatus); |
|
2047 CActive::SetActive(); |
|
2048 CActiveScheduler::Start(); |
|
2049 |
|
2050 // Close iManager when this object is destroyed in destructor |
|
2051 } |
|
2052 |
|
2053 TInt CDmFailurePolicyTest::TransitionNotification(MDmDomainMember& aMember) |
|
2054 { |
|
2055 RDebug::Printf("CDmFailurePolicyTest::TransitionNotification: aMember(%d)", aMember.Ordinal()); |
|
2056 |
|
2057 if ((aMember.Ordinal() & 0xff ) == 0) // Member in domain B |
|
2058 { |
|
2059 if (((aMember.Ordinal() & 0xff00) >> 8) == 0) // Stop policy |
|
2060 { |
|
2061 return KErrAbort; // Dont let this member in domain B ackn. |
|
2062 } |
|
2063 else // Continue policy |
|
2064 { |
|
2065 return KErrCommsParity; // Ackn with bizarre error |
|
2066 } |
|
2067 } |
|
2068 |
|
2069 // Should only reach here for Members of sub-domain BA |
|
2070 return KErrNone; |
|
2071 } |
|
2072 |
|
2073 |
|
2074 void CDmFailurePolicyTest::RunL() |
|
2075 { |
|
2076 RDebug::Printf("CDmFailurePolicyTest::RunL: istatus(%d)", iStatus.Int()); |
|
2077 |
|
2078 // Handle Transition completion code here. Should be a time out. |
|
2079 |
|
2080 // Based on failure policy check to see if the second member was transitioned |
|
2081 // (continue) or whether it was not (stop). Since ETraverseParentsFirst is used |
|
2082 // in the transition iMember[0] in domain B should fail and the iMember [1] |
|
2083 // in domain BA may or may not then be transitioned.... |
|
2084 |
|
2085 test_Equal(1, iMembers[0]->Notifications()); |
|
2086 |
|
2087 if (iFailPolicy == ETransitionFailureContinue) |
|
2088 { |
|
2089 test_Equal(KErrCommsParity, iStatus.Int()); |
|
2090 test_Equal(1, iMembers[1]->Notifications()); // Proves it did continue with transition |
|
2091 } |
|
2092 else if (iFailPolicy == ETransitionFailureStop) |
|
2093 { |
|
2094 test_Equal(KErrTimedOut, iStatus.Int()); |
|
2095 test_Equal(0, iMembers[1]->Notifications()); // Proves it did stop transition |
|
2096 } |
|
2097 else |
|
2098 { |
|
2099 test(0); // Panic default case |
|
2100 } |
|
2101 |
|
2102 test.Printf(_L("Test passed - failure policy (%d)\n"), iFailPolicy); |
|
2103 |
|
2104 CActiveScheduler::Stop(); |
|
2105 } |
|
2106 |
|
2107 |
|
2108 void CDmFailurePolicyTest::Release() |
|
2109 { |
|
2110 RDebug::Printf("CDmFailurePolicyTest::Release"); |
|
2111 delete this; |
|
2112 } |
|
2113 |
|
2114 /****************************** CDmDomainKeepAlive Functional coverage test ******************************/ |
|
2115 // CDmKeepAliveFuncCov |
|
2116 class CDmKeepAliveFuncCov : public CDmDomainKeepAlive |
|
2117 { |
|
2118 public: |
|
2119 enum TMemKeepAliveCovTests { ECovHandleError, ECovDoCancel }; |
|
2120 |
|
2121 static CDmKeepAliveFuncCov* NewL(TDmHierarchyId aHierarchy, TDmDomainId aId); |
|
2122 ~CDmKeepAliveFuncCov(); |
|
2123 |
|
2124 // from CDmDomainKeepAlive |
|
2125 void HandleTransitionL(); |
|
2126 private: |
|
2127 CDmKeepAliveFuncCov(TDmHierarchyId aHierarchy, TDmDomainId aId); |
|
2128 |
|
2129 public: |
|
2130 TMemKeepAliveCovTests iDmMemCov; |
|
2131 }; |
|
2132 |
|
2133 CDmKeepAliveFuncCov* CDmKeepAliveFuncCov::NewL(TDmHierarchyId aHierarchy, TDmDomainId aId) |
|
2134 { |
|
2135 CDmKeepAliveFuncCov* self=new (ELeave) CDmKeepAliveFuncCov(aHierarchy, aId); |
|
2136 CleanupStack::PushL(self); |
|
2137 self->ConstructL(); |
|
2138 |
|
2139 self->RequestTransitionNotification(); |
|
2140 |
|
2141 CleanupStack::Pop(); |
|
2142 return self; |
|
2143 } |
|
2144 |
|
2145 CDmKeepAliveFuncCov::~CDmKeepAliveFuncCov() |
|
2146 { |
|
2147 Cancel(); |
|
2148 } |
|
2149 |
|
2150 CDmKeepAliveFuncCov::CDmKeepAliveFuncCov(TDmHierarchyId aHierarchy, TDmDomainId aId): |
|
2151 CDmDomainKeepAlive(aHierarchy, aId) |
|
2152 { |
|
2153 } |
|
2154 |
|
2155 void CDmKeepAliveFuncCov::HandleTransitionL() |
|
2156 { |
|
2157 switch(iDmMemCov) |
|
2158 { |
|
2159 case ECovHandleError: |
|
2160 // Simply ack. Since the request transition is for 0 deferral |
|
2161 // KErrNotSupported will anyways happen |
|
2162 GetState(); |
|
2163 AcknowledgeLastState(KErrNone); |
|
2164 RequestTransitionNotification(); |
|
2165 break; |
|
2166 case ECovDoCancel: |
|
2167 // do nothing, let the keep alive deferrals be active and let the CDmKeepAliveFuncCovTest delete this object |
|
2168 CActiveScheduler::Stop(); |
|
2169 break; |
|
2170 default: |
|
2171 User::Leave(KErrUnknown); |
|
2172 break; |
|
2173 } |
|
2174 } |
|
2175 |
|
2176 class CDmDomainManFuncCov : public CDmDomainManager |
|
2177 { |
|
2178 public: |
|
2179 static CDmDomainManFuncCov* NewL(TDmHierarchyId aHierarchy); |
|
2180 ~CDmDomainManFuncCov(); |
|
2181 |
|
2182 // from CDmDomainManager |
|
2183 void RunL(); |
|
2184 private: |
|
2185 CDmDomainManFuncCov(TDmHierarchyId aHierarchy); |
|
2186 }; |
|
2187 |
|
2188 CDmDomainManFuncCov* CDmDomainManFuncCov::NewL(TDmHierarchyId aHierarchy) |
|
2189 { |
|
2190 CDmDomainManFuncCov* self=new (ELeave) CDmDomainManFuncCov(aHierarchy); |
|
2191 CleanupStack::PushL(self); |
|
2192 |
|
2193 self->ConstructL(); |
|
2194 CleanupStack::Pop(); |
|
2195 return self; |
|
2196 } |
|
2197 |
|
2198 CDmDomainManFuncCov::~CDmDomainManFuncCov() |
|
2199 { |
|
2200 Cancel(); |
|
2201 } |
|
2202 |
|
2203 CDmDomainManFuncCov::CDmDomainManFuncCov(TDmHierarchyId aHierarchy) : |
|
2204 CDmDomainManager(aHierarchy) |
|
2205 { |
|
2206 } |
|
2207 |
|
2208 void CDmDomainManFuncCov::RunL() |
|
2209 { |
|
2210 CActiveScheduler::Stop(); |
|
2211 } |
|
2212 |
|
2213 class CDmKeepAliveFuncCovTest : public CActive, public MDmTest |
|
2214 { |
|
2215 public: |
|
2216 CDmKeepAliveFuncCovTest() : CActive(CActive::EPriorityStandard) {}; |
|
2217 void Perform(); |
|
2218 void Release(); |
|
2219 |
|
2220 TInt TransitionNotification(MDmDomainMember&) { return KErrNone; }; |
|
2221 void TransitionRequestComplete() {}; |
|
2222 |
|
2223 // from CActive |
|
2224 void RunL() {}; |
|
2225 virtual void DoCancel() |
|
2226 { |
|
2227 test(0); |
|
2228 } |
|
2229 |
|
2230 public: |
|
2231 CDmDomainManFuncCov* iTestDomainManager; |
|
2232 }; |
|
2233 |
|
2234 void CDmKeepAliveFuncCovTest::Perform() |
|
2235 { |
|
2236 __UHEAP_MARK; |
|
2237 |
|
2238 CActiveScheduler::Add(this); |
|
2239 |
|
2240 test.Printf(_L("****************CFunctionalCoverageTest****************\n")); |
|
2241 test.Next(_L("Test to perform code coverage")); |
|
2242 |
|
2243 TInt r = CDmDomainManager::AddDomainHierarchy(KDmHierarchyIdTestV2); |
|
2244 test(r == KErrNone); |
|
2245 |
|
2246 TRAP_IGNORE(iTestDomainManager = CDmDomainManFuncCov::NewL(KDmHierarchyIdTestV2)); |
|
2247 test (iTestDomainManager != NULL); |
|
2248 |
|
2249 CDmKeepAliveFuncCov* member = NULL; |
|
2250 // Add some test hierarchy members |
|
2251 TRAP(r, member = CDmKeepAliveFuncCov::NewL(KDmHierarchyIdTestV2, KDmIdRoot)); |
|
2252 test(member != NULL); |
|
2253 |
|
2254 SDmStateSpecV1 aStateSpec = Get0DeferralState(); |
|
2255 |
|
2256 TDmDomainState testState = aStateSpec.iState; |
|
2257 |
|
2258 // request a system transition |
|
2259 iTestDomainManager->RequestSystemTransition(testState, ETraverseChildrenFirst); |
|
2260 test.Printf(_L("Requested system transition\n")); |
|
2261 |
|
2262 member->iDmMemCov = CDmKeepAliveFuncCov::ECovHandleError; |
|
2263 |
|
2264 test.Printf(_L("HandleDeferralError functional coverage...\n")); |
|
2265 // wait for test transition to complete |
|
2266 CActiveScheduler::Start(); |
|
2267 |
|
2268 test.Printf(_L("......system transition completed\n")); |
|
2269 |
|
2270 aStateSpec = GetMaxDeferralState(); |
|
2271 testState = aStateSpec.iState; |
|
2272 |
|
2273 // request a system transition |
|
2274 iTestDomainManager->RequestSystemTransition(testState, ETraverseChildrenFirst); |
|
2275 test.Printf(_L("Requested system transition\n")); |
|
2276 |
|
2277 member->iDmMemCov = CDmKeepAliveFuncCov::ECovDoCancel; |
|
2278 test.Printf(_L("DoCancel functional coverage...\n")); |
|
2279 // wait for the member to call CActiveScheduler::Stop |
|
2280 CActiveScheduler::Start(); |
|
2281 delete member; |
|
2282 |
|
2283 // wait for test transition to complete |
|
2284 CActiveScheduler::Start(); |
|
2285 test.Printf(_L("......system transition completed\n")); |
|
2286 |
|
2287 // Add some test hierarchy members |
|
2288 TRAP(r, member = CDmKeepAliveFuncCov::NewL(KDmHierarchyIdTestV2, KDmIdRoot)); |
|
2289 test(member != NULL); |
|
2290 |
|
2291 aStateSpec = GetMaxDeferralState(); |
|
2292 testState = aStateSpec.iState; |
|
2293 |
|
2294 // request a system transition |
|
2295 iTestDomainManager->RequestSystemTransition(testState, ETraverseChildrenFirst); |
|
2296 test.Printf(_L("Requested system transition\n")); |
|
2297 |
|
2298 member->iDmMemCov = CDmKeepAliveFuncCov::ECovDoCancel; // just so that the member will call CActiveScheduler::Stop |
|
2299 |
|
2300 test.Printf(_L("DoCancel functional coverage...\n")); |
|
2301 // wait for the member to call CActiveScheduler::Stop |
|
2302 CActiveScheduler::Start(); |
|
2303 |
|
2304 delete iTestDomainManager; |
|
2305 delete member; |
|
2306 |
|
2307 __UHEAP_MARKEND; |
|
2308 } |
|
2309 |
|
2310 void CDmKeepAliveFuncCovTest::Release() |
|
2311 { |
|
2312 delete this; |
|
2313 } |
|
2314 |
|
2315 |
|
2316 /////////////////////////////////////////////////////////////////////////////// |
|
2317 // --- Main() --- |
|
2318 |
|
2319 GLDEF_C TInt E32Main() |
|
2320 { |
|
2321 CTrapCleanup* trapHandler = CTrapCleanup::New(); |
|
2322 test(trapHandler != NULL); |
|
2323 |
|
2324 CActiveScheduler* scheduler = new CActiveScheduler(); |
|
2325 test(scheduler != NULL); |
|
2326 CActiveScheduler::Install(scheduler); |
|
2327 |
|
2328 // Turn off evil lazy dll unloading |
|
2329 RLoader l; |
|
2330 test(l.Connect() == KErrNone); |
|
2331 test(l.CancelLazyDllUnload()== KErrNone); |
|
2332 l.Close(); |
|
2333 |
|
2334 // Default number of iteration |
|
2335 TInt iter = 1; |
|
2336 |
|
2337 TInt len = User::CommandLineLength(); |
|
2338 if (len) |
|
2339 { |
|
2340 // Copy the command line in a buffer |
|
2341 HBufC* hb = HBufC::NewMax(len); |
|
2342 test(hb != NULL); |
|
2343 TPtr cmd((TUint16*) hb->Ptr(), len); |
|
2344 User::CommandLine(cmd); |
|
2345 // Extract the number of iterations |
|
2346 TLex l(cmd); |
|
2347 TInt i; |
|
2348 TInt r = l.Val(i); |
|
2349 if (r == KErrNone) |
|
2350 iter = i; |
|
2351 else |
|
2352 // strange command - silently ignore |
|
2353 {} |
|
2354 delete hb; |
|
2355 } |
|
2356 |
|
2357 test.Title(); |
|
2358 |
|
2359 test.Start(_L("Test starting...")); |
|
2360 |
|
2361 test.Printf(_L("Go for %d iterations\n"), iter); |
|
2362 |
|
2363 // Remember the number of open handles. Just for a sanity check |
|
2364 TInt start_thc, start_phc; |
|
2365 RThread().HandleCount(start_phc, start_thc); |
|
2366 |
|
2367 for (TInt i = 1; i <= iter; i++) |
|
2368 { |
|
2369 test.Printf(_L("\nThis iteration: %d\n"), i); |
|
2370 |
|
2371 MDmTest* tests[] = |
|
2372 { |
|
2373 // DM Client PlatSec tests |
|
2374 new CDmTestPlatSec(TPtrC(KSecuritySlavePath1)), |
|
2375 new CDmTestPlatSec(TPtrC(KSecuritySlavePath2)), |
|
2376 new CDmTestPlatSec(TPtrC(KSecuritySlavePath3)), |
|
2377 |
|
2378 // Domain Member R-Class API tests |
|
2379 new CDmDeferralTestKErrNone(KDmHierarchyIdTestV2, EShutdownCritical, 1, ETrue), // TC 1.1.1.1.1 |
|
2380 new CDmDeferralTestKErrNone(KDmHierarchyIdTestV2, EShutdownCritical, 2, ETrue), // TC 1.1.1.1.2 |
|
2381 new CDmDeferralTestKErrNone(KDmHierarchyIdTestV2, EShutdownCritical, 1, EFalse), // TC 1.1.1.1.3 |
|
2382 new CDmDeferralTestCompletion(KDmHierarchyIdTestV2, EBackupMode), // TC 1.1.1.2.1 |
|
2383 new CDmDeferralTestKErrNotSupported(KDmHierarchyIdTestV2, EShutdownCritical, 6), // TC 1.1.1.3.1 |
|
2384 new CDmDeferralTestKErrNotSupported(KDmHierarchyIdTestV2, ENormalRunning, 1), // TC 1.1.1.3.2 |
|
2385 new CDmDeferralTestKErrNotSupported(KDmHierarchyIdTest, EBackupMode, 1), // TC 1.1.1.3.3 |
|
2386 new CDmDeferralTestKErrCancel(KDmHierarchyIdTestV2, EBackupMode, ETrue), // TC 1.1.1.4.1 |
|
2387 new CDmDeferralTestKErrCancel(KDmHierarchyIdTestV2, EBackupMode, EFalse), // TC 1.1.1.4.2 |
|
2388 new CDmDeferralTestKErrNotReady(KDmHierarchyIdTestV2, EBackupMode), // TC 1.1.1.5.1 |
|
2389 new CDmDeferralTestKErrServerBusy(KDmHierarchyIdTestV2, ERestoreMode), // TC 1.1.1.7.1 |
|
2390 |
|
2391 new CDmDeferralTestKErrNone(KDmHierarchyIdTestV2, ERestoreMode, 0, ETrue), // TC 1.2.0 |
|
2392 new CDmDeferralTestKErrNone(KDmHierarchyIdTestV2, ERestoreMode, 1, ETrue), // TC 1.2.1 |
|
2393 new CDmDeferralTestKErrNone(KDmHierarchyIdTestV2, ERestoreMode, 2, ETrue), // TC 1.2.2 |
|
2394 new CDmDeferralTestKErrNone(KDmHierarchyIdTestV2, ERestoreMode, 3, ETrue), // TC 1.2.3 |
|
2395 |
|
2396 new CDmDeferralMixed(KDmHierarchyIdTestV2, EShutdownCritical, 3, ETrue,EFalse), // TC 1.3.1 |
|
2397 new CDmDeferralMixed(KDmHierarchyIdTestV2, EShutdownCritical, 3, ETrue,ETrue), // TC 1.3.2 |
|
2398 |
|
2399 // Domain Member C-Class API tests |
|
2400 new CDmDomainKeepAliveTest(), |
|
2401 |
|
2402 // Policy State Spec Failure Policy tests - transition timeouts |
|
2403 // ETransitionFailureUsePolicyFromOrdinal3 |
|
2404 new CDmFailurePolicyTest(EStartupCriticalStatic, HierarchyPolicy.iFailurePolicy), |
|
2405 new CDmFailurePolicyTest(EStartupCriticalDynamic, ETransitionFailureStop), |
|
2406 new CDmFailurePolicyTest(ENormalRunning, ETransitionFailureContinue), |
|
2407 |
|
2408 // Policy Interface tests |
|
2409 new CDmPolicyInterfaceTest(), |
|
2410 |
|
2411 // Functional coverage test |
|
2412 new CDmKeepAliveFuncCovTest(), |
|
2413 }; |
|
2414 |
|
2415 for (TUint j = 0; j < sizeof(tests)/sizeof(*tests); j++) |
|
2416 { |
|
2417 test(tests[j] != NULL); |
|
2418 tests[j]->Perform(); |
|
2419 tests[j]->Release(); |
|
2420 } |
|
2421 } |
|
2422 |
|
2423 test.End(); |
|
2424 |
|
2425 // Sanity check for open handles and for pending requests |
|
2426 TInt end_thc, end_phc; |
|
2427 RThread().HandleCount(end_phc, end_thc); |
|
2428 test(start_thc == end_thc); |
|
2429 test(start_phc == end_phc); |
|
2430 test(RThread().RequestCount() >= 0); |
|
2431 |
|
2432 delete scheduler; |
|
2433 delete trapHandler; |
|
2434 |
|
2435 return KErrNone; |
|
2436 } |