1 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // 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 

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

    63 _LIT(KThreadName, "t_domain_panic_thread");

    64 

    65 #ifdef _DEBUG

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

    67 #else

    68 #define __PRINT(x) 

    69 #endif

    70 

    71 class CDmTestMember;

    72 

    73 // interface for test domain memebers.

    74 // Any test memeber should derive from this interface 

    75 class MDmDomainMember

    76 	{

    77 public:

    78 	virtual TDmHierarchyId HierarchyId() = 0;

    79 	virtual TDmDomainId	DomainId() = 0;

    80 	virtual TDmDomainState State() = 0;

    81 	virtual TInt Status() = 0;

    82 	virtual TUint32 Ordinal() = 0;

    83 	virtual TInt Notifications() = 0;

    84 	};

    85 

    86 class MDmTest

    87 	{

    88 public:

    89 	virtual void Perform() = 0;

    90 	virtual void Release() = 0;

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

    92 	virtual void TransitionRequestComplete() = 0;

    93 	};

    94 

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

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

    97 #define ORDINAL_FROM_DOMAINID0(id) (id)

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

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

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

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

   102 

   103 #define ORDINAL_LEVEL(ordinal)			\

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

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

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

   107 

   108 

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

   110 TBool GetDomainChar(TDmDomainId aDomainId, TChar& aChar)

   111 	{

   112 	TBool found = ETrue;

   113 	switch(aDomainId)

   114 		{

   115 		

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

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

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

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

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

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

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

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

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

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

   126 		// domain char not found 

   127 		case KDmIdNone:

   128 		case KDmIdRoot:		

   129 		default:			

   130 			found = EFalse;

   131 		}

   132 	return found;

   133 	}

   134 

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

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

   137 void GetDomainDesc(TUint32 aOrdinal, TDes& aDes)

   138 	{

   139 	if (aOrdinal == KDmIdRoot)

   140 		{

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

   142 		return;

   143 		}

   144 

   145 	TUint32 val =  aOrdinal;

   146 

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

   148 		{

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

   150 		TChar ch;

   151 		TBool found = GetDomainChar(domainId, ch);

   152 		if (found)

   153 			aDes.Append(ch);

   154 		val = val << 8;

   155 		}

   156 

   157 	}

   158 

   159 

   160 class CDmTestMember : public CActive, public MDmDomainMember

   161 	{

   162 public:	

   163 	// from CActive

   164 	void RunL();

   165 	// from MDmDomainMember

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

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

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

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

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

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

   172 

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

   174 	~CDmTestMember();

   175 	void Acknowledge();

   176 

   177 protected:

   178 	// from CActive

   179 	virtual void DoCancel();

   180 

   181 

   182 public:

   183 	TDmHierarchyId iHierarchy;

   184 	TDmDomainId	iId;

   185 	TDmDomainState iState;

   186 	TUint32		iOrdinal;

   187 	MDmTest*	iTest;	

   188 	TInt		iNotifications;

   189 	RDmDomain	iDomain;

   190 	};

   191 

   192 

   193 

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

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

   196 	{

   197 	TInt r;

   198 

   199 	if (iHierarchy == KDmHierarchyIdPower)

   200 		 r = iDomain.Connect(iId);

   201 	else

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

   203 

   204 	test(r == KErrNone);

   205 

   206 	CActiveScheduler::Add(this);

   207 

   208 	iDomain.RequestTransitionNotification(CActive::iStatus);

   209 	CActive::SetActive();

   210 	}

   211 

   212 CDmTestMember::~CDmTestMember()

   213 	{

   214 	CActive::Cancel();

   215 	iDomain.Close();

   216 	}

   217 

   218 void CDmTestMember::Acknowledge()

   219 	{

   220 	iDomain.AcknowledgeLastState();

   221 	}

   222 

   223 void CDmTestMember::RunL()

   224 	{

   225 

   226 	iNotifications++;

   227 

   228 	iState = iDomain.GetState();

   229 

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

   231 	if (ackError == KErrNone)

   232 		iDomain.AcknowledgeLastState();

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

   234 		;

   235 	else

   236 		iDomain.AcknowledgeLastState(ackError);

   237 

   238 	

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

   240 	iDomain.RequestTransitionNotification(CActive::iStatus);

   241 	CActive::SetActive();

   242 	}

   243 

   244 void CDmTestMember::DoCancel()

   245 	{

   246 	iDomain.CancelTransitionNotification();

   247 	}

   248 

   249 

   250 // CDomainMemberAo

   251 class CDomainMemberAo : public CDmDomain, public MDmDomainMember

   252 	{

   253 public:	

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

   255 	~CDomainMemberAo();

   256 

   257 	// from CActive

   258 	void RunL();

   259 

   260 	// from MDmDomainMember

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

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

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

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

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

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

   267 

   268 private:

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

   270 

   271 public:

   272 	TDmHierarchyId iHierarchy;

   273 	TDmDomainId	iId;

   274 	TDmDomainState iState;

   275 	TUint32		iOrdinal;

   276 	MDmTest*	iTest;	

   277 	TInt		iNotifications;

   278 	};

   279 

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

   281 	{

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

   283 	CleanupStack::PushL(self);

   284 	self->ConstructL();

   285 

   286 	self->RequestTransitionNotification();

   287 

   288 	CleanupStack::Pop();

   289 	return self;

   290 	}

   291 

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

   293 	CDmDomain(aHierarchy, aId), 

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

   295 	{

   296 	}

   297 

   298 CDomainMemberAo::~CDomainMemberAo()

   299 	{

   300 	Cancel();

   301 	}

   302 

   303 void CDomainMemberAo::RunL()

   304 	{

   305 	iNotifications++;

   306 

   307 	iState = GetState();

   308 

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

   310 	if (ackError == KErrNone)

   311 		AcknowledgeLastState(ackError);

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

   313 		;

   314 	else

   315 		AcknowledgeLastState(ackError); 

   316 	if (ackError != KErrAbort)	

   317 		AcknowledgeLastState(ackError);

   318 

   319 	

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

   321 	RequestTransitionNotification();

   322 	}

   323 

   324 

   325 // CDomainManagerAo

   326 class CDomainManagerAo : public CDmDomainManager

   327 	{

   328 public:	

   329 	~CDomainManagerAo();

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

   331 

   332 	// from CActive

   333 	void RunL();

   334 

   335 private:

   336 	CDomainManagerAo(TDmHierarchyId aHierarchy, MDmTest& aTest);

   337 

   338 private:

   339 	MDmTest& iTest;

   340 	};

   341 

   342 

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

   344 	{

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

   346 	CleanupStack::PushL(self);

   347 

   348 	self->ConstructL();

   349 	CleanupStack::Pop();

   350 	return self;

   351 	}

   352 

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

   354 	CDmDomainManager(aHierarchy), iTest(aTest)

   355 	{

   356 	}

   357 

   358 CDomainManagerAo::~CDomainManagerAo()

   359 	{

   360 	}

   361 

   362 void CDomainManagerAo::RunL()

   363 	{

   364 	iTest.TransitionRequestComplete();

   365 	}

   366 

   367 

   368 class CDmTest1 : public CActive, public MDmTest

   369 	{

   370 public: // from CActive

   371 	void RunL();

   372 

   373 	// from MDmTest

   374 	void Perform();

   375 	void Release();

   376 	TInt TransitionNotification(MDmDomainMember& aDomainMember);

   377 	void TransitionRequestComplete() {};

   378 

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

   380 

   381 protected:

   382 	// from CActive

   383 	virtual void DoCancel();

   384 

   385 private:

   386 	enum { KMembersMax = 16 };

   387 	CDmTestMember*		iMembers[KMembersMax]; 

   388 	RDmDomainManager	iManager;

   389 	TDmDomainId			iDomainId;

   390 	TPowerState			iState;

   391 	TBool				iAcknowledge;

   392 	TInt				iMembersCount;

   393 	TInt				iCount;

   394 	TUint32				iOrdinal;

   395 	};

   396 

   397 void CDmTest1::Perform()

   398 	{

   399 	//

   400 	// Test domain transitions

   401 	//

   402 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   417 	

   418 	// expected number of notifications

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

   420 	// first expected ordinal

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

   422 

   423 	TInt r = iManager.Connect();

   424 	test(r == KErrNone);

   425 

   426 	CActiveScheduler::Add(this);

   427 

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

   429 	CActive::SetActive();

   430 

   431 	CActiveScheduler::Start();

   432 	}

   433 

   434 TInt CDmTest1::TransitionNotification(MDmDomainMember& aDomainMember)

   435 	{

   436 	++iCount;

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

   438 		{

   439 		if(aDomainMember.Ordinal() < iOrdinal)

   440 			{

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

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

   443 			iCount--;

   444 			}

   445 		}

   446 	else

   447 		{

   448 		if(aDomainMember.Ordinal() > iOrdinal)

   449 			{

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

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

   452 			iCount--;

   453 			}

   454 		}

   455 	iOrdinal = aDomainMember.Ordinal();

   456 

   457 	// acknowledge one from two

   458 	iAcknowledge = !iAcknowledge;

   459 	return iAcknowledge?KErrNone:KErrGeneral;

   460 	}

   461 

   462 void CDmTest1::RunL()

   463 	{

   464 	CActiveScheduler::Stop();

   465 

   466 	iManager.Close();

   467 

   468 	CDmTestMember** mp;

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

   470 		delete *mp;

   471 	test(iCount == iMembersCount);

   472 	}

   473 

   474 void CDmTest1::DoCancel()

   475 	{

   476 	test(0);

   477 	}

   478 

   479 void CDmTest1::Release()

   480 	{

   481 	delete this;

   482 	}

   483 

   484 class CDmTest2Timer : public CTimer

   485 	{

   486 public: // fomr CTimer

   487    void RunL();

   488 public:

   489 	CDmTest2Timer() : CTimer(0) 

   490 		{

   491 		TRAPD(r,

   492 			ConstructL());

   493 		test(r == KErrNone);

   494 		CActiveScheduler::Add(this);

   495 		}

   496 	};

   497 

   498 void CDmTest2Timer::RunL()

   499 	{

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

   501 

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

   503 	TTime wakeup;

   504 	wakeup.HomeTime();

   505 	wakeup += TTimeIntervalSeconds(3);

   506 	At(wakeup);

   507 	}

   508 

   509 class CDmTest2 : public CActive, public MDmTest

   510 	{

   511 public: // from CActive

   512 	void RunL();

   513 

   514 	// from MDmTest

   515 	void Perform();

   516 	void Release();

   517 	TInt TransitionNotification(MDmDomainMember& aDomainMember);

   518 	void TransitionRequestComplete() {};

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

   520 

   521 protected:

   522 	// from CActive

   523 	virtual void DoCancel();

   524 

   525 private:

   526 	enum { KMembersMax = 16 };

   527 	CDmTestMember*		iMembers[KMembersMax]; 

   528 	RDmDomainManager	iManager;

   529 	TPowerState			iState;

   530 	TBool				iAcknowledge;

   531 	TInt				iMembersCount;

   532 	TInt				iCount;

   533 	TUint32				iOrdinal;

   534 	CDmTest2Timer*		iTimer;

   535 	};

   536 

   537 

   538 void CDmTest2::Perform()

   539 	{

   540 	//

   541 	// Test system standby

   542 	//

   543 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   558 	

   559 	// expected number of notifications

   560 	iMembersCount = 12;

   561 	// first expected ordinal

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

   563 

   564 	TInt r = iManager.Connect();

   565 	test(r == KErrNone);

   566 

   567 	CActiveScheduler::Add(this);

   568 

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

   570 	iTimer = new CDmTest2Timer();

   571 	TTime wakeup;

   572 	wakeup.HomeTime();

   573 	wakeup += TTimeIntervalSeconds(5);

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

   575 	iTimer->At(wakeup);

   576 	

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

   578 	CActive::SetActive();

   579 

   580 	CActiveScheduler::Start();

   581 	}

   582 

   583 TInt CDmTest2::TransitionNotification(MDmDomainMember& aDomainMember)

   584 	{

   585 	++iCount;

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

   587 		{

   588 		if(aDomainMember.Ordinal() < iOrdinal)

   589 			{

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

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

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

   593 			iCount--;

   594 			}

   595 		}

   596 	else

   597 		{

   598 		if(aDomainMember.Ordinal() > iOrdinal)

   599 			{

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

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

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

   603 			iCount--;

   604 			}

   605 		}

   606 	iOrdinal = aDomainMember.Ordinal();

   607 

   608 	// acknowledge one from two

   609 	iAcknowledge = !iAcknowledge;

   610 	return iAcknowledge?KErrNone:KErrAbort;

   611 	}

   612 

   613 void CDmTest2::RunL()

   614 	{

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

   616 

   617 	iTimer->Cancel();	

   618 	CActiveScheduler::Stop();

   619 

   620 	iManager.Close();

   621 

   622 	CDmTestMember** mp;

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

   624 		delete *mp;

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

   626 	test(iCount == iMembersCount);

   627 	}

   628 

   629 void CDmTest2::DoCancel()

   630 	{

   631 	test(0);

   632 	}

   633 

   634 void CDmTest2::Release()

   635 	{

   636 	if (iTimer)

   637 		{

   638 		iTimer->Cancel();

   639 		delete iTimer;

   640 		}

   641 	delete this;

   642 	}

   643 

   644 class CDmTest3 : public MDmTest

   645 	{

   646 public: 

   647 	// from MDmTest

   648 	void Perform();

   649 	void Release();

   650 	TInt TransitionNotification(MDmDomainMember& aDomainMember);

   651 	void TransitionRequestComplete() {};

   652 	};

   653 

   654 void CDmTest3::Perform()

   655 	{

   656 	//

   657 	// Test simple error situation

   658 	//

   659 	RDmDomainManager manager;

   660 	TInt r = manager.Connect();

   661 	test(r == KErrNone);

   662 

   663 	RDmDomainManager manager1;

   664 	r = manager1.Connect();

   665 	test(r == KErrInUse);

   666 

   667 	RDmDomain domain;

   668 	r = domain.Connect(KDmIdNone);

   669 	test(r == KDmErrBadDomainId);

   670 	CDmTestMember*		testMember;

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

   672 	test (testMember != NULL);

   673 

   674 	TRequestStatus status;

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

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

   677 

   678 	TRequestStatus status1;

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

   680 	User::WaitForRequest(status1);

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

   682 	User::WaitForRequest(status);

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

   684 

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

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

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

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

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

   690 

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

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

   693 	manager.CancelTransition();

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

   695 	manager.CancelTransition();

   696 	User::WaitForRequest(status);

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

   698 

   699 	testMember->iDomain.CancelTransitionNotification();

   700 

   701 	delete testMember;

   702 	

   703 	domain.Close();

   704 	manager.Close();

   705 	}

   706 

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

   708 	{

   709 	test(0);

   710 	return KErrAbort;	// don't acknowledge

   711 	}

   712 

   713 void CDmTest3::Release()

   714 	{

   715 	delete this;

   716 	}

   717 

   718 class CDmTest4 : public MDmTest

   719 	{

   720 public: 

   721 	// from MDmTest

   722 	void Perform();

   723 	void Release();

   724 	TInt TransitionNotification(MDmDomainMember& aDomainMember);

   725 	void TransitionRequestComplete() {};

   726 private:

   727 	void ExecSlave(TUint arg);

   728 	};

   729 

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

   731 

   732 void CDmTest4::ExecSlave(TUint aArg)

   733 	{

   734 	RProcess proc;

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

   736 	test(r == KErrNone);

   737 	TRequestStatus status;

   738 	proc.Logon(status);

   739 	proc.Resume();

   740 	User::WaitForRequest(status);

   741 

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

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

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

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

   746 

   747 	CLOSE_AND_WAIT(proc);

   748 	}

   749 

   750 //! @SYMTestCaseID PBASE-T_DOMAIN-4

   751 //! @SYMTestType CT

   752 //! @SYMTestCaseDesc Dmain manager security tests

   753 //! @SYMREQ 3722

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

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

   756 //! @SYMTestPriority High

   757 //! @SYMTestStatus Defined

   758 void CDmTest4::Perform()

   759 	{

   760 	//

   761 	// Security tests

   762 	//

   763 

   764 	ExecSlave(0);

   765 

   766     ExecSlave(1);

   767 

   768 	}

   769 

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

   771 	{

   772 	test(0);

   773 	return KErrNone;

   774 	}

   775 

   776 void CDmTest4::Release()

   777 	{

   778 	delete this;

   779 	}

   780 

   781 // Test hierarchy tests

   782 class CDmTestStartupMember : public CDmTestMember

   783 	{

   784 public:

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

   786 

   787 public:

   788 private:

   789 	};

   790 

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

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

   793 	{

   794 	}

   795 

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

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

   798 class CDmTest5 : public CActive, public MDmTest

   799 	{

   800 public: 

   801 	// from CActive

   802 	void RunL();

   803 	// from MDmTest

   804 	void Perform();

   805 	void Release();

   806 	TInt TransitionNotification(MDmDomainMember& aDomainMember);

   807 	void TransitionRequestComplete();

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

   809 		CActive(CActive::EPriorityStandard), 

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

   811 protected:

   812 	// from CActive

   813 	virtual void DoCancel();

   814 

   815 private:

   816 	enum { KMembersMax = 16 };

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

   818 

   819 	CDmTestMember*		iTestMembers[KMembersMax]; 

   820 	CDomainMemberAo*	iPowerMembers[KMembersMax]; 

   821 

   822 	RDmDomainManager	iTestDomainManager;

   823 	

   824 	TDmDomainId			iPowerDomainId;

   825 	TDmDomainId			iTestDomainId;

   826 

   827 	TDmDomainState		iPowerState;

   828 	TDmDomainState		iTestState;

   829 

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

   831 	TInt				iTestDomainLevel;	

   832 

   833 	TDmTraverseDirection iTraverseDirection;

   834 

   835 	TAckMode			iAckMode;

   836 

   837 public:

   838 	TInt				iTestNotifications;

   839 	TInt				iPowerNotifications;

   840 	TInt				iTestNotificationsExpected;

   841 	TInt				iPowerNotificationsExpected;

   842 

   843 	TInt				iTransitionsCompleted;

   844 	TInt				iTransitionsExpected;

   845 	};

   846 

   847 

   848 

   849 //! @SYMTestCaseID PBASE-T_DOMAIN-5

   850 //! @SYMTestType CT

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

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

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

   854 //! @SYMTestExpectedResults  All tests should pass

   855 //! @SYMTestPriority High

   856 //! @SYMTestStatus Defined

   857 void CDmTest5::Perform()

   858 	{

   859 

   860  	__UHEAP_MARK;

   861 

   862 	//

   863 	// Test domain transitions

   864 	//

   865 	CActiveScheduler::Add(this);

   866 

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

   868 

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

   870 

   871 	test(r == KErrNone);

   872 

   873 	CDomainManagerAo* powerDomainManager = NULL;

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

   875 	test (powerDomainManager != NULL);

   876 

   877 	r = CDomainManagerAo::AddDomainHierarchy(KDmHierarchyIdPower);

   878 	test(r == KErrNone);

   879 

   880 	//*************************************************

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

   882 	//*************************************************

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

   884 

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

   886 

   887 	TInt testMemberCount = 0;

   888 

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

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

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

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

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

   894 	

   895 	// row 1

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

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

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

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

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

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

   902 	

   903 	// row2

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

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

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

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

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

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

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

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

   912 	

   913 	// row 3

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

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

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

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

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

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

   920 

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

   922 	TInt powerMemberCount = 0;

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

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

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

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

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

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

   929 

   930 

   931 	RArray<const TTransitionFailure> testFailures;

   932 	TInt testFailureCount;

   933 	RArray<const TTransitionFailure> powerFailures;

   934 	TInt powerFailureCount;

   935 

   936 

   937 

   938 	// calculate the expected number of notifications

   939 	TInt expectedTestNotifications = 0;

   940 	TInt leafNodes = 0;

   941 	

   942 

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

   944 	// notifications for the domain that is being transitioned

   945 	switch(iTestDomainId)

   946 		{

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

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

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

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

   951 

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

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

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

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

   956 

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

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

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

   960 		default:

   961 			test(0);

   962 		}

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

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

   965 

   966 	TInt expectedPowerNotifications = 0;

   967 	switch(iPowerDomainId)

   968 		{

   969 		case KDmIdRoot		:	expectedPowerNotifications = powerMemberCount; break;

   970 		case KDmIdApps		:	expectedPowerNotifications = 1; break;

   971 		case KDmIdUiApps	:	expectedPowerNotifications = 1; break;

   972 		default:

   973 			test(0);

   974 		}

   975 

   976 

   977 

   978 	// connect to the test hierarchy

   979 	r = iTestDomainManager.Connect(KDmHierarchyIdTest);

   980 	test(r == KErrNone);

   981 

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

   983 	RDmDomainManager	domainManager;

   984 	r = domainManager.Connect(KDmHierarchyIdTest);

   985 	test(r == KErrInUse);

   986 

   987 

   988 

   989 	//*************************************************

   990 	// Test 5b - request a positive transition

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

   992 	// and request that the test domain use ETraverseParentsFirst

   993 	//*************************************************

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

   995 	iAckMode = KAckAlways;

   996 

   997 	iTransitionsCompleted = iTestNotifications = iPowerNotifications = 0;

   998 	iPowerNotificationsExpected = 0;

   999 	iTestNotificationsExpected = expectedTestNotifications;

  1000 	iTransitionsExpected = 1;

  1001 

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

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

  1004 	// request a domain transition on the test hierarchy

  1005 	iTraverseDirection = ETraverseParentsFirst;

  1006 	if (iTestDomainId == KDmIdRoot)

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

  1008 	else

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

  1010 	CActive::SetActive();

  1011 

  1012 	CActiveScheduler::Start();

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

  1014 	test(iStatus == KErrNone);

  1015 	test(iTestNotifications == iTestNotificationsExpected);

  1016 	test(iPowerNotifications == iPowerNotificationsExpected);

  1017 

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

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

  1020 	//*************************************************

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

  1022 	RDmDomain domainMember;

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

  1024 	test (r == KErrNone);

  1025 	TDmDomainState state = domainMember.GetState();

  1026 	domainMember.Close();

  1027 	test (state == iTestState);

  1028 

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

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

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

  1032 		{

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

  1034 		test (r == KErrNone);

  1035 		TDmDomainState state = domainMember.GetState();

  1036 		domainMember.Close();

  1037 		test (state != iTestState);

  1038 		}

  1039 

  1040 

  1041 	//*************************************************

  1042 	// Test 5d- request a negative transition

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

  1044 	// and request that the test domain use ETraverseChildrenFirst

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

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

  1047 	iAckMode = KAckAlways;

  1048 	iTestState--;	// EStartupCriticalStatic;

  1049 	iPowerState--;	// EPwStandby

  1050 

  1051 	iTransitionsCompleted = iTestNotifications = iPowerNotifications = 0;

  1052 	iPowerNotificationsExpected = expectedPowerNotifications;

  1053 	iTestNotificationsExpected = expectedTestNotifications;

  1054 	iTransitionsExpected = 2;

  1055 

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

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

  1058 

  1059 	// request a domain transition on the test hierarchy

  1060 	iTraverseDirection = ETraverseChildrenFirst;

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

  1062 	CActive::SetActive();

  1063 

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

  1065 	CActiveScheduler::Start();

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

  1067 	test(iStatus == KErrNone);

  1068 	test(iTestNotifications == iTestNotificationsExpected);

  1069 	test(iPowerNotifications == iPowerNotificationsExpected);

  1070 	

  1071 

  1072 	//*************************************************

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

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

  1075 	//*************************************************

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

  1077 	iAckMode = KAckNever;

  1078 	iTestState++;		// EStartupCriticalDynamic;

  1079 	iPowerState++;		// EPwActive

  1080 

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

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

  1083 	iTransitionsCompleted = iTestNotifications = iPowerNotifications = 0;

  1084 	iPowerNotificationsExpected = expectedPowerNotifications;

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

  1086 	iTransitionsExpected = 2;

  1087 

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

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

  1090 

  1091 	// request a domain transition on the test hierarchy

  1092 	iTraverseDirection = ETraverseChildrenFirst;

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

  1094 	CActive::SetActive();

  1095 

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

  1097 	CActiveScheduler::Start();

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

  1099 	test(iStatus == KErrTimedOut);

  1100 	test(iTestNotifications == iTestNotificationsExpected);

  1101 	test(iPowerNotifications == iPowerNotificationsExpected);

  1102 	

  1103 	// get the failures on the test hierarchy

  1104 	testFailureCount = iTestDomainManager.GetTransitionFailureCount();

  1105 	test (testFailureCount == 1);

  1106 

  1107 	r = iTestDomainManager.GetTransitionFailures(testFailures);

  1108 	test(r == KErrNone);

  1109 	test(testFailureCount == testFailures.Count());

  1110 

  1111 	test.Printf(_L("Test failures = %d\n"), testFailureCount);

  1112 	TInt i;

  1113 	for (i=0; i<testFailureCount; i++)

  1114 		{

  1115 		test.Printf(_L("%d: iDomainId %d, iError %d\n"), 

  1116 			i, testFailures[i].iDomainId, testFailures[i].iError);

  1117 		test(testFailures[i].iError == KErrTimedOut);

  1118 		}

  1119 

  1120 	// get the failures on the power hierarchy

  1121 	powerFailureCount = powerDomainManager->GetTransitionFailureCount();

  1122 	test (powerFailureCount == expectedPowerNotifications);

  1123 

  1124 	r = powerDomainManager->GetTransitionFailures(powerFailures);

  1125 	test(r == KErrNone);

  1126 	test(powerFailureCount == powerFailures.Count());

  1127 

  1128 	test.Printf(_L("Power failures = %d\n"), powerFailureCount);

  1129 	for (i=0; i<powerFailureCount; i++)

  1130 		{

  1131 		test.Printf(_L("%d: iDomainId %d, iError %d\n"), 

  1132 			i, powerFailures[i].iDomainId, powerFailures[i].iError);

  1133 		test(powerFailures[i].iError == KErrTimedOut);

  1134 		}