// 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 ModuleClassesStep.cpp

 @internalTechnology

*/

#include "moduleclassesstep.h"

#include "te_lbsapisuitedefs.h"

#include "lcfsbucommondefinitions.h"

#include <lbs.h>

#include <lbssatellite.h>

CModuleClassesStep::~CModuleClassesStep()

/**

 * Destructor

 */

	{

	}

CModuleClassesStep::CModuleClassesStep()

/**

 * 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(KModuleClassesStep);

	}

TVerdict CModuleClassesStep::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 CModuleClassesStep::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 CModuleClassesStep::doTestStepPostambleL()

/**

 * @return - TVerdict code

 * Override of base class virtual

 */

	{

	return TestStepResult();

	}

void CModuleClassesStep::StartL(TInt aIndex)

	{

	switch (aIndex)

		{

	case 0:

		TPositionModuleInfo_ConstructionL ();

		break;

	case 1:

		TPositionModuleInfo_GettersL ();

		break;

	case 2:

		TPositionModuleInfo_InvalidL ();

		break;

	case 3:

		TPositionQuality_ConstructionL ();

		break;

	case 4:

		TPositionQuality_SettersL ();

		break;

	case 5:

		TPositionQuality_InvalidL ();

		break;

	case 6:

		TPositionQuality_ComparisonL ();

		break;

	case 7:

		ModuleClasses_ConstructionL ();

		break;

	case 8:

		ModuleClasses_SettersL ();

		break;

	case 9:

		TPositionUpdateOptions_InvalidL ();

		break;

	default:

		break;

		}

	}

//

//

// TPositionModuleInfo

//

//

// 6.1.1. Construction

void CModuleClassesStep::TPositionModuleInfo_ConstructionL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    TPositionModuleInfo posModInfo;

    CHECK_EQUAL_(sizeof(TPositionModuleInfo), posModInfo.PositionClassSize());

    CHECK(EPositionModuleInfoClass == posModInfo.PositionClassType());

    CHECK(KPositionNullModuleId.iUid == posModInfo.ModuleId().iUid);

    TPositionQuality posQuality;

    posModInfo.GetPositionQuality(posQuality);

    CHECK(Math::IsNaN(posQuality.HorizontalAccuracy())); // new pos quality

    CHECK(!posModInfo.IsAvailable());

    TBuf<KPositionMaxModuleName> moduleName;

    posModInfo.GetModuleName(moduleName);

    CHECK_EQUAL_(0, moduleName.Length());

    CHECK_EQUAL_(TPositionModuleInfo::TTechnologyType(TPositionModuleInfo::ETechnologyUnknown),

                            posModInfo.TechnologyType());

    CHECK_EQUAL_(TPositionModuleInfo::TDeviceLocation(TPositionModuleInfo::EDeviceUnknown),

                            posModInfo.DeviceLocation());

    CHECK_EQUAL_(TPositionModuleInfo::TCapabilities(TPositionModuleInfo::ECapabilityNone),

                            posModInfo.Capabilities());

    for(TInt i=0; i<EPositionLastFamily; i++)

            CHECK(0 == posModInfo.ClassesSupported(TPositionClassFamily(i)));

    TVersion version = posModInfo.Version();

    TVersion defaultVersion;

    CHECK_EQUAL_(version.iMajor, defaultVersion.iMajor);

    CHECK_EQUAL_(version.iMinor, defaultVersion.iMinor);

    CHECK_EQUAL_(version.iBuild, defaultVersion.iBuild);

    StandardCleanup();

	}

// 6.1.2. Set and Get

void CModuleClassesStep::TPositionModuleInfo_GettersL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    TPositionModuleInfo posModInfo;

    const TPositionModuleId KDummyModuleId = {0x32};

    posModInfo.SetModuleId(KDummyModuleId);

    CHECK_EQUAL_(KDummyModuleId.iUid, posModInfo.ModuleId().iUid);

    posModInfo.SetIsAvailable(ETrue);

    CHECK(posModInfo.IsAvailable());

    posModInfo.SetIsAvailable(EFalse);

    CHECK(!posModInfo.IsAvailable());

    _LIT(KDummyModuleName, "Testing 1,2,3");

    posModInfo.SetModuleName(KDummyModuleName);

    TBuf<KPositionMaxModuleName> tempBuf;

    posModInfo.GetModuleName(tempBuf);

    CHECK(0 == tempBuf.Compare(KDummyModuleName));

    TPositionQuality quality, quality2;

    const TPositionQuality::TCostIndicator KDummyCostIndicator = TPositionQuality::ECostCharge;

    quality.SetCostIndicator(KDummyCostIndicator);

    posModInfo.SetPositionQuality(quality);

    posModInfo.GetPositionQuality(quality2);

    CHECK_EQUAL_(KDummyCostIndicator, quality2.CostIndicator());

    posModInfo.SetTechnologyType(TPositionModuleInfo::ETechnologyNetwork);

    posModInfo.SetDeviceLocation(TPositionModuleInfo::EDeviceExternal);

    CHECK_EQUAL_(TPositionModuleInfo::TTechnologyType(TPositionModuleInfo::ETechnologyNetwork),

                            posModInfo.TechnologyType());

    CHECK_EQUAL_(TPositionModuleInfo::TDeviceLocation(TPositionModuleInfo::EDeviceExternal),

                            posModInfo.DeviceLocation());

    const TPositionModuleInfo::TCapabilities KDummyCaps =

            TPositionModuleInfo::ECapabilitySpeed |

            TPositionModuleInfo::ECapabilityNmea;

    posModInfo.SetCapabilities(KDummyCaps);

    CHECK_EQUAL_(KDummyCaps, posModInfo.Capabilities());

    for(TUint i=0; i<EPositionLastFamily; i++)

            posModInfo.SetClassesSupported(TPositionClassFamily(i), 2*i);

    for(TUint j=0; j<EPositionLastFamily; j++)

            CHECK(2*j == posModInfo.ClassesSupported(TPositionClassFamily(j)));

    TVersion KDummyVersion(12,31,45);        //Should be const, but Name isn't a const method for some reason!

    posModInfo.SetVersion(KDummyVersion);

    CHECK(posModInfo.Version().Name()==KDummyVersion.Name());

    StandardCleanup();

	}

// 6.1.3. Invalid calls to Setters

TInt Set_Bad_Class_Type_TPositionModuleInfo(TAny* /*aPtr*/)

    {

    TPositionModuleInfo modInfo;

    modInfo.SetClassesSupported(EPositionLastFamily, 0);        //This should panic

    return KErrGeneral;

    }

TInt Get_Bad_Class_Type_TPositionModuleInfo(TAny* /*aPtr*/)

    {

    TPositionModuleInfo modInfo;

    (void)modInfo.ClassesSupported(EPositionLastFamily);        //This should panic

    return KErrGeneral;

    }

void CModuleClassesStep::TPositionModuleInfo_InvalidL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    DO_PANIC_TEST_L(Set_Bad_Class_Type_TPositionModuleInfo, KPosClientFault,

                                EPositionInvalidClassType, KDefaultTestTimeout);

    DO_PANIC_TEST_L(Get_Bad_Class_Type_TPositionModuleInfo, KPosClientFault,

                                EPositionInvalidClassType, KDefaultTestTimeout);

    StandardCleanup();

	}

//

//

// TPositionQuality

//

//

// 6.2.1. Construction

void CModuleClassesStep::TPositionQuality_ConstructionL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    TPositionQuality quality;

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

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

    CHECK(quality.PositionClassSize() == sizeof(TPositionQuality));

    CHECK(quality.PositionClassType() == EPositionQualityClass);

    CHECK(quality.TimeToFirstFix()   == TTimeIntervalMicroSeconds(TInt64(0)));

    CHECK(quality.TimeToNextFix()    == TTimeIntervalMicroSeconds(TInt64(0)));

    CHECK(quality.CostIndicator()    == TPositionQuality::ECostUnknown);

    CHECK(quality.PowerConsumption() == TPositionQuality::EPowerUnknown);

    StandardCleanup();

	}

// 6.2.2. Getter and Setters

void CModuleClassesStep::TPositionQuality_SettersL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    TPositionQuality posQuality;

    // "time to" fixes

    const TTimeIntervalMicroSeconds KTTFF(3425234);

    const TTimeIntervalMicroSeconds KTTNF(45256265);

    const TReal32 KHorizontalAccuracy(TReal32(34252.23452));

    const TReal32 KVerticalAccuracy(TReal32(423.456563));

    const TPositionQuality::TCostIndicator KDummyCost(TPositionQuality::ECostPossible);

    const TPositionQuality::TPowerConsumption KDummyPowerConsumption(TPositionQuality::EPowerMedium);

    posQuality.SetTimeToFirstFix(KTTFF);

    posQuality.SetTimeToNextFix(KTTNF);

    posQuality.SetHorizontalAccuracy(KHorizontalAccuracy);

    posQuality.SetVerticalAccuracy(KVerticalAccuracy);

    posQuality.SetCostIndicator(KDummyCost);

    posQuality.SetPowerConsumption(KDummyPowerConsumption);

    CHECK_EQUAL_(posQuality.TimeToFirstFix().Int64(),    KTTFF.Int64());

    CHECK_EQUAL_(posQuality.TimeToNextFix().Int64(),     KTTNF.Int64());

    CHECK_EQUAL_(posQuality.HorizontalAccuracy(),        KHorizontalAccuracy);

    CHECK_EQUAL_(posQuality.VerticalAccuracy(),          KVerticalAccuracy);

    CHECK_EQUAL_(posQuality.CostIndicator(),             KDummyCost);

    CHECK_EQUAL_(posQuality.PowerConsumption(),          KDummyPowerConsumption);

    // NaNs

    TRealX nan;

    nan.SetNaN();

    posQuality.SetHorizontalAccuracy(nan);

    posQuality.SetVerticalAccuracy(nan);

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

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

    // "Zeroes"

    posQuality.SetTimeToFirstFix(TTimeIntervalMicroSeconds(0));

    posQuality.SetTimeToNextFix(TTimeIntervalMicroSeconds(0));

    posQuality.SetCostIndicator(TPositionQuality::ECostUnknown);

    posQuality.SetPowerConsumption(TPositionQuality::EPowerUnknown);

    CHECK_EQUAL_(posQuality.TimeToFirstFix().Int64(),    TInt64(0));

    CHECK_EQUAL_(posQuality.TimeToNextFix().Int64(),     TInt64(0));

    CHECK_EQUAL_(posQuality.CostIndicator(),             TPositionQuality::ECostUnknown);

    CHECK_EQUAL_(posQuality.PowerConsumption(),          TPositionQuality::EPowerUnknown);

    StandardCleanup();

	}

// 6.2.3. Invalid Input

TInt TPositionQuality_Set_Negative_HAccuracy(TAny* /*aPtr*/)

	{

    TPositionQuality quality;

    quality.SetHorizontalAccuracy(TReal32(-0.1));

    return KErrGeneral;

	}

TInt TPositionQuality_Set_Negative_VAccuracy(TAny* /*aPtr*/)

	{

    TPositionQuality quality;

    quality.SetVerticalAccuracy(TReal32(-0.1));

    return KErrGeneral;

	}

TInt TPositionQuality_Set_Negative_TTFirstFix(TAny* /*aPtr*/)

	{

    TPositionQuality quality;

    quality.SetTimeToFirstFix(TTimeIntervalMicroSeconds(-1));

    return KErrGeneral;

	}

TInt TPositionQuality_Set_Negative_TTNextFix(TAny* /*aPtr*/)

	{

    TPositionQuality quality;

    quality.SetTimeToNextFix(TTimeIntervalMicroSeconds(-1));

    return KErrGeneral;

	}

void CModuleClassesStep::TPositionQuality_InvalidL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    DO_PANIC_TEST_L(TPositionQuality_Set_Negative_HAccuracy,

            KPosClientFault, EPositionBadAccuracy, KDefaultTestTimeout);

    DO_PANIC_TEST_L(TPositionQuality_Set_Negative_VAccuracy,

            KPosClientFault, EPositionBadAccuracy, KDefaultTestTimeout);

    DO_PANIC_TEST_L(TPositionQuality_Set_Negative_TTFirstFix,

            KPosClientFault, EPositionBadTime, KDefaultTestTimeout);

    DO_PANIC_TEST_L(TPositionQuality_Set_Negative_TTNextFix,

            KPosClientFault, EPositionBadTime, KDefaultTestTimeout);

    StandardCleanup();

	}

// 6.2.4 Element Comparison

#define SET_ELEMENT(aId, aType, aPref, aData)   \

    if (aId < KPositionMaxSectionFields) SetElement(aId, aType, aPref, aData);

#pragma warning (push)

#pragma warning (disable: 4127)

void CModuleClassesStep::TPositionQuality_ComparisonL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    TPositionQuality q1, q2;

    TPositionQualityItem::TResult result;

    // set high values

    q1.SetTimeToFirstFix(       TTimeIntervalMicroSeconds(20000));

    q1.SetTimeToNextFix(        TTimeIntervalMicroSeconds(10000));

    q1.SetHorizontalAccuracy(   TReal32(1000));

    q1.SetVerticalAccuracy(     TReal32(2000));

    q1.SetCostIndicator(        TPositionQuality::ECostCharge);

    q1.SetPowerConsumption(     TPositionQuality::EPowerHigh);

    // set low values

    q2.SetTimeToFirstFix(       TTimeIntervalMicroSeconds(2));

    q2.SetTimeToNextFix(        TTimeIntervalMicroSeconds(1));

    q2.SetHorizontalAccuracy(   TReal32(1));

    q2.SetVerticalAccuracy(     TReal32(2));

    q2.SetCostIndicator(        TPositionQuality::ECostZero);

    q2.SetPowerConsumption(     TPositionQuality::EPowerZero);

    for (TInt i = 0; i < q1.HighWaterMark() + 1; i++)

    	{

        q1.Compare(q2, i, result);

        CHECK_EQUAL_(TPositionQualityItem::EIsBetter, result);

    	}

    // more common test :-)

    class TBigQuality1 : public TPositionQualityBase {

        public:

            TBigQuality1()

            	{

                SET_ELEMENT(0, TPositionQualityItem::EUndefined,

                                                  TPositionQualityItem::EPreferGreaterValues, TInt8(100));

                SET_ELEMENT(1, TPositionQualityItem::ETInt8,

                                                  TPositionQualityItem::EPreferSmallerValues, TInt8(100));

                SET_ELEMENT(2, TPositionQualityItem::ETInt16,

                                                  TPositionQualityItem::EPreferGreaterValues, TInt16(100));

                SET_ELEMENT(3, TPositionQualityItem::ETInt32,

                                                  TPositionQualityItem::EPreferSmallerValues, TInt32(100));

                SET_ELEMENT(4, TPositionQualityItem::ETInt64,

                                                  TPositionQualityItem::EPreferGreaterValues, TInt64(100));

                SET_ELEMENT(5, TPositionQualityItem::ETUint8,

                                                  TPositionQualityItem::EPreferSmallerValues, TUint8(100));

                SET_ELEMENT(6, TPositionQualityItem::ETUint16,

                                                  TPositionQualityItem::EPreferGreaterValues, TUint16(100));

                SET_ELEMENT(7, TPositionQualityItem::ETUint32,

                                                  TPositionQualityItem::EPreferSmallerValues, TUint32(100));

            	};

    } bigQ1;

    class TBigQuality2 : public TPositionQualityBase {

        public:

            TBigQuality2()

            	{

                SET_ELEMENT(0, TPositionQualityItem::ETReal32,

                                                  TPositionQualityItem::EPreferGreaterValues, TReal32(100));

                SET_ELEMENT(1, TPositionQualityItem::ETReal64,

                                                  TPositionQualityItem::EPreferSmallerValues, TReal64(100));

                SET_ELEMENT(2,TPositionQualityItem::ETTime,

                                                  TPositionQualityItem::EPreferGreaterValues, TTime(100));

                SET_ELEMENT(3,TPositionQualityItem::ETTimeIntervalMicroSeconds,

                                                  TPositionQualityItem::EPreferSmallerValues, TTimeIntervalMicroSeconds(100));

            	};

    } bigQ2;

    class TLowQuality1 : public TPositionQualityBase {

        public:

            TLowQuality1()

            	{

                SET_ELEMENT(0, TPositionQualityItem::EUndefined,

                                                  TPositionQualityItem::EPreferGreaterValues, TInt8(1));

                SET_ELEMENT(1, TPositionQualityItem::ETInt8,

                                                  TPositionQualityItem::EPreferSmallerValues, TInt8(1));

                SET_ELEMENT(2, TPositionQualityItem::ETInt16,

                                                  TPositionQualityItem::EPreferGreaterValues, TInt16(1));

                SET_ELEMENT(3, TPositionQualityItem::ETInt32,

                                                  TPositionQualityItem::EPreferSmallerValues, TInt32(1));

                SET_ELEMENT(4, TPositionQualityItem::ETInt64,

                                                  TPositionQualityItem::EPreferGreaterValues, TInt64(1));

                SET_ELEMENT(5, TPositionQualityItem::ETUint8,

                                                  TPositionQualityItem::EPreferSmallerValues, TUint8(1));

                SET_ELEMENT(6, TPositionQualityItem::ETUint16,

                                                  TPositionQualityItem::EPreferGreaterValues, TUint16(1));

                SET_ELEMENT(7, TPositionQualityItem::ETUint32,

                                                  TPositionQualityItem::EPreferSmallerValues, TUint32(1));

            	};

    } lowQ1;

    class TLowQuality2 : public TPositionQualityBase {

        public:

            TLowQuality2()

            	{

                SET_ELEMENT(0, TPositionQualityItem::ETReal32,

                                                   TPositionQualityItem::EPreferGreaterValues, TReal32(1));

                SET_ELEMENT(1, TPositionQualityItem::ETReal64,

                                                   TPositionQualityItem::EPreferSmallerValues, TReal64(1));

                SET_ELEMENT(2, TPositionQualityItem::ETTime,

                                                   TPositionQualityItem::EPreferGreaterValues, TTime(1));

                SET_ELEMENT(3, TPositionQualityItem::ETTimeIntervalMicroSeconds,

                                                   TPositionQualityItem::EPreferSmallerValues, TTimeIntervalMicroSeconds(1));

            	};

    } lowQ2;

    // 1st part

    TInt j = 0;

    for (j = 0; j < lowQ1.HighWaterMark() + 1; j++)

    	{

        lowQ1.Compare(bigQ1, j, result);

        if (j % 2 == 0)

        	{

            // we prefer greater values here