// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "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:
// @file ctlbsclientstepignoreaccurracysetting.cpp
//
//
#include "ctlbsclientstepignoreaccurracysetting.h"
#include <lbs.h>
#include <lbssatellite.h>
#include <lbsadmin.h>
#include "tlbsutils.h"
#include "ctlbsasyncwaiter.h"
#define EXPECTED_GPS_ACCURACY_HORIZONTAL 10
#define EXPECTED_GPS_ACCURACY_VERTICAL 10
const TTimeIntervalMicroSeconds KModuleTimeout = 5000000;//makes test module time out(which should be more than the Maxtime in lbsprofile.ini)
/**
* Construction.
*/
CT_LbsClientStep_IgnoreAccuracySetting* CT_LbsClientStep_IgnoreAccuracySetting::New(CT_LbsClientServer& aParent)
{
// Note the lack of ELeave.
// This means that having insufficient memory will return NULL;
CT_LbsClientStep_IgnoreAccuracySetting* testStep = new CT_LbsClientStep_IgnoreAccuracySetting(aParent);
if (testStep)
{
TInt err = KErrNone;
TRAP(err, testStep->ConstructL());
if (err)
{
delete testStep;
testStep = NULL;
}
}
return testStep;
}
CT_LbsClientStep_IgnoreAccuracySetting::CT_LbsClientStep_IgnoreAccuracySetting(CT_LbsClientServer& aParent)
: CT_LbsClientStep(aParent), iTestCaseId(0)
{
SetTestStepName(KLbsClientStep_IgnoreAccuracySetting);
}
void CT_LbsClientStep_IgnoreAccuracySetting::ConstructL()
{
// Connect server.
User::LeaveIfError(iServer.Connect());
}
/**
* Destructor
*/
CT_LbsClientStep_IgnoreAccuracySetting::~CT_LbsClientStep_IgnoreAccuracySetting()
{
iPositioner.Close();
CloseNetSim();
iServer.Close();
}
/**
* The set-up for the tests open the net sim, where required (the terminal based
* tests) and open the connection to the server. Also it sets the update options
* for the requests with those in the ini file. RPositioner is open through one
* of the three APIs, depending on the tests
*/
TVerdict CT_LbsClientStep_IgnoreAccuracySetting::doTestStepPreambleL()
{
// Process some common pre setting to test steps then set SetTestStepResult to EFail or Epass.
INFO_PRINTF1(_L(">>CT_LbsClientStep::doTestStepPreambleL()"));
SetTestStepResult(EPass);
T_LbsUtils utils;
if(GetIntFromConfig(ConfigSection(), KTestCaseId, iTestCaseId))
{
switch(iTestCaseId)
{ // open the network simulator for the tests that run in terminal based
case 151: // LBS-IGNORE-ACCURACY-ON-TERMINAL-BASED-001
case 152: // LBS-IGNORE-ACCURACY-ON-TERMINAL-BASED-002
case 153: // LBS-IGNORE-ACCURACY-ON-TERMINAL-BASED-003
{
CloseNetSim();
User::LeaveIfError(OpenNetSim());
break;
}
default:
{
}
}
switch(iTestCaseId)
{ // open the positioner for the tests that are doing a position update
// the positioner is opened through the required API for each test
case 1: // LBS-IGNORE-ACCURACY-ENABLED-001
case 2: // LBS-IGNORE-ACCURACY-DISABLED-001
{ // do nothing, these tests don't ask for a position update
break;
}
case 3: // LBS-IGNORE-ACCURACY-ABSENT-001
case 101: // LBS-MOLR-IGNORE-ACCURACY-ON-ACCURATE-001
case 104: // LBS-MOLR-IGNORE-ACCURACY-ON-INACCURATE-001
case 107: // LBS-MOLR-IGNORE-ACCURACY-ON-TIMEOUT-001
case 110: // LBS-IGNORE-ACCURACY-ON-PARTIAL-UPDATE-001
case 111: // LBS-IGNORE-ACCURACY-ON-PARTIAL-UPDATE-002
case 114: // LBS-IGNORE-ACCURACY-ON-EARLY-COMPLETE-001
case 151: // LBS-IGNORE-ACCURACY-ON-TERMINAL-BASED-001
case 201: // LBS-MOLR-IGNORE-ACCURACY-OFF-ACCURATE-001
case 204: // LBS-MOLR-IGNORE-ACCURACY-OFF-INACCURATE-001
case 207: // LBS-MOLR-IGNORE-ACCURACY-OFF-TIMEOUT-001
case 210: // LBS-IGNORE-ACCURACY-OFF-PARTIAL-UPDATE-001
case 211: // LBS-IGNORE-ACCURACY-OFF-PARTIAL-UPDATE-002
case 214: // LBS-IGNORE-ACCURACY-OFF-EARLY-COMPLETE-001
{
User::LeaveIfError(iPositioner.Open(iServer));
break;
}
case 102: // LBS-MOLR-IGNORE-ACCURACY-ON-ACCURATE-002
case 105: // LBS-MOLR-IGNORE-ACCURACY-ON-INACCURATE-002
case 108: // LBS-MOLR-IGNORE-ACCURACY-ON-TIMEOUT-002
case 152: // LBS-IGNORE-ACCURACY-ON-TERMINAL-BASED-002
case 202: // LBS-MOLR-IGNORE-ACCURACY-OFF-ACCURATE-002
case 205: // LBS-MOLR-IGNORE-ACCURACY-OFF-INACCURATE-002
case 208: // LBS-MOLR-IGNORE-ACCURACY-OFF-TIMEOUT-002
{
TPositionModuleId networkModuleId = utils.GetAGpsModuleIdL(iServer);
User::LeaveIfError(iPositioner.Open(iServer, networkModuleId));
break;
}
case 103: // LBS-MOLR-IGNORE-ACCURACY-ON-ACCURATE-003
case 106: // LBS-MOLR-IGNORE-ACCURACY-ON-INACCURATE-003
case 109: // LBS-MOLR-IGNORE-ACCURACY-ON-TIMEOUT-003
case 153: // LBS-IGNORE-ACCURACY-ON-TERMINAL-BASED-003
case 203: // LBS-MOLR-IGNORE-ACCURACY-OFF-ACCURATE-003
case 206: // LBS-MOLR-IGNORE-ACCURACY-OFF-INACCURATE-003
case 209: // LBS-MOLR-IGNORE-ACCURACY-OFF-TIMEOUT-003
{
TPositionCriteria criteria;
TPositionQuality quality;
// set up the required accuracy
quality.SetHorizontalAccuracy(EXPECTED_GPS_ACCURACY_HORIZONTAL);
quality.SetVerticalAccuracy(EXPECTED_GPS_ACCURACY_VERTICAL);
criteria.SetRequiredQuality(quality);
User::LeaveIfError(iPositioner.Open(iServer, criteria));
break;
}
default:
{
SetTestStepResult(EFail);
}
}
if(iTestCaseId != 1 && iTestCaseId !=2)
{ // Loading the update options for all tests, except those that
// don't request a position update
TPtrC configFileName;
_LIT(KUpdateOptionsFile, "pos_infos_file");
GetStringFromConfig(ConfigSection(), KUpdateOptionsFile, configFileName);
TPositionUpdateOptions updateOpts;
utils.GetConfigured_ModuleUpdateOptionsL(configFileName, ConfigSection(), updateOpts);
iPositioner.SetUpdateOptions(updateOpts);
}
}
else
{
SetTestStepResult(EFail);
}
return TestStepResult();
}
/**
* @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.
*/
TVerdict CT_LbsClientStep_IgnoreAccuracySetting::doTestStepL()
{
// Generic test step used to test the LBS SetUpdateOptions API.
INFO_PRINTF1(_L(">>CT_LbsClientStep_IgnoreAccuracySetting::doTestStepL()"));
if(iTestCaseId == 1 || iTestCaseId == 2)
{ // Testing the ignore accuracy setting is as required
CLbsAdmin* lbsAdmin = CLbsAdmin::NewL();
CleanupStack::PushL(lbsAdmin);
CLbsAdmin::TSpecialFeature ignoreAccuracySetting;
TInt err = lbsAdmin->Get(KLbsSpecialFeatureIgnoreAccuracy, ignoreAccuracySetting);
if(err != KErrNone)
{
SetTestStepResult(EFail);
}
else
{
switch(iTestCaseId)
{
case 1: // LBS-IGNORE-ACCURACY-ENABLED-001
{
if(ignoreAccuracySetting != CLbsAdmin::ESpecialFeatureOn)
{
SetTestStepResult(EFail);
}
break;
}
case 2: // LBS-IGNORE-ACCURACY-DISABLED-001
{
if(ignoreAccuracySetting != CLbsAdmin::ESpecialFeatureOff)
{
SetTestStepResult(EFail);
}
break;
}
default:
{
SetTestStepResult(EFail);
}
}
}
CleanupStack::PopAndDestroy(lbsAdmin);
}
else
{
// Testing the ignore accuracy setting is absent
if(iTestCaseId == 3)
{ // Testing the ignore accuracy setting is absent
CLbsAdmin* lbsAdmin = CLbsAdmin::NewL();
CleanupStack::PushL(lbsAdmin);
TInt err(KErrNone);
CLbsAdmin::TSpecialFeature ignoreAccuracySetting;
err = lbsAdmin->Get(KLbsSpecialFeatureIgnoreAccuracy, ignoreAccuracySetting);
if(err != KErrNone || ignoreAccuracySetting != CLbsAdmin::ESpecialFeatureOff)
{
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(lbsAdmin);
}
switch(iTestCaseId)
{ // Requesting the module to delay it's response so we get a time-out
case 107: // LBS-MOLR-IGNORE-ACCURACY-ON-TIMEOUT-001
case 108: // LBS-MOLR-IGNORE-ACCURACY-ON-TIMEOUT-002
case 109: // LBS-MOLR-IGNORE-ACCURACY-ON-TIMEOUT-003
case 207: // LBS-MOLR-IGNORE-ACCURACY-OFF-TIMEOUT-001
case 208: // LBS-MOLR-IGNORE-ACCURACY-OFF-TIMEOUT-002
case 209: // LBS-MOLR-IGNORE-ACCURACY-OFF-TIMEOUT-003
{
if (iParent.iSharedData->iTestModuleInUse)
{
T_LbsUtils utils;
TModuleDataIn modDataIn;
modDataIn.iRequestType = TModuleDataIn::EModuleRequestTimeOut;
modDataIn.iTimeOut = KModuleTimeout;
utils.NotifyModuleOfConfigChangeL(modDataIn); // This will block.
}
else
{
SetTestStepResult(EFail);
}
break;
}
default:
{
break;
}
}
if (TestStepResult()==EPass)
{
T_LbsUtils utils;
// Create a posinfo and store in our shared array for later verification.
RPointerArray<TAny>& posInfoArr = iParent.iSharedData->iCurrentPosInfoArr;
// The posInfo shouldn't be put on the cleanup stack because ownership is passed to the parent
TPositionInfo* posInfo = new(ELeave) TPositionInfo();
utils.ResetAndDestroy_PosInfoArr(posInfoArr); // Clear previous entries before new entry is appended.
posInfoArr.Append(posInfo);
TInt err;
// Request a position update
switch(iTestCaseId)
{
case 114: // LBS-IGNORE-ACCURACY-ON-EARLY-COMPLETE-001
case 214: // LBS-IGNORE-ACCURACY-OFF-EARLY-COMPLETE-001
{ // In the early complete tests we request for a position
// update in a different way so the client can complete
// the request early
err = DoNotifyUpdateL(*posInfo);
if(err != KPositionPartialUpdate)
{
SetTestStepResult(EFail);
break;
}
TRequestStatus status;
iPositioner.NotifyPositionUpdate(*posInfo, status);
err = iPositioner.CompleteRequest(EPositionerNotifyPositionUpdate);
if(err != KErrNone)
{
SetTestStepResult(EFail);
}
// this should complete with either KErrNone or KErrCancel
User::WaitForRequest(status);
err = status.Int();
break;
}
default:
{
// Get the actual position
err = DoNotifyUpdateL(*posInfo);
}
}
if(iTestCaseId == 151 || iTestCaseId == 153)
{ // expect reference position in the appropiate terminal based tests
if(KErrNone != err)
{
SetTestStepResult(EFail);
}
else
{
// Verify reference position.
TPositionInfo verifyRefPosInfo;
verifyRefPosInfo.SetPosition(iRefPos);
if (!utils.Compare_PosInfo(verifyRefPosInfo, *posInfo))
{
if(!iParent.iSharedData->iTestModuleInUse)
{
WARN_PRINTF1(_L("WARNING: position received was not reference position"));
}
else
{
INFO_PRINTF1(_L("Failed test, reference position incorrect."));
SetTestStepResult(EFail);
}
}
}
err = DoNotifyUpdateL(*posInfo);
}
// check we receive the appropiate error code from the request we made
switch(iTestCaseId)
{
case 101: // LBS-MOLR-IGNORE-ACCURACY-ON-ACCURATE-001
case 104: // LBS-MOLR-IGNORE-ACCURACY-ON-INACCURATE-001
case 201: // LBS-MOLR-IGNORE-ACCURACY-OFF-ACCURATE-001
case 102: // LBS-MOLR-IGNORE-ACCURACY-ON-ACCURATE-002
case 105: // LBS-MOLR-IGNORE-ACCURACY-ON-INACCURATE-002
case 151: // LBS-IGNORE-ACCURACY-ON-TERMINAL-BASED-001
case 152: // LBS-IGNORE-ACCURACY-ON-TERMINAL-BASED-002
case 153: // LBS-IGNORE-ACCURACY-ON-TERMINAL-BASED-003
case 202: // LBS-MOLR-IGNORE-ACCURACY-OFF-ACCURATE-002
case 103: // LBS-MOLR-IGNORE-ACCURACY-ON-ACCURATE-003
case 106: // LBS-MOLR-IGNORE-ACCURACY-ON-INACCURATE-003
case 203: // LBS-MOLR-IGNORE-ACCURACY-OFF-ACCURATE-003
{
if (KErrNone != err)
{
INFO_PRINTF2(_L("Failed test, error = %d."), err);
SetTestStepResult(EFail);
}
break;
}
case 107: // LBS-MOLR-IGNORE-ACCURACY-ON-TIMEOUT-001
case 108: // LBS-MOLR-IGNORE-ACCURACY-ON-TIMEOUT-002
case 109: // LBS-MOLR-IGNORE-ACCURACY-ON-TIMEOUT-003
case 207: // LBS-MOLR-IGNORE-ACCURACY-OFF-TIMEOUT-001
case 208: // LBS-MOLR-IGNORE-ACCURACY-OFF-TIMEOUT-002
case 209: // LBS-MOLR-IGNORE-ACCURACY-OFF-TIMEOUT-003
{
if (KErrTimedOut != err)
{
INFO_PRINTF2(_L("Failed test, expected KErrTimedOut, got error = %d."), err);
SetTestStepResult(EFail);
}
break;
}
case 3: // LBS-IGNORE-ACCURACY-ABSENT-001
case 110: // LBS-IGNORE-ACCURACY-ON-PARTIAL-UPDATE-001
case 204: // LBS-MOLR-IGNORE-ACCURACY-OFF-INACCURATE-001
case 205: // LBS-MOLR-IGNORE-ACCURACY-OFF-INACCURATE-002
case 206: // LBS-MOLR-IGNORE-ACCURACY-OFF-INACCURATE-003
case 210: // LBS-IGNORE-ACCURACY-OFF-PARTIAL-UPDATE-001
{
if (KPositionQualityLoss != err)
{
INFO_PRINTF2(_L("Failed test, expected KPositionQualityLoss, got error = %d."), err);
SetTestStepResult(EFail);
}
break;
}
case 111: // LBS-IGNORE-ACCURACY-ON-PARTIAL-UPDATE-002
case 211: // LBS-IGNORE-ACCURACY-OFF-PARTIAL-UPDATE-002
{
if (KPositionPartialUpdate != err)
{
INFO_PRINTF2(_L("Failed test, expected KPositionPartialUpdate, got error = %d."), err);
SetTestStepResult(EFail);
}
break;
}
case 114: // LBS-IGNORE-ACCURACY-ON-EARLY-COMPLETE-001
case 214: // LBS-IGNORE-ACCURACY-OFF-EARLY-COMPLETE-001
{
if (KPositionEarlyComplete != err)
{
INFO_PRINTF2(_L("Failed test, expected KPositionEarlyComplete, got error = %d."), err);
SetTestStepResult(EFail);
}
break;
}
default:
{
INFO_PRINTF2(_L("Failed test, unexpected Test Case Id %d"), iTestCaseId);
SetTestStepResult(EFail);
}
}
}
}
INFO_PRINTF1(_L("<<CT_LbsClientStep_IgnoreAccuracySetting::doTestStepL()"));
return TestStepResult();
}