// Copyright (c) 2003-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:
// This contains RootServer Test cases from section 6
//
//
// EPOC includes
#include <e32base.h>
#include <es_mbman.h>
// Test system includes
//#include <networking/log.h>
//#include <networking/teststep.h>
//#include <networking/testsuite.h>
#include "TestStepRootServer.h"
#include "TestAsynchHandler.h"
#include "RootServerTestSection5.h"
#include "RootServerTest.h"
// Test step 3.5 - Retrieve Module Information
CRootServerTest_GracefulUnload::CRootServerTest_GracefulUnload(CTE_RootServerServer *aSuite) : CTestStepRootServer(aSuite)
{
}
TVerdict CRootServerTest_GracefulUnload::UnloadGracefullyL(TThreadPriority aPriority)
{
SetTestStepResult(EFail);
// Create scheduler/active object framework
CSelfPopScheduler* scheduler = CSelfPopScheduler::CreateLC();
CTestAsynchHandler* asynchHandler = CTestAsynchHandler::NewLC(&iRootServerSuite->RootSess());
//*****************step 2************************
INFO_PRINTF1(_L("02 Load test module"));
TRSStartModuleParams startParams;
TTestModuleIniData iniData;
DefaultStartParams(startParams, iniData);
startParams.iParams.iName = KModule1;
startParams.iParams.iPriority = aPriority;
asynchHandler->TryLoad(startParams, iniData);
CActiveScheduler::Start();
if (asynchHandler->iStatus != KErrNone)
{
INFO_PRINTF2(_L("LoadServer returned error: <%d> "), asynchHandler->iStatus.Int());
SetTestStepResult(EInconclusive);
}
else
{
//*****************step 4***********************
INFO_PRINTF1(_L("04 Unload Test Module"));
asynchHandler->TryUnLoad(startParams.iParams.iName, EGraceful);
CActiveScheduler::Start();
if (asynchHandler->iStatus != KErrNone)
{
INFO_PRINTF2(_L("Unload returned error: <%d> "), asynchHandler->iStatus.Int());
SetTestStepResult(EInconclusive);
}
else
{
SetTestStepResult(EPass); }
}
// uninstall and destroy active scheduler
CleanupStack::PopAndDestroy(asynchHandler);
CleanupStack::PopAndDestroy(scheduler);
return TestStepResult();
}
// Test step 5.1 - UnLoad Gracefully (normal priority)
CRootServerTest5_1::CRootServerTest5_1(CTE_RootServerServer *aSuite) : CRootServerTest_GracefulUnload(aSuite)
{
// store the name of this test case
SetTestStepName(_L("Test5.1"));
}
TVerdict CRootServerTest5_1::doTestStepL( void )
{
INFO_PRINTF1(_L("Test Purpose: UnLoad Comms Provider Module gracefully (normal priority)"));
return UnloadGracefullyL(EPriorityNormal);
}
// Test step 5.2 - UnLoad Gracefully (elevated priority)
CRootServerTest5_2::CRootServerTest5_2(CTE_RootServerServer *aSuite) : CRootServerTest_GracefulUnload(aSuite)
{
// store the name of this test case
SetTestStepName(_L("Test5.2"));
}
TVerdict CRootServerTest5_2::doTestStepL( void )
{
INFO_PRINTF1(_L("Test Purpose: UnLoad Comms Provider Module gracefully (elevated priority)"));
return UnloadGracefullyL(EPriorityRealTime);
}
// Test step 5.3 - Cancel UnLoad Gracefully
CRootServerTest5_3::CRootServerTest5_3(CTE_RootServerServer *aSuite) : CTestStepRootServer(aSuite)
{
// store the name of this test case
SetTestStepName(_L("Test5.3"));
}
TVerdict CRootServerTest5_3::doTestStepL( void )
{
INFO_PRINTF1(_L("Test Purpose: Cancel UnLoad Comms Provider Module gracefully"));
SetTestStepResult(EPass);
// Create scheduler/active object framework
CSelfPopScheduler* scheduler = CSelfPopScheduler::CreateLC();
CTestAsynchHandler* asynchHandler = CTestAsynchHandler::NewLC(&iRootServerSuite->RootSess());
//*****************step 2************************
INFO_PRINTF1(_L("02 Load Test Module"));
TRSStartModuleParams startParams;
TTestModuleIniData iniData;
DefaultStartParams(startParams, iniData);
startParams.iParams.iName = KModule1;
asynchHandler->TryLoad(startParams, iniData);
CActiveScheduler::Start();
if (asynchHandler->iStatus != KErrNone)
{
INFO_PRINTF2(_L("LoadServer returned error: <%d> "), asynchHandler->iStatus.Int());
SetTestStepResult(EInconclusive);
}
else
{
//*****************step 3***********************
INFO_PRINTF1(_L("03 Unload Test Module"));
asynchHandler->TryUnLoad(startParams.iParams.iName, EGraceful);
//*****************step 4***********************
INFO_PRINTF2(_L("04 Cancelling UnLoad: %S"), &startParams.iParams.iName);
iRootServerSuite->RootSess().CancelUnloadCpm(startParams.iParams.iName);
CActiveScheduler::Start();
if ((asynchHandler->iStatus != KErrNone) && (asynchHandler->iStatus != KErrCancel))
{
INFO_PRINTF2(_L("Unload returned error: <%d> "), asynchHandler->iStatus.Int());
SetTestStepResult(EFail); }
}
// uninstall and destroy active scheduler
CleanupStack::PopAndDestroy(asynchHandler);
CleanupStack::PopAndDestroy(scheduler);
return TestStepResult();
}
// Test step 3.5 - Retrieve Module Information
CRootServerTest_UngracefulUnload::CRootServerTest_UngracefulUnload(CTE_RootServerServer *aSuite) : CTestStepRootServer(aSuite)
{
}
TVerdict CRootServerTest_UngracefulUnload::UnloadNonGracefullyL(TThreadPriority aPriority)
{
SetTestStepResult(EFail);
// Create scheduler/active object framework
CSelfPopScheduler* scheduler = CSelfPopScheduler::CreateLC();
CTestAsynchHandler* asynchHandler = CTestAsynchHandler::NewLC(&iRootServerSuite->RootSess());
//*****************step 3************************
INFO_PRINTF1(_L("03 Load Test Module"));
TRSStartModuleParams startParams;
TTestModuleIniData iniData;
DefaultStartParams(startParams, iniData);
startParams.iParams.iName = KModule1;
startParams.iParams.iPriority = aPriority;
asynchHandler->TryLoad(startParams, iniData);
CActiveScheduler::Start();
if (asynchHandler->iStatus != KErrNone)
{
INFO_PRINTF2(_L("LoadServer returned error: <%d> "), asynchHandler->iStatus.Int());
SetTestStepResult(EInconclusive);
}
else
{
//*****************step 4***********************
INFO_PRINTF1(_L("04 Unload Test Module"));
asynchHandler->TryUnLoad(startParams.iParams.iName, EUnGraceful);
CActiveScheduler::Start();
if (asynchHandler->iStatus != KErrNone)
{
INFO_PRINTF2(_L("Unload returned error: <%d> "), asynchHandler->iStatus.Int());
SetTestStepResult(EInconclusive);
}
else
{
SetTestStepResult(EPass);
}
}
// uninstall and destroy active scheduler
CleanupStack::PopAndDestroy(asynchHandler);
CleanupStack::PopAndDestroy(scheduler);
return TestStepResult();
}
// Test step 5.4 - UnLoad Ungracefully - normal priority
CRootServerTest5_4::CRootServerTest5_4(CTE_RootServerServer *aSuite) : CRootServerTest_UngracefulUnload(aSuite)
{
// store the name of this test case
SetTestStepName(_L("Test5.4"));
}
TVerdict CRootServerTest5_4::doTestStepL( void )
{
INFO_PRINTF1(_L("Test Purpose: UnLoad Comms Provider Module Ungracefully (normal priority)"));
return UnloadNonGracefullyL(EPriorityNormal);
}
// Test step 5.5 - UnLoad Ungracefully - elevated priority
CRootServerTest5_5::CRootServerTest5_5(CTE_RootServerServer *aSuite) : CRootServerTest_UngracefulUnload(aSuite)
{
// store the name of this test case
SetTestStepName(_L("Test5.5"));
}
TVerdict CRootServerTest5_5::doTestStepL( void )
{
INFO_PRINTF1(_L("Test Purpose: UnLoad Comms Provider Module Ungracefully (elevated priority)"));
return UnloadNonGracefullyL(EPriorityRealTime);
}
// Test step 5.6 - Cancel UnLoad Ungracefully
CRootServerTest5_6::CRootServerTest5_6(CTE_RootServerServer *aSuite) : CTestStepRootServer(aSuite)
{
// store the name of this test case
SetTestStepName(_L("Test5.6"));
}
TVerdict CRootServerTest5_6::doTestStepL( void )
{
INFO_PRINTF1(_L("Test Purpose: Cancel UnLoad Comms Provider Module Ungracefully"));
SetTestStepResult(EPass);
// Create scheduler/active object framework
CSelfPopScheduler* scheduler = CSelfPopScheduler::CreateLC();
CTestAsynchHandler* asynchHandler = CTestAsynchHandler::NewLC(&iRootServerSuite->RootSess());
//*****************step 2************************
INFO_PRINTF1(_L("02 Load Test Module"));
TRSStartModuleParams startParams;
TTestModuleIniData iniData;
DefaultStartParams(startParams, iniData);
startParams.iParams.iName = KModule1;
asynchHandler->TryLoad(startParams, iniData);
CActiveScheduler::Start();
if (asynchHandler->iStatus != KErrNone)
{
INFO_PRINTF2(_L("Load returned error: <%d> "), asynchHandler->iStatus.Int());
SetTestStepResult(EInconclusive);
}
else
{
//*****************step 3***********************
INFO_PRINTF1(_L("03 Unload Test Module"));
asynchHandler->TryUnLoad(startParams.iParams.iName, EUnGraceful);
//*****************step 4***********************
INFO_PRINTF2(_L("04 Cancelling UnLoad: %S"), &startParams.iParams.iName);
iRootServerSuite->RootSess().CancelUnloadCpm(startParams.iParams.iName);
CActiveScheduler::Start();
// Unload the CPM anyway in case we were too late to cancel the load.
TRequestStatus status;
iRootServerSuite->RootSess().UnloadCpm(status, startParams.iParams.iName, EImmediate);
User::WaitForRequest(status);
if (asynchHandler->iStatus != KErrNone)
{
INFO_PRINTF2(_L("Unload returned error: <%d> "), asynchHandler->iStatus.Int());
SetTestStepResult(EFail);
}
}
// uninstall and destroy active scheduler
CleanupStack::PopAndDestroy(asynchHandler);
CleanupStack::PopAndDestroy(scheduler);
return TestStepResult();
}
// Test step 5.7 - UnLoad 2 modules sharing the same heap
CRootServerTest5_7::CRootServerTest5_7(CTE_RootServerServer *aSuite) : CTestStepRootServer(aSuite)
{
// store the name of this test case
SetTestStepName(_L("Test5.7"));
}
TVerdict CRootServerTest5_7::doTestStepL( void )
{
INFO_PRINTF1(_L("Test Purpose: UnLoad 2 modules sharing the same heap"));
SetTestStepResult(EFail);
// Create scheduler/active object framework
CSelfPopScheduler* scheduler = CSelfPopScheduler::CreateLC();
CTestAsynchHandler* asynchHandler = CTestAsynchHandler::NewLC(&iRootServerSuite->RootSess());
//*****************step 3************************
INFO_PRINTF1(_L("03 Load Test Module_Share1"));
TRSStartModuleParams startParams;
TTestModuleIniData iniData;
DefaultStartParams(startParams, iniData);
_LIT8(KShareModule1, "Test ModuleShare1");
_LIT8(KShareModule2, "Test ModuleShare2");
startParams.iParams.iName = KShareModule1;
asynchHandler->TryLoad(startParams, iniData);
CActiveScheduler::Start();
if (asynchHandler->iStatus != KErrNone)
{
INFO_PRINTF2(_L("LoadServer returned error: <%d> "), asynchHandler->iStatus.Int());
User::Leave(asynchHandler->iStatus.Int());
}
//*****************step 3************************
INFO_PRINTF1(_L("03 Load Test Module"));
startParams.iParams.iName = KShareModule2;
startParams.iParams.iHeapType = EShareHeap;
startParams.iParams.iShareHeapWith = KShareModule1;
asynchHandler->TryLoad(startParams, iniData);
CActiveScheduler::Start();
if (asynchHandler->iStatus != KErrNone)
{
INFO_PRINTF2(_L("LoadServer returned error: <%d> "), asynchHandler->iStatus.Int());
User::Leave(asynchHandler->iStatus.Int());
}
//*****************step 5***********************
INFO_PRINTF1(_L("05 Unload Test Module_Share1"));
startParams.iParams.iName = KShareModule1;
asynchHandler->TryUnLoad(startParams.iParams.iName, EGraceful);
CActiveScheduler::Start();
if (asynchHandler->iStatus != KErrNone)
{
INFO_PRINTF2(_L("Unload returned error: <%d> "), asynchHandler->iStatus.Int());
User::Leave(asynchHandler->iStatus.Int());
}
//*****************step 6***********************
INFO_PRINTF1(_L("06 Unload Test Module_Share2"));
startParams.iParams.iName = KShareModule2;
asynchHandler->TryUnLoad(startParams.iParams.iName, EGraceful);
CActiveScheduler::Start();
if (asynchHandler->iStatus != KErrNone)
{
INFO_PRINTF2(_L("Unload returned error: <%d> "), asynchHandler->iStatus.Int());
SetTestStepResult(EInconclusive);
}
else
{
SetTestStepResult(EPass);
}
// uninstall and destroy active scheduler
CleanupStack::PopAndDestroy(asynchHandler);
CleanupStack::PopAndDestroy(scheduler);
return TestStepResult();
}
// Test step 5.8 - Unload Sluggish CPM Gracefully with intervening Close of Session
CRootServerTest5_8::CRootServerTest5_8(CTE_RootServerServer *aSuite) : CTestStepRootServer(aSuite)
{
// store the name of this test case
SetTestStepName(_L("Test5.8"));
}
TVerdict CRootServerTest5_8::doTestStepL( void )
{
INFO_PRINTF1(_L("Test Purpose: Unload Sluggish CPM Gracefully with intervening Close of Session"));
SetTestStepResult(EPass);
// Create scheduler/active object framework
CSelfPopScheduler* scheduler = CSelfPopScheduler::CreateLC();
CTestAsynchHandler* asynchHandler = CTestAsynchHandler::NewLC(&iRootServerSuite->RootSess());
TRSStartModuleParams startParams;
TTestModuleIniData iniData;
DefaultStartParams(startParams, iniData);
startParams.iParams.iName = KModule1;
iniData.iParams.iShutdownDelay = isTestServerLifeTime;
INFO_PRINTF2(_L("01 Loading sluggish module: %S"), &startParams.iParams.iName);
asynchHandler->TryLoad(startParams, iniData);
CActiveScheduler::Start();
if (asynchHandler->iStatus != KErrNone)
{
INFO_PRINTF2(_L("LoadServer returned error: <%d> "), asynchHandler->iStatus.Int());
User::Leave(asynchHandler->iStatus.Int());
}
INFO_PRINTF1(_L("02 Unload sluggish Module"));
asynchHandler->TryUnLoad(startParams.iParams.iName, EGraceful);
// Brief wait to give unload chance to start
User::After(250 * 1000);
// Close the session
INFO_PRINTF1(_L("03 Closing RRootServ"));
iRootServerSuite->RootSess().Close();
// Brief wait for any fireworks
User::After(250 * 1000);
// Let the request complete
CActiveScheduler::Start();
// Reconnect the session
INFO_PRINTF1(_L("04 Reconnecting RRootServ"));
TInt ret = iRootServerSuite->RootSess().Connect();
if (ret != KErrNone)
{
INFO_PRINTF2(_L("Reconnect of RRootServ failed with error: <%d> "), ret);
User::Leave(ret);
}
// Brief wait for any fireworks
User::After(250 * 1000);
// now try to retrieve information about the module; should be ERunning after session close
// causes unload handler to be canceled
INFO_PRINTF1(_L("05 Getting module information"));
TRSModuleInfo info;
TCFModuleName moduleName = startParams.iParams.iName;
ret = iRootServerSuite->RootSess().GetModuleInfo(moduleName, info);
INFO_PRINTF4(_L("GetModuleInfo for %S returned %d, state %c= ERunning"), &moduleName, ret, info.iParams.iState == EStopping? '=': '!');
if(KErrNone != ret || info.iParams.iState != ERunning)
{
CleanupStack::PopAndDestroy(asynchHandler);
CleanupStack::PopAndDestroy(scheduler);
SetTestStepResult(EFail);
return TestStepResult();
}
// Wait for it to finish stopping, query again
INFO_PRINTF1(_L("06 Getting module information after waiting for stop"));
User::After((iniData.iParams.iShutdownDelay + 500) * 1000);
moduleName = startParams.iParams.iName;
ret = iRootServerSuite->RootSess().GetModuleInfo(moduleName, info);
INFO_PRINTF3(_L("GetModuleInfo for %S returned %d"), &moduleName, ret);
if(KErrRSModuleUnknown != ret)
{
CleanupStack::PopAndDestroy(asynchHandler);
CleanupStack::PopAndDestroy(scheduler);
SetTestStepResult(EFail);
return TestStepResult();
}
CleanupStack::PopAndDestroy(asynchHandler);
CleanupStack::PopAndDestroy(scheduler);
return TestStepResult();
}