LbsApi/src/moduleclassesstep.cpp
author Maciej Seroka <maciejs@symbian.org>
Wed, 28 Jul 2010 13:24:28 +0100
branchSymbian3
changeset 54 a4835904093b
permissions -rw-r--r--
Added new LbsApi smoke test

// 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();
	}