--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/src/moduleclassesstep.cpp Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,798 @@
+// 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
+ CHECK_EQUAL_(TPositionQualityItem::EIsBetter, result);
+ }
+ else // odd ids
+ {
+ // we prefer smaller values here
+ CHECK_EQUAL_(TPositionQualityItem::EIsWorse, result);
+ }
+ }
+ // same for the 2nd part
+ for (j = 0; j < lowQ2.HighWaterMark() + 1; j++)
+ {
+ lowQ2.Compare(bigQ2, j, result);
+ TPositionQualityItem::TResult pref;
+ pref = (j % 2 == 0) ? TPositionQualityItem::EIsBetter : TPositionQualityItem::EIsWorse;
+ CHECK_EQUAL_(pref, result);
+ }
+
+ // specific test for different preferences and data types
+
+ class TQualityGreaterSigned : public TPositionQualityBase {
+ public:
+ TQualityGreaterSigned()
+ {
+ SET_ELEMENT(0, TPositionQualityItem::ETInt8,
+ TPositionQualityItem::EPreferGreaterValues, TInt8(1));
+ SET_ELEMENT(1, TPositionQualityItem::ETInt8,
+ TPositionQualityItem::EPreferGreaterValues, TInt8(2));
+ SET_ELEMENT(2, TPositionQualityItem::ETInt8,
+ TPositionQualityItem::EPreferGreaterValues, TInt8(3));
+ };
+ } qGS;
+
+ class TQualityReverse : public TPositionQualityBase {
+ public:
+ TQualityReverse()
+ {
+ SET_ELEMENT(0, TPositionQualityItem::ETInt8,
+ TPositionQualityItem::EPreferSmallerValues, TInt8(1));
+ SET_ELEMENT(1, TPositionQualityItem::ETUint8,
+ TPositionQualityItem::EPreferGreaterValues, TUint8(2));
+ SET_ELEMENT(2, TPositionQualityItem::ETUint8,
+ TPositionQualityItem::EPreferSmallerValues, TUint8(3));
+
+ SET_ELEMENT(3, TPositionQualityItem::ETUint8,
+ TPositionQualityItem::EPreferSmallerValues, TUint8(3));
+ ResetElement(3);
+ };
+ } qR;
+
+ // in all cases KErrArgument should be returned
+ CHECK_EQUAL_(KErrArgument, qGS.Compare(qR, 0, result));
+ CHECK_EQUAL_(KErrArgument, qGS.Compare(qR, 1, result));
+ CHECK_EQUAL_(KErrArgument, qGS.Compare(qR, 2, result));
+
+ StandardCleanup();
+ }
+#pragma warning (pop)
+
+//
+//
+// Module Updates, Status, Events classes
+//
+//
+
+// 7.1.1. Construction
+void CModuleClassesStep::ModuleClasses_ConstructionL()
+ {
+ DECLARE_ERROR_LOGGING;
+ StandardPrepareL();
+
+ // Update Options
+ TPositionUpdateOptions updateOptions;
+
+ CHECK(updateOptions.PositionClassSize() == sizeof(TPositionUpdateOptions));
+ CHECK(updateOptions.PositionClassType() == EPositionUpdateOptionsClass);
+
+ CHECK_EQUAL_(TInt64(0), updateOptions.UpdateInterval().Int64());
+ CHECK_EQUAL_(TInt64(0), updateOptions.UpdateTimeOut().Int64());
+ CHECK_EQUAL_(TInt64(0), updateOptions.MaxUpdateAge().Int64());
+ CHECK(!updateOptions.AcceptPartialUpdates());
+
+ const TBool KDummyAcceptUpdates = ETrue;
+ const TTimeIntervalMicroSeconds KUpdateInterval(23412);
+ const TTimeIntervalMicroSeconds KTimeOut(4123523);
+ const TTimeIntervalMicroSeconds KMaxUpdateAge(3245);
+
+ TPositionUpdateOptions updateOptions2(
+ KUpdateInterval,
+ KTimeOut,
+ KMaxUpdateAge,
+ KDummyAcceptUpdates);
+
+ CHECK_EQUAL_(KUpdateInterval, updateOptions2.UpdateInterval());
+ CHECK_EQUAL_(KTimeOut, updateOptions2.UpdateTimeOut().Int64());
+ CHECK_EQUAL_(KMaxUpdateAge, updateOptions2.MaxUpdateAge().Int64());
+ CHECK(updateOptions2.AcceptPartialUpdates());
+
+ // Module Status
+ TPositionModuleStatus moduleStatus;
+
+ CHECK(moduleStatus.PositionClassSize() == sizeof(TPositionModuleStatus));
+ CHECK(moduleStatus.PositionClassType() == EPositionModuleStatusClass);
+
+ CHECK(moduleStatus.DeviceStatus() == TPositionModuleStatus::EDeviceUnknown);
+ CHECK(moduleStatus.DataQualityStatus() == TPositionModuleStatus::EDataQualityUnknown);
+
+ // Module status event
+ TPositionModuleStatusEvent posModEvent;
+
+ CHECK(posModEvent.PositionClassSize() == sizeof(TPositionModuleStatusEvent));
+ CHECK(posModEvent.PositionClassType() == EPositionModuleStatusEventClass);
+
+ CHECK(posModEvent.RequestedEvents() == TPositionModuleStatusEvent::EEventNone);
+ CHECK(posModEvent.OccurredEvents() == TPositionModuleStatusEvent::EEventNone);
+
+ posModEvent.GetModuleStatus(moduleStatus);
+
+ CHECK(moduleStatus.DeviceStatus() == TPositionModuleStatus::EDeviceUnknown);
+ CHECK(moduleStatus.DataQualityStatus() == TPositionModuleStatus::EDataQualityUnknown);
+
+ //Just do a check here for construction with requested events parameter.
+ TPositionModuleStatusEvent posModEvent2(TPositionModuleStatusEvent::EEventDataQualityStatus);
+ CHECK(posModEvent2.RequestedEvents() == TPositionModuleStatusEvent::EEventDataQualityStatus);
+
+ StandardCleanup();
+ }
+
+// 7.1.2. Setters/Getters
+void CModuleClassesStep::ModuleClasses_SettersL()
+ {
+ DECLARE_ERROR_LOGGING;
+ StandardPrepareL();
+
+ // Update Options
+ TPositionUpdateOptions updateOptions;
+
+ const TBool KDummyAcceptUpdates = ETrue;
+ const TTimeIntervalMicroSeconds KUpdateInterval(23412);
+ const TTimeIntervalMicroSeconds KTimeOut(4123523);
+ const TTimeIntervalMicroSeconds KMaxUpdateAge(3245);
+
+ updateOptions.SetAcceptPartialUpdates(KDummyAcceptUpdates);
+ updateOptions.SetUpdateInterval(KUpdateInterval);
+ updateOptions.SetUpdateTimeOut(KTimeOut);
+ updateOptions.SetMaxUpdateAge(KMaxUpdateAge);
+
+ CHECK(updateOptions.AcceptPartialUpdates());
+ CHECK_EQUAL_(updateOptions.UpdateInterval().Int64(), KUpdateInterval.Int64());
+ CHECK_EQUAL_(updateOptions.UpdateTimeOut().Int64(), KTimeOut.Int64());
+ CHECK_EQUAL_(updateOptions.MaxUpdateAge().Int64(), KMaxUpdateAge.Int64());
+
+ // Module status
+ TPositionModuleStatus moduleStatus;
+
+ const TPositionModuleStatus::TDeviceStatus
+ KDummyDeviceStatus(TPositionModuleStatus::EDeviceInactive);
+ const TPositionModuleStatus::TDataQualityStatus
+ KDummyQualityStatus(TPositionModuleStatus::EDataQualityPartial);
+
+ moduleStatus.SetDeviceStatus(KDummyDeviceStatus);
+ moduleStatus.SetDataQualityStatus(KDummyQualityStatus);
+
+ CHECK_EQUAL_(KDummyDeviceStatus, moduleStatus.DeviceStatus());
+ CHECK_EQUAL_(KDummyQualityStatus, moduleStatus.DataQualityStatus());
+
+ // Module status event
+ TPositionModuleStatusEvent posModEvent;
+
+ const TPositionModuleId KDummyModuleId = {0x00355463};
+ const TPositionModuleStatusEvent::TModuleEvent
+ KDummyRequestedEvent(TPositionModuleStatusEvent::EEventDeviceStatus);
+ const TPositionModuleStatusEvent::TModuleEvent
+ KDummyOccurredEvent(TPositionModuleStatusEvent::EEventDataQualityStatus);
+ const TPositionModuleStatusEvent::TSystemModuleEvent
+ KDummySystemEvent(TPositionModuleStatusEvent::ESystemModuleRemoved);
+
+ posModEvent.SetModuleId(KDummyModuleId);
+ posModEvent.SetRequestedEvents(KDummyRequestedEvent);
+ posModEvent.SetOccurredEvents(KDummyOccurredEvent);
+ posModEvent.SetSystemModuleEvent(KDummySystemEvent);
+
+ CHECK_EQUAL_(KDummyModuleId.iUid, posModEvent.ModuleId().iUid);
+ CHECK_EQUAL_(KDummyRequestedEvent, posModEvent.RequestedEvents());
+ CHECK_EQUAL_(KDummyOccurredEvent, posModEvent.OccurredEvents());
+ CHECK_EQUAL_(KDummySystemEvent, posModEvent.SystemModuleEvent());
+
+ TPositionModuleStatus modStatus2;
+ posModEvent.SetModuleStatus(moduleStatus);
+ posModEvent.GetModuleStatus(modStatus2);
+
+ CHECK_EQUAL_(modStatus2.DeviceStatus(), KDummyDeviceStatus);
+ CHECK_EQUAL_(modStatus2.DataQualityStatus(), KDummyQualityStatus);
+
+ StandardCleanup();
+ }
+
+// 7.2.1. Invalid Input in TPositionUpdateOptions
+const TInt timeNEG(-1);
+const TInt timeZero(-1);
+
+
+TInt NegativeTimeConstructionInterval(TAny* /*aPtr*/)
+ {
+ TPositionUpdateOptions updateOptions(timeNEG, timeZero, timeZero);
+ return KErrGeneral;
+ }
+
+
+TInt NegativeTimeConstructionTimeOut(TAny* /*aPtr*/)
+ {
+ TPositionUpdateOptions updateOptions(timeZero, timeNEG, timeZero);
+ return KErrGeneral;
+ }
+
+
+TInt NegativeTimeConstructionMaxAge(TAny* /*aPtr*/)
+ {
+ TPositionUpdateOptions updateOptions(timeZero, timeZero, timeNEG);
+ return KErrGeneral;
+ }
+
+
+TInt NegativeTimeSettingInterval(TAny* /*aPtr*/)
+ {
+ TPositionUpdateOptions updateOptions;
+ updateOptions.SetUpdateInterval(timeNEG);
+ return KErrGeneral;
+ }
+
+
+TInt NegativeTimeSettingTimeOut(TAny* /*aPtr*/)
+ {
+ TPositionUpdateOptions updateOptions;
+ updateOptions.SetUpdateTimeOut(timeNEG);
+ return KErrGeneral;
+ }
+
+
+TInt NegativeTimeSettingMaxAge(TAny* /*aPtr*/)
+ {
+ TPositionUpdateOptions updateOptions;
+ updateOptions.SetMaxUpdateAge(timeNEG);
+ return KErrGeneral;
+ }
+
+
+void CModuleClassesStep::TPositionUpdateOptions_InvalidL()
+ {
+ DECLARE_ERROR_LOGGING;
+ StandardPrepareL();
+
+ // construction
+ DO_PANIC_TEST_L(NegativeTimeConstructionInterval, KPosClientFault,
+ EPositionBadTime, KDefaultTestTimeout);
+ DO_PANIC_TEST_L(NegativeTimeConstructionTimeOut, KPosClientFault,
+ EPositionBadTime, KDefaultTestTimeout);
+ DO_PANIC_TEST_L(NegativeTimeConstructionMaxAge, KPosClientFault,
+ EPositionBadTime, KDefaultTestTimeout);
+
+ // setting
+ DO_PANIC_TEST_L(NegativeTimeSettingInterval, KPosClientFault,
+ EPositionBadTime, KDefaultTestTimeout);
+ DO_PANIC_TEST_L(NegativeTimeSettingTimeOut, KPosClientFault,
+ EPositionBadTime, KDefaultTestTimeout);
+ DO_PANIC_TEST_L(NegativeTimeSettingMaxAge, KPosClientFault,
+ EPositionBadTime, KDefaultTestTimeout);
+
+ StandardCleanup();
+ }
+