// Copyright (c) 2008-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 PositionerTestStep.cpp

 @internalTechnology

*/

#include "positionerteststep.h"

#include "te_locsrvsuitedefs.h"

CPositionerTestStep::~CPositionerTestStep()

/**

 * Destructor

 */

	{

	}

CPositionerTestStep::CPositionerTestStep()

/**

 * Constructor

 */

	{

	SetTestStepName(KPositionerTestStep);

	}

TVerdict CPositionerTestStep::doTestStepPreambleL()

/**

 * @return - TVerdict code

 * Override of base class virtual

 */

	{

	CTe_locsrvSuiteStepBase::doTestStepPreambleL();

	SetTestStepResult(EPass);

	return TestStepResult();

	}

TVerdict CPositionerTestStep::doTestStepL()

/**

 * @return - TVerdict code

 * Override of base class pure virtual

 * Our implementation only gets called if the base class doTestStepPreambleL() did

 * not leave. That being the case, the current test result value will be EPass.

 */

	{

	if (TestStepResult()==EPass)

	    {

	    TInt testIndex = KErrNotFound;

	    if(!GetIntFromConfig(ConfigSection(),KTe_locsrvSuiteInt,testIndex))

	        {

	        User::Leave(KErrNotFound);

	        }

	    else

	        {

	        TestByIndexL(testIndex);

	        }

	    }

	return TestStepResult();

	}

void CPositionerTestStep::TestByIndexL(TInt aIndex)

    {

    switch (aIndex)

        {

        case 0: 

            _LIT(KTestName0, "All Open Close");

            INFO_PRINTF1(KTestName0);

            TdLocSrv_Positioner_All_Open_CloseL();

            break;

        case 1: 

            _LIT(KTestName1, "Open No Connection");

            INFO_PRINTF1(KTestName1);

            TdLocSrv_Positioner_Open_No_ConnectionL();

            break;

        case 2: 

            _LIT(KTestName2, "Open Twice");

            INFO_PRINTF1(KTestName2);

            TdLocSrv_Positioner_Open_TwiceL();

            break;

        case 3: 

            _LIT(KTestName3, "Request Before Open");

            INFO_PRINTF1(KTestName3);

            TdLocSrv_Positioner_Request_before_OpenL();

            break;

        case 4: 

            _LIT(KTestName4, "Close No Open");

            INFO_PRINTF1(KTestName4);

            TdLocSrv_Positioner_Close_No_OpenL();

            break;

        case 5: 

            _LIT(KTestName5, "Open Specific Module");

            INFO_PRINTF1(KTestName5);

            TdLocSrv_Positioner_Open_Specific_ModuleL();

            break;

        case 6: 

            _LIT(KTestName6, "Open Bad Module");

            INFO_PRINTF1(KTestName6);

            TdLocSrv_Positioner_Open_Bad_ModuleL();

            break;

        case 7: 

            _LIT(KTestName7, "No Requestor");

            INFO_PRINTF1(KTestName7);

            TdLocSrv_Positioner_No_RequestorL();

            break;

        case 8: 

            _LIT(KTestName8, "Requestor");

            INFO_PRINTF1(KTestName8);

            TdLocSrv_Positioner_RequestorL();

            break;

        case 9: 

            break;

        case 10: 

            _LIT(KTestName10, "Set GetUpdateOptions");

            INFO_PRINTF1(KTestName10);

            TdLocSrv_Positioner_Set_GetUpdateOptionsL();

            break;

        case 11: 

            _LIT(KTestName11, "Close With Requests");

            INFO_PRINTF1(KTestName11);

            TdLocSrv_Positioner_Close_With_RequestsL();

            break;

        case 12: 

            _LIT(KTestName12, "Double NotifyPositionUpdate");

            INFO_PRINTF1(KTestName12);

            TdLocSrv_Positioner_Double_NotifyPositionUpdateL();

            break;

        case 13: 

            _LIT(KTestName13, "Double CancelRequest");

            INFO_PRINTF1(KTestName13);

            TdLocSrv_Positioner_Double_CancelRequestL();

            break;

        case 14: 

            break;

        case 15: 

            break;

        case 16: 

            _LIT(KTestName16, "NotifyPositionUpdate Standard");

            INFO_PRINTF1(KTestName16);

            TdLocSrv_Positioner_NotifyPositionUpdate_StandardL();

            break;

        case 17: 

            _LIT(KTestName17, "NotifyPositionUpdate Generic");

            INFO_PRINTF1(KTestName17);

            TdLocSrv_Positioner_NotifyPositionUpdate_GenericL();

            break;

        case 18: 

            _LIT(KTestName18, "NotifyPositionUpdate Extended Support");

            INFO_PRINTF1(KTestName18);

            TdLocSrv_Positioner_NotifyPositionUpdate_Extended_SupportL();

            break;

        case 19: 

            _LIT(KTestName19, "NotifyPositionUpdate Extended Unsupported");

            INFO_PRINTF1(KTestName19);

            TdLocSrv_Positioner_NotifyPositionUpdate_Extended_UnsupportedL();

            break;

        case 20: 

            _LIT(KTestName20, "Tracking Session");

            INFO_PRINTF1(KTestName20);

            TdLocSrv_Positioner_Tracking_SessionL();

            break;

        case 21: 

            _LIT(KTestName21, "Tracking Session Changing");

            INFO_PRINTF1(KTestName21);

            TdLocSrv_Positioner_Tracking_Session_ChangingL();

            break;

        case 22: 

            _LIT(KTestName22, "Cancel Tracking Session");

            INFO_PRINTF1(KTestName22);

            TdLocSrv_Positioner_Cancel_Tracking_SessionL();

            break;

        case 23: 

            _LIT(KTestName23, "Module DisabledEnabled");

            INFO_PRINTF1(KTestName23);

            TdLocSrv_Positioner_ModuleDisabledEnabledL();

            break;

        case 24: 

            _LIT(KTestName24, "Open No Modules");

            INFO_PRINTF1(KTestName24);

            TdLocSrv_Positioner_Open_No_ModulesL();

            break;

        default: 

            _LIT(KTestName25, "This test step doesn't exist");

            ERR_PRINTF1(KTestName25);

            SetTestStepResult(EFail);

            break;

        }

    }

TVerdict CPositionerTestStep::doTestStepPostambleL()

/**

 * @return - TVerdict code

 * Override of base class virtual

 */

	{

	return TestStepResult();

	}

extern TInt SetAuthenticRequestor(RPositioner& aPositioner);

HPositionGenericInfo* CreatePSY6DelayInstructionC(TTimeIntervalMicroSeconds aDelay)

{

    HPositionGenericInfo* genInfo = HPositionGenericInfo::NewLC();

    genInfo->SetRequestedField(KPSY6FieldDelayProcessing);

    genInfo->SetValue(KPSY6FieldDelayProcessing, aDelay);

    return genInfo;

}

extern TBool RequestTimedOut(TRequestStatus&, TUint);

//

// 

// RPositioner

//

//  Open/Close a connection

//

//

// 1.10.1 All Opens

TVerdict CPositionerTestStep::TdLocSrv_Positioner_All_Open_CloseL()

{

    StandardPrepareL();

    // Try different open methods (from server, from positioner, etc.)

    RPositionServer server;

    User::LeaveIfError(server.Connect());

    CleanupClosePushL(server);

    RPositioner positioner;

    CheckExpectedResult(0, positioner.SubSessionHandle()); // initial state

    CleanupClosePushL(positioner);

    // No params

    CheckExpectedResult(KErrNone, positioner.Open(server));

    CheckResult(0 < positioner.SubSessionHandle());

    positioner.Close();

    CheckExpectedResult(0, positioner.SubSessionHandle());

    // By ModuleID

    TPositionModuleId moduleId;

    moduleId.iUid = DUMMY_MODULE_ID1;

    CheckExpectedResult(KErrNone, positioner.Open(server, moduleId));

    CheckResult(0 < positioner.SubSessionHandle());

    positioner.Close();

    CheckExpectedResult(0, positioner.SubSessionHandle());

    // With Criteria

    TPositionCriteria requiredPosCriteria;

#if _CRITERIA_IMPLEMENTED_ || _TEST_SERVER_

    CheckExpectedResult(KErrNone, positioner.Open(server, requiredPosCriteria));

    CheckResult(0 < positioner.SubSessionHandle());

#else

    TInt res = positioner.Open(server, requiredPosCriteria);

    CheckExpectedResult(res, KErrNotFound, KWrongOpenByCriteriaResult);

    CheckResult(0 == positioner.SubSessionHandle());

#endif

    positioner.Close();

    CheckExpectedResult(0, positioner.SubSessionHandle());

    CleanupStack::PopAndDestroy(2, &server);

    return TestStepResult();

}

// 1.10.2 Open w/o connection

TInt RPositioner_Open_No_Connection_Default(TAny* /*aPtr*/)

{

    RPositionServer server;

    RPositioner positioner;

    positioner.Open(server);  // this should panic

    return KErrGeneral;

}

TInt RPositioner_Open_No_Connection_ModuleId(TAny* /*aPtr*/)

{

    RPositionServer server;

    RPositioner positioner;

    TPositionModuleId moduleId;

    moduleId.iUid = DUMMY_MODULE_ID1;

    positioner.Open(server, moduleId);  // this should panic

    return KErrGeneral;

}

TInt RPositioner_Open_No_Connection_Criteria(TAny* /*aPtr*/)

{

    RPositionServer server;

    RPositioner positioner;

    TPositionCriteria criteria;

    criteria.ResetCriteria(); // defaults

    positioner.Open(server, criteria);  // this should panic

    return KErrGeneral; // or this :-)

}

TVerdict CPositionerTestStep::TdLocSrv_Positioner_Open_No_ConnectionL()

{

    // default open

    DO_PANIC_TEST_L(

            RPositioner_Open_No_Connection_Default, 

            KPosClientFault,

            EPositionServerBadHandle, 

            KDefaultTestTimeout);

    // open by module id

    DO_PANIC_TEST_L(

            RPositioner_Open_No_Connection_ModuleId, 

            KPosClientFault,

            EPositionServerBadHandle, 

            KDefaultTestTimeout);

    // open by criteria

    DO_PANIC_TEST_L(

            RPositioner_Open_No_Connection_Criteria, 

            KPosClientFault,

            EPositionServerBadHandle, 

            KDefaultTestTimeout);

    return TestStepResult();

}

// 1.10.3 Double Open

TInt OpenRPositionerTwice(TAny* /*aPtr*/)

{

    RPositionServer server;

    User::LeaveIfError(server.Connect());

    CleanupClosePushL(server);

    RPositioner positioner;

    User::LeaveIfError(positioner.Open(server));

    CleanupClosePushL(positioner);

    positioner.Open(server);    //Should panic.

    CleanupStack::PopAndDestroy(2, &server);

    return KErrGeneral;

}

TVerdict CPositionerTestStep::TdLocSrv_Positioner_Open_TwiceL()

{

    DO_PANIC_TEST_L(OpenRPositionerTwice, KPosClientFault, 

                    EPositionServerHandleNotClosed, KDefaultTestTimeout);

    return TestStepResult();

}

// 1.10.4 Restricted calls before Open

TInt Close_Before_Open(TAny* /*aPtr*/)

{

    RPositioner positioner;

    positioner.Close();

    return KErrGeneral;

}

TInt CancelRequest_Before_Open(TAny* /*aPtr*/)

{

    RPositioner positioner;

    positioner.CancelRequest(0);

    return KErrGeneral;

}

TInt SetRequestor_Before_Open(TAny* /*aPtr*/)

{

    RPositioner positioner;

    SetAuthenticRequestor(positioner);

    return KErrGeneral;

}

TInt SetRequestors_Before_Open(TAny* /*aPtr*/)

{

    RPositioner positioner;

    RRequestorStack requestors;

    positioner.SetRequestor(requestors);

    return KErrGeneral;

}

TInt SetUpdateOptions_Before_Open(TAny* /*aPtr*/)

{

    RPositioner positioner;

    TPositionUpdateOptions options;

    positioner.SetUpdateOptions(options);

    return KErrGeneral;

}

TInt GetUpdateOptions_Before_Open(TAny* /*aPtr*/)

{

    RPositioner positioner;

    TPositionUpdateOptions options;

    positioner.GetUpdateOptions(options);

    return KErrGeneral;

}

TInt GetLastKnownPosition_Before_Open(TAny* /*aPtr*/)

{

    RPositioner positioner;

    TRequestStatus request;

    TPositionInfo posInfo;

    positioner.GetLastKnownPosition(posInfo, request);

    return KErrGeneral;

}

TInt NotifyPositionUpdate_Before_Open(TAny* /*aPtr*/)

{

    RPositioner positioner;

    TRequestStatus request;

    TPositionInfo posInfo;

    positioner.NotifyPositionUpdate(posInfo, request);

    return KErrGeneral;

}

TVerdict CPositionerTestStep::TdLocSrv_Positioner_Request_before_OpenL()

{

    DO_PANIC_TEST_L(CancelRequest_Before_Open, KPosClientFault, 

                    EPositionServerBadHandle, KDefaultTestTimeout);

    DO_PANIC_TEST_L(SetRequestor_Before_Open, KPosClientFault, 

                    EPositionServerBadHandle, KDefaultTestTimeout);

    DO_PANIC_TEST_L(SetRequestor_Before_Open, KPosClientFault, 

                    EPositionServerBadHandle, KDefaultTestTimeout);

    DO_PANIC_TEST_L(SetUpdateOptions_Before_Open, KPosClientFault, 

                    EPositionServerBadHandle, KDefaultTestTimeout);

    DO_PANIC_TEST_L(GetUpdateOptions_Before_Open, KPosClientFault, 

                    EPositionServerBadHandle, KDefaultTestTimeout);

    DO_PANIC_TEST_L(GetLastKnownPosition_Before_Open, KPosClientFault, 

                    EPositionServerBadHandle, KDefaultTestTimeout);

    DO_PANIC_TEST_L(NotifyPositionUpdate_Before_Open, KPosClientFault, 

                    EPositionServerBadHandle, KDefaultTestTimeout);

    return TestStepResult();

}

// 1.10.5 Close w/o Open

TVerdict CPositionerTestStep::TdLocSrv_Positioner_Close_No_OpenL()

{

    RPositioner positioner;

    positioner.Close();

    return TestStepResult();

}

// 1.10.6 Open when no modules exist

TVerdict CPositionerTestStep::TdLocSrv_Positioner_Open_No_ModulesL()

{

    StandardPrepareL();

    RPositionServer server;

    User::LeaveIfError(server.Connect());

    CleanupClosePushL(server);

    // 1. save list of enabled psys

    CPosModules* modules = CPosModules::OpenL();

    CleanupStack::PushL(modules);

    RArray<TPositionModuleId> enabledPsys;

    CPosModuleIdList* idList = modules->ModuleIdListLC();

    for (TInt i = 0; i < idList->Count(); i++)

        {

        TPositionModuleInfo info;

        modules->GetModuleInfoL((*idList)[i], info);

        if (info.IsAvailable())

            {

            enabledPsys.AppendL(info.ModuleId());

            }

        }

    // 2. Disable all PSYs and try to open connection

    TRequestStatus status;

    TPositionInfo posInfo;

    DisableAllModulesL();

    RPositioner positioner;

    CleanupClosePushL(positioner);

    // specific PSYs

    for (TInt i = 0; i < idList->Count(); i++)

        {

        CheckExpectedResult(KErrNotFound, positioner.Open(server, (*idList)[i]));

        }

    // default proxy

    CheckExpectedResult(KErrNone, positioner.Open(server));

    SetAuthenticRequestor(positioner);

    // return value from Default Proxy

    positioner.NotifyPositionUpdate(posInfo, status);

    User::WaitForRequest(status);

    CheckExpectedResult(status.Int(), KErrNotFound, KWrongErrorCode);

    // return value from Server

    positioner.GetLastKnownPosition(posInfo, status);

    User::WaitForRequest(status);

    if (status.Int() != KErrNone && status.Int() != KErrUnknown)

        {

        ERR_PRINTF1(KWrongErrorCode);

        SetTestStepResult(EFail);

        }

    // 3. Restore PSYs

    CPosModuleUpdate* update = CPosModuleUpdate::NewLC();

    update->SetUpdateAvailability(ETrue);

    for (TInt i = 0; i < enabledPsys.Count(); i++)

        {

        modules->UpdateModuleL(enabledPsys[i], *update);

        }

    enabledPsys.Close();

    CleanupStack::PopAndDestroy(5, &server);

    return TestStepResult();

}

// 1.10.7 Open with No Memory

// See NoMemoryTests.cpp

//

// 

// RPositioner

//

//  Module Selection

//

//