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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// Example CTestStep derived implementation

// 

//

/**

 @file DataClassesStep.cpp

 @internalTechnology

*/

#include "dataclassesstep.h"

#include "te_lbsapisuitedefs.h"

#include "lcfsbucommondefinitions.h"

#include <lbs.h>

#include <lbs/lbsextendedsatellite.h>

#include <lbs/lbsgpstimingmeasurement.h>

#include <lbs/lbsgpsmeasurement.h>

// used to confirm that PositionXInfo class sizes do not change

const TUint KPositionSatelliteInfoSize = 920;  

const TUint KPositionGpsMeasurementInfoSize = 832;

CDataClassesStep::~CDataClassesStep()

/**

 * Destructor

 */

	{

	}

CDataClassesStep::CDataClassesStep()

/**

 * Constructor

 */

	{

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

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

	// up the step's unique logging ID.

	SetTestStepName(KDataClassesStep);

	}

TVerdict CDataClassesStep::doTestStepPreambleL()

/**

 * @return - TVerdict code

 * Override of base class virtual

 */

	{

	 CTe_LbsApiSuiteStepBase::doTestStepPreambleL();

	 if (TestStepResult()!=EPass)

	    return   TestStepResult();

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

	SetTestStepResult(EPass);

	return TestStepResult();

	}

TVerdict CDataClassesStep::doTestStepL()

/**

 * @return - TVerdict code

 * Override of base class pure virtual

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

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

 */

	{

	  if (TestStepResult()==EPass)

		{

		TInt test;

		if(!GetIntFromConfig(ConfigSection(),KTe_LbsApiSuiteInt,test)

			)

			{

			// Leave if there's any error.

			User::Leave(KErrNotFound);

			}

		SetTestStepResult(EPass);

		StartL(test);

		}

	  return TestStepResult();

	}

TVerdict CDataClassesStep::doTestStepPostambleL()

/**

 * @return - TVerdict code

 * Override of base class virtual

 */

	{

	// process something post setting to the test step

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

	// CTe_LbsApiVariant2SuiteStepBase::doTestStepPostambleL();

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

	// SetTestStepResult(EPass);		// or EFail

	return TestStepResult();

	}

void CDataClassesStep::StartL(TInt aIndex)

	{

	switch (aIndex)

		{

	case 0:

		TCoordinate_BlankConstructionL ();

		break;

	case 1:

		TCoordinate_ConstructorsL ();

		break;

	case 2:

		TCoordinate_Constructors2L ();

		break;

	case 3:

		TCoordinate_InvalidL ();

		break;

	case 4:

		TCoordinate_NormalizationWithNansL ();

		break;

	case 5:

		TLocality_BlankConstructionL ();

		break;

	case 6:

		TLocality_ConstructorsL ();

		break;

	case 7:

		TLocality_Constructors2L ();

		break;

	case 8:

		TLocality_NegativeL ();

		break;

	case 9:

		TPosition_ConstructionL ();

		break;

	case 10:

		TPosition_SettersL ();

		break;

	case 11:

		TPositionInfo_ConstructionL ();

		break;

	case 12:

		TPositionInfo_ModificationL ();

		break;

	case 13:

		CourseClasses_ConstructionL ();

		break;

	case 14:

		CourseClasses_Modification2L ();

		break;

	case 15:

		CourseClasses_ModificationL ();

		break;

	case 16:

		CourseClasses_InvalidL ();

		break;

	case 17:

		SatelliteClasses_ConstructionL ();

		break;

	case 18:

		SatelliteClasses_PropertiesL ();

		break;

	case 19:

		SatelliteClasses_Properties2L ();

		break;

	case 20:

		SatelliteClasses_InfoL ();

		break;

	case 21:

		SatelliteClasses_SatelliteInfoL ();

		break;

	case 22:

		SatelliteClasses_OverflowL ();

		break;

	case 23:

       GpsMeasurementClasses_PropertiesL ();

       break;

	default:

		break;

		}

	}

extern void CheckPanic(const char* aFileName, TInt aLine);

//

//

// TCoordinate

//

//

// 2.1.1. Default constructor sets values to NAN

void CDataClassesStep::TCoordinate_BlankConstructionL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    TCoordinate coordinate;

    CHECK(Math::IsNaN(coordinate.Latitude()));

    CHECK(Math::IsNaN(coordinate.Longitude()));

    CHECK(Math::IsNaN(coordinate.Altitude()));

    CHECK_EQUAL_(KPositionDatumWgs84.iUid, coordinate.Datum().iUid);

    StandardCleanup();

	}

// 2.1.2 Parameterized constructors and Setters work same

void CDataClassesStep::TCoordinate_ConstructorsL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    const TReal64 dumLat = 11.111;

    const TReal64 dumLon = 22.222;

    const TReal32 dumAlt = TReal32(33.333);

    TCoordinate coordSet;

    // 2 parameters

    coordSet.SetCoordinate(dumLat, dumLon);

    CHECK_REAL_EQUAL(coordSet.Latitude() , dumLat);

    CHECK_REAL_EQUAL(coordSet.Longitude(), dumLon);

    CHECK(Math::IsNaN(coordSet.Altitude()));

    TCoordinate coord2p(dumLat, dumLon);

    CHECK_REAL_EQUAL(coord2p.Latitude()  , coordSet.Latitude());

    CHECK_REAL_EQUAL(coord2p.Longitude() , coordSet.Longitude());

    CHECK(Math::IsNaN(coord2p.Altitude()));

    // 3 params

    coordSet.SetCoordinate(dumLat, dumLon, dumAlt);

    CHECK_REAL_EQUAL(coordSet.Latitude() , dumLat);

    CHECK_REAL_EQUAL(coordSet.Longitude(), dumLon);

    CHECK_REAL_EQUAL(coordSet.Altitude() , dumAlt);

    TCoordinate coord3p(dumLat, dumLon, dumAlt);

    CHECK_REAL_EQUAL(coord3p.Latitude() , coordSet.Latitude());

    CHECK_REAL_EQUAL(coord3p.Longitude(), coordSet.Longitude());

    CHECK_REAL_EQUAL(coord3p.Altitude() , coordSet.Altitude());

    // datum

    const TPositionDatumId otherDatum = {0x10101010};

    coordSet.SetDatum(otherDatum);

    CHECK_EQUAL_(otherDatum.iUid, coordSet.Datum().iUid);

    StandardCleanup();

	}

// 2.1.3 Parameterized constructors and Setters work same with NANs

void CDataClassesStep::TCoordinate_Constructors2L()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    TRealX nan;

    nan.SetNaN();

    TReal64 dumLat(nan);

    TReal64 dumLon(nan);

    TReal32 dumAlt(nan);

    TCoordinate coordSet;

    // 2 parameters

    coordSet.SetCoordinate(dumLat, dumLon);

    CHECK(Math::IsNaN(coordSet.Latitude()));

    CHECK(Math::IsNaN(coordSet.Longitude()));

    CHECK(Math::IsNaN(coordSet.Altitude()));

    TCoordinate coord2p(dumLat, dumLon);

    CHECK(Math::IsNaN(coord2p.Latitude()));

    CHECK(Math::IsNaN(coord2p.Longitude()));

    CHECK(Math::IsNaN(coord2p.Altitude()));

    // 3 params

    coordSet.SetCoordinate(dumLat, dumLon, dumAlt);

    CHECK(Math::IsNaN(coordSet.Latitude()));

    CHECK(Math::IsNaN(coordSet.Longitude()));

    CHECK(Math::IsNaN(coordSet.Altitude()));

    TCoordinate coord3p(dumLat, dumLon, dumAlt);

    CHECK(Math::IsNaN(coord3p.Latitude()));

    CHECK(Math::IsNaN(coord3p.Longitude()));

    CHECK(Math::IsNaN(coord3p.Altitude()));

    StandardCleanup();

	}

// 2.1.4 Bad Input in TCoordinate

// The function is to normalize Lat/Lon parameters

// to [-90,+90] and (-180,+180] ranges respectively.

// If Latitude wraps +90 or -90 boundary, than Longitude

// is corrected to be shifted to another hemisphere

//

// IF Latitude is in 1st quarter of circle THEN nothing to do

// IF Latitude is in 2nd or 3rd quarter,

// THEN Longitude is shifted to opposite hemisphere, and Latitude

// is mirrored about 90 degrees (to accord with longitude)

// IF Latitude is in 4th quarter, THEN Latitude is mirrored

// about 0 degrees (to be below equator)

//

// NOTE that as +90 and -90 a valid Latitude values,

// then 4th quarter begins from +270 inclusively (it is -90 inclusively in fact)

//

// Latitude is processed first as it has its influence on Longitude

void NormalLatLon(TReal lat, TReal lon, TReal& nlat, TReal& nlon)

	{

    // 1. latitude

    // save sign, because negative and positive latitude

    // values are processed same way

    TBool isNegLat = (lat < 0);

    // truncate by 360, work with positive values

    TReal absLat = isNegLat ? -lat : lat;

    Math::Mod(lat, absLat, 360);  // 0 <= lat < 360

    // correct values, if latitude wraps 90 deg boundary

    if (lat >= 270)         // 4th quarter

    {

        lat = lat - 360;    // reverse

    }

    else

    if (lat > 90)           // 2nd or 3rd quarter

    {

        lat = 180 - lat;    // round about 90

        lon = lon + 180;    // another hemisphere

    }

    // recall latutide sign

    if (isNegLat) lat = - lat;

    // 2. longitude

    // -360 < lon < 360

    Math::Mod(lon, lon, 360);

    // let's put lon to -180 .. 180 range

    if (lon > 180)

    {

        lon = lon - 360;

    }

    else

    if (lon < - 180) // for negative longitudes

    {

        lon = lon + 360;

    }

    nlat = lat;

    nlon = lon;

	}

void XYZfromLatLon(TReal& x, TReal& y, TReal& z, TReal lat, TReal lon)

	{

    Math::Mod(lat, lat, 360);  // -360 < lat < 360

    Math::Mod(lon, lon, 360);  // -360 < lon < 360

    // if latitude is 90 deg or -90 deg, then reduce it by one degree : 89 deg.

    // it allows to check longitude direction more correctly (avoid cos(lat)==0)

    if ((lat == 90) || (lat == -270))

    {

        lat -= 1;

    }

    else

    if ((lat == -90) || (lat == 270))

    {

        lat += 1;

    }

    TReal latCos, latSin, lonCos, lonSin;

    Math::Cos(latCos, lat * KDegToRad);

    Math::Sin(latSin, lat * KDegToRad);

    Math::Cos(lonCos, lon * KDegToRad);

    Math::Sin(lonSin, lon * KDegToRad);

    x = latCos * lonCos;

    y = latCos * lonSin;

    z = latSin;

	}

TBool IsSamePoint(TReal lat1, TReal lon1, TReal lat2, TReal lon2)

	{

    TReal x1,y1,z1, x2,y2,z2;

    XYZfromLatLon(x1,y1,z1, lat1, lon1);    // source values

    XYZfromLatLon(x2,y2,z2, lat2, lon2);    // TCoordinate

    const TReal tolerance = 0.0000001; // 1 of million

    TBool same = (Abs(x1 - x2) < tolerance) &&

                 (Abs(y1 - y2) < tolerance) &&

                 (Abs(z1 - z2) < tolerance);

    return same;

	}

void CDataClassesStep::TCoordinate_InvalidL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    const TReal32 alt = 10;

    TBool noErrors = ETrue;

    // 1. Valid WGS84 range + Out of WGS84 range

    // check values (step 30 degrees) in (-540..+540] of longitude

    for (TReal64 lon = 540; lon > -540; lon -= 30)

    	{

        // check values (step 30 degrees) in [-450; 450] of latitude

        for (TReal64 lat = 720; lat >= -720; lat -= 30)

        	{

            // set

            TCoordinate coordinate2, coordinate3;

            coordinate2.SetCoordinate(lat,lon);

            coordinate3.SetCoordinate(lat,lon, alt);

            // construct

            TCoordinate coord2(lat, lon);

            TCoordinate coord3(lat, lon, alt);

            TBool isValidCoordinate2 = IsSamePoint(lat, lon, coordinate2.Latitude(), coordinate2.Longitude());

            TBool isValidCoordinate3 = IsSamePoint(lat, lon, coordinate3.Latitude(), coordinate3.Longitude());

            TBool isValidCoord2 = IsSamePoint(lat, lon, coord2.Latitude(), coord2.Longitude());

            TBool isValidCoord3 = IsSamePoint(lat, lon, coord3.Latitude(), coord3.Longitude());

            TReal nlat, nlon;

            NormalLatLon(lat, lon, nlat, nlon);

            TBool isValidNormalLatLon = IsSamePoint(lat, lon, nlat, nlon);

            if (!isValidCoordinate2 || !isValidCoordinate3 || !isValidCoord2 || !isValidCoord3 || !isValidNormalLatLon)

            	{

                noErrors = EFalse;

            	}

        	}

    	}

    if (!noErrors) LOG("There were errors in Normalization.");

    CHECK(noErrors);

    StandardCleanup();

	}

TInt TCoordinate_NormalizationWithNans_Panic(TAny* /*aPtr*/)

	{

    TRealX nan; nan.SetNaN();

    const TReal KBigLatitude = 120.0;

    const TReal KBigLongitude = 200.0;

    const TReal KGoodLatitude = 180 - KBigLatitude;

    const TReal KGoodLongitude = KBigLongitude - 360;

    TCoordinate coord;

    // this will cause normalization process

    // this should not panic even though longitude is NaN

    coord.SetCoordinate(KBigLatitude, nan);

    CHECK_PANIC(coord.Latitude() == KGoodLatitude);

    CHECK_PANIC(Math::IsNaN(coord.Longitude()));

    // this will cause normalization process

    // this should not panic even though latitude is NaN

    coord.SetCoordinate(nan, KBigLongitude);

    CHECK_PANIC(coord.Longitude() == KGoodLongitude);

    CHECK_PANIC(Math::IsNaN(coord.Latitude()));

    return KErrNone;

	}

// 2.1.5 Normalization if one of members is NaN

void CDataClassesStep::TCoordinate_NormalizationWithNansL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    DO_PANIC_TEST_L(

        TCoordinate_NormalizationWithNans_Panic,

        KNoClientFault,

        KErrNone,

        KDefaultTestTimeout);

    StandardCleanup();

	}

//

//

// TLocality

//

//

// 2.3.1. Blank constructor

void CDataClassesStep::TLocality_BlankConstructionL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    TLocality locality;

    CHECK(Math::IsNaN(locality.Latitude()));

    CHECK(Math::IsNaN(locality.Longitude()));

    CHECK(Math::IsNaN(locality.Altitude()));

    CHECK(Math::IsNaN(locality.HorizontalAccuracy()));

    CHECK(Math::IsNaN(locality.VerticalAccuracy()));

    StandardCleanup();

	}