1 // Copyright (c) 2007-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 "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 //

    15 

    16 /**

    17  @file

    18  @test

    19  @internalComponent - Internal Symbian test code  

    20 */

    21 

    22 #include <ssm/ssmstates.hrh>

    23 #include <ssm/ssmsubstates.hrh>

    24 #include <ssm/ssmstatemanager.h>

    25 #include <ssm/startupadaptation.h>

    26 #include <ssm/startupadaptationcommands.h>

    27 #include <ssm/startupadaptationevents.h>

    28 

    29 // Include the header file for the class under test

    30 #include "saastateadaptation.h"

    31 #include "saartcadaptation.h"

    32 #include "saasimadaptation.h"

    33 #include "saaemergencycallrfadaptation.h"

    34 #include "saamiscadaptation.h"

    35 #include "startupadaptationadapter.h"

    36 

    37 

    38 #include "ssmclayer.h"

    39 

    40 #include "ssmdebug.h"

    41 

    42 #include "tclayer_step_startupadaptationadapter.h"

    43 

    44 //Include the test wrappers

    45 #include "startupadaptationwrapper.h"

    46 

    47 #include <s32mem.h>

    48 

    49 /**

    50  * Helper class that stops the active scheduler when it's iStatus is complete

    51  * 

    52  * @internalComponent

    53  * @test

    54  */

    55 class CRequestWaiter : public CActive

    56 	{

    57 public:

    58 	/**

    59 	 * Starts the activescheduler, stopping it when iStatus on this object is complete.

    60 	 * Equivalent to User::WaitForRequest(iStatus) but uses the activescheduler.

    61 	 */

    62 	void StartWait()

    63 		{

    64 		if(!IsActive())

    65 			{

    66 			SetActive();

    67 			}

    68 		CActiveScheduler::Start();

    69 		}

    70 

    71 	// Make iStatus public for ease of use.

    72 	using CActive::iStatus;

    73 	// Make SetActive public for ease of use

    74 	void SetActive()

    75 		{

    76 		CActive::SetActive();

    77 		}

    78 	

    79 	CRequestWaiter() : CActive(EPriorityNormal)

    80 		{

    81 		CActiveScheduler::Add(this);

    82 		}

    83 protected:

    84 	// From CActive

    85 	void RunL()

    86 		{

    87 		// Ignore the completion value and just stop the active scheduler

    88 		CActiveScheduler::Stop();

    89 		}

    90 	

    91 	TInt RunError(TInt aError)

    92 		{

    93 		return aError;

    94 		}

    95 	

    96 	void DoCancel()

    97 		{

    98 		// Do nothing

    99 		}

   100 	};

   101 

   102 /**

   103  * Constructs a complete CCLayerTestStartupAdaptationAdapter object

   104  * @internalComponent

   105  */

   106 CCLayerTestStartupAdaptationAdapter::CCLayerTestStartupAdaptationAdapter()

   107 	{

   108 	

   109 	}

   110 

   111 /**

   112  * Releases any resources associated with this test

   113  * @internalComponent

   114  */

   115 CCLayerTestStartupAdaptationAdapter::~CCLayerTestStartupAdaptationAdapter()

   116 	{

   117 	

   118 	}

   119 

   120 /**

   121  * Test step preamble

   122  * @internalComponent

   123  */

   124 TVerdict CCLayerTestStartupAdaptationAdapter::doTestStepPreambleL()

   125 	{

   126 	return CTestStep::doTestStepPreambleL();

   127 	}

   128 

   129 /**

   130  * Test step - a single test step performs a series of tests.

   131  * 

   132  * See the individual doTest... methods on this class for details of the tests.

   133  * 

   134  * @internalComponent

   135  */

   136 TVerdict CCLayerTestStartupAdaptationAdapter::doTestStepL()

   137 	{

   138 	INFO_PRINTF1(_L("Entering test for compatibility layer startup adaptation adapter"));

   139 	__UHEAP_MARK;

   140 	

   141 	CActiveScheduler* as = new (ELeave) CActiveScheduler();

   142 	CleanupStack::PushL(as);

   143 	CActiveScheduler::Install(as);

   144 	

   145 	TRAPD(err, doTestOnDemandL());

   146 	TEST(err == KErrNone);

   147 	

   148 	TRAP(err, doTestStateAdaptationL());

   149 	TEST(err == KErrNone);

   150 	

   151 	TRAP(err, doTestSimAdaptationL());

   152 	TEST(err == KErrNone);

   153 	

   154 	TRAP(err, doTestRtcAdaptationL());

   155 	TEST(err == KErrNone);

   156 	

   157 	TRAP(err, doTestEmergencyCallRfAdaptationL());

   158 	TEST(err == KErrNone);

   159 	

   160 	TRAP(err, doTestMiscAdaptationL());

   161 	TEST(err == KErrNone);

   162 	

   163 	TRAP(err, doTestConcurrentRequestsL());

   164 	TEST(err == KErrNone);

   165 	

   166 	TRAP(err, doTestMultipleRequestsL());

   167 	TEST(err == KErrNone);	

   168 	

   169 	TRAP(err, doTestCreationAndDestructionL());

   170 	TEST(err == KErrNone);	

   171 	

   172 	CleanupStack::PopAndDestroy(as);

   173 	

   174 	__UHEAP_MARKEND;

   175 	INFO_PRINTF1(_L("Leaving test for compatibility layer startup adaptation adapter"));

   176 	return TestStepResult();

   177 	}

   178 

   179 /**

   180  * Test step postamble

   181  * @internalComponent

   182  */

   183 TVerdict CCLayerTestStartupAdaptationAdapter::doTestStepPostambleL()

   184 	{

   185 	return CTestStep::doTestStepPostambleL();

   186 	}

   187 	

   188 /**

   189 Old Test CaseID 		AFSS-CLAYER-0012

   190 New Test CaseID 		DEVSRVS-SSREFPLUGINS-CLAYER-0012

   191  */		

   192 

   193 void CCLayerTestStartupAdaptationAdapter::doTestStateAdaptationL()

   194 	{

   195 	__UHEAP_MARK;

   196 	INFO_PRINTF1(_L("Enterting doTestStateAdaptationL()"));

   197 	

   198 	INFO_PRINTF1(_L("Creating state adaptation"));

   199 	MStateAdaptation* stateAdaptation = CStartupAdaptationAdapter::NewStateAdaptationL();

   200 	TEST(stateAdaptation != NULL);

   201 	if(stateAdaptation == NULL)

   202 		{

   203 		INFO_PRINTF1(_L("Failed to create state adaptation"));

   204 		return;

   205 		}

   206 	

   207 	CRequestWaiter* request = new (ELeave) CRequestWaiter();

   208 	CleanupStack::PushL(request);

   209 	

   210 	INFO_PRINTF1(_L("Testing coop state change mapping"));

   211 	doTestStateChangeMappingsL(stateAdaptation);

   212 	

   213 	INFO_PRINTF1(_L("Testing coop self test"));

   214 	stateAdaptation->RequestCoopSysSelfTest(request->iStatus);

   215 	StartupAdaptation::TResponsePckg okResponse(KErrNone); 

   216 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EExecuteSelftests);

   217 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EExecuteSelftests, okResponse);	

   218 	request->StartWait();

   219 	TEST(request->iStatus == KErrNone);

   220 	

   221 	INFO_PRINTF1(_L("Testing coop self test fail"));

   222 	stateAdaptation->RequestCoopSysSelfTest(request->iStatus);

   223 	StartupAdaptation::TResponsePckg failResponse(KErrGeneral); 

   224 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EExecuteSelftests);

   225 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EExecuteSelftests, failResponse);	

   226 	request->StartWait();

   227 	TEST(request->iStatus == KErrGeneral);

   228 	

   229 	INFO_PRINTF1(_L("Testing coop self test cancel"));

   230 	stateAdaptation->RequestCoopSysSelfTest(request->iStatus); 

   231 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EExecuteSelftests);	

   232 	TEST(request->iStatus == KRequestPending);

   233 	stateAdaptation->RequestCancel();

   234 	request->StartWait();

   235 	TEST(request->iStatus == KErrCancel);

   236 	

   237 	INFO_PRINTF1(_L("Testing coop perform shutdown actions"));

   238 	TInt reason = 0;

   239 	stateAdaptation->RequestCoopSysPerformShutdownActions(reason, request->iStatus);

   240 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EExecuteShutdown);

   241 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EExecuteShutdown, okResponse);

   242 	request->StartWait();

   243 	TEST(request->iStatus == KErrNone);

   244 	

   245 	INFO_PRINTF1(_L("Testing coop perform shutdown actions fail"));

   246 	reason = 0;

   247 	stateAdaptation->RequestCoopSysPerformShutdownActions(reason, request->iStatus);

   248 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EExecuteShutdown);

   249 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EExecuteShutdown, failResponse);

   250 	request->StartWait();

   251 	TEST(request->iStatus == KErrGeneral);

   252 				

   253 	INFO_PRINTF1(_L("Testing coop perform RFS actions"));

   254 	INFO_PRINTF1(_L("Testing shallow RFS"));

   255 	stateAdaptation->RequestCoopSysPerformRfsActions(ESsmShallowRfs, request->iStatus);

   256 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EExecuteDOSRfs);

   257 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EExecuteDOSRfs, okResponse);

   258 	request->StartWait();

   259 	TEST(request->iStatus == KErrNone);

   260 	TPckgBuf<StartupAdaptation::TRFSReason> rfsReasonBuf;

   261 	rfsReasonBuf.Copy(*CStartupAdaptationWrapper::LastCommandData());

   262 	TEST(rfsReasonBuf() == StartupAdaptation::ENormalRFS);

   263 	

   264 	INFO_PRINTF1(_L("Testing shallow RFS fail"));

   265 	stateAdaptation->RequestCoopSysPerformRfsActions(ESsmShallowRfs, request->iStatus);

   266 	TEST(request->iStatus == KRequestPending);

   267 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EExecuteDOSRfs);

   268 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EExecuteDOSRfs, failResponse);

   269 	request->StartWait();

   270 	TEST(request->iStatus == KErrGeneral);

   271 	rfsReasonBuf.Copy(*CStartupAdaptationWrapper::LastCommandData());

   272 	TEST(rfsReasonBuf() == StartupAdaptation::ENormalRFS);

   273 	

   274 	INFO_PRINTF1(_L("Testing deep RFS"));

   275 	stateAdaptation->RequestCoopSysPerformRfsActions(ESsmDeepRfs, request->iStatus);

   276 	TEST(request->iStatus == KRequestPending);

   277 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EExecuteDOSRfs);

   278 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EExecuteDOSRfs, okResponse);

   279 	request->StartWait();

   280 	TEST(request->iStatus == KErrNone);

   281 	rfsReasonBuf.Copy(*CStartupAdaptationWrapper::LastCommandData());

   282 	TEST(rfsReasonBuf() == StartupAdaptation::EDeepRFS);	

   283 	

   284 	INFO_PRINTF1(_L("Testing deep RFS failure"));

   285 	stateAdaptation->RequestCoopSysPerformRfsActions(ESsmDeepRfs, request->iStatus);

   286 	TEST(request->iStatus == KRequestPending);

   287 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EExecuteDOSRfs);

   288 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EExecuteDOSRfs, failResponse);

   289 	request->StartWait();

   290 	TEST(request->iStatus == KErrGeneral);

   291 	rfsReasonBuf.Copy(*CStartupAdaptationWrapper::LastCommandData());

   292 	TEST(rfsReasonBuf() == StartupAdaptation::EDeepRFS);

   293 	

   294 	INFO_PRINTF1(_L("Testing coop perform restart actions"));

   295 	reason = StartupAdaptation::ELanguageSwitchReset;

   296 	stateAdaptation->RequestCoopSysPerformRestartActions(reason, request->iStatus);

   297 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EExecuteReset);

   298 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EExecuteReset, okResponse);

   299 	request->StartWait();

   300 	TEST(request->iStatus == KErrNone);

   301 	TPckgBuf<StartupAdaptation::TResetReason> restartReasonBuf;

   302 	restartReasonBuf.Copy(*CStartupAdaptationWrapper::LastCommandData());

   303 	TEST(restartReasonBuf() == reason);

   304 	

   305 	INFO_PRINTF1(_L("Testing coop perform restart actions fail"));

   306 	reason = StartupAdaptation::ELanguageSwitchReset;

   307 	stateAdaptation->RequestCoopSysPerformRestartActions(reason, request->iStatus);

   308 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EExecuteReset);

   309 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EExecuteReset, failResponse);

   310 	request->StartWait();

   311 	TEST(request->iStatus == KErrGeneral);

   312 	restartReasonBuf.Copy(*CStartupAdaptationWrapper::LastCommandData());

   313 	TEST(restartReasonBuf() == reason);

   314 	

   315 	INFO_PRINTF1(_L("Testing alternative coop perform restart actions"));

   316 	reason = StartupAdaptation::ESIMStatusChangeReset;

   317 	stateAdaptation->RequestCoopSysPerformRestartActions(reason, request->iStatus);

   318 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EExecuteReset);

   319 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EExecuteReset, okResponse);

   320 	request->StartWait();

   321 	TEST(request->iStatus == KErrNone);

   322 	restartReasonBuf.Copy(*CStartupAdaptationWrapper::LastCommandData());

   323 	TEST(restartReasonBuf() == reason);

   324 			

   325 	INFO_PRINTF1(_L("Testing coop notify sys event fatal event"));

   326 	TPckgBuf<TSsmCoopSysEventType> eventBuf;

   327 	stateAdaptation->NotifyCoopSysEvent(eventBuf, request->iStatus);

   328 	TEST(request->iStatus == KRequestPending);

   329 	StartupAdaptation::TFatalErrorTypePckg fatalErrorPckg(StartupAdaptation::EUnclassifiedError);

   330 	CStartupAdaptationWrapper::TriggerObserverEventCallbackL(StartupAdaptation::EFatalError, fatalErrorPckg);

   331 	TEST(request->iStatus == KErrNone);

   332 	TEST(eventBuf() == ESsmFatalCoopSysError);

   333 	

   334 	INFO_PRINTF1(_L("Testing coop notify sys event non-fatal event"));

   335 	stateAdaptation->NotifyCoopSysEvent(eventBuf, request->iStatus);

   336 	TEST(request->iStatus == KRequestPending);

   337     fatalErrorPckg() = StartupAdaptation::ESimRemoved;

   338 	CStartupAdaptationWrapper::TriggerObserverEventCallbackL(StartupAdaptation::EFatalError, fatalErrorPckg);

   339 	//Should still be pending as SIM removed goes via the SIM adaptation

   340 	TEST(request->iStatus == KRequestPending);

   341 	

   342 	INFO_PRINTF1(_L("Testing coop notify sys event cancel"));

   343 	stateAdaptation->NotifyCancel();

   344 	request->StartWait();

   345 	TEST(request->iStatus == KErrCancel);

   346 	

   347 	INFO_PRINTF1(_L("Testing coop notify sys shutdown event"));

   348 	stateAdaptation->NotifyCoopSysEvent(eventBuf, request->iStatus);

   349 	TEST(request->iStatus == KRequestPending);

   350 	TBuf8<1> emptyBuf;

   351 	CStartupAdaptationWrapper::TriggerObserverEventCallbackL(StartupAdaptation::EDOSOriginatedShutdown, emptyBuf);

   352 	request->StartWait();

   353 	TEST(request->iStatus == KErrNone);

   354 	TEST(eventBuf() == ESsmShutdownDevice);

   355 	

   356 	INFO_PRINTF1(_L("Testing coop notify sys restart event"));

   357 	stateAdaptation->NotifyCoopSysEvent(eventBuf, request->iStatus);

   358 	TEST(request->iStatus == KRequestPending);

   359 	CStartupAdaptationWrapper::TriggerObserverEventCallbackL(StartupAdaptation::EDOSOriginatedReset, emptyBuf);

   360 	request->StartWait();

   361 	TEST(request->iStatus == KErrNone);

   362 	TEST(eventBuf() == ESsmRestartDevice);

   363 	

   364 	INFO_PRINTF1(_L("Releasing state adaptation"));

   365 	stateAdaptation->Release();

   366 	stateAdaptation = NULL;

   367 

   368 	CleanupStack::PopAndDestroy(request);

   369 	

   370 	INFO_PRINTF1(_L("Heap check macro end"));

   371 	// Delete the test data buffer

   372 	CStartupAdaptationWrapper::DeleteLastCommandData();

   373 	__UHEAP_MARKEND;

   374 	

   375 	INFO_PRINTF1(_L("Returning from doTestStateAdaptationL()"));

   376 	}

   377 

   378 /**

   379 Old Test CaseID 		AFSS-CLAYER-0013

   380 New Test CaseID 		DEVSRVS-SSREFPLUGINS-CLAYER-0012

   381  */		

   382 

   383 void CCLayerTestStartupAdaptationAdapter::doTestSimAdaptationL()

   384 	{

   385 	__UHEAP_MARK;

   386 	INFO_PRINTF1(_L("Enterting doTestSimAdaptationL()"));

   387 

   388 	INFO_PRINTF1(_L("Creating SIM adaptation"));

   389 	MSimAdaptation* simAdaptation = CStartupAdaptationAdapter::NewSimAdaptationL();

   390 	TEST(simAdaptation != NULL);

   391 	if(simAdaptation == NULL)

   392 		{

   393 		INFO_PRINTF1(_L("Failed to create SIM adaptation"));

   394 		return;

   395 		}

   396 	

   397 	INFO_PRINTF1(_L("Testing get SIM changed true"));

   398 	CRequestWaiter* request = new (ELeave) CRequestWaiter();

   399 	CleanupStack::PushL(request);

   400 	

   401 	TPckgBuf<TBool> boolPckg;

   402 	StartupAdaptation::TBooleanResponsePckg booleanResponsePckg;

   403 	

   404 	INFO_PRINTF1(_L("Testing get SIM owned true"));

   405 	simAdaptation->GetSimOwned(boolPckg, request->iStatus);

   406 	TEST(request->iStatus == KRequestPending);

   407 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EGetSimOwned);

   408 	booleanResponsePckg().iErrorCode = KErrNone;

   409 	booleanResponsePckg().iValue = ETrue;

   410 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EGetSimOwned, booleanResponsePckg);

   411 	request->StartWait();

   412 	TEST(request->iStatus == KErrNone);

   413 	TEST(boolPckg());

   414 		

   415 	

   416 	INFO_PRINTF1(_L("Testing get SIM owned false"));

   417 	simAdaptation->GetSimOwned(boolPckg, request->iStatus);

   418 	TEST(request->iStatus == KRequestPending);

   419 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EGetSimOwned);

   420 	booleanResponsePckg().iErrorCode = KErrNone;

   421 	booleanResponsePckg().iValue = EFalse;

   422 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EGetSimOwned, booleanResponsePckg);

   423 	request->StartWait();

   424 	TEST(request->iStatus == KErrNone);

   425 	TEST(!boolPckg());

   426 	

   427 	INFO_PRINTF1(_L("Testing get SIM owned fail"));

   428 	simAdaptation->GetSimOwned(boolPckg, request->iStatus);

   429 	TEST(request->iStatus == KRequestPending);

   430 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EGetSimOwned);

   431 	booleanResponsePckg().iErrorCode = KErrGeneral;

   432 	booleanResponsePckg().iValue = ETrue;

   433 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EGetSimOwned, booleanResponsePckg);

   434 	request->StartWait();

   435 	TEST(request->iStatus == KErrGeneral);

   436 	

   437 	INFO_PRINTF1(_L("Testing get SIM owned cancel"));

   438 	simAdaptation->GetSimOwned(boolPckg, request->iStatus);

   439 	TEST(request->iStatus == KRequestPending);

   440 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EGetSimOwned);

   441 	// Cancel instead of responding

   442 	simAdaptation->GetCancel();

   443 	request->StartWait();

   444 	TEST(request->iStatus == KErrCancel);

   445 		

   446 		

   447 	INFO_PRINTF1(_L("Testing notify SIM event: SIM removed remembered from state test"));

   448 	TPckgBuf<TSsmSimEventType> simEventPckg;

   449 	StartupAdaptation::TFatalErrorTypePckg fatalErrorTypePckg;

   450 	simAdaptation->NotifySimEvent(simEventPckg, request->iStatus);

   451 	request->StartWait();

   452 	TEST(request->iStatus == KErrNone);

   453 	TEST(simEventPckg() == ESsmSimRemoved);

   454 	

   455 	INFO_PRINTF1(_L("Testing notify SIM event: SIM removed"));

   456 	simAdaptation->NotifySimEvent(simEventPckg, request->iStatus);

   457 	TEST(request->iStatus == KRequestPending);

   458 	fatalErrorTypePckg() = StartupAdaptation::ESimRemoved;

   459 	CStartupAdaptationWrapper::TriggerObserverEventCallbackL(StartupAdaptation::EFatalError, fatalErrorTypePckg);

   460 	request->StartWait();

   461 	TEST(request->iStatus == KErrNone);

   462 	TEST(simEventPckg() == ESsmSimRemoved);

   463 	

   464 	INFO_PRINTF1(_L("Testing notify SIM event: SIM usable"));

   465 	StartupAdaptation::TSimEventTypePckg simEventTypePckg;

   466 	simAdaptation->NotifySimEvent(simEventPckg, request->iStatus);

   467 	TEST(request->iStatus == KRequestPending);

   468 	simEventTypePckg() = StartupAdaptation::ESimUsable;

   469 	CStartupAdaptationWrapper::TriggerObserverEventCallbackL(StartupAdaptation::ESimEvent, simEventTypePckg);

   470 	request->StartWait();

   471 	TEST(request->iStatus == KErrNone);

   472 	TEST(simEventPckg() == ESsmSimUsable);

   473 	

   474 	INFO_PRINTF1(_L("Testing notify SIM event: SIM not ready"));

   475 	simAdaptation->NotifySimEvent(simEventPckg, request->iStatus);

   476 	TEST(request->iStatus == KRequestPending);

   477 	simEventTypePckg() = StartupAdaptation::ESimNotReady;

   478 	CStartupAdaptationWrapper::TriggerObserverEventCallbackL(StartupAdaptation::ESimEvent, simEventTypePckg);

   479 	request->StartWait();

   480 	TEST(request->iStatus == KErrNone);

   481 	TEST(simEventPckg() == ESsmSimNotReady);

   482 	

   483 	INFO_PRINTF1(_L("Testing notify SIM event: SIM readable"));

   484 	simAdaptation->NotifySimEvent(simEventPckg, request->iStatus);

   485 	TEST(request->iStatus == KRequestPending);

   486 	simEventTypePckg() = StartupAdaptation::ESimReadable;

   487 	CStartupAdaptationWrapper::TriggerObserverEventCallbackL(StartupAdaptation::ESimEvent, simEventTypePckg);

   488 	request->StartWait();

   489 	TEST(request->iStatus == KErrNone);

   490 	TEST(simEventPckg() == ESsmSimReadable);

   491 	

   492 	INFO_PRINTF1(_L("Testing notify SIM event ignores state events"));

   493 	simAdaptation->NotifySimEvent(simEventPckg, request->iStatus);

   494 	TEST(request->iStatus == KRequestPending);

   495 	fatalErrorTypePckg() = StartupAdaptation::EUnclassifiedError;

   496 	CStartupAdaptationWrapper::TriggerObserverEventCallbackL(StartupAdaptation::EFatalError, fatalErrorTypePckg);

   497 	TEST(request->iStatus == KRequestPending);

   498 	

   499 	INFO_PRINTF1(_L("Testing notify SIM event cancel"));

   500 	simAdaptation->NotifyCancel();

   501 	request->StartWait();

   502 	TEST(request->iStatus == KErrCancel);

   503 

   504 	CleanupStack::PopAndDestroy(request);

   505 	

   506 	INFO_PRINTF1(_L("Releasing SIM adaptation"));

   507 	simAdaptation->Release();

   508 	simAdaptation = NULL;

   509 

   510 	INFO_PRINTF1(_L("Heap check macro end"));

   511 	// Delete the test data buffer

   512 	CStartupAdaptationWrapper::DeleteLastCommandData();

   513 	__UHEAP_MARKEND;

   514 		

   515 	INFO_PRINTF1(_L("Returning from doTestSimAdaptationL()"));

   516 	}

   517 

   518 /**

   519 Old Test CaseID 		AFSS-CLAYER-0014

   520 New Test CaseID 		DEVSRVS-SSREFPLUGINS-CLAYER-0012

   521  */

   522 void CCLayerTestStartupAdaptationAdapter::doTestRtcAdaptationL()

   523 	{

   524 	__UHEAP_MARK;

   525 	INFO_PRINTF1(_L("Enterting doTestRtcAdaptationL()"));

   526 

   527 	INFO_PRINTF1(_L("Creating RTC adaptation"));

   528 	MRtcAdaptation* rtcAdaptation = CStartupAdaptationAdapter::NewRtcAdaptationL();

   529 	TEST(rtcAdaptation != NULL);

   530 	if(rtcAdaptation == NULL)

   531 		{

   532 		INFO_PRINTF1(_L("Failed to create RTC adaptation"));

   533 		return;

   534 		}

   535 	

   536 	CRequestWaiter* request = new (ELeave) CRequestWaiter();

   537 	CleanupStack::PushL(request);

   538 	

   539 	INFO_PRINTF1(_L("Testing RTC validity true"));

   540 	TPckgBuf<TBool> boolPckg;

   541 	StartupAdaptation::TResponsePckg responsePckg;

   542 	rtcAdaptation->ValidateRtc(boolPckg, request->iStatus);

   543 	TEST(request->iStatus == KRequestPending);

   544 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EValidateRTCTime);

   545 	// KErrNone means the RTC is valid

   546 	responsePckg() = KErrNone;

   547 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EValidateRTCTime, responsePckg);

   548 	request->StartWait();

   549 	TEST(request->iStatus == KErrNone);

   550 	TEST(boolPckg());

   551 	

   552 	INFO_PRINTF1(_L("Testing RTC validity false/failure - KErrGeneral"));

   553 	rtcAdaptation->ValidateRtc(boolPckg, request->iStatus);

   554 	TEST(request->iStatus == KRequestPending);

   555 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EValidateRTCTime);

   556 	// KErrGeneral means the RTC is not valid

   557 	responsePckg() = KErrGeneral;

   558 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EValidateRTCTime, responsePckg);

   559 	request->StartWait();

   560 	TEST(request->iStatus == KErrNone);

   561 	TEST(!boolPckg());

   562 		

   563 	

   564 	INFO_PRINTF1(_L("Testing RTC validity false/failure - KErrNotFound"));

   565 	rtcAdaptation->ValidateRtc(boolPckg, request->iStatus);

   566 	TEST(request->iStatus == KRequestPending);

   567 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EValidateRTCTime);

   568 	// KErrNotFound means the RTC is invalid

   569 	responsePckg() = KErrNotFound;

   570 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EValidateRTCTime, responsePckg);

   571 	request->StartWait();

   572 	TEST(request->iStatus == KErrNone);

   573 	TEST(!boolPckg());

   574 		

   575 	INFO_PRINTF1(_L("Testing RTC validity cancelling"));

   576 	rtcAdaptation->ValidateRtc(boolPckg, request->iStatus);

   577 	TEST(request->iStatus == KRequestPending);

   578 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EValidateRTCTime);

   579 	rtcAdaptation->Cancel();

   580 	request->StartWait();

   581 	TEST(request->iStatus == KErrCancel);

   582 	

   583 	INFO_PRINTF1(_L("Testing setting RTC wakeup"));

   584 	TInt64 testTime64 = 0x6677445599226600LL;

   585 	TTime testTime(testTime64);

   586 	TPckgC<TTime> timePckg(testTime);

   587 	rtcAdaptation->SetWakeupAlarm(timePckg, request->iStatus);

   588 	TEST(request->iStatus == KRequestPending);

   589 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::ESetWakeupAlarm);

   590 	StartupAdaptation::TWakeupAlarmPckg alarmPckg;

   591 	alarmPckg.Copy(*CStartupAdaptationWrapper::LastCommandData());

   592 	TEST(alarmPckg().iTime.Int64() == timePckg().Int64());

   593 	TEST(alarmPckg().iUniversalTimeOffset.Int() == 0);

   594 	TEST(alarmPckg().iDaylightSavingOffset.Int() == 0);

   595 	responsePckg() = KErrNone;

   596 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::ESetWakeupAlarm, responsePckg);

   597 	request->StartWait();

   598 	TEST(request->iStatus == KErrNone);

   599 	

   600 	INFO_PRINTF1(_L("Testing setting RTC wakeup failure"));

   601 	TInt64 test2Time64 = 0x5577112299338844LL;

   602 	TTime test2Time(test2Time64);

   603 	TPckgC<TTime> time2Pckg(test2Time);

   604 	rtcAdaptation->SetWakeupAlarm(time2Pckg, request->iStatus);

   605 	TEST(request->iStatus == KRequestPending);

   606 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::ESetWakeupAlarm);

   607 	alarmPckg.Copy(*CStartupAdaptationWrapper::LastCommandData());

   608 	TEST(alarmPckg().iTime.Int64() == time2Pckg().Int64());

   609 	TEST(alarmPckg().iUniversalTimeOffset.Int() == 0);

   610 	TEST(alarmPckg().iDaylightSavingOffset.Int() == 0);

   611 	responsePckg() = KErrGeneral;

   612 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::ESetWakeupAlarm, responsePckg);

   613 	request->StartWait();

   614 	TEST(request->iStatus == KErrGeneral);

   615 	

   616 	INFO_PRINTF1(_L("Testing unsetting RTC wakeup"));

   617 	rtcAdaptation->UnsetWakeupAlarm(request->iStatus);

   618 	TEST(request->iStatus == KRequestPending);

   619 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::ECancelWakeupAlarm);

   620 	TBuf8<1> nullBuf;

   621 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::ECancelWakeupAlarm, nullBuf);

   622 	request->StartWait();

   623 	TEST(request->iStatus == KErrNone);

   624 	

   625 	INFO_PRINTF1(_L("Testing unsetting RTC wakeup cancel"));

   626 	rtcAdaptation->UnsetWakeupAlarm(request->iStatus);

   627 	TEST(request->iStatus == KRequestPending);

   628 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::ECancelWakeupAlarm);

   629 	rtcAdaptation->Cancel();

   630 	request->StartWait();

   631 	TEST(request->iStatus == KErrCancel);	

   632 	

   633 	INFO_PRINTF1(_L("Releasing RTC adaptation"));

   634 	rtcAdaptation->Release();

   635 	rtcAdaptation = NULL;

   636 

   637 	CleanupStack::PopAndDestroy(request);

   638 	

   639 	INFO_PRINTF1(_L("Heap check macro end"));

   640 	// Delete the test data buffer

   641 	CStartupAdaptationWrapper::DeleteLastCommandData();

   642 	__UHEAP_MARKEND;

   643 	

   644 	INFO_PRINTF1(_L("Returning from doTestRtcAdaptationL()"));

   645 	}

   646 

   647 /**

   648 Old Test CaseID 		AFSS-CLAYER-0015

   649 New Test CaseID 		DEVSRVS-SSREFPLUGINS-CLAYER-0012

   650  */

   651 

   652 void CCLayerTestStartupAdaptationAdapter::doTestEmergencyCallRfAdaptationL()

   653 	{

   654 	__UHEAP_MARK;

   655 	INFO_PRINTF1(_L("Enterting doTestEmergencyCallRfAdaptationL()"));

   656 	

   657 	INFO_PRINTF1(_L("Creating emergency call rf adaptation"));

   658 	MEmergencyCallRfAdaptation* ecrfAdaptation = CStartupAdaptationAdapter::NewEmergencyCallRfAdaptationL();

   659 	TEST(ecrfAdaptation != NULL);

   660 	if(ecrfAdaptation == NULL)

   661 		{

   662 		INFO_PRINTF1(_L("Failed to create emergency call rf adaptation"));

   663 		return;

   664 		}

   665 		

   666 	CRequestWaiter* request = new (ELeave) CRequestWaiter();

   667 	CleanupStack::PushL(request);

   668 	

   669 	INFO_PRINTF1(_L("Test emergency RF activation success"));

   670 	StartupAdaptation::TResponsePckg responsePckg;

   671 	ecrfAdaptation->ActivateRfForEmergencyCall(request->iStatus);

   672 	TEST(request->iStatus == KRequestPending);

   673 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EActivateRfForEmergencyCall);

   674 	responsePckg() = KErrNone;

   675 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EActivateRfForEmergencyCall, responsePckg);

   676 	request->StartWait();

   677 	TEST(request->iStatus == KErrNone);

   678 	

   679 	INFO_PRINTF1(_L("Test emergency RF activation failure"));

   680 	ecrfAdaptation->ActivateRfForEmergencyCall(request->iStatus);

   681 	TEST(request->iStatus == KRequestPending);

   682 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EActivateRfForEmergencyCall);

   683 	responsePckg() = KErrGeneral;

   684 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EActivateRfForEmergencyCall, responsePckg);

   685 	request->StartWait();

   686 	TEST(request->iStatus == KErrGeneral);

   687 	

   688 	INFO_PRINTF1(_L("Test emergency RF deactivation success"));

   689 	ecrfAdaptation->DeactivateRfForEmergencyCall(request->iStatus);

   690 	TEST(request->iStatus == KRequestPending);

   691 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EDeactivateRfAfterEmergencyCall);

   692 	responsePckg() = KErrNone;

   693 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EDeactivateRfAfterEmergencyCall, responsePckg);

   694 	request->StartWait();

   695 	TEST(request->iStatus == KErrNone);

   696 	

   697 	INFO_PRINTF1(_L("Test emergency RF deactivation failure"));

   698 	ecrfAdaptation->DeactivateRfForEmergencyCall(request->iStatus);

   699 	TEST(request->iStatus == KRequestPending);

   700 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EDeactivateRfAfterEmergencyCall);

   701 	responsePckg() = KErrGeneral;

   702 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EDeactivateRfAfterEmergencyCall, responsePckg);

   703 	request->StartWait();

   704 	TEST(request->iStatus == KErrGeneral);

   705 	

   706 	INFO_PRINTF1(_L("Test emergency RF activation cancel"));

   707 	ecrfAdaptation->ActivateRfForEmergencyCall(request->iStatus);

   708 	TEST(request->iStatus == KRequestPending);

   709 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EActivateRfForEmergencyCall);

   710 	ecrfAdaptation->Cancel();

   711 	request->StartWait();

   712 	TEST(request->iStatus == KErrCancel);

   713 		

   714 		

   715 	INFO_PRINTF1(_L("Releasing emergency call rf adaptation"));

   716 	ecrfAdaptation->Release();

   717 	ecrfAdaptation = NULL;

   718 

   719 	CleanupStack::PopAndDestroy(request);

   720 	

   721 	INFO_PRINTF1(_L("Heap check macro end"));

   722 	// Delete the test data buffer

   723 	CStartupAdaptationWrapper::DeleteLastCommandData();

   724 	__UHEAP_MARKEND;

   725 		

   726 	INFO_PRINTF1(_L("Returning from doTestEmergencyCallRfAdaptationL()"));

   727 	}

   728 

   729 /**

   730 Old Test CaseID 		AFSS-CLAYER-0016

   731 New Test CaseID 		DEVSRVS-SSREFPLUGINS-CLAYER-0012

   732  */

   733 

   734 

   735 void CCLayerTestStartupAdaptationAdapter::doTestMiscAdaptationL()

   736 	{

   737 	__UHEAP_MARK;

   738 	INFO_PRINTF1(_L("Enterting doTestMiscAdaptationL()"));

   739 

   740 	INFO_PRINTF1(_L("Creating misc. adaptation"));

   741 	MMiscAdaptation* miscAdaptation = CStartupAdaptationAdapter::NewMiscAdaptationL();

   742 	TEST(miscAdaptation != NULL);

   743 	if(miscAdaptation == NULL)

   744 		{

   745 		INFO_PRINTF1(_L("Failed to create misc. adaptation"));

   746 		return;

   747 		}

   748 	

   749 

   750 	CRequestWaiter* request = new (ELeave) CRequestWaiter();

   751 	CleanupStack::PushL(request);

   752 	

   753 	INFO_PRINTF1(_L("Testing get global startup mode success"));

   754 	TPckgBuf<TInt> startupModePckg;

   755 	StartupAdaptation::TGlobalStartupModeResponsePckg startupModeResponsePckg; 

   756 	miscAdaptation->GetGlobalStartupMode(startupModePckg, request->iStatus);

   757 	TEST(request->iStatus == KRequestPending);

   758 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EGetGlobalStartupMode);

   759 	startupModeResponsePckg().iErrorCode = KErrNone;

   760 	startupModeResponsePckg().iValue = StartupAdaptation::EAlarm;

   761 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EGetGlobalStartupMode, startupModeResponsePckg);

   762 	request->StartWait();

   763 	TEST(request->iStatus == KErrNone);

   764 	TEST(startupModePckg() == StartupAdaptation::EAlarm);

   765 	

   766 	INFO_PRINTF1(_L("Testing get global startup mode failure"));

   767 	miscAdaptation->GetGlobalStartupMode(startupModePckg, request->iStatus);

   768 	TEST(request->iStatus == KRequestPending);

   769 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EGetGlobalStartupMode);

   770 	startupModeResponsePckg().iErrorCode = KErrGeneral;

   771 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EGetGlobalStartupMode, startupModeResponsePckg);

   772 	request->StartWait();

   773 	TEST(request->iStatus == KErrGeneral);

   774 	

   775 	INFO_PRINTF1(_L("Testing get global startup mode cancel"));

   776 	miscAdaptation->GetGlobalStartupMode(startupModePckg, request->iStatus);

   777 	TEST(request->iStatus == KRequestPending);

   778 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EGetGlobalStartupMode);

   779 	miscAdaptation->Cancel();

   780 	request->StartWait();

   781 	TEST(request->iStatus == KErrCancel);

   782 		

   783 	INFO_PRINTF1(_L("Testing get hidden reset success"));

   784 	TPckgBuf <TBool> hiddenResetPckg;

   785 	StartupAdaptation::TBooleanResponsePckg hiddenResetResponsePckg; 

   786 	miscAdaptation->GetHiddenReset(hiddenResetPckg, request->iStatus);

   787 	TEST(request->iStatus == KRequestPending);

   788 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EGetHiddenReset);

   789 	hiddenResetResponsePckg().iErrorCode = KErrNone;

   790 	hiddenResetResponsePckg().iValue = ETrue;

   791 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EGetHiddenReset, hiddenResetResponsePckg);

   792 	request->StartWait();

   793 	TInt expectedErr = KErrNone;

   794 	TEST(request->iStatus == expectedErr);

   795 	INFO_PRINTF3(_L("Get hidden reset success status : %d Expected Status : %d"), request->iStatus.Int(), expectedErr);

   796 	TEST(hiddenResetPckg() == 1);

   797 	INFO_PRINTF2(_L("Get hidden reset package : %d"), hiddenResetPckg());

   798 	

   799 	INFO_PRINTF1(_L("Testing get hidden reset failure"));

   800 	miscAdaptation->GetHiddenReset(hiddenResetPckg, request->iStatus);

   801 	TEST(request->iStatus == KRequestPending);

   802 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EGetHiddenReset);

   803 	hiddenResetResponsePckg().iErrorCode = KErrGeneral;

   804 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EGetHiddenReset, hiddenResetResponsePckg);

   805 	request->StartWait();

   806 	expectedErr = KErrGeneral;

   807 	TEST(request->iStatus == expectedErr);

   808 	INFO_PRINTF3(_L("Get hidden reset failure status : %d Expected Status : %d"), request->iStatus.Int(), expectedErr);

   809 	

   810 	INFO_PRINTF1(_L("Testing get hidden reset cancel"));

   811 	miscAdaptation->GetHiddenReset(hiddenResetPckg, request->iStatus);

   812 	TEST(request->iStatus == KRequestPending);

   813 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EGetHiddenReset);

   814 	miscAdaptation->Cancel();

   815 	request->StartWait();

   816 	expectedErr = KErrCancel;

   817 	TEST(request->iStatus == expectedErr);

   818 	INFO_PRINTF3(_L("Get hidden reset cancel status : %d Expected Status : %d"), request->iStatus.Int(), expectedErr);

   819 	

   820 	INFO_PRINTF1(_L("Testing security state change success, EAskPIN"));

   821 	TPckgBuf<TInt> clientResponsePckg;

   822 	StartupAdaptation::TSecurityStateResponsePckg adaptationResponsePckg;

   823 	StartupAdaptation::TSecurityStateChangePckg statePckg;

   824 	miscAdaptation->SecurityStateChange(StartupAdaptation::EAskPIN, clientResponsePckg, request->iStatus);

   825 	TEST(request->iStatus == KRequestPending);

   826 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::ESecurityStateChange);

   827 	statePckg.Copy(*CStartupAdaptationWrapper::LastCommandData());

   828 	TEST(statePckg() == StartupAdaptation::EAskPIN);

   829 	adaptationResponsePckg().iErrorCode = KErrNone;

   830 	adaptationResponsePckg().iValue = StartupAdaptation::ENoValue;

   831 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::ESecurityStateChange, adaptationResponsePckg);

   832 	request->StartWait();

   833 	TEST(request->iStatus == KErrNone);

   834 	TEST(clientResponsePckg() == adaptationResponsePckg().iValue);

   835 	

   836 	INFO_PRINTF1(_L("Testing security state change success, ESIMRejected"));

   837 	miscAdaptation->SecurityStateChange(StartupAdaptation::ESIMRejected, clientResponsePckg, request->iStatus);

   838 	TEST(request->iStatus == KRequestPending);

   839 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::ESecurityStateChange);

   840 	statePckg.Copy(*CStartupAdaptationWrapper::LastCommandData());

   841 	TEST(statePckg() == StartupAdaptation::ESIMRejected);

   842 	adaptationResponsePckg().iErrorCode = KErrNone;

   843 	adaptationResponsePckg().iValue = StartupAdaptation::EYes;

   844 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::ESecurityStateChange, adaptationResponsePckg);

   845 	request->StartWait();

   846 	TEST(request->iStatus == KErrNone);

   847 	TEST(clientResponsePckg() == adaptationResponsePckg().iValue);

   848 	

   849 	INFO_PRINTF1(_L("Testing security state change failure"));

   850 	miscAdaptation->SecurityStateChange(StartupAdaptation::ESIMBlocked, clientResponsePckg, request->iStatus);

   851 	TEST(request->iStatus == KRequestPending);

   852 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::ESecurityStateChange);

   853 	statePckg.Copy(*CStartupAdaptationWrapper::LastCommandData());

   854 	TEST(statePckg() == StartupAdaptation::ESIMBlocked);

   855 	adaptationResponsePckg().iErrorCode = KErrGeneral;

   856 	adaptationResponsePckg().iValue = StartupAdaptation::ENo;

   857 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::ESecurityStateChange, adaptationResponsePckg);

   858 	request->StartWait();

   859 	TEST(request->iStatus == KErrGeneral);

   860 	

   861 	INFO_PRINTF1(_L("Testing security state change cancel"));	

   862 	miscAdaptation->SecurityStateChange(StartupAdaptation::ESIMLock, clientResponsePckg, request->iStatus);

   863 	TEST(request->iStatus == KRequestPending);

   864 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::ESecurityStateChange);

   865 	statePckg.Copy(*CStartupAdaptationWrapper::LastCommandData());

   866 	TEST(statePckg() == StartupAdaptation::ESIMLock);

   867 	miscAdaptation->Cancel();

   868 	request->StartWait();

   869 	TEST(request->iStatus == KErrCancel);

   870 		

   871 		

   872 	INFO_PRINTF1(_L("Testing prepare and get SIM languages success, size 2"));

   873 	TPckgBuf<TInt> sizePckg;

   874 	StartupAdaptation::TLanguageListPriorityPckg languagePriorityPckg;

   875 	StartupAdaptation::RLanguageListResponse languageListResponse; 

   876 	StartupAdaptation::TLanguageListResponsePckg languageResponsePckg(languageListResponse);

   877 	miscAdaptation->PrepareSimLanguages(EPrimaryLanguages, sizePckg, request->iStatus);

   878 	TEST(request->iStatus == KRequestPending);

   879 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EGetSIMLanguages);

   880 	languagePriorityPckg.Copy(*CStartupAdaptationWrapper::LastCommandData());

   881 	TEST(languagePriorityPckg() == StartupAdaptation::EPrimaryLanguages);

   882 	languageListResponse.iErrorCode = KErrNone;

   883 	languageListResponse.iLanguages.AppendL(StartupAdaptation::EPrefLangEnglish);

   884 	languageListResponse.iLanguages.AppendL(StartupAdaptation::EPrefLangFinnish);

   885 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EGetSIMLanguages, languageResponsePckg);

   886 	request->StartWait();

   887 	TEST(request->iStatus == KErrNone);

   888 	TEST(sizePckg() == 2);

   889 	

   890 	//Getting the Sim Languages using the flat storage dynamic buffer

   891 	CBufFlat* writeBuffer=CBufFlat::NewL(2);

   892 	CleanupStack::PushL(writeBuffer);

   893 	writeBuffer->ExpandL(0,2 * sizeof(TInt32));

   894 	TRAPD(res,miscAdaptation->GetSimLanguagesL(writeBuffer, 2));

   895 	TEST(res == KErrNone);

   896 	

   897 	//Reading the languages using the read stream from the buffer

   898 	RBufReadStream readBuffer;

   899 	readBuffer.Open(*writeBuffer,0);

   900 	CleanupClosePushL(readBuffer);

   901 	TInt32 language = readBuffer.ReadInt32L();

   902 	TEST(language == StartupAdaptation::EPrefLangEnglish);

   903 	language = readBuffer.ReadInt32L();

   904 	TEST(language == StartupAdaptation::EPrefLangFinnish);

   905 	

   906 	//Reset the write Buffer

   907 	writeBuffer->Reset();

   908 	

   909 	INFO_PRINTF1(_L("Testing prepare and get SIM languages success, size 1"));

   910 	miscAdaptation->PrepareSimLanguages(EPrimaryLanguages, sizePckg, request->iStatus);

   911 	TEST(request->iStatus == KRequestPending);

   912 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EGetSIMLanguages);

   913 	languagePriorityPckg.Copy(*CStartupAdaptationWrapper::LastCommandData());

   914 	TEST(languagePriorityPckg() == StartupAdaptation::EPrimaryLanguages);

   915 	languageListResponse.iErrorCode = KErrNone;

   916 	languageListResponse.iLanguages.Remove(1); // Remove EPrefLangFinnish

   917 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EGetSIMLanguages, languageResponsePckg);

   918 	request->StartWait();

   919 	TEST(request->iStatus == KErrNone);

   920 	TEST(sizePckg() == 1);

   921 

   922 	//Getting the Sim Languages using the flat storage dynamic buffer

   923 	writeBuffer->ResizeL(sizeof(TInt32));

   924 	TRAP(res,miscAdaptation->GetSimLanguagesL(writeBuffer, 1));

   925 	TEST(res == KErrNone);

   926 		

   927 	//Reading the languages using the read stream from the buffer

   928 	readBuffer.Open(*writeBuffer,0);

   929 	language = readBuffer.ReadInt32L();

   930 	TEST(language == StartupAdaptation::EPrefLangEnglish);

   931 	

   932 	INFO_PRINTF1(_L("Testing get SIM languages failure, prepared sim languages count 1, size 0"));

   933 	miscAdaptation->PrepareSimLanguages(EPrimaryLanguages, sizePckg, request->iStatus);

   934 	TEST(request->iStatus == KRequestPending);

   935 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EGetSIMLanguages);

   936 	languagePriorityPckg.Copy(*CStartupAdaptationWrapper::LastCommandData());

   937 	TEST(languagePriorityPckg() == StartupAdaptation::EPrimaryLanguages);

   938 	languageListResponse.iErrorCode = KErrNone;

   939 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EGetSIMLanguages, languageResponsePckg);

   940 	request->StartWait();

   941 	TEST(request->iStatus == KErrNone);

   942 	TEST(sizePckg() == 1);

   943 

   944 	writeBuffer->ResizeL(0);

   945 	TRAP(res,miscAdaptation->GetSimLanguagesL(writeBuffer, 0));

   946 	TEST(res == KErrArgument);

   947 		

   948 	INFO_PRINTF1(_L("Testing prepare and get SIM languages success, size 0"));

   949 	miscAdaptation->PrepareSimLanguages(EPrimaryLanguages, sizePckg, request->iStatus);

   950 	TEST(request->iStatus == KRequestPending);

   951 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EGetSIMLanguages);

   952 	languagePriorityPckg.Copy(*CStartupAdaptationWrapper::LastCommandData());

   953 	TEST(languagePriorityPckg() == StartupAdaptation::EPrimaryLanguages);

   954 	languageListResponse.iErrorCode = KErrNone;

   955 	languageListResponse.iLanguages.Remove(0); // Remove EPrefLangEnglish from the array

   956 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EGetSIMLanguages, languageResponsePckg);

   957 	request->StartWait();

   958 	TEST(request->iStatus == KErrNone);

   959 	TEST(sizePckg() == 0);

   960 

   961 	//Getting the Sim Languages using the flat storage dynamic buffer

   962 	TRAP(res,miscAdaptation->GetSimLanguagesL(writeBuffer, 0));

   963 	TEST(res == KErrNone);

   964 

   965 	INFO_PRINTF1(_L("Testing prepare twice and get SIM languages success, size 0"));

   966 	miscAdaptation->PrepareSimLanguages(EPrimaryLanguages, sizePckg, request->iStatus);

   967 	TEST(request->iStatus == KRequestPending);

   968 	request->SetActive();

   969 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EGetSIMLanguages);

   970 	languagePriorityPckg.Copy(*CStartupAdaptationWrapper::LastCommandData());

   971 	TEST(languagePriorityPckg() == StartupAdaptation::EPrimaryLanguages);

   972 	//Try preparing the list again while outstanding request

   973 	CRequestWaiter* request2 = new (ELeave) CRequestWaiter();

   974 	CleanupStack::PushL(request2);

   975 	miscAdaptation->PrepareSimLanguages(EPrimaryLanguages, sizePckg, request2->iStatus);

   976 	request2->StartWait();

   977 	TEST(request2->iStatus == KErrInUse);

   978 	languageListResponse.iErrorCode = KErrNone;

   979 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EGetSIMLanguages, languageResponsePckg);

   980 	request->StartWait();

   981 	TEST(request->iStatus == KErrNone);

   982 	TEST(sizePckg() == 0);

   983 	

   984 	//Getting the Sim Languages using the flat storage dynamic buffer

   985 	TRAP(res,miscAdaptation->GetSimLanguagesL(writeBuffer, 0));

   986 	TEST(res == KErrNone);

   987 

   988 	INFO_PRINTF1(_L("Testing prepare get SIM languages failure"));

   989 	miscAdaptation->PrepareSimLanguages(EPrimaryLanguages, sizePckg, request->iStatus);

   990 	TEST(request->iStatus == KRequestPending);

   991 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EGetSIMLanguages);

   992 	languagePriorityPckg.Copy(*CStartupAdaptationWrapper::LastCommandData());

   993 	TEST(languagePriorityPckg() == StartupAdaptation::EPrimaryLanguages);

   994 	languageListResponse.iErrorCode = KErrGeneral;

   995 	CStartupAdaptationWrapper::TriggerResponseCallbackL(StartupAdaptation::EGetSIMLanguages, languageResponsePckg);

   996 	request->StartWait();

   997 	TEST(request->iStatus == KErrGeneral);

   998 	

   999 	INFO_PRINTF1(_L("Testing prepare SIM lanuages and then cancel"));

  1000 	miscAdaptation->PrepareSimLanguages(EPrimaryLanguages, sizePckg, request->iStatus);

  1001 	TEST(request->iStatus == KRequestPending);

  1002 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EGetSIMLanguages);

  1003 	languagePriorityPckg.Copy(*CStartupAdaptationWrapper::LastCommandData());

  1004 	TEST(languagePriorityPckg() == StartupAdaptation::EPrimaryLanguages);

  1005 	languageListResponse.iErrorCode = KErrNone;

  1006 	// Try to cancel

  1007 	miscAdaptation->Cancel();

  1008 	request->StartWait();

  1009 	TEST(request->iStatus == KErrCancel);	

  1010 	

  1011 	INFO_PRINTF1(_L("Releasing misc. adaptation"));

  1012 	miscAdaptation->Release();

  1013 	miscAdaptation = NULL;

  1014 	

  1015 	CleanupStack::PopAndDestroy(request2);

  1016 	CleanupStack::PopAndDestroy(3); //readBuffer, writeBuffer, request

  1017 	

  1018 	INFO_PRINTF1(_L("Heap check macro end"));

  1019 	// Delete the test data buffer

  1020 	CStartupAdaptationWrapper::DeleteLastCommandData();

  1021 	// Close the adaptation wrapper language array

  1022 	languageListResponse.Close();

  1023 	__UHEAP_MARKEND;

  1024 		

  1025 	INFO_PRINTF1(_L("Returning from doTestMiscAdaptationL()"));

  1026 	}

  1027 

  1028 /**

  1029 Old Test CaseID 		AFSS-CLAYER-0017

  1030 New Test CaseID 		DEVSRVS-SSREFPLUGINS-CLAYER-0012

  1031  */

  1032 

  1033 void CCLayerTestStartupAdaptationAdapter::doTestConcurrentRequestsL()

  1034 	{

  1035 	__UHEAP_MARK;

  1036 	INFO_PRINTF1(_L("Enterting doTestConcurrentRequestsL()"));

  1037 	

  1038 	INFO_PRINTF1(_L("Setting up adaptation classes"));

  1039 	

  1040 	INFO_PRINTF1(_L("Creating state adaptation"));

  1041 	MStateAdaptation* stateAdaptation = CStartupAdaptationAdapter::NewStateAdaptationL();

  1042 	TEST(stateAdaptation != NULL);

  1043 	if(stateAdaptation == NULL)

  1044 		{

  1045 		INFO_PRINTF1(_L("Failed to create state adaptation"));

  1046 		return;

  1047 		}

  1048 	

  1049 	INFO_PRINTF1(_L("Creating SIM adaptation"));

  1050 	MSimAdaptation* simAdaptation = CStartupAdaptationAdapter::NewSimAdaptationL();

  1051 	TEST(simAdaptation != NULL);

  1052 	if(simAdaptation == NULL)

  1053 		{

  1054 		INFO_PRINTF1(_L("Failed to create SIM adaptation"));

  1055 		return;

  1056 		}

  1057 	

  1058 	INFO_PRINTF1(_L("Creating RTC adaptation"));

  1059 	MRtcAdaptation* rtcAdaptation = CStartupAdaptationAdapter::NewRtcAdaptationL();

  1060 	TEST(rtcAdaptation != NULL);

  1061 	if(rtcAdaptation == NULL)

  1062 		{

  1063 		INFO_PRINTF1(_L("Failed to create RTC adaptation"));

  1064 		return;

  1065 		}

  1066 	

  1067 	INFO_PRINTF1(_L("Creating emergency call rf adaptation"));

  1068 	MEmergencyCallRfAdaptation* ecrfAdaptation = CStartupAdaptationAdapter::NewEmergencyCallRfAdaptationL();

  1069 	TEST(ecrfAdaptation != NULL);

  1070 	if(ecrfAdaptation == NULL)

  1071 		{

  1072 		INFO_PRINTF1(_L("Failed to create emergency call rf adaptation"));

  1073 		return;

  1074 		}

  1075 		

  1076 	INFO_PRINTF1(_L("Creating misc. adaptation"));

  1077 	MMiscAdaptation* miscAdaptation = CStartupAdaptationAdapter::NewMiscAdaptationL();

  1078 	TEST(miscAdaptation != NULL);

  1079 	if(miscAdaptation == NULL)

  1080 		{

  1081 		INFO_PRINTF1(_L("Failed to create misc. adaptation"));

  1082 		return;

  1083 		}

  1084 	

  1085 	INFO_PRINTF1(_L("End of set up of adaptation classes"));

  1086 	

  1087 	INFO_PRINTF1(_L("Starting concurrency tests"));

  1088 	

  1089 	INFO_PRINTF1(_L("Testing queued requests"));

  1090 	INFO_PRINTF1(_L("Testing non-queued self test"));

  1091 	CRequestWaiter* stateRequest = new (ELeave) CRequestWaiter();

  1092 	CleanupStack::PushL(stateRequest);

  1093 	stateAdaptation->RequestCoopSysSelfTest(stateRequest->iStatus);

  1094 	TEST(stateRequest->iStatus == KRequestPending);

  1095 	stateRequest->SetActive();

  1096 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EExecuteSelftests);

  1097 	

  1098 	INFO_PRINTF1(_L("Testing queueing unset wakeup alarm"));

  1099 	CRequestWaiter* rtcRequest = new (ELeave) CRequestWaiter();

  1100 	CleanupStack::PushL(rtcRequest);

  1101 	rtcAdaptation->UnsetWakeupAlarm(rtcRequest->iStatus);

  1102 	TEST(rtcRequest->iStatus == KRequestPending);

  1103 	rtcRequest->SetActive();

  1104 	TEST(CStartupAdaptationWrapper::LastCommandId() == StartupAdaptation::EExecuteSelftests);

  1105 	

  1106 	CRequestWaiter* busyRequest = new (ELeave) CRequestWaiter();

  1107 	CleanupStack::PushL(busyRequest);

  1108 		

  1109 	INFO_PRINTF1(_L("Testing busy response on state adaptation APIs"));

  1110 	stateAdaptation->RequestCoopSysPerformRestartActions(0, busyRequest->iStatus);

  1111 	busyRequest->StartWait();

  1112 	TEST(busyRequest->iStatus == KErrInUse);

  1113 	

  1114 	stateAdaptation->RequestCoopSysPerformRfsActions(ESsmShallowRfs, busyRequest->iStatus);

  1115 	busyRequest->StartWait();

  1116 	TEST(busyRequest->iStatus == KErrInUse);

  1117 	

  1118 	stateAdaptation->RequestCoopSysSelfTest(busyRequest->iStatus);

  1119 	busyRequest->StartWait();

  1120 	TEST(busyRequest->iStatus == KErrInUse);

  1121 	

  1122 	stateAdaptation->RequestCoopSysPerformShutdownActions(0, busyRequest->iStatus);

  1123 	busyRequest->StartWait();

  1124 	TEST(busyRequest->iStatus == KErrInUse);

  1125 	

  1126 	TSsmState state;

  1127 	stateAdaptation->RequestCoopSysStateChange(state, busyRequest->iStatus);

  1128 	busyRequest->StartWait();

  1129 	TEST(busyRequest->iStatus == KErrInUse);

  1130 	

  1131 	INFO_PRINTF1(_L("Testing cancelling dispatched request with queue"));

  1132 	stateAdaptation->RequestCancel();

  1133 	stateRequest->StartWait();

  1134 	TEST(stateRequest->iStatus == KErrCancel);