--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/src/criteriaclassesstep.cpp Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,563 @@
+// 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;
+ TPositionSelectionOrder::TOrder order1;
+ User::LeaveIfError(aLhs.GetSelectionItem(0, field1, order1));
+
+ TUint j;
+ for (j=0; j<num; j++)
+ {
+ TPositionSelectionOrder::TField field2;
+ TPositionSelectionOrder::TOrder order2;
+ User::LeaveIfError(aRhs.GetSelectionItem(0, field2, order2));
+ if (field1 == field2 && order1 == order2)
+ {
+ break;
+ }
+ }
+
+ if (j == num)
+ {
+ return EFalse;
+ }
+ }
+ return ETrue;
+ }
+TBool AreEqualL(const TPositionQuality& aLhs, const TPositionQuality& aRhs)
+/**
+ * If this function leaves, it would fail the test
+ */
+ {
+ RETURN_IF_NOT_EQUAL( aLhs.TimeToFirstFix(), aRhs.TimeToFirstFix());
+ RETURN_IF_NOT_EQUAL( aLhs.TimeToNextFix(), aRhs.TimeToNextFix());
+ RETURN_IF_NOT_EQUAL( aLhs.HorizontalAccuracy(), aRhs.HorizontalAccuracy());
+ RETURN_IF_NOT_EQUAL( aLhs.VerticalAccuracy(), aRhs.VerticalAccuracy());
+ RETURN_IF_NOT_EQUAL( aLhs.CostIndicator(), aRhs.CostIndicator());
+ RETURN_IF_NOT_EQUAL( aLhs.PowerConsumption(), aRhs.PowerConsumption());
+ return ETrue;
+ }