//
// This test checks that a SetLastKnowPosition request
// results in a request to store a position sent to the DB
//
TVerdict CTe_LocMonitorStep11::doTestStepL()
{
if (TestStepResult()==EPass)
{
TPositionInfo positionInfo;
TPosition position;
TReal64 latitude(11), longitude(21);
position.SetCoordinate(latitude, longitude);
positionInfo.SetPosition(position);
RLbsLocMonitorSession locMonSession;
User::LeaveIfError(locMonSession.Connect());
RLbsLocMonitorAreaPositioner areaPositioner;
areaPositioner.OpenL(locMonSession);
CleanupClosePushL(areaPositioner);
iLocMonDbListener->ListenForLocMonDbFeedback();
areaPositioner.SetLastKnownPosition(positionInfo);
iLocMonDbListener->WaitForDbFeedback();
// Check that the position received by the DB is the position
// sent by the test
TESTL(latitude == iLocMonDbListener->iDbData.iPosition.Latitude());
TESTL(longitude == iLocMonDbListener->iDbData.iPosition.Longitude());
CleanupStack::PopAndDestroy(&areaPositioner);
locMonSession.Close();
}
return TestStepResult();
}
// ---------------------------------------------------------
// CT_LbsInstallPsyTp273::NotifyPositionUpdate
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsInstallPsyTp273::NotifyPositionUpdate(
TPositionInfoBase& aPosInfo,
TRequestStatus& aStatus)
{
TInt err = KErrNone;
TTime tt;
tt.UniversalTime();
//Request ID must be unique, use universalime as seed
// to give a random number
TInt64 seed = tt.Int64();
TReal lat = 90 * Math::FRand(seed);
TReal lon = 90 * Math::FRand(seed);
TReal32 alt = (TReal32)(90 * Math::FRand(seed));
TPositionInfo* position = static_cast<TPositionInfo*> (&aPosInfo);
TUid implUid = { KPosImplementationUid };
position->SetModuleId(implUid);
TTime now;
now.UniversalTime();
TPosition posse;
posse.SetCoordinate(lat, lon, alt);
posse.SetTime(now);
position->SetPosition(posse);
TRequestStatus* status = &aStatus;
User::RequestComplete(status, err);
}
void CNetworkPsy2::CompleteRequestByDefault()
{
if(!iRequestStatus)
{
return;
}
if(iPositionInfoBase->PositionClassType() & EPositionInfoClass)
{
TPositionInfo* posInfo = static_cast<TPositionInfo*>(iPositionInfoBase);
TPosition pos;
pos.SetCoordinate(1.0, 1.0, 1.0);
pos.SetAccuracy(1.0, 1.0);
posInfo->SetPosition(pos);
}
CompleteRequest(KErrNone);
}
// ---------------------------------------------------------
// CTestPsy4Positioner::NotifyPositionUpdate
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsTestProxyPsy5Positioner::NotifyPositionUpdate(TPositionInfoBase& aPosInfo, TRequestStatus& aStatus)
{
TPositionInfo* posInfo = static_cast<TPositionInfo*> (&aPosInfo);
TPosition pos;
pos.SetCoordinate(99, 99, 99);
posInfo->SetPosition(pos);
TUint32 request = posInfo->UpdateType();
switch (request)
{
case 304:
iRequestHandler->SetErrorCode(KErrNone);
break;
default:
iRequestHandler->SetErrorCode(KErrUnknown);
break;
}
iRequestHandler->NotifyPositionUpdate(posInfo, &aStatus);
}
void CLcfPsyDummy3::GetBasicPositionInfoL(TPositionInfoBase& aPosInfo)
{
// The position info object is at least a TPositionInfo
TPositionInfo* posInfo =
static_cast<TPositionInfo*>(&aPosInfo);
TPosition pos;
// Calculate the position and fill in the position info
// object
pos.SetCoordinate(67.567, -12.34, 45.32);
// set horizontal and vertical accuracy
pos.SetAccuracy(150.0, 500.0);
// set time of fix
pos.SetCurrentTime();
// Set position in position info.
posInfo->SetPosition(pos);
// Set the implementation uid
posInfo->SetModuleId(ImplementationUid());
}
void CLcfPsyDummy1::GetBasicPositionInfoL(TPositionInfoBase& aPosInfo)
{
// The position info object is at least a TPositionInfo
TPositionInfo* posInfo =
static_cast<TPositionInfo*>(&aPosInfo);
TPosition pos;
// Calculate the position and fill in the position info
// object
// Latitude, Longtitude, altitude
pos.SetCoordinate(57.1, 11.3, 32.5);
// set horizontal and vertical accuracy
pos.SetAccuracy(40.0, 40.0);
// set time of fix
pos.SetCurrentTime();
// Set position in position info.
posInfo->SetPosition(pos);
// Set the implementation uid
posInfo->SetModuleId(ImplementationUid());
}
/** Perform Cmtlr24Step test step.
This test verifies that the SUPL Protocol Module correctly handles
an MT-LR Network requested Locate Terminal Based sequence (assistance data
delivered via an RRLP payload).
@return TVerdict test result code
*/
TVerdict Cmtlr24Step::doTestStepL()
{
INFO_PRINTF1(_L("\t********************************************************************"));
INFO_PRINTF1(_L("\tMTLR - LBS sends response before connection is established)"));
INFO_PRINTF1(_L("\t********************************************************************"));
INFO_PRINTF1(_L("- START -"));
// Initiate MT-LR
// Generate received SUPL INIT message (test message content #0)
TPtr8 messagePtr(iReceiveBuffer.Des());
TInt err = iSuplInitGenerator->GenerateSuplInitL(0, messagePtr);
if (err != KErrNone)
{
SetTestStepResult(EFail);
return TestStepResult();
}
// Inject SUPL INIT using the SUPL Push API
INFO_PRINTF1(_L("\tLBS (SuplPush) -> OnSuplInit()"));
TLbsSuplPushRequestId reqId = 12445;
TPtrC8 message(messagePtr);
iSuplPush->SuplInit(reqId, message, 0);
// Check Gateway receives a Privacy request and Location Request
INFO_PRINTF1(_L("\tLBS <- ProcessLocationRequest()"));
if (EFail == CheckGatewayCallbackL(CSuplGatewayObserver::EProcessLocationRequest) ||
!iGatewayObserver->IsPrivReqReceived() ||
MLbsNetworkProtocolObserver::EServiceMobileTerminated != iGatewayObserver->LocType() )
{
SetTestStepResult(EFail);
return TestStepResult();
}
// Wait a couple of seconds for user instructions
INFO_PRINTF1(_L("...user taking a couple of seconds for privacy response"));
if (iGatewayObserver->IsMoreObserverActivity() ||
iNetworkObserver->IsMoreObserverActivity())
{
SetTestStepResult(EFail);
return TestStepResult();
}
// LBS delivers privacy response
INFO_PRINTF1(_L("\tLBS -> PrivacyResponse (EPrivacyResponseAccepted)"));
CLbsNetworkProtocolBase::TLbsPrivacyResponse privacyResponse = CLbsNetworkProtocolBase::EPrivacyResponseAccepted;
iModule->RespondPrivacyRequest(iGatewayObserver->SessionIdValue(), privacyResponse, 0);
// Check Connection Manager receives a request for connecting
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::EConnectReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t ConnectionRequest -> NET"));
// **************** Location Response is sent by LBS before the connection is up *****************
// **************************************************************************************************
// Fake LBS sending results (position) to SPM
INFO_PRINTF1(_L("\tLBS -> RespondLocationRequest"));
TReal64 latitude = 10;
TReal64 longitude = 0;
TReal32 HorAccuracy = 10;
TPositionInfo mobilePosInfo;
TTime utcTime;
utcTime.UniversalTime();
TCoordinate coor(latitude,longitude);
TPosition mobilePos(TLocality(coor,HorAccuracy),utcTime);
mobilePosInfo.SetPosition(mobilePos);
iModule->RespondLocationRequest(iGatewayObserver->SessionIdValue(),KErrNone,mobilePosInfo);
// Wait a couple of seconds for connection activation
INFO_PRINTF1(_L("...connection taking a couple of seconds to activate"));
if (iGatewayObserver->IsMoreObserverActivity() ||
iNetworkObserver->IsMoreObserverActivity())
{
SetTestStepResult(EFail);
return TestStepResult();
}
// Simulate the connection is up (inject that event)
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t Connected <- NET"));
iNetworkObserver->InjectConnectedIndication(iNetworkObserver->SessionId());
// Check Connection Manager receives a request to send a SUPL POS INIT
// with the assistance data mask requested by the gateway
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::ESendSuplPosInitSendReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL POS INIT -> NET"));
// Inject a SUPL END (without position)
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL END <- NET"));
CSuplMessageBase* suplEnd = BuildSuplEndL(EFalse);
iNetworkObserver->InjectSuplMessage(iNetworkObserver->SessionId(), suplEnd);
// Check gateway session completed
if (EFail == CheckGatewayCallbackL(
CSuplGatewayObserver::EProcessSessionComplete))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessSessionComplete"));
// Check Connection Manager receives a disconnection request
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::EDisconnectReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t DisconnectRequest -> NET"));
// Check if more observer activity takes place
if (iGatewayObserver->IsMoreObserverActivity() ||
iNetworkObserver->IsMoreObserverActivity())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("- END -"));
SetTestStepResult(EPass);
return TestStepResult();
}
/** Perform CMoLrStep1 test step.
This test verifies that the SUPL Protocol Module correctly handles
an MO-LR Self Locate Terminal Based sequence. Assistance data is
partially delivered whith an RRLP assistance data message and then complemented
with more assistance data received in an RRLP Measure Position Request.
This test also ensures that Reference Location is one of the assistance data
types requested by LBS after SUPL RESPONSE. The test verifies that a reference
location is delivered to LBS if it is received from the network in the
Reference Location assistance data type.
@return TVerdict test result code
*/
TVerdict Cmolr30Step::doTestStepL()
{
INFO_PRINTF1(_L("\t********************************************************************"));
INFO_PRINTF1(_L("\tMOLR times out waiting for SUPL END after SUPL POS session"));
INFO_PRINTF1(_L("\t********************************************************************"));
INFO_PRINTF1(_L("- START -"));
// Initiate MO-LR
TLbsNetSessionId sessionId1(TUid::Uid(0x87654321), 0x1111);
TLbsNetPosRequestOptionsAssistance options1;
options1.SetNewClientConnected(ETrue);
TLbsNetPosRequestQuality quality1;
options1.SetRequestQuality(quality1);
TLbsAsistanceDataGroup dataRequestMask1 = EAssistanceDataBadSatList;
TLbsAsistanceDataGroup dataRequestMask2 = EAssistanceDataReferenceLocation;
// Request both sets of assitance data. They'll be delivered in different
// SUPL POS messages later on in the test.
TLbsAsistanceDataGroup dataRequestMask = dataRequestMask1|dataRequestMask2;
options1.SetDataRequestMask(dataRequestMask);
INFO_PRINTF1(_L("\tLBS -> RequestSelfLocation"));
iModule->RequestSelfLocation(sessionId1, options1);
// Check Connection Manager receives a request for connecting
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::EConnectReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t ConnectionRequest -> NET"));
// Simulate the connection is up (inject that event)
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t Connected <- NET"));
iNetworkObserver->InjectConnectedIndication(iNetworkObserver->SessionId());
// Check Connection Manager receives a request to send a SUPL START
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::ESuplStartSendReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL START -> NET"));
// Inject a SUPL RESPONSE
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL RESPONSE <- NET"));
CSuplMessageBase* resp = BuildSuplResponseL(TPositionModuleInfo::ETechnologyTerminal | TPositionModuleInfo::ETechnologyAssisted);
iNetworkObserver->InjectSuplMessage(iNetworkObserver->SessionId(), resp);
// Check gateway receives Location Request
INFO_PRINTF1(_L("\tLBS <- ProcessLocationRequest()"));
if (EFail == CheckGatewayCallbackL(
CSuplGatewayObserver::EProcessLocationRequest) ||
MLbsNetworkProtocolObserver::EServiceSelfLocation != iGatewayObserver->LocType())
{
SetTestStepResult(EFail);
return TestStepResult();
}
// LBS Requests assistance data
INFO_PRINTF1(_L("\tLBS -> RequestAssistanceData ()"));
TLbsNetSessionIdArray dummyIdArray;
iModule->RequestAssistanceData(dataRequestMask, dummyIdArray);
// Check Connection Manager receives a request to send a SUPL POS INIT
// with the assistance data mask requested by the gateway
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::ESendSuplPosInitSendReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL POS INIT -> NET"));
// Inject a SUPL POS (RRLP ASSIST DATA) with some of the Assistance data requested
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL POS - RRLP Assitance Data <- NET"));
CSuplMessageBase* suplPos = BuildSuplPosAssitDataL(dataRequestMask2, ETrue); // ETrue = more assistance data underway
iNetworkObserver->InjectSuplMessage(iNetworkObserver->SessionId(), suplPos);
// Check the Connection Manager receives a request to send a SUPL POS (ack to assistance data)
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::ESendSuplPosSendReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL POS - RRLP Assistance Data Ack -> NET"));
// Inject a SUPL POS (RRLP MEASURE POSITION REQUEST) wich carries
// assistance data
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL POS - RRLP Measure Position Request <- NET"));
suplPos = BuildSuplPosRequestL(TPositionModuleInfo::ETechnologyTerminal | TPositionModuleInfo::ETechnologyAssisted, dataRequestMask1);
iNetworkObserver->InjectSuplMessage(iNetworkObserver->SessionId(), suplPos);
// Check gateway receives the assistance data types contained in both SUPL POS messages
// received earlier.
if (EFail == CheckGatewayCallbackL(CSuplGatewayObserver::EProcessAssistanceData) ||
(dataRequestMask & iGatewayObserver->AssistanceDataSetMask() != dataRequestMask) )
{
SetTestStepResult(EFail);
return TestStepResult();
}
// Ref Loc has been requested. Make sure it's been notified (the callback mechanism does
// not work well because EProcessAssistanceData overwrites EProcessLocationUpdate as they
// happen in the same RunL of the SUPL Protocol). Instead, a flag has to be checked after
// having received EProcessAssistanceData above
if (!iGatewayObserver->IsRefLocNotified())
{
SetTestStepResult(EFail);
return TestStepResult();
}
// Reference Location is reported before Assistance Data...if we got this far,
// both ref loc and assist data have been notified:
INFO_PRINTF1(_L("\tLBS <- ProcessLocationUpdate(Reference Location)"));
INFO_PRINTF1(_L("\tLBS <- ProcessAssistanceData()"));
// Check gateway receives a location request (due to the RRLP Measure Position Request)
//
INFO_PRINTF1(_L("\tLBS <- ProcessLocationRequest()"));
if (EFail == CheckGatewayCallbackL(
CSuplGatewayObserver::EProcessLocationRequest) ||
MLbsNetworkProtocolObserver::EServiceSelfLocation != iGatewayObserver->LocType())
{
SetTestStepResult(EFail);
return TestStepResult();
}
// Fake LBS sending results (position) to SPM
INFO_PRINTF1(_L("\tLBS -> RespondLocationRequest"));
TReal64 latitude = 10;
TReal64 longitude = 0;
TReal32 HorAccuracy = 10;
TPositionInfo mobilePosInfo;
TTime utcTime;
utcTime.UniversalTime();
TCoordinate coor(latitude,longitude);
TPosition mobilePos(TLocality(coor,HorAccuracy),utcTime);
mobilePosInfo.SetPosition(mobilePos);
iModule->RespondLocationRequest(sessionId1,KErrNone,mobilePosInfo);
// Check the Connection Manager receives a request to send a SUPL POS (RRLP MEASURE POSITION RESPONSE)
//
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::ESendSuplPosSendReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL POS - RRLP Measure Position Response -> NET"));
// ********* DONNOT Inject a SUPL END (from SUPL server) *************
// This will test that the 10 second timer goes off due to inactivity after
// sending the last SUPL POS message.
// The SUPL Protocol Module will send a SUPL END and close the connection.
// ********************************************************************
// Check the Connection Manager receives a request to send a SUPL END
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::ESendSuplEndSendReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL END -> NET"));
// Check gateway session completed
if (EFail == CheckGatewayCallbackL(
CSuplGatewayObserver::EProcessSessionComplete))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessSessionComplete"));
// Check Connection Manager receives a disconnection request
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::EDisconnectReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t DisconnectRequest -> NET"));
// Check if more observer activity takes place
if (iGatewayObserver->IsMoreObserverActivity() ||
iNetworkObserver->IsMoreObserverActivity())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("- END -"));
SetTestStepResult(EPass);
return TestStepResult();
}
void CT_LbsClientStep_PartialUpdate::NotifyMeasurementReportLocation(const TPositionInfo& aPosition)
{
T_LbsUtils utils;
T_LbsUtils::TComparisonAccuracyType accType;
if(iParent.iSharedData->iTestModuleInUse)
{
accType = T_LbsUtils::EExactAccuracy;
}
else
{
accType = T_LbsUtils::ERoughAccuracy;
}
switch(iTestCaseId)
{
case 21:
case 22:
{
TPositionInfo refPosInfo;
refPosInfo.SetPosition(iRefPos);
if (!utils.Compare_PosInfo(refPosInfo, aPosition, accType))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
break;
}
case 24:
case 25:
case 28:
{
TPositionInfo* verPosInfoPtr = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iVerifyPosInfoArr[0]);
if (!utils.Compare_PosInfo(*verPosInfoPtr, aPosition, accType))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
break;
}
/*case 25:
{
TPositionInfo* verPosInfoPtr = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iVerifyPosInfoArr[1]);
if (!utils.Compare_PosInfo(*verPosInfoPtr, aPosition, accType))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
break;
}*/
case 26:
{
//INFO_PRINTF1(_L("Position should not be sent to Network"));
//SetTestStepResult(EFail);
break;
}
default:
break;
}
}
/** Perform CNiLrStep1 test step.
This test verifies that the Test Protocol Module correctly handles
a Network Induced location request.
@return TVerdict test result code
*/
TVerdict CNiLrStep1::doTestStepL()
{
INFO_PRINTF1(_L("\t********************************************************************"));
INFO_PRINTF1(_L("\tNILR basic procedure"));
INFO_PRINTF1(_L("\t********************************************************************"));
INFO_PRINTF1(_L("- START -"));
// Initiate NI-LR
INFO_PRINTF1(_L("\t ProcessMeasurementControlLocation <- NET"));
TPositionInfo refLoc;
TPosition refPos;
refPos.SetHorizontalAccuracy(KRefPosHorizAcc);
refLoc.SetPosition(refPos);
RLbsAssistanceDataBuilderSet assistData;
CleanupClosePushL(assistData);
assistData.OpenL();
SetDummyAssistanceData(assistData, EAssistanceDataReferenceTime);
TLbsNetPosRequestQuality quality;
quality.SetMinHorizontalAccuracy(KLocReqHorizAcc);
iNetworkObserver->ProcessMeasurementControlLocationL(refLoc, assistData, quality);
CleanupStack::PopAndDestroy(&assistData);
// Check gateway receives Assistance data
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessAssistanceData) ||
EAssistanceDataReferenceTime != iGatewayObserver->AssistanceDataSetMask())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessAssistanceData"));
// Check gateway receives Network Based location
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessLocationUpdate) ||
KRefPosHorizAcc != iGatewayObserver->ReferencePos().HorizontalAccuracy())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessLocationUpdate"));
// Check gateway receives Location Request
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessLocationRequest) ||
iGatewayObserver->IsLocEmergency() ||
MLbsNetworkProtocolObserver::EServiceNetworkInduced != iGatewayObserver->LocType() ||
KLocReqHorizAcc != iGatewayObserver->LocQuality().MinHorizontalAccuracy())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessLocationRequest"));
// Generate Location Response
INFO_PRINTF1(_L("\tLBS -> RespondLocationRequest"));
TInt reason = KErrNone;
TPositionInfo mobilePosInfo;
TPosition mobilePos;
mobilePos.SetHorizontalAccuracy(KMobilePosHorizAcc);
mobilePosInfo.SetPosition(mobilePos);
iModule->RespondLocationRequest(iGatewayObserver->SessionIdValue(),
reason, mobilePosInfo);
// Check network receives Location Response
if (EFail == CheckNetworkCallbackL(
CNetworkObserver::EMeasurementReportLocation) ||
KMobilePosHorizAcc != iNetworkObserver->MobilePos().HorizontalAccuracy())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t MeasurementReportLocation -> NET"));
// Check gateway session completed
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessSessionComplete))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessSessionComplete"));
// Check if more observer activity takes place
if (iGatewayObserver->IsMoreObserverActivity() ||
iNetworkObserver->IsMoreObserverActivity())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("- END -"));
SetTestStepResult(EPass);
return TestStepResult();
}
void CT_LbsConflictStep_X3PTimerPush::NotifyMeasurementControlLocation(const TPositionInfo& aPosition,
const RLbsAssistanceDataBuilderSet& aData,
const TLbsNetPosRequestQuality& aQuality)
{
T_LbsUtils utils;
TInt err;
// Determine and record sequence event.
if (iState == EReqX3PTimer)
{
INFO_PRINTF1(_L("Got - X3P(TIMER1) MOLR - NetSim Notify Measurement Control Location - Event."));
// For the first attempt (before pre-emption) we *may* get this, depending how far
// the request has run, but we can't guarantee it, so it's not added to the
// verify list but ...
// ... if we do get one of these, we must also get a failure message so add that to adhoc list
SetVerifyAdhocEvent(EX3P_TIMER_MOLR_NetSim_Got_NotifyMeasurementReportControlFailure);
}
else if(iState == EReqX3PTimer2)
{
INFO_PRINTF1(_L("Got - X3P(TIMER2) MOLR - NetSim Notify Measurement Control Location - Event."));
SetCurrentSeqEvent(EX3P_TIMER_MOLR_NetSim_Got_NotifyMeasurementControlLocation);
}
else if(iState == EReqX3PPush)
{
INFO_PRINTF1(_L("Got - X3P(PUSH) MOLR - NetSim Notify Measurement Control Location - Event."));
SetCurrentSeqEvent(EX3P_PUSH_MOLR_NetSim_Got_NotifyMeasurementControlLocation);
}
// Verify the reference position.
TPositionInfo verifyRefPosInfo;
verifyRefPosInfo.SetPosition(iRefPos);
if (!utils.Compare_PosInfo(verifyRefPosInfo, aPosition))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
// Verify the assistance data.
RLbsAssistanceDataBuilderSet& data = const_cast<RLbsAssistanceDataBuilderSet&>(aData);
RUEPositioningGpsReferenceTimeBuilder* refTimeBuilder = NULL;
data.GetDataBuilder(refTimeBuilder);
// Create a reader from the builder's data to allow us to verify the actual
// assistance data.
RUEPositioningGpsReferenceTimeReader refTimeReader;
TRAP(err, refTimeReader.OpenL());
if (err == KErrNone)
{
refTimeReader.DataBuffer() = refTimeBuilder->DataBuffer();
if (!utils.VerifySimpleAssistanceData(refTimeReader))
{
INFO_PRINTF1(_L("Failed test, assistance data incorrect."));
SetTestStepResult(EFail);
}
refTimeReader.Close();
}
else
{
INFO_PRINTF2(_L("Failed test, assistance data reader err %d."), err);
SetTestStepResult(EFail);
}
// TODO: Check if we can verify aQuality in any way.
(void)aQuality;
}
/** Perform CNiLrStep2 test step.
This test verifies that the Test Protocol Module correctly handles
a NI-LR with location response timeout.
@return TVerdict test result code
*/
TVerdict CNiLrStep2::doTestStepL()
{
INFO_PRINTF1(_L("\t********************************************************************"));
INFO_PRINTF1(_L("\tNILR - location response timeout"));
INFO_PRINTF1(_L("\t********************************************************************"));
INFO_PRINTF1(_L("- START -"));
// Initiate NI-LR
INFO_PRINTF1(_L("\t ProcessMeasurementControlLocation <- NET"));
TPositionInfo refLoc;
TPosition refPos;
refPos.SetHorizontalAccuracy(KRefPosHorizAcc);
refLoc.SetPosition(refPos);
RLbsAssistanceDataBuilderSet assistData;
CleanupClosePushL(assistData);
assistData.OpenL();
SetDummyAssistanceData(assistData, EAssistanceDataReferenceTime);
TLbsNetPosRequestQuality quality;
quality.SetMinHorizontalAccuracy(KLocReqHorizAcc);
iNetworkObserver->ProcessMeasurementControlLocationL(refLoc, assistData, quality);
CleanupStack::PopAndDestroy(&assistData);
// Check gateway receives Assistance data
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessAssistanceData) ||
EAssistanceDataReferenceTime != iGatewayObserver->AssistanceDataSetMask())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessAssistanceData"));
// Check gateway receives Network Based location
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessLocationUpdate) ||
KRefPosHorizAcc != iGatewayObserver->ReferencePos().HorizontalAccuracy())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessLocationUpdate"));
// Check gateway receives Location Request
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessLocationRequest) ||
iGatewayObserver->IsLocEmergency() ||
MLbsNetworkProtocolObserver::EServiceNetworkInduced != iGatewayObserver->LocType() ||
KLocReqHorizAcc != iGatewayObserver->LocQuality().MinHorizontalAccuracy())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessLocationRequest"));
// Delay activity by 70 secs
INFO_PRINTF1(_L("*** DELAY 70 SECONDS ***"));
User::After(TTimeIntervalMicroSeconds32(25000000));
// Check network receives Location error response
if (EFail == CheckNetworkCallbackL(
CNetworkObserver::EMeasurementControlFailure) ||
KErrTimedOut != iNetworkObserver->MeasurementFailure())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t MeasurementControlFailure (TIMEOUT) -> NET"));
// Check gateway session timeout is reported
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessSessionComplete) ||
KErrTimedOut != iGatewayObserver->SessionCloseReason())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessSessionComplete (TIMEOUT)"));
// Check if more observer activity takes place
if (iGatewayObserver->IsMoreObserverActivity() ||
iNetworkObserver->IsMoreObserverActivity())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("- END -"));
SetTestStepResult(EPass);
return TestStepResult();
}
void CT_LbsClientStep_PartialUpdate::VerifyPosInfos()
{
T_LbsUtils utils;
T_LbsUtils::TComparisonAccuracyType accType;
if(iParent.iSharedData->iTestModuleInUse)
{
accType = T_LbsUtils::EExactAccuracy;
}
else
{
accType = T_LbsUtils::ERoughAccuracy;
}
switch(iTestCaseId)
{
case 5:
case 6:
{
//Verify Position returned - It should be the position returned earlier
TPositionInfo* curPosInfoPtr1 = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iCurrentPosInfoArr[0]);
TPositionInfo* curPosInfoPtr2 = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iCurrentPosInfoArr[1]);
TPositionInfo* verPosInfoPtr = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iVerifyPosInfoArr[0]);
if (!utils.Compare_PosInfo(*curPosInfoPtr1, *verPosInfoPtr, accType))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
if (!utils.Compare_PosInfo(*curPosInfoPtr2, *verPosInfoPtr, accType))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
break;
}
case 7:
{
//Verify Position returned - It should be the position returned earlier
TPositionInfo* curPosInfoPtr1 = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iCurrentPosInfoArr[0]);
TPositionInfo* curPosInfoPtr2 = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iCurrentPosInfoArr[1]);
TPositionInfo* verPosInfoPtr1 = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iVerifyPosInfoArr[0]);
TPositionInfo* verPosInfoPtr2 = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iVerifyPosInfoArr[1]);
if (!utils.Compare_PosInfo(*curPosInfoPtr1, *verPosInfoPtr1, accType))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
if (!utils.Compare_PosInfo(*curPosInfoPtr2, *verPosInfoPtr2, accType))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
break;
}
case 21:
case 22:
{
//Verify Position returned - It should be the position returned earlier
TPositionInfo* curPosInfoPtr1 = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iCurrentPosInfoArr[0]);
TPositionInfo* curPosInfoPtr2 = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iCurrentPosInfoArr[1]);
TPositionInfo refPosInfo;
refPosInfo.SetPosition(iRefPos);
if (!utils.Compare_PosInfo(*curPosInfoPtr1, refPosInfo, accType))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
if (!utils.Compare_PosInfo(*curPosInfoPtr2, refPosInfo, accType))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
break;
}
case 23:
{
//Verify Position returned - It should be the position returned earlier
TPositionInfo* curPosInfoPtr = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iCurrentPosInfoArr[0]);
TPositionInfo refPosInfo;
refPosInfo.SetPosition(iRefPos);
if (!utils.Compare_PosInfo(*curPosInfoPtr, refPosInfo, accType))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
break;
}
case 24:
case 25:
case 26:
case 28:
{
//Verify Position returned - It should be the position returned earlier
TPositionInfo* curPosInfoPtr1 = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iCurrentPosInfoArr[0]);
TPositionInfo* curPosInfoPtr2 = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iCurrentPosInfoArr[1]);
TPositionInfo* curPosInfoPtr3 = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iCurrentPosInfoArr[2]);
TPositionInfo* verPosInfoPtr1 = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iVerifyPosInfoArr[0]);
TPositionInfo* verPosInfoPtr2 = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iVerifyPosInfoArr[1]);
TPositionInfo refPosInfo;
refPosInfo.SetPosition(iRefPos);
if (!utils.Compare_PosInfo(*curPosInfoPtr1, refPosInfo, accType))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
if (!utils.Compare_PosInfo(*curPosInfoPtr2, *verPosInfoPtr1, accType))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
//if(iTestCaseId == 26 || iTestCaseId == 25)
// {
// if (!utils.Compare_PosInfo(*curPosInfoPtr3, *verPosInfoPtr2, accType))
// {
// INFO_PRINTF1(_L("Failed test, position incorrect."));
// SetTestStepResult(EFail);
// }
// }
//else
// {
if (!utils.Compare_PosInfo(*curPosInfoPtr3, *verPosInfoPtr1, accType))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
// }
break;
}
case 27:
{
//Verify Position returned - It should be the position returned earlier
TPositionInfo* curPosInfoPtr1 = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iCurrentPosInfoArr[0]);
TPositionInfo* curPosInfoPtr2 = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iCurrentPosInfoArr[1]);
TPositionInfo* curPosInfoPtr3 = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iCurrentPosInfoArr[2]);
TPositionInfo* verPosInfoPtr1 = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iVerifyPosInfoArr[0]);
TPositionInfo* verPosInfoPtr2 = reinterpret_cast<TPositionInfo*>(iParent.iSharedData->iVerifyPosInfoArr[1]);
if (!utils.Compare_PosInfo(*curPosInfoPtr1, *verPosInfoPtr1, accType))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
if (!utils.Compare_PosInfo(*curPosInfoPtr2, *verPosInfoPtr2, accType))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
if (!utils.Compare_PosInfo(*curPosInfoPtr3, *verPosInfoPtr2, accType))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
break;
}
default:
break;
}
}
void CT_LbsConflictStep_X3PPushMenu::NotifyMeasurementControlLocation(const TPositionInfo& aPosition,
const RLbsAssistanceDataBuilderSet& aData,
const TLbsNetPosRequestQuality& aQuality)
{
T_LbsUtils utils;
TInt err;
// Determine and record sequence event.
if (iState == EReqX3PMenu)
{
INFO_PRINTF1(_L("Got - X3P(MENU) MOLR - NetSim Notify Measurement Control Location - Event."));
SetCurrentSeqEvent(EX3P_MENU_MOLR_NetSim_Got_NotifyMeasurementControlLocation);
}
else if(iState == EReqX3PPush)
{
INFO_PRINTF1(_L("Got - X3P(PUSH) MOLR - NetSim Notify Measurement Control Location - Event."));
SetCurrentSeqEvent(EX3P_PUSH_MOLR_NetSim_Got_NotifyMeasurementControlLocation);
}
// Verify the reference position.
TPositionInfo verifyRefPosInfo;
verifyRefPosInfo.SetPosition(iRefPos);
if (!utils.Compare_PosInfo(verifyRefPosInfo, aPosition))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
// Verify the assistance data.
RLbsAssistanceDataBuilderSet& data = const_cast<RLbsAssistanceDataBuilderSet&>(aData);
RUEPositioningGpsReferenceTimeBuilder* refTimeBuilder = NULL;
data.GetDataBuilder(refTimeBuilder);
// Create a reader from the builder's data to allow us to verify the actual
// assistance data.
RUEPositioningGpsReferenceTimeReader refTimeReader;
TRAP(err, refTimeReader.OpenL());
if (err == KErrNone)
{
refTimeReader.DataBuffer() = refTimeBuilder->DataBuffer();
if (!utils.VerifySimpleAssistanceData(refTimeReader))
{
INFO_PRINTF1(_L("Failed test, assistance data incorrect."));
SetTestStepResult(EFail);
}
refTimeReader.Close();
}
else
{
INFO_PRINTF2(_L("Failed test, assistance data reader err %d."), err);
SetTestStepResult(EFail);
}
// TODO: Check if we can verify aQuality in any way.
(void)aQuality;
}
void CT_LbsConflictStep_selflocatex3ppush::NotifyMeasurementControlLocation(const TPositionInfo& aPosition,
const RLbsAssistanceDataBuilderSet& aData,
const TLbsNetPosRequestQuality& aQuality)
{
T_LbsUtils utils;
TInt err;
// Determine and record sequence event.
if (iState == EReqPosUpdate)
{
INFO_PRINTF1(_L("Got - Self MOLR - NetSim Notify Measurement Control Location - Event."));
// cannot record this event since it may/maynot occur depending on timing but ...
// SetCurrentSeqEvent(ESelf_MOLR_NetSim_Got_NotifyMeasurementControlLocation);
// ... if we do get one of these, we must get a failure message so add that to adhoc list
SetVerifyAdhocEvent(ESelf_MOLR_NetSim_Got_NotifyMeasurementReportControlFailure);
}
else if(iState == EReqX3P)
{
INFO_PRINTF1(_L("Got - X3P MOLR - NetSim Notify Measurement Control Location - Event."));
SetCurrentSeqEvent(EX3P_PUSH_MOLR_NetSim_Got_NotifyMeasurementControlLocation);
}
// Verify the reference position.
TPositionInfo verifyRefPosInfo;
verifyRefPosInfo.SetPosition(iRefPos);
if (!utils.Compare_PosInfo(verifyRefPosInfo, aPosition))
{
INFO_PRINTF1(_L("Failed test, position incorrect."));
SetTestStepResult(EFail);
}
// Verify the assistance data.
RLbsAssistanceDataBuilderSet& data = const_cast<RLbsAssistanceDataBuilderSet&>(aData);
RUEPositioningGpsReferenceTimeBuilder* refTimeBuilder = NULL;
data.GetDataBuilder(refTimeBuilder);
// Create a reader from the builder's data to allow us to verify the actual
// assistance data.
RUEPositioningGpsReferenceTimeReader refTimeReader;
TRAP(err, refTimeReader.OpenL());
if (err == KErrNone)
{
refTimeReader.DataBuffer() = refTimeBuilder->DataBuffer();
if (!utils.VerifySimpleAssistanceData(refTimeReader))
{
INFO_PRINTF1(_L("Failed test, assistance data incorrect."));
SetTestStepResult(EFail);
}
refTimeReader.Close();
}
else
{
INFO_PRINTF2(_L("Failed test, assistance data reader err %d."), err);
SetTestStepResult(EFail);
}
// TODO: Check if we can verify aQuality in any way.
(void)aQuality;
}
//
// Performes the test by connecting to MLFW
// (and makes a number of Location requests if aFullTest is true
//
void DoTestL(TBool aFullTest, TInt aNumberOfRuns, TInt *aResult)
{
RPositionServer posServer;
TInt errorCode = errorCode = posServer.Connect();
if (errorCode != KErrNone)
{
*aResult = KErrCouldNotConnect;
return;
}
CleanupClosePushL(posServer);
RPositioner positioner;
// Full test means requesting position updates
if (aFullTest)
{
TPositionInfo positionInfo = TPositionInfo();
const TInt32 KUidMultiPsy = 0x01010176;
TUid uidMultiPsy;
uidMultiPsy.iUid = KUidMultiPsy;
errorCode = positioner.Open(posServer, uidMultiPsy);
if (errorCode != KErrNone)
{
*aResult = errorCode;
return;
}
CleanupClosePushL(positioner);
_LIT(KService ,"Service");
errorCode = positioner.SetRequestor(CRequestor::ERequestorService,
CRequestor::EFormatApplication, KService);
if (errorCode != KErrNone)
{
*aResult = 1001;
return;
}
TRequestStatus status;
TLocality loca(TCoordinate(0,0,0),0);
TPosition pos(loca, TTime(0));
for (TInt i = 0; i < aNumberOfRuns; i++)
{
positionInfo.SetPosition(pos);
positioner.NotifyPositionUpdate(positionInfo, status);
User::WaitForRequest(status);
TInt err = status.Int();
if (err != KErrNone)
{
*aResult = err;
}
TPosition result;
positionInfo.GetPosition(result);
//sanity check
if (result.Latitude() == pos.Latitude() ||
result.Longitude() == pos.Longitude() ||
result.Altitude() == pos.Altitude())
{
//_LIT(KErrorPositon, "ERROR:: The postion was not updated");
errorCode = 1005;
}
}
positioner.Close();
CleanupStack::PopAndDestroy(&positioner);
}
posServer.Close();
CleanupStack::PopAndDestroy(&posServer);
}
void CNetworkPsy2::TimerCompleted()
{
TPsyConfig& config(iPsyConfigArray[iCurrentIndex]);
if(config.iType==TPsyConfig::EConfigLRResponse)
{
//If no pending LR, then just return
if(!iRequestStatus)
{
return;
}
TInt err = config.iData.iLRConfig.iErr;
//complete location request
if(iPositionInfoBase->PositionClassType() & EPositionInfoClass)
{
//Set TPositionInfo
TPosition pos;
pos.SetCoordinate(
config.iData.iLRConfig.iLat,
config.iData.iLRConfig.iLon,
config.iData.iLRConfig.iAlt);
TPositionInfo* posInfo = reinterpret_cast<TPositionInfo*>(iPositionInfoBase);
posInfo->SetPosition(pos);
}
if(iPositionInfoBase->PositionClassType() & EPositionGenericInfoClass)
{
//Set HGeneric Info
HPositionGenericInfo* genInfo =
static_cast<HPositionGenericInfo*>(iPositionInfoBase);
if(genInfo->IsRequestedField(EPositionFieldNMEASentences))
{
genInfo->SetValue(EPositionFieldNMEASentences, TInt8(1));
HBufC8* nmea = NULL;
TRAP(err, nmea = HBufC8::NewL(config.iData.iLRConfig.iNmeaDataSize));
if(KErrNone == err)
{
TPtr8 nmeaPtr(nmea->Des());
nmeaPtr.Fill('H', config.iData.iLRConfig.iNmeaDataSize);
err = genInfo->SetValue(EPositionFieldNMEASentences+1, *nmea);
}
delete nmea;
}
}
CompleteRequest(err);
if(config.iData.iLRConfig.iNumOfResponse>1)
{
config.iData.iLRConfig.iNumOfResponse--;
}
else if(config.iData.iLRConfig.iNumOfResponse>0)
{
iCurrentIndex++;
}
else
{
//0 means forever response with this
}
}
else //ECinfigModuleStatus
{
//Change module status
TPositionModuleStatus modStatus;
modStatus.SetDataQualityStatus(config.iData.iStatusConfig.iDataQuality);
modStatus.SetDeviceStatus(config.iData.iStatusConfig.iDeviceStatus);
MPositionerStatus* observer = PositionerStatus();
observer->ReportStatus(modStatus);
iCurrentIndex++;
}
iTimer->Cancel();
if(iCurrentIndex>=iPsyConfigArray.Count())
{
//When all items are used, then clean the config items
iPsyConfigArray.Reset();
iCurrentIndex = 0;
}
StartTimerIfNeeded();
}
/**
* Performes the test by connecting to MLFW and makes 50 Location request
*/
TInt DoTestL()
{
TBuf<40> traceFile = GenerateFileNameForTraceL();
RFs fileserver;
RFile file;
User::LeaveIfError(fileserver.Connect());
CleanupClosePushL(fileserver);
User::LeaveIfError(file.Open(fileserver, traceFile, EFileWrite));
CleanupClosePushL(file);
_LIT(KClientStarted, "Client Started");
TraceL(KClientStarted, file);
const TInt32 KUidMultiPsy = 0x01010176;
TUid uidMultiPsy;
uidMultiPsy.iUid = KUidMultiPsy;
SetupPsyL(uidMultiPsy);
_LIT(KMultiPsySetup, "MultiPsy set up");
TraceL(KMultiPsySetup, file);
TInt numberOfRuns = 50;
RPositionServer posServer;
CleanupClosePushL(posServer);
RPositioner positioner;
CleanupClosePushL(positioner);
TPositionInfo positionInfo = TPositionInfo();
_LIT(KConnectErr, "ERROR: Error when connecing to EPos server, %d");
TInt err = posServer.Connect();
AssertTrueL(err == KErrNone, KConnectErr, err, file);
_LIT(KOpenErr, "ERROR: Error when opening positioner, %d");
err = positioner.Open(posServer, uidMultiPsy);
AssertTrueL(err == KErrNone, KOpenErr, err, file);
_LIT(KService ,"Service");
err = positioner.SetRequestor(CRequestor::ERequestorService,
CRequestor::EFormatApplication, KService);
_LIT(KRequestor, "ERROR: Not possible to set requestor");
AssertTrueL(err == KErrNone, KRequestor, err, file);
TTime now, startTime;
TTimeIntervalMicroSeconds requestTime;
TRequestStatus status;
TInt64 reqTime;
TCoordinate corr(0,0,0);
TLocality loca(corr,0);
TPosition pos(loca, TTime(0));
TBool success = ETrue;
_LIT(KStartingRequests, "Starting requests");
TraceL(KStartingRequests, file);
for (TInt i = 0; i < numberOfRuns; i++)
{
startTime.UniversalTime();
positionInfo.SetPosition(pos);
positioner.NotifyPositionUpdate(positionInfo, status);
User::WaitForRequest(status);
err = status.Int();
if (err != KErrNone)
{
success=EFalse;
}
now.UniversalTime();
requestTime = now.MicroSecondsFrom(startTime);
_LIT(KError, "Request time, %d µs. Error code from Notify = %d");
TBuf<100> buf;
reqTime = requestTime.Int64();
buf.Format(KError, reqTime, err);
TraceL(buf, file);
TPosition result;
positionInfo.GetPosition(result);
// Sanity check
if (result.Latitude() == pos.Latitude() ||
result.Longitude() == pos.Longitude() ||
result.Altitude() == pos.Altitude())
{
success = EFalse;
_LIT(KErrorPositon, "ERROR:: The postion was not updated");
TraceL(KErrorPositon, file);
}
}
CleanupStack::PopAndDestroy(&positioner);
CleanupStack::PopAndDestroy(&posServer);
if (success)
{
_LIT(KOk, "SUCCESS");
TraceL(KOk, file);
}
else
{
_LIT(KErr, "FAILED");
TraceL(KErr, file);
}
CleanupStack::PopAndDestroy(&file);
CleanupStack::PopAndDestroy(&fileserver);
return (success) ? 0 : 1;
}
/** Perform CMtLrStep7 test step.
This test verifies that the Test Protocol Module correctly handles
an MT-LR sequence with a timeout when waiting for the privacy response.
@return TVerdict test result code
*/
TVerdict CMtLrStep7::doTestStepL()
{
INFO_PRINTF1(_L("\t********************************************************************"));
INFO_PRINTF1(_L("\tMTLR - privacy response timeout"));
INFO_PRINTF1(_L("\t********************************************************************"));
INFO_PRINTF1(_L("- START -"));
// Initiate MT-LR
INFO_PRINTF1(_L("\t ProcessRegisterLcsLocationNotification <- NET"));
TLbsExternalRequestInfo reqInfo;
reqInfo.SetRequesterId(KRequesterId());
TLbsNetPosRequestPrivacy privacyReq;
privacyReq.SetRequestAction(TLbsNetPosRequestPrivacy::ERequestActionAllow);
iNetworkObserver->ProcessRegisterLcsLocationNotificationL(reqInfo, privacyReq);
// Generate network Measurement Control
INFO_PRINTF1(_L("\t ProcessMeasurementControlLocation <- NET"));
TPositionInfo refLoc;
TPosition refPos;
refPos.SetHorizontalAccuracy(KRefPosHorizAcc);
refLoc.SetPosition(refPos);
RLbsAssistanceDataBuilderSet assistData;
CleanupClosePushL(assistData);
assistData.OpenL();
SetDummyAssistanceData(assistData, EAssistanceDataReferenceTime);
TLbsNetPosRequestQuality quality;
quality.SetMinHorizontalAccuracy(KLocReqHorizAcc);
iNetworkObserver->ProcessMeasurementControlLocationL(refLoc, assistData, quality);
CleanupStack::PopAndDestroy(&assistData);
// Check gateway receives Assistance data
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessAssistanceData) ||
EAssistanceDataReferenceTime != iGatewayObserver->AssistanceDataSetMask())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessAssistanceData"));
// Check gateway receives privacy request
TBuf8<KLbsMaxRequesterIdSize> id;
if (EFail == CheckGatewayCallbackL(CGatewayObserver::EProcessPrivacyRequest))
{
SetTestStepResult(EFail);
return TestStepResult();
}
iGatewayObserver->RequesterId(id);
TLbsNetSessionId sessionId = iGatewayObserver->SessionIdValue();
if (TLbsNetPosRequestPrivacy::ERequestActionAllow != iGatewayObserver->PrivacyNotifType().RequestAction() ||
KRequesterId() != id)
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessPrivacyRequest"));
// Check gateway receives Network Based location
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessLocationUpdate) ||
KRefPosHorizAcc != iGatewayObserver->ReferencePos().HorizontalAccuracy())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessLocationUpdate"));
// Check gateway receives Location Request
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessLocationRequest) ||
iGatewayObserver->IsLocEmergency() ||
MLbsNetworkProtocolObserver::EServiceMobileTerminated != iGatewayObserver->LocType() ||
KLocReqHorizAcc != iGatewayObserver->LocQuality().MinHorizontalAccuracy() ||
sessionId != iGatewayObserver->SessionIdValue())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessLocationRequest"));
// Delay activity by 25 secs
INFO_PRINTF1(_L("*** DELAY 25 SECONDS ***"));
User::After(TTimeIntervalMicroSeconds32(25000000));
// Check network receives privacy response
if (EFail == CheckNetworkCallbackL(
CNetworkObserver::EReleaseLcsLocationNotification) ||
CLbsNetworkProtocolBase::EPrivacyResponseUnknown != iNetworkObserver->PrivacyResponse())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t ReleaseLcsLocationNotification (unknown?) -> NET"));
// Check gateway session closes
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessSessionComplete) ||
KErrTimedOut != iGatewayObserver->SessionCloseReason())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessSessionComplete (TIMEOUT)"));
// Generate Location Response with error
INFO_PRINTF1(_L("\tLBS -> RespondLocationRequest"));
TInt reason = KErrGeneral;
TPositionInfo mobilePosInfo;
iModule->RespondLocationRequest(iGatewayObserver->SessionIdValue(),
reason, mobilePosInfo);
// Check network receives Location error response
if (EFail == CheckNetworkCallbackL(
CNetworkObserver::EMeasurementControlFailure) ||
KErrGeneral != iNetworkObserver->MeasurementFailure())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t MeasurementControlFailure (KErrGeneral) -> NET"));
// Check if more observer activity takes place
if (iGatewayObserver->IsMoreObserverActivity() ||
iNetworkObserver->IsMoreObserverActivity())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("- END -"));
SetTestStepResult(EPass);
return TestStepResult();
}
/** Perform Cmtlr5Step test step.
This test checks that the Protocol Module handles the case in which LBS requests further
assistance data.
2 data items are requested - one is included in the rrlp assistance data message, and one
is included in the rrlp measure position request.
@return TVerdict test result code
*/
TVerdict Cmtlr5Step::doTestStepL()
{
INFO_PRINTF1(_L("\t********************************************************************"));
INFO_PRINTF1(_L("\tMTLR basic procedure - not all requested assistance data delivered..."));
INFO_PRINTF1(_L("\t********************************************************************"));
INFO_PRINTF1(_L("- START -"));
// Initiate MT-LR
// Generate received SUPL INIT message (test message content #0)
TPtr8 messagePtr(iReceiveBuffer.Des());
TInt err = iSuplInitGenerator->GenerateSuplInitL(0, messagePtr);
if (err != KErrNone)
{
SetTestStepResult(EFail);
return TestStepResult();
}
// Inject SUPL INIT using the SUPL Push API
INFO_PRINTF1(_L("\tLBS (SuplPush) -> OnSuplInit()"));
TLbsSuplPushRequestId reqId = 12345;
TPtrC8 message(messagePtr);
iSuplPush->SuplInit(reqId, message, 0);
// Check Gateway receives a Privacy request and Location Request
INFO_PRINTF1(_L("\tLBS <- ProcessLocationRequest()"));
if (EFail == CheckGatewayCallbackL(CSuplGatewayObserver::EProcessLocationRequest) ||
!iGatewayObserver->IsPrivReqReceived() ||
MLbsNetworkProtocolObserver::EServiceMobileTerminated != iGatewayObserver->LocType() )
{
SetTestStepResult(EFail);
return TestStepResult();
}
// LBS delivers privacy response
INFO_PRINTF1(_L("\tLBS -> RespondPrivacyRequest ()"));
CLbsNetworkProtocolBase::TLbsPrivacyResponse privacyResponse = CLbsNetworkProtocolBase::EPrivacyResponseAccepted;
iModule->RespondPrivacyRequest(iGatewayObserver->SessionIdValue(), privacyResponse, 0);
// Check Connection Manager receives a request for connecting
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::EConnectReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t ConnectionRequest -> NET"));
// Simulate the connection is up (inject that event)
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t Connected <- NET"));
iNetworkObserver->InjectConnectedIndication(iNetworkObserver->SessionId());
// LBS Requests assistance data
INFO_PRINTF1(_L("\tLBS -> RequestAssistanceData ()"));
// Request both sets of assitance data.
// They'll be delivered in different SUPL POS messages later on in the test.
TLbsAsistanceDataGroup dataRequestMask1 = EAssistanceDataBadSatList;
TLbsAsistanceDataGroup dataRequestMask2 = EAssistanceDataIonosphericModel;
TLbsAsistanceDataGroup dataRequestMask = dataRequestMask1|dataRequestMask2;
TLbsNetSessionIdArray dummyIdArray;
iModule->RequestAssistanceData(dataRequestMask, dummyIdArray);
// Check Connection Manager receives a request to send a SUPL POS INIT
// with the assistance data mask requested by the gateway
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::ESendSuplPosInitSendReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL POS INIT -> NET"));
// Inject a SUPL POS with some of the Assistance data requested
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL POS - RRLP Assitance Data <- NET"));
CSuplMessageBase* suplPos = BuildSuplPosAssitDataL(dataRequestMask1, EFalse);
iNetworkObserver->InjectSuplMessage(iNetworkObserver->SessionId(), suplPos);
// Check gateway receives the assistance data types requested.
INFO_PRINTF1(_L("\tLBS <- ProcessAssistanceData()"));
if (EFail == CheckGatewayCallbackL(
CSuplGatewayObserver::EProcessAssistanceData) ||
(dataRequestMask1 & iGatewayObserver->AssistanceDataSetMask() != dataRequestMask1))
{
SetTestStepResult(EFail);
return TestStepResult();
}
// Check the Connection Manager receives a request to send a SUPL POS (ack to assistance data)
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::ESendSuplPosSendReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL POS - RRLP Assistance Data Ack -> NET"));
// Inject a SUPL POS (RRLP Measure Position Request) - does not contains missing assistance data
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL POS - RRLP Measure Position Request <- NET"));
suplPos = BuildSuplPosRequestL(TPositionModuleInfo::ETechnologyTerminal | TPositionModuleInfo::ETechnologyAssisted, dataRequestMask2);
iNetworkObserver->InjectSuplMessage(iNetworkObserver->SessionId(), suplPos);
// Check gateway receives the assistance data types requested.
INFO_PRINTF1(_L("\tLBS <- ProcessAssistanceData()"));
if (EFail == CheckGatewayCallbackL(
CSuplGatewayObserver::EProcessAssistanceData) ||
(dataRequestMask2 & iGatewayObserver->AssistanceDataSetMask() != dataRequestMask2))
{
SetTestStepResult(EFail);
return TestStepResult();
}
// Check gateway receives a location request (due to the RRLP Measure Position Request)
INFO_PRINTF1(_L("\tLBS <- ProcessLocationRequest()"));
if (EFail == CheckGatewayCallbackL(
CSuplGatewayObserver::EProcessLocationRequest) ||
MLbsNetworkProtocolObserver::EServiceMobileTerminated != iGatewayObserver->LocType())
{
SetTestStepResult(EFail);
return TestStepResult();
}
// Fake LBS sending results (position) to SPM
INFO_PRINTF1(_L("\tLBS -> RespondLocationRequest"));
TReal64 latitude = 10;
TReal64 longitude = 0;
TReal32 HorAccuracy = 10;
TPositionInfo mobilePosInfo;
TTime utcTime;
utcTime.UniversalTime();
TCoordinate coor(latitude,longitude);
TPosition mobilePos(TLocality(coor,HorAccuracy),utcTime);
mobilePosInfo.SetPosition(mobilePos);
iModule->RespondLocationRequest(iGatewayObserver->SessionIdValue(),KErrNone,mobilePosInfo);
// Check the Connection Manager receives a request to send a SUPL POS (RRLP Measure Position Response)
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::ESendSuplPosSendReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL POS - RRLP Measure Position Response -> NET"));
// Inject a SUPL END (without position)
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t SUPL END <- NET"));
CSuplMessageBase* suplEnd = BuildSuplEndL(EFalse);
iNetworkObserver->InjectSuplMessage(iNetworkObserver->SessionId(), suplEnd);
// Check gateway session completed
if (EFail == CheckGatewayCallbackL(
CSuplGatewayObserver::EProcessSessionComplete))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessSessionComplete"));
// Check Connection Manager receives a disconnection request
if (EFail == CheckNetworkCallbackL(CSuplNetworkTestObserver::EDisconnectReq))
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t\t\t\t\t\t\t\t DisconnectRequest -> NET"));
// Check if more observer activity takes place
if (iGatewayObserver->IsMoreObserverActivity() ||
iNetworkObserver->IsMoreObserverActivity())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("- END -"));
SetTestStepResult(EPass);
return TestStepResult();
}
/** Perform CMtLrStep2 test step.
This test verifies that the Test Protocol Module correctly handles
an MT-LR sequence - with measurement control before privacy response.
@return TVerdict test result code
*/
TVerdict CMtLrStep2::doTestStepL()
{
INFO_PRINTF1(_L("\t********************************************************************"));
INFO_PRINTF1(_L("\tMTLR basic procedure - measurement control before privacy response"));
INFO_PRINTF1(_L("\t********************************************************************"));
INFO_PRINTF1(_L("- START -"));
// Initiate MT-LR
INFO_PRINTF1(_L("\t ProcessRegisterLcsLocationNotification <- NET"));
TLbsExternalRequestInfo reqInfo;
reqInfo.SetRequesterId(KRequesterId());
TLbsNetPosRequestPrivacy privacyReq;
privacyReq.SetRequestAction(TLbsNetPosRequestPrivacy::ERequestActionAllow);
iNetworkObserver->ProcessRegisterLcsLocationNotificationL(reqInfo, privacyReq);
// Check gateway receives privacy request
TBuf8<KLbsMaxRequesterIdSize> id;
if (EFail == CheckGatewayCallbackL(CGatewayObserver::EProcessPrivacyRequest))
{
SetTestStepResult(EFail);
return TestStepResult();
}
iGatewayObserver->RequesterId(id);
TLbsNetSessionId sessionId = iGatewayObserver->SessionIdValue();
if (TLbsNetPosRequestPrivacy::ERequestActionAllow != iGatewayObserver->PrivacyNotifType().RequestAction() ||
KRequesterId() != id)
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessPrivacyRequest"));
// Generate network Measurement Control
INFO_PRINTF1(_L("\t ProcessMeasurementControlLocation <- NET"));
TPositionInfo refLoc;
TPosition refPos;
refPos.SetHorizontalAccuracy(KRefPosHorizAcc);
refLoc.SetPosition(refPos);
RLbsAssistanceDataBuilderSet assistData;
CleanupClosePushL(assistData);
assistData.OpenL();
SetDummyAssistanceData(assistData, EAssistanceDataReferenceTime);
TLbsNetPosRequestQuality quality;
quality.SetMinHorizontalAccuracy(KLocReqHorizAcc);
iNetworkObserver->ProcessMeasurementControlLocationL(refLoc, assistData, quality);
CleanupStack::PopAndDestroy(&assistData);
// Check gateway receives Assistance data
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessAssistanceData) ||
EAssistanceDataReferenceTime != iGatewayObserver->AssistanceDataSetMask())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessAssistanceData"));
// Check gateway receives Network Based location
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessLocationUpdate) ||
KRefPosHorizAcc != iGatewayObserver->ReferencePos().HorizontalAccuracy())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessLocationUpdate"));
// Check gateway receives Location Request
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessLocationRequest) ||
iGatewayObserver->IsLocEmergency() ||
MLbsNetworkProtocolObserver::EServiceMobileTerminated != iGatewayObserver->LocType() ||
KLocReqHorizAcc != iGatewayObserver->LocQuality().MinHorizontalAccuracy() ||
sessionId != iGatewayObserver->SessionIdValue())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessLocationRequest"));
// Generate privacy response
INFO_PRINTF1(_L("\tLBS -> RespondPrivacyRequest"));
iModule->RespondPrivacyRequest(iGatewayObserver->SessionIdValue(),
CLbsNetworkProtocolBase::EPrivacyResponseAccepted);
// Check network receives privacy response
if (EFail == CheckNetworkCallbackL(
CNetworkObserver::EReleaseLcsLocationNotification) ||
CLbsNetworkProtocolBase::EPrivacyResponseAccepted != iNetworkObserver->PrivacyResponse())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t ReleaseLcsLocationNotification -> NET"));
// Generate Location Response
INFO_PRINTF1(_L("\tLBS -> RespondLocationRequest"));
TInt reason = KErrNone;
TPositionInfo mobilePosInfo;
TPosition mobilePos;
mobilePos.SetHorizontalAccuracy(KMobilePosHorizAcc);
mobilePosInfo.SetPosition(mobilePos);
iModule->RespondLocationRequest(iGatewayObserver->SessionIdValue(),
reason, mobilePosInfo);
// Check network receives Location Response
if (EFail == CheckNetworkCallbackL(
CNetworkObserver::EMeasurementReportLocation) ||
KMobilePosHorizAcc != iNetworkObserver->MobilePos().HorizontalAccuracy())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\t MeasurementReportLocation -> NET"));
// Check gateway session completed
if (EFail == CheckGatewayCallbackL(
CGatewayObserver::EProcessSessionComplete) ||
KErrNone != iGatewayObserver->SessionCloseReason())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("\tLBS <- ProcessSessionComplete"));
// Check if more observer activity takes place
if (iGatewayObserver->IsMoreObserverActivity() ||
iNetworkObserver->IsMoreObserverActivity())
{
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("- END -"));
SetTestStepResult(EPass);
return TestStepResult();
}
// ---------------------------------------------------------
// CTestPsy2Positioner::NotifyPositionUpdate
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsTestProxyPsy2Positioner::NotifyPositionUpdate(TPositionInfoBase& aPosInfo, TRequestStatus& aStatus)
{
TBuf<256> buf;
OpenFileForAppend();
_LIT(KTestProxyPsy2Positioner, " Request issued to TestProxyPsy2Positioner");
buf.Append(KTestProxyPsy2Positioner);
_LIT(KAppend, "\r");
buf.Append(KAppend);
iFileText.Write(buf);
iFile.Close();
TRequestStatus* status = &aStatus;
TPositionInfo* posInfo = static_cast<TPositionInfo*> (&aPosInfo);
TPosition pos;
pos.SetCoordinate(10, 20, 30);
posInfo->SetPosition(pos);
TUid implUid = { KPosImplementationUid };
posInfo->SetModuleId(implUid);
TUint32 request = posInfo->UpdateType();
switch (request)
{
// case 1-10 - TC269
// case 11-15 - TC270
// case 21-26 - TC271
case 1:
case 5:
case 12:
case 13:
case 14:
case 21:
case 23:
case 24:
User::RequestComplete( status, KPositionPartialUpdate);
break;
case 2:
case 3:
case 4:
case 11:
case 15:
case 22:
User::RequestComplete( status, KErrLocked);
break;
case 6:
case 9:
case 10:
case 25:
User::RequestComplete( status, KErrDied);
break;
case 7:
case 8:
case 26:
User::RequestComplete( status, KErrBadPower);
break;
case 4701:
iRequestHandler->SetErrorCode(KErrNone);
iRequestHandler->SetTimerDelay(2000000);
iRequestHandler->NotifyPositionUpdate(posInfo, status);
break;
case 4702:
iRequestHandler->SetErrorCode(KErrNone);
iRequestHandler->SetTimerDelay(3000000);
iRequestHandler->NotifyPositionUpdate(posInfo, status);
break;
case 4703:
iRequestHandler->SetErrorCode(KErrNone);
iRequestHandler->SetTimerDelay(2000000);
iRequestHandler->NotifyPositionUpdate(posInfo, status);
break;
case 4704:
iRequestHandler->SetErrorCode(KErrNone);
iRequestHandler->SetTimerDelay(3000000);
iRequestHandler->NotifyPositionUpdate(posInfo, status);
break;
case 4708:
case 304:
iRequestHandler->SetErrorCode(KErrNone);
iRequestHandler->SetTimerDelay(1000000); // 1 second
iRequestHandler->NotifyPositionUpdate(posInfo, status);
break;
case 100:
iRequestHandler->ReportStatus(
TPositionModuleStatus::EDeviceInitialising,
TPositionModuleStatus::EDataQualityUnknown);
User::RequestComplete( status, KErrNone );
break;
case 200:
iRequestHandler->ReportStatus(
TPositionModuleStatus::EDeviceActive,
TPositionModuleStatus::EDataQualityUnknown);
User::RequestComplete( status, KErrNone );
break;
default:
User::RequestComplete( status, KErrDied);
break;
}
}
TVerdict CT_LbsHybridUEAssistedX3PAccurateGPS::doTestStepL()
{
// Generic test step used to test the LBS Client Notify position update API.
INFO_PRINTF1(_L("CT_LbsHybridUEAssistedX3PAccurateGPS::doTestStepL()"));
// Stop the test if the preamble failed
TESTL(TestStepResult() == EPass);
const TInt KTimeOut = 30*1000*1000;
const TInt KAdviceSystemStatusTimeout = 40*1000*1000;
const TInt KSmallTimeOut = 3*1000*1000;
// >> AdviceSystemStatus(0)
TESTL(iProxy->WaitForResponse(KAdviceSystemStatusTimeout) == ENetMsgGetCurrentCapabilitiesResponse);
CLbsNetworkProtocolBase::TLbsSystemStatus status;
TInt cleanupCnt;
cleanupCnt = iProxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status);
TESTL(status == CLbsNetworkProtocolBase::ESystemStatusNone);
CleanupStack::PopAndDestroy(cleanupCnt);
//Initiate X3P start
// TransmitPosition()
_LIT(KThirdParty,"+4407463842101");
const TInt KPriority= 6;
TLbsTransmitPositionOptions options(TTimeIntervalMicroSeconds(50*1000*1000));
TRequestStatus refPosStatus=KRequestPending;
TRequestStatus transPosStatus=KRequestPending;
TPositionInfo refPosInfo;
TPositionInfo transPosInfo;
iTransmitter.SetTransmitOptions(options);
iTransmitter.TransmitPosition(KThirdParty, KPriority, refPosStatus, refPosInfo, transPosStatus, transPosInfo);
// RequestTransmitLocation()
TESTL(iProxy->WaitForResponse(KTimeOut) == ENetMsgRequestTransmitLocation);
TBufC16<14> thirdParty(KThirdParty);
TPtr16 ptr = thirdParty.Des();
HBufC16* getThirdParty = NULL;
TLbsNetSessionId* getSessionId = NULL;
TInt getPriority(0);
cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestTransmitLocation, &getSessionId, &getThirdParty, &getPriority);
TESTL(ptr.Compare(*getThirdParty)==KErrNone);
TESTL(getPriority == KPriority);
iSessionId = *getSessionId; //session ID is initialised by LBS
CleanupStack::PopAndDestroy(cleanupCnt);
// ProcessStatusUpdate()
MLbsNetworkProtocolObserver::TLbsNetProtocolService service = MLbsNetworkProtocolObserver::EServiceTransmitThirdParty;
iProxy->CallL(ENetMsgProcessStatusUpdate, &service);
//End Initiate
//Reference Position Notification Start
// ProcessLocationUpdate()
refPosInfo = ArgUtils::ReferencePositionInfo();
iProxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, &refPosInfo);
//Reference Position Notification End
//Assistance Data Notification Start
// ProcessAssistanceData()
TLbsAsistanceDataGroup dataRequestMask = EAssistanceDataReferenceTime;
RLbsAssistanceDataBuilderSet assistanceData;
ArgUtils::PopulateLC(assistanceData);
TInt reason = KErrNone;
iProxy->CallL(ENetMsgProcessAssistanceData, &dataRequestMask, &assistanceData, &reason);
CleanupStack::PopAndDestroy(1); //assistanceData
// Assistance Data Notification End
// Network Location Request Start
// ProcessLocationRequest()
const TBool emergency(EFalse);
TLbsNetPosRequestQuality quality = ArgUtils::QualityAlpha2();
TLbsNetPosRequestMethod method = ArgUtils::RequestHybridMethod();
iProxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method);
// Network Location Request Stop
//Start the timer
TTime timerStart;
timerStart.HomeTime();
// RequestAssistanceData(0)
TESTL(iProxy->WaitForResponse(KSmallTimeOut) == ENetMsgRequestAssistanceData);
TLbsAsistanceDataGroup dataGroup;
cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataGroup);
TESTL(dataGroup == EAssistanceDataNone);
CleanupStack::PopAndDestroy(cleanupCnt);
// now wait for either to complete - but we will expect only the asynchrous request
// waiting for the REF position to complete with KErrNone
User::WaitForRequest(refPosStatus, transPosStatus);
TESTL(refPosStatus==KErrNone);
TESTL(transPosStatus.Int() == KRequestPending);
//Find the time elapsed from timer
TTimeIntervalMicroSeconds microseconds;
TTime timerStop;
timerStop.HomeTime();
microseconds = timerStop.MicroSecondsFrom(timerStart);
TInt64 timeElapsed = microseconds.Int64();
/*** NRH's Alpha2 timer expires. We enter Hybrid mode.***/
//Test that we do not get response before alpha2 has expired
TESTL(iProxy->WaitForResponse(KAlpha2Timeout-timeElapsed-KDelta) == ENetMsgTimeoutExpired);
TESTL(iProxy->WaitForResponse(2*KDelta) == ENetMsgRespondLocationRequest);
getSessionId = NULL;
TInt getReason = KErrNone;
TPositionSatelliteInfo* getPositionInfo = NULL;
cleanupCnt = iProxy->GetArgsLC(ENetMsgRespondLocationRequest, &getSessionId, &getReason, &getPositionInfo);
TESTL(getSessionId->SessionNum() == iSessionId.SessionNum());
TESTL(getReason==KErrNone);
CleanupStack::PopAndDestroy(cleanupCnt);
// no need for looping, we assume that the next update location from GPS will give accurate fix
quality = ArgUtils::Quality();
iProxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method);
// RequestAssistanceData(0)
TESTL(iProxy->WaitForResponse(KSmallTimeOut) == ENetMsgRequestAssistanceData);
cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataGroup);
TESTL(dataGroup == EAssistanceDataNone);
CleanupStack::PopAndDestroy(cleanupCnt);
// GPS positions meets required accuracy. This is sent immediately to protocol module
// The ini file should contain accurate gps fix for this test case to work
TESTL(iProxy->WaitForResponse(KTTimeout) == ENetMsgRespondLocationRequest);
getSessionId = NULL;
getReason = KErrNone;
getPositionInfo = NULL;
cleanupCnt = iProxy->GetArgsLC(ENetMsgRespondLocationRequest, &getSessionId, &getReason, &getPositionInfo);
TESTL(getSessionId->SessionNum() == iSessionId.SessionNum());
TESTL(getReason == KErrNone);
// Test position is the same as in the ini file data fed to the GPS module
// $update,1,2,51.5015,-0.105,50,2,3*
TPosition gpsPos;
getPositionInfo->GetPosition(gpsPos);
TESTL(gpsPos.Latitude()==51.5015 && gpsPos.Longitude()==-0.105 && gpsPos.Altitude()==50 && gpsPos.HorizontalAccuracy()==2 && gpsPos.VerticalAccuracy()==3);
CleanupStack::PopAndDestroy(cleanupCnt);
// Network Result Notification Start
// ProcessLocationUpdate()
//Final Network Position is the GPS position
TPositionInfo gpsPosInfo;
gpsPosInfo.SetPosition(gpsPos);
gpsPosInfo.SetUpdateType(EPositionUpdateGeneral);
gpsPosInfo.SetPositionMode(TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted);
gpsPosInfo.SetPositionModeReason(EPositionModeReasonNone);
iProxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, &gpsPosInfo);
// Network Result Notification Stop
// Session Complete Start
reason = KErrNone;
iProxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason);
MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask = MLbsNetworkProtocolObserver::EServiceNone;
iProxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask);
// Session Complete Stop
// the REF position request has completed, so now, after injecting the FNP and Session Complete
// we expect that the other request to complete with KErrNone
User::WaitForRequest(transPosStatus);
TESTL(transPosStatus==KErrNone);
return TestStepResult();
}
