// 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 "TestAscynHandler.h"
#include "unloadcpmStep.h"
#include "Te_ConfiguratorSuiteDefs.h"
//NET-CONFIGURATOR-I-0013-HP
//UnLoading CPM which has been loaded prevesouly
CUnloadCpm::~CUnloadCpm()
/**
* Destructor
*/
{
}
CUnloadCpm::CUnloadCpm()
/**
* Constructor
*/
{
SetTestStepName(KUnloadCpm);
}
/**
* @see UnloadCpm test case NET-CONFIGURATOR-I-0013-HP
*
* doTestStepL virtual function does the below action
* Connect to a configurator server
* Configurator Loads the CPMs (Communication provider module)
* Configurator unloads the CPMs
* close the connection to configuator
* Expected:-UnloadCpm return KErrNone
*/
TVerdict CUnloadCpm::doTestStepL()
{
SetTestStepResult(EFail);
_LIT8(KNameDummyCpm,"DummyCpm");
//Configurator Load the tesCpm 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());
SetTestStepResult(EFail);
}
else
{
INFO_PRINTF2(_L("LoadCpm (DummyCpm) returned Error (%d) \n"), iStatus.Int());
SetTestStepResult(EFail);
}
//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 UnLoaded Successfully "));
SetTestStepResult(EPass);
}
else if(iStatus.Int() == KErrRSModuleUnknown)
{
INFO_PRINTF2(_L("UnLoaded (DummyCpm) returned KErrRSModuleUnknown(%d) \n"), iStatus.Int());
SetTestStepResult(EFail);
}
else
{
INFO_PRINTF2(_L("UnLoaded (DummyCpm) returned Error (%d) \n"), iStatus.Int());
SetTestStepResult(EFail);
}
return TestStepResult();
}
//NET-CONFIGURATOR-I-0014-HP
//UnLoading CPM which has not been already loaded
CUnloadCpmPreNotLoaded::~CUnloadCpmPreNotLoaded()
/**
* Destructor
*/
{
}
CUnloadCpmPreNotLoaded::CUnloadCpmPreNotLoaded()
/**
* Constructor
*/
{
SetTestStepName(KUnloadCpmPreNotLoaded);
}
/**
* @see UnloadCpmPreNotLoaded test case NET-CONFIGURATOR-I-0014-HP
*
* doTestStepL virtual function does the below action
* Connect to a configurator server
* Configurator unloads the CPM
* close the connection to configuator
* Expected:-UnloadCpmPreNotLoaded return KErrRSModuleNotLoaded
*/
TVerdict CUnloadCpmPreNotLoaded::doTestStepL()
{
SetTestStepResult(EFail);
_LIT8(KNameDummyCpm,"DummyCpm");
//Configurator to unload the DummyCpm CPM
iConfigurator.UnloadCpm(KNameDummyCpm(), EImmediate, iStatus);
//Waits for a specific asynchronous request to complete
User::WaitForRequest(iStatus);
if(iStatus == KErrNone)
{
INFO_PRINTF1(_L("DummyCpm UnLoaded Successfully returned \n"));
SetTestStepResult(EFail);
}
else if(iStatus.Int() == KErrRSModuleUnknown)
{
INFO_PRINTF2(_L("UnLoaded (DummyCpm) returned KErrRSModuleUnknown(%d) \n"), iStatus.Int());
SetTestStepResult(EFail);
}
else if(iStatus.Int() == KErrRSModuleNotLoaded)
{
INFO_PRINTF2(_L("UnLoaded (DummyCpm) returned KErrRSModuleNotLoaded(%d) \n"), iStatus.Int());
SetTestStepResult(EPass);
}
else
{
INFO_PRINTF2(_L("UnLoaded (DummyCpm) returned Error (%d) \n"), iStatus.Int());
SetTestStepResult(EFail);
}
return TestStepResult();
}
//NET-CONFIGURATOR-I-0015-HP
//Loading and unload different combination of cpm
// To be modified different combination Loading and unloading existing cpm
CLoadUnloadDiffCombination::~CLoadUnloadDiffCombination()
/**
* Destructor
*/
{
}
CLoadUnloadDiffCombination::CLoadUnloadDiffCombination()
/**
* Constructor
*/
{
SetTestStepName(KLoadUnloadDiffCombination);
}
/**
* @see LoadUnloadDiffCombination test case NET-CONFIGURATOR-I-0015-HP
*
* doTestStepL virtual function does the below action
* Connect to a configurator server
* Configurator loads the CPM
* Configurator unloads the CPM
* Repeat the loading and unloading with different combination
* close the connection to configuator
* Expected:-LoadUnloadDiffCombination return KErrRSModuleNotLoaded
*/
TVerdict CLoadUnloadDiffCombination::doTestStepL()
{
SetTestStepResult(EFail);
TRequestStatus status3;
TRequestStatus status4;
TInt failCount = 0;
_LIT8(KNameDummyCpm,"DummyCpm");
//Configurator Load the TesCpm CPM
iConfigurator.LoadCpm(KNameDummyCpm(), iStatus);
//Waits for a specific asynchronous request to complete
User::WaitForRequest(iStatus);
if(iStatus.Int() == KErrNone)
{
INFO_PRINTF1(_L("Cpm Loading Differenent order (DummyCpm) Loaded Successfully \n"));
}
else if(iStatus.Int() == KErrRSModuleUnknown)
{
INFO_PRINTF2(_L("Cpm Loading Differenent order (DummyCpm) returned KErrRSModuleUnknown(%d) \n"), iStatus.Int());
failCount++;
}
else
{
INFO_PRINTF2(_L("Cpm Loading Differenent order (DummyCpm) returned Error (%d) \n"), iStatus.Int());
failCount++;
}
_LIT8(KNameDummyCpm3,"DummyCpm3");
//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("Cpm Loading Differenent order (DummyCpm3) Loaded Successfully \n"));
}
else if(status3.Int() == KErrRSModuleUnknown)
{
INFO_PRINTF2(_L("Cpm Loading Differenent order (DummyCpm3) returned KErrRSModuleUnknown(%d) \n"), status3.Int());
failCount++;
}
else
{
INFO_PRINTF2(_L("Cpm Loading Differenent order (DummyCpm3) returned Error (%d) \n"), status3.Int());
failCount++;
}
_LIT8(KNameDummyCpm4,"DummyCpm4");
//Configurator Load the TesCpm4 CPM
iConfigurator.LoadCpm(KNameDummyCpm4(),status4);
//Waits for a specific asynchronous request to complete
User::WaitForRequest(status4);
if(status4.Int() == KErrNone)
{
INFO_PRINTF1(_L("Cpm Loading Differenent order (DummyCpm4) Loaded Successfully \n"));
}
else if(status4.Int() == KErrRSModuleUnknown)
{
INFO_PRINTF2(_L("Cpm Loading Differenent order (DummyCpm4) returned KErrRSModuleUnknown(%d) \n"), status4.Int());
failCount++;
}
else
{
INFO_PRINTF2(_L("Cpm Loading Differenent order (DummyCpm4) returned Error (%d) \n"), status4.Int());
failCount++;
}
//Configurator to unload the DummyCpm4 CPM
iConfigurator.UnloadCpm(KNameDummyCpm4(), EImmediate, status4);
User::WaitForRequest(status4);
//Configurator to unload the DummyCpm3 CPM
iConfigurator.UnloadCpm(KNameDummyCpm3(), EImmediate, status3);
User::WaitForRequest(status3);
//Configurator to unload the DummyCpm CPM
iConfigurator.UnloadCpm(KNameDummyCpm(), EImmediate, iStatus);
User::WaitForRequest(iStatus);
//Configurator to load the DummyCpm4 CPM
iConfigurator.LoadCpm(KNameDummyCpm4(), status4);
User::WaitForRequest(status4);
if(status4.Int() == KErrNone)
{
INFO_PRINTF1(_L("Cpm Loading Differenent order (DummyCpm4) Loaded Successfully \n"));
}
else if(status4.Int() == KErrRSModuleUnknown)
{
INFO_PRINTF2(_L("Cpm Loading Differenent order (DummyCpm4) returned KErrRSModuleUnknown(%d) \n"), status4.Int());
failCount++;
}
else
{
INFO_PRINTF2(_L("Cpm Loading Differenent order (DummyCpm4) returned Error (%d) \n"), status4.Int());
failCount++;
}
//Configurator to unload the DummyCpm4
iConfigurator.UnloadCpm(KNameDummyCpm4(), EImmediate, status4);
User::WaitForRequest(status4);
//Configurator to load the DummyCpm3
iConfigurator.LoadCpm(KNameDummyCpm3(), status3);
User::WaitForRequest(status3);
if(status3.Int() == KErrNone)
{
INFO_PRINTF1(_L("Cpm Loading Differenent order (DummyCpm3) Loaded Successfully \n"));
}
else if(status3.Int() == KErrRSModuleUnknown)
{
INFO_PRINTF2(_L("Cpm Loading Differenent order (DummyCpm3) returned KErrRSModuleUnknown(%d) \n"), status3.Int());
failCount++;
}
else
{
INFO_PRINTF2(_L("Cpm Loading Differenent order (DummyCpm3) returned Error (%d) \n"), status3.Int());
failCount++;
}
//Configurator to unload the DummyCpm3 CPM
iConfigurator.UnloadCpm(KNameDummyCpm3(), EImmediate, status3);
User::WaitForRequest(status3);
if(failCount == 0)
{
SetTestStepResult(EPass);
}
return TestStepResult();
}
// NET-CONFIGURATOR-I-0016-HP
//Cancelling the Loading CPM before and after loading
CCancelLoadCpm::~CCancelLoadCpm()
/**
* Destructor
*/
{
}
CCancelLoadCpm::CCancelLoadCpm()
/**
* Constructor
*/
{
SetTestStepName(KCancelLoadCpm);
}
/**
* @see CancelLoadCpm test case NET-CONFIGURATOR-I-0016-HP
*
* doTestStepL virtual function does the below action
* Connect to a configurator server
* Configurator loads the CPM
* Configurator unloads the CPM
* Configurator call Cancel load to cancel the preveous load request
* close the connection to configuator
* Expected:-CancelLoadCpm return KErrNone or KerrCancelled
* Expected result may not be always true it is wrote below mentioned in the production code
* There is no guarantee the module loading is canceled.
A best effort is made and the asynchronous request waiting for the module
to load returns with KErrCanceled on success.
*/
TVerdict CCancelLoadCpm::doTestStepL()
{
SetTestStepResult(EFail);
// Construct and install the active scheduler
CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;
// Push onto the cleanup stack
CleanupStack::PushL(scheduler);
// Install as the active scheduler
CActiveScheduler::Install(scheduler);
CCanceledLoadCpm* synchHandler = CCanceledLoadCpm::NewL();
CleanupStack::PushL(synchHandler);
_LIT8(KNameDummyCpm,"DummyCpm");
// issuing the Load request
INFO_PRINTF1(_L("DummyCpm Trying to Load"));
synchHandler->TryLoad(KNameDummyCpm());
//synchHandler->Cancel();
iConfigurator.CancelLoadCpm(KNameDummyCpm());
CActiveScheduler::Start();
if ((KErrCancel == synchHandler->iStatus.Int()) || (KErrNone == synchHandler->iStatus.Int()))
{
INFO_PRINTF2(_L("LoadCpm Success %d \n"),synchHandler->iStatus.Int());
SetTestStepResult(EPass);
}
// Unload the CPM anyway in case we were too late to cancel the load.
TRequestStatus status;
iConfigurator.UnloadCpm(KNameDummyCpm(), EImmediate, status);
User::WaitForRequest(status);
CleanupStack::PopAndDestroy(synchHandler);
CleanupStack::PopAndDestroy(scheduler);
return TestStepResult();
}
//NET-CONFIGURATOR-I-0017-HP
CCancelUnLoadCpm::~CCancelUnLoadCpm()
/**
* Destructor
*/
{
}
CCancelUnLoadCpm::CCancelUnLoadCpm()
/**
* Constructor
*/
{
}
/**
* @see CancelUnLoadCpm test case NET-CONFIGURATOR-I-0017-HP
*
* doTestStepL virtual function does the below action
* Connect to a configurator server
* Configurator loads the CPM
* Configurator unloads the CPM
* Configurator call Cancel unload to cancel the preveous unload request
* close the connection to configuator
* Expected:-CancelUnLoadCpm return KErrCancel or KErrNone
* Expected result may not be always true it is wrote below mentioned in the production code
* There is no guarantee the module loading is canceled.
A best effort is made and the asynchronous request waiting for the module
to load returns with KErrCanceled on success.
*/
TVerdict CCancelUnLoadCpm::doTestStepL()
{
SetTestStepResult(EFail);
// Construct and install the active scheduler
CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;
// Push into the cleanup stack
CleanupStack::PushL(scheduler);
// Install as the active scheduler
CActiveScheduler::Install(scheduler);
// create a CanceledLoadCpm active objects
CCanceledLoadCpm* synchHandler = CCanceledLoadCpm::NewL();
CleanupStack::PushL(synchHandler);
_LIT8(KNameDummyCpm,"DummyCpm");
INFO_PRINTF1(_L("DummyCpm Trying to Load"));
iConfigurator.LoadCpm(KNameDummyCpm(), iStatus);
User::WaitForRequest(iStatus);
synchHandler->TryUnLoad(KNameDummyCpm(), EImmediate);
iConfigurator.CancelUnloadCpm(KNameDummyCpm());
CActiveScheduler::Start();
if ((KErrCancel == synchHandler->iStatus.Int()) ||
(KErrNone == synchHandler->iStatus.Int()) ||
(KErrRSModuleNotLoaded == synchHandler->iStatus.Int()))
{
INFO_PRINTF2(_L("Cancel UnloadCpm Success %d \n"), synchHandler->iStatus.Int());
SetTestStepResult(EPass);
}
else
{
INFO_PRINTF2(_L("Cancel UnloadCpm Fail %d \n"), synchHandler->iStatus.Int());
}
CleanupStack::PopAndDestroy(synchHandler);
CleanupStack::PopAndDestroy(scheduler);
return TestStepResult();
}