diff -r 000000000000 -r dfb7c4ff071f commsprocess/commsrootserverconfig/Te_Configurator/src/unloadcpmStep.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commsprocess/commsrootserverconfig/Te_Configurator/src/unloadcpmStep.cpp Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,468 @@ +// 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(); + } +