// 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 NoServerStep.cpp
 @internalTechnology
*/
#include "noserverstep.h"
#include "te_lbsapisuitedefs.h"

#include "lcfsbucommondefinitions.h"

#include <lbs.h>
#include <lbssatellite.h>
#include <e32math.h>
#include <s32mem.h>
#include <bautils.h>

CNoServerStep::~CNoServerStep()
/**
 * Destructor
 */
	{
	}

CNoServerStep::CNoServerStep()
/**
 * Constructor
 */
	{
	// **MUST** call SetTestStepName in the constructor as the controlling
	// framework uses the test step name immediately following construction to set
	// up the step's unique logging ID.
	SetTestStepName(KNoServerStep);
	}

TVerdict CNoServerStep::doTestStepPreambleL()
/**
 * @return - TVerdict code
 * Override of base class virtual
 */
	{
	 CTe_LbsApiSuiteStepBase::doTestStepPreambleL();
	 if (TestStepResult()!=EPass)
	    return   TestStepResult();
	// process some pre setting to this test step then set SetTestStepResult to EFail or Epass.
	SetTestStepResult(EPass);
	return TestStepResult();
	}


TVerdict CNoServerStep::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 test;
		if(!GetIntFromConfig(ConfigSection(),KTe_LbsApiSuiteInt,test)
			)
			{
			// Leave if there's any error.
			User::Leave(KErrNotFound);
			}
		SetTestStepResult(EPass);
		StartL(test);
		}
	  return TestStepResult();
	}



TVerdict CNoServerStep::doTestStepPostambleL()
/**
 * @return - TVerdict code
 * Override of base class virtual
 */
	{
	// process something post setting to the test step
	// uncomment the following line if you have common post setting to all the test steps in there
	// CTe_LbsApiSuiteStepBase::doTestStepPostambleL();
	// uncomment the following line if you have post process or remove the following line if no post process
	// SetTestStepResult(EPass);		// or EFail
	return TestStepResult();
	}


void CNoServerStep::StartL (TInt aIndex)
	{
	switch (aIndex)
		{
	case 0:
		RPositionServer_NoConnectionL ();
		break;
	case 1:
		RPositionServer_NoL ();
		break;
	case 2:
		RPositioner_NoL ();
		break;
	default:
		break;
		}
	}

void CNoServerStep::CheckThereIsNoServerL()
    {
    DECLARE_ERROR_LOGGING;
    
    RPositionServer server;
    CleanupClosePushL(server);
    FAIL(server.Connect() == KErrNone, 
        "Location Server must be deleted to run this test case");
        
    CleanupStack::PopAndDestroy(&server);
    }


// 1.1.2 Connect but server doesn't start
// The test must be started when there is no server
// See LBSAPIACCTESTNOSVR.BAT for details
void CNoServerStep::RPositionServer_NoConnectionL()
	{
    DECLARE_ERROR_LOGGING;
    StandardPrepareL();
    CheckThereIsNoServerL();
    
    RPositionServer server;

    __UHEAP_MARK;
    CHECK( 0 == server.Handle() );
    CHECK( KErrNone != server.Connect() );
    CHECK( server.Handle() == 0 );
    __UHEAP_MARKEND;

    StandardCleanup();
	}

// x.x.x Connect and try to execute RPositionServer methods
// This should fail with panic

TInt No_Server_GetDefaultModuleId(TAny* /*aPtr*/)
    {
    RPositionServer server;
    TPositionModuleId moduleId = KPositionNullModuleId;
    server.GetDefaultModuleId(moduleId);
    return KErrGeneral;
    }


TInt No_Server_GetNumModules(TAny* /*aPtr*/)
    {
    RPositionServer server;
    TUint numModules;
    server.GetNumModules(numModules);
    return KErrGeneral;
    }


TInt No_Server_GetModuleInfoByIndex(TAny* /*aPtr*/)
    {
    RPositionServer server;
    TUint index = 0;
    TPositionModuleInfo info;
    server.GetModuleInfoByIndex(index, info);
    return KErrGeneral;
    }


TInt No_Server_GetModuleInfoById(TAny* /*aPtr*/)
    {
    RPositionServer server;
    TPositionModuleId moduleId = KPositionNullModuleId;
    TPositionModuleInfo info;
    server.GetModuleInfoById(moduleId, info);
    return KErrGeneral;
    }


TInt No_Server_GetModuleStatus(TAny* /*aPtr*/)
    {
    RPositionServer server;
    TPositionModuleStatus moduleStatus;
    TPositionModuleId moduleId = KPositionNullModuleId;
    server.GetModuleStatus(moduleStatus, moduleId);
    return KErrGeneral;
    }


TInt No_Server_NotifyModuleStatusEvent(TAny* /*aPtr*/)
    {
    RPositionServer server;
    TPositionModuleStatusEvent event;
    TPositionModuleId moduleId = KPositionNullModuleId;
    TRequestStatus request;
    server.NotifyModuleStatusEvent(event, request, moduleId);
    return KErrGeneral;
    }


TInt No_Server_CancelRequest(TAny* /*aPtr*/)
    {
    RPositionServer server;
    server.CancelRequest(EPositionServerNotifyModuleStatusEvent);
    return KErrGeneral;
    }


void CNoServerStep::RPositionServer_NoL()
	{
    DECLARE_ERROR_LOGGING;
    StandardPrepareL();
    CheckThereIsNoServerL();
    
    RPositionServer server;

    CHECK( KErrNone != server.Connect() );
    FAIL( server.Handle() != 0 , "Server found, while should not be");
        
    DO_PANIC_TEST_L(
        No_Server_GetDefaultModuleId,
        KPosClientFault,
        EPositionServerBadHandle,
        KDefaultTestTimeout);
       
    DO_PANIC_TEST_L(
        No_Server_GetNumModules,
        KPosClientFault,
        EPositionServerBadHandle,
        KDefaultTestTimeout);

    DO_PANIC_TEST_L(
        No_Server_GetModuleInfoByIndex,
        KPosClientFault,
        EPositionServerBadHandle,
        KDefaultTestTimeout);

    DO_PANIC_TEST_L(
        No_Server_GetModuleInfoById,
        KPosClientFault,
        EPositionServerBadHandle,
        KDefaultTestTimeout);

    DO_PANIC_TEST_L(
        No_Server_GetModuleStatus,
        KPosClientFault,
        EPositionServerBadHandle,
        KDefaultTestTimeout);

    DO_PANIC_TEST_L(
        No_Server_NotifyModuleStatusEvent,
        KPosClientFault,
        EPositionServerBadHandle,
        KDefaultTestTimeout);

    DO_PANIC_TEST_L(
        No_Server_CancelRequest,
        KPosClientFault,
        EPositionServerBadHandle,
        KDefaultTestTimeout);

    StandardCleanup();
    }


// 9.1.3 Connect and try to execute RPositioner methods
// This should fail with panic

TInt No_Positioner_CancelRequest(TAny* /*aPtr*/)
    {
    RPositionServer server;
    server.Connect();
    
    RPositioner positioner;
    positioner.CancelRequest(EPositionerGetLastKnownPosition);
    return KErrGeneral;
    }


TInt No_Positioner_Open(TAny* /*aPtr*/)
    {
    RPositionServer server;
    server.Connect();
    
    RPositioner positioner;
    positioner.Open(server);
    return KErrGeneral;
    }


TInt No_Positioner_Open_ModuleId(TAny* /*aPtr*/)
    {
    RPositionServer server;
    server.Connect();
    
    TPositionModuleId moduleId = {0x012345678};

    RPositioner positioner;
    positioner.Open(server, moduleId);
    return KErrGeneral;
    }


TInt No_Positioner_Open_Criteria(TAny* /*aPtr*/)
    {
    RPositionServer server;
    server.Connect();
    
    TPositionCriteria crit;
    
    RPositioner positioner;
    positioner.Open(server, crit);
    return KErrGeneral;
    }
    

// Close method should not fail    
TInt No_Positioner_Close(TAny* /*aPtr*/)
    {
    RPositionServer server;
    server.Connect();
    
    RPositioner positioner;
    positioner.Close();
    return KErrNone;
    }


TInt No_Positioner_SetRequestor(TAny* /*aPtr*/)
    {
    RPositionServer server;
    server.Connect();
    
    RPositioner positioner;
    positioner.SetRequestor(0, 0, KNullDesC);
    return KErrGeneral;
    }


TInt No_Positioner_SetRequestor_Stack(TAny* /*aPtr*/)
    {
    RPositionServer server;
    server.Connect();
    
    RRequestorStack stack;
    
    RPositioner positioner;
    positioner.SetRequestor(stack);
    return KErrGeneral;
    }


TInt No_Positioner_SetUpdateOptions(TAny* /*aPtr*/)
    {
    RPositionServer server;
    server.Connect();
    
    TPositionUpdateOptions options;

    RPositioner positioner;
    positioner.SetUpdateOptions(options);
    return KErrGeneral;
    }


TInt No_Positioner_GetUpdateOptions(TAny* /*aPtr*/)
    {
    RPositionServer server;
    server.Connect();
    
    TPositionUpdateOptions options;

    RPositioner positioner;
    positioner.GetUpdateOptions(options);
    return KErrGeneral;
    }


TInt No_Positioner_GetLastKnownPosition(TAny* /*aPtr*/)
    {
    RPositionServer server;
    server.Connect();
    
    TPositionInfo info;
    TRequestStatus status;

    RPositioner positioner;
    positioner.GetLastKnownPosition(info, status);
    return KErrGeneral;
    }


TInt No_Positioner_NotifyPositionUpdate(TAny* /*aPtr*/)
    {
    RPositionServer server;
    server.Connect();
    
    TPositionInfo info;
    TRequestStatus status;

    RPositioner positioner;
    positioner.NotifyPositionUpdate(info, status);
    return KErrGeneral;
    }


void CNoServerStep::RPositioner_NoL()
	{
    DECLARE_ERROR_LOGGING;
    StandardPrepareL();
    CheckThereIsNoServerL();
    
    RPositionServer server;

    CHECK( KErrNone != server.Connect() );
    FAIL( server.Handle() != 0, "Server found, while should not be" );
        
    DO_PANIC_TEST_L(
        No_Positioner_CancelRequest,
        KPosClientFault,
        EPositionServerBadHandle,
        KDefaultTestTimeout);
       
    DO_PANIC_TEST_L(
        No_Positioner_Open,
        KPosClientFault,
        EPositionServerBadHandle,
        KDefaultTestTimeout);

    DO_PANIC_TEST_L(
        No_Positioner_Open_ModuleId,
        KPosClientFault,
        EPositionServerBadHandle,
        KDefaultTestTimeout);

    DO_PANIC_TEST_L(
        No_Positioner_Open_Criteria,
        KPosClientFault,
        EPositionServerBadHandle,
        KDefaultTestTimeout);

    DO_PANIC_TEST_L(
        No_Positioner_Close,
        KNoClientFault,
        KErrNone,
        KDefaultTestTimeout);

    DO_PANIC_TEST_L(
        No_Positioner_SetRequestor,
        KPosClientFault,
        EPositionServerBadHandle,
        KDefaultTestTimeout);

    DO_PANIC_TEST_L(
        No_Positioner_SetRequestor_Stack,
        KPosClientFault,
        EPositionServerBadHandle,
        KDefaultTestTimeout);

    DO_PANIC_TEST_L(
        No_Positioner_SetUpdateOptions,
        KPosClientFault,
        EPositionServerBadHandle,
        KDefaultTestTimeout);

    DO_PANIC_TEST_L(
        No_Positioner_GetUpdateOptions,
        KPosClientFault,
        EPositionServerBadHandle,
        KDefaultTestTimeout);

    DO_PANIC_TEST_L(
        No_Positioner_GetLastKnownPosition,
        KPosClientFault,
        EPositionServerBadHandle,
        KDefaultTestTimeout);

    DO_PANIC_TEST_L(
        No_Positioner_NotifyPositionUpdate,
        KPosClientFault,
        EPositionServerBadHandle,
        KDefaultTestTimeout);

    StandardCleanup();
	}