// Copyright (c) 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:

//These tests are only for the Cleserver when it reconstructs the 

//commands from the commandlist. 

/**

 @file

 @test

 @internalComponent - Internal Symbian test code  

*/

#include <ssm/ssmstartupproperties.h>

#include <f32file.h>

#include <e32property.h>

#include "clesrv.h"

#include "clecli.h"

#include "cmdpublishswp.h"

#include "ssmcustomcommandinfo.h"

#include "cmdcustomcommand.h"

#include "cmdloadsup.h"

#include "cmdpublishsystemstate.h"

#include "cmdreqswpchange.h"

#include "ssmtestapps.h"

#include "cmdstartapp.h"

#include "cmdstartprocess.h"

#include "ssmtestprocgoodsession.h"

#include "cmdpoweroff.h"

#include "cmdamastarter.h"

#include "cmdmultiplewait.h"

#include "cmdcreateswp.h"

#include "cmdpersisthalattributes.h"

#include "cmdfinalisedrives.h"

#include "cmdsetpandskey.h"

#include "cmdwaitforapparcinit.h"

#include "tcmd_runclecmdtest.h"

static const TUint KSwpNullUid = {0};

static const TUint KNewSwpKey = 0xAEAE;

static const TUint KNewSwpKey2 = 0xEAEA;

const TUid KTestPropertyCat={0x1234};

const TUint KTestKey = 678;

const TUid KTestDscId = {0x1234};

const TInt KNumOfRetries = 5;

const TInt KThrottleTime = 10000000; //10s

_LIT(KBadFileName, "c:\\badfile.exe");  //this file does not exist

_LIT(KSlowStartApp, "ssmtestappslow.exe");

_LIT(KEmptyArgs, "");

_LIT(KGoodProc, "ssmtestprocgood.exe");

_LIT(KPolicyFilename, "ssm.swp.policy.test.cmdreqswp");

_LIT(KNoSuchDll, "nosuchdll.dll");

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

typedef TDmTraverseDirection TTestSsmDirection;

TTestSsmDirection testTraverseDefault = ETraverseDefault;

#else //SYMBIAN_ENABLE_SPLIT_HEADERS

typedef TSsmDmTraverseDirection TTestSsmDirection;

TTestSsmDirection testTraverseDefault = ESsmTraverseDefault;

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS

CCmdRunCleTest::CCmdRunCleTest()

    {

    }

CCmdRunCleTest::~CCmdRunCleTest()

    {

    delete iActiveScheduler;

    delete iAsyncStopScheduler;

    delete iStartupProperties;

    iStartupProperties = NULL;

    iSem.Close();

    }

static TInt StopScheduler(TAny* /*aCCmdRunCleTest*/)

    {

    CActiveScheduler::Stop();

    return KErrNone;

    }

TVerdict CCmdRunCleTest::doTestStepPreambleL()

    {

    iStartupProperties = CSsmStartupProperties::NewL();

    INFO_PRINTF1(_L("Starting scheduler..."));

    iActiveScheduler = new(ELeave) CActiveScheduler;

    CActiveScheduler::Install( iActiveScheduler );

    iAsyncStopScheduler = new(ELeave) CAsyncCallBack(CActive::EPriorityIdle);

    TCallBack stop(StopScheduler, this);

    iAsyncStopScheduler->Set(stop);

    return CTestStep::doTestStepPreambleL();

    }

TVerdict CCmdRunCleTest::doTestStepPostambleL()

    {

    delete iStartupProperties;

    iStartupProperties = NULL;

    return CTestStep::doTestStepPostambleL();

    }

TVerdict CCmdRunCleTest::doTestStepL()

    {

    __UHEAP_MARK;

    TRAPD(err, doTestRunClePublishSwpL());

    TEST(err == KErrNone);

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAP(err, doTestRunCleCustomCommandL());

    TEST(err == KErrNone);

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAP(err, doTestRunCleCmdLoadSupL());

    TEST(err ==  KErrNone);

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAP(err, doTestRunCleCmdpublishSystemStateL());

    TEST(err ==  KErrNone);

    __UHEAP_MARKEND;

    __UHEAP_MARK;

       TRAP(err,  doTestRunCmdCreateSwpL());

       TEST(err ==  KErrNone);

   __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAP(err, doTestRunCleCcmdreqSwpchangeL());

    TEST(err ==  KErrNone);

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAP(err, doTestRunCleCmdAmaStarterL());

    TEST(err ==  KErrNone);

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAP(err, doTesTRunCleCmdMultipleWaitL());

    TEST(err ==  KErrNone);

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAP(err, doTestRunCmdPowerOffL());

    TEST(err ==  KErrNone);

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAP(err,  doTestRunCleCmdStartAppL());

    TEST(err ==  KErrNone);

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAP(err,  doTestRunCleCmdStartProcessL());

    TEST(err ==  KErrNone);

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAP(err,  doTestRunCleCmdPersistHalAttributesL());

    TEST(err ==  KErrNone);

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAP(err, doTestRunCleCmdFinaliseDrivesL());

    TEST(err ==  KErrNone);

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAP(err,  doTestRunCleCmdSetPAndSKeyL());

    TEST(err ==  KErrNone);

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAP(err,  doTestRunCleCmdWaitForApparcInitL());

    TEST(err ==  KErrNone);

    __UHEAP_MARKEND;

    err = iSem.CreateGlobal(KStartAppSignalSemaphore, 0);

    INFO_PRINTF2(_L("Created semaphore with err %d"),err);

    __UHEAP_MARK;

    TRAP(err, doTestRunCleFandFAppWithMonitorL());

    TEST(err ==  KErrNone);

    __UHEAP_MARKEND;

    iSem.Close();

    err = iSem.CreateGlobal(KStartProcSignalSemaphore, 0);

    INFO_PRINTF2(_L("Created semaphore with err %d"),err);

    TEST(err == KErrNone);

    __UHEAP_MARK;

    TRAP(err,  doTestRunCleFandFProcWithMonitorL());

    TEST(err ==  KErrNone);

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    TRAP(err, doTestRunCleFandFAlreadyRunWithMonitorL());

    TEST(err ==  KErrNone);

    __UHEAP_MARKEND;

   iSem.Close();

   return TestStepResult();

   }

//create cle server in separate thread within the Test server process

TInt CCmdRunCleTest::RunTestWithCleAndWaitL(MSsmCommand* aCommand, TBool aMultipleWait)

    {

    _LIT(KCleSrver, "TestCleSrv");

    RCleSession cleSession;// CLE session to execute commands

    CleanupClosePushL(cleSession);

    cleSession.ConnectL(KCleSrver);

    CSsmCommandList* iCmdList = CSsmCommandList::NewL();

    CleanupStack::PushL(iCmdList);

    iCmdList->AppendL(aCommand);

    if(aMultipleWait)

        {

        TInt32 timeout = 10000;

        CCmdMultipleWait* iCmd = CCmdMultipleWait::NewL(timeout);

        CleanupStack::PushL(iCmd);

        iCmdList->AppendL(iCmd);

        CleanupStack::Pop(iCmd);

        }

    //run engine, stop when there are no further transition

    iAsyncStopScheduler->CallBack();

    iActiveScheduler->Start();

    TRequestStatus trs;

    TCmdErrorSeverity severity;

    cleSession.ExecuteCommandList(*iCmdList, trs, severity);

    INFO_PRINTF1(_L("Waiting for syscle command to finish..."));

    User::WaitForRequest(trs);

    CleanupStack::PopAndDestroy(iCmdList);

    CleanupStack::PopAndDestroy();//for cle session

    return trs.Int();

    }

void CCmdRunCleTest::doTestRunCleCmdWaitForApparcInitL()

    {

    TInt expectedErr = KErrNone;    

    TCmdErrorSeverity severity = ECmdIgnoreFailure;

    INFO_PRINTF1(_L("doTestRunCleCmdWaitForApparcInitL, severity:ECmdIgnoreFailure"));

    iCmd = CCmdWaitForApparcInit::NewL(severity);

    TInt err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL;

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    severity = ECmdCriticalSeverity;

    INFO_PRINTF1(_L("doTestRunCleCmdWaitForApparcInitL, severity:ECmdCriticalSeverity"));

    iCmd = CCmdWaitForApparcInit::NewL(severity);

    err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL;

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    }

void CCmdRunCleTest::doTestRunCleCmdSetPAndSKeyL()

    {

    TInt expectedErr = KErrNone;    

    TCmdErrorSeverity severity = ECmdIgnoreFailure;

    TInt actualValue;

    INFO_PRINTF1(_L("doTestRunCleCmdSetPAndSKeyL, severity:ECmdIgnoreFailure"));

    iCmd = CCmdSetPAndSKey::NewL(severity, KTestPropertyCat, KTestKey, 589);

    TInt err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL;

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    TEST(err == expectedErr);

    err = RProperty::Get(KTestPropertyCat,KTestKey,actualValue);

    TEST(actualValue == 589);

    severity = ECmdCriticalSeverity;

    INFO_PRINTF1(_L("doTestRunCleCmdSetPAndSKeyL, severity:ECmdCriticalSeverity"));

    iCmd = CCmdSetPAndSKey::NewL(severity, KTestPropertyCat, KTestKey, 589);

    err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL;

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    TEST(actualValue == 589);

    TEST(err == expectedErr);

    err = err = RProperty::Get(KTestPropertyCat,KTestKey,actualValue);

    TEST(actualValue == 589);

    }

void CCmdRunCleTest::doTestRunCleCmdFinaliseDrivesL()

    {

    TInt expectedErr = KErrNone;    

    TCmdErrorSeverity severity = ECmdIgnoreFailure;

    INFO_PRINTF1(_L("doTestRunCleCmdFinaliseDrivesL, severity:ECmdIgnoreFailure"));

    iCmd = CCmdFinaliseDrives::NewL(severity);

    TInt err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL;

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    severity = ECmdCriticalSeverity;

    INFO_PRINTF1(_L("doTestRunCleCmdFinaliseDrivesL, severity:ECmdCriticalSeverity"));

    iCmd = CCmdFinaliseDrives::NewL(severity);

    err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL;

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    }

void CCmdRunCleTest::doTestRunCleCmdPersistHalAttributesL()

    {

    TInt expectedErr = KErrNone;    

    TCmdErrorSeverity severity = ECmdIgnoreFailure;

    INFO_PRINTF1(_L("doTestRunCleCmdPersistHalAttributesL, severity:ECmdIgnoreFailure"));

    iCmd = CCmdPersistHalAttributes::NewL(severity);

    TInt err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL;

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    severity = ECmdCriticalSeverity;

    INFO_PRINTF1(_L("doTestRunCleCmdPersistHalAttributesL, severity:ECmdCriticalSeverity"));

    iCmd = CCmdPersistHalAttributes::NewL(severity);

    err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL;

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    }

void CCmdRunCleTest::doTestRunCmdCreateSwpL()

    {

    TInt expectedType = ESsmCmdCreateSwp;

    TInt expectedErr = KErrNone;    

    TCmdErrorSeverity severity = ECmdIgnoreFailure;

    TSsmSwp swpInfo(KNewSwpKey, 876);

    TPtrC filename = KPolicyFilename();

    INFO_PRINTF1(_L("doTestRunCmdCreateSwpL, severity:ECmdIgnoreFailure"));

    iCmd = CCmdCreateSwp::NewL(severity, swpInfo, filename);

    TEST(iCmd->Type() == expectedType);

    TInt err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL;

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    severity = ECmdCriticalSeverity;

    swpInfo.Set(KNewSwpKey2, 767);

    INFO_PRINTF1(_L("doTestRunCmdCreateSwpL, severity:ECmdCriticalSeverity"));

    iCmd = CCmdCreateSwp::NewL(severity, swpInfo, filename);

    TEST(iCmd->Type() == expectedType);

    err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL;

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    }

void CCmdRunCleTest::doTestRunCmdPowerOffL()

    {

    TCmdErrorSeverity severity = ECmdIgnoreFailure;

    TInt err = KErrNone;

    TInt expectedErr = KErrNone;

    TPowerState powerEvent = EPwActive;

    INFO_PRINTF1(_L("doTestRunCmdPowerOffL, severity:ECmdIgnoreFailure, powerEvent:EPwActive"));

    iCmd = CCmdPowerOff::NewL(severity, powerEvent);

    err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL;    //ownership of iCmd is with Cle server

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    TEST(err == expectedErr);

    severity = ECmdCriticalSeverity;

    INFO_PRINTF1(_L("doTestRunCmdPowerOffL, severity:ECmdCriticalSeverity, powerEvent:EPwActive"));

    iCmd = CCmdPowerOff::NewL(severity, powerEvent);

    err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL;    //ownership of iCmd is with Cle server

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, KErrArgument);

    TEST(err == expectedErr | KErrArgument);//we are not testing the power event functionality 

    }

void CCmdRunCleTest::doTesTRunCleCmdMultipleWaitL()

    {

    TInt err = KErrNone;

    TInt expectedErr = KErrNone;

    TCmdErrorSeverity severity = ECmdIgnoreFailure;

    TBool multipleWait = TRUE;

    INFO_PRINTF1(_L("doTesTRunCleCmdMultipleWaitL, Test:ESsmDeferredWaitForSignal, severity:ECmdIgnoreFailure"));

    SetStartupPropertiesL(KBadFileName, KEmptyArgs, ESsmDeferredWaitForSignal, ESsmCmdStartApp);

    iCmd = CCmdStartApp::NewL(severity,iStartupProperties);

    err = RunTestWithCleAndWaitL(iCmd,multipleWait);

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    TEST(err == expectedErr);

    Reset();

    iCmd = NULL; //ownership of iCmd is with Cle server

    TEST(err == expectedErr);

    }

void CCmdRunCleTest::doTestRunCleCmdAmaStarterL()

    {

    TInt expectedErr = KErrNone;

    TCmdErrorSeverity severity = ECmdIgnoreFailure;

    INFO_PRINTF1(_L("doTestRunCleCmdAmaStarterL, Test:ESsmFireAndForget, severity:ECmdIgnoreFailure"));

    iCmd = CCmdAmaStarter::NewL(severity, ESsmFireAndForget, KTestDscId);

    TInt err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL; //ownership of iCmd is with Cle server

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    TEST(err == expectedErr);

    severity = ECmdCriticalSeverity;

    INFO_PRINTF1(_L("doTestRunCleCmdAmaStarterL, Test:ESsmFireAndForget, severity:ECmdCriticalSeverity"));

    iCmd = CCmdAmaStarter::NewL(severity, ESsmFireAndForget, KTestDscId);

    err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL; //ownership of iCmd is with Cle server

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    TEST(err == expectedErr);

    }

void CCmdRunCleTest::doTestRunClePublishSwpL()

    {

    TInt expectedErr = KErrNone;

    TCmdErrorSeverity severity = ECmdIgnoreFailure;

    TSsmSwp info(KSwpNullUid, 0);

    INFO_PRINTF1(_L("doTestRunClePublishSwp, Test:ESsmFireAndForget, severity:ECmdIgnoreFailure"));

    iCmd = CCmdPublishSwp::NewL(severity, ESsmFireAndForget, info);

    TInt err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL; //ownership of iCmd is with Cle server 

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    TEST(err == expectedErr);

    severity = ECmdCriticalSeverity;

    INFO_PRINTF1(_L("doTestRunClePublishSwp, Test:ESsmFireAndForget, severity:ECmdCriticalSeverity"));

    iCmd = CCmdPublishSwp::NewL(severity, ESsmFireAndForget, info);

    err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL; //ownership of iCmd is with Cle server

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    TEST(err == expectedErr);

    severity = ECmdHighSeverity;

    TSsmSwp info2(KNewSwpKey, 789);

    INFO_PRINTF1(_L("doTestRunClePublishSwp, Test:ESsmFireAndForget, severity:ECmdHighSeverity"));

    iCmd = CCmdPublishSwp::NewL(severity, ESsmFireAndForget, info2);

    err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL; //ownership of iCmd is with Cle server

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    TEST(err == expectedErr);

    }

void CCmdRunCleTest::doTestRunCleCustomCommandL()

    {

    TInt expectedErr = KErrNone;

    TCmdErrorSeverity severity = ECmdIgnoreFailure;

    TPtrC filename = KNoSuchDll();

    TInt32 ordinal = 1;

    TPtrC8 params = KNullDesC8();

    TCmdCustomCommandLibUnloading unloading = EUnloadOnCommandCompletion;

    CSsmCustomCommandInfo* info = new (ELeave) CSsmCustomCommandInfo();

    CleanupStack::PushL(info);

    info->SetL(filename, ordinal, unloading, KNumOfRetries, params);

    INFO_PRINTF1(_L("doTestRunCleCustomCommand, Test:ESsmFireAndForget, severity:ECmdIgnoreFailure"));

    iCmd = CCmdCustomCommand::NewL(severity, ESsmFireAndForget, *info);

    TInt err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL; //ownership of iCmd is with Cle server 

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    TEST(err == expectedErr);

    severity = ECmdCriticalSeverity;

    INFO_PRINTF1(_L("doTestRunCleCustomCommand, Test:ESsmFireAndForget, severity:ECmdCriticalSeverity"));

    iCmd = CCmdCustomCommand::NewL(severity, ESsmFireAndForget, *info);

    err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL; //ownership of iCmd is with Cle server

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    TEST(err == expectedErr);

    severity = ECmdHighSeverity;

    INFO_PRINTF1(_L("doTestRunCleCustomCommand, Test:ESsmFireAndForget, severity:ECmdHighSeverity"));

    iCmd = CCmdCustomCommand::NewL(severity, ESsmFireAndForget, *info);

    err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL; //ownership of iCmd is with Cle server

    CleanupStack::PopAndDestroy(info);

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    TEST(err == expectedErr);

    }

void CCmdRunCleTest::doTestRunCleCmdLoadSupL()

    {

    TInt err = KErrNone;    

    TInt expectedErr = KErrNone;

    TCmdErrorSeverity severity = ECmdIgnoreFailure;

    TUid uid;

    uid.iUid = 0;

    TInt32 ordinal = 1;

    TSsmSupInfo info;

    _LIT(KFileName, "tiCmdgoodsup.dll");

    info.SetL(KFileName, ordinal, uid);

    INFO_PRINTF1(_L("doTestRunCleiCmdLoadSup, Test:ESsmFireAndForget, severity:ECmdIgnoreFailure"));

    iCmd = CCmdLoadSup::NewL(severity, ESsmFireAndForget, KNumOfRetries, info);

    err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL;//ownership of iCmd is with Cle server

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    TEST(err == expectedErr);

    severity = ECmdCriticalSeverity;

    INFO_PRINTF1(_L("doTestRunCleiCmdLoadSup, Test:ESsmFireAndForget, severity:ECmdCriticalSeverity"));

    iCmd = CCmdLoadSup::NewL(severity, ESsmFireAndForget, KNumOfRetries, info);

    err = RunTestWithCleAndWaitL(iCmd);

    iCmd = NULL;//ownership of iCmd is with Cle server

    INFO_PRINTF3(_L("Command execution finished with error : %d, expectedErr : %d. "), err, expectedErr);

    TEST(err == expectedErr);

    }

void CCmdRunCleTest::doTestRunCleCmdpublishSystemStateL()

    {

    TInt err = KErrNone;

    TInt expectedErr = KErrNone;

    TCmdErrorSeverity severity = ECmdIgnoreFailure;

    TSsmPublishSystemStateInfo info;

    TSsmState state(ESsmEmergencyCallsOnly, 0);