diff -r 7f293ed715ec -r a4835904093b LbsApi/src/moduleclassesstep.cpp
--- /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();
+	}
+