1 // Copyright (c) 2005-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 // Example CTestStep derived implementation

    15 // 

    16 //

    17 

    18 /**

    19  @file SimPsyNmeaPositionerStep.cpp

    20  @internalTechnology

    21 */

    22 #include "simpsynmeapositionerstep.h"

    23 #include "te_lbssimulationpsysuitedefs.h"

    24 

    25 #include "CSimPsyMultiNmeaPosRequester.h"

    26 

    27 

    28 #include <lbs.h>

    29 #include <lbssatellite.h>

    30 

    31 // A few useful macros

    32 #define MAX(x,y)      ((x)<(y))?(y):(x)

    33 #define MIN(x,y)      ((x)<(y))?(x):(y)

    34 

    35 // CONSTANTS

    36 _LIT(KNmeaFile, "c:\\system\\data\\nmea.nme");

    37 _LIT(KNmeaShortFile, "c:\\system\\data\\nmea_short.nme");

    38 _LIT(KWrongFileType, "c:\\system\\data\\simfile.wng");

    39 _LIT(KNmeaSatelliteFile, "c:\\system\\data\\nmea_garmin3plus.nme");

    40 _LIT(KNmeaMagellanFile, "c:\\system\\data\\nmea_Magellantracker.nme");

    41 _LIT(KNmeaPdopMissingFile, "c:\\system\\data\\nmea_pdopmissing.nme");

    42 _LIT(KNmeaPartialUpdateFile, "c:\\system\\data\\nmea_partial_updates.nme");

    43 _LIT(KNmeaError1, "c:\\system\\data\\nmea_error1.nme");

    44 _LIT(KNmeaError2, "c:\\system\\data\\nmea_error2.nme");

    45 _LIT(KNmeaError3, "c:\\system\\data\\nmea_error3.nme");

    46 _LIT(KNmeaSpecialCase, "c:\\system\\data\\nmea_special_case.nme");

    47 

    48 const TInt32 KSimModuleId = 270498433;

    49 

    50 

    51 CSimPsyNmeaPositionerStep::~CSimPsyNmeaPositionerStep()

    52 /**

    53  * Destructor

    54  */

    55 	{

    56     iFileReader->CloseResources();    

    57     delete iSimDataArray; 

    58     iSimDataArray = NULL;

    59     delete iFileReader;

    60     iFileReader = NULL;

    61 

    62 #ifdef __CTC__ 

    63     #pragma CTC APPEND

    64 #endif

    65 	}

    66 

    67 CSimPsyNmeaPositionerStep::CSimPsyNmeaPositionerStep()

    68 /**

    69  * Constructor

    70  */

    71 	{

    72 	// **MUST** call SetTestStepName in the constructor as the controlling

    73 	// framework uses the test step name immediately following construction to set

    74 	// up the step's unique logging ID.

    75 	SetTestStepName(KSimPsyNmeaPositionerStep);

    76 	}

    77 

    78 TVerdict CSimPsyNmeaPositionerStep::doTestStepPreambleL()

    79 /**

    80  * @return - TVerdict code

    81  * Override of base class virtual

    82  */

    83 	{

    84 	// uncomment the following 3 lines if you have common pre setting to all the test steps in there

    85 	CTe_LbsSimulationPSYSuiteStepBase::doTestStepPreambleL();

    86 	// if (TestStepResult()!=EPass)

    87 	//    return   TestStepResult();

    88 	// process some pre setting to this test step then set SetTestStepResult to EFail or Epass.

    89 	SetTestStepResult(EPass);

    90 	TTime time;

    91 	time.UniversalTime();            

    92 	iSeed = time.Int64();            

    93 	iFileReader = CPosFileReader::NewL();  

    94 	return TestStepResult();

    95 	}

    96 

    97 

    98 TVerdict CSimPsyNmeaPositionerStep::doTestStepL()

    99 /**

   100  * @return - TVerdict code

   101  * Override of base class pure virtual

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

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

   104  */

   105 	{

   106 	  if (TestStepResult()==EPass)

   107 		{

   108 		TInt test;

   109 		if(!GetIntFromConfig(ConfigSection(),KTe_LbsSimulationPSYSuiteInt,test)

   110 			)

   111 			{

   112 			// Leave if there's any error.

   113 			User::Leave(KErrNotFound);

   114 			}

   115 		SetTestStepResult(EPass);

   116 		StartL(test);

   117 		}

   118 	  return TestStepResult();

   119 	}

   120 

   121 

   122 

   123 TVerdict CSimPsyNmeaPositionerStep::doTestStepPostambleL()

   124 /**

   125  * @return - TVerdict code

   126  * Override of base class virtual

   127  */

   128 	{

   129 	// process something post setting to the test step

   130 	// uncomment the following line if you have common post setting to all the test steps in there

   131 	// CTe_LbsSimulationPSYSuiteStepBase::doTestStepPostambleL();

   132 	// uncomment the following line if you have post process or remove the following line if no post process

   133 	// SetTestStepResult(EPass);		// or EFail

   134 	return TestStepResult();

   135 	}

   136 

   137 

   138 // ================= MEMBER FUNCTIONS =======================

   139 

   140 

   141 // ---------------------------------------------------------

   142 // CSimPsyNmeaPositionerStep::FixSettingsForSimPSY

   143 // (other items were commented in a header).

   144 // ---------------------------------------------------------

   145 // 

   146 void CSimPsyNmeaPositionerStep::FixSettingsForSimPSY(const TDesC& aFileName) 

   147 	{	

   148     // Third version of settings simulation psy file

   149 	TFileName fileName = aFileName;

   150     CRepository* repository = CRepository::NewLC(KCRUidSimulationPSY);

   151     User::LeaveIfError(repository->Set(KCRKeySimPSYSimulationFile, fileName));

   152     CleanupStack::PopAndDestroy(repository);

   153 	}

   154 

   155 

   156 // ---------------------------------------------------------

   157 // CSimPsyNmeaPositionerStep::StartL

   158 // (other items were commented in a header).

   159 // ---------------------------------------------------------

   160 //    

   161 void CSimPsyNmeaPositionerStep::StartL(TInt aIndex)

   162     {

   163     switch (aIndex)

   164         {                   

   165         case 0:

   166         	_LIT(KSingleNmeaRequestTest, "**** Single nmea request test ****");

   167         	INFO_PRINTF1(KSingleNmeaRequestTest);

   168         	FixSettingsForSimPSY(KNmeaFile); 

   169         	//TestSingleNmeaRequestL(); 

   170         	HeapTestL(aIndex);

   171         	break;                        

   172         case 1:

   173         	_LIT(KSingleNmeaCancelTest, "**** Single nmea cancel test ****");

   174         	INFO_PRINTF1(KSingleNmeaCancelTest);

   175         	FixSettingsForSimPSY(KNmeaFile); 

   176         	CancelSingleNmeaRequestL(); 

   177         	break;  

   178         case 2: 

   179         	_LIT(KMultCancelTest, "****  Multiple cancel test 1 ****");

   180         	INFO_PRINTF1(KMultCancelTest);

   181         	FixSettingsForSimPSY(KNmeaFile); 

   182         	TestMultipleNmeaCancelTestL(EFalse, EFalse, ETrue); 

   183         	break;  

   184         case 3: 

   185         	_LIT(KMultCancelTest2, "**** Multiple cancel test 2 ****");

   186         	INFO_PRINTF1(KMultCancelTest2);

   187         	FixSettingsForSimPSY(KNmeaFile); 

   188         	TestMultipleNmeaCancelTestL(ETrue, EFalse, ETrue); 

   189         	break;

   190         case 4: 

   191         	_LIT(KMultCancelTest3, "**** Multiple cancel test 3 ****");

   192             INFO_PRINTF1(KMultCancelTest3);

   193         	FixSettingsForSimPSY(KNmeaFile); 

   194         	TestMultipleNmeaCancelTestL(ETrue, ETrue, ETrue); 

   195         	break;                        

   196         case 5:

   197         	_LIT(KMultipleRequestsMemoryTestName, "**** Multiple req memory leak test ****");

   198         	INFO_PRINTF1(KMultipleRequestsMemoryTestName);

   199         	FixSettingsForSimPSY(KNmeaFile); 

   200         	//TestMultipleRequestsL(10); 

   201         	HeapTestL(aIndex);

   202         	break;        

   203         case 6: 

   204         	_LIT(KMultipleRequestsAndCancelMemoryTestName, "**** Multiple req and cancel memory leak test ****");

   205             INFO_PRINTF1(KMultipleRequestsAndCancelMemoryTestName);

   206         	FixSettingsForSimPSY(KNmeaFile); 

   207         	TestMultipleRequestsAndCancelL(5, EFalse, ETrue, EFalse); 

   208         	break;        

   209         case 7:	

   210         	_LIT(KRequestNmeaData, "**** Request Nmea data ****");

   211         	INFO_PRINTF1(KRequestNmeaData);

   212         	FixSettingsForSimPSY(KNmeaFile); 

   213         	//TestRequestNmeaDataL(); 

   214         	HeapTestL(aIndex);

   215         	break;                        

   216         case 8: 

   217         	_LIT(KReadUntilEof, "**** Read until eof ****");

   218         	INFO_PRINTF1(KReadUntilEof);

   219         	//TestReadUntilEofL(); 

   220         	HeapTestL(aIndex);

   221         	break;                        

   222         case 9:

   223         	_LIT(KWrongPsyMode, "**** Unknown PSY mode ****"); 

   224         	INFO_PRINTF1(KWrongPsyMode);

   225         	TestWrongSimModeL(); 

   226         	break;  

   227         case 10: 

   228         	_LIT(KRequestCourseInfo, "**** Request course info ****");

   229         	INFO_PRINTF1(KRequestCourseInfo);

   230         	TestRequestCourseInfoL(); 

   231         	break;    

   232         case 11: 

   233         	_LIT(KRequestSatelliteInfo, "**** Request satellite info ****");

   234         	INFO_PRINTF1(KRequestSatelliteInfo);

   235         	TestRequestSatelliteInfoL(); 

   236         	break;

   237         case 12: 

   238         	_LIT(KRequestGenericInfo, "**** Request generic info ****");

   239         	INFO_PRINTF1(KRequestGenericInfo);

   240         	//TestRequestGenericInfoL(); 

   241         	HeapTestL(aIndex);

   242         	break;

   243         case 13: 

   244         	_LIT(KRequestBasicInfo, "**** Request basic info ****");

   245         	INFO_PRINTF1(KRequestBasicInfo);

   246         	TestRequestBasicInfoL(); 

   247         	break;

   248         case 14: 

   249         	_LIT(KRequestMagellan, "**** Request Magellan ****");

   250         	INFO_PRINTF1(KRequestMagellan);

   251         	TestRequestMagellanL(); 

   252         	break;

   253         case 15: 

   254         	_LIT(KRequestPartialGenericInfo, "**** Request partial generic info ****");

   255         	INFO_PRINTF1(KRequestPartialGenericInfo);

   256         	TestRequestPartialGenericInfoL(); 

   257         	break;

   258         case 16: 

   259         	_LIT(KRequestClearAndSetDefaultPositionData, "**** Test Clear Position Data ****");

   260         	INFO_PRINTF1(KRequestClearAndSetDefaultPositionData);

   261         	//TestClearAndSetDefaultPositionDataL(); 

   262         	HeapTestL(aIndex);

   263         	break;

   264         case 17: 

   265         	_LIT(KTestPartialUpdate, "**** Test Partial Update ****");

   266         	INFO_PRINTF1(KTestPartialUpdate);

   267         	TestPartialUpdateL(); 

   268         	break;

   269         case 18: 

   270         	_LIT(KTestErrorSituations, "**** Test wrong situations ****");

   271         	INFO_PRINTF1(KTestErrorSituations);

   272         	TestErrorSituationsL(); 

   273         	break;

   274         case 19: 

   275         	_LIT(KTestSpecialCase, "**** Test Special Case ****");

   276         	INFO_PRINTF1(KTestSpecialCase);

   277         	TestSpecialCasesL(); 

   278         	break;

   279 

   280         // Not a real test only a helper method for printing checksums

   281         default: 

   282         	break;

   283         }

   284     }

   285   

   286 void CSimPsyNmeaPositionerStep::DoTestL(TInt aIndex)

   287     {

   288     switch (aIndex)

   289         {                   

   290         case 0: TestSingleNmeaRequestL(); break;                        

   291         case 1: CancelSingleNmeaRequestL(); break;  

   292         case 2: TestMultipleNmeaCancelTestL(EFalse, EFalse, ETrue); break;  

   293         case 3: TestMultipleNmeaCancelTestL(ETrue, EFalse, ETrue); break;

   294         case 4: TestMultipleNmeaCancelTestL(ETrue, ETrue, ETrue); break;                        

   295         case 5: TestMultipleRequestsL(10); break;        

   296         case 6: TestMultipleRequestsAndCancelL(5, EFalse, ETrue, EFalse); break;        

   297         case 7: TestRequestNmeaDataL(); break;                        

   298         case 8: TestReadUntilEofL(); break;                        

   299         case 9: TestWrongSimModeL(); break;  

   300         case 10: TestRequestCourseInfoL(); break;    

   301         case 11: TestRequestSatelliteInfoL(); break;

   302         case 12: TestRequestGenericInfoL(); break;

   303         case 13: TestRequestBasicInfoL(); break;

   304         case 14: TestRequestMagellanL(); break;

   305         case 15: TestRequestPartialGenericInfoL(); break;

   306         case 16: TestClearAndSetDefaultPositionDataL(); break;

   307         case 17: TestPartialUpdateL(); break;

   308         case 18: TestErrorSituationsL(); break;

   309         case 19: TestSpecialCasesL(); break;

   310 

   311         // Not a real test only a helper method for printing checksums

   312         default: break;

   313         }

   314     }

   315 

   316 // ---------------------------------------------------------

   317 // CSimPsyNmeaPositionerStep::TestSingleNmeaRequestL

   318 // (other items were commented in a header).

   319 // ---------------------------------------------------------

   320 //       

   321 void CSimPsyNmeaPositionerStep::TestSingleNmeaRequestL()

   322     {

   323     CSimPsyMultiNmeaPosRequester* requester = CSimPsyMultiNmeaPosRequester::NewLC();

   324 

   325     TInt status;    

   326     TTimeIntervalMicroSeconds requestTime;

   327 

   328     for (TInt i = 0; i < 5; i++)

   329         {

   330 		if (i <= 2) 

   331 			{

   332 			TPositionInfo position = TPositionInfo();    

   333 			requester->MakeRequests(&position);

   334 			requester->GetResult(status, requestTime);

   335 			CheckRequestResultL(status, position);

   336 

   337 			if (!&position)

   338 				{

   339 				User::Leave(KErrGeneral);

   340 				}

   341 			TPosition pos;			

   342 			position.GetPosition(pos);

   343 			TTime time = pos.Time();

   344 			TDateTime dtime = time.DateTime();

   345 			if (pos.Latitude() < 0 || pos.Longitude() < 0 || dtime.Year() < 2000)

   346 				{

   347 				User::Leave(KErrGeneral);

   348 				}

   349 			}

   350 		else

   351 			{

   352 			HPositionGenericInfo* genposition = HPositionGenericInfo::NewLC();    

   353             User::LeaveIfError(genposition->SetRequestedField(EPositionFieldNMEASentences));

   354 			requester->MakeRequests(genposition);

   355 			requester->GetResult(status, requestTime); 

   356 			CheckRequestResultL(status, *genposition);

   357 			if (!&genposition && status == KErrNone)

   358 				{

   359 				User::Leave(KErrGeneral);

   360 				}			

   361 			TPosition genpos;			

   362 			genposition->GetPosition(genpos);

   363 			TTime time = genpos.Time();

   364 			TDateTime dtime = time.DateTime();

   365 			if (genpos.Latitude() < 0 || genpos.Longitude() < 0 || dtime.Year() < 2000)

   366 				{

   367 				User::Leave(KErrGeneral);

   368 				}

   369 

   370             // Check that the burst starts with the same sentence all the time.

   371             // In the nmea test file, the first burst will be GLL.

   372             _LIT8(KExpectedFirstSentence, "$GPGLL");

   373             TPtrC8 firstNmeaString(NULL, 0);

   374             User::LeaveIfError(genposition->GetValue(EPositionFieldNMEASentencesStart, firstNmeaString));

   375             if (firstNmeaString.Left(6).Compare(KExpectedFirstSentence) != 0)

   376                 {

   377                 _LIT(KError, "Expected GPGLL sentence at the beginning of the burst");

   378                 LogErrorAndFail(KError);

   379                 }

   380 

   381 			CleanupStack::PopAndDestroy(genposition);

   382 			}

   383         }

   384 

   385     CleanupStack::PopAndDestroy(); // requester        

   386     _LIT(KSingleNmeaRequestTest, "Ended: **** Single nmea request test ****");

   387     INFO_PRINTF1(KSingleNmeaRequestTest);

   388     }

   389 

   390 // ---------------------------------------------------------

   391 // CSimPsyNmeaPositionerStep::CancelSingleNmeaRequestL

   392 // (other items were commented in a header).

   393 // ---------------------------------------------------------

   394 //       

   395 void CSimPsyNmeaPositionerStep::CancelSingleNmeaRequestL()

   396     {        

   397     CSimPsyMultiNmeaPosRequester* requester = CSimPsyMultiNmeaPosRequester::NewLC();

   398     requester->SetRequesterWillCancelL();

   399 

   400     TPositionInfo position = TPositionInfo();

   401     TInt status;

   402     TTimeIntervalMicroSeconds requestTime;

   403     

   404     requester->StopRequests();

   405     requester->MakeRequests(&position);

   406     requester->GetResult(status, requestTime);

   407 

   408     if (status != KErrCancel)

   409         {

   410         _LIT(KReqWasNotCancelled, "The request was not cancelled");

   411         LogErrorAndFail(KReqWasNotCancelled);

   412         }

   413 

   414     CleanupStack::PopAndDestroy(requester); // requester  

   415 	_LIT(KSingleNmeaCancelTest, "Ended: **** Single nmea cancel test ****");

   416 	INFO_PRINTF1(KSingleNmeaCancelTest);

   417     }

   418 

   419 // ---------------------------------------------------------

   420 // CSimPsyNmeaPositionerStep::TestMultipleNmeaCancelTestL

   421 // (other items were commented in a header).

   422 // ---------------------------------------------------------

   423 //       

   424 void CSimPsyNmeaPositionerStep::TestMultipleNmeaCancelTestL(

   425     TBool aFirstWillCancel,

   426     TBool aSecondWillCancel,

   427     TBool aThirdWillCancel)

   428     {    

   429     CSimPsyMultiNmeaPosRequester* requester = CSimPsyMultiNmeaPosRequester::NewLC(3);

   430     if (aFirstWillCancel)

   431         {

   432         requester->SetRequesterWillCancelL(0);

   433         }

   434     if (aSecondWillCancel)

   435         {

   436         requester->SetRequesterWillCancelL(1);

   437         }

   438     if (aThirdWillCancel)

   439         {

   440         requester->SetRequesterWillCancelL(2);

   441         }

   442 

   443     TPositionInfo position = TPositionInfo();    

   444     TInt status;

   445     TTimeIntervalMicroSeconds requestTime;

   446     

   447     requester->MakeRequests(&position);

   448 

   449     for (TInt i = 0; i < 3; i++)

   450         {

   451         requester->GetResult(status, requestTime, i);

   452 

   453         TBool shouldHaveCancelled = 

   454             (i == 0) ? aFirstWillCancel

   455             : (i == 1) ? aSecondWillCancel

   456             : aThirdWillCancel;

   457 

   458         if (shouldHaveCancelled)

   459             {

   460             if (status != KErrCancel)

   461                 {

   462                 _LIT(KReqWasNotCancelled, "The request was not cancelled");                

   463                 LogErrorAndFail(KReqWasNotCancelled);

   464                 }

   465 			}

   466         else

   467             {

   468             if (status != KErrNone)

   469                 {

   470                 _LIT(KReqFailed, "The request failed");

   471                 LogErrorAndFail(KReqFailed);

   472                 }

   473             if (!&position)

   474                 {

   475                 _LIT(KHasNoPosition, "The request did not return a position");

   476                 LogErrorAndFail(KHasNoPosition);        

   477                 }            

   478             }

   479         }

   480 

   481     CleanupStack::PopAndDestroy(); // requester    

   482 	_LIT(KMultCancelTest, "Ended: ****  Multiple cancel test ****");

   483 	INFO_PRINTF1(KMultCancelTest);

   484     }

   485 

   486 // ---------------------------------------------------------

   487 // CSimPsyNmeaPositionerStep::TestMultipleRequestsL

   488 // (other items were commented in a header).

   489 // ---------------------------------------------------------

   490 //       

   491 void CSimPsyNmeaPositionerStep::TestMultipleRequestsL(TInt aNumberOfRequests)

   492     {

   493     CSimPsyMultiNmeaPosRequester* requester = CSimPsyMultiNmeaPosRequester::NewLC();

   494 

   495     TInt status;

   496     TPositionInfo position = TPositionInfo();        

   497     TTimeIntervalMicroSeconds requestTime;    

   498     for (TInt i = 0; i < aNumberOfRequests; i++)

   499         {

   500         // RDebug::Print(_L("TestMultipleRequestsL making request"));

   501         requester->MakeRequests(&position);

   502         requester->GetResult(status, requestTime);   

   503 		CheckRequestResultL(status, position);		

   504         }

   505     CleanupStack::PopAndDestroy(); // requester        

   506     requester = NULL;  

   507 	_LIT(KMultipleRequestsMemoryTestName, "Ended: **** Multiple req memory leak test ****");

   508 	INFO_PRINTF1(KMultipleRequestsMemoryTestName);

   509     }

   510 

   511 // ---------------------------------------------------------

   512 // CSimPsyNmeaPositionerStep::TestMultipleRequestsAndCancelL

   513 // (other items were commented in a header).

   514 // ---------------------------------------------------------

   515 //      

   516 void CSimPsyNmeaPositionerStep::TestMultipleRequestsAndCancelL(

   517     TInt aNumberOfRequests, TBool aFirstWillCancel,

   518     TBool aSecondWillCancel, TBool aThirdWillCancel)

   519     {    

   520     CSimPsyMultiNmeaPosRequester* requester = CSimPsyMultiNmeaPosRequester::NewLC(3);

   521     if (aFirstWillCancel)

   522         {

   523         requester->SetRequesterWillCancelL(0);

   524         }

   525     if (aSecondWillCancel)

   526         {

   527         requester->SetRequesterWillCancelL(1);

   528         }

   529     if (aThirdWillCancel)

   530         {

   531         requester->SetRequesterWillCancelL(2);

   532         }

   533 

   534     TPositionInfo position = TPositionInfo();

   535     TInt status;    

   536     TTimeIntervalMicroSeconds requestTime;        

   537 

   538     for (TInt i = 0; i < aNumberOfRequests; i++)

   539         {

   540         requester->MakeRequests(&position);

   541 

   542         for (TInt j = 0; j < 3; j++)

   543             {

   544             requester->GetResult(status, requestTime, j);

   545             if (status == KErrNoMemory)

   546                 {

   547                 User::Leave(status);

   548                 }

   549             }

   550         }

   551     CleanupStack::PopAndDestroy(); // requester  

   552 	_LIT(KMultipleRequestsAndCancelMemoryTestName, "Ended: **** Multiple req and cancel memory leak test ****");

   553     INFO_PRINTF1(KMultipleRequestsAndCancelMemoryTestName);

   554     }

   555 

   556 // ---------------------------------------------------------

   557 // CSimPsyNmeaPositionerStep::TestRequestNmeaDataL

   558 // (other items were commented in a header).

   559 // ---------------------------------------------------------

   560 //       

   561 void CSimPsyNmeaPositionerStep::TestRequestNmeaDataL()

   562     {

   563 	CSimPsyMultiNmeaPosRequester* req = CSimPsyMultiNmeaPosRequester::NewLC();

   564 

   565     TInt status;

   566     TTimeIntervalMicroSeconds requestTime;

   567     for (TInt i = 0; i < 3; i++)

   568         {

   569 		HPositionGenericInfo* position = HPositionGenericInfo::NewLC();

   570 		TReal32 trueCourse = TReal32(30.00);

   571 		TInt err = position->SetValue(EPositionFieldTrueCourse, trueCourse);

   572 		

   573 		position->SetRequestedField(EPositionFieldNMEASentences);

   574 		req->MakeRequests(position);

   575         req->GetResult(status, requestTime);          

   576 		

   577 		err = position->GetValue(EPositionFieldTrueCourse, trueCourse);

   578 		if (err != KErrNotFound) 

   579 			{

   580 			User::Leave(KErrGeneral);	

   581 			}

   582 		CheckRequestResultL(status, *position);

   583 

   584 		if (status != KErrNone)

   585 			{

   586 			User::Leave(KErrGeneral);

   587 			}	

   588 		TUint8 sentences;

   589 		err = position->GetValue(EPositionFieldNMEASentences, sentences); 

   590 		User::LeaveIfError(err);

   591 		if (sentences <= 0)

   592 			{

   593 			User::Leave(KErrGeneral);

   594 			}

   595 

   596 		TUint8 upper;

   597 		TUint16 sent = static_cast<TUint16> (EPositionFieldNMEASentencesStart+sentences); 

   598 		err = position->GetValue(sent, upper);

   599 		if (err != KErrNotFound)

   600 			{

   601 			User::Leave(KErrGeneral);

   602 			}

   603 

   604 		TBuf8<200> buf;

   605 		for (TInt j = 0; j < sentences; j++)

   606 			{

   607 			TUint16 sentnr = static_cast<TUint16> (EPositionFieldNMEASentencesStart+j); 

   608 			err = position->GetValue(sentnr, buf); 

   609 			User::LeaveIfError(err);

   610 		    if (buf.Compare(KNullDesC8) == 0) 

   611 				{

   612 				User::Leave(KErrGeneral);

   613 				}

   614 			}	

   615 		TBool mustbetrue = position->IsFieldAvailable(EPositionFieldNMEASentences); 

   616 		if (!mustbetrue)

   617 			{

   618 			User::Leave(KErrGeneral);

   619 			}

   620 		CleanupStack::PopAndDestroy(position);

   621 		}

   622     CleanupStack::PopAndDestroy(req); // requester   

   623 	_LIT(KRequestNmeaData, "Ended: **** Request Nmea data ****");

   624 	INFO_PRINTF1(KRequestNmeaData);

   625     }

   626 

   627 // ---------------------------------------------------------

   628 // CSimPsyNmeaPositionerStep::TestReadUntilEofL

   629 // (other items were commented in a header).

   630 // ---------------------------------------------------------

   631 //       

   632 void CSimPsyNmeaPositionerStep::TestReadUntilEofL()

   633     {

   634 	FixSettingsForSimPSY(KNmeaShortFile);

   635     CSimPsyMultiNmeaPosRequester* requester = CSimPsyMultiNmeaPosRequester::NewLC();

   636 

   637     TInt status;    

   638     TTimeIntervalMicroSeconds requestTime;

   639 

   640 	// TPositionInfo position = TPositionInfo();    

   641 	HPositionGenericInfo* position = HPositionGenericInfo::NewLC();    

   642     for (TInt i = 0; i < 3; i++)

   643         {

   644 		requester->MakeRequests(position);

   645 		requester->GetResult(status, requestTime); 

   646         if (status == KErrNoMemory)

   647 			{

   648 			User::Leave(status);

   649 			}

   650         else if (status != KErrNotSupported)

   651 			{

   652 			User::Leave(KErrGeneral);

   653 			}

   654         }

   655     CleanupStack::PopAndDestroy(2, requester); // position

   656 	_LIT(KReadUntilEof, "Ended: **** Read until eof ****");

   657 	INFO_PRINTF1(KReadUntilEof);

   658     }

   659 

   660 

   661 // ---------------------------------------------------------

   662 // CSimPsyNmeaPositionerStep::TestWrongSimModeL

   663 // (other items were commented in a header).

   664 // ---------------------------------------------------------

   665 //       

   666 void CSimPsyNmeaPositionerStep::TestWrongSimModeL()

   667     {

   668 	FixSettingsForSimPSY(KWrongFileType);

   669 	CSimPsyMultiNmeaPosRequester* req = NULL;

   670     TRAPD(err, req = CSimPsyMultiNmeaPosRequester::NewLC());

   671 

   672 	if ((err != KErrNotSupported) || (req!= NULL))

   673 		{

   674 		User::Leave(KErrGeneral);

   675 		}

   676 	_LIT(KWrongPsyMode, "Ended: **** Unknown PSY mode ****"); 

   677 	INFO_PRINTF1(KWrongPsyMode);

   678     }

   679 

   680 

   681 // ---------------------------------------------------------

   682 // CSimPsyNmeaPositionerStep::TestRequestCourseInfoL

   683 // (other items were commented in a header).

   684 // ---------------------------------------------------------

   685 //       

   686 void CSimPsyNmeaPositionerStep::TestRequestCourseInfoL()

   687     {

   688     // correct NMEA file

   689     FixSettingsForSimPSY(KNmeaSatelliteFile);

   690     

   691     const TInt KNORequests = 3;

   692 	CSimPsyMultiNmeaPosRequester* req = CSimPsyMultiNmeaPosRequester::NewLC();

   693 

   694     TInt status;

   695     TTimeIntervalMicroSeconds requestTime;

   696 

   697     //expected values for course info parsed from nmea.nme

   698     const TReal32 KKnotsToMetrePerSecFactor = 1.852F / 3.6F;

   699     const TReal32 KExpectedCourse = 360.0F;

   700     const TReal32 KExpectedSpeed = KKnotsToMetrePerSecFactor * 0.0F; 

   701 

   702     for (TInt i = 0; i < KNORequests; i++)

   703         {

   704 		TPositionCourseInfo position = TPositionCourseInfo();

   705 		

   706 		req->MakeRequests(&position);

   707         req->GetResult(status, requestTime);  

   708         

   709         CheckRequestResultL(status, position);

   710 

   711         // check data from returned course-info object

   712         TCourse course;

   713         position.GetCourse(course);

   714 

   715         if (course.Speed() != KExpectedSpeed)

   716             {

   717             User::Leave(KErrGeneral);                

   718             }

   719         if (course.Heading() != KExpectedCourse)

   720             {

   721             User::Leave(KErrGeneral);                

   722             }

   723 		}

   724     CleanupStack::PopAndDestroy(req); // requester        

   725 	_LIT(KRequestCourseInfo, "Ended: **** Request course info ****");

   726 	INFO_PRINTF1(KRequestCourseInfo);

   727     }

   728 

   729 

   730 // ---------------------------------------------------------

   731 // CSimPsyNmeaPositionerStep::TestRequestSatelliteInfoL

   732 // (other items were commented in a header).

   733 // ---------------------------------------------------------

   734 //       

   735 void CSimPsyNmeaPositionerStep::TestRequestSatelliteInfoL()

   736     {

   737     // correct NMEA file

   738     FixSettingsForSimPSY(KNmeaSatelliteFile);

   739 

   740     const TInt KNORequests = 3;

   741 	CSimPsyMultiNmeaPosRequester* req = CSimPsyMultiNmeaPosRequester::NewLC();

   742 

   743     TInt status;

   744     TTimeIntervalMicroSeconds requestTime;

   745 

   746     // expected values for satellite info parsed from KNmeaSatelliteFile

   747     // RMC

   748     const TInt KExpectedYear = 2003;

   749     const TMonth KExpectedMonth = EApril;

   750     const TInt KExpectedDay = 1;

   751     const TInt KExpectedHour = 14;

   752     const TInt KExpectedMin[KNORequests] = {18, 19, 19};

   753     const TInt KExpectedSec[KNORequests] = {59, 1, 3};

   754     const TReal32 KKnotsToMetrePerSecFactor = 1.852F / 3.6F;

   755     const TReal32 KExpectedCourse = 360.0F;

   756     const TReal32 KExpectedSpeed = KKnotsToMetrePerSecFactor * 0.0F; 

   757     // GSA    

   758     const TInt KExpectedSatUsed = 6;

   759     const TInt KExpectedSatInView = 10;

   760         // IDs of satellites used in solution

   761     const TInt KExpectedUsedSatId[KExpectedSatUsed] = {7,9,11,18,23,28};

   762     const TReal32 KExpectedHDOP= 2.2F;

   763     const TReal32 KExpectedVDOP= 2.7F;

   764     // GSV

   765         // IDs of satellites in view

   766     const TInt KExpectedInViewSatId[KExpectedSatInView] = {7,9,11,18,23,28,3,14,20,31};

   767     const TReal32 KExpectedElevation[KExpectedSatInView] = {2,16,57,8,3,19,10,51,9,30};

   768     const TReal32 KExpectedAzimuth[KNORequests][KExpectedSatInView] = 

   769         {

   770         {331,26,267,66,64,301,179,106,240,196},

   771         {331,26,267,66,64,301,179,105,240,196},

   772         {331,26,267,66,64,301,179,105,240,196}

   773         };

   774 

   775     const TInt KExpectedSR[KNORequests][KExpectedSatInView] = 

   776         {

   777         {42,47,44,39,38,46,0,33,0,0},

   778         {42,48,44,39,38,45,0,33,0,0}, 

   779         {42,48,44,39,38,45,0,34,0,0}

   780         };

   781 

   782 

   783     for (TInt i = 0; i < KNORequests; i++)

   784         {

   785 		TPositionSatelliteInfo position = TPositionSatelliteInfo();

   786 

   787 		req->MakeRequests(&position);

   788         req->GetResult(status, requestTime);  

   789         

   790         CheckRequestResultL(status, position);

   791         

   792         // check data from returned satellite-info object...

   793         // from RMC

   794         TTime sattime = position.SatelliteTime();

   795         TDateTime dtime = sattime.DateTime();

   796         TInt year = dtime.Year();

   797         TMonth month = dtime.Month();

   798         TInt day = dtime.Day();

   799         TInt hour = dtime.Hour();

   800         TInt min = dtime.Minute();

   801         TInt sec = dtime.Second();

   802 

   803         if (year != KExpectedYear)

   804             {

   805             User::Leave(KErrGeneral);                

   806             }

   807         if (month != KExpectedMonth)

   808             {

   809             User::Leave(KErrGeneral);                

   810             }

   811         if (day != KExpectedDay)

   812             {

   813             User::Leave(KErrGeneral);                

   814             }

   815         if (hour != KExpectedHour)

   816             {

   817             User::Leave(KErrGeneral);                

   818             }

   819         if (min != KExpectedMin[i])

   820             {

   821             User::Leave(KErrGeneral);                

   822             }

   823         if (sec != KExpectedSec[i])

   824             {

   825             User::Leave(KErrGeneral);                

   826             }

   827 

   828         TCourse course;

   829         position.GetCourse(course);

   830 

   831         if (course.Speed() != KExpectedSpeed)

   832             {

   833             User::Leave(KErrGeneral);                

   834             }

   835         if (course.Heading() != KExpectedCourse)

   836             {

   837             User::Leave(KErrGeneral);                

   838             }

   839 

   840         // from GSA

   841         TInt satused = position.NumSatellitesUsed();

   842         TInt satinview = position.NumSatellitesInView();

   843         if (satused != KExpectedSatUsed)

   844             {

   845             User::Leave(KErrGeneral);                

   846             }

   847         if (satinview != KExpectedSatInView)

   848             {

   849             User::Leave(KErrGeneral);                

   850             }

   851 

   852         TSatelliteData satdata;

   853         TInt k = 0;

   854         TInt j;

   855         for (j = 0; j < satinview; j++)

   856             {

   857             TInt err = position.GetSatelliteData(j, satdata);

   858             if (err != KErrNone)

   859                 {

   860                 User::Leave(KErrGeneral);                

   861                 }

   862             if (satdata.SatelliteId() == KExpectedUsedSatId[k] && satdata.IsUsed())

   863                 {

   864                 k++; 

   865                 }

   866             }

   867         if (k != satused)

   868             {

   869             User::Leave(KErrGeneral); // correct n.o Ids used for fix NOT present

   870             }

   871 

   872         if (position.HorizontalDoP() != KExpectedHDOP)

   873             {

   874             User::Leave(KErrGeneral);

   875             }

   876         if (position.VerticalDoP() != KExpectedVDOP)

   877             {

   878             User::Leave(KErrGeneral);

   879             }

   880 

   881         // from GSV

   882         for (j = 0; j < satinview; j++)

   883             {

   884             TInt err = position.GetSatelliteData(j, satdata);

   885             if (err != KErrNone)

   886                 {

   887                 User::Leave(KErrGeneral);                

   888                 }

   889             if (satdata.SatelliteId() != KExpectedInViewSatId[j])

   890                 {

   891                 User::Leave(KErrGeneral); 

   892                 }

   893             if (satdata.Azimuth() != KExpectedAzimuth[i][j])

   894                 {

   895                 User::Leave(KErrGeneral); 

   896                 }

   897             if (satdata.Elevation() != KExpectedElevation[j])

   898                 {

   899                 User::Leave(KErrGeneral); 

   900                 }      

   901             if (satdata.SignalStrength() != KExpectedSR[i][j])

   902                 {

   903                 User::Leave(KErrGeneral); 

   904                 }

   905             }

   906 		}

   907     CleanupStack::PopAndDestroy(req); // requester        

   908 	_LIT(KRequestSatelliteInfo, "Ended: **** Request satellite info ****");

   909 	INFO_PRINTF1(KRequestSatelliteInfo);

   910     }

   911 

   912 

   913 // ---------------------------------------------------------

   914 // CSimPsyNmeaPositionerStep::TestRequestGenericInfoL

   915 // (other items were commented in a header).

   916 // ---------------------------------------------------------

   917 //       

   918 void CSimPsyNmeaPositionerStep::TestRequestGenericInfoL()

   919     {

   920     // correct NMEA file

   921     FixSettingsForSimPSY(KNmeaSatelliteFile);

   922 

   923     const TInt KNORequests = 3;

   924 	CSimPsyMultiNmeaPosRequester* req = CSimPsyMultiNmeaPosRequester::NewLC();

   925 

   926     TInt status;

   927     TTimeIntervalMicroSeconds requestTime;

   928 

   929     // expected values for satellite info parsed from nmea.nme

   930     // GGA

   931     const TReal32 KExpectedWGS84Alt[KNORequests] = 

   932         {169.5F, 169.8F, 169.6F}; 

   933     const TReal32 KExpectedGeodialSep = 20.7F;

   934     // RMC

   935     const TInt KExpectedYear = 2003;

   936     const TMonth KExpectedMonth = EApril;

   937     const TInt KExpectedDay = 1;

   938     const TInt KExpectedHour = 14;

   939     const TInt KExpectedMin[KNORequests] = {18, 19, 19};

   940     const TInt KExpectedSec[KNORequests] = {59, 1, 3};

   941     const TReal32 KKnotsToMetrePerSecFactor = 1.852F / 3.6F;

   942     const TReal32 KExpectedCourse = 360.0F;

   943     const TReal32 KExpectedSpeed = KKnotsToMetrePerSecFactor * 0.0F; 

   944     const TReal32 KExpectedMagCourse = 354.0F;

   945     // GSA

   946     const TInt KExpectedSatUsed = 6;

   947     const TReal32 KExpectedPDOP= 3.5F;

   948     const TReal32 KExpectedHDOP= 2.2F;

   949     const TReal32 KExpectedVDOP= 2.7F;

   950     // GSV

   951     const TInt8 KExpectedSatInView = 10;

   952 

   953 

   954     for (TInt i = 0; i < KNORequests; i++)

   955         {

   956 		HPositionGenericInfo* position = HPositionGenericInfo::NewLC();

   957 		

   958         // set requested fields..

   959         // GGA

   960 		position->SetRequestedField(EPositionFieldSatelliteSeaLevelAltitude);		

   961         position->SetRequestedField(EPositionFieldSatelliteGeoidalSeparation);

   962         // RMC

   963         position->SetRequestedField(EPositionFieldSatelliteTime);

   964         position->SetRequestedField(EPositionFieldTrueCourse);

   965         position->SetRequestedField(EPositionFieldHorizontalSpeed);

   966         // position->SetRequestedField(EPositionFieldMagneticVariation);        

   967         position->SetRequestedField(EPositionFieldMagneticCourse);        

   968         // GSA

   969         position->SetRequestedField(EPositionFieldSatelliteNumUsed);

   970         position->SetRequestedField(EPositionFieldSatelliteHorizontalDoP);

   971         position->SetRequestedField(EPositionFieldSatelliteVerticalDoP);

   972         position->SetRequestedField(EPositionFieldSatellitePositionDoP);

   973         // GSV

   974         position->SetRequestedField(EPositionFieldSatelliteNumInView);

   975 

   976         req->MakeRequests(position);

   977         req->GetResult(status, requestTime);          

   978 

   979         CheckRequestResultL(status, *position);

   980         

   981         // check data from returned generic-info object...

   982         // from GGA

   983         TBool mustbetrue = position->IsFieldAvailable(EPositionFieldSatelliteSeaLevelAltitude); 

   984 		if (!mustbetrue)

   985 			{

   986 			User::Leave(KErrGeneral);

   987 			}

   988         TReal32 wgs84alt;

   989         position->GetValue(EPositionFieldSatelliteSeaLevelAltitude, 

   990                         wgs84alt);

   991         if (wgs84alt != KExpectedWGS84Alt[i])

   992                 {

   993                 User::Leave(KErrGeneral); 

   994                 }

   995 

   996         mustbetrue = position->IsFieldAvailable(EPositionFieldSatelliteGeoidalSeparation);

   997         if (!mustbetrue)

   998 			{

   999 			User::Leave(KErrGeneral);

  1000 			}

  1001         TReal32 geosep;

  1002         position->GetValue(EPositionFieldSatelliteGeoidalSeparation, 

  1003                         geosep);

  1004         if (geosep != KExpectedGeodialSep)

  1005                 {

  1006                 User::Leave(KErrGeneral); 

  1007                 }

  1008 

  1009         // from RMC

  1010         mustbetrue = position->IsFieldAvailable(EPositionFieldSatelliteTime);

  1011         if (!mustbetrue)

  1012 			{

  1013 			User::Leave(KErrGeneral);

  1014 			}

  1015         TTime sattime;

  1016         position->GetValue(EPositionFieldSatelliteTime, 

  1017                         sattime);

  1018         TDateTime dtime = sattime.DateTime();

  1019         TInt year = dtime.Year();

  1020         TMonth month = dtime.Month();

  1021         TInt day = dtime.Day();

  1022         TInt hour = dtime.Hour();

  1023         TInt min = dtime.Minute();

  1024         TInt sec = dtime.Second();

  1025         if (year != KExpectedYear)

  1026             {

  1027             User::Leave(KErrGeneral);                

  1028             }

  1029         if (month != KExpectedMonth)

  1030             {

  1031             User::Leave(KErrGeneral);                

  1032             }

  1033         if (day != KExpectedDay)

  1034             {

  1035             User::Leave(KErrGeneral);                

  1036             }

  1037         if (hour != KExpectedHour)

  1038             {

  1039             User::Leave(KErrGeneral);                

  1040             }

  1041         if (min != KExpectedMin[i])

  1042             {

  1043             User::Leave(KErrGeneral);                

  1044             }

  1045         if (sec != KExpectedSec[i])

  1046             {

  1047             User::Leave(KErrGeneral);                

  1048             }

  1049 

  1050         mustbetrue = position->IsFieldAvailable(EPositionFieldTrueCourse);

  1051         if (!mustbetrue)

  1052 			{

  1053 			User::Leave(KErrGeneral);

  1054 			}

  1055         TReal32 trueCourse;

  1056         position->GetValue(EPositionFieldTrueCourse, 

  1057                         trueCourse);

  1058         if (trueCourse != KExpectedCourse)

  1059             {

  1060             User::Leave(KErrGeneral);                

  1061             }

  1062 

  1063         mustbetrue = position->IsFieldAvailable(EPositionFieldHorizontalSpeed);

  1064         if (!mustbetrue)

  1065 			{

  1066 			User::Leave(KErrGeneral);

  1067 			}

  1068         TReal32 speed;

  1069         position->GetValue(EPositionFieldHorizontalSpeed, 

  1070                         speed);

  1071         if (speed != KExpectedSpeed)

  1072             {

  1073             User::Leave(KErrGeneral);                

  1074             }

  1075         mustbetrue = position->IsFieldAvailable(EPositionFieldMagneticCourse);

  1076         if (!mustbetrue)

  1077 			{

  1078 			User::Leave(KErrGeneral);

  1079 			}

  1080         // TReal32 magvar;

  1081         TReal32 magCourse;

  1082         position->GetValue(EPositionFieldMagneticCourse, 

  1083                         magCourse);

  1084         if (magCourse != KExpectedMagCourse)

  1085             {

  1086             User::Leave(KErrGeneral);                

  1087             }

  1088 

  1089         // from GSA

  1090         mustbetrue = position->IsFieldAvailable(EPositionFieldSatelliteNumUsed);

  1091         if (!mustbetrue)

  1092 			{

  1093 			User::Leave(KErrGeneral);

  1094 			}

  1095         TInt8 numUsedSatellites;

  1096         position->GetValue(EPositionFieldSatelliteNumUsed, 

  1097                         numUsedSatellites);

  1098         if (numUsedSatellites != KExpectedSatUsed)

  1099             {

  1100             User::Leave(KErrGeneral);                

  1101             }

  1102 

  1103         mustbetrue = position->IsFieldAvailable(EPositionFieldSatelliteHorizontalDoP);

  1104         if (!mustbetrue)

  1105 			{

  1106 			User::Leave(KErrGeneral);

  1107 			}

  1108         TReal32 hdop;

  1109         position->GetValue(EPositionFieldSatelliteHorizontalDoP, 

  1110                         hdop);

  1111         if (hdop != KExpectedHDOP)

  1112             {

  1113             User::Leave(KErrGeneral);                

  1114             }

  1115 

  1116         mustbetrue = position->IsFieldAvailable(EPositionFieldSatelliteVerticalDoP);

  1117         if (!mustbetrue)

  1118 			{

  1119 			User::Leave(KErrGeneral);

  1120 			}

  1121         TReal32 vdop;

  1122         position->GetValue(EPositionFieldSatelliteVerticalDoP, 

  1123                         vdop);

  1124         if (vdop != KExpectedVDOP)

  1125             {

  1126             User::Leave(KErrGeneral);                

  1127             }

  1128 

  1129         mustbetrue = position->IsFieldAvailable(EPositionFieldSatellitePositionDoP);

  1130         if (!mustbetrue)

  1131 			{

  1132 			User::Leave(KErrGeneral);

  1133 			}

  1134         TReal32 pdop;

  1135         position->GetValue(EPositionFieldSatellitePositionDoP,