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 // Framework code for Domain Manager tests.

    15 //

    16 

    17 #include <e32base.h>

    18 #define __E32TEST_EXTENSION__

    19 #include <e32test.h>

    20 

    21 #include "domainpolicytest.h"

    22 #include "t_domain.h"

    23 

    24 

    25 extern RTest test;

    26 

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

    28 TBool GetDomainChar(TDmDomainId aDomainId, TChar& aChar)

    29 	{

    30 	TBool found = ETrue;

    31 	switch(aDomainId)

    32 		{

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

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

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

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

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

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

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

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

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

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

    43 		// domain char not found

    44 		case KDmIdNone:

    45 		case KDmIdRoot:

    46 		default:

    47 			found = EFalse;

    48 		}

    49 	return found;

    50 	}

    51 

    52 

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

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

    55 void GetDomainDesc(TUint32 aOrdinal, TDes& aDes)

    56 	{

    57 	if (aOrdinal == KDmIdRoot)

    58 		{

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

    60 		return;

    61 		}

    62 

    63 	TUint32 val =  aOrdinal;

    64 

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

    66 		{

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

    68 		TChar ch;

    69 		TBool found = GetDomainChar(domainId, ch);

    70 		if (found)

    71 			aDes.Append(ch);

    72 		val = val << 8;

    73 		}

    74 	}

    75 

    76 

    77 CDmTestMember::CDmTestMember(TDmHierarchyId aHierarchy, TDmDomainId aId,

    78 							 TUint32 aOrdinal, MDmTest* aTest)

    79   : CActive(CActive::EPriorityStandard),

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

    81 	{

    82 	TInt r;

    83 

    84 	if (iHierarchy == KDmHierarchyIdPower)

    85 		 r = iDomain.Connect(iId);

    86 	else

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

    88 

    89 	test(r == KErrNone);

    90 

    91 	CActiveScheduler::Add(this);

    92 

    93 	iDomain.RequestTransitionNotification(CActive::iStatus);

    94 	CActive::SetActive();

    95 	}

    96 

    97 CDmTestMember::~CDmTestMember()

    98 	{

    99 	CActive::Cancel();

   100 	iDomain.Close();

   101 	}

   102 

   103 void CDmTestMember::Acknowledge()

   104 	{

   105 	iDomain.AcknowledgeLastState();

   106 	}

   107 

   108 void CDmTestMember::RunL()

   109 	{

   110 	RDebug::Printf("CDmTestMember::RunL(): %d", iStatus.Int());

   111 	iNotifications++;

   112 

   113 	if (iHierarchy == KDmHierarchyIdPower)

   114 		{

   115 		iState = (TDmDomainState) iDomain.GetPowerState();

   116 		}

   117 	else

   118 		{

   119 		iState = iDomain.GetState();

   120 		}

   121 		

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

   123 	if (ackError == KErrNone)

   124 		{

   125 		iDomain.AcknowledgeLastState();

   126 		}

   127 	else if (ackError == KErrAbort)

   128 		{

   129 		; // don't acknowledge

   130 		}

   131 	else

   132 		{

   133 		iDomain.AcknowledgeLastState(ackError);

   134 		}

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

   136 	iDomain.RequestTransitionNotification(CActive::iStatus);

   137 	CActive::SetActive();

   138 	}

   139 

   140 void CDmTestMember::DoCancel()

   141 	{

   142 	iDomain.CancelTransitionNotification();

   143 	}

   144 

   145 

   146 CDomainMemberAo* CDomainMemberAo::NewL(TDmHierarchyId aHierarchy, TDmDomainId aId,

   147 									   TUint32 aOrdinal, MDmTest* aTest)

   148 	{

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

   150 	CleanupStack::PushL(self);

   151 	self->ConstructL();

   152 

   153 	self->RequestTransitionNotification();

   154 

   155 	CleanupStack::Pop();

   156 	return self;

   157 	}

   158 

   159 CDomainMemberAo::CDomainMemberAo(TDmHierarchyId aHierarchy, TDmDomainId aId, TUint32 aOrdinal,

   160 								 MDmTest* aTest)

   161 	: CDmDomain(aHierarchy, aId),

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

   163 	{

   164 	}

   165 

   166 CDomainMemberAo::~CDomainMemberAo()

   167 	{

   168 	Cancel();

   169 	}

   170 

   171 void CDomainMemberAo::RunL()

   172 	{

   173 	RDebug::Printf("CDomainMemberAo::RunL(): %d", iStatus.Int());

   174 	iNotifications++;

   175 

   176 	iState = GetState();

   177 

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

   179 	if (ackError == KErrNone)

   180 		AcknowledgeLastState(ackError);

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

   182 		;

   183 	else

   184 		AcknowledgeLastState(ackError);

   185 	if (ackError != KErrAbort)

   186 		AcknowledgeLastState(ackError);

   187 

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

   189 	RequestTransitionNotification();

   190 	}

   191 

   192 

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

   194 	{

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

   196 	CleanupStack::PushL(self);

   197 

   198 	self->ConstructL();

   199 	CleanupStack::Pop();

   200 	return self;

   201 	}

   202 

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

   204 	CDmDomainManager(aHierarchy), iTest(aTest)

   205 	{

   206 	}

   207 

   208 CDomainManagerAo::~CDomainManagerAo()

   209 	{

   210 	}

   211 

   212 void CDomainManagerAo::RunL()

   213 	{

   214 	RDebug::Printf("CDomainManagerAo::RunL(): %d", iStatus.Int());

   215 	iTest.TransitionRequestComplete();

   216 	}

   217 

   218 

   219 //

   220 // Deferral Test code

   221 //

   222 

   223 //

   224 // CDmDeferralTest

   225 //

   226 

   227 CDmDeferralTest::CDmDeferralTest(TDmHierarchyId aId, TDmDomainState aState)

   228 	: CActive(CActive::EPriorityStandard), iHierarchyId(aId), iState(aState)

   229 	{

   230 	CActiveScheduler::Add(this);

   231 	}

   232 

   233 CDmDeferralTest::~CDmDeferralTest()

   234 	{

   235 	iManager.Close();

   236 	delete iMember;

   237 	}

   238 

   239 /**

   240 Basic test setup : load and connect to appropriate hierarchy

   241 */

   242 void CDmDeferralTest::Perform()

   243 	{

   244 	TInt r = RDmDomainManager::AddDomainHierarchy(iHierarchyId);

   245 	test_KErrNone(r);

   246 

   247 	r = iManager.Connect(iHierarchyId);

   248 	test_KErrNone(r);

   249 

   250 	DoPerform();

   251 

   252 	CActive::SetActive();

   253 	CActiveScheduler::Start();

   254 	}

   255 

   256 void CDmDeferralTest::Release()

   257 	{

   258 	delete this;

   259 	}

   260 

   261 /**

   262 aDomainMember has recieved a transition notification

   263 */

   264 TInt CDmDeferralTest::TransitionNotification(MDmDomainMember& aDomainMember)

   265 	{

   266 	test.Printf(_L("MDmDomainMember notified of transition, Domain ID=%d"),

   267 				aDomainMember.DomainId());

   268 	return KErrNone;

   269 	}

   270 

   271 /**

   272 A transition has completed

   273 */

   274 void CDmDeferralTest::TransitionRequestComplete()

   275 	{}

   276 

   277 void CDmDeferralTest::RunL()

   278 	{

   279 	RDebug::Printf("CDmDeferralTest::RunL(): %d", iStatus.Int());

   280 	TransitionRequestComplete();

   281 	CActiveScheduler::Stop();

   282 	}

   283 

   284 void CDmDeferralTest::DoCancel()

   285 	{

   286 	test(0);

   287 	}

   288 

   289 //

   290 //

   291 // CTestKeepAlive

   292 //

   293 

   294 

   295 CTestKeepAlive::CTestKeepAlive(RDmDomain& aDomain)

   296 	: CActive(CActive::EPriorityHigh), iDomain(aDomain), iCount(0)

   297 	{

   298 	CActiveScheduler::Add(this);

   299 	}

   300 

   301 CTestKeepAlive::~CTestKeepAlive()

   302 	{

   303 	Cancel();

   304 	}

   305 

   306 /**

   307 Begin deferrals

   308 

   309 @param aMember The object to notify when deferrals cease

   310 @param aDeferralCount Number of times to defer

   311 */

   312 void CTestKeepAlive::BeginDeferrals(MDeferringMember* aMember, TInt aDeferralCount)

   313 	{

   314 	iDeferringMember = aMember;

   315 	iCount = aDeferralCount;

   316 

   317 	if(iCount > 0)

   318 		DeferAcknowledgement();

   319 	}

   320 

   321 void CTestKeepAlive::DeferAcknowledgement()

   322 	{

   323 	test.Printf(_L("DeferAcknowledgement() iCount %d\n"), iCount);

   324 	iDomain.DeferAcknowledgement(iStatus);

   325 	SetActive();

   326 	}

   327 

   328 void CTestKeepAlive::RunL()

   329 	{

   330 	RDebug::Printf("CTestKeepAlive::RunL(): %d", iStatus.Int());

   331 	test(iCount>0);

   332 	--iCount;

   333 	TInt err = iStatus.Int();

   334 

   335 	if((iCount == 0) || (KErrNone != err))

   336 		{

   337 		iDeferringMember->HandleEndOfDeferrals(err);

   338 		iDeferringMember = NULL;

   339 		}

   340 	else

   341 		{

   342 		DeferAcknowledgement();

   343 		}

   344 	}

   345 

   346 void CTestKeepAlive::DoCancel()

   347 	{

   348 	iDomain.CancelDeferral();

   349 	}