1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // @file ctlbsx3psteptransmit.cpp

    15 // This is the class implementation for the Module Information Tests

    16 // EPOC includes.

    17 // 

    18 //

    19 

    20 // LBS includes.

    21 #include <lbs.h>

    22 #include <lbs/lbsx3p.h>

    23 #include <lbs/test/lbsnetsimtest.h>

    24 

    25 #include <lbs/lbsadmin.h>

    26 #include <lbs/lbslocerrors.h>

    27 

    28 #include <lbs/lbsassistancedatabuilderset.h>

    29 

    30 // LBS test includes.

    31 #include "ctlbsx3psteptransmit.h"

    32 

    33 // Required for LBS-X3P-Transmit-0007

    34 #include  "ctlbsstepsetautonomousmode.h"

    35 

    36 

    37 const TInt KTestAssistanceDataProviderPluginUidValue = 0x10281D77;

    38 const TInt KRealAssistanceDataProviderPluginUidValue = 0x10285AC2;

    39 

    40 const TUint KLbsGpsLocManagerUidValue		= 0x10281D44;

    41 const TUid  KLbsGpsLocManagerUid			= {KLbsGpsLocManagerUidValue};

    42 

    43 #define REFPOS_LAT				52.2

    44 #define REFPOS_LONG				0.2

    45 #define REFPOS_ALT				10

    46 #define REFPOS_HORZ_ACCURACY	100

    47 #define REFPOS_VERT_ACCURACY	100

    48 

    49 #define NETWORK_MAX_FIX_TIME	5000000

    50 #define NETWORK_HORZ_ACCURACY	10

    51 #define NETWORK_VERT_ACCURACY	10

    52 

    53 

    54 //profile_id in ini file

    55 _LIT(KLbsProfileId, "profile_id");

    56 

    57 //max_time in ini file

    58 _LIT(KLbsMaxTime, "max_time");

    59 

    60 /**

    61  * Destructor

    62  */

    63 CT_LbsX3PStep_Transmit::~CT_LbsX3PStep_Transmit()

    64 	{

    65 	iServer.Close();

    66 	iPositionTransmitter.Close();

    67 	}

    68 

    69 

    70 /**

    71  * Constructor

    72  */

    73 CT_LbsX3PStep_Transmit::CT_LbsX3PStep_Transmit(CT_LbsX3PServer& aParent) : CT_LbsX3PStep(aParent)

    74 	{

    75 	SetTestStepName(KLbsX3PStep_Transmit);

    76 	}

    77 

    78 

    79 /**

    80 Static Constructor

    81 */

    82 CT_LbsX3PStep_Transmit* CT_LbsX3PStep_Transmit::New(CT_LbsX3PServer& aParent)

    83 	{

    84 	CT_LbsX3PStep_Transmit* testStep = new CT_LbsX3PStep_Transmit(aParent);

    85 	// Note the lack of ELeave.

    86 	// This means that having insufficient memory will return NULL;

    87 

    88 	if (testStep)

    89 		{

    90 		TInt err = KErrNone;

    91 

    92 		TRAP(err, testStep->ConstructL());

    93 		if (err)

    94 			{

    95 			delete testStep;

    96 			testStep = NULL;

    97 			}

    98 		}

    99 

   100 	return testStep;

   101 	}

   102 

   103 void CT_LbsX3PStep_Transmit::ConstructL()

   104 	{

   105 	CT_LbsX3PStep::ConstructL();

   106 	

   107 	//We need to wait while the log events are added

   108 	SetExtendedTimerInterval(1000000);

   109 

   110 	// Carry out common test actions (such as connecting to a server).

   111 

   112 	// Connect to the Transmit Position server.

   113 	User::LeaveIfError(iServer.Connect());

   114 

   115 	// Open the positioner.

   116 	User::LeaveIfError(iPositionTransmitter.Open(iServer));

   117 

   118 	}

   119 

   120 /**

   121  * @return - TVerdict code

   122  * Override of base class pure virtual

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

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

   125  */

   126 TVerdict CT_LbsX3PStep_Transmit::doTestStepL()

   127 	{

   128 	// Generic test step used to test the LBS Client Notify position update API.

   129 	INFO_PRINTF1(_L(">>CT_LbsX3PStep_Transmit::doTestStepL()"));

   130 

   131 	if (TestStepResult() == EPass)

   132 		{

   133 		//Code common to all switch statements

   134 

   135 		// Create the active object to carry out the transmit location.

   136 		iDoTransmitPos = CT_LbsX3PDoTransmitPos::NewL(this, iPositionTransmitter);

   137 		CleanupStack::PushL(iDoTransmitPos);

   138 

   139 		// Location to use.

   140 		//RPointerArray<TAny>& srcPosInfoArr = iParent.iSharedData->iVerifyPosInfoArr;

   141 		//TPositionInfo* srcPosInfo = reinterpret_cast<TPositionInfo*>(srcPosInfoArr[0]);

   142 		//TPosition srcPos;

   143 		//srcPosInfo->GetPosition(srcPos);

   144 

   145 

   146 

   147 	    iRefPosFlag = GetIntFromConfig(ConfigSection(), KLbsRefPos, iRefPosFlag);

   148 

   149 		iFlagsToHaltOn =	KLbsCallback_MoLr |

   150 							KLbsCallback_Got_NotifyDoTransmitPos |

   151 							(iRefPosFlag? KLbsCallback_Got_NotifyDoTransmitReferencePos:0) |

   152 							KLbsCallback_NetSim_Got_Connect; // Test case callback events.

   153 

   154 		TModuleDataIn modDataIn; // Used to send test information to the test module.

   155 		//Reset test module timeout

   156 		//if(iParent.iSharedData->iTestModuleInUse)

   157 		//	{

   158 		//	modDataIn.iRequestType = TModuleDataIn::EModuleRequestTimeOut;

   159 		//	modDataIn.iTimeOut = 0;

   160 		//

   161 		//	iUtils.NotifyModuleOfConfigChangeL(modDataIn);

   162 		//	}

   163 

   164 		CLbsAdmin* adminApi = CLbsAdmin::NewL();

   165 		CleanupStack::PushL(adminApi);

   166 

   167 		// Kick off the keep alive timer.

   168 		TTimeIntervalMicroSeconds32 interval(KLbsKeepAlivePeriod);

   169 		iKeepAliveTimer->SetTimer(interval);

   170 

   171 		// Carry out unique test actions.

   172 		if (GetIntFromConfig(ConfigSection(), KTestCaseId, iTestCaseId))

   173 			{

   174 			switch (iTestCaseId)

   175 				{

   176 				// Test case LBS-X3P-Options-0001

   177 				case 01:

   178 				// Test case LBS-X3P-Options-0001	Request Transmit to third party with timeout

   179 				//

   180 				// External step:	Inform module of required single position to be transmitted.

   181 				// Local step:		Do X3P.

   182 				// Local callbacks:	Verify callback parameters are as expected.

   183 				//					NotifyMeasurementReportLocation callback, aPosition should match iVerifyPosInfoArr.

   184 				//					TransmitPosition callback, aStatus should be KErrTimedOut

   185 

   186 					{

   187 

   188 					// We now expect extra callback of NotifyMeasurementReportControlFailure instead of

   189 					// KLbsCallback_NetSim_Got_NotifyMeasurementReportLocation due to timeout.

   190 					iFlagsToHaltOn = 	KLbsCallback_MoLr |

   191 										KLbsCallback_NetSim_Got_Connect |

   192 										KLbsCallback_Got_NotifyDoTransmitPos |

   193 										(iRefPosFlag? KLbsCallback_Got_NotifyDoTransmitReferencePos:0) |

   194 										KLbsCallback_NetSim_Got_NotifyMeasurementReportControlFailure;

   195 										// We expet failure callback due to tmieout!

   196 

   197 					iFlagsToHaltOn &=~ 	KLbsCallback_NetSim_Got_NotifyMeasurementReportLocation;

   198 					iFlagsToHaltOn &=~ 	KLbsCallback_NetSim_Got_NotifyFacilityLcsMoLrResult;

   199 

   200 					//1.

   201 

   202 					//2

   203 					//Transmit Location

   204 					TLbsTransmitPositionOptions transmitOptions;

   205 					transmitOptions.SetTimeOut(5*1000000);	//Set X3P Timeout to 5 sec

   206 					iPositionTransmitter.SetTransmitOptions(transmitOptions);

   207 

   208 					User::After(1000);

   209 

   210 					TLbsTransmitPositionOptions retrievedTransmitOptions;

   211 					iPositionTransmitter.GetTransmitOptions(retrievedTransmitOptions);

   212 

   213 					if(retrievedTransmitOptions.TimeOut() != transmitOptions.TimeOut())

   214 						{

   215 						INFO_PRINTF1(_L("<FONT><B>Set and Get results didnt match</B></FONT>"));

   216 						SetTestStepResult(EFail);

   217 						}

   218 

   219 					// The module request type - time out value.

   220 					modDataIn.iRequestType = TModuleDataIn::EModuleRequestTimeOut;

   221 					modDataIn.iTimeOut = 10*1000000;

   222 

   223 					// Send timeout value to test module - will block.

   224 					iUtils.NotifyModuleOfConfigChangeL(modDataIn);

   225 

   226 					}

   227 					break;

   228 

   229 				case 03:

   230 					{

   231 					//Timeout for Transmit Location

   232 					TLbsTransmitPositionOptions transmitOptions;

   233 

   234 					TTimeIntervalMicroSeconds timeout = transmitOptions.TimeOut();

   235 					if(timeout.Int64() != 0)

   236 						{

   237 						INFO_PRINTF1(_L("<FONT><B>Default timeout should be zero</B></FONT>"));

   238 						SetTestStepResult(EFail);

   239 						}

   240 

   241 					//iFlagsToHaltOn = 	KLbsCallback_NetSim_Got_Connect ;

   242 

   243 					CleanupStack::PopAndDestroy(adminApi);

   244 					iDoTransmitPos->Cancel();

   245 					CleanupStack::PopAndDestroy(iDoTransmitPos);

   246 					return TestStepResult();

   247 					}

   248 

   249 				case 04:

   250 					{

   251 					//We might have to put this test in LBS-X3P-TransmitOptions

   252 					//Timeout for Transmit Location

   253 					TLbsTransmitPositionOptions transmitOptions(-10);

   254 

   255 					//The code should panic before and not come to this point

   256 					INFO_PRINTF1(_L("<FONT><B>Negative timout should not be allowed</B></FONT>"));

   257 					SetTestStepResult(EFail);

   258 

   259 					//return TestStepResult();

   260 					}

   261 

   262 				case 05:

   263 					{

   264 					if(iParent.iSharedData->iTestModuleInUse)

   265 						{

   266 						//Configure gps-test-module to respond after the specified timeout.

   267 						modDataIn.iRequestType = TModuleDataIn::EModuleRequestTimeOut;

   268 						modDataIn.iTimeOut = 140*1000000;

   269 

   270 						// Send timeout value to test module - will block.

   271 						iUtils.NotifyModuleOfConfigChangeL(modDataIn);

   272 						}

   273 

   274 					iFlagsToHaltOn = KLbsCallback_NetSim_Got_Connect |

   275 									 KLbsCallback_NetSim_Got_NotifyRegisterLcsMoLr |

   276 									 KLbsCallback_NetSim_Got_NotifyMeasurementControlLocation |

   277 									 KLbsCallback_NetSim_Got_NotifyMeasurementReportControlFailure |

   278 									 KLbsCallback_NetSim_Got_NotifyReleaseLcsMoLr|

   279 									 (iRefPosFlag? KLbsCallback_Got_NotifyDoTransmitReferencePos:0) |

   280 									 KLbsCallback_Got_NotifyDoTransmitPos;

   281 

   282 					}

   283 					break;

   284 

   285 				// Test case LBS-X3P-Transmit-0001

   286 				// This test uses the default functionality in each of the callbacks.

   287 				case 11:

   288 					{

   289 					// Kick off basic test.

   290 					// Test case LBS-X3P-Transmit-0001	Transmit current position with default options (no SetTransmitOptions() call

   291 					//									and quality profile left as default) to a valid destination.

   292 					//

   293 					// External step:	Inform module of required single position to be transmitted.

   294 					// Local step:		Do X3P.

   295 					// Local callbacks:	Verify callback parameters are as expected.

   296 					//					NotifyMeasurementReportLocation callback, aPosition should match iVerifyPosInfoArr.

   297 					//					TransmitPosition callback, aStatus should be KErrNone

   298 

   299 					}

   300 					break;

   301 

   302 				// Test case LBS-X3P-Transmit-0003

   303 				// This test switches to specific functionality in each of the callbacks.

   304 				case 13:

   305 					{

   306 					// Test case LBS-X3P-Transmit-0003	Request transmit current position from multiple sessions.

   307 					//

   308 					// External step:	Inform module of required single position to be transmitted.

   309 					// Local step:		Do multiple X3P.

   310 					// Local callbacks:	Verify callback parameters are as expected.

   311 					// 					NotifyMeasurementReportLocation callback, each aPosition should match iVerifyPosInfoArr.

   312 					//					TransmitPosition callback, aStatus should be KErrNone

   313 

   314 					//	1. Create single client (RlbsTransnitPositionServer object)

   315 					//	2. Open multiple sub-sessions (RlbsTransnitPosition objects)

   316 

   317 					CT_LbsX3PDoTransmitPos* pDoTransPos;

   318 					//RLbsTransmitPosition transPos1;

   319 					//RLbsTransmitPosition transPos2;

   320 					//RLbsTransmitPosition transPos3;

   321 					iTransmitPos1.Open(iServer);

   322 					iTransmitPos2.Open(iServer);

   323 					iTransmitPos3.Open(iServer);

   324 

   325 						//	3. Request X3P on each sub-session (can have same priorities)

   326 					// Create the active object array to carry out the transmit location.

   327 

   328 					pDoTransPos = CT_LbsX3PDoTransmitPos::NewL(this, iTransmitPos1);

   329 					iDoTransmitPosArr.AppendL(pDoTransPos);

   330 

   331 					pDoTransPos = CT_LbsX3PDoTransmitPos::NewL(this, iTransmitPos2);

   332 					iDoTransmitPosArr.AppendL(pDoTransPos);

   333 

   334 					pDoTransPos = CT_LbsX3PDoTransmitPos::NewL(this, iTransmitPos3);

   335 					iDoTransmitPosArr.AppendL(pDoTransPos);

   336 

   337 					}

   338 					break;

   339 

   340 				// Test case LBS-X3P-Transmit-0004

   341 				case 14:

   342 

   343 					// Test case LBS-X3P-Transmit-0004	Transmit current position with specified quality profile Id to a valid destination.

   344 					//

   345 					// External step:	Inform module of required single position to be transmitted.

   346 					// Local step:      Set admin KLbsSettingQualityProfileTransmitLocate and profile Id 4((which is exist in lbsprofile.ini)

   347 					// Local step:		Do X3P.

   348 					// Local callbacks:	Verify callback parameters are as expected.

   349 					//					NotifyMeasurementReportLocation callback, aPosition should match iVerifyPosInfoArr.

   350 					//					TransmitPosition callback, aStatus should be KErrNone

   351 

   352 					// Test case LBS-X3P-Transmit-Profile-0033

   353 				case 133:

   354 				// Test case LBS-X3P-Transmit-Profile-0033	Request Transmit to third party with timeout

   355 				//

   356 				// External step:	Inform module of required single position to be transmitted.

   357 				// Local step:      Set admin KLbsSettingQualityProfileTransmitLocate and profile Id 0((which is exist in lbsprofile.ini)

   358 				// Local step:		Do X3P.

   359 				// Local callbacks:	Verify callback parameters are as expected.

   360 				//					NotifyMeasurementReportLocation callback, aPosition should match iVerifyPosInfoArr.

   361 				//					TransmitPosition callback, aStatus should be KErrTimedOut

   362 

   363 					{

   364 

   365 					if(iTestCaseId==133)

   366 						{

   367 						// We now expect extra callback of NotifyMeasurementReportControlFailure instead of

   368 						// KLbsCallback_NetSim_Got_NotifyMeasurementReportLocation due to timeout.

   369 						iFlagsToHaltOn = 	KLbsCallback_MoLr |

   370 											KLbsCallback_NetSim_Got_Connect |

   371 											KLbsCallback_Got_NotifyDoTransmitPos |

   372 											(iRefPosFlag? KLbsCallback_Got_NotifyDoTransmitReferencePos:0) |

   373 											KLbsCallback_NetSim_Got_NotifyMeasurementReportControlFailure;

   374 											// We expet failure callback due to tmieout!

   375 

   376 						iFlagsToHaltOn &=~ 	KLbsCallback_NetSim_Got_NotifyMeasurementReportLocation;

   377 						iFlagsToHaltOn &=~ 	KLbsCallback_NetSim_Got_NotifyFacilityLcsMoLrResult;

   378 

   379 

   380 						// The module request type - time out value.

   381 					    modDataIn.iRequestType = TModuleDataIn::EModuleRequestTimeOut;

   382 					    modDataIn.iTimeOut = 10*1000000;

   383 

   384 					    // Send timeout value to test module - will block.

   385 					    iUtils.NotifyModuleOfConfigChangeL(modDataIn);

   386 						}

   387 

   388 					TInt profileid_ini;

   389 					TBool profileid_exists;

   390 			        profileid_exists = GetIntFromConfig(ConfigSection(), KLbsProfileId, profileid_ini);

   391 		            if(!profileid_exists)

   392 						{

   393 						INFO_PRINTF1(_L("Could not get profileid from section"));

   394 						SetTestStepResult(EFail);

   395 						}

   396 

   397 					TLbsQualityProfileId profileId;

   398 					// Set Profile id

   399 					User::LeaveIfError(adminApi->Set(KLbsSettingQualityProfileTransmitLocate, TLbsQualityProfileId(profileid_ini)));

   400 					//wait some time to propagate the setting

   401 					User::After(5*1000000);

   402 

   403 					// Verify that the setting is what we expect

   404 					User::LeaveIfError(adminApi->Get(KLbsSettingQualityProfileTransmitLocate, profileId));

   405 					if(profileId != TLbsQualityProfileId(profileid_ini))

   406 						{

   407 						INFO_PRINTF1(_L("<FONT><B>Set Profile id failed</B></FONT>"));

   408 						SetTestStepResult(EFail);

   409 						}

   410 					 }

   411 					break;

   412 

   413 				// Test case LBS-X3P-Transmit-0006

   414 				case 16:

   415 					{

   416 

   417 					// Test case LBS-X3P-Transmit-0006	Request X3P when gps unavailable

   418 					//

   419 					// External step:	Inform module of required single position to be transmitted.

   420 					// Local step:		Do X3P.

   421 					// Local callbacks:	Verify callback parameters are as expected.

   422 					//					NotifyMeasurementReportLocation callback, aPosition should match iVerifyPosInfoArr.

   423 					//					TransmitPosition callback, aStatus should not be KErrNone

   424 

   425 					iFlagsToHaltOn = 	KLbsCallback_NetSim_Got_Connect |

   426 										KLbsCallback_NetSim_Got_NotifyRegisterLcsMoLr |

   427 										KLbsCallback_NetSim_Got_NotifyMeasurementControlLocation |

   428 										KLbsCallback_NetSim_Got_NotifyMeasurementReportControlFailure |

   429 										KLbsCallback_Got_NotifyDoTransmitPos |

   430 										(iRefPosFlag? KLbsCallback_Got_NotifyDoTransmitReferencePos:0) |

   431 										KLbsCallback_NetSim_Got_NotifyReleaseLcsMoLr;

   432 

   433 					//	1. Configure test a-gps module to respond with error (gps unavailable)

   434 					// The module request type - error value.

   435 					modDataIn.iRequestType = TModuleDataIn::EModuleRequestError;

   436 					modDataIn.iError = KErrNotFound;

   437 

   438 					// Send error value to test module - will block.

   439 					iUtils.NotifyModuleOfConfigChangeL(modDataIn);

   440 

   441 					}

   442 					break;

   443 

   444 				// Test case LBS-X3P-Transmit-0007

   445 				case 17:

   446 					{

   447 

   448 					// Test case LBS-X3P-Transmit-0007	Transmit to 3rd party with 'autonomous-only' mode set

   449 					//

   450 					// External step:	Inform module of required single position to be transmitted.

   451 					// Local step:		Do X3P.

   452 					// Local callbacks:	Verify callback parameters are as expected.

   453 					//					NotifyMeasurementReportLocation callback, aPosition should match iVerifyPosInfoArr.

   454 					//					TransmitPosition callback, aStatus should be KErrNone

   455 

   456 					}

   457 					break;

   458 

   459 				// Test case LBS-X3P-Transmit-0008

   460 				case 18:

   461 					{

   462 

   463 					// Test case LBS-X3P-Transmit-0008	Request X3P when X3P turned off in admin settings.

   464 					//

   465 					// External step:	Inform module of required single position to be transmitted.

   466 					// Local step:		Do X3P.

   467 					// Local callbacks:	Verify callback parameters are as expected.

   468 					//					Callback should not be invoked

   469 					//					TransmitPosition callback, aStatus should be KErrAccessDenied

   470 

   471 					//	1. ETransmitLocateOff for KSettingHomeTransmitLocate

   472 

   473 					// X3P is turned off so no netsim callbacks should be recieved.

   474 					iFlagsToHaltOn = 	KLbsCallback_NetSim_Got_Connect |

   475 										(iRefPosFlag? KLbsCallback_Got_NotifyDoTransmitReferencePos:0) |

   476 										KLbsCallback_Got_NotifyDoTransmitPos;

   477 

   478 					adminApi->Set(KLbsSettingHomeTransmitLocate, CLbsAdmin::ETransmitLocateOff);

   479 					User::After(10*1000000);

   480 					}

   481 					break;

   482 

   483 				// Test case LBS-X3P-Transmit-0009

   484 				case 19:

   485 					{

   486 

   487 					// Test case LBS-X3P-Transmit-0009	Request X3P when self-locate turned off in admin settings.

   488 					//

   489 					// External step:	Inform module of required single position to be transmitted.

   490 					// Local step:		Do X3P.

   491 					// Local callbacks:	Verify callback parameters are as expected.

   492 					//					NotifyMeasurementReportLocation callback, aPosition should match iVerifyPosInfoArr.

   493 					//					TransmitPosition callback, aStatus should be KErrNone

   494 

   495 					//	1. ESelfLocateOff for KSettingHomeTransmitLocate

   496 					adminApi->Set(KLbsSettingHomeTransmitLocate, CLbsAdmin::ESelfLocateOff);

   497 					User::After(5*1000000);

   498 					}

   499 					break;

   500 

   501 				// Test case LBS-X3P-Transmit-0010

   502 				case 110:

   503 					{

   504 

   505 					// Test case LBS-X3P-Transmit-0010	Request X3P when ExternalLocateOff set for KSettingHomeTransmitLocate in admin settings.

   506 					//

   507 					// External step:	Inform module of required single position to be transmitted.

   508 					// Local step:		Do X3P.

   509 					// Local callbacks:	Verify callback parameters are as expected.

   510 					//					NotifyMeasurementReportLocation callback, aPosition should match iVerifyPosInfoArr.

   511 					//					TransmitPosition callback, aStatus should be KErrNone

   512 

   513 					//	1. EExternalLocateOff for KSettingHomeTransmitLocate

   514 					adminApi->Set(KLbsSettingHomeTransmitLocate, CLbsAdmin::EExternalLocateOff);

   515 					User::After(5*1000000);

   516 					}

   517 					break;

   518 

   519 				// Test case LBS-X3P-Transmit-0011

   520 				case 111:

   521 					{

   522 

   523 					// Test case LBS-X3P-Transmit-0011	Request X3P when X3P turned off in admin settings. Roaming.

   524 					//

   525 					// External step:	Inform module of required single position to be transmitted.

   526 					// Local step:		Do X3P.

   527 					// Local callbacks:	Verify callback parameters are as expected.

   528 					//					NotifyMeasurementReportLocation callback, aPosition should match iVerifyPosInfoArr.

   529 					//					TransmitPosition callback, aStatus should be KErrNone

   530 

   531 					iFlagsToHaltOn = 	KLbsCallback_NetSim_Got_Connect |

   532 										(iRefPosFlag? KLbsCallback_Got_NotifyDoTransmitReferencePos:0) |

   533 										KLbsCallback_Got_NotifyDoTransmitPos;

   534 

   535 					#pragma message("TO DO: LBS-X3P-Transmit-0011 CANNOT TEST THIS IN ROAMING MODE YET. INCOMPLETE")

   536 

   537 					//	1. EExternalLocateOff for KSettingRoamingTransmitLocate

   538 					adminApi->Set(KLbsSettingRoamingTransmitLocate, CLbsAdmin::ETransmitLocateOff);

   539 					User::After(5*1000000);

   540 					}

   541 					break;

   542 

   543 				// Test case LBS-X3P-Transmit-0012

   544 				case 112:

   545 					{

   546 

   547 					// Test case LBS-X3P-Transmit-0012	Request X3P when ESelfLocateOff set for KLbsSettingRoamingTransmitLocate in admin settings.

   548 					//

   549 					// External step:	Inform module of required single position to be transmitted.

   550 					// Local step:		Do X3P.

   551 					// Local callbacks:	Verify callback parameters are as expected.

   552 					//					NotifyMeasurementReportLocation callback, aPosition should match iVerifyPosInfoArr.

   553 					//					TransmitPosition callback, aStatus should be KErrNone

   554 

   555 					//	1. ESelfLocateOff for KLbsSettingRoamingTransmitLocate

   556 					adminApi->Set(KLbsSettingRoamingTransmitLocate, CLbsAdmin::ESelfLocateOff);

   557 					User::After(5*1000000);

   558 					}

   559 					break;

   560 

   561 				// Test case LBS-X3P-Transmit-0013

   562 				case 113:

   563 					{

   564 

   565 					// Test case LBS-X3P-Transmit-0013	Request X3P when EExternalLocateOff set for KLbsSettingRoamingTransmitLocate in admin settings.

   566 					//

   567 					// External step:	Inform module of required single position to be transmitted.

   568 					// Local step:		Do X3P.

   569 					// Local callbacks:	Verify callback parameters are as expected.

   570 					//					NotifyMeasurementReportLocation callback, aPosition should match iVerifyPosInfoArr.

   571 					//					TransmitPosition callback, aStatus should be KErrNone

   572 

   573 					//	1. EExternalLocateOff for KLbsSettingRoamingTransmitLocate

   574 					adminApi->Set(KLbsSettingRoamingTransmitLocate, CLbsAdmin::EExternalLocateOff);

   575 					User::After(5*1000000);

   576 					}

   577 					break;

   578 

   579 				// Test case LBS-X3P-Transmit-0014

   580 				case 114:

   581 					{

   582 					if(iParent.iSharedData->iTestModuleInUse)

   583 						{

   584 						//Configure gps-test-module to respond after the specified timeout.

   585 						modDataIn.iRequestType = TModuleDataIn::EModuleRequestTimeOut;

   586 						modDataIn.iTimeOut = 10*1000000;

   587 

   588 						// Send timeout value to test module - will block.

   589 						iUtils.NotifyModuleOfConfigChangeL(modDataIn);

   590 						}

   591 

   592 					//Set timeout to 0 - This should disable Timeout

   593 					TLbsTransmitPositionOptions transmitOptions;

   594 					transmitOptions.SetTimeOut(0);

   595 					iPositionTransmitter.SetTransmitOptions(transmitOptions);

   596 

   597 					}

   598 					break;

   599 

   600 				// Test case LBS-X3P-Transmit-0015

   601 				case 115:

   602 					{

   603 					iFlagsToHaltOn = KLbsCallback_NetSim_Got_Connect |

   604 									 KLbsCallback_NetSim_Got_NotifyRegisterLcsMoLr |

   605 									 (iRefPosFlag? KLbsCallback_Got_NotifyDoTransmitReferencePos:0) |

   606 									 KLbsCallback_Got_NotifyDoTransmitPos;

   607 

   608 					}

   609 					break;

   610 

   611 				// Test case LBS-X3P-Transmit-0016

   612 				case 116:

   613 					{

   614 					iFlagsToHaltOn = KLbsCallback_NetSim_Got_Connect |

   615 									 KLbsCallback_NetSim_Got_NotifyRegisterLcsMoLr |

   616 									 KLbsCallback_NetSim_Got_NotifyMeasurementControlLocation |

   617 									 (iRefPosFlag? KLbsCallback_Got_NotifyDoTransmitReferencePos:0) |

   618 									 KLbsCallback_Got_NotifyDoTransmitPos;

   619 

   620 					}

   621 					break;

   622 

   623 				// Test case LBS-X3P-Transmit-0017

   624 				case 117:

   625 					{

   626 					if(iParent.iSharedData->iTestModuleInUse)

   627 						{

   628 						//Configure gps-test-module to request for more assitance data.

   629 						T_LbsUtils utils;

   630 						TModuleDataIn modDataIn; // Used to send test information to the test module.

   631 						modDataIn.iRequestType = TModuleDataIn::EModuleRequestTestMode;

   632 						modDataIn.iAssDataEventType = TModuleDataIn::EAssDataEventExpectSingle;

   633 						modDataIn.iAssDataTestMode = TModuleDataIn::EModuleTestModeAssDataOn_SomeDataNotAvailable;

   634 

   635 						utils.NotifyModuleOfConfigChangeL(modDataIn);

   636 						}

   637 

   638 					iFlagsToHaltOn |= 	KLbsCallback_NetSim_Got_NotifyMeasurementReportRequestMoreAssistanceData;

   639 

   640 					}

   641 					break;

   642 

   643 				case 118:

   644 					break;

   645 

   646 

   647 				// Test case LBS-X3P-Transmit-0030

   648 				case 130:

   649 					{

   650 					// Test case LBS-X3P-Transmit-0030	Kick off X3P test with bad phone number/email.

   651 					//

   652 					// External step:	Inform module of required single position to be transmitted.

   653 					// Local step:		Do X3P but pass in an invalid number/email.

   654 					// Local callbacks:	Verify callback parameters are as expected.

   655 					//					TransmitPosition callback, aStatus should be KErrNotFound

   656 					iFlagsToHaltOn = 	KLbsCallback_NetSim_Got_Connect |

   657 										(iRefPosFlag? KLbsCallback_Got_NotifyDoTransmitReferencePos:0) |

   658 										KLbsCallback_Got_NotifyDoTransmitPos |

   659 										KLbsCallback_NetSim_Got_NotifyReleaseLcsMoLr;

   660 

   661 					}

   662 					break;

   663 

   664 				// Test case LBS-X3P-Timeout-0001

   665 				case 134:

   666 					{

   667 					// Kick off basic test.

   668 					// Test case LBS-X3P-Timeout-0001	Transmit current position with default options (no SetTransmitOptions() call

   669 					//									and quality profile left as default) to a valid destination.

   670 					//

   671 					// External step:	Inform module of required single position to be transmitted.

   672 					// Local step:		Do X3P.

   673 					// Local callbacks:	Verify callback parameters are as expected.

   674 					//					NotifyMeasurementReportLocation callback, aStatus should be KPositionQualityLoss

   675 					//					as the location provided didn't meet the quality requirements

   676  					iFlagsToHaltOn = KLbsCallback_NetSim_Got_Connect |

   677 									 KLbsCallback_NetSim_Got_NotifyRegisterLcsMoLr |

   678 									 KLbsCallback_NetSim_Got_NotifyMeasurementControlLocation |

   679 									 KLbsCallback_NetSim_Got_NotifyReleaseLcsMoLr |

   680 									 KLbsCallback_Got_NotifyDoTransmitPos |

   681 									 KLbsCallback_NetSim_Got_NotifyMeasurementReportLocation |

   682 									 KLbsCallback_NetSim_Got_NotifyFacilityLcsMoLrResult;

   683 					}

   684 					break;

   685 

   686 

   687 				default:

   688 					{

   689 					User::Panic(KLbsX3PStep_Transmit, KErrUnknown);

   690 					}

   691 				}

   692 			}

   693 

   694 		//Connect to NetSim

   695 		iNetSim.ConnectL(this);

   696 

   697 		// Set the reference position, which also be used for any required verification.

   698 		iRefPos.SetCoordinate(REFPOS_LAT, REFPOS_LONG, REFPOS_ALT);

   699 		iRefPos.SetAccuracy(REFPOS_HORZ_ACCURACY, REFPOS_VERT_ACCURACY);

   700 		iRefPos.SetCurrentTime();

   701 

   702 		if (!iNetSim.SetReferenceLocation(iRefPos))

   703 			{

   704 			INFO_PRINTF1(_L("Failed test, can't set NetSim's reference location."));

   705 			SetTestStepResult(EFail);

   706 			iNetSim.Close();

   707 			return TestStepResult();

   708 			}

   709 

   710 		// Test case LBS-X3P-Transmit-0004 or Test case LBS-X3P-Transmit-0005

   711 		if(iTestCaseId==14 || iTestCaseId==15)

   712 			{

   713 			// Set all parameters invalid (0 for max fix time; NaN for

   714 			// accuracy) then network should use quality profile with the

   715 			// ID set

   716 			TTimeIntervalMicroSeconds maxFixTime(0);

   717 			iNetPosQuality.SetMaxFixTime(maxFixTime);

   718     		TRealX nan;

   719     		nan.SetNaN();

   720 			iNetPosQuality.SetMinHorizontalAccuracy(nan);

   721 	    	iNetPosQuality.SetMinVerticalAccuracy(nan);

   722 			}

   723 		// Test case LBS-X3P-Timeout-0001

   724 		else if (iTestCaseId==134)

   725 			{

   726 			TTimeIntervalMicroSeconds maxFixTime(5000000);

   727 	    	iNetPosQuality.SetMaxFixTime(maxFixTime);

   728 			iNetPosQuality.SetMinHorizontalAccuracy(1);

   729 	    	iNetPosQuality.SetMinVerticalAccuracy(1);

   730 			}

   731 		else

   732 			{

   733 			//Set the position quality required by the network.

   734 			TTimeIntervalMicroSeconds maxFixTime(120 * 1000000);//default was 60

   735 																	//max acceptable age of a position

   736 	    	iNetPosQuality.SetMaxFixTime(maxFixTime);

   737 			iNetPosQuality.SetMinHorizontalAccuracy(NETWORK_HORZ_ACCURACY);

   738 	    	iNetPosQuality.SetMinVerticalAccuracy(NETWORK_VERT_ACCURACY);

   739 			}

   740 

   741 		if (!iNetSim.SetQuality(iNetPosQuality))

   742 			{

   743 			INFO_PRINTF1(_L("Failed test, can't set NetSim's quality."));

   744 			SetTestStepResult(EFail);

   745 			iNetSim.Close();

   746 			return TestStepResult();

   747 			}

   748 

   749 		TUid pluginUid;

   750 		if(iParent.iSharedData->iTestModuleInUse)

   751 			{

   752 			// Set plugin to use.

   753 			pluginUid = TUid::Uid(KTestAssistanceDataProviderPluginUidValue);

   754 			}

   755 		else

   756 			{

   757 			// Real AGPS Uid

   758 			pluginUid = TUid::Uid(KRealAssistanceDataProviderPluginUidValue);

   759 			}

   760 

   761 

   762 		if (!iNetSim.SetAssistanceDataProvider(pluginUid))

   763 			{

   764 			INFO_PRINTF1(_L("Failed test, can't set NetSim's assistance data plugin uid."));

   765 			SetTestStepResult(EFail);

   766 			iNetSim.Close();

   767 			return TestStepResult();

   768 			}

   769 

   770 		if(iTestCaseId !=133)

   771 			{

   772 			//Set X3P Timeout

   773 			TLbsTransmitPositionOptions transmitOptions;			//This is how long we wait for an X3P

   774 			TTimeIntervalMicroSeconds KLbsTransmitPositionTimeOut;

   775 			if(iTestCaseId == 01)

   776 				KLbsTransmitPositionTimeOut = 5*1000000;  //5 sec

   777 			else if(iTestCaseId==05)

   778 				KLbsTransmitPositionTimeOut = 180*1000000;  //180 sec - Let maxFixtime expire first

   779 			else if (iTestCaseId==134)

   780 				KLbsTransmitPositionTimeOut = 10*1000000;  //10 sec - Let maxFixtime expire first

   781 			else

   782 				KLbsTransmitPositionTimeOut = 20*1000000;  //20 sec

   783 

   784 			transmitOptions.SetTimeOut(KLbsTransmitPositionTimeOut);

   785 			iPositionTransmitter.SetTransmitOptions(transmitOptions);

   786 			}

   787 

   788 		

   789 		//Kickoff test

   790 		CActiveScheduler::Start();

   791 		

   792 		switch(iTestCaseId)

   793 			{

   794 			case 01:

   795 			case 05:

   796 			case 133:

   797 				{

   798 				// The module request type - time out value.

   799 				modDataIn.iRequestType = TModuleDataIn::EModuleRequestTimeOut;

   800 				modDataIn.iTimeOut = 0;

   801 

   802 				// Reset test module timeout

   803 				iUtils.NotifyModuleOfConfigChangeL(modDataIn);

   804 

   805 				}

   806 				break;

   807 

   808 			case 13:

   809 				{

   810 				iDoTransmitPosArr.ResetAndDestroy();

   811 

   812 				//Close temporary transmitPosition objects

   813 				iTransmitPos1.Close();

   814 				iTransmitPos2.Close();

   815 				iTransmitPos3.Close();

   816 				}

   817 				break;

   818 

   819 

   820 			case 16:

   821 				{

   822 				//reset the error code back

   823 				// The module request type - error value.

   824 				modDataIn.iRequestType = TModuleDataIn::EModuleRequestError;

   825 				modDataIn.iError = KErrNone;

   826 

   827 				// Send error value to test module - will block.

   828 				iUtils.NotifyModuleOfConfigChangeL(modDataIn);

   829 				}

   830 				break;

   831 

   832 			default:

   833 				break;

   834 			}

   835 

   836 		iNetSim.ClearAssistanceDataFilters();

   837 		iNetSim.Close();

   838 

   839 		CleanupStack::PopAndDestroy(adminApi);

   840 		iDoTransmitPos->Cancel();

   841 		CleanupStack::PopAndDestroy(iDoTransmitPos);

   842 

   843 		}

   844 

   845 

   846 	INFO_PRINTF1(_L("<<CT_LbsX3PStep_Transmit::doTestStepL()"));

   847 

   848 	return TestStepResult();

   849 	}

   850 

   851 

   852 

   853 /** NetSim callbacks given for a X3P, which we invoke as a result of the notify position update.

   854 */

   855 void CT_LbsX3PStep_Transmit::Connected()

   856 	{

   857 

   858 	CT_LbsNetSimStep::Connected();

   859 

   860 	// Create a posinfo and store in our shared array for later verification.

   861 	RPointerArray<TAny>& posInfoArr = iParent.iSharedData->iCurrentPosInfoArr;

   862 	TPositionInfo* posInfo = NULL;

   863 

   864 

   865 	iUtils.ResetAndDestroy_PosInfoArr(posInfoArr);	// Clear previous entries before new entry is appended.

   866 

   867 	//If X3PRefLocation flag is on, we have to test reference location functionality

   868 	//TBool bRefPos;

   869     //bRefPos = GetIntFromConfig(ConfigSection(), KLbsRefPos, bRefPos);

   870 

   871 	switch(iTestCaseId)

   872 		{

   873 		case 3:

   874 		case 4:

   875 			break;

   876 

   877 		case 13:

   878 			{

   879 			for(TInt counter = 0 ; counter < KMaxCount ; counter++)

   880 				{

   881 				posInfo = new TPositionInfo();

   882 				if (posInfo != NULL)

   883 					{

   884 					posInfoArr.Append(posInfo);

   885 					CT_LbsX3PDoTransmitPos* localDoTransmitPos;

   886 					localDoTransmitPos = (reinterpret_cast<CT_LbsX3PDoTransmitPos*>(iDoTransmitPosArr[counter]));

   887 					if(iRefPosFlag)

   888 						localDoTransmitPos->TransmitPositionReportingRefLoc(KDefaultDestination, KTransmitPriority, *posInfo);

   889 					else

   890 						localDoTransmitPos->TransmitPosition(KDefaultDestination, KTransmitPriority, *posInfo);

   891 

   892 					}

   893 				}

   894 			}

   895 			break;

   896 

   897 		case 130:

   898 			{

   899 			// Kick off transmit position.

   900 	 	    posInfo = new(ELeave) TPositionInfo();

   901 			CleanupStack::PushL(posInfo);

   902 			posInfoArr.AppendL(posInfo);

   903 			CleanupStack::Pop(posInfo);

   904 			if(iRefPosFlag)

   905 				iDoTransmitPos->TransmitPositionReportingRefLoc(KInvalidDestination, KTransmitPriority, *posInfo);

   906 			else

   907 				iDoTransmitPos->TransmitPosition(KInvalidDestination, KTransmitPriority, *posInfo);

   908 

   909 			iState = EWaiting;

   910 			}

   911 			break;

   912 		default:

   913 			{

   914 			posInfo = new TPositionInfo();

   915 			CleanupStack::PushL(posInfo);

   916 			posInfoArr.AppendL(posInfo);

   917 			CleanupStack::Pop(posInfo);

   918 

   919 			if(iTestCaseId ==133)

   920 				{

   921 				// Position requested at

   922 				iTimeRequested.UniversalTime();

   923 				}

   924 

   925 			if(iRefPosFlag)

   926 				{

   927 				iDoTransmitPos->TransmitPositionReportingRefLoc(KDefaultDestination, KTransmitPriority, *posInfo);

   928 				}

   929 			else

   930 				{

   931 				iDoTransmitPos->TransmitPosition(KDefaultDestination, KTransmitPriority, *posInfo);

   932 				}

   933 

   934 

   935 			iState = EWaiting;

   936 			}

   937 			break;

   938 

   939 		}

   940 	}

   941 

   942 void CT_LbsX3PStep_Transmit::NotifyRegisterLcsMoLr(const TDesC& aData)

   943 	{

   944 	//First NetSim callback (FROM: Gateway)

   945 

   946 	CT_LbsNetSimStep::NotifyRegisterLcsMoLr(aData);

   947 

   948 	// find out what aData is, it may be an idea to verify it's correct

   949 	// Verify correct destination telephone number:

   950 	//		if its an X3P aData will contain "something",

   951 	//		if its an MOLR aData should contain "nothing".

   952 

   953 	switch(iTestCaseId)

   954 		{

   955 		// X3P should be turned off for these test cases

   956 		case 111:

   957 		case 18:

   958 			{

   959 			INFO_PRINTF1(_L("<FONT><B>NotifyRegisterLcsMoLr should not be invoked. Test Failed. </B></FONT>"));

   960 			SetTestStepResult(EFail);

   961 			}

   962 			break;

   963 

   964 		case 130:

   965 			{

   966 			if(aData.Compare(KInvalidDestination) != 0)

   967 				{

   968 				INFO_PRINTF1(_L("<FOND><B>For case 130 the phone number should have been invalid.</B></FONT>"));

   969 				SetTestStepResult(EFail);

   970 				}

   971 			}

   972 			break;

   973 

   974 		case 115:

   975 			{

   976 			if(!iNetSim.SetResponseError(RLbsNetSimTest::KNetSimNetworkNotAvailable, ETrue))

   977 				{

   978 				INFO_PRINTF1(_L("CT_LbsClientStep_CellBasedNotifyPosUpdate::doTestStepL() Failed: Can't set NetSim's response error."));

   979 				SetTestStepResult(EFail);

   980 				}

   981 			}

   982 			break;

   983 

   984 		default:

   985 			{

   986 			if(aData.Compare(KDefaultDestination) != 0)

   987 				{

   988 				INFO_PRINTF1(_L("<FOND><B>For an X3P, aData should contain something.</B></FONT>"));

   989 				SetTestStepResult(EFail);

   990 				}

   991 			}

   992 		}

   993 	}

   994 

   995 

   996 

   997 void CT_LbsX3PStep_Transmit::NotifyMeasurementControlLocation(	const TPositionInfo& aPosition,

   998 										const RLbsAssistanceDataBuilderSet& aData,

   999 										const TLbsNetPosRequestQuality& aQuality)

  1000 	{

  1001 	//Second callback

  1002 

  1003 	// Call base functionality

  1004 	CT_LbsNetSimStep::NotifyMeasurementControlLocation(aPosition, aData, aQuality);

  1005 	/*

  1006 	aPosition is the reference position set at the top in netsim.setrefposition().

  1007 	compare aposition and this to verify its correct.

  1008 	*/

  1009 

  1010 

  1011 	//RPointerArray<TAny>& srcPosInfoArr = iParent.iSharedData->iVerifyPosInfoArr;

  1012 	//TPositionInfo* srcPosInfo = reinterpret_cast<TPositionInfo*>(srcPosInfoArr[0]);

  1013 

  1014 	//T_LbsUtils::TComparisonAccuracyType whatAccuracyToUse;

  1015 

  1016 	//if(iParent.iSharedData->iTestModuleInUse)

  1017 	//	{

  1018 	//	whatAccuracyToUse = T_LbsUtils::EExactAccuracy;

  1019 	//	}

  1020 	//else

  1021 	//	{

  1022 	//	whatAccuracyToUse = T_LbsUtils::ERoughAccuracy;

  1023 	//	}

  1024 	//TPositionInfo  refPosInfo;

  1025 	//refPosInfo.SetPosition(iRefPos);

  1026 	//if(!iUtils.Compare_PosInfo(refPosInfo, aPosition, whatAccuracyToUse))

  1027 

  1028 	TPositionInfo refPosInfo;

  1029 	T_LbsUtils::TComparisonAccuracyType accType;

  1030 

  1031 	refPosInfo.SetPosition(iRefPos);

  1032 

  1033 	if(iParent.iSharedData->iTestModuleInUse)

  1034 		accType = T_LbsUtils::EExactAccuracy;

  1035 	else

  1036 		accType = T_LbsUtils::ERoughAccuracy;

  1037 

  1038 	if(!iUtils.Compare_PosInfo(refPosInfo, aPosition, accType))

  1039 		{

  1040 		INFO_PRINTF1(_L("<FONT><B>Failed test, NotifyMeasurementControlLocation: srcPosInfo differs from aPositionInfo</B></FONT>"));

  1041 		SetTestStepResult(EFail);

  1042 		}

  1043 

  1044 	if(iParent.iSharedData->iTestModuleInUse)

  1045 		{

  1046 

  1047 		// Verify the assistance data for test mode.

  1048 		RLbsAssistanceDataBuilderSet& data = const_cast<RLbsAssistanceDataBuilderSet&>(aData);

  1049 		RUEPositioningGpsReferenceTimeBuilder* refTimeBuilder = NULL;

  1050 

  1051 		data.GetDataBuilder(refTimeBuilder);

  1052 

  1053 		// Create a reader from the builder's data to allow us to verify the actual

  1054 		// assistance data.

  1055 		TInt err;

  1056 

  1057 		RUEPositioningGpsReferenceTimeReader refTimeReader;

  1058 

  1059 		TRAP(err, refTimeReader.OpenL());

  1060 		if (err == KErrNone)

  1061 			{

  1062 			refTimeReader.DataBuffer() = refTimeBuilder->DataBuffer();

  1063 

  1064 			if (!iUtils.VerifySimpleAssistanceData(refTimeReader))

  1065 				{

  1066 				INFO_PRINTF1(_L("Failed test, assistance data incorrect."));

  1067 				SetTestStepResult(EFail);

  1068 				}

  1069 			refTimeReader.Close();

  1070 			}

  1071 

  1072 		else

  1073 			{

  1074 			INFO_PRINTF2(_L("Failed test, assistance data reader err %d."), err);

  1075 			SetTestStepResult(EFail);

  1076 			}

  1077 		}

  1078 	else

  1079 		{

  1080 		//Real data, dont know what to expect so cant check it for cnonsistency.

  1081 		}

  1082 

  1083 

  1084 	// Need to check quality. Should be same for real and test.

  1085 	// Can't check for NaN by a direct check

  1086 	TBool maxFixTimeOK = aQuality.MaxFixTime() == iNetPosQuality.MaxFixTime();

  1087 	TBool minHAccuracyOK = (aQuality.MinHorizontalAccuracy() == iNetPosQuality.MinHorizontalAccuracy()) ||

  1088 				(Math::IsNaN(aQuality.MinHorizontalAccuracy()) && Math::IsNaN(iNetPosQuality.MinHorizontalAccuracy()));

  1089 	TBool minVAccuracyOK = (aQuality.MinVerticalAccuracy() == iNetPosQuality.MinVerticalAccuracy()) ||

  1090 				(Math::IsNaN(aQuality.MinVerticalAccuracy()) && Math::IsNaN(iNetPosQuality.MinVerticalAccuracy()));

  1091 

  1092 	if(	!maxFixTimeOK || !minHAccuracyOK || !minVAccuracyOK)

  1093 		{

  1094 		INFO_PRINTF1(_L("NotifyMeasurementControlLocation: Quality should have matched."));

  1095 		SetTestStepResult(EFail);

  1096 		}

  1097 

  1098 	if(iTestCaseId == 116)

  1099 		{

  1100 		if(!iNetSim.SetResponseError(RLbsNetSimTest::KNetSimNetworkNotAvailable, ETrue))

  1101 			{

  1102 			INFO_PRINTF1(_L("CT_LbsClientStep_CellBasedNotifyPosUpdate::doTestStepL() Failed: Can't set NetSim's response error."));

  1103 			SetTestStepResult(EFail);

  1104 			}

  1105 		}

  1106 	}

  1107 

  1108 

  1109 // NotifyMeasurementReportLocation callback, aPosition should match iVerifyPosInfoArr

  1110 void CT_LbsX3PStep_Transmit::NotifyMeasurementReportLocation(const TPositionInfo& aPosition)

  1111 	{

  1112 

  1113 	//Third NetSim callback (FROM: Gateway)

  1114 	CT_LbsNetSimStep::NotifyMeasurementReportLocation(aPosition);

  1115 

  1116 	T_LbsUtils::TComparisonAccuracyType whatAccuracyToUse;

  1117 

  1118 	if(iParent.iSharedData->iTestModuleInUse)

  1119 		{

  1120 		whatAccuracyToUse = T_LbsUtils::EExactAccuracy;

  1121 		}

  1122 		else

  1123 		{

  1124 		whatAccuracyToUse = T_LbsUtils::ERoughAccuracy;

  1125 		}

  1126 

  1127 	// get the ref position from the iVerifyPosInfoArr (the last time) then verify with aPosition

  1128 	// the array would have been added to at the call to TransmitPosition above in net connect callback

  1129 

  1130 	// Common stuff

  1131 	// Create a posinfo and store in our shared array for later verification.

  1132 

  1133 	RPointerArray<TAny>& posInfoArr = iParent.iSharedData->iVerifyPosInfoArr;

  1134