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

 @internalTechnology

*/

#include "criteriaclassesstep.h"

#include "te_lbsapisuitedefs.h"

#include "lcfsbucommondefinitions.h"

#include <lbs.h>

#include <lbssatellite.h>

CCriteriaClassesStep::~CCriteriaClassesStep()

/**

 * Destructor

 */

	{

	}

CCriteriaClassesStep::CCriteriaClassesStep()

/**

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

	}

TVerdict CCriteriaClassesStep::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 CCriteriaClassesStep::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 CCriteriaClassesStep::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_LbsApiSuiteStepBase::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 CCriteriaClassesStep::StartL(TInt aIndex)

	{

	switch(aIndex)

		{

		case 0:

			TPositionSelectionOrder_ConstructionL();

			break;

		case 1:

			TPositionSelectionOrder_SetL();

			break;

		case 2:

			TPositionSelectionOrder_ClearL();

			break;

		case 3:

			TPositionSelectionOrder_NumSelectionItemsL();

			break;

		case 4:

			TPositionCriteria_ConstructionL();

			break;

		case 5:

			TPositionCriteria_SetL();

			break;

		case 6:

			TPositionCriteria_ResetAndClearL();

			break;

		default:

			break;

		}

	}

#define ARRAYLENGTH(aArray) (static_cast<TInt>((sizeof(aArray) / sizeof(aArray[0]))))

//

// Constant test values used in many tests

//

const TPositionSelectionOrder::TOrder KTestOrders[] =

    {

    TPositionSelectionOrder::EOrderVeryLow,

    TPositionSelectionOrder::EOrderLow,

    TPositionSelectionOrder::EOrderFairlyLow,

    TPositionSelectionOrder::EOrderMedium,

    TPositionSelectionOrder::EOrderFairlyHigh,

    TPositionSelectionOrder::EOrderHigh,

    TPositionSelectionOrder::EOrderVeryHigh

    };

const TPositionSelectionOrder::TField KTestFields[] =

    {

    TPositionSelectionOrder::EFieldTimeToFirstFix,

    TPositionSelectionOrder::EFieldTimeToNextFix,

    TPositionSelectionOrder::EFieldHorizontalAccuracy,

    TPositionSelectionOrder::EFieldVerticalAccuracy,

    TPositionSelectionOrder::EFieldCost,

    TPositionSelectionOrder::EFieldPower

    };

typedef TInt (TPositionSelectionOrder::*SetterFuncTYPE)(TPositionSelectionOrder::TOrder);

// WARNING: The order of these must match the order of the KTestFields

// array declared above.

const SetterFuncTYPE KSetterFunctions[] =

    {

    &TPositionSelectionOrder::SetOrderTimeToFirstFix,

    &TPositionSelectionOrder::SetOrderTimeToNextFix,

    &TPositionSelectionOrder::SetOrderHorizontalAccuracy,

    &TPositionSelectionOrder::SetOrderVerticalAccuracy,

    &TPositionSelectionOrder::SetOrderCostIndicator,

    &TPositionSelectionOrder::SetOrderPowerConsumption

    };

//

// Constants that reflect the API design

//

#define NUM_SELECTION_CRITERIA    (TUint(ARRAYLENGTH(KSetterFunctions)))

#define DEFAULT_CRITERIA_MANDATORY_CAPABILITIES (static_cast<TPositionModuleInfo::TCapabilities>(TPositionModuleInfo::ECapabilityHorizontal))

//

// Utility function prototypes

//

TBool IsNewlyConstructed(const TPositionSelectionOrder& aSelOrder);

TBool IsNewlyConstructed(const TPositionQuality& aPosQuality);

TBool AreEqualL(const TPositionSelectionOrder& aLhs, const TPositionSelectionOrder& aRhs);

TBool AreEqualL(const TPositionQuality& aLhs, const TPositionQuality& aRhs);

//

//

// Position Criteria classes

//

//

// 5.2.1. Construction

void CCriteriaClassesStep::TPositionSelectionOrder_ConstructionL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    TPositionSelectionOrder selOrder;

    CHECK( IsNewlyConstructed(selOrder));

    StandardCleanup();

	}

// 5.2.2. Set/Get

void CCriteriaClassesStep::TPositionSelectionOrder_SetL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    __UHEAP_MARK;

    for (TInt i=0; i<ARRAYLENGTH(KTestOrders); i++)

    	{

        for (TInt j=0; j<ARRAYLENGTH(KSetterFunctions); j++)

        	{

        	TPositionSelectionOrder selOrder;

        	selOrder.ClearSelectionOrder();

            // Set field priority

            SetterFuncTYPE setterFunction = KSetterFunctions[j];

            CHECK_EQUAL_( KErrNone, (selOrder.*setterFunction)(KTestOrders[i]));

            // Get & check field priority

            TPositionSelectionOrder::TField field;

            TPositionSelectionOrder::TOrder order;

            CHECK_EQUAL_( KErrNone, selOrder.GetSelectionItem(j, field, order));

            CHECK_EQUAL_( KTestFields[j], field);

            CHECK_EQUAL_( KTestOrders[i], order);

        	}

    	}

    __UHEAP_MARKEND;

    StandardCleanup();

	}

// 5.2.3. Clear & Reset

void CCriteriaClassesStep::TPositionSelectionOrder_ClearL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    TPositionSelectionOrder selOrder;

    TPositionSelectionOrder::TField field;

    TPositionSelectionOrder::TOrder order;

    selOrder.ClearSelectionOrder();

    CHECK_EQUAL_( TUint(0), selOrder.NumSelectionItems());

    selOrder.ResetSelectionOrder();

    CHECK_EQUAL_( 2, selOrder.NumSelectionItems());

    for (TInt i=0; i<ARRAYLENGTH(KTestFields); i++)

	    {

	    CHECK_EQUAL_( KErrNone, selOrder.GetSelectionItem(i, field, order));

	    if(i == TPositionSelectionOrder::EFieldHorizontalAccuracy)

	    	{

	    	CHECK_EQUAL_( TPositionSelectionOrder::EOrderHigh, order);

	    	}

	    else if(i == TPositionSelectionOrder::EFieldCost)

	    	{

	    	CHECK_EQUAL_( TPositionSelectionOrder::EOrderMedium, order);

	    	}

	    else

	    	{

	    	CHECK_EQUAL_(0, field);

	    	CHECK_EQUAL_( TPositionSelectionOrder::EOrderDontCare, order);

	    	}

	    }

    StandardCleanup();

	}

// 5.2.5. NumSelectionItems

void CCriteriaClassesStep::TPositionSelectionOrder_NumSelectionItemsL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    TPositionSelectionOrder selOrder;

    selOrder.ClearSelectionOrder();

    TInt i;

    for (i=0; i<ARRAYLENGTH(KSetterFunctions); i++)

    	{

        SetterFuncTYPE setterFunction = KSetterFunctions[i];

        CHECK_EQUAL_( KErrNone, (selOrder.*setterFunction)(KTestOrders[i]));

        CHECK_EQUAL_( TUint(i), selOrder.NumSelectionItems());

    	}

    for (i=0; i<ARRAYLENGTH(KSetterFunctions); i++)

    	{

        SetterFuncTYPE setterFunction = KSetterFunctions[i];

        CHECK_EQUAL_( KErrNone, (selOrder.*setterFunction)(KTestOrders[i]));

        CHECK_EQUAL_( (TUint(ARRAYLENGTH(KTestFields))-1), selOrder.NumSelectionItems());

    	}

    StandardCleanup();

	}

//

//

// TPositionCriteria

//

//

// 5.1.1. Construction

void CCriteriaClassesStep::TPositionCriteria_ConstructionL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    // Blank Constructor

    TPositionCriteria blankCriteria;

    // Check the required caps are blank

    CHECK_EQUAL_(

            DEFAULT_CRITERIA_MANDATORY_CAPABILITIES,

            blankCriteria.RequiredCapabilities()

    );

    // Check the TPositionSelectionOrder component is blank / newly constructed

    TPositionSelectionOrder selOrder;

    blankCriteria.GetSelectionOrder(selOrder);

    CHECK( IsNewlyConstructed(selOrder));

    // Check the position quality is blank

    TPositionQuality posQuality;

    blankCriteria.GetRequiredQuality(posQuality);

    CHECK( IsNewlyConstructed(posQuality));

    // Capabilities Constructor

    const TPositionModuleInfo::TCapabilities KCaps =

        TPositionModuleInfo::ECapabilityHorizontal |

        TPositionModuleInfo::ECapabilityVertical |

        TPositionModuleInfo::ECapabilityDirection |

        TPositionModuleInfo::ECapabilityCompass;

    TPositionCriteria criteria(KCaps);

    // Check the required caps are blank

    CHECK_EQUAL_( KCaps, criteria.RequiredCapabilities());

    // Check the TPositionSelectionOrder component is blank / newly constructed

    TPositionSelectionOrder selOrder2;

    criteria.GetSelectionOrder(selOrder2);

    CHECK( IsNewlyConstructed(selOrder2));

    // Check the position quality is blank

    TPositionQuality posQuality2;

    criteria.GetRequiredQuality(posQuality2);

    CHECK( IsNewlyConstructed(posQuality2));

    StandardCleanup();

	}

// 5.1.2. Get/Set properties

void CCriteriaClassesStep::TPositionCriteria_SetL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    TPositionCriteria criteria;

    // selction order

    TPositionSelectionOrder order, order2;

    CHECK_EQUAL_(KErrNone, order.SetOrderTimeToFirstFix(TPositionSelectionOrder::EOrderLow));

    CHECK_EQUAL_(KErrNone, order.SetOrderTimeToNextFix(TPositionSelectionOrder::EOrderFairlyHigh));

    CHECK_EQUAL_(KErrNone, order.SetOrderVerticalAccuracy(TPositionSelectionOrder::EOrderFairlyLow));

    CHECK_EQUAL_(KErrNone, order.SetOrderPowerConsumption(TPositionSelectionOrder::EOrderVeryHigh));

    criteria.SetSelectionOrder(order);

    criteria.GetSelectionOrder(order2);

    CHECK( AreEqualL(order, order2));

        // position quality

    TPositionQuality quality, quality2;

    quality.SetTimeToFirstFix(TTimeIntervalMicroSeconds (987));

    quality.SetTimeToNextFix(TTimeIntervalMicroSeconds (654));

    quality.SetHorizontalAccuracy(TReal32 (123.555));

    quality.SetVerticalAccuracy(TReal32 (45.88));

    quality.SetCostIndicator(TPositionQuality::ECostPossible);

    quality.SetPowerConsumption(TPositionQuality::EPowerZero);

    criteria.SetRequiredQuality(quality);

    criteria.GetRequiredQuality(quality2);

    CHECK( AreEqualL(quality, quality2));

    // required capabilities

    TPositionModuleInfo::TCapabilities caps = 0;

    // i ranges over all the bits in a TPositionModuleInfo::TCapabilities

    for (TUint i=0; i<sizeof(TPositionModuleInfo::TCapabilities) * 8; i++)

    	{

        caps |= (1 << i);

        criteria.AddRequiredCapabilities(1 << i);

        CHECK_EQUAL_( caps, criteria.RequiredCapabilities());

    	}

    criteria.ClearRequiredCapabilities();

    CHECK_EQUAL_( TPositionModuleInfo::TCapabilities(0), criteria.RequiredCapabilities());

    StandardCleanup();

	}

// 5.1.3. Reset and Clear

void CCriteriaClassesStep::TPositionCriteria_ResetAndClearL()

	{

    DECLARE_ERROR_LOGGING;

    StandardPrepareL();

    __UHEAP_MARK;

    // create it

    TPositionCriteria criteria( TPositionModuleInfo::ECapabilityHorizontal |

                            TPositionModuleInfo::ECapabilityVertical |

                            TPositionModuleInfo::ECapabilityDirection |

                            TPositionModuleInfo::ECapabilityCompass);

    TPositionSelectionOrder selOrder;

    CHECK_EQUAL_(KErrNone, selOrder.SetOrderTimeToFirstFix(TPositionSelectionOrder::EOrderLow));

    CHECK_EQUAL_(KErrNone, selOrder.SetOrderTimeToNextFix(TPositionSelectionOrder::EOrderFairlyHigh));

    CHECK_EQUAL_(KErrNone, selOrder.SetOrderVerticalAccuracy(TPositionSelectionOrder::EOrderFairlyLow));

    CHECK_EQUAL_(KErrNone, selOrder.SetOrderPowerConsumption(TPositionSelectionOrder::EOrderVeryHigh));

    criteria.SetSelectionOrder(selOrder);

    TPositionQuality quality;

    quality.SetTimeToFirstFix(TTimeIntervalMicroSeconds (987));

    quality.SetTimeToNextFix(TTimeIntervalMicroSeconds (654));

    quality.SetHorizontalAccuracy(TReal32 (123.555));

    quality.SetVerticalAccuracy(TReal32 (45.88));

    quality.SetCostIndicator(TPositionQuality::ECostPossible);

    quality.SetPowerConsumption(TPositionQuality::EPowerZero);

    criteria.SetRequiredQuality(quality);

    // Do a reset

    criteria.ResetCriteria();

    // Check the required caps are blank

    CHECK_EQUAL_(

            DEFAULT_CRITERIA_MANDATORY_CAPABILITIES,

            criteria.RequiredCapabilities());

    // Check the TPositionSelectionOrder component is blank / newly constructed

    TPositionSelectionOrder selOrder2;

    criteria.GetSelectionOrder(selOrder2);

    // TODO Investigate

    //CHECK( IsNewlyConstructed(selOrder2));

    // Check the position quality is blank

    TPositionQuality posQuality;

    criteria.GetRequiredQuality(posQuality);

    CHECK( IsNewlyConstructed(posQuality));

    // Do a clear

    criteria.ClearCriteria();

    // Should not be any selection items in the contains TPositionSelectionOrder

    criteria.GetSelectionOrder(selOrder);

    CHECK_EQUAL_( TUint(0), selOrder.NumSelectionItems());

    __UHEAP_MARKEND;

    StandardCleanup();

	}

//

//

// Utility functions

//

//

// Macro

// Only supposed to be used by the following utility functions

#define RETURN_IF_NOT_EQUAL(aLhs, aRhs) \

    if ((aLhs) != (aRhs))               \

            return EFalse;

TBool IsNewlyConstructed(const TPositionSelectionOrder& aSelOrder)

    {

    RETURN_IF_NOT_EQUAL( NUM_SELECTION_CRITERIA, aSelOrder.NumSelectionItems());

    for (TInt i=0; i<ARRAYLENGTH(KTestFields); i++)

            {

            TPositionSelectionOrder::TField field;

            TPositionSelectionOrder::TOrder order;

            RETURN_IF_NOT_EQUAL( KErrNone, aSelOrder.GetSelectionItem(i, field, order));

            RETURN_IF_NOT_EQUAL( KTestFields[i], field);

            RETURN_IF_NOT_EQUAL( TPositionSelectionOrder::EOrderDefault, order);

            }

    return ETrue;

    }

TBool IsNewlyConstructed(const TPositionQuality& aPosQuality)

    {

    RETURN_IF_NOT_EQUAL( TTimeIntervalMicroSeconds(0), aPosQuality.TimeToFirstFix());

    RETURN_IF_NOT_EQUAL( TTimeIntervalMicroSeconds(0), aPosQuality.TimeToNextFix());

    RETURN_IF_NOT_EQUAL( TPositionQuality::ECostUnknown, aPosQuality.CostIndicator());

    RETURN_IF_NOT_EQUAL( TPositionQuality::EPowerUnknown, aPosQuality.PowerConsumption());

    if (!Math::IsNaN(aPosQuality.HorizontalAccuracy())) return EFalse;

    if (!Math::IsNaN(aPosQuality.VerticalAccuracy())) return EFalse;

    return ETrue;

    }

TBool AreEqualL(const TPositionSelectionOrder& aLhs, const TPositionSelectionOrder& aRhs)

/**

 * If this function leaves, it would fail the test

 */

    {

    RETURN_IF_NOT_EQUAL( aLhs.NumSelectionItems(), aRhs.NumSelectionItems());

    TUint num = aLhs.NumSelectionItems();

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

        {

        TPositionSelectionOrder::TField field1;