1 // Copyright (c) 2002-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\power\t_domain.cpp

    15 // Overview:

    16 // Domain manager tests

    17 // API Information:

    18 // RDmDomain, RDmDomainManager CDmDomain, CDmDomainManager

    19 // Details:

    20 // - Test a variety of domain transitions, check the expected number of

    21 // notifications and the first expected ordinal. Verify results are

    22 // as expected.

    23 // - Test system standby, check the expected number of notifications and 

    24 // the first expected ordinal. Use a timer to request a wakeup event.

    25 // Verify results are as expected.

    26 // - Test domain related simple error situations, verify results are

    27 // as expected.

    28 // - Perform platform security tests: launch a separate process with no 

    29 // capabilities, verify that results are as expected.

    30 // - Test domain transitions by connecting to two domain hierarchies 

    31 // simultaneously, add some test and power hierarchy members, verify

    32 // the expected target state, notifications and leaf nodes. Verify results.

    33 // - Verify that the same hierarchy can not be connected to more than once.

    34 // - Request a positive transition and request that the test domain use 

    35 // ETraverseParentsFirst. Verify results are as expected and verify 

    36 // domains are in the correct state.

    37 // - Request a negative transition and request that the test domain use 

    38 // ETraverseChildrenFirst. Verify results are as expected.

    39 // - Request a positive transition with zero acknowledgements. Verify 

    40 // results are as expected.

    41 // - Request a positive transition with error acknowledgements. Verify 

    42 // results are as expected.

    43 // - Perform a variety of negative tests and verify results are as expected.

    44 // - Perform various tests on domain transitions with activated observer.

    45 // Verify results are as expected.

    46 // Platforms/Drives/Compatibility:

    47 // All.

    48 // Assumptions/Requirement/Pre-requisites:

    49 // Failures and causes:

    50 // Base Port information:

    51 // 

    52 //

    53 

    54 #include <e32test.h>

    55 #include <domainmember.h>

    56 #include <domainmanager.h>

    57 #include <domainobserver.h>

    58 #include "domainpolicytest.h"

    59 #include <e32debug.h>

    60 #include <f32file.h>

    61 #include <e32ldr.h>

    62 #include <e32ldr_private.h>

    63 

    64 LOCAL_D RTest test(_L(" T_DOMAIN "));

    65 _LIT(KThreadName, "t_domain_panic_thread");

    66 

    67 #ifdef _DEBUG

    68 #define __PRINT(x) {RDebug::Print x;}

    69 #else

    70 #define __PRINT(x) 

    71 #endif

    72 

    73 class CDmTestMember;

    74 

    75 // interface for test domain memebers.

    76 // Any test memeber should derive from this interface 

    77 class MDmDomainMember

    78 	{

    79 public:

    80 	virtual TDmHierarchyId HierarchyId() = 0;

    81 	virtual TDmDomainId	DomainId() = 0;

    82 	virtual TDmDomainState State() = 0;

    83 	virtual TInt Status() = 0;

    84 	virtual TUint32 Ordinal() = 0;

    85 	virtual TInt Notifications() = 0;

    86 	};

    87 

    88 class MDmTest

    89 	{

    90 public:

    91 	virtual void Perform() = 0;

    92 	virtual void Release() = 0;

    93 	virtual TInt TransitionNotification(MDmDomainMember& aDomainMember) = 0;

    94 	virtual void TransitionRequestComplete() = 0;

    95 	};

    96 

    97 // for the test hierarchy, we generate an ordinal for each domain

    98 // each byte of which describes the exact location of the domain in the hierarchy

    99 #define ORDINAL_FROM_DOMAINID0(id) (id)

   100 #define ORDINAL_FROM_DOMAINID1(parent, id) ((parent << 8) | (id))

   101 #define ORDINAL_FROM_DOMAINID2(grandparent, parent, id) ((grandparent << 16) | (parent << 8) | id)

   102 #define ORDINAL_FROM_DOMAINID3(greatgrandparent, grandparent, parent, id) ((greatgrandparent << 24) | (grandparent << 16) | (parent << 8) | id)

   103 #define PARENT_ORDINAL(id) (id >> 8)

   104 

   105 #define ORDINAL_LEVEL(ordinal)			\

   106 	((ordinal & 0xFF00) == 0) ? 1 :			\

   107 	((ordinal & 0xFF0000) == 0) ? 2 :		\

   108 	((ordinal & 0xFF000000) == 0) ? 3 : 4;

   109 

   110 

   111 // get the least significant domain id character (for debugging purposes)

   112 TBool GetDomainChar(TDmDomainId aDomainId, TChar& aChar)

   113 	{

   114 	TBool found = ETrue;

   115 	switch(aDomainId)

   116 		{

   117 		

   118 		case KDmIdTestA:	aChar = 'A'; break;

   119 		case KDmIdTestB:	aChar = 'B'; break;

   120 		case KDmIdTestC:	aChar = 'C'; break;

   121 		case KDmIdTestAA:	aChar = 'A'; break;

   122 		case KDmIdTestAB:	aChar = 'B'; break;

   123 		case KDmIdTestBA:	aChar = 'A'; break;

   124 		case KDmIdTestCA:	aChar = 'A'; break;

   125 		case KDmIdTestABA:	aChar = 'A'; break;

   126 		case KDmIdTestABB:	aChar = 'B'; break;

   127 		case KDmIdTestCAA:	aChar = 'A'; break;

   128 		// domain char not found 

   129 		case KDmIdNone:

   130 		case KDmIdRoot:		

   131 		default:			

   132 			found = EFalse;

   133 		}

   134 	return found;

   135 	}

   136 

   137 // prints the 4-character domain string into the passed descriptor (for debugging purposes)

   138 // e.g. "CAA" for KDmIdTestCAA

   139 void GetDomainDesc(TUint32 aOrdinal, TDes& aDes)

   140 	{

   141 	if (aOrdinal == KDmIdRoot)

   142 		{

   143 		aDes.Append(_L("root"));

   144 		return;

   145 		}

   146 

   147 	TUint32 val =  aOrdinal;

   148 

   149 	for (TInt n=0; n<4; n++)

   150 		{

   151 		TDmDomainId domainId = (TDmDomainId) (val >> 24);

   152 		TChar ch;

   153 		TBool found = GetDomainChar(domainId, ch);

   154 		if (found)

   155 			aDes.Append(ch);

   156 		val = val << 8;

   157 		}

   158 

   159 	}

   160 

   161 

   162 class CDmTestMember : public CActive, public MDmDomainMember

   163 	{

   164 public:	

   165 	// from CActive

   166 	void RunL();

   167 	// from MDmDomainMember

   168 	inline TDmHierarchyId HierarchyId() {return iHierarchy;};

   169 	inline TDmDomainId	DomainId() {return iId;};

   170 	inline TDmDomainState State() {return iState;};

   171 	inline TInt Status() {return iStatus.Int();};

   172 	inline TUint32 Ordinal() {return iOrdinal;};

   173 	inline TInt Notifications() {return iNotifications;};

   174 

   175 	CDmTestMember(TDmHierarchyId aHierarchy, TDmDomainId aId, TUint32 aOrdinal, MDmTest*);

   176 	~CDmTestMember();

   177 	void Acknowledge();

   178 

   179 protected:

   180 	// from CActive

   181 	virtual void DoCancel();

   182 

   183 

   184 public:

   185 	TDmHierarchyId iHierarchy;

   186 	TDmDomainId	iId;

   187 	TDmDomainState iState;

   188 	TUint32		iOrdinal;

   189 	MDmTest*	iTest;	

   190 	TInt		iNotifications;

   191 	RDmDomain	iDomain;

   192 	};

   193 

   194 

   195 

   196 CDmTestMember::CDmTestMember(TDmHierarchyId aHierarchy, TDmDomainId aId, TUint32 aOrdinal, MDmTest* aTest) : CActive(CActive::EPriorityStandard), 

   197 	iHierarchy(aHierarchy), iId(aId), iOrdinal(aOrdinal), iTest(aTest)

   198 	{

   199 	TInt r;

   200 

   201 	if (iHierarchy == KDmHierarchyIdPower)

   202 		 r = iDomain.Connect(iId);

   203 	else

   204 		 r = iDomain.Connect(iHierarchy, iId);

   205 

   206 	test(r == KErrNone);

   207 

   208 	CActiveScheduler::Add(this);

   209 

   210 	iDomain.RequestTransitionNotification(CActive::iStatus);

   211 	CActive::SetActive();

   212 	}

   213 

   214 CDmTestMember::~CDmTestMember()

   215 	{

   216 	CActive::Cancel();

   217 	iDomain.Close();

   218 	}

   219 

   220 void CDmTestMember::Acknowledge()

   221 	{

   222 	iDomain.AcknowledgeLastState();

   223 	}

   224 

   225 void CDmTestMember::RunL()

   226 	{

   227 

   228 	iNotifications++;

   229 

   230 	iState = iDomain.GetState();

   231 

   232 	TInt ackError = iTest->TransitionNotification(*this);

   233 	if (ackError == KErrNone)

   234 		iDomain.AcknowledgeLastState();

   235 	else if (ackError == KErrAbort)	// don't acknowledge

   236 		;

   237 	else

   238 		iDomain.AcknowledgeLastState(ackError);

   239 

   240 	

   241 	// request another notification (even if we didn't acknowledge the last one)

   242 	iDomain.RequestTransitionNotification(CActive::iStatus);

   243 	CActive::SetActive();

   244 	}

   245 

   246 void CDmTestMember::DoCancel()

   247 	{

   248 	iDomain.CancelTransitionNotification();

   249 	}

   250 

   251 

   252 // CDomainMemberAo

   253 class CDomainMemberAo : public CDmDomain, public MDmDomainMember

   254 	{

   255 public:	

   256 	static CDomainMemberAo* NewL(TDmHierarchyId aHierarchy, TDmDomainId aId, TUint32 aOrdinal, MDmTest*);

   257 	~CDomainMemberAo();

   258 

   259 	// from CActive

   260 	void RunL();

   261 

   262 	// from MDmDomainMember

   263 	inline TDmHierarchyId HierarchyId() {return iHierarchy;};

   264 	inline TDmDomainId	DomainId() {return iId;};

   265 	inline TDmDomainState State() {return iState;};

   266 	inline TInt Status() {return iStatus.Int();};

   267 	inline TUint32 Ordinal() {return iOrdinal;};

   268 	inline TInt Notifications() {return iNotifications;};

   269 

   270 private:

   271 	CDomainMemberAo(TDmHierarchyId aHierarchy, TDmDomainId aId, TUint32 aOrdinal, MDmTest*);

   272 

   273 public:

   274 	TDmHierarchyId iHierarchy;

   275 	TDmDomainId	iId;

   276 	TDmDomainState iState;

   277 	TUint32		iOrdinal;

   278 	MDmTest*	iTest;	

   279 	TInt		iNotifications;

   280 	};

   281 

   282 CDomainMemberAo* CDomainMemberAo::NewL(TDmHierarchyId aHierarchy, TDmDomainId aId, TUint32 aOrdinal, MDmTest* aTest)

   283 	{

   284 	CDomainMemberAo* self=new (ELeave) CDomainMemberAo(aHierarchy, aId, aOrdinal, aTest);

   285 	CleanupStack::PushL(self);

   286 	self->ConstructL();

   287 

   288 	self->RequestTransitionNotification();

   289 

   290 	CleanupStack::Pop();

   291 	return self;

   292 	}

   293 

   294 CDomainMemberAo::CDomainMemberAo(TDmHierarchyId aHierarchy, TDmDomainId aId, TUint32 aOrdinal, MDmTest* aTest) : 

   295 	CDmDomain(aHierarchy, aId), 

   296 	iHierarchy(aHierarchy), iId(aId), iOrdinal(aOrdinal), iTest(aTest)

   297 	{

   298 	}

   299 

   300 CDomainMemberAo::~CDomainMemberAo()

   301 	{

   302 	Cancel();

   303 	}

   304 

   305 void CDomainMemberAo::RunL()

   306 	{

   307 	iNotifications++;

   308 

   309 	iState = GetState();

   310 

   311 	TInt ackError = iTest->TransitionNotification(*this);

   312 	if (ackError == KErrNone)

   313 		AcknowledgeLastState(ackError);

   314 	else if (ackError == KErrAbort)	// don't acknowledge

   315 		;

   316 	else

   317 		AcknowledgeLastState(ackError); 

   318 	if (ackError != KErrAbort)	

   319 		AcknowledgeLastState(ackError);

   320 

   321 	

   322 	// request another notification (even if we didn't acknowledge the last one)

   323 	RequestTransitionNotification();

   324 	}

   325 

   326 

   327 // CDomainManagerAo

   328 class CDomainManagerAo : public CDmDomainManager

   329 	{

   330 public:	

   331 	~CDomainManagerAo();

   332 	static CDomainManagerAo* NewL(TDmHierarchyId aHierarchy, MDmTest& aTest);

   333 

   334 	// from CActive

   335 	void RunL();

   336 

   337 private:

   338 	CDomainManagerAo(TDmHierarchyId aHierarchy, MDmTest& aTest);

   339 

   340 private:

   341 	MDmTest& iTest;

   342 	};

   343 

   344 

   345 CDomainManagerAo* CDomainManagerAo::NewL(TDmHierarchyId aHierarchy, MDmTest& aTest)

   346 	{

   347 	CDomainManagerAo* self=new (ELeave) CDomainManagerAo(aHierarchy, aTest);

   348 	CleanupStack::PushL(self);

   349 

   350 	self->ConstructL();

   351 	CleanupStack::Pop();

   352 	return self;

   353 	}

   354 

   355 CDomainManagerAo::CDomainManagerAo(TDmHierarchyId aHierarchy, MDmTest& aTest) : 

   356 	CDmDomainManager(aHierarchy), iTest(aTest)

   357 	{

   358 	}

   359 

   360 CDomainManagerAo::~CDomainManagerAo()

   361 	{

   362 	}

   363 

   364 void CDomainManagerAo::RunL()

   365 	{

   366 	iTest.TransitionRequestComplete();

   367 	}

   368 

   369 

   370 class CDmTest1 : public CActive, public MDmTest

   371 	{

   372 public: // from CActive

   373 	void RunL();

   374 

   375 	// from MDmTest

   376 	void Perform();

   377 	void Release();

   378 	TInt TransitionNotification(MDmDomainMember& aDomainMember);

   379 	void TransitionRequestComplete() {};

   380 

   381 	CDmTest1 (TDmDomainId aId, TDmDomainState aState) : CActive(CActive::EPriorityStandard), iDomainId(aId), iState((TPowerState) aState) {}

   382 

   383 protected:

   384 	// from CActive

   385 	virtual void DoCancel();

   386 

   387 private:

   388 	enum { KMembersMax = 16 };

   389 	CDmTestMember*		iMembers[KMembersMax]; 

   390 	RDmDomainManager	iManager;

   391 	TDmDomainId			iDomainId;

   392 	TPowerState			iState;

   393 	TBool				iAcknowledge;

   394 	TInt				iMembersCount;

   395 	TInt				iCount;

   396 	TUint32				iOrdinal;

   397 	};

   398 

   399 void CDmTest1::Perform()

   400 	{

   401 	//

   402 	// Test domain transitions

   403 	//

   404 

   405 	test.Next(_L("Test 1"));

   406 	test.Printf(_L("Domain id = 0x%x Target State = 0x%x\n"), iDomainId, iState);

   407 	iMembers[0] = new CDmTestMember(KDmHierarchyIdPower, KDmIdRoot, 0, this);

   408 	test(iMembers[0] != NULL);

   409 	iMembers[1] = new CDmTestMember(KDmHierarchyIdPower, KDmIdRoot, 0, this);

   410 	test(iMembers[1] != NULL);

   411 	iMembers[2] = new CDmTestMember(KDmHierarchyIdPower, KDmIdApps, 1, this);

   412 	test(iMembers[2] != NULL);

   413 	iMembers[3] = new CDmTestMember(KDmHierarchyIdPower, KDmIdApps, 1, this);

   414 	test(iMembers[3] != NULL);

   415 	iMembers[4] = new CDmTestMember(KDmHierarchyIdPower, KDmIdUiApps, 1, this);

   416 	test(iMembers[4] != NULL);

   417 	iMembers[5] = new CDmTestMember(KDmHierarchyIdPower, KDmIdUiApps, 1, this);

   418 	test(iMembers[5] != NULL);

   419 	

   420 	// expected number of notifications

   421 	iMembersCount = (iDomainId == KDmIdRoot) ? 6 : 2;

   422 	// first expected ordinal

   423 	iOrdinal = (iState == EPwActive) ? 0 : 1;

   424 

   425 	TInt r = iManager.Connect();

   426 	test(r == KErrNone);

   427 

   428 	CActiveScheduler::Add(this);

   429 

   430 	iManager.RequestDomainTransition(iDomainId, iState, CActive::iStatus);

   431 	CActive::SetActive();

   432 

   433 	CActiveScheduler::Start();

   434 	}

   435 

   436 TInt CDmTest1::TransitionNotification(MDmDomainMember& aDomainMember)

   437 	{

   438 	++iCount;

   439 	if (aDomainMember.State() == EPwActive)

   440 		{

   441 		if(aDomainMember.Ordinal() < iOrdinal)

   442 			{

   443 			// Making the test to fail in RunL function inorder to complete the cleanup from domain manager.

   444 			test.Printf(_L("Making test to fail as Ordinal Mismatch Expected : %d, Returned : %d"), aDomainMember.Ordinal(), iOrdinal);

   445 			iCount--;

   446 			}

   447 		}

   448 	else

   449 		{

   450 		if(aDomainMember.Ordinal() > iOrdinal)

   451 			{

   452 			//Making the test to fail in RunL function inorder to complete the cleanup from domain manager.

   453 			test.Printf(_L("Making test to fail as Ordinal Mismatch Expected : %d, Returned : %d"), aDomainMember.Ordinal(), iOrdinal);

   454 			iCount--;

   455 			}

   456 		}

   457 	iOrdinal = aDomainMember.Ordinal();

   458 

   459 	// acknowledge one from two

   460 	iAcknowledge = !iAcknowledge;

   461 	return iAcknowledge?KErrNone:KErrGeneral;

   462 	}

   463 

   464 void CDmTest1::RunL()

   465 	{

   466 	CActiveScheduler::Stop();

   467 

   468 	iManager.Close();

   469 

   470 	CDmTestMember** mp;

   471 	for (mp = iMembers; *mp; ++mp)

   472 		delete *mp;

   473 	test(iCount == iMembersCount);

   474 	}

   475 

   476 void CDmTest1::DoCancel()

   477 	{

   478 	test(0);

   479 	}

   480 

   481 void CDmTest1::Release()

   482 	{

   483 	delete this;

   484 	}

   485 

   486 class CDmTest2Timer : public CTimer

   487 	{

   488 public: // fomr CTimer

   489    void RunL();

   490 public:

   491 	CDmTest2Timer() : CTimer(0) 

   492 		{

   493 		TRAPD(r,

   494 			ConstructL());

   495 		test(r == KErrNone);

   496 		CActiveScheduler::Add(this);

   497 		}

   498 	};

   499 

   500 void CDmTest2Timer::RunL()

   501 	{

   502 	test.Printf(_L("Tick count after CDmTest2Timer::RunL() = %d\n"), User::NTickCount());

   503 

   504 	// kick the timer again in case power down hasn't happened yet

   505 	TTime wakeup;

   506 	wakeup.HomeTime();

   507 	wakeup += TTimeIntervalSeconds(3);

   508 	At(wakeup);

   509 	}

   510 

   511 class CDmTest2 : public CActive, public MDmTest

   512 	{

   513 public: // from CActive

   514 	void RunL();

   515 

   516 	// from MDmTest

   517 	void Perform();

   518 	void Release();

   519 	TInt TransitionNotification(MDmDomainMember& aDomainMember);

   520 	void TransitionRequestComplete() {};

   521 	CDmTest2 (TDmDomainState aState) : CActive(CActive::EPriorityStandard), iState((TPowerState) aState) {}

   522 

   523 protected:

   524 	// from CActive

   525 	virtual void DoCancel();

   526 

   527 private:

   528 	enum { KMembersMax = 16 };

   529 	CDmTestMember*		iMembers[KMembersMax]; 

   530 	RDmDomainManager	iManager;

   531 	TPowerState			iState;

   532 	TBool				iAcknowledge;

   533 	TInt				iMembersCount;

   534 	TInt				iCount;

   535 	TUint32				iOrdinal;

   536 	CDmTest2Timer*		iTimer;

   537 	};

   538 

   539 

   540 void CDmTest2::Perform()

   541 	{

   542 	//

   543 	// Test system standby

   544 	//

   545 

   546 	test.Next(_L("Test 2"));

   547 	test.Printf(_L("Target State = 0x%x\n"), iState);

   548 	iMembers[0] = new CDmTestMember(KDmHierarchyIdPower, KDmIdRoot, 0, this);

   549 	test(iMembers[0] != NULL);

   550 	iMembers[1] = new CDmTestMember(KDmHierarchyIdPower, KDmIdRoot, 0, this);

   551 	test(iMembers[1] != NULL);

   552 	iMembers[2] = new CDmTestMember(KDmHierarchyIdPower, KDmIdApps, 1, this);

   553 	test(iMembers[2] != NULL);

   554 	iMembers[3] = new CDmTestMember(KDmHierarchyIdPower, KDmIdApps, 1, this);

   555 	test(iMembers[3] != NULL);

   556 	iMembers[4] = new CDmTestMember(KDmHierarchyIdPower, KDmIdUiApps, 1, this);

   557 	test(iMembers[4] != NULL);

   558 	iMembers[5] = new CDmTestMember(KDmHierarchyIdPower, KDmIdUiApps, 1, this);

   559 	test(iMembers[5] != NULL);

   560 	

   561 	// expected number of notifications

   562 	iMembersCount = 12;

   563 	// first expected ordinal

   564 	iOrdinal = (iState == EPwActive) ? 0 : 1;

   565 

   566 	TInt r = iManager.Connect();

   567 	test(r == KErrNone);

   568 

   569 	CActiveScheduler::Add(this);

   570 

   571 	// Use an absolute timer to request a wakeup event

   572 	iTimer = new CDmTest2Timer();

   573 	TTime wakeup;

   574 	wakeup.HomeTime();

   575 	wakeup += TTimeIntervalSeconds(5);

   576 	test.Printf(_L("Tick count before timer = %d\n"), User::NTickCount());

   577 	iTimer->At(wakeup);

   578 	

   579 	iManager.RequestSystemTransition(iState, CActive::iStatus);

   580 	CActive::SetActive();

   581 

   582 	CActiveScheduler::Start();

   583 	}

   584 

   585 TInt CDmTest2::TransitionNotification(MDmDomainMember& aDomainMember)

   586 	{

   587 	++iCount;

   588 	if (aDomainMember.State() == EPwActive)

   589 		{

   590 		if(aDomainMember.Ordinal() < iOrdinal)

   591 			{

   592 			// Making the test to fail in RunL function inorder to complete the cleanup from domain manager.

   593 			test.Printf(_L("Making test to fail as Ordinal Mismatch Expected : %d, Returned : %d, State : %d"), 

   594 																		aDomainMember.Ordinal(), iOrdinal, aDomainMember.State());

   595 			iCount--;

   596 			}

   597 		}

   598 	else

   599 		{

   600 		if(aDomainMember.Ordinal() > iOrdinal)

   601 			{

   602 			// Making the test to fail in RunL function inorder to complete the cleanup from domain manager.

   603 			test.Printf(_L("Making test to fail as Ordinal Mismatch Expected : %d, Returned : %d, State: %d"), 

   604 																		aDomainMember.Ordinal(), iOrdinal, aDomainMember.State());

   605 			iCount--;

   606 			}

   607 		}

   608 	iOrdinal = aDomainMember.Ordinal();

   609 

   610 	// acknowledge one from two

   611 	iAcknowledge = !iAcknowledge;

   612 	return iAcknowledge?KErrNone:KErrAbort;

   613 	}

   614 

   615 void CDmTest2::RunL()

   616 	{

   617 	test.Printf(_L("Tick count after CDmTest2::RunL() = %d\n"), User::NTickCount());

   618 

   619 	iTimer->Cancel();	

   620 	CActiveScheduler::Stop();

   621 

   622 	iManager.Close();

   623 

   624 	CDmTestMember** mp;

   625 	for (mp = iMembers; *mp; ++mp)

   626 		delete *mp;

   627 	test(CActive::iStatus == KErrTimedOut);

   628 	test(iCount == iMembersCount);

   629 	}

   630 

   631 void CDmTest2::DoCancel()

   632 	{

   633 	test(0);

   634 	}

   635 

   636 void CDmTest2::Release()

   637 	{

   638 	if (iTimer)

   639 		{

   640 		iTimer->Cancel();

   641 		delete iTimer;

   642 		}

   643 	delete this;

   644 	}

   645 

   646 class CDmTest3 : public MDmTest

   647 	{

   648 public: 

   649 	// from MDmTest

   650 	void Perform();

   651 	void Release();

   652 	TInt TransitionNotification(MDmDomainMember& aDomainMember);

   653 	void TransitionRequestComplete() {};

   654 	};

   655 

   656 void CDmTest3::Perform()

   657 	{

   658 	//

   659 	// Test simple error situation

   660 	//

   661 	RDmDomainManager manager;

   662 	TInt r = manager.Connect();

   663 	test(r == KErrNone);

   664 

   665 	RDmDomainManager manager1;

   666 	r = manager1.Connect();

   667 	test(r == KErrInUse);

   668 

   669 	RDmDomain domain;

   670 	r = domain.Connect(KDmIdNone);

   671 	test(r == KDmErrBadDomainId);

   672 	CDmTestMember*		testMember;

   673 	testMember = new CDmTestMember(KDmHierarchyIdPower, KDmIdApps, 1, this);

   674 	test (testMember != NULL);

   675 

   676 	TRequestStatus status;

   677 	manager.RequestDomainTransition(KDmIdApps, EPwStandby, status);

   678 	test(status.Int() == KRequestPending);

   679 

   680 	TRequestStatus status1;

   681 	manager.RequestDomainTransition(KDmIdApps, EPwActive, status1);

   682 	User::WaitForRequest(status1);

   683 	test(status1.Int() == KDmErrBadSequence);

   684 	User::WaitForRequest(status);

   685 	test(status.Int() == KErrTimedOut);

   686 

   687 	// Since this test doesn't start the active scheduler, a domain member's RunL() will 

   688 	// not get called so we need to re-request a domain transition notification manually

   689 	User::WaitForRequest(testMember->iStatus);

   690 	test(testMember->iStatus.Int() == KErrNone);

   691 	testMember->iDomain.RequestTransitionNotification(testMember->iStatus);

   692 

   693 	manager.RequestDomainTransition(KDmIdApps, EPwActive, status);

   694 	test(status.Int() == KRequestPending);

   695 	manager.CancelTransition();

   696 	test(status.Int() == KErrCancel);

   697 	manager.CancelTransition();

   698 	User::WaitForRequest(status);

   699 	test(status.Int() == KErrCancel);

   700 

   701 	testMember->iDomain.CancelTransitionNotification();

   702 

   703 	delete testMember;

   704 	

   705 	domain.Close();

   706 	manager.Close();

   707 	}

   708 

   709 TInt CDmTest3::TransitionNotification(MDmDomainMember& /*aDomainMember*/)

   710 	{

   711 	test(0);

   712 	return KErrAbort;	// don't acknowledge

   713 	}

   714 

   715 void CDmTest3::Release()

   716 	{

   717 	delete this;

   718 	}

   719 

   720 class CDmTest4 : public MDmTest

   721 	{

   722 public: 

   723 	// from MDmTest

   724 	void Perform();

   725 	void Release();

   726 	TInt TransitionNotification(MDmDomainMember& aDomainMember);

   727 	void TransitionRequestComplete() {};

   728 private:

   729 	void ExecSlave(TUint arg);

   730 	};

   731 

   732 _LIT(KSecuritySlavePath, "t_domain_slave.exe");

   733 

   734 void CDmTest4::ExecSlave(TUint aArg)

   735 	{

   736 	RProcess proc;

   737 	TInt r = proc.Create(KSecuritySlavePath, TPtrC((TUint16*) &aArg, sizeof(aArg)/sizeof(TUint16)));

   738 	test(r == KErrNone);

   739 	TRequestStatus status;

   740 	proc.Logon(status);

   741 	proc.Resume();

   742 	User::WaitForRequest(status);

   743 

   744     RDebug::Printf("CDmTest4::ExecSlave(%d) ExitType %d", aArg, proc.ExitType() );

   745     RDebug::Printf("CDmTest4::ExecSlave(%d) ExitReason %d", aArg, proc.ExitReason() );

   746 	test(proc.ExitType() == EExitKill);

   747 //	test(proc.ExitReason() == KErrPermissionDenied);

   748 

   749 	CLOSE_AND_WAIT(proc);

   750 	}

   751 

   752 //! @SYMTestCaseID PBASE-T_DOMAIN-4

   753 //! @SYMTestType CT

   754 //! @SYMTestCaseDesc Dmain manager security tests

   755 //! @SYMREQ 3722

   756 //! @SYMTestActions Launches a separate process with no capabilities

   757 //! @SYMTestExpectedResults  DM APIs should fail with KErrPermissionDenied

   758 //! @SYMTestPriority High

   759 //! @SYMTestStatus Defined

   760 void CDmTest4::Perform()

   761 	{

   762 	//

   763 	// Security tests

   764 	//

   765 

   766 	ExecSlave(0);

   767 

   768     ExecSlave(1);

   769 

   770 	}

   771 

   772 TInt CDmTest4::TransitionNotification(MDmDomainMember& /*aDomainMember*/)

   773 	{

   774 	test(0);

   775 	return KErrNone;

   776 	}

   777 

   778 void CDmTest4::Release()

   779 	{

   780 	delete this;

   781 	}

   782 

   783 // Test hierarchy tests

   784 class CDmTestStartupMember : public CDmTestMember

   785 	{

   786 public:

   787 	CDmTestStartupMember(TDmHierarchyId aHierarchy, TDmDomainId aId, TUint32 aOrdinal, MDmTest*);

   788 

   789 public:

   790 private:

   791 	};

   792 

   793 CDmTestStartupMember::CDmTestStartupMember(TDmHierarchyId aHierarchy, TDmDomainId aId, TUint32 aOrdinal, MDmTest* aTest) 

   794 	: CDmTestMember(aHierarchy, aId, aOrdinal, aTest)

   795 	{

   796 	}

   797 

   798 // Simultaneously testing of test domain defined in DomainPolicy99.dll

   799 // and the power domain defined in DomainPolicy.dll

   800 class CDmTest5 : public CActive, public MDmTest

   801 	{

   802 public: 

   803 	// from CActive

   804 	void RunL();

   805 	// from MDmTest

   806 	void Perform();

   807 	void Release();

   808 	TInt TransitionNotification(MDmDomainMember& aDomainMember);

   809 	void TransitionRequestComplete();	

   810 	void RunTestOnGetTransitionFailures(RArray<const TTransitionFailure>& aTransitionFailure);

   811 	

   812 	CDmTest5(TDmDomainId aPowerId, TDmDomainId aTestId, TDmDomainState aPowerState, TDmDomainState aTestState) : 

   813 		CActive(CActive::EPriorityStandard), 

   814 		iPowerDomainId(aPowerId), iTestDomainId(aTestId), iPowerState(aPowerState), iTestState(aTestState) {}

   815 protected:

   816 	// from CActive

   817 	virtual void DoCancel();

   818 

   819 private:

   820 	enum { KMembersMax = 16 };

   821 	enum TAckMode{ KAckAlways, KAckNever, KAckError, KAckOddDomainsOnly };

   822 

   823 	CDmTestMember*		iTestMembers[KMembersMax]; 

   824 	CDomainMemberAo*	iPowerMembers[KMembersMax]; 

   825 

   826 	RDmDomainManager	iTestDomainManager;

   827 	

   828 	TDmDomainId			iPowerDomainId;

   829 	TDmDomainId			iTestDomainId;

   830 

   831 	TDmDomainState		iPowerState;

   832 	TDmDomainState		iTestState;

   833 

   834 	// level number for iTestDomainId. E.g 1 for KDmIdRoot, 2 for KDmIdTestA, etc.

   835 	TInt				iTestDomainLevel;	

   836 

   837 	TDmTraverseDirection iTraverseDirection;

   838 

   839 	TAckMode			iAckMode;

   840 

   841 public:

   842 	TInt				iTestNotifications;

   843 	TInt				iPowerNotifications;

   844 	TInt				iTestNotificationsExpected;

   845 	TInt				iPowerNotificationsExpected;

   846 

   847 	TInt				iTransitionsCompleted;

   848 	TInt				iTransitionsExpected;

   849 	};

   850 

   851 void CDmTest5::RunTestOnGetTransitionFailures(RArray<const TTransitionFailure>& aTransitionFailure)

   852 	{

   853 	//*************************************************

   854 	// Test - OOM Testing on GetTransitionFailures()

   855 	// Simulates heap failure in GetTransitionFailures()

   856 	//*************************************************

   857 	TInt error = 0;

   858 	TInt count = 0;	

   859 	do

   860 		{		

   861 		__UHEAP_SETFAIL(RHeap::EFailNext, ++count);

   862 		error = iTestDomainManager.GetTransitionFailures(aTransitionFailure);						

   863 		test.Printf( _L( "CDmTest5::RunTestOnGetTransitionFailures, simulating heap failure on GetTransitionFailures(), Error=%d, Run=%d\n" ), error, count );

   864 		}while(error == KErrNoMemory);		

   865 		

   866 	__UHEAP_RESET;

   867 	

   868 	//Actual count of heap failure as the final iteration which terminates the loop would not return KErrNoMemory 

   869 	--count;

   870 	test(count > 0);

   871 	test.Printf( _L( "Out of memory tests on GetTransitionFailures() succeeded at heap failure rate of %i\n" ), count );

   872 	}

   873 

   874 //! @SYMTestCaseID PBASE-T_DOMAIN-5

   875 //! @SYMTestType CT

   876 //! @SYMTestCaseDesc Connects to two domain hierarchies simulteneously and perform various tests

   877 //! @SYMREQ 3704,3705,3706,3707,3708,3709,3710,3711,3720,3721,3724,3725,3726,3727

   878 //! @SYMTestActions Open two hiearchies simultaneously and perform various actions.

   879 //! @SYMTestExpectedResults  All tests should pass

   880 //! @SYMTestPriority High

   881 //! @SYMTestStatus Defined

   882 void CDmTest5::Perform()

   883 	{

   884 

   885  	__UHEAP_MARK;

   886 

   887 	//

   888 	// Test domain transitions

   889 	//

   890 	CActiveScheduler::Add(this);

   891 

   892 	TInt r = RDmDomainManager::AddDomainHierarchy(KDmHierarchyIdTest);

   893 

   894     RDebug::Printf("RDmDomainManager::AddDomainHierarchy returns %d", r );

   895 

   896 	test(r == KErrNone);

   897 

   898 	CDomainManagerAo* powerDomainManager = NULL;

   899 	TRAP(r, powerDomainManager = CDomainManagerAo::NewL(KDmHierarchyIdPower, *this));

   900 	test (powerDomainManager != NULL);

   901 

   902 	r = CDomainManagerAo::AddDomainHierarchy(KDmHierarchyIdPower);

   903 	test(r == KErrNone);

   904 

   905 	//*************************************************

   906 	//	Test 5a - connect to two domain hierarchies simultaneously

   907 	//*************************************************

   908 	test.Next(_L("Test 5a - connect to two domain hierarchies simultaneously"));

   909 

   910 	test.Printf(_L("Domain id = 0x%x, Target State = 0x%x\n"), iTestDomainId, iTestState);

   911 

   912 	TInt testMemberCount = 0;

   913 

   914 	// Add some test hierarchy members - these use the RDmDomain API

   915 	iTestMembers[testMemberCount] = new CDmTestMember(KDmHierarchyIdTest, KDmIdRoot, ORDINAL_FROM_DOMAINID0(KDmIdRoot), this);

   916 	test(iTestMembers[testMemberCount++] != NULL);

   917 	iTestMembers[testMemberCount] = new CDmTestMember(KDmHierarchyIdTest, KDmIdRoot, ORDINAL_FROM_DOMAINID0(KDmIdRoot), this);

   918 	test(iTestMembers[testMemberCount++] != NULL);

   919 	

   920 	// row 1

   921 	iTestMembers[testMemberCount] = new CDmTestMember(KDmHierarchyIdTest, KDmIdTestA, ORDINAL_FROM_DOMAINID1(KDmIdRoot, KDmIdTestA), this);

   922 	test(iTestMembers[testMemberCount++] != NULL);

   923 	iTestMembers[testMemberCount] = new CDmTestMember(KDmHierarchyIdTest, KDmIdTestB, ORDINAL_FROM_DOMAINID1(KDmIdRoot, KDmIdTestB), this);

   924 	test(iTestMembers[testMemberCount++] != NULL);

   925 	iTestMembers[testMemberCount] = new CDmTestMember(KDmHierarchyIdTest, KDmIdTestC, ORDINAL_FROM_DOMAINID1(KDmIdRoot, KDmIdTestC), this);

   926 	test(iTestMembers[testMemberCount++] != NULL);

   927 	

   928 	// row2

   929 	iTestMembers[testMemberCount] = new CDmTestMember(KDmHierarchyIdTest, KDmIdTestAA, ORDINAL_FROM_DOMAINID2(KDmIdRoot, KDmIdTestA, KDmIdTestAA), this);

   930 	test(iTestMembers[testMemberCount++] != NULL);

   931 	iTestMembers[testMemberCount] = new CDmTestMember(KDmHierarchyIdTest, KDmIdTestAB, ORDINAL_FROM_DOMAINID2(KDmIdRoot, KDmIdTestA, KDmIdTestAB), this);

   932 	test(iTestMembers[testMemberCount++] != NULL);

   933 	iTestMembers[testMemberCount] = new CDmTestMember(KDmHierarchyIdTest, KDmIdTestBA, ORDINAL_FROM_DOMAINID2(KDmIdRoot, KDmIdTestB, KDmIdTestBA), this);

   934 	test(iTestMembers[testMemberCount++] != NULL);

   935 	iTestMembers[testMemberCount] = new CDmTestMember(KDmHierarchyIdTest, KDmIdTestCA, ORDINAL_FROM_DOMAINID2(KDmIdRoot, KDmIdTestC, KDmIdTestCA), this);

   936 	test(iTestMembers[testMemberCount++] != NULL);

   937 	

   938 	// row 3

   939 	iTestMembers[testMemberCount] = new CDmTestMember(KDmHierarchyIdTest, KDmIdTestABA, ORDINAL_FROM_DOMAINID3(KDmIdRoot, KDmIdTestA, KDmIdTestAB, KDmIdTestABA), this);

   940 	test(iTestMembers[testMemberCount++] != NULL);

   941 	iTestMembers[testMemberCount] = new CDmTestMember(KDmHierarchyIdTest, KDmIdTestABB, ORDINAL_FROM_DOMAINID3(KDmIdRoot, KDmIdTestA, KDmIdTestAB, KDmIdTestABB), this);

   942 	test(iTestMembers[testMemberCount++] != NULL);

   943 	iTestMembers[testMemberCount] = new CDmTestMember(KDmHierarchyIdTest, KDmIdTestCAA, ORDINAL_FROM_DOMAINID3(KDmIdRoot, KDmIdTestC, KDmIdTestCA, KDmIdTestCAA), this);

   944 	test(iTestMembers[testMemberCount++] != NULL);

   945 

   946 	// add some power hierarchy members - these use the CDmDomain AO API

   947 	TInt powerMemberCount = 0;

   948 	TRAP(r, iPowerMembers[powerMemberCount] = CDomainMemberAo::NewL(KDmHierarchyIdPower, KDmIdRoot, KDmIdRoot, this));

   949 	test(iTestMembers[powerMemberCount++] != NULL);

   950 	TRAP(r, iPowerMembers[powerMemberCount] = CDomainMemberAo::NewL(KDmHierarchyIdPower, KDmIdApps, KDmIdApps, this));

   951 	test(iTestMembers[powerMemberCount++] != NULL);

   952 	TRAP(r, iPowerMembers[powerMemberCount] = CDomainMemberAo::NewL(KDmHierarchyIdPower, KDmIdUiApps, KDmIdUiApps, this));

   953 	test(iTestMembers[powerMemberCount++] != NULL);

   954 

   955 

   956 	RArray<const TTransitionFailure> testFailures;

   957 	TInt testFailureCount;

   958 	RArray<const TTransitionFailure> powerFailures;

   959 	TInt powerFailureCount;

   960 

   961 

   962 

   963 	// calculate the expected number of notifications

   964 	TInt expectedTestNotifications = 0;

   965 	TInt leafNodes = 0;

   966 	

   967 

   968 	// work out the domain level, the number of leaf nodes and the expected number of 

   969 	// notifications for the domain that is being transitioned

   970 	switch(iTestDomainId)

   971 		{

   972 		case KDmIdRoot		:	iTestDomainLevel = 1; leafNodes = 5; expectedTestNotifications = testMemberCount; break;

   973 		case KDmIdTestA		:	iTestDomainLevel = 2; leafNodes = 3; expectedTestNotifications = 5; break;

   974 		case KDmIdTestB		:	iTestDomainLevel = 2; leafNodes = 1; expectedTestNotifications = 2; break;

   975 		case KDmIdTestC		:	iTestDomainLevel = 2; leafNodes = 1; expectedTestNotifications = 3; break;

   976 

   977 		case KDmIdTestAA	:	iTestDomainLevel = 3; leafNodes = 1; expectedTestNotifications = 1; break;

   978 		case KDmIdTestAB	:	iTestDomainLevel = 3; leafNodes = 2; expectedTestNotifications = 3; break;

   979 		case KDmIdTestBA	:	iTestDomainLevel = 3; leafNodes = 1; expectedTestNotifications = 1; break;

   980 		case KDmIdTestCA	:	iTestDomainLevel = 3; leafNodes = 1; expectedTestNotifications = 2; break;

   981 

   982 		case KDmIdTestABA	:	iTestDomainLevel = 4; leafNodes = 1; expectedTestNotifications = 1; break;

   983 		case KDmIdTestABB	:	iTestDomainLevel = 4; leafNodes = 1; expectedTestNotifications = 1; break;

   984 		case KDmIdTestCAA	:	iTestDomainLevel = 4; leafNodes = 1; expectedTestNotifications = 1; break;

   985 		default:

   986 			test(0);

   987 		}

   988 	test.Printf(_L("Test Domain id = 0x%x, Level = %d, Target State = 0x%x, expected notifications = %d, leafNodes = %d\n"), 

   989 		iTestDomainId, iTestDomainLevel, iTestState, expectedTestNotifications, leafNodes);

   990 

   991 	TInt expectedPowerNotifications = 0;

   992 	switch(iPowerDomainId)

   993 		{

   994 		case KDmIdRoot		:	expectedPowerNotifications = powerMemberCount; break;

   995 		case KDmIdApps		:	expectedPowerNotifications = 1; break;

   996 		case KDmIdUiApps	:	expectedPowerNotifications = 1; break;

   997 		default:

   998 			test(0);

   999 		}

  1000 

  1001 

  1002 

  1003 	// connect to the test hierarchy

  1004 	r = iTestDomainManager.Connect(KDmHierarchyIdTest);

  1005 	test(r == KErrNone);

  1006 

  1007 	// verify that we can't connect to the same hierarchy more than once

  1008 	RDmDomainManager	domainManager;

  1009 	r = domainManager.Connect(KDmHierarchyIdTest);

  1010 	test(r == KErrInUse);

  1011 

  1012 

  1013 

  1014 	//*************************************************

  1015 	// Test 5b - request a positive transition

  1016 	// issue a positive  transition (i.e. transition state increases)

  1017 	// and request that the test domain use ETraverseParentsFirst

  1018 	//*************************************************

  1019 	test.Next(_L("Test 5b - request a positive transition"));

  1020 	iAckMode = KAckAlways;

  1021 

  1022 	iTransitionsCompleted = iTestNotifications = iPowerNotifications = 0;

  1023 	iPowerNotificationsExpected = 0;

  1024 	iTestNotificationsExpected = expectedTestNotifications;

  1025 	iTransitionsExpected = 1;

  1026 

  1027 	// DON'T request any domain transition on the power hierarchy

  1028 	// powerDomainManager->RequestDomainTransition(iPowerDomainId, EPwActive);

  1029 	// request a domain transition on the test hierarchy

  1030 	iTraverseDirection = ETraverseParentsFirst;

  1031 	if (iTestDomainId == KDmIdRoot)

  1032 		iTestDomainManager.RequestSystemTransition(iTestState, ETraverseDefault, CActive::iStatus);

  1033 	else

  1034 		iTestDomainManager.RequestDomainTransition(iTestDomainId, iTestState, ETraverseDefault, CActive::iStatus);

  1035 	CActive::SetActive();

  1036 

  1037 	CActiveScheduler::Start();

  1038 	test(powerDomainManager->iStatus == KErrNone);

  1039 	test(iStatus == KErrNone);

  1040 	test(iTestNotifications == iTestNotificationsExpected);

  1041 	test(iPowerNotifications == iPowerNotificationsExpected);

  1042 

  1043 	//*************************************************

  1044 	// Test 5c- verify domains are in correct state

  1045 	//*************************************************

  1046 	test.Next(_L("Test 5c- verify domains are in correct state"));

  1047 	RDmDomain domainMember;

  1048 	r = domainMember.Connect(KDmHierarchyIdTest, iTestDomainId);

  1049 	test (r == KErrNone);

  1050 	TDmDomainState state = domainMember.GetState();

  1051 	domainMember.Close();

  1052 	test (state == iTestState);

  1053 

  1054 	// if the transition request is not on the root, verify that that 

  1055 	// the root domain and the transition domain are in different states

  1056 	if (iTestDomainId != KDmIdRoot && iTestState != EStartupCriticalStatic)

  1057 		{

  1058 		r = domainMember.Connect(KDmHierarchyIdTest, KDmIdRoot);

  1059 		test (r == KErrNone);

  1060 		TDmDomainState state = domainMember.GetState();

  1061 		domainMember.Close();

  1062 		test (state != iTestState);

  1063 		}

  1064 

  1065 

  1066 	//*************************************************

  1067 	// Test 5d- request a negative transition

  1068 	// issue a negative transition (i.e. transition state decreases)

  1069 	// and request that the test domain use ETraverseChildrenFirst

  1070 	//*************************************************

  1071 	test.Next(_L("Test 5d- request a negative transition"));

  1072 	iAckMode = KAckAlways;

  1073 	iTestState--;	// EStartupCriticalStatic;

  1074 	iPowerState--;	// EPwStandby

  1075 

  1076 	iTransitionsCompleted = iTestNotifications = iPowerNotifications = 0;

  1077 	iPowerNotificationsExpected = expectedPowerNotifications;

  1078 	iTestNotificationsExpected = expectedTestNotifications;

  1079 	iTransitionsExpected = 2;

  1080 

  1081 	// DO request a domain transition on the power hierarchy

  1082 	powerDomainManager->RequestDomainTransition(iPowerDomainId, iPowerState, ETraverseDefault);

  1083 

  1084 	// request a domain transition on the test hierarchy

  1085 	iTraverseDirection = ETraverseChildrenFirst;

  1086 	iTestDomainManager.RequestDomainTransition(iTestDomainId, iTestState, iTraverseDirection, CActive::iStatus);

  1087 	CActive::SetActive();

  1088 

  1089 	// wait for all test & power transitions to complete

  1090 	CActiveScheduler::Start();

  1091 	test(powerDomainManager->iStatus == KErrNone);

  1092 	test(iStatus == KErrNone);

  1093 	test(iTestNotifications == iTestNotificationsExpected);

  1094 	test(iPowerNotifications == iPowerNotificationsExpected);

  1095 	

  1096 

  1097 	//*************************************************

  1098 	// Test 5e- request a positive transition, with zero acknowledgements

  1099 	// issue a positive transition with no members acknowledging the transition

  1100 	//*************************************************

  1101 	test.Next(_L("Test 5e- request a positive transition, with zero acknowledgements"));

  1102 	iAckMode = KAckNever;

  1103 	iTestState++;		// EStartupCriticalDynamic;

  1104 	iPowerState++;		// EPwActive

  1105 

  1106 	// power hierarchy should continue on failure, so we all power domains should transition

  1107 	// test hierarchy should stop on failure, so should get notifications from all leaf nodes

  1108 	iTransitionsCompleted = iTestNotifications = iPowerNotifications = 0;

  1109 	iPowerNotificationsExpected = expectedPowerNotifications;

  1110 	iTestNotificationsExpected = leafNodes;	// 5 leaf nodes for root domain

  1111 	iTransitionsExpected = 2;

  1112 

  1113 	// DO request a domain transition on the power hierarchy

  1114 	powerDomainManager->RequestDomainTransition(iPowerDomainId, iPowerState, ETraverseDefault);

  1115 

  1116 	// request a domain transition on the test hierarchy

  1117 	iTraverseDirection = ETraverseChildrenFirst;

  1118 	iTestDomainManager.RequestDomainTransition(iTestDomainId, iTestState, iTraverseDirection, CActive::iStatus);

  1119 	CActive::SetActive();

  1120 

  1121 	// wait for all test & power transitions to complete

  1122 	CActiveScheduler::Start();

  1123 	test(powerDomainManager->iStatus == KErrTimedOut);

  1124 	test(iStatus == KErrTimedOut);

  1125 	test(iTestNotifications == iTestNotificationsExpected);

  1126 	test(iPowerNotifications == iPowerNotificationsExpected);

  1127 	

  1128 	// get the failures on the test hierarchy

  1129 	testFailureCount = iTestDomainManager.GetTransitionFailureCount();

  1130 	test (testFailureCount == 1);

  1131 

  1132 #ifdef _DEBUG

  1133 	//***************************************************************

  1134 	// OOM Testing: Simulates heap failure in GetTransitionFailures()