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

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

// Example CTestStep derived implementation

// 

//

/**

 @file loadcpmStep.cpp

*/

#include "loadcpmStep.h"

#include "Te_ConfiguratorSuiteDefs.h"

#include "Te_ConfiguratorSuiteServer.h"

//NET-CONFIGURATOR-I-0001-HP

//Loading a CPM in configurator with OnDemand option 1

/**

 * Destructor

 */

CLoadCpm::~CLoadCpm()

	{

	}

/**

 * Constructor

 */

CLoadCpm::CLoadCpm()

	{

	SetTestStepName(KLoadCpm);

	}

/**

 * @see LoadCpm test case NET-CONFIGURATOR-I-0001-HP

 *

 * doTestStepL virtual function does the below action

 * Connect to a configurator

 * Configurator Loads the DummyCpm CPM (Communication provider module)

 * Configurator to unload the DummyCpm

 * close the connection to configuator

 * Expected:-LoadCpm return kerrNone

*/

TVerdict CLoadCpm::doTestStepL()

	{

	SetTestStepResult(EFail);

    _LIT8(KNameDummyCpm,"DummyCpm");

	//Configurator Load the DummyCpm CPM

	iConfigurator.LoadCpm(KNameDummyCpm(),iStatus);

	User::WaitForRequest(iStatus);

	if(iStatus.Int() == KErrNone)

		{

		INFO_PRINTF1(_L("DummCpm Loaded Successfully \n"));

		SetTestStepResult(EPass);

		}

	else if(iStatus.Int() == KErrRSModuleUnknown)

		{

		INFO_PRINTF2(_L("LoadCpm (DummyCpm) returned KErrRSModuleUnknown(%d)  \n"), iStatus.Int());

		}

	else if(iStatus.Int() == KErrRSModuleAlreadyExist )

		{

		INFO_PRINTF2(_L("LoadCpm Loaded more than one returned KErrRSModuleAlreadyExist (%d)  \n"), iStatus.Int());

		}

	else

		{

		INFO_PRINTF2(_L("LoadCpm (DummyCpm) returned Error (%d)  \n"), iStatus.Int());

		}

	iConfigurator.UnloadCpm(KNameDummyCpm(), EImmediate, iStatus);

	//Waits for a specific asynchronous request to complete.

	User::WaitForRequest(iStatus);

	if(iStatus.Int() != KErrNone && iStatus.Int() != KErrCancel)

		{

		INFO_PRINTF1(_L("DummyCpm is not UnLoaded Successfully \n"));

		SetTestStepResult(EFail);

		}

	return TestStepResult();

	}

//NET-CONFIGURATOR-I-0002-HP

//Loading CPM More Than one time in a Configurator

/**

 * Destructor

 */

CLoadCpmMorethanOne::~CLoadCpmMorethanOne()

	{

	}

/**

 * Constructor

 */

CLoadCpmMorethanOne::CLoadCpmMorethanOne()

	{

	SetTestStepName(KLoadCpmMorethanOne);

	}

/**

 * @see LoadCpmMoreThanOne test case NET-CONFIGURATOR-I-0002-HP

 *

 * doTestStepL virtual function does the below action

 * Connect to a configurator

 * Configurator Loads the DummyCpm CPM (Communication provider module)

 * Configurator Loads the DummyCpm CPM

 * Configurator to unload the DummyCpm

 * close the connection to configuator

 * Expected:-LoadCpmMoreThanOne return KErrRSModuleAlreadyExist

*/

TVerdict CLoadCpmMorethanOne::doTestStepL()

	{

	SetTestStepResult(EFail);

	_LIT8(KNameDummyCpm,"DummyCpm");

	//Configurator Load the dummycpm CPM

	iConfigurator.LoadCpm(KNameDummyCpm(), iStatus);

	//Waits for a specific asynchronous request to complete.

	User::WaitForRequest(iStatus);

	if(iStatus.Int() == KErrNone)

		{

		INFO_PRINTF1(_L("DummyCpm Loaded Successfully \n"));

		}

	else if(iStatus.Int() == KErrRSModuleUnknown)

		{

		INFO_PRINTF2(_L("LoadCpm (DummyCpm) returned KErrRSModuleUnknown(%d)  \n"), iStatus.Int());

		}

	else

		{

		INFO_PRINTF2(_L("LoadCpm (DummyCpm) returned Error (%d)  \n"), iStatus.Int());

		}

	//Configurator Load the dummycpm CPM

	iConfigurator.LoadCpm(KNameDummyCpm(), iStatus);

	//Waits for a specific asynchronous request to complete.

	User::WaitForRequest(iStatus);

	if(iStatus.Int() == KErrNone)

		{

		INFO_PRINTF1(_L("DummyCpm Loaded more than one Successfully \n"));

		}

	else if(iStatus.Int() == KErrRSModuleUnknown)

		{

		INFO_PRINTF2(_L("DummyCpm Loaded more than one returned KErrRSModuleUnknown(%d)  \n"), iStatus.Int());

		}

	else if(iStatus.Int() == KErrRSModuleAlreadyExist )

		{

		INFO_PRINTF2(_L("DummyCpm Loaded more than one returned KErrRSModuleAlreadyExist (%d)  \n"), iStatus.Int());

		SetTestStepResult(EPass);

		}

	else

		{

		INFO_PRINTF2(_L("DummyCpm Loaded more than one returned Error (%d)  \n"), iStatus.Int());

		}

	//Configurator to unload the DummyCpm CPM

	iConfigurator.UnloadCpm(KNameDummyCpm(), EImmediate, iStatus);

	//Waits for a specific asynchronous request to complete.

	User::WaitForRequest(iStatus);

	if(iStatus.Int() != KErrNone)

		{

		INFO_PRINTF1(_L("DummyCpm is not UnLoaded Successfully \n"));

		SetTestStepResult(EFail);

		}

	return TestStepResult();

	}

//NET-CONFIGURATOR-I-0003-HP

//Loading a CPM in configurator on Boot time

/**

 * Destructor

 */

CLoadCpmBootTime::~CLoadCpmBootTime()

	{

	}

/**

 * Constructor

 */

CLoadCpmBootTime::CLoadCpmBootTime()

	{

	SetTestStepName(KLoadCpmBootTime);

	}

/**

 * @see LoadCpmBootTime test case NET-CONFIGURATOR-I-0003-HP

 *

 * doTestStepL virtual function does the below action

 * Connect to a configurator

 * Configurator Loads the DummyCpm CPM

 * Configurator to unload the DummyCpm

 * close the connection to configuator

 * Expected:-LoadCpmBootTime return KErrRSModuleAlreadyExist

*/

TVerdict CLoadCpmBootTime::doTestStepL()

	{

	SetTestStepResult(EFail);

	INFO_PRINTF1(_L("Configurator Connection Sucessful"));

    _LIT8(KNameDummyCpm8,"DummyCpm8");

	//Configurator Load the DummyCpm CPM

	iConfigurator.LoadCpm(KNameDummyCpm8(), iStatus);

	//Waits for a specific asynchronous request to complete.

	User::WaitForRequest(iStatus);

	if(iStatus.Int() == KErrNone)

		{

		INFO_PRINTF1(_L("DummyCpm8 is not Loaded during boot time \n"));

		}

	else if(iStatus.Int() == KErrRSModuleUnknown)

		{

		INFO_PRINTF2(_L("LoadCpm during boot time returned KErrRSModuleUnknown(%d)  \n"), iStatus.Int());

		}

	else

	if(iStatus.Int() == KErrRSModuleAlreadyExist)

		{

		INFO_PRINTF2(_L("LoadCpm returned KErrRSModuleAlreadyExist(%d)  \n"), iStatus.Int());

    	SetTestStepResult(EPass);

		}

	else

		{

		INFO_PRINTF2(_L("LoadCpm returned Error (%d)  \n"), iStatus.Int());

		}

	return TestStepResult();

	}

//NET-CONFIGURATOR-I-0004-HP

//Loading CPM in a Configurator Without CMI files

/**

 * Destructor

 */

CLoadCpmWithoutCMI::~CLoadCpmWithoutCMI()

	{

	}

/**

 * Constructor

 */

CLoadCpmWithoutCMI::CLoadCpmWithoutCMI()

	{

	SetTestStepName(KLoadCpmWithoutCMI);

	}

/**

 * @see LoadCpmWithoutCMI test case NET-CONFIGURATOR-I-0004-HP

 *

 * doTestStepL virtual function does the below action

 * Connect to a configurator

 * Configurator Loads the Test_NoCmi CPM (Communication provider module)

 * close the connection to configuator

 * Expected:-LoadCpm return KErrRSModuleUnknown

*/

TVerdict CLoadCpmWithoutCMI::doTestStepL()

	{

	SetTestStepResult(EFail);

	//Connection to the configurator

	_LIT8(KNameDummyNoCmi,"DummyNoCMI");

	//Configurator Load the dummycpm

	iConfigurator.LoadCpm(KNameDummyNoCmi(), iStatus);

	//Waits for a specific asynchronous request to complete.

	User::WaitForRequest(iStatus);

	if(iStatus.Int() == KErrNone)

		{

	    INFO_PRINTF2(_L("LoadCpmWithoutCMI returned KErrNone (%d) - Expected KErrRSModuleUnknown  \n"), iStatus.Int());

		}

	else if(iStatus.Int() == KErrRSModuleAlreadyExist)

		{

		INFO_PRINTF2(_L("DummyCpm (ENewHeap) Cpm returned KErrRSModuleAlreadyExist(%d)  \n"), iStatus.Int());

		}

	if(iStatus.Int() == KErrRSModuleUnknown)

		{

		INFO_PRINTF2(_L("LoadCpmWithoutCMI returned KErrRSModuleUnknown (%d)  \n"), iStatus.Int());

		SetTestStepResult(EPass);

		}

	else

		{

		INFO_PRINTF2(_L("LoadCpmWithoutCMI returned Error (%d)  \n"), iStatus.Int());

		}

	return TestStepResult();

	}

//NET-CONFIGURATOR-I-0005-HP

//Loading a CPM which has different heap option

/**

 * Destructor

 */

CLoadCpmWithDiffHeapOption::~CLoadCpmWithDiffHeapOption()

	{

	}

/**

 * Constructor

 */

CLoadCpmWithDiffHeapOption::CLoadCpmWithDiffHeapOption()

	{

	SetTestStepName(KLoadCpmWithDiffHeapOption);

	}

/**

 * @see LoadCpmWithDiffHeapOption test case NET-CONFIGURATOR-I-0005-HP

 *

 * doTestStepL virtual function does the below action

 * Connect to a configurator

 * Configurator Loads the CPMs (Communication provider module)

 * Configurator to unload the CPMs

 * close the connection to configuator

 * Expected:-LoadCpmWithDiffHeapOption return KerrNone

*/

TVerdict CLoadCpmWithDiffHeapOption::doTestStepL()

	{

	SetTestStepResult(EFail);

	TRequestStatus status2, status3;

	_LIT8(KNameDummyCpm,"DummyCpm");

	_LIT8(KNameDummyCpm2,"DummyCpm2");

	_LIT8(KNameDummyCpm3,"DummyCpm3");

	//Configurator Load the DummyCpm CPM

	iConfigurator.LoadCpm(KNameDummyCpm(), iStatus);

	//Waits for a specific asynchronous request to complete.

	User::WaitForRequest(iStatus);

	if(iStatus.Int() == KErrNone)

		{

		INFO_PRINTF1(_L("DummyCpm (ENewHeap) Cpm Loaded Successfully \n"));

		}

	else if(iStatus == KErrRSModuleAlreadyExist)

		{

		INFO_PRINTF2(_L("DummyCpm (ENewHeap) Cpm returned KErrRSModuleAlreadyExist(%d)  \n"), iStatus.Int());

		}

	else

	if(iStatus.Int() == KErrRSModuleUnknown)

		{

		INFO_PRINTF2(_L("DummyCpm (ENewHeap) Cpm returned KErrRSModuleUnknown(%d)  \n"), iStatus.Int());

		}

	else

		{

		INFO_PRINTF2(_L("DummyCpm (ENewHeap) Cpm returned Error (%d)  \n"), iStatus.Int());

		}

	//Configurator Load the DummyCpm2 CPM

	iConfigurator.LoadCpm(KNameDummyCpm2(), status2);

	User::WaitForRequest(status2);

	if(status2.Int() == KErrNone)

		{

		INFO_PRINTF1(_L("DummyCpm2 (EshareHeap) Cpm Loaded Successfully \n"));

		}

	else if(status2.Int() == KErrRSModuleAlreadyExist)

		{

		INFO_PRINTF2(_L("DummyCpm2 (EshareHeap) Cpm returned KErrRSModuleAlreadyExist(%d)  \n"), status2.Int());

		}

	else if(status2.Int() == KErrRSModuleUnknown)

		{

		INFO_PRINTF2(_L("DummyCpm2 (EshareHeap) Cpm returned KErrRSModuleUnknown(%d)  \n"), status2.Int());

		}

	else

		{

		INFO_PRINTF2(_L("DummyCpm2 (EshareHeap) Cpm returned Error (%d)  \n"), status2.Int());

		}

	//Configurator Load the DummyCpm3 CPM

	iConfigurator.LoadCpm(KNameDummyCpm3(), status3);

	//Waits for a specific asynchronous request to complete.

	User::WaitForRequest(status3);

	if(status3.Int() == KErrNone)

		{

		INFO_PRINTF1(_L("DummyCpm3 (EDefaultHeap) Cpm Loaded Successfully \n"));

		}

	else if(status3.Int() == KErrRSModuleUnknown)

		{

		INFO_PRINTF2(_L("DummyCpm3 (EDefaultHeap) Cpm returned KErrRSModuleUnknown(%d)  \n"), status3.Int());

		}

	else

		{

		INFO_PRINTF2(_L("DummyCpm3 (EDefaultHeap) Cpm returned Error (%d)  \n"), status3.Int());

		}

	if(iStatus.Int() == KErrNone && status2.Int() == KErrNone && status3.Int() == KErrNone )

		{

		INFO_PRINTF1(_L("DummyCpm (ENewHeap),DummyCpm2 (EshareHeap),DummyCpm3 (EDefaultHeap) are loading Successfully\n"));

		SetTestStepResult(EPass);

		}

	else

		{

		SetTestStepResult(EFail);

		}

	//Configurator unload the  CPMs

	iConfigurator.UnloadCpm(KNameDummyCpm(), EImmediate, iStatus);

	User::WaitForRequest(iStatus);

	iConfigurator.UnloadCpm(KNameDummyCpm2(), EImmediate, status2);

	User::WaitForRequest(status2);

	iConfigurator.UnloadCpm(KNameDummyCpm3(), EImmediate, status3);

	User::WaitForRequest(status3);

	return TestStepResult();

	}

//NET-CONFIGURATOR-I-0006-HP

//Loading of CPM at the boot time

/**

 * Destructor

 */

CLoadOnDemandCpmBootTime::~CLoadOnDemandCpmBootTime()

	{

	}

/**

 * Constructor

 */

CLoadOnDemandCpmBootTime::CLoadOnDemandCpmBootTime()

	{

		SetTestStepName(KLoadOnDemandCpmBootTime);

	}

/**

 * @see LoadOnDemandCpmBootTime test case NET-CONFIGURATOR-I-0006-HP

 *

 * doTestStepL virtual function does the below action

 * Connect to a configurator

 * Configurator Loads the CPMs (Communication provider module)

 * Configurator to unload the DummyCpm

 * close the connection to configuator

 * Expected:-LoadOnDemandCpmBootTime return KErrNone

*/

TVerdict CLoadOnDemandCpmBootTime::doTestStepL()

	{

	SetTestStepResult(EFail);

	INFO_PRINTF1(_L("Configurator Connection Sucessful"));

	_LIT8(KNameDummyCpm,"DummyCpm");

	//Configurator Load the DummyCpm CPM

	iConfigurator.LoadCpm(KNameDummyCpm(), iStatus);

	//Waits for a specific asynchronous request to complete.

	User::WaitForRequest(iStatus);

	if(iStatus.Int() == KErrNone)

		{

		INFO_PRINTF1(_L("DummyCpm Loaded Sucessfully"));

		SetTestStepResult(EPass);

		}

	else

		{

		INFO_PRINTF2(_L("DummyCpm Load Error %d"), iStatus.Int());

		}

	//Configurator to unload the DummyCpm CPM

	iConfigurator.UnloadCpm(KNameDummyCpm(), EImmediate, iStatus);

	//Waits for a specific asynchronous request to complete.

	User::WaitForRequest(iStatus);

	if(iStatus.Int() != KErrNone)

		{

		INFO_PRINTF1(_L("DummyCpm is not UnLoaded Successfully \n"));

		SetTestStepResult(EFail);

		}

	return TestStepResult();

	}

//NET-CONFIGURATOR-I-0007-HP

//Load same cpm with difference session simultaneously

/**

 * Destructor

 */

CLoadCpmDiffSession::~CLoadCpmDiffSession()

	{

	}

/**

 * Constructor

 */

CLoadCpmDiffSession::CLoadCpmDiffSession()

	{

	SetTestStepName(KLoadCpmDiffSession);

	}

/**

 * @see LoadCpmDiffSession test case NET-CONFIGURATOR-I-0007-HP

 *

 * doTestStepL virtual function does the below action

 * Connect to a configurator with two sessions

 * Configurator Loads the CPMs (Communication provider module)

 * Configurator to unload the DummyCpm2

 * close the connection to configuator

 * Expected:-LoadCpmDiffSession return KErrRSModuleAlreadyExist

*/

TVerdict CLoadCpmDiffSession::doTestStepL()

	{

	SetTestStepResult(EFail);

	TRequestStatus status1;

	RRsConfigurator configurator1;

	//Connection to the configurator

	TInt result1 = configurator1.Connect();

	if (result1 == KErrNone)

		{

		_LIT8(KNameDummyCpm,"DummyCpm");

		iConfigurator.LoadCpm(KNameDummyCpm(),iStatus);

		configurator1.LoadCpm(KNameDummyCpm(),status1);

		User::WaitForRequest(iStatus, status1);

		//Waits for a specific asynchronous request to complete

		if(iStatus.Int() == KErrNone || status1.Int() == KErrRSModuleAlreadyExist)

			{

			INFO_PRINTF1(_L("Session1 loaded DummyCpm Successfully \n"));

			SetTestStepResult(EPass);

			}

		else if(iStatus.Int() == KErrRSModuleAlreadyExist || status1.Int() == KErrNone)

			{