// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code  

*/

#include <ssm/ssmstates.hrh>

#include <ssm/ssmsubstates.hrh>

#include <ssm/ssmstatemanager.h>

#include <ssm/startupadaptation.h>

#include <ssm/startupadaptationcommands.h>

#include <ssm/startupadaptationevents.h>

// Include the header file for the class under test

#include "saastateadaptation.h"

#include "saartcadaptation.h"

#include "saasimadaptation.h"

#include "saaemergencycallrfadaptation.h"

#include "saamiscadaptation.h"

#include "startupadaptationadapter.h"

#include "ssmclayer.h"

#include "ssmdebug.h"

#include "tclayer_step_startupadaptationadapter.h"

//Include the test wrappers

#include "startupadaptationwrapper.h"

#include <s32mem.h>

/**

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

 * 

 * @internalComponent

 * @test

 */

class CRequestWaiter : public CActive

	{

public:

	/**

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

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

	 */

	void StartWait()

		{

		if(!IsActive())

			{

			SetActive();

			}

		CActiveScheduler::Start();

		}

	// Make iStatus public for ease of use.

	using CActive::iStatus;

	// Make SetActive public for ease of use

	void SetActive()

		{

		CActive::SetActive();

		}

	CRequestWaiter() : CActive(EPriorityNormal)

		{

		CActiveScheduler::Add(this);

		}

protected:

	// From CActive

	void RunL()

		{

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

		CActiveScheduler::Stop();

		}

	TInt RunError(TInt aError)

		{

		return aError;

		}

	void DoCancel()

		{

		// Do nothing

		}

	};

/**

 * Constructs a complete CCLayerTestStartupAdaptationAdapter object

 * @internalComponent

 */

CCLayerTestStartupAdaptationAdapter::CCLayerTestStartupAdaptationAdapter()

	{

	}

/**

 * Releases any resources associated with this test

 * @internalComponent

 */

CCLayerTestStartupAdaptationAdapter::~CCLayerTestStartupAdaptationAdapter()

	{

	}

/**

 * Test step preamble

 * @internalComponent

 */

TVerdict CCLayerTestStartupAdaptationAdapter::doTestStepPreambleL()

	{

	return CTestStep::doTestStepPreambleL();

	}

/**

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

 * 

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

 * 

 * @internalComponent

 */

TVerdict CCLayerTestStartupAdaptationAdapter::doTestStepL()

	{

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

	__UHEAP_MARK;

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

	CleanupStack::PushL(as);

	CActiveScheduler::Install(as);

	TRAPD(err, doTestOnDemandL());

	TEST(err == KErrNone);

	TRAP(err, doTestStateAdaptationL());

	TEST(err == KErrNone);

	TRAP(err, doTestSimAdaptationL());

	TEST(err == KErrNone);

	TRAP(err, doTestRtcAdaptationL());

	TEST(err == KErrNone);

	TRAP(err, doTestEmergencyCallRfAdaptationL());

	TEST(err == KErrNone);

	TRAP(err, doTestMiscAdaptationL());

	TEST(err == KErrNone);

	TRAP(err, doTestConcurrentRequestsL());

	TEST(err == KErrNone);

	TRAP(err, doTestMultipleRequestsL());

	TEST(err == KErrNone);	

	TRAP(err, doTestCreationAndDestructionL());

	TEST(err == KErrNone);	

	CleanupStack::PopAndDestroy(as);

	__UHEAP_MARKEND;

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

	return TestStepResult();

	}

/**

 * Test step postamble

 * @internalComponent

 */

TVerdict CCLayerTestStartupAdaptationAdapter::doTestStepPostambleL()

	{

	return CTestStep::doTestStepPostambleL();

	}

/**

Old Test CaseID 		AFSS-CLAYER-0012

New Test CaseID 		DEVSRVS-SSREFPLUGINS-CLAYER-0012

 */		

void CCLayerTestStartupAdaptationAdapter::doTestStateAdaptationL()

	{

	__UHEAP_MARK;

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

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

	MStateAdaptation* stateAdaptation = CStartupAdaptationAdapter::NewStateAdaptationL();

	TEST(stateAdaptation != NULL);

	if(stateAdaptation == NULL)

		{

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

		return;

		}

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

	CleanupStack::PushL(request);

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

	doTestStateChangeMappingsL(stateAdaptation);

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

	stateAdaptation->RequestCoopSysSelfTest(request->iStatus);

	StartupAdaptation::TResponsePckg okResponse(KErrNone); 

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

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

	request->StartWait();

	TEST(request->iStatus == KErrNone);

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

	stateAdaptation->RequestCoopSysSelfTest(request->iStatus);

	StartupAdaptation::TResponsePckg failResponse(KErrGeneral); 

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

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

	request->StartWait();

	TEST(request->iStatus == KErrGeneral);

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

	stateAdaptation->RequestCoopSysSelfTest(request->iStatus); 

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

	TEST(request->iStatus == KRequestPending);

	stateAdaptation->RequestCancel();

	request->StartWait();

	TEST(request->iStatus == KErrCancel);

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

	TInt reason = 0;

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

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

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

	request->StartWait();

	TEST(request->iStatus == KErrNone);

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

	reason = 0;

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

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

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

	request->StartWait();

	TEST(request->iStatus == KErrGeneral);

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

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

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

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

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

	request->StartWait();

	TEST(request->iStatus == KErrNone);

	TPckgBuf<StartupAdaptation::TRFSReason> rfsReasonBuf;

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

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

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

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

	TEST(request->iStatus == KRequestPending);

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

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

	request->StartWait();

	TEST(request->iStatus == KErrGeneral);

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

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

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

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

	TEST(request->iStatus == KRequestPending);

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

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

	request->StartWait();

	TEST(request->iStatus == KErrNone);

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

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

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

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

	TEST(request->iStatus == KRequestPending);

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

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

	request->StartWait();

	TEST(request->iStatus == KErrGeneral);

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

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

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

	reason = StartupAdaptation::ELanguageSwitchReset;

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

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

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

	request->StartWait();

	TEST(request->iStatus == KErrNone);

	TPckgBuf<StartupAdaptation::TResetReason> restartReasonBuf;

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

	TEST(restartReasonBuf() == reason);

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

	reason = StartupAdaptation::ELanguageSwitchReset;

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

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

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

	request->StartWait();

	TEST(request->iStatus == KErrGeneral);

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

	TEST(restartReasonBuf() == reason);

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

	reason = StartupAdaptation::ESIMStatusChangeReset;

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

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

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

	request->StartWait();

	TEST(request->iStatus == KErrNone);

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

	TEST(restartReasonBuf() == reason);

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

	TPckgBuf<TSsmCoopSysEventType> eventBuf;

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

	TEST(request->iStatus == KRequestPending);

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

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

	TEST(request->iStatus == KErrNone);

	TEST(eventBuf() == ESsmFatalCoopSysError);

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

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

	TEST(request->iStatus == KRequestPending);

    fatalErrorPckg() = StartupAdaptation::ESimRemoved;

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

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

	TEST(request->iStatus == KRequestPending);

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

	stateAdaptation->NotifyCancel();

	request->StartWait();

	TEST(request->iStatus == KErrCancel);

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

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

	TEST(request->iStatus == KRequestPending);

	TBuf8<1> emptyBuf;

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

	request->StartWait();

	TEST(request->iStatus == KErrNone);

	TEST(eventBuf() == ESsmShutdownDevice);

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

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

	TEST(request->iStatus == KRequestPending);

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

	request->StartWait();

	TEST(request->iStatus == KErrNone);

	TEST(eventBuf() == ESsmRestartDevice);

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

	stateAdaptation->Release();

	stateAdaptation = NULL;

	CleanupStack::PopAndDestroy(request);

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

	// Delete the test data buffer

	CStartupAdaptationWrapper::DeleteLastCommandData();

	__UHEAP_MARKEND;

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

	}

/**

Old Test CaseID 		AFSS-CLAYER-0013

New Test CaseID 		DEVSRVS-SSREFPLUGINS-CLAYER-0012

 */		

void CCLayerTestStartupAdaptationAdapter::doTestSimAdaptationL()

	{

	__UHEAP_MARK;

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

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

	MSimAdaptation* simAdaptation = CStartupAdaptationAdapter::NewSimAdaptationL();

	TEST(simAdaptation != NULL);

	if(simAdaptation == NULL)

		{

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

		return;

		}

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

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

	CleanupStack::PushL(request);

	TPckgBuf<TBool> boolPckg;

	StartupAdaptation::TBooleanResponsePckg booleanResponsePckg;

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

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

	TEST(request->iStatus == KRequestPending);

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

	booleanResponsePckg().iErrorCode = KErrNone;

	booleanResponsePckg().iValue = ETrue;

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

	request->StartWait();

	TEST(request->iStatus == KErrNone);

	TEST(boolPckg());

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

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

	TEST(request->iStatus == KRequestPending);

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

	booleanResponsePckg().iErrorCode = KErrNone;

	booleanResponsePckg().iValue = EFalse;

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

	request->StartWait();

	TEST(request->iStatus == KErrNone);

	TEST(!boolPckg());

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

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

	TEST(request->iStatus == KRequestPending);

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

	booleanResponsePckg().iErrorCode = KErrGeneral;

	booleanResponsePckg().iValue = ETrue;

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

	request->StartWait();

	TEST(request->iStatus == KErrGeneral);

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

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

	TEST(request->iStatus == KRequestPending);

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

	// Cancel instead of responding

	simAdaptation->GetCancel();

	request->StartWait();

	TEST(request->iStatus == KErrCancel);

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

	TPckgBuf<TSsmSimEventType> simEventPckg;

	StartupAdaptation::TFatalErrorTypePckg fatalErrorTypePckg;

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

	request->StartWait();

	TEST(request->iStatus == KErrNone);

	TEST(simEventPckg() == ESsmSimRemoved);

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

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

	TEST(request->iStatus == KRequestPending);

	fatalErrorTypePckg() = StartupAdaptation::ESimRemoved;

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

	request->StartWait();

	TEST(request->iStatus == KErrNone);

	TEST(simEventPckg() == ESsmSimRemoved);

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

	StartupAdaptation::TSimEventTypePckg simEventTypePckg;

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

	TEST(request->iStatus == KRequestPending);

	simEventTypePckg() = StartupAdaptation::ESimUsable;

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

	request->StartWait();

	TEST(request->iStatus == KErrNone);

	TEST(simEventPckg() == ESsmSimUsable);

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

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

	TEST(request->iStatus == KRequestPending);

	simEventTypePckg() = StartupAdaptation::ESimNotReady;

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

	request->StartWait();

	TEST(request->iStatus == KErrNone);

	TEST(simEventPckg() == ESsmSimNotReady);

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

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

	TEST(request->iStatus == KRequestPending);

	simEventTypePckg() = StartupAdaptation::ESimReadable;

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

	request->StartWait();

	TEST(request->iStatus == KErrNone);

	TEST(simEventPckg() == ESsmSimReadable);

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

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

	TEST(request->iStatus == KRequestPending);

	fatalErrorTypePckg() = StartupAdaptation::EUnclassifiedError;

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

	TEST(request->iStatus == KRequestPending);

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

	simAdaptation->NotifyCancel();

	request->StartWait();

	TEST(request->iStatus == KErrCancel);

	CleanupStack::PopAndDestroy(request);

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

	simAdaptation->Release();

	simAdaptation = NULL;

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

	// Delete the test data buffer

	CStartupAdaptationWrapper::DeleteLastCommandData();

	__UHEAP_MARKEND;

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

	}

/**

Old Test CaseID 		AFSS-CLAYER-0014

New Test CaseID 		DEVSRVS-SSREFPLUGINS-CLAYER-0012

 */

void CCLayerTestStartupAdaptationAdapter::doTestRtcAdaptationL()

	{

	__UHEAP_MARK;

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

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

	MRtcAdaptation* rtcAdaptation = CStartupAdaptationAdapter::NewRtcAdaptationL();