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 ctlbsx3pstepconflict.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/lbsnetcommon.h>

    23 //#include <kernel.h>

    24 // LBS test includes.

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

    26 #include "ctlbsx3pstepconflict.h"

    27 #include <lbs/test/tlbsutils.h>

    28 

    29 const TInt KLbsKeepAlivePeriod1=10*1000000; 

    30 

    31 _LIT(KDestIDL, "07725547323");

    32 _LIT(KDestIDH, "07703125837");

    33 _LIT(KDestIDM, "07703103066");

    34 const TUint priorityL = X3P_PRIORITY_TIMER;

    35 const TUint priorityM = X3P_PRIORITY_MENU;

    36 const TUint priorityH = X3P_PRIORITY_PUSH;

    37 //TPositionInfo postitionInfo;

    38 static TUint iterator=0;

    39 

    40 /**

    41  * Destructor

    42  */

    43 CT_LbsX3PStep_Conflict::~CT_LbsX3PStep_Conflict()

    44 	{

    45 	iDoPosUpdate->Cancel();

    46 	delete iDoPosUpdate;

    47 	if(iDoTransmitPosAO!=NULL)

    48 		delete iDoTransmitPosAO;

    49 	if(iDoTransmitPosAO2 != NULL)

    50 		delete iDoTransmitPosAO2;

    51 	

    52 	iTransmitPositioner2.Close();

    53 	iTransmitPositioner.Close();

    54 	iServer.Close();					

    55 	

    56 	iTSArray.Close();

    57 	}

    58 

    59 

    60 /**

    61  * Constructor

    62  */

    63 CT_LbsX3PStep_Conflict::CT_LbsX3PStep_Conflict(CT_LbsX3PServer& aParent) : CT_LbsX3PStep(aParent)

    64 	{

    65 	SetTestStepName(KLbsX3PStep_Conflict);

    66 	}

    67 

    68 

    69 /**

    70 Static Constructor

    71 */

    72 CT_LbsX3PStep_Conflict* CT_LbsX3PStep_Conflict::New(CT_LbsX3PServer& aParent)

    73 	{

    74 	CT_LbsX3PStep_Conflict* testStep = new CT_LbsX3PStep_Conflict(aParent);

    75 	// Note the lack of ELeave.

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

    77 	if (testStep)

    78 		{

    79 		TInt err = KErrNone;

    80 

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

    82 		if (err)

    83 			{

    84 			delete testStep;

    85 			testStep = NULL;

    86 			}

    87 		}

    88 		

    89 	return testStep;

    90 	}

    91 

    92 void CT_LbsX3PStep_Conflict::ConstructL()

    93 	{

    94 		CT_LbsX3PStep::ConstructL();

    95 

    96 		//The active object wrapper for the notify position update.

    97 		iDoPosUpdate = CT_LbsDoPosUpdate::NewL(this);

    98 	}

    99 

   100 

   101 /**

   102  * @return - TVerdict code

   103  * Override of base class pure virtual

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

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

   106  */

   107 TVerdict CT_LbsX3PStep_Conflict::doTestStepL()

   108 	{

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

   110 	INFO_PRINTF1(_L(">>CT_LbsX3PStep_Conflict::doTestStepL()"));

   111 

   112 	if (TestStepResult() == EPass)

   113 		{		

   114 		//TInt err = KErrNone;

   115 		//RLbsTransmitPositionServer server;

   116 

   117 		//TInt testCaseId;

   118 		TRequestStatus aStatus;

   119 		TLbsTransmitPositionOptions tOptions;

   120 

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

   122 		iStateX3P = EX3POk;

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

   124 		//CleanupClosePushL(server);

   125 

   126 		INFO_PRINTF1(_L("server opened"));

   127 	

   128 		User::LeaveIfError(iTransmitPositioner.Open(iServer));

   129 		//CleanupClosePushL(iTransmitPositioner);

   130 

   131 		//second transmit positioner is used for test case 7-10

   132 		User::LeaveIfError(iTransmitPositioner2.Open(iServer));

   133 		//CleanupClosePushL(iTransmitPositioner2);

   134 

   135 		iDoTransmitPosAO = CT_LbsX3PDoTransmitPos::NewL(this, iTransmitPositioner);

   136 		iDoTransmitPosAO2 = CT_LbsX3PDoTransmitPos::NewL(this, iTransmitPositioner2);

   137 		

   138 		//define local variables to point current and verify arrays.

   139 		RPointerArray<TAny>& verifyPosInfoArr = iParent.iSharedData->iVerifyPosInfoArr;

   140 		RPointerArray<TAny>& curPosInfoArr = iParent.iSharedData->iCurrentPosInfoArr;

   141 

   142 		T_LbsUtils utils;

   143 		RPointerArray<TTime> doTransmitPosTime;

   144 		RPointerArray<TTime> notifyMRLocationTime;

   145 		RPointerArray<TTime> doPosUpdateTime;

   146 		RPointerArray<TTime> notifyMCLocationTime;

   147 		RPointerArray<TTime> notifyReleaseLcsMoLrTime;

   148 			

   149 		TModuleDataIn modDataInTimeout; // Used to send test information to the test module.

   150 		const TInt KLbsTestModuleTimeOut = 1000000;

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

   152 		modDataInTimeout.iRequestType = TModuleDataIn::EModuleRequestTimeOut;

   153 		// Micro seconds time value to delay the return position update from the module.

   154 		modDataInTimeout.iTimeOut = KLbsTestModuleTimeOut;

   155 

   156 		TModuleDataIn modDataInAssDataOn;

   157 		modDataInAssDataOn.iRequestType = TModuleDataIn::EModuleRequestTestMode;

   158 		modDataInAssDataOn.iAssDataEventType = TModuleDataIn::EAssDataEventExpectSingle;

   159 		modDataInAssDataOn.iAssDataTestMode = TModuleDataIn::EModuleTestModeAssDataOn;

   160 		

   161 		iNetSim.ConnectL(this); // Once we have connected, we will get NetSim callbacks.

   162 		iNetSim.SetStepMode(ETrue); //To run NetSim in step mode

   163 

   164 		// Create reference location:

   165 		// Location to use.

   166 		TPositionInfo* srcPosInfo = reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0]);

   167 		TPosition srcPos;

   168 		srcPosInfo->GetPosition(srcPos);

   169 	

   170 		if (!iNetSim.SetReferenceLocation(srcPos))

   171 			{

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

   173 			SetTestStepResult(EFail);

   174 			iNetSim.Close();

   175 			return TestStepResult();

   176 			}	

   177 	

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

   179 		TTimeIntervalMicroSeconds maxFixTime(20*1000000);

   180 		TLbsNetPosRequestQuality netPosQuality;

   181 

   182 		netPosQuality.SetMaxFixTime(maxFixTime);

   183 		netPosQuality.SetMinHorizontalAccuracy(srcPos.HorizontalAccuracy());

   184 		netPosQuality.SetMinVerticalAccuracy(srcPos.VerticalAccuracy());

   185 		

   186 		if (!iNetSim.SetQuality(netPosQuality))

   187 			{

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

   189 			SetTestStepResult(EFail);

   190 			iNetSim.Close();

   191 			return TestStepResult();

   192 			}

   193 

   194 		// Set plugin to use.

   195 		TUid pluginUid;

   196 		if(iParent.iSharedData->iTestModuleInUse)

   197 			{

   198 			pluginUid = TUid::Uid(KSimpleAssistanceDataProviderPluginUidValue);

   199 			}

   200 		else

   201 			{

   202 			pluginUid = TUid::Uid(KSuplAssistanceDataProviderPluginUidValue);

   203 			}

   204 			

   205 		if (!iNetSim.SetAssistanceDataProvider(pluginUid))

   206 			{

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

   208 			SetTestStepResult(EFail);

   209 			iNetSim.Close();

   210 			return TestStepResult();

   211 			}

   212 

   213 		//Timeout for Transmit Location

   214 		TLbsTransmitPositionOptions transmitOptions;

   215 		transmitOptions.SetTimeOut(20*1000000);  

   216 

   217 		iTransmitPositioner.SetTransmitOptions(transmitOptions);

   218 

   219 		//Reset iterator value

   220 		iterator=0;

   221 		

   222 		// Kick off the keep alive timer.

   223 		TTimeIntervalMicroSeconds32 interval(KLbsKeepAlivePeriod1);

   224 		iKeepAliveTimer->SetTimer(interval);

   225 

   226 		// Carry out unique test actions.

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

   228 			{

   229 			switch (iTestCaseId)

   230 				{

   231 				// Test case LBS-X3P-Conflict-0001

   232 				case 1:

   233 					break;

   234 					

   235 				// Test case LBS-X3P-Conflict-0002

   236 				case 2:

   237 				case 3:

   238 				case 4:

   239 					{

   240 					//Set assistence data mode flag to on so that MoLr gets all notifications.

   241 					utils.NotifyModuleOfConfigChangeL(modDataInAssDataOn);

   242 

   243 					// Kick off test.

   244 					CActiveScheduler::Start();

   245 

   246 					AnalyseCallbackFlags( KLbsCallback_Got_NotifyDoTransmitPos, doTransmitPosTime);

   247 					AnalyseCallbackFlags( KLbsCallback_Got_DoPosUpdate, doPosUpdateTime);

   248 

   249 					TBool bResult;

   250 					if(iParent.iSharedData->iTestModuleInUse)

   251 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::EExactAccuracy);

   252 					else

   253 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::ERoughAccuracy);

   254 

   255 					if(doTransmitPosTime.Count() !=1 ||doPosUpdateTime.Count() != 0  || !bResult)

   256 						{

   257 						INFO_PRINTF1(_L("<FONT><B>MoLr wasn't cancelled after getting X3P(Push)</B></FONT>"));

   258 						SetTestStepResult(EFail);	

   259 						}

   260 					}

   261 					break;

   262 

   263 				case 5:

   264 				case 12:

   265 					{

   266 					//Set assistence data mode flag to on so that MoLr gets all notifications.

   267 					utils.NotifyModuleOfConfigChangeL(modDataInAssDataOn);

   268 

   269 					// Kick off test.

   270 					CActiveScheduler::Start();

   271 

   272 					AnalyseCallbackFlags( KLbsCallback_Got_NotifyDoTransmitPos, doTransmitPosTime);

   273 					AnalyseCallbackFlags( KLbsCallback_Got_DoPosUpdate, doPosUpdateTime);

   274 

   275 					TBool bResult;

   276 					if(iParent.iSharedData->iTestModuleInUse)

   277 						{

   278 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::EExactAccuracy);

   279 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::EExactAccuracy);

   280 						}

   281 					else

   282 						{

   283 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::ERoughAccuracy);

   284 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::ERoughAccuracy);

   285 						}

   286 

   287 					if(doTransmitPosTime.Count() !=1 ||doPosUpdateTime.Count() != 1  ||doPosUpdateTime[0]->Int64() > doTransmitPosTime[0]->Int64() || !bResult)

   288 						{

   289 						INFO_PRINTF1(_L("<FONT><B>X3P didn't complete before MoLr</B></FONT>"));

   290 						SetTestStepResult(EFail);	

   291 						}

   292 					}

   293 					break;

   294 					

   295 					

   296 				case 21:

   297 				case 22:

   298 				case 54: 	//Check that X3P(Push) completes after X3P(Menu) as it was too late to cancel X3P(Menu) by X3P(Push)

   299 				case 62:	//Check

   300 				case 102:

   301 				case 94:  

   302 					{

   303 					// Kick off test.

   304 					CActiveScheduler::Start();

   305 

   306 					AnalyseCallbackFlags( KLbsCallback_Got_NotifyDoTransmitPos, doTransmitPosTime);

   307 

   308 					TBool bResult;

   309 					if(iParent.iSharedData->iTestModuleInUse)

   310 						{

   311 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::EExactAccuracy);

   312 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::EExactAccuracy);

   313 						}

   314 					else

   315 						{

   316 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::ERoughAccuracy);

   317 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::ERoughAccuracy);

   318 						}

   319 

   320 					if(doTransmitPosTime.Count() !=2 || !bResult)

   321 						{

   322 						INFO_PRINTF1(_L("<FONT><B>X3P(Push) wasn't completed before X3P(Timer)</B></FONT>"));

   323 						SetTestStepResult(EFail);	

   324 						}

   325 					}

   326 					break;

   327 

   328 					

   329 				case 31:

   330 				case 32:

   331 				case 34:

   332 

   333 				case 72:

   334 				case 74:

   335 

   336 				case 112:

   337 				case 114:

   338 					{

   339 					//Set minimum response time for a-gps

   340 					utils.NotifyModuleOfConfigChangeL(modDataInTimeout);

   341 

   342 					// Kick off test.

   343 					CActiveScheduler::Start();

   344 

   345 					AnalyseCallbackFlags( KLbsCallback_Got_NotifyDoTransmitPos, doTransmitPosTime);

   346 					AnalyseCallbackFlags( KLbsCallback_NetSim_Got_NotifyMeasurementControlLocation, notifyMCLocationTime);

   347 

   348 					TBool bResult;

   349 					if(iParent.iSharedData->iTestModuleInUse)

   350 						{

   351 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::EExactAccuracy);

   352 						}

   353 					else

   354 						{

   355 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::ERoughAccuracy);

   356 						}

   357 

   358 					//Check that X3P(push) complets and MTLR doesn't start

   359 					//There should be one transmit position flag 

   360 					//There should be just one NotifyMeasurementControlLocation flag to make sure that MTLR is not even started

   361 					if(doTransmitPosTime.Count() !=1 ||notifyMCLocationTime.Count() !=1 || ! bResult)

   362 						{

   363 						INFO_PRINTF1(_L("<FONT><B>MTLR wasn't get cancelled </B></FONT>"));

   364 						SetTestStepResult(EFail);	

   365 						}

   366 					}

   367 					break;

   368 					

   369 				case 35:

   370 				case 75:

   371 				case 115:

   372 					{

   373 					//Set minimum response time for a-gps

   374 					utils.NotifyModuleOfConfigChangeL(modDataInTimeout);

   375 

   376 					// Kick off test.

   377 					CActiveScheduler::Start();

   378 

   379 					AnalyseCallbackFlags( KLbsCallback_Got_NotifyDoTransmitPos, doTransmitPosTime);

   380 					AnalyseCallbackFlags( KLbsCallback_NetSim_Got_NotifyMeasurementReportLocation, notifyMRLocationTime);

   381 

   382 					TBool bResult;

   383 					if(iParent.iSharedData->iTestModuleInUse)

   384 						{

   385 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::EExactAccuracy);

   386 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::EExactAccuracy);

   387 						}

   388 					else

   389 						{

   390 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::ERoughAccuracy);

   391 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::ERoughAccuracy);

   392 						}

   393 

   394 					//Check that X3P(Push) completes followed by MTLR

   395 					//There should be one transmit position flag

   396 					//there should be two notifyMeasurementReportLocation flags

   397 					//second notifymesurementreportlocation flag should come after transmitPostion flag

   398 					if(doTransmitPosTime.Count() !=1 ||notifyMRLocationTime.Count() !=2 ||doTransmitPosTime[0]->Int64() > notifyMRLocationTime[1]->Int64() || !bResult)

   399 						{

   400 						INFO_PRINTF1(_L("<FONT><B>MTLR didnt follow X3P(Push) </B></FONT>"));

   401 						SetTestStepResult(EFail);	

   402 						}

   403 					}

   404 					break;

   405 

   406 

   407 				case 42:

   408 				case 43:

   409 

   410 				case 82:		//0082

   411 				case 83: 	//0083

   412 

   413 				case 122:	//0122

   414 				case 123:	//0123

   415 

   416 				case 1001:

   417 					{

   418 					//Set minimum response time for a-gps

   419 					utils.NotifyModuleOfConfigChangeL(modDataInTimeout);

   420 

   421 					// Kick off test.

   422 					CActiveScheduler::Start();

   423 

   424 					AnalyseCallbackFlags( KLbsCallback_Got_NotifyDoTransmitPos, doTransmitPosTime);

   425 					AnalyseCallbackFlags( KLbsCallback_NetSim_Got_NotifyMeasurementReportLocation, notifyMRLocationTime);

   426 					AnalyseCallbackFlags( KLbsCallback_NetSim_Got_NotifyReleaseLcsMoLr, notifyReleaseLcsMoLrTime);

   427 

   428 					TBool bResult;

   429 					if(iParent.iSharedData->iTestModuleInUse)

   430 						{

   431 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::EExactAccuracy);

   432 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::EExactAccuracy);

   433 						}

   434 					else

   435 						{

   436 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::ERoughAccuracy);

   437 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::ERoughAccuracy);

   438 						}

   439 

   440 					//Check that E-MTLR interrupts X3P(Push) and complets before X3P(Push)

   441 					//There should be one transmit position flag

   442 					//There should be two notifiyMeasurementReportLocation flags

   443 					//The time stamp of second mesurementreportlocation flag is before transmit position flag.

   444 					//There should be two releaseLcsMoLr flags

   445 					if(doTransmitPosTime.Count() !=1 ||notifyMRLocationTime.Count() !=2 || notifyReleaseLcsMoLrTime.Count() !=2 ||

   446 						doTransmitPosTime[0]->Int64() < notifyMRLocationTime[1]->Int64() || !bResult)

   447 						{

   448 						INFO_PRINTF1(_L("<FONT><B>MTLR wasn't get cancelled </B></FONT>"));

   449 						SetTestStepResult(EFail);	

   450 						}

   451 					}

   452 					break;

   453 					

   454 				case 44:

   455 				case 84:	//0084

   456 				case 124:	//0124

   457 					{

   458 					// Kick off test.

   459 					CActiveScheduler::Start();

   460 

   461 					AnalyseCallbackFlags( KLbsCallback_Got_NotifyDoTransmitPos, doTransmitPosTime);

   462 					AnalyseCallbackFlags( KLbsCallback_NetSim_Got_NotifyMeasurementReportLocation, notifyMRLocationTime);

   463 					AnalyseCallbackFlags( KLbsCallback_NetSim_Got_NotifyReleaseLcsMoLr, notifyReleaseLcsMoLrTime);

   464 

   465 					TBool bResult;

   466 					if(iParent.iSharedData->iTestModuleInUse)

   467 						{

   468 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::EExactAccuracy);

   469 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::EExactAccuracy);

   470 						}

   471 					else

   472 						{

   473 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::ERoughAccuracy);

   474 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::ERoughAccuracy);

   475 						}

   476 

   477 					//Check that E-MTLR interrupts X3P(Push) and complets before X3P(Push)

   478 					//There should be one transmit position flag

   479 					//There should be three notifiyMeasurementReportLocation flags

   480 					//The time stamp of third mesurementreportlocation flag is before transmit position flag.

   481 					//There should be two releaseLcsMoLr flags

   482 					if(doTransmitPosTime.Count() !=1 ||notifyMRLocationTime.Count() !=3 || notifyReleaseLcsMoLrTime.Count() !=2 ||

   483 						doTransmitPosTime[0]->Int64() < notifyMRLocationTime[1]->Int64() || !bResult)

   484 						{

   485 						INFO_PRINTF1(_L("<FONT><B>MTLR wasn't get cancelled </B></FONT>"));

   486 						SetTestStepResult(EFail);	

   487 						}

   488 					}

   489 					break;

   490 					

   491 				case 45:

   492 				case 85:		//0085

   493 				case 125:	//0125

   494 					{

   495 					//Set minimum response time for a-gps

   496 					utils.NotifyModuleOfConfigChangeL(modDataInTimeout);

   497 

   498 					// Kick off test.

   499 					CActiveScheduler::Start();

   500 

   501 					AnalyseCallbackFlags( KLbsCallback_Got_NotifyDoTransmitPos, doTransmitPosTime);

   502 					AnalyseCallbackFlags( KLbsCallback_NetSim_Got_NotifyMeasurementReportLocation, notifyMRLocationTime);

   503 					AnalyseCallbackFlags( KLbsCallback_NetSim_Got_NotifyReleaseLcsMoLr, notifyReleaseLcsMoLrTime);

   504 

   505 					TBool bResult;

   506 					if(iParent.iSharedData->iTestModuleInUse)

   507 						{

   508 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::EExactAccuracy);

   509 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::EExactAccuracy);

   510 						}

   511 					else

   512 						{

   513 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::ERoughAccuracy);

   514 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::ERoughAccuracy);

   515 						}

   516 

   517 					//Check that E-MTLR interrupts X3P(Push) and complets before X3P(Push)

   518 					//There should be one transmit position flag

   519 					//There should be two notifiyMeasurementReportLocation flags

   520 					//The time stamp of second mesurementreportlocation flag is after transmit position flag.

   521 					//There should be one releaseLcsMoLr flags

   522 					if(doTransmitPosTime.Count() !=1 ||notifyMRLocationTime.Count() !=2 || notifyReleaseLcsMoLrTime.Count() !=1 ||

   523 						doTransmitPosTime[0]->Int64() > notifyMRLocationTime[1]->Int64() || !bResult)

   524 						{

   525 						INFO_PRINTF1(_L("<FONT><B>MTLR wasn't get cancelled </B></FONT>"));

   526 						SetTestStepResult(EFail);	

   527 						}

   528 					}

   529 					break;

   530 

   531 					

   532 				case 51:

   533 					//TBD

   534 					break;

   535 					

   536 				case 53:

   537 					{

   538 					// Kick off test.

   539 					CActiveScheduler::Start();

   540 

   541 					AnalyseCallbackFlags( KLbsCallback_Got_NotifyDoTransmitPos, doTransmitPosTime);

   542 					AnalyseCallbackFlags( KLbsCallback_NetSim_Got_NotifyMeasurementControlLocation, notifyMCLocationTime);

   543 					AnalyseCallbackFlags( KLbsCallback_NetSim_Got_NotifyReleaseLcsMoLr, notifyReleaseLcsMoLrTime);

   544 

   545 					TBool bResult;

   546 					if(iParent.iSharedData->iTestModuleInUse)

   547 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::EExactAccuracy);

   548 					else

   549 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::ERoughAccuracy);

   550 

   551 					//Check that X3P(Push) cancels X3P(Menu) 

   552 					//There should be one transmit position flag

   553 					//There should be two notifiyMeasurementControlLocation flags

   554 					//There should be two releaseLcsMoLr flags

   555 					if(doTransmitPosTime.Count() !=1 ||notifyMCLocationTime.Count() !=2 || notifyReleaseLcsMoLrTime.Count() !=2 || !bResult)

   556 						{

   557 						INFO_PRINTF1(_L("<FONT><B>X3P(Push) didn't cancel X3P(Menu) </B></FONT>"));

   558 						SetTestStepResult(EFail);	

   559 						}

   560 					}

   561 					break;

   562 					

   563 					

   564 				case 61:

   565 					break;

   566 					

   567 					

   568 				case 71:

   569 					break;

   570 					

   571 					

   572 				case 81:	//0081

   573 					break;

   574 					

   575 					

   576 				case 93:	//0093

   577 					{

   578 					// Kick off test.

   579 					CActiveScheduler::Start();

   580 

   581 					AnalyseCallbackFlags( KLbsCallback_Got_NotifyDoTransmitPos, doTransmitPosTime);

   582 					AnalyseCallbackFlags( KLbsCallback_NetSim_Got_NotifyMeasurementControlLocation, notifyMCLocationTime);

   583 					AnalyseCallbackFlags( KLbsCallback_NetSim_Got_NotifyReleaseLcsMoLr, notifyReleaseLcsMoLrTime);

   584 

   585 					TBool bResult;

   586 					if(iParent.iSharedData->iTestModuleInUse)

   587 						{

   588 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::EExactAccuracy);

   589 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::EExactAccuracy);

   590 						}

   591 					else

   592 						{

   593 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::ERoughAccuracy);

   594 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::ERoughAccuracy);

   595 						}

   596 

   597 					//X3P(Push) should interupt X3P(Timer) and X3P(Timer) should complete after X3P(Push)

   598 					//There should be two transmit position flags

   599 					//There should be three release flags

   600 					if(doTransmitPosTime.Count() !=2 ||notifyMCLocationTime.Count() !=3 || notifyReleaseLcsMoLrTime.Count() !=3 || !bResult)

   601 						{

   602 						INFO_PRINTF1(_L("<FONT><B>MTLR wasn't get cancelled </B></FONT>"));

   603 						SetTestStepResult(EFail);	

   604 						}

   605 					}

   606 					break;

   607 					

   608 					

   609 				case 111:

   610 					break;

   611 					

   612 					

   613 				case 121:	//0121

   614 					break;

   615 					

   616 

   617 				case 133:

   618 					{

   619 					//Set minimum response time for a-gps

   620 					utils.NotifyModuleOfConfigChangeL(modDataInTimeout);

   621 

   622 					// Kick off test.

   623 					CActiveScheduler::Start();

   624 

   625 					AnalyseCallbackFlags( KLbsCallback_Got_NotifyDoTransmitPos, doTransmitPosTime);

   626 					AnalyseCallbackFlags( KLbsCallback_NetSim_Got_NotifyMeasurementControlLocation, notifyMCLocationTime);

   627 

   628 					TBool bResult;

   629 					if(iParent.iSharedData->iTestModuleInUse)

   630 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::EExactAccuracy);

   631 					else

   632 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::ERoughAccuracy);

   633 

   634 					//X3P(Push) should cancel MTLR when X3P(Push) called at 

   635 					//There should be one transmit position flags

   636 					//There should be one MeasurementControlLocation flag

   637 					if(doTransmitPosTime.Count() !=1 ||notifyMCLocationTime.Count() !=1 || !bResult)

   638 						{

   639 						INFO_PRINTF1(_L("<FONT><B>MTLR wasn't get cancelled </B></FONT>"));

   640 						SetTestStepResult(EFail);	

   641 						}

   642 					}

   643 					break;

   644 

   645 				case 134:

   646 					{

   647 					//Set minimum response time for a-gps

   648 					utils.NotifyModuleOfConfigChangeL(modDataInTimeout);

   649 

   650 					// Kick off test.

   651 					CActiveScheduler::Start();

   652 

   653 					AnalyseCallbackFlags( KLbsCallback_Got_NotifyDoTransmitPos, doTransmitPosTime);

   654 					AnalyseCallbackFlags( KLbsCallback_NetSim_Got_NotifyMeasurementReportLocation, notifyMRLocationTime);

   655 

   656 					TBool bResult;

   657 					if(iParent.iSharedData->iTestModuleInUse)

   658 						{

   659 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::EExactAccuracy);

   660 						}

   661 					else

   662 						{

   663 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::ERoughAccuracy);

   664 						}

   665 

   666 					//X3P(Push) should cancel MTLR when X3P(Push) called at 

   667 					//There should be one transmit position flags

   668 					//There should be one MeasurementReportLocation flag

   669 					if(doTransmitPosTime.Count() !=1 ||notifyMRLocationTime.Count() !=1 || !bResult)

   670 						{

   671 						INFO_PRINTF1(_L("<FONT><B>MTLR wasn't get cancelled </B></FONT>"));

   672 						SetTestStepResult(EFail);	

   673 						}

   674 					}

   675 					break;

   676 

   677 				case 135:	//0135

   678 

   679 				case 143:

   680 				case 144:

   681 					{

   682 					//Set minimum response time for a-gps

   683 					utils.NotifyModuleOfConfigChangeL(modDataInTimeout);

   684 

   685 					// Kick off test.

   686 					CActiveScheduler::Start();

   687 

   688 					AnalyseCallbackFlags( KLbsCallback_Got_NotifyDoTransmitPos, doTransmitPosTime);

   689 					AnalyseCallbackFlags( KLbsCallback_NetSim_Got_NotifyMeasurementReportLocation, notifyMRLocationTime);

   690 

   691 					TBool bResult;

   692 					if(iParent.iSharedData->iTestModuleInUse)

   693 						{

   694 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::EExactAccuracy);

   695 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::EExactAccuracy);

   696 						}

   697 					else

   698 						{

   699 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::ERoughAccuracy);

   700 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::ERoughAccuracy);

   701 						}

   702 

   703 					//X3P(Push) should complete after MTLR as its too late to cancel MTLR. 

   704 					//There should be one transmit position flags

   705 					//There should be two MeasurementReportLocation flag

   706 					//The time stamp of Transmit position should be after second MeasurementReportLocation flag

   707 					if(doTransmitPosTime.Count() !=1 ||notifyMRLocationTime.Count() !=2 || 

   708 						doTransmitPosTime[0]->Int64() < notifyMRLocationTime[1]->Int64() || !bResult)

   709 						{

   710 						INFO_PRINTF1(_L("<FONT><B>MTLR wasn't get cancelled </B></FONT>"));

   711 						SetTestStepResult(EFail);	

   712 						}

   713 					}

   714 					break;

   715 

   716 

   717 				case 1002:

   718 					{

   719 					//Set minimum response time for a-gps

   720 					utils.NotifyModuleOfConfigChangeL(modDataInTimeout);

   721 

   722 					//Kick off test.

   723 					CActiveScheduler::Start();

   724 

   725 					AnalyseCallbackFlags( KLbsCallback_Got_NotifyDoTransmitPos, doTransmitPosTime);

   726 					AnalyseCallbackFlags( KLbsCallback_NetSim_Got_NotifyMeasurementReportLocation, notifyMRLocationTime);

   727 

   728 					TBool bResult;

   729 					if(iParent.iSharedData->iTestModuleInUse)

   730 						{

   731 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[2])), T_LbsUtils::EExactAccuracy);

   732 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::EExactAccuracy);

   733 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[2])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::EExactAccuracy);

   734 						}

   735 					else

   736 						{

   737 						bResult = utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[2])), T_LbsUtils::ERoughAccuracy);

   738 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[1])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[1])), T_LbsUtils::ERoughAccuracy);

   739 						bResult &= utils.Compare_PosInfo(*(reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[2])), *(reinterpret_cast<TPositionInfo*>(curPosInfoArr[0])), T_LbsUtils::ERoughAccuracy);

   740 						}

   741 

   742 					//X3P(Push) should cancel MTLR when X3P(Push) called at 

   743 					//There should be one transmit position flags

   744 					//There should be one MeasurementReportLocation flag

   745 					if(doTransmitPosTime.Count() !=2 ||notifyMRLocationTime.Count() !=3 ||

   746 						doTransmitPosTime[0]->Int64() < notifyMRLocationTime[1]->Int64() || !bResult)

   747 						{

   748 						INFO_PRINTF1(_L("<FONT><B>MTLR wasn't get cancelled </B></FONT>"));

   749 						SetTestStepResult(EFail);	

   750 						}

   751 					}

   752 					break;

   753 

   754 				case 1003:

   755 					//TBD

   756 					ASSERT(FALSE);

   757 					break;

   758 

   759 				case 1004:

   760 					//TBD

   761 					ASSERT(FALSE);

   762 					break;

   763 

   764 

   765 				default:

   766 					{

   767 					User::Panic(KLbsX3PStep_Conflict, KErrUnknown);

   768 					}					

   769 				}

   770 			}

   771 		// Clean up.

   772 		iNetSim.Close();

   773 		//CleanupStack::PopAndDestroy(&iTransmitPositioner2);					

   774 		//CleanupStack::PopAndDestroy(&iTransmitPositioner);					

   775 		//CleanupStack::PopAndDestroy(&server);	

   776 		}

   777 

   778 

   779 	INFO_PRINTF1(_L("<<CT_LbsX3PStep_Conflict::doTestStepL()"));

   780 

   781 	return TestStepResult();

   782 	}

   783 

   784 void CT_LbsX3PStep_Conflict::MT_LbsX3PDoRefPosCallback(const TRequestStatus& aStatus,const TPositionInfo& aRefPosInfo)

   785 	{

   786 	(void)aStatus;

   787 	(void)aRefPosInfo;

   788 	}

   789 

   790 

   791 

   792 /**	

   793 	Transmit Position callback.

   794 **/

   795 

   796 void CT_LbsX3PStep_Conflict::MT_LbsX3PDoTransmitPosCallback(TRequestStatus& aStatus, CT_LbsX3PDoTransmitPos* aDoTransmitPosAO)

   797 	{

   798 	INFO_PRINTF1(_L("Got - Transmit Position - Callback Event."));

   799 

   800 	//We can check callback completion order here in the case of two X3Ps

   801 

   802 	switch(iTestCaseId)

   803 		{

   804 		case 22:

   805 		case 54:

   806 		case 62:

   807 		case 94:

   808 		case 102:

   809 			{

   810 			if(iterator==0 && aDoTransmitPosAO != iDoTransmitPosAO)

   811 				iStateX3P=EX3PErrorReported;

   812 			else if(iterator==1 && aDoTransmitPosAO != iDoTransmitPosAO2)

   813 				iStateX3P=EX3PErrorReported;

   814 			else if(aStatus.Int() != KErrNone)

   815 				iStateX3P=EX3PErrorReported;

   816 			}

   817 			break;

   818 

   819 		case 53:

   820 			{

   821 			if(iterator==0 && aStatus.Int() != KErrCancel)

   822 				iStateX3P=EX3PErrorReported;

   823 			else if(iterator==1 && aDoTransmitPosAO != iDoTransmitPosAO2)

   824 				iStateX3P=EX3PErrorReported;

   825 			else if(aStatus.Int() != KErrNone)

   826 				iStateX3P=EX3PErrorReported;

   827 			}

   828 			break;

   829 

   830 		case 93:  //Might have to modify as Timer and Menu priorities are same in the case of MOAP

   831 			{

   832 			if(iterator==0 && aDoTransmitPosAO != iDoTransmitPosAO && aStatus.Int() != KErrCancel)

   833 				iStateX3P=EX3PErrorReported;

   834 			else if(iterator==1 && aDoTransmitPosAO != iDoTransmitPosAO2)

   835 				iStateX3P=EX3PErrorReported;

   836 			else if(iterator==2 && aDoTransmitPosAO != iDoTransmitPosAO)

   837 				iStateX3P=EX3PErrorReported;

   838 			else if(aStatus.Int() != KErrNone)

   839 				iStateX3P=EX3PErrorReported;

   840 			}

   841 			break;

   842 

   843 		//For the following cases, the error code should never be cancel or anything else...

   844 		case 32:

   845 		case 34:

   846 		case 35:

   847 		case 45:

   848 

   849 		case 72:

   850 		case 74:

   851 		case 75:

   852 		case 85:

   853 

   854 		case 112:

   855 		case 114:

   856 		case 115:

   857 		case 125:

   858 

   859 		case 133:

   860 		case 134:

   861 		case 135:

   862 		case 143:

   863 		case 144:

   864 			{

   865 			if(aStatus.Int() != KErrNone)

   866 				iStateX3P=EX3PErrorReported;

   867 			}

   868 			break;

   869 			

   870 		case 42:

   871 		case 43:

   872 		case 44:

   873 

   874 		case 82:

   875 		case 83:

   876 		case 84:

   877 

   878 		case 122:

   879 		case 123:

   880 		case 124:

   881 			{

   882 			if(iterator==0 && aStatus.Int() != KErrCancel)

   883 				iStateX3P=EX3PErrorReported;

   884 			else if(aStatus.Int() != KErrNone)

   885 				iStateX3P=EX3PErrorReported;

   886 			}

   887 			break;

   888 			

   889 		default:

   890 			break;

   891 		}

   892 

   893 	if(iStateX3P == EX3PErrorReported)

   894 		{

   895 		INFO_PRINTF1(_L("Error in X3P Completion"));

   896 		SetTestStepResult(EFail);

   897 		}

   898 	

   899 	SetCallbackFlag(KLbsCallback_Got_NotifyDoTransmitPos);

   900 	}	

   901 

   902 void CT_LbsX3PStep_Conflict::MT_LbsDoPosUpdateCallback(TRequestStatus& aStatus)

   903 	{

   904 	INFO_PRINTF1(_L("Got - Notify Update - Callback Event."));

   905 

   906 	switch(iTestCaseId)

   907 		{

   908 		case 2:

   909 		case 3:

   910 		case 4:

   911 			if(aStatus.Int() != KErrCancel)

   912 				iStateX3P = EX3PErrorReported;

   913 			break;

   914 

   915 		case 5:

   916 		case 12:

   917 			if(aStatus.Int() != KErrNone || !TestCallbackFlags(KLbsCallback_Got_NotifyDoTransmitPos))

   918 				iStateX3P = EX3PErrorReported;

   919 

   920 			iState = EWaiting;

   921 			break;

   922 

   923 		default:

   924 			iStateX3P = EX3PErrorReported;

   925 		}

   926 

   927 	if(iStateX3P==EX3PErrorReported)

   928 		{

   929 		INFO_PRINTF1(_L("Failed in Notify Update"));

   930 		SetTestStepResult(EFail);

   931 		}

   932 

   933 	SetCallbackFlag(KLbsCallback_Got_DoPosUpdate);

   934 	}	

   935 	

   936 /** Keep alive timer callback.

   937 	Check the state machine to determine when to halt the test. Once all the callbacks

   938 	have been received the test can end.

   939 	This function should just monitor iState and nothing else releated to the test.

   940 **/

   941 

   942 void CT_LbsX3PStep_Conflict::HandleTimerL(TInt aTimerId, const TTime& aTargetTime)

   943 	{

   944 	(void)aTimerId;

   945 	(void)aTargetTime;

   946 

   947 	INFO_PRINTF1(_L("Got - Keep Alive Timer - Callback Event."));

   948 

   949 	RPointerArray<TTime> doTransmitPosTime;

   950 	RPointerArray<TTime> releaseLcsMoLrTime;

   951 	RPointerArray<TTime> notifyMRLocationTime;

   952 

   953 	AnalyseCallbackFlags( KLbsCallback_Got_NotifyDoTransmitPos, doTransmitPosTime);

   954 	AnalyseCallbackFlags( KLbsCallback_NetSim_Got_NotifyMeasurementReportLocation, notifyMRLocationTime);

   955 	AnalyseCallbackFlags( KLbsCallback_NetSim_Got_NotifyReleaseLcsMoLr, releaseLcsMoLrTime);

   956 	

   957 	//Setting termination condition

   958 	switch(iTestCaseId)

   959 		{

   960 		case 2:

   961 		case 3:

   962 		case 4:

   963 			{

   964 			if(doTransmitPosTime.Count()==1)

   965 				iState = EWaiting;

   966 			}

   967 			break;

   968 

   969 		case 5:	//These cases are already handled in MT_LbsDoPosUpdateCallback() function

   970 		case 12:

   971 			break; 

   972 

   973 		//If we got two Transmit positions, we can terminate

   974 		case 22:

   975 		case 53:

   976 		case 54:

   977 		case 62:

   978 		case 94:	

   979 		case 102:

   980 			{

   981 			if(doTransmitPosTime.Count()==2)

   982 				iState = EWaiting;

   983 			}

   984 			break;

   985 

   986 		case 93:	

   987 			{

   988 			if(doTransmitPosTime.Count()==3)

   989 				iState = EWaiting;

   990 			}

   991 			break;

   992 

   993 		//The second MTLR request should be cancelled so if we get one Transmit Position, we can terminate

   994 		case 32:

   995 		case 34:

   996 		case 72:

   997 		case 74:

   998 		case 112:

   999 		case 114:

  1000 

  1001 		case 133:

  1002 		case 134:

  1003 			{

  1004 			if(doTransmitPosTime.Count()==1)

  1005 				iState = EWaiting;

  1006 			}

  1007 			break;

  1008 

  1009 		//When X3P is interrupted  by (E)MTLR, if we get one transmit position and two ReleaseLcsMoLr, we can terminate

  1010 		case 42:

  1011 		case 43:

  1012 		case 44:

  1013 			

  1014 		case 82:		//0082

  1015 		case 83:		//0083

  1016 		case 84:		//0084

  1017 			

  1018 		case 122:	//0122

  1019 		case 123:	//0123

  1020 		case 124:	//0124

  1021 			{

  1022 			if(doTransmitPosTime.Count()==2 && releaseLcsMoLrTime.Count()==2)

  1023 				iState = EWaiting;

  1024 			}

  1025 			break;

  1026 		

  1027 		//When X3P is finished followed by (E)MTLR, if we get one transmit position and one ReleaseLcsMoLr, we can terminate

  1028 		case 35:

  1029 		case 45:

  1030 		case 75:

  1031 		case 85:		//0085

  1032 		case 115:

  1033 		case 125:	//0125

  1034 			{

  1035 			if(doTransmitPosTime.Count()==1 && releaseLcsMoLrTime.Count()==1)

  1036 				iState = EWaiting;

  1037 			}

  1038 			break;

  1039 

  1040 		//If MTLR is finished followed by X3P, we should get one transmitposition and one Measurementcontrolreport to terminate

  1041 		case 135:	//0135

  1042 		case 143:

  1043 		case 144:

  1044 			{

  1045 			if(doTransmitPosTime.Count()==1 && notifyMRLocationTime.Count()==1)

  1046 				iState = EWaiting;

  1047 			}

  1048 			break;

  1049 

  1050 		default:

  1051 			{

  1052 			INFO_PRINTF1(_L("Unknown Error"));

  1053 			SetTestStepResult(EFail);

  1054 			}

  1055 			break;

  1056 		}

  1057 

  1058 

  1059 	// We stop test from here when in the correct state and , there should not be anything outstanding.

  1060 	if (iStateX3P == EX3PErrorReported ||iState == EWaiting) 	//(iState != EDone && (iStateX3P == EX3PDone || iStateX3P == EX3PNormal) && (TestCallbackFlags(KLbsCallback_Got_NotifyDoTransmitPos) ||TestCallbackFlags(KLbsCallback_NetSim_Got_NotifyMeasurementReportLocation))))

  1061 		{

  1062 		iState = EDone;

  1063 		iStateX3P = EX3POk;

  1064 		CActiveScheduler::Stop();

  1065 		}

  1066 	else    // Keep going, still waiting for callbacks.	

  1067 		{

  1068 		TTimeIntervalMicroSeconds32 interval(KLbsKeepAlivePeriod1);

  1069 		iKeepAliveTimer->SetTimer(interval);

  1070 		}

  1071 	}

  1072 

  1073 void CT_LbsX3PStep_Conflict::Connected()

  1074 	{

  1075 	INFO_PRINTF1(_L("Got - NetSim Connect - Callback Event."));

  1076 

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

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

  1079 	iPosInfo0 = new(ELeave) TPositionInfo();

  1080 	iPosInfo1 = new(ELeave) TPositionInfo();

  1081 	

  1082 	T_LbsUtils utils;

  1083 	utils.ResetAndDestroy_PosInfoArr(posInfoArr);	// Clear previous entries before new entry is appended.

  1084 	posInfoArr.Append(iPosInfo0);

  1085 	posInfoArr.Append(iPosInfo1);

  1086 

  1087 	switch(iTestCaseId)

  1088 		{

  1089 

  1090 		case 2:

  1091 		case 3:

  1092 		case 4:

  1093 		case 5:

  1094 

  1095 		case 12:

  1096 			{

  1097 			iDoPosUpdate->StartL(*iPosInfo0);

  1098 			}

  1099 			break;

  1100 			

  1101 		case 21:

  1102 		case 22:

  1103 

  1104 		case 31:

  1105 		case 32:

  1106 		case 34:

  1107 		case 35:

  1108 

  1109 		//case 0041:

  1110 		case 42:

  1111 		case 43:

  1112 		case 44:

  1113 

  1114 		case 1001:

  1115 			{

  1116 			iDoTransmitPosAO->TransmitPosition( KDestIDH, priorityH, *iPosInfo0);

  1117 

  1118 			if(iTestCaseId == 21)			

  1119 				iDoTransmitPosAO2->TransmitPosition( KDestIDL, priorityL, *iPosInfo1); 

  1120 			else if(iTestCaseId == 31 || iTestCaseId == 41)			

  1121 				{

  1122 				//Do we need to put some sleep - TBD

  1123 				//Ask Netsim to send MTLR

  1124 				TLbsNetPosRequestPrivacy reqType;

  1125 				reqType.SetRequestAction(TLbsNetPosRequestPrivacy::ERequestActionAllow); // Request will be accepted

  1126 				reqType.SetRequestAdvice(TLbsNetPosRequestPrivacy::ERequestAdviceSilent); // No user involvement.

  1127 				TLbsExternalRequestInfo reqInfo; // Hope default values are good enough.

  1128 

  1129 				if(iTestCaseId == 41)			

  1130 					iNetSim.SetEmergenyStatus(ETrue);

  1131 				

  1132 				iNetSim.StartNetworkPrivacyRequest(reqType, reqInfo);

  1133 				}

  1134 			}

  1135 			break;