# HG changeset patch
# User Maciej Seroka <maciejs@symbian.org>
# Date 1280319868 -3600
# Node ID a4835904093b9cf52def74f392d62886fc9e99f8
# Parent  7f293ed715ecf23f2c400f4db49984092b1c8d65
Added new LbsApi smoke test

diff -r 7f293ed715ec -r a4835904093b Group/ats4_smoketest.xml
--- a/Group/ats4_smoketest.xml	Tue Jul 20 09:28:07 2010 +0100
+++ b/Group/ats4_smoketest.xml	Wed Jul 28 13:24:28 2010 +0100
@@ -208,6 +208,13 @@
 			<task agents="target">
 				<type>FileUploadTask</type>
 				<parameters>
+					<parameter value="smoketest\winscw_udeb\te_lbsapisuite.exe" name="src"/>
+					<parameter value="c:\sys\bin\te_lbsapisuite.exe" name="dst"/>
+				</parameters>
+			</task>
+			<task agents="target">
+				<type>FileUploadTask</type>
+				<parameters>
 					<parameter value="smoketest\winscw_udeb\testsdkskins.dll" name="src"/>
 					<parameter value="c:\sys\bin\testsdkskins.dll" name="dst"/>
 				</parameters>
@@ -350,6 +357,16 @@
 			<type>ExecutableTestCaseTask</type>
 			<parameters>
 				<parameter name="file" value="testexecute.exe"/>
+				<parameter name="parameters" value="c:\smoketest\smoketest_lbs.script" />
+				<parameter name="parser" value="TEFResultParser" />
+				<parameter name="result-file" value="c:\logs\testexecute\smoketest_lbs.htm" />
+				<parameter name="timeout" value="1200" />
+			</parameters>
+		</task>
+		<task agents="target">
+			<type>ExecutableTestCaseTask</type>
+			<parameters>
+				<parameter name="file" value="testexecute.exe"/>
 				<parameter name="parameters" value="c:\smoketest\smoketest_bitmap.script" />
 				<parameter name="parser" value="TEFResultParser" />
 				<parameter name="result-file" value="c:\logs\testexecute\smoketest_bitmap.htm" />
diff -r 7f293ed715ec -r a4835904093b Group/ats4_smoketest_syborg.xml
--- a/Group/ats4_smoketest_syborg.xml	Tue Jul 20 09:28:07 2010 +0100
+++ b/Group/ats4_smoketest_syborg.xml	Wed Jul 28 13:24:28 2010 +0100
@@ -106,6 +106,16 @@
 			<type>ExecutableTestCaseTask</type>
 			<parameters>
 				<parameter name="file" value="testexecute.exe"/>
+				<parameter name="parameters" value="z:\smoketest\smoketest_lbs.script" />
+				<parameter name="parser" value="TEFResultParser" />
+				<parameter name="result-file" value="c:\logs\testexecute\smoketest_lbs.htm" />
+				<parameter name="timeout" value="1200" />
+			</parameters>
+		</task>
+		<task agents="target">
+			<type>ExecutableTestCaseTask</type>
+			<parameters>
+				<parameter name="file" value="testexecute.exe"/>
 				<parameter name="parameters" value="z:\smoketest\smoketest_bitmap.script" />
 				<parameter name="parser" value="TEFResultParser" />
 				<parameter name="result-file" value="c:\logs\testexecute\smoketest_bitmap.htm" />
diff -r 7f293ed715ec -r a4835904093b Group/bld.inf
--- a/Group/bld.inf	Tue Jul 20 09:28:07 2010 +0100
+++ b/Group/bld.inf	Wed Jul 28 13:24:28 2010 +0100
@@ -26,7 +26,7 @@
 #include "../profiles/group/Bld.inf"
 #include "../notepad/group/bld.inf"
 #include "../appinstall/group/Bld.inf"
-//#include "../lbs/group/bld.inf"
+#include "../LbsApi/group/bld.inf"
 #include "../uiresources/group/bld.inf"
 #include "../inputmethods/group/Bld.inf"
 //#include "../localisation/uiftestfw/group/BLD.INF"
diff -r 7f293ed715ec -r a4835904093b Group/smoketest.oby
--- a/Group/smoketest.oby	Tue Jul 20 09:28:07 2010 +0100
+++ b/Group/smoketest.oby	Wed Jul 28 13:24:28 2010 +0100
@@ -10,6 +10,7 @@
 #include <Smoketest_graphics.iby>
 #include <Smoketest_http.iby>
 #include <Smoketest_InputMethods.iby>
+#include <Smoketest_lbs.iby>
 #include <Smoketest_Mediamgmt.iby>
 #include <Smoketest_Mess.iby>
 #include <Smoketest_notepad.iby>
diff -r 7f293ed715ec -r a4835904093b Group/smoketest.pl
--- a/Group/smoketest.pl	Tue Jul 20 09:28:07 2010 +0100
+++ b/Group/smoketest.pl	Wed Jul 28 13:24:28 2010 +0100
@@ -161,12 +161,7 @@
 	copy($epoc . "release/winscw/udeb/t_msgutilityserver.dll",			"temp/smoketest/winscw_udeb/t_msgutilityserver.dll");
 	copy($epoc . "release/winscw/udeb/t_msgpopserver.exe",				"temp/smoketest/winscw_udeb/t_msgpopserver.exe");
 	copy($epoc . "release/winscw/udeb/t_msgsmtpserver.exe",				"temp/smoketest/winscw_udeb/t_msgsmtpserver.exe");
-	copy($epoc . "release/winscw/udeb/lbstestutils.dll",				"temp/smoketest/winscw_udeb/lbstestutils.dll");
-	copy($epoc . "release/winscw/udeb/lbstestclient.dll",				"temp/smoketest/winscw_udeb/lbstestclient.dll");
-	copy($epoc . "release/winscw/udeb/lbstestchannel.dll",				"temp/smoketest/winscw_udeb/lbstestchannel.dll");
-	copy($epoc . "release/winscw/udeb/lbstestserver.exe",				"temp/smoketest/winscw_udeb/lbstestserver.exe");
-	copy($epoc . "release/winscw/udeb/ctlbsexeclient.exe",				"temp/smoketest/winscw_udeb/ctlbsexeclient.exe");
-	copy($epoc . "release/winscw/udeb/lbsclienttestserver.exe",			"temp/smoketest/winscw_udeb/lbsclienttestserver.exe");
+	copy($epoc . "release/winscw/udeb/te_lbsapisuite.exe",				"temp/smoketest/winscw_udeb/te_lbsapisuite.exe");
 	copy($epoc . "release/winscw/udeb/appfwk_test_AppUi.dll",			"temp/smoketest/winscw_udeb/appfwk_test_AppUi.dll");
 	copy($epoc . "release/winscw/udeb/appfwk_test_utils.dll",			"temp/smoketest/winscw_udeb/appfwk_test_utils.dll");
 	copy($epoc . "release/winscw/udeb/TIconLoaderAndIconArrayForLeaks.dll",	"temp/smoketest/winscw_udeb/TIconLoaderAndIconArrayForLeaks.dll");
diff -r 7f293ed715ec -r a4835904093b Group/smoketest.xml
--- a/Group/smoketest.xml	Tue Jul 20 09:28:07 2010 +0100
+++ b/Group/smoketest.xml	Wed Jul 28 13:24:28 2010 +0100
@@ -544,57 +544,12 @@
 							<param component-path="smoketest" />
 						</params>
 					</step>						
-					<step id="" name="Test Step 1 (install)" harness="GENERIC" enabled="false" passrate="100" significant="false">
-						<command>install</command>
-						<params>
-							<param type="binary"/>
-							<param src="lbstestutils.dll"/>
-							<param dst="c:\sys\bin\lbstestutils.dll"/>
-							<param component-path="smoketest" />
-						</params>
-					</step>	
-					<step id="" name="Test Step 1 (install)" harness="GENERIC" enabled="false" passrate="100" significant="false">
-						<command>install</command>
-						<params>
-							<param type="binary"/>
-							<param src="lbstestclient.dll"/>
-							<param dst="c:\sys\bin\lbstestclient.dll"/>
-							<param component-path="smoketest" />
-						</params>
-					</step>	
-					<step id="" name="Test Step 1 (install)" harness="GENERIC" enabled="false" passrate="100" significant="false">
+					<step id="" name="Test Step 1 (install)" harness="GENERIC" enabled="true" passrate="100" significant="false">
 						<command>install</command>
 						<params>
 							<param type="binary"/>
-							<param src="lbstestchannel.dll"/>
-							<param dst="c:\sys\bin\lbstestchannel.dll"/>
-							<param component-path="smoketest" />
-						</params>
-					</step>
-					<step id="" name="Test Step 1 (install)" harness="GENERIC" enabled="false" passrate="100" significant="false">
-						<command>install</command>
-						<params>
-							<param type="binary"/>
-							<param src="lbstestserver.exe"/>
-							<param dst="c:\sys\bin\lbstestserver.exe"/>
-							<param component-path="smoketest" />
-						</params>
-					</step>
-					<step id="" name="Test Step 1 (install)" harness="GENERIC" enabled="false" passrate="100" significant="false">
-						<command>install</command>
-						<params>
-							<param type="binary"/>
-							<param src="ctlbsexeclient.exe"/>
-							<param dst="c:\sys\bin\ctlbsexeclient.exe"/>
-							<param component-path="smoketest" />
-						</params>
-					</step>
-					<step id="" name="Test Step 1 (install)" harness="GENERIC" enabled="false" passrate="100" significant="false">
-						<command>install</command>
-						<params>
-							<param type="binary"/>
-							<param src="lbsclienttestserver.exe"/>
-							<param dst="c:\sys\bin\lbsclienttestserver.exe"/>
+							<param src="te_lbsapisuite.exe"/>
+							<param dst="c:\sys\bin\te_lbsapisuite.exe"/>
 							<param component-path="smoketest" />
 						</params>
 					</step>
@@ -763,7 +718,7 @@
 							<param leave-old-result="true"/>
 						</params>
 					</step>
-					<step id="" name="Test Step 2 (execute)" harness="GENERIC" enabled="false" passrate="100" significant="true">
+					<step id="" name="Test Step 2 (execute)" harness="GENERIC" enabled="true" passrate="100" significant="true">
 						<command>execute</command>
 						<params>
 							<param file="testexecute.exe"/>
@@ -1214,6 +1169,8 @@
 		<file>smoketest/general/smoketest_timew.script</file>
 		<file>smoketest/general/smoketest_email.ini</file>
 		<file>smoketest/general/smoketest_email.script</file>
+		<file>smoketest/general/smoketest_lbs.ini</file>
+		<file>smoketest/general/smoketest_lbs.script</file>
 
 		<file>smoketest/general/smoketest_bitmap.ini</file>
 		<file>smoketest/general/smoketest_bitmap.script</file>
@@ -1238,6 +1195,7 @@
 		<file>smoketest/winscw_udeb/t_msgutilityserver.dll</file>
 		<file>smoketest/winscw_udeb/t_msgpopserver.exe</file>
 		<file>smoketest/winscw_udeb/t_msgsmtpserver.exe</file>
+		<file>smoketest/winscw_udeb/te_lbsapisuite.exe</file>
 
 		<file>smoketest/winscw_udeb/t_animplugin.dll</file>
 		<file>smoketest/winscw_udeb/t_graphicswservapi.exe</file>
diff -r 7f293ed715ec -r a4835904093b LbsApi/group/Smoketest_lbs.iby
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/group/Smoketest_lbs.iby	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,28 @@
+/*
+* Copyright (c) 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:
+*
+*/
+
+#ifndef SMOKETEST_LBS_IBY
+#define SMOKETEST_LBS_IBY
+
+#include <testexecute.iby>
+
+file=ABI_DIR\DEBUG_DIR\te_lbsapisuite.exe		sys\bin\te_lbsapisuite.exe
+data=EPOCROOT##epoc32\data\z\smoketest\smoketest_lbs.ini	smoketest\smoketest_lbs.ini
+data=EPOCROOT##epoc32\data\z\smoketest\setup_smoketest_lbs.script	smoketest\setup_smoketest_lbs.script
+data=EPOCROOT##epoc32\data\z\smoketest\smoketest_lbs.script	smoketest\smoketest_lbs.script
+
+#endif //SMOKETEST_LBS_IBY
diff -r 7f293ed715ec -r a4835904093b LbsApi/group/bld.inf
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/group/bld.inf	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,28 @@
+// Copyright (c) 2002-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:
+//
+
+PRJ_EXPORTS
+
+PRJ_TESTEXPORTS
+../scripts/smoketest_lbs.script			z:/smoketest/smoketest_lbs.script
+../scripts/setup_smoketest_lbs.script	z:/smoketest/setup_smoketest_lbs.script
+../testdata/smoketest_lbs.ini			z:/smoketest/smoketest_lbs.ini
+
+./Smoketest_lbs.iby						/epoc32/rom/include/Smoketest_lbs.iby
+
+PRJ_MMPFILES
+
+PRJ_TESTMMPFILES
+te_lbsapisuite.mmp
diff -r 7f293ed715ec -r a4835904093b LbsApi/group/te_lbsapisuite.mmp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/group/te_lbsapisuite.mmp	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,47 @@
+// Copyright (c) 2002-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:
+//
+
+TARGET      te_lbsapisuite.exe
+TARGETTYPE  exe
+UID         0x1000007A 0x1028375B
+
+CAPABILITY Location
+
+
+//Please add any change under here
+SOURCEPATH  ../src
+SOURCE te_lbsapisuiteserver.cpp
+SOURCE te_lbsapisuitestepbase.cpp
+SOURCE calculationmethodsstep.cpp
+SOURCE criteriaclassesstep.cpp
+SOURCE dataclassesstep.cpp
+SOURCE genericinfostep.cpp
+SOURCE moduleclassesstep.cpp
+SOURCE nomemorystep.cpp
+SOURCE noserverstep.cpp
+SOURCE requestorclassesstep.cpp
+SOURCE reminderstep.cpp
+
+USERINCLUDE   ../inc
+
+OS_LAYER_SYSTEMINCLUDE_SYMBIAN
+
+LIBRARY		testexecuteutils.lib 
+LIBRARY		testexecutelogclient.lib 
+
+LIBRARY         euser.lib efsrv.lib estor.lib bafl.lib charconv.lib
+LIBRARY         lbs.lib             // Location Client Library
+
+SMPSAFE
diff -r 7f293ed715ec -r a4835904093b LbsApi/inc/calculationmethodsstep.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/inc/calculationmethodsstep.h	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,47 @@
+/**
+* Copyright (c) 2002-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:
+*
+*/
+
+
+
+/**
+ @file CalculationMethodsStep.h
+ @internalTechnology
+*/
+#if (!defined __CALCULATIONMETHODS_STEP_H__)
+#define __CALCULATIONMETHODS_STEP_H__
+#include <test/TestExecuteStepBase.h>
+#include "te_lbsapisuitestepbase.h"
+
+class CCalculationMethodsStep : public CTe_LbsApiSuiteStepBase
+	{
+public:
+	CCalculationMethodsStep();
+	~CCalculationMethodsStep();
+	virtual TVerdict doTestStepPreambleL();
+	virtual TVerdict doTestStepL();
+	virtual TVerdict doTestStepPostambleL();
+
+private:
+	void StartL(TInt aIndex);
+	void Calculation_InvalidL();
+	void Calculation_BasicsL();
+	void Calculation_TCoordinate_MoveBigL();
+	};
+
+_LIT(KCalculationMethodsStep,"CalculationMethodsStep");
+
+#endif
diff -r 7f293ed715ec -r a4835904093b LbsApi/inc/criteriaclassesstep.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/inc/criteriaclassesstep.h	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,52 @@
+/**
+* Copyright (c) 2002-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:
+*
+*/
+
+
+
+/**
+ @file CriteriaClassesStep.h
+ @internalTechnology
+*/
+#if (!defined __CRITERIACLASSES_STEP_H__)
+#define __CRITERIACLASSES_STEP_H__
+#include <test/TestExecuteStepBase.h>
+#include "te_lbsapisuitestepbase.h"
+
+class CCriteriaClassesStep : public CTe_LbsApiSuiteStepBase
+	{
+public:
+	CCriteriaClassesStep();
+	~CCriteriaClassesStep();
+	virtual TVerdict doTestStepPreambleL();
+	virtual TVerdict doTestStepL();
+	virtual TVerdict doTestStepPostambleL();
+
+private:
+	void StartL(TInt aIndex);
+	
+	void TPositionSelectionOrder_ConstructionL();
+	void TPositionSelectionOrder_SetL();
+	void TPositionSelectionOrder_ClearL();
+	void TPositionSelectionOrder_NumSelectionItemsL();
+	void TPositionCriteria_ConstructionL();
+	void TPositionCriteria_SetL();
+	void TPositionCriteria_ResetAndClearL();
+	};
+
+_LIT(KCriteriaClassesStep,"CriteriaClassesStep");
+
+#endif
diff -r 7f293ed715ec -r a4835904093b LbsApi/inc/dataclassesstep.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/inc/dataclassesstep.h	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,70 @@
+/**
+* Copyright (c) 2002-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:
+*
+*/
+
+
+
+/**
+ @file DataClassesStep.h
+ @internalTechnology
+*/
+#if (!defined __DATACLASSES_STEP_H__)
+#define __DATACLASSES_STEP_H__
+#include <test/TestExecuteStepBase.h>
+#include "te_lbsapisuitestepbase.h"
+
+class CDataClassesStep : public CTe_LbsApiSuiteStepBase
+	{
+public:
+	CDataClassesStep();
+	~CDataClassesStep();
+	virtual TVerdict doTestStepPreambleL();
+	virtual TVerdict doTestStepL();
+	virtual TVerdict doTestStepPostambleL();
+private:
+
+	void StartL(TInt aIndex);
+// Data Classes
+	void TCoordinate_BlankConstructionL();
+	void TCoordinate_ConstructorsL();
+	void TCoordinate_Constructors2L();
+	void TCoordinate_InvalidL();
+	void TCoordinate_NormalizationWithNansL();
+	void TLocality_BlankConstructionL();
+	void TLocality_ConstructorsL();
+	void TLocality_Constructors2L();
+	void TLocality_NegativeL();
+	void TPosition_ConstructionL();
+	void TPosition_SettersL();
+	void TPositionInfo_ConstructionL();
+	void TPositionInfo_ModificationL();
+	void CourseClasses_ConstructionL();
+	void CourseClasses_Modification2L();
+	void CourseClasses_ModificationL();
+	void CourseClasses_InvalidL();
+	void SatelliteClasses_ConstructionL();
+	void SatelliteClasses_PropertiesL();
+	void SatelliteClasses_Properties2L();
+	void SatelliteClasses_InfoL();
+	void SatelliteClasses_SatelliteInfoL();
+	void SatelliteClasses_OverflowL();
+	void GpsMeasurementClasses_PropertiesL();
+
+	};
+
+_LIT(KDataClassesStep,"DataClassesStep");
+
+#endif
diff -r 7f293ed715ec -r a4835904093b LbsApi/inc/genericinfostep.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/inc/genericinfostep.h	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,57 @@
+/**
+* Copyright (c) 2002-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:
+*
+*/
+
+
+
+/**
+ @file GenericInfoStep.h
+ @internalTechnology
+*/
+#if (!defined __GENERICINFO_STEP_H__)
+#define __GENERICINFO_STEP_H__
+#include <test/TestExecuteStepBase.h>
+#include "te_lbsapisuitestepbase.h"
+
+class CGenericInfoStep : public CTe_LbsApiSuiteStepBase
+	{
+public:
+	CGenericInfoStep();
+	~CGenericInfoStep();
+	virtual TVerdict doTestStepPreambleL();
+	virtual TVerdict doTestStepL();
+	virtual TVerdict doTestStepPostambleL();
+
+private:
+	void StartL (TInt aIndex);
+	// Generic Info
+	void HPositionGenericInfo_ConstructionL();
+	void HPositionGenericInfo_Construction2L();
+	void HPositionGenericInfo_RequestingL();
+	void HPositionGenericInfo_Requesting2L();
+	void HPositionGenericInfo_GetL();
+	void HPositionGenericInfo_GoodL();
+	void HPositionGenericInfo_MismatchedL();
+	void HPositionGenericInfo_HBufCL();
+	void HPositionGenericInfo_BufferL();
+	void HPositionGenericInfo_FieldsL();
+	void HPositionGenericInfo_OverflowL();
+	void HPositionGenericInfo_SetL();
+	};
+
+_LIT(KGenericInfoStep,"GenericInfoStep");
+
+#endif
diff -r 7f293ed715ec -r a4835904093b LbsApi/inc/lcfsbucommondefinitions.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/inc/lcfsbucommondefinitions.h	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,184 @@
+/**
+* Copyright (c) 2008-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:
+*
+*/
+
+
+
+/**
+ @file lcfsbucommondefinitions.h
+ @internalTechnology
+*/
+#ifndef _LCF_SBU_COMMON_DEFINITIONS_H_
+#define _LCF_SBU_COMMON_DEFINITIONS_H_
+
+
+///////////////////////////////////////////////////////
+//
+// Constants
+//
+///////////////////////////////////////////////////////
+
+
+#define DUMMY_REQUESTOR_TYPE_ACCEPTED1        (CRequestor::ERequestorService)
+#define DUMMY_REQUESTOR_FORMAT_ACCEPTED1      (CRequestor::EFormatApplication)
+#define DUMMY_REQUESTOR_NAME_ACCEPTED1        (_L("TestService"))
+
+#define DUMMY_REQUESTOR_TYPE_ACCEPTED2        (CRequestor::ERequestorContact)
+#define DUMMY_REQUESTOR_FORMAT_ACCEPTED2      (CRequestor::EFormatTelephone)
+#define DUMMY_REQUESTOR_NAME_ACCEPTED2        (_L("+123121234567"))
+
+
+
+const TInt KDefaultTestTimeout = 5*1000*1000;        //5 seconds should be more than enough.
+
+//0.00001;
+#define KErrorToleranceValue KMinTReal64    
+
+_LIT(KNoClientFault, "Kill");
+
+
+///////////////////////////////////////////////////////
+//
+// Other text
+//
+///////////////////////////////////////////////////////
+
+// Indicate not yet implemented
+_LIT(KNotImplemented, "Not yet implemented");
+
+_LIT(KBadDiagVerifEventNum, "Wrong number of Verification events in Notifier");
+_LIT(KBadDiagNotifEventNum, "Wrong number of Notification events in Notifier");
+
+#define CHECK_EQUAL_(_expected, _actual) \
+    ERROR(_expected != _actual, "Equal check failed")
+
+#define CHECK(_condition) ERROR(!(_condition), "Check failed")
+
+
+#define CHECK_REAL_EQUAL_TOL(aExpected, aActual, aTolerance) \
+    FAIL(Math::IsNaN(aActual) || Math::IsNaN(aExpected), "One or two of compared values is NaN!") \
+    CHECK(Abs(aActual - aExpected) < aTolerance)
+
+#define CHECK_REAL_EQUAL(aExpected, aActual) \
+    CHECK_REAL_EQUAL_TOL(aExpected, aActual, KErrorToleranceValue)
+
+#define CHECK_PANIC(aCondition) \
+    if (!(aCondition)) CheckPanic(__FILE__, __LINE__);
+
+#define DO_PANIC_TEST_L(aThreadFunction, aExpectedExitCat, aExpectedExitReason, aTimeoutValue) \
+    DO_PANIC_TEST_L_PTR(aThreadFunction, aExpectedExitCat, aExpectedExitReason, aTimeoutValue, NULL)
+
+#define DO_PANIC_TEST_L_PTR(aThreadFunction, aExpectedExitCat, aExpectedExitReason, \
+    aTimeoutValue, aAnyPtr) \
+    { \
+    TExitCategoryName exitName = TPtrC(aExpectedExitCat).Left(KMaxExitCategoryName); \
+    DoPanicTestL(aThreadFunction, exitName, aExpectedExitReason, aTimeoutValue, aAnyPtr); \
+    }
+
+///////////////////////////////////////////////////////
+//
+// Here are macros for error logging 
+// Those imply that are called from within of 
+// TEF class's function (they use (INFO/ERR)PRINTF member)
+//
+///////////////////////////////////////////////////////
+
+// LEAVES with _error_ if _condition_ is true
+#define FAIL(condition, error)             \
+    if (condition) {                        \
+        errStr.Format(_L("%s (line %d)"), _S(error), __LINE__);    \
+        ERR_PRINTF1(errStr);				\
+		SetTestStepResult(EFail);           \
+    }
+
+
+// Must be included in the begining of function definitions
+// in order to use following ("ERROR") macros
+// (The string buffer needs to be defined once, otherwise,
+// in case when a lot of errors are checked, stack may be
+// overflown, and copilation will fail)
+#define DECLARE_ERROR_STR                   TBuf<160> errStr;
+#define DECLARE_MESSAGE_STR                 TBuf<160> message;
+
+#define DECLARE_ERROR_LOGGING               DECLARE_ERROR_STR   DECLARE_MESSAGE_STR
+
+#define START_ERROR_LOGGING                 iErrorCounter = 0;
+
+// Logs a message, which is defined as "..." constant
+#define LOG(msg)                            \
+    {                                       \
+        errStr.Format(_L("%s (line %d)"), _S(msg), __LINE__);    \
+        INFO_PRINTF1(errStr);                  \
+    }
+#define LOG_DES(msg_des)                    \
+    {                                       \
+        errStr.Format(_L("%S (line %d)"), &msg_des, __LINE__);    \
+        INFO_PRINTF1(errStr);                  \
+    }
+
+#define LOG_IIF(condition, msg1, msg2)      \
+    if (condition) LOG(msg1) else LOG(msg2)
+
+// Logs an error, which is defined as "..." constant
+#define ERR(error)                          \
+    {                                       \
+        errStr.Format(_L("%s (line %d)"), _S(error), __LINE__);    \
+        ERR_PRINTF1(errStr);             \
+        SetTestStepResult(EFail);			\
+    }
+#define ERR_DES(error)                      \
+    {                                       \
+        errStr.Format(_L("%S (line %d)"), &error, __LINE__);    \
+        ERR_PRINTF1(errStr);             \
+        SetTestStepResult(EFail);			\
+    }
+
+// Logs an _error_ if _condition_ is true
+#define ERROR(condition, error)             \
+    if (condition) ERR(error)
+
+// Logs an error, which defined as descriptor
+#define ERROR_DES(condition, error_des)     \
+    if (condition) ERR_DES(error_des)
+
+#define ERROR_1(condition, msg_fmt_des, param1)  \
+    message.Format(msg_fmt_des, param1);        \
+    ERROR_DES(condition, message);
+
+#define ERROR_2(condition, msg_fmt_des, param1, param2)  \
+    message.Format(msg_fmt_des, param1, param2);        \
+    ERROR_DES(condition, message);
+
+#define ERROR_3(condition, msg_fmt_des, param1, param2, param3) \
+    message.Format(msg_fmt_des, param1, param2, param3);        \
+    ERROR_DES(condition, message);
+
+#define IF_ERROR(error_code, msg)                               \
+    { TInt32 _err = error_code;                                 \
+    ERROR_2(_err != KErrNone, _L("%s (error=%d)"), _S(msg), _err); }
+
+#define IF_ERROR_DES(error_code, msg_des)                       \
+    { TInt32 _err = error_code;                                 \
+    ERROR_2(_err != KErrNone, _L("%S (error=%d)"), &msg_des, _err); }
+
+#define CHECK_EQUAL(_actual, _expected, _msg)                     \
+    ERROR_3(_actual != _expected, _L("%s (actual=%d, expected=%d)"), _S(_msg), _actual, _expected);
+
+#define CHECK_EQUAL_DES(_actual, _expected, _msg_des)           \
+    ERROR_3(_actual != _expected, _L("%S (actual=%d, expected=%d)"), &_msg_des, _actual, _expected);
+
+
+#endif // _LCF_SBU_COMMON_DEFINITIONS_H_
diff -r 7f293ed715ec -r a4835904093b LbsApi/inc/moduleclassesstep.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/inc/moduleclassesstep.h	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,55 @@
+/**
+* Copyright (c) 2002-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:
+*
+*/
+
+
+
+/**
+ @file ModuleClassesStep.h
+ @internalTechnology
+*/
+#if (!defined __MODULECLASSES_STEP_H__)
+#define __MODULECLASSES_STEP_H__
+#include <test/TestExecuteStepBase.h>
+#include "te_lbsapisuitestepbase.h"
+
+class CModuleClassesStep : public CTe_LbsApiSuiteStepBase
+	{
+public:
+	CModuleClassesStep();
+	~CModuleClassesStep();
+	virtual TVerdict doTestStepPreambleL();
+	virtual TVerdict doTestStepL();
+	virtual TVerdict doTestStepPostambleL();
+
+private:
+	void StartL(TInt aIndex);
+	// Module Classes
+	void TPositionModuleInfo_ConstructionL();
+	void TPositionModuleInfo_GettersL();
+	void TPositionModuleInfo_InvalidL();
+	void TPositionQuality_ConstructionL();
+	void TPositionQuality_SettersL();
+	void TPositionQuality_InvalidL();
+	void TPositionQuality_ComparisonL();
+	void ModuleClasses_ConstructionL();
+	void ModuleClasses_SettersL();
+	void TPositionUpdateOptions_InvalidL();
+	};
+
+_LIT(KModuleClassesStep,"ModuleClassesStep");
+
+#endif
diff -r 7f293ed715ec -r a4835904093b LbsApi/inc/nomemorystep.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/inc/nomemorystep.h	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,51 @@
+/**
+* Copyright (c) 2002-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:
+*
+*/
+
+
+
+/**
+ @file NoMemoryStep.h
+ @internalTechnology
+*/
+#if (!defined __NOMEMORY_STEP_H__)
+#define __NOMEMORY_STEP_H__
+#include <test/TestExecuteStepBase.h>
+#include "te_lbsapisuitestepbase.h"
+
+class CNoMemoryStep : public CTe_LbsApiSuiteStepBase
+	{
+public:
+	CNoMemoryStep();
+	~CNoMemoryStep();
+	virtual TVerdict doTestStepPreambleL();
+	virtual TVerdict doTestStepL();
+	virtual TVerdict doTestStepPostambleL();
+private:
+	void StartL(TInt aIndex);
+	void OOM_RPositionServer_Open_NoMemoryL();
+	void OOM_RPositioner_OpenL();
+	void OOM_RPositioner_SetRequestorL();
+	void OOM_CRequestor_ConstructionL();
+	void OOM_CRequestor_SetRequestorL();
+	void OOM_CRequestor_StreamingL();
+	void OOM_RRequestorStack_StreamingL();
+	void OOM_HPositionGenericInfo_ConstructionL();
+	};
+
+_LIT(KNoMemoryStep,"NoMemoryStep");
+
+#endif
diff -r 7f293ed715ec -r a4835904093b LbsApi/inc/noserverstep.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/inc/noserverstep.h	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,48 @@
+/**
+* Copyright (c) 2002-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:
+*
+*/
+
+
+
+/**
+ @file NoServerStep.h
+ @internalTechnology
+*/
+#if (!defined __NOSERVER_STEP_H__)
+#define __NOSERVER_STEP_H__
+#include <test/TestExecuteStepBase.h>
+#include "te_lbsapisuitestepbase.h"
+
+class CNoServerStep : public CTe_LbsApiSuiteStepBase
+	{
+public:
+	CNoServerStep();
+	~CNoServerStep();
+	virtual TVerdict doTestStepPreambleL();
+	virtual TVerdict doTestStepL();
+	virtual TVerdict doTestStepPostambleL();
+private:
+	void StartL(TInt aIndex);
+	void CheckThereIsNoServerL();
+	// No Server
+	void RPositionServer_NoConnectionL();
+	void RPositionServer_NoL();
+	void RPositioner_NoL();
+	};
+
+_LIT(KNoServerStep,"NoServerStep");
+
+#endif
diff -r 7f293ed715ec -r a4835904093b LbsApi/inc/reminderstep.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/inc/reminderstep.h	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,41 @@
+/**
+* Copyright (c) 2002-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:
+*
+*/
+
+
+
+/**
+ @file reminderstep.h
+ @internalTechnology
+*/
+#if (!defined __REMINDER_STEP_H__)
+#define __REMINDER_STEP_H__
+#include <test/TestExecuteStepBase.h>
+#include "te_lbsapisuitestepbase.h"
+
+class CReminderStep : public CTe_LbsApiSuiteStepBase
+	{
+public:
+	CReminderStep();
+	~CReminderStep();
+	virtual TVerdict doTestStepPreambleL();
+	virtual TVerdict doTestStepL();
+	virtual TVerdict doTestStepPostambleL();
+	};
+
+_LIT(KReminderStep,"NoMemoryStep");
+
+#endif
diff -r 7f293ed715ec -r a4835904093b LbsApi/inc/requestorclassesstep.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/inc/requestorclassesstep.h	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,51 @@
+/**
+* Copyright (c) 2002-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:
+*
+*/
+
+
+
+/**
+ @file RequestorClassesStep.h
+ @internalTechnology
+*/
+#if (!defined __REQUESTORCLASSES_STEP_H__)
+#define __REQUESTORCLASSES_STEP_H__
+#include <test/TestExecuteStepBase.h>
+#include "te_lbsapisuitestepbase.h"
+
+class CRequestorClassesStep : public CTe_LbsApiSuiteStepBase
+	{
+public:
+	CRequestorClassesStep();
+	~CRequestorClassesStep();
+	virtual TVerdict doTestStepPreambleL();
+	virtual TVerdict doTestStepL();
+	virtual TVerdict doTestStepPostambleL();
+private:
+	void StartL (TInt aIndex);
+	// Requestor Classes
+	void RRequestorStack_StreamingL();
+	void RRequestorStack_Streaming2L();
+	void CRequestor_ConstructionL();
+	void CRequestor_SetL();
+	void CRequestor_Construction2L();
+	void CRequestor_StreamingL();
+	void CRequestor_Streaming2L();
+	};
+
+_LIT(KRequestorClassesStep,"RequestorClassesStep");
+
+#endif
diff -r 7f293ed715ec -r a4835904093b LbsApi/inc/te_lbsapisuitedefs.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/inc/te_lbsapisuitedefs.h	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,37 @@
+/**
+* Copyright (c) 2004-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:
+* This file define all the common values thoughout your test project
+* 
+*
+*/
+
+
+
+/**
+ @file Te_LbsApiSuiteDefs.h
+ @internalTechnology
+*/
+#if (!defined __TE_LBSAPI_SUITEDEFS_H__)
+#define __TE_LBSAPI_SUITEDEFS_H__
+
+// Please modify below value with your project and must match with your configuration ini file which is required to be modified as well
+_LIT(KTe_LbsApiSuiteInt,"Test");
+
+// For test step panics
+_LIT(KTe_LbsApiSuitePanic,"Te_LbsApiSuite");
+
+_LIT(KReminderCaption,"The OOM test should be run on winscw udeb only");
+
+#endif
diff -r 7f293ed715ec -r a4835904093b LbsApi/inc/te_lbsapisuiteserver.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/inc/te_lbsapisuiteserver.h	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,38 @@
+/**
+* Copyright (c) 2004-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:
+*
+*/
+
+
+
+/**
+ @file Te_LbsApiSuiteServer.h
+ @internalTechnology
+*/
+
+#if (!defined __TE_LBSAPI_SERVER_H__)
+#define __TE_LBSAPI_SERVER_H__
+#include "test/testexecuteserverbase.h"
+
+
+class CTe_LbsApiSuite : public CTestServer
+	{
+public:
+	static CTe_LbsApiSuite* NewL();
+	// Base class pure virtual override
+	virtual CTestStep* CreateTestStep(const TDesC& aStepName);
+	};
+
+#endif
diff -r 7f293ed715ec -r a4835904093b LbsApi/inc/te_lbsapisuitestepbase.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/inc/te_lbsapisuitestepbase.h	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,70 @@
+/**
+* Copyright (c) 2004-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:
+*
+*/
+
+
+
+/**
+ @file Te_LbsApiSuiteStepBase.h
+ @internalTechnology
+*/
+
+#if (!defined __TE_LBSAPI_STEP_BASE__)
+#define __TE_LBSAPI_STEP_BASE__
+#include <test/TestExecuteStepBase.h>
+// Please add your include here if you have 
+
+struct SPanicThreadFunctionData
+{
+    TThreadFunction     iPanicFunction;     // thread function that will panic
+    TAny*               iPtr;               // data to pass to the function
+};
+
+/****************************************************************************
+* The reason to have a new step base is that it is very much possible
+* that the all individual test steps have project related common variables 
+* and members 
+* and this is the place to define these common variable and members.
+* 
+****************************************************************************/
+class CTe_LbsApiSuiteStepBase : public CTestStep
+	{
+public:
+	virtual ~CTe_LbsApiSuiteStepBase();
+	CTe_LbsApiSuiteStepBase();
+	virtual TVerdict doTestStepPreambleL(); 
+	virtual TVerdict doTestStepPostambleL();
+
+protected:
+// Tool functions
+
+    void StandardPrepareL();
+    void StandardCleanup();
+
+    TInt DoPanicTestL(TThreadFunction aThreadFunction, TExitCategoryName aExpectedExitCat,
+                      TInt aExpectedExitReason, TTimeIntervalMicroSeconds32 aTimeoutValue,
+                      TAny* aPtr);
+
+    void CheckThereIsNoServerL();
+	
+//Please add your class members which will be common to all individual test steps:
+protected:
+	TInt 		iErrorCounter;
+	HBufC8*		iReadData;
+	HBufC8*		iWriteData;
+	};
+
+#endif
diff -r 7f293ed715ec -r a4835904093b LbsApi/scripts/setup_smoketest_lbs.script
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/scripts/setup_smoketest_lbs.script	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,22 @@
+//
+// Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "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:
+//
+
+RUN_UTILS MkDir			c:\smoketest\
+
+RUN_UTILS CopyFile 		z:\smoketest\smoketest_lbs.ini	c:\smoketest\smoketest_lbs.ini
+RUN_UTILS MakeReadWrite	c:\smoketest\smoketest_lbs.ini
+RUN_UTILS CopyFile 		z:\smoketest\smoketest_lbs.script	c:\smoketest\smoketest_lbs.script
+RUN_UTILS MakeReadWrite	c:\smoketest\smoketest_lbs.script
diff -r 7f293ed715ec -r a4835904093b LbsApi/scripts/smoketest_lbs.script
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/scripts/smoketest_lbs.script	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,29 @@
+//
+// Copyright (c) 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:
+//
+//!@File
+//!@SYMTestSuiteName         LBS-API-0001
+//!@SYMScriptTestEnvironment TestExecute with LBS-API-0001
+//
+
+PRINT Run LBS smoketest
+
+LOAD_SUITE te_LbsApiSuite
+
+START_TESTCASE			SMOKE_LBS_0001
+//!	@SYMTestCaseID		SMOKE_LBS_0001
+//!	@SYMTestCaseDesc	Set and get the status of the positioning device.
+RUN_TEST_STEP 100 te_LbsApiSuite ModuleClassesStep c:\smoketest\smoketest_lbs.ini LBS-ModuleClassesSetters-0001
+END_TESTCASE SMOKE_LBS_0001
diff -r 7f293ed715ec -r a4835904093b LbsApi/src/calculationmethodsstep.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/src/calculationmethodsstep.cpp	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,480 @@
+// 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 CalculationMethodsStep.cpp
+ @internalTechnology
+*/
+#include "calculationmethodsstep.h"
+#include "te_lbsapisuitedefs.h"
+
+#include "lcfsbucommondefinitions.h"
+
+#include <lbs.h>
+#include <lbssatellite.h>
+
+CCalculationMethodsStep::~CCalculationMethodsStep()
+/**
+ * Destructor
+ */
+	{
+	}
+
+CCalculationMethodsStep::CCalculationMethodsStep()
+/**
+ * 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(KCalculationMethodsStep);
+	}
+
+TVerdict CCalculationMethodsStep::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 CCalculationMethodsStep::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 CCalculationMethodsStep::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_LbsApiVariant2SuiteStepBase::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 CCalculationMethodsStep::StartL(TInt aIndex)
+	{
+	switch(aIndex)
+		{
+		case 0:
+			Calculation_InvalidL();
+			break;
+		case 1:
+			Calculation_BasicsL();
+			break;
+		case 2:
+			Calculation_TCoordinate_MoveBigL();
+			break;
+		}
+	}
+
+
+#define REPORT_REAL(_real) \
+    report.Format(_L("%15.9f"), _real); \
+    LOG_DES(report);
+
+#define REPORT_REAL_16(_real) \
+    report.Format(_L("%22.16f"), _real); \
+    LOG_DES(report);
+
+#define REPORT_REAL_G(_real) \
+    report.Format(_L("%10g"), _real); \
+    LOG_DES(report);
+
+#define REPORT_CRLF \
+    report.Format(_L("\n")); \
+    LOG_DES(report);
+
+#define REPORT_TAB \
+    report.Format(_L("\t")); \
+    LOG_DES(report);
+
+//
+//
+// TCoordinate
+//
+//
+
+void CCalculationMethodsStep::Calculation_BasicsL()
+    {
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    TRealX nan;
+    nan.SetNaN();
+
+    const TReal tlat = 10, tlon = 20, acc1 = 5, acc2 = 15;
+    TReal32 distance, bearing, delta, speed;
+
+    TCoordinate sCoord, tCoord, zero(0,0), target(tlat, tlon);
+    TLocality sLoc, tLoc;
+    TPosition sPos, tPos;
+
+    //
+    // 1. TCoordinate
+    
+    sCoord.SetCoordinate(0, 0);
+    tCoord.SetCoordinate(tlat, tlon);
+    
+    CHECK(sCoord.Distance(tCoord, distance) == KErrNone);
+    CHECK(sCoord.Distance(sCoord, distance) == KErrNone);
+    CHECK(sCoord.BearingTo(tCoord, bearing) == KErrNone);
+    CHECK(sCoord.Move(distance, bearing) == KErrNone);
+    CHECK(sCoord.Move(distance, bearing) == KErrNone);
+
+    //
+    // 2. TLocality
+    
+    sLoc = TLocality(zero, acc1);
+    tLoc = TLocality(target, acc2);
+
+    CHECK(sLoc.Distance(tCoord, distance) == KErrNone);
+    CHECK(sLoc.Distance(sCoord, distance) == KErrNone);
+    CHECK(sLoc.Distance(tLoc, distance, delta) == KErrNone);
+    CHECK(sLoc.Distance(sLoc, distance, delta) == KErrNone);
+    CHECK(sLoc.BearingTo(tCoord, bearing) == KErrNone);
+    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrNone);
+
+    //
+    // 2. TPosition
+
+    TTime time1, time2;
+    time1.UniversalTime();
+    time2 = time1 + TTimeIntervalMinutes(60);
+
+    sPos = TPosition(sLoc, time1);
+    tPos = TPosition(tLoc, time2);
+
+    CHECK(sPos.Speed(tPos, speed) == KErrNone);
+    CHECK(sPos.Speed(TPosition(sLoc, time2), speed) == KErrNone);
+    CHECK(sPos.Speed(tPos, speed, delta) == KErrNone);
+    CHECK(sPos.Speed(TPosition(sLoc, time2), speed, delta) == KErrNone);
+
+    StandardCleanup();
+    }
+    
+void CCalculationMethodsStep::Calculation_InvalidL()
+    {
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    TRealX nan;
+    nan.SetNaN();
+    
+    const TReal lat = 10, lon = 20, acc = 5;
+    const TReal32 dist = 1000, bear = 60;
+    
+    const TCoordinate zeroCoord(0, 0), north(90, 0), south(-90, 0);
+    
+    enum ENanParam
+        {
+        LAT, LON, ACC,
+        };
+
+    const TCoordinate nanCoord[] = 
+        {
+        TCoordinate(nan, lon),
+        TCoordinate(lat, nan)
+        };
+
+    const TLocality nanLoc[] = 
+        {
+        TLocality(nanCoord[LAT], acc),
+        TLocality(nanCoord[LON], acc),
+        TLocality(zeroCoord, nan)
+        };
+
+    //
+    // 1. TCoordinate
+    
+    TCoordinate sCoord, tCoord;
+    TReal32 distance, bearing;
+
+    // NaN in Distance, BearingTo, Move
+
+    tCoord = zeroCoord;
+
+    sCoord = nanCoord[LAT];
+    CHECK(sCoord.Distance(tCoord, distance) == KErrArgument);
+    CHECK(sCoord.BearingTo(tCoord, bearing) == KErrArgument);
+    CHECK(sCoord.Move(dist, bear) == KErrArgument);
+
+    sCoord = nanCoord[LON];
+    CHECK(sCoord.Distance(tCoord, distance) == KErrArgument);
+    CHECK(sCoord.BearingTo(tCoord, bearing) == KErrArgument);
+    CHECK(sCoord.Move(dist, bear) == KErrArgument);
+
+    sCoord = zeroCoord;
+
+    tCoord = nanCoord[LAT];
+    CHECK(sCoord.Distance(tCoord, distance) == KErrArgument);
+    CHECK(sCoord.BearingTo(tCoord, bearing) == KErrArgument);
+
+    tCoord = nanCoord[LON];
+    CHECK(sCoord.Distance(tCoord, distance) == KErrArgument);
+    CHECK(sCoord.BearingTo(tCoord, bearing) == KErrArgument);
+    
+    // Incalculable cases
+    
+    // poles
+    tCoord = zeroCoord;
+
+    sCoord = north;
+    CHECK(sCoord.BearingTo(tCoord, bearing) == KErrPositionIncalculable);
+    CHECK(sCoord.Move(dist, bear) == KErrPositionIncalculable);
+
+    sCoord = south;
+    CHECK(sCoord.BearingTo(tCoord, bearing) == KErrPositionIncalculable);
+    CHECK(sCoord.Move(dist, bear) == KErrPositionIncalculable);
+    
+    // same coords
+    sCoord = tCoord = zeroCoord;
+    CHECK(sCoord.BearingTo(tCoord, bearing) == KErrPositionIncalculable);
+    
+    // antipodal
+    tCoord.SetCoordinate(-zeroCoord.Latitude(), zeroCoord.Longitude() + 180);
+    CHECK(sCoord.BearingTo(tCoord, bearing) == KErrPositionIncalculable);
+
+    //
+    // 2. TLocality
+    
+    TLocality sLoc, tLoc;
+    TReal32 delta;
+
+    // NaN in Distance and BearingTo
+
+    tLoc = TLocality(zeroCoord, acc);
+
+    sLoc = nanLoc[LAT];
+    CHECK(sLoc.Distance(tLoc, distance, delta) == KErrArgument);
+    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrArgument);
+
+    sLoc = nanLoc[LON];
+    CHECK(sLoc.Distance(tLoc, distance, delta) == KErrArgument);
+    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrArgument);
+
+    sLoc = nanLoc[ACC];
+    CHECK(sLoc.Distance(tLoc, distance, delta) == KErrArgument);
+    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrArgument);
+
+    sLoc = TLocality(zeroCoord, acc);
+
+    tLoc = nanLoc[LAT];
+    CHECK(sLoc.Distance(tLoc, distance, delta) == KErrArgument);
+    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrArgument);
+
+    tLoc = nanLoc[LON];
+    CHECK(sLoc.Distance(tLoc, distance, delta) == KErrArgument);
+    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrArgument);
+    
+    tLoc = nanLoc[ACC];
+    CHECK(sLoc.Distance(tLoc, distance, delta) == KErrArgument);
+    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrArgument);
+    
+    // Incalculable cases
+    
+    // 1 latitude degree is about 117 km
+    const TReal32 circle = 200 * 1000;
+    
+    // pole in error circle
+    sLoc = TLocality(TCoordinate(89, 0), circle); 
+    tLoc = TLocality(zeroCoord, 0);
+    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrPositionIncalculable);
+    
+    // overlapping error circles
+    sLoc = TLocality(TCoordinate(1, 0), circle);
+    tLoc = TLocality(TCoordinate(-1, 0), circle);
+    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrPositionIncalculable);
+
+    // overlapping error circles if target is antipodal
+    sLoc = TLocality(TCoordinate(1, 0), circle);
+    tLoc = TLocality(TCoordinate(1, 180), circle); // antipodal is (-1, 0)
+    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrPositionIncalculable);
+
+    //
+    // 3. TPosition
+    
+    TPosition sPos, tPos;
+    TReal32 speed;
+    
+    // Nan in Speed methods
+    TTime time1, time2;
+    time1.UniversalTime();
+    time2 = time1 + TTimeIntervalMinutes(60);
+    
+    tPos = TPosition(TLocality(zeroCoord, acc), time2);
+
+    sPos = TPosition(nanLoc[LAT], time1);
+    CHECK(sPos.Speed(tPos, speed) == KErrArgument);
+    CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument);
+
+    sPos = TPosition(nanLoc[LON], time1);
+    CHECK(sPos.Speed(tPos, speed) == KErrArgument);
+    CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument);
+
+    sPos = TPosition(nanLoc[ACC], time1);
+    CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument);
+    
+    sPos = TPosition(TLocality(zeroCoord, acc), time1);
+
+    tPos = TPosition(nanLoc[LAT], time2);
+    CHECK(sPos.Speed(tPos, speed) == KErrArgument);
+    CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument);
+
+    tPos = TPosition(nanLoc[LON], time2);
+    CHECK(sPos.Speed(tPos, speed) == KErrArgument);
+    CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument);
+
+    tPos = TPosition(nanLoc[ACC], time2);
+    CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument);
+    
+    // Zero time
+
+    sPos = TPosition(TLocality(zeroCoord, acc), 0);
+    tPos = TPosition(TLocality(zeroCoord, acc), time2);
+    CHECK(sPos.Speed(tPos, speed) == KErrArgument);
+    CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument);
+
+    sPos = TPosition(TLocality(zeroCoord, acc), time1);
+    tPos = TPosition(TLocality(zeroCoord, acc), 0);
+    CHECK(sPos.Speed(tPos, speed) == KErrArgument);
+    CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument);
+    
+    // Same time
+
+    sPos = TPosition(TLocality(zeroCoord, acc), time1);
+    tPos = TPosition(TLocality(zeroCoord, acc), time1);
+    CHECK(sPos.Speed(tPos, speed) == KErrArgument);
+    CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument);
+
+    StandardCleanup();
+    }
+
+
+
+
+TReal32 NextReal32Value(TReal32 aReal32)
+	{
+    TInt32* pint32 = (TInt32*) &(aReal32);
+    (*pint32) = (*pint32) + 1; // works ok only if increment does not touch exponent!!!
+    return *((TReal32*) pint32);
+	}
+
+TReal32 PrevReal32Value(TReal32 aReal32)
+	{
+    TInt32* pint32 = (TInt32*) &(aReal32);
+    (*pint32) = (*pint32) - 1; // works ok only if decrement does not touch exponent!!!
+    return *((TReal32*) pint32);
+	}
+
+void CCalculationMethodsStep::Calculation_TCoordinate_MoveBigL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    TBuf<256> report;
+    const TReal32 KEarthRadius = 6371010;
+    const TReal32 KAccuracy = 0.1;
+
+    TInt bearing;
+    TReal32 alpha, arc = 2*KPi*KEarthRadius;
+    TCoordinate center(0,0), farPoint, closePoint, diff;
+
+    _LIT(KHeader, "=== TCoordinate::Move() test for big distances ===\n");
+    INFO_PRINTF1(KHeader);
+    
+    for (int lon = -180; lon < 180; lon += 60)
+    	{
+        center = TCoordinate(0, lon);
+
+        report.Format(_L("Center = (%f,%f), Arc(m) = %g(%g)\n"),
+                center.Latitude(), center.Longitude(), arc, NextReal32Value(arc));
+
+        for (bearing = 0; bearing < 360; bearing +=60)
+        	{
+            for (alpha = 0; alpha < 180; alpha += 30)
+            	{
+                farPoint = closePoint = center;
+
+                TReal32 smallDistance = alpha * KDegToRad * KEarthRadius;
+                closePoint.Move(bearing, smallDistance);
+
+                TReal bigDistance = ((2*KPi) - alpha*KDegToRad) * KEarthRadius;
+                farPoint.Move(bearing + 180, bigDistance);
+
+                diff = TCoordinate(closePoint.Latitude() - farPoint.Latitude(),
+                                   closePoint.Longitude() - farPoint.Longitude());
+
+                if ((Abs(diff.Latitude()) > KAccuracy) ||
+                    (Abs(diff.Longitude()) > KAccuracy))
+                	{
+                    report.Format(_L("Alpha %g\n"), alpha);
+                    LOG_DES(report);
+
+                    _LIT(KBearingDistance, "\tBearing %3d, Dist(m) %g: (%f;%f)\n");
+                    report.Format(KBearingDistance, bearing, smallDistance, closePoint.Latitude(), closePoint.Longitude());
+                    LOG_DES(report);
+
+                    report.Format(KBearingDistance, bearing + 180, bigDistance, farPoint.Latitude(), farPoint.Longitude());
+                    LOG_DES(report);
+
+                    report.Format(_L("\tDiff (%f;%f)\n"), diff.Latitude(), diff.Longitude());
+                    LOG_DES(report);
+                	}
+            	}
+        	}
+    	}
+
+    _LIT(KFooter, "=== TCoordinate::Move() test done ===\n");
+    INFO_PRINTF1(KFooter);
+    
+    StandardCleanup();
+	}
diff -r 7f293ed715ec -r a4835904093b LbsApi/src/criteriaclassesstep.cpp
--- /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;
+    }
diff -r 7f293ed715ec -r a4835904093b LbsApi/src/dataclassesstep.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/src/dataclassesstep.cpp	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,1361 @@
+// 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 DataClassesStep.cpp
+ @internalTechnology
+*/
+#include "dataclassesstep.h"
+#include "te_lbsapisuitedefs.h"
+
+#include "lcfsbucommondefinitions.h"
+
+#include <lbs.h>
+#include <lbs/lbsextendedsatellite.h>
+#include <lbs/lbsgpstimingmeasurement.h>
+#include <lbs/lbsgpsmeasurement.h>
+   
+// used to confirm that PositionXInfo class sizes do not change
+const TUint KPositionSatelliteInfoSize = 920;  
+const TUint KPositionGpsMeasurementInfoSize = 832;
+
+
+CDataClassesStep::~CDataClassesStep()
+/**
+ * Destructor
+ */
+	{
+	}
+
+CDataClassesStep::CDataClassesStep()
+/**
+ * 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(KDataClassesStep);
+	}
+
+TVerdict CDataClassesStep::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 CDataClassesStep::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 CDataClassesStep::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_LbsApiVariant2SuiteStepBase::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 CDataClassesStep::StartL(TInt aIndex)
+	{
+	switch (aIndex)
+		{
+	case 0:
+		TCoordinate_BlankConstructionL ();
+		break;
+	case 1:
+		TCoordinate_ConstructorsL ();
+		break;
+	case 2:
+		TCoordinate_Constructors2L ();
+		break;
+	case 3:
+		TCoordinate_InvalidL ();
+		break;
+	case 4:
+		TCoordinate_NormalizationWithNansL ();
+		break;
+	case 5:
+		TLocality_BlankConstructionL ();
+		break;
+	case 6:
+		TLocality_ConstructorsL ();
+		break;
+	case 7:
+		TLocality_Constructors2L ();
+		break;
+	case 8:
+		TLocality_NegativeL ();
+		break;
+	case 9:
+		TPosition_ConstructionL ();
+		break;
+	case 10:
+		TPosition_SettersL ();
+		break;
+	case 11:
+		TPositionInfo_ConstructionL ();
+		break;
+	case 12:
+		TPositionInfo_ModificationL ();
+		break;
+	case 13:
+		CourseClasses_ConstructionL ();
+		break;
+	case 14:
+		CourseClasses_Modification2L ();
+		break;
+	case 15:
+		CourseClasses_ModificationL ();
+		break;
+	case 16:
+		CourseClasses_InvalidL ();
+		break;
+	case 17:
+		SatelliteClasses_ConstructionL ();
+		break;
+	case 18:
+		SatelliteClasses_PropertiesL ();
+		break;
+	case 19:
+		SatelliteClasses_Properties2L ();
+		break;
+	case 20:
+		SatelliteClasses_InfoL ();
+		break;
+	case 21:
+		SatelliteClasses_SatelliteInfoL ();
+		break;
+	case 22:
+		SatelliteClasses_OverflowL ();
+		break;
+	case 23:
+       GpsMeasurementClasses_PropertiesL ();
+       break;
+	default:
+		break;
+		}
+	}
+
+
+extern void CheckPanic(const char* aFileName, TInt aLine);
+
+//
+//
+// TCoordinate
+//
+//
+
+// 2.1.1. Default constructor sets values to NAN
+void CDataClassesStep::TCoordinate_BlankConstructionL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    TCoordinate coordinate;
+    CHECK(Math::IsNaN(coordinate.Latitude()));
+    CHECK(Math::IsNaN(coordinate.Longitude()));
+    CHECK(Math::IsNaN(coordinate.Altitude()));
+    CHECK_EQUAL_(KPositionDatumWgs84.iUid, coordinate.Datum().iUid);
+
+    StandardCleanup();
+	}
+
+// 2.1.2 Parameterized constructors and Setters work same
+void CDataClassesStep::TCoordinate_ConstructorsL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    const TReal64 dumLat = 11.111;
+    const TReal64 dumLon = 22.222;
+    const TReal32 dumAlt = TReal32(33.333);
+
+    TCoordinate coordSet;
+
+    // 2 parameters
+
+    coordSet.SetCoordinate(dumLat, dumLon);
+
+    CHECK_REAL_EQUAL(coordSet.Latitude() , dumLat);
+    CHECK_REAL_EQUAL(coordSet.Longitude(), dumLon);
+    CHECK(Math::IsNaN(coordSet.Altitude()));
+
+    TCoordinate coord2p(dumLat, dumLon);
+
+    CHECK_REAL_EQUAL(coord2p.Latitude()  , coordSet.Latitude());
+    CHECK_REAL_EQUAL(coord2p.Longitude() , coordSet.Longitude());
+    CHECK(Math::IsNaN(coord2p.Altitude()));
+
+    // 3 params
+    coordSet.SetCoordinate(dumLat, dumLon, dumAlt);
+
+    CHECK_REAL_EQUAL(coordSet.Latitude() , dumLat);
+    CHECK_REAL_EQUAL(coordSet.Longitude(), dumLon);
+    CHECK_REAL_EQUAL(coordSet.Altitude() , dumAlt);
+
+    TCoordinate coord3p(dumLat, dumLon, dumAlt);
+
+    CHECK_REAL_EQUAL(coord3p.Latitude() , coordSet.Latitude());
+    CHECK_REAL_EQUAL(coord3p.Longitude(), coordSet.Longitude());
+    CHECK_REAL_EQUAL(coord3p.Altitude() , coordSet.Altitude());
+
+    // datum
+    const TPositionDatumId otherDatum = {0x10101010};
+    coordSet.SetDatum(otherDatum);
+    CHECK_EQUAL_(otherDatum.iUid, coordSet.Datum().iUid);
+
+    StandardCleanup();
+	}
+
+// 2.1.3 Parameterized constructors and Setters work same with NANs
+void CDataClassesStep::TCoordinate_Constructors2L()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    TRealX nan;
+    nan.SetNaN();
+
+    TReal64 dumLat(nan);
+    TReal64 dumLon(nan);
+    TReal32 dumAlt(nan);
+
+    TCoordinate coordSet;
+
+    // 2 parameters
+
+    coordSet.SetCoordinate(dumLat, dumLon);
+
+    CHECK(Math::IsNaN(coordSet.Latitude()));
+    CHECK(Math::IsNaN(coordSet.Longitude()));
+    CHECK(Math::IsNaN(coordSet.Altitude()));
+
+    TCoordinate coord2p(dumLat, dumLon);
+
+    CHECK(Math::IsNaN(coord2p.Latitude()));
+    CHECK(Math::IsNaN(coord2p.Longitude()));
+    CHECK(Math::IsNaN(coord2p.Altitude()));
+
+    // 3 params
+    coordSet.SetCoordinate(dumLat, dumLon, dumAlt);
+
+    CHECK(Math::IsNaN(coordSet.Latitude()));
+    CHECK(Math::IsNaN(coordSet.Longitude()));
+    CHECK(Math::IsNaN(coordSet.Altitude()));
+
+    TCoordinate coord3p(dumLat, dumLon, dumAlt);
+
+    CHECK(Math::IsNaN(coord3p.Latitude()));
+    CHECK(Math::IsNaN(coord3p.Longitude()));
+    CHECK(Math::IsNaN(coord3p.Altitude()));
+
+    StandardCleanup();
+	}
+
+// 2.1.4 Bad Input in TCoordinate
+
+// The function is to normalize Lat/Lon parameters
+// to [-90,+90] and (-180,+180] ranges respectively.
+// If Latitude wraps +90 or -90 boundary, than Longitude
+// is corrected to be shifted to another hemisphere
+//
+// IF Latitude is in 1st quarter of circle THEN nothing to do
+// IF Latitude is in 2nd or 3rd quarter,
+// THEN Longitude is shifted to opposite hemisphere, and Latitude
+// is mirrored about 90 degrees (to accord with longitude)
+// IF Latitude is in 4th quarter, THEN Latitude is mirrored
+// about 0 degrees (to be below equator)
+//
+// NOTE that as +90 and -90 a valid Latitude values,
+// then 4th quarter begins from +270 inclusively (it is -90 inclusively in fact)
+//
+// Latitude is processed first as it has its influence on Longitude
+void NormalLatLon(TReal lat, TReal lon, TReal& nlat, TReal& nlon)
+	{
+    // 1. latitude
+
+    // save sign, because negative and positive latitude
+    // values are processed same way
+    TBool isNegLat = (lat < 0);
+
+    // truncate by 360, work with positive values
+    TReal absLat = isNegLat ? -lat : lat;
+    Math::Mod(lat, absLat, 360);  // 0 <= lat < 360
+
+    // correct values, if latitude wraps 90 deg boundary
+    if (lat >= 270)         // 4th quarter
+    {
+        lat = lat - 360;    // reverse
+    }
+    else
+    if (lat > 90)           // 2nd or 3rd quarter
+    {
+        lat = 180 - lat;    // round about 90
+        lon = lon + 180;    // another hemisphere
+    }
+
+    // recall latutide sign
+    if (isNegLat) lat = - lat;
+
+    // 2. longitude
+
+    // -360 < lon < 360
+    Math::Mod(lon, lon, 360);
+    // let's put lon to -180 .. 180 range
+    if (lon > 180)
+    {
+        lon = lon - 360;
+    }
+    else
+    if (lon < - 180) // for negative longitudes
+    {
+        lon = lon + 360;
+    }
+
+    nlat = lat;
+    nlon = lon;
+	}
+
+void XYZfromLatLon(TReal& x, TReal& y, TReal& z, TReal lat, TReal lon)
+	{
+    Math::Mod(lat, lat, 360);  // -360 < lat < 360
+    Math::Mod(lon, lon, 360);  // -360 < lon < 360
+
+
+    // if latitude is 90 deg or -90 deg, then reduce it by one degree : 89 deg.
+    // it allows to check longitude direction more correctly (avoid cos(lat)==0)
+    if ((lat == 90) || (lat == -270))
+    {
+        lat -= 1;
+    }
+    else
+    if ((lat == -90) || (lat == 270))
+    {
+        lat += 1;
+    }
+
+    TReal latCos, latSin, lonCos, lonSin;
+    Math::Cos(latCos, lat * KDegToRad);
+    Math::Sin(latSin, lat * KDegToRad);
+    Math::Cos(lonCos, lon * KDegToRad);
+    Math::Sin(lonSin, lon * KDegToRad);
+
+    x = latCos * lonCos;
+    y = latCos * lonSin;
+    z = latSin;
+	}
+
+TBool IsSamePoint(TReal lat1, TReal lon1, TReal lat2, TReal lon2)
+	{
+    TReal x1,y1,z1, x2,y2,z2;
+
+    XYZfromLatLon(x1,y1,z1, lat1, lon1);    // source values
+    XYZfromLatLon(x2,y2,z2, lat2, lon2);    // TCoordinate
+
+    const TReal tolerance = 0.0000001; // 1 of million
+
+    TBool same = (Abs(x1 - x2) < tolerance) &&
+                 (Abs(y1 - y2) < tolerance) &&
+                 (Abs(z1 - z2) < tolerance);
+    return same;
+	}
+
+
+void CDataClassesStep::TCoordinate_InvalidL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    const TReal32 alt = 10;
+    TBool noErrors = ETrue;
+
+    // 1. Valid WGS84 range + Out of WGS84 range
+
+    // check values (step 30 degrees) in (-540..+540] of longitude
+    for (TReal64 lon = 540; lon > -540; lon -= 30)
+    	{
+        // check values (step 30 degrees) in [-450; 450] of latitude
+        for (TReal64 lat = 720; lat >= -720; lat -= 30)
+        	{
+            // set
+            TCoordinate coordinate2, coordinate3;
+            coordinate2.SetCoordinate(lat,lon);
+            coordinate3.SetCoordinate(lat,lon, alt);
+
+            // construct
+            TCoordinate coord2(lat, lon);
+            TCoordinate coord3(lat, lon, alt);
+
+            TBool isValidCoordinate2 = IsSamePoint(lat, lon, coordinate2.Latitude(), coordinate2.Longitude());
+            TBool isValidCoordinate3 = IsSamePoint(lat, lon, coordinate3.Latitude(), coordinate3.Longitude());
+            TBool isValidCoord2 = IsSamePoint(lat, lon, coord2.Latitude(), coord2.Longitude());
+            TBool isValidCoord3 = IsSamePoint(lat, lon, coord3.Latitude(), coord3.Longitude());
+
+
+            TReal nlat, nlon;
+            NormalLatLon(lat, lon, nlat, nlon);
+            TBool isValidNormalLatLon = IsSamePoint(lat, lon, nlat, nlon);
+
+            if (!isValidCoordinate2 || !isValidCoordinate3 || !isValidCoord2 || !isValidCoord3 || !isValidNormalLatLon)
+            	{
+                noErrors = EFalse;
+            	}
+        	}
+    	}
+
+    if (!noErrors) LOG("There were errors in Normalization.");
+    CHECK(noErrors);
+
+    StandardCleanup();
+	}
+
+
+
+TInt TCoordinate_NormalizationWithNans_Panic(TAny* /*aPtr*/)
+	{
+    TRealX nan; nan.SetNaN();
+
+    const TReal KBigLatitude = 120.0;
+    const TReal KBigLongitude = 200.0;
+
+    const TReal KGoodLatitude = 180 - KBigLatitude;
+    const TReal KGoodLongitude = KBigLongitude - 360;
+
+    TCoordinate coord;
+
+    // this will cause normalization process
+    // this should not panic even though longitude is NaN
+    coord.SetCoordinate(KBigLatitude, nan);
+    CHECK_PANIC(coord.Latitude() == KGoodLatitude);
+    CHECK_PANIC(Math::IsNaN(coord.Longitude()));
+
+    // this will cause normalization process
+    // this should not panic even though latitude is NaN
+    coord.SetCoordinate(nan, KBigLongitude);
+    CHECK_PANIC(coord.Longitude() == KGoodLongitude);
+    CHECK_PANIC(Math::IsNaN(coord.Latitude()));
+
+    return KErrNone;
+	}
+
+// 2.1.5 Normalization if one of members is NaN
+void CDataClassesStep::TCoordinate_NormalizationWithNansL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    DO_PANIC_TEST_L(
+        TCoordinate_NormalizationWithNans_Panic,
+        KNoClientFault,
+        KErrNone,
+        KDefaultTestTimeout);
+
+    StandardCleanup();
+	}
+
+
+//
+//
+// TLocality
+//
+//
+
+// 2.3.1. Blank constructor
+void CDataClassesStep::TLocality_BlankConstructionL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    TLocality locality;
+    CHECK(Math::IsNaN(locality.Latitude()));
+    CHECK(Math::IsNaN(locality.Longitude()));
+    CHECK(Math::IsNaN(locality.Altitude()));
+    CHECK(Math::IsNaN(locality.HorizontalAccuracy()));
+    CHECK(Math::IsNaN(locality.VerticalAccuracy()));
+
+    StandardCleanup();
+	}
+
+// 2.3.2. Compare constructor parameters setting and using setters
+void CDataClassesStep::TLocality_ConstructorsL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    const TReal64 dumLat = 11.111;
+    const TReal64 dumLon = 22.222;
+    const TReal32 dumAlt = TReal32(33.333);
+    const TReal32 dumHorAcc = TReal32(0.444);
+    const TReal32 dumVerAcc = TReal32(0.555);
+
+    TCoordinate coord(dumLat, dumLon, dumAlt);
+
+    // hor
+    TLocality localSetHor;
+    localSetHor.SetHorizontalAccuracy(dumHorAcc);
+
+    CHECK_REAL_EQUAL(localSetHor.HorizontalAccuracy() , dumHorAcc);
+    CHECK(Math::IsNaN(localSetHor.VerticalAccuracy()));
+
+    TLocality localHor(coord, dumHorAcc);
+
+    CHECK_REAL_EQUAL(localHor.Latitude() , dumLat);
+    CHECK_REAL_EQUAL(localHor.Longitude(), dumLon);
+    CHECK_REAL_EQUAL(localHor.Altitude() , dumAlt);
+
+    CHECK_REAL_EQUAL(localHor.HorizontalAccuracy(), dumHorAcc);
+    CHECK(Math::IsNaN(localHor.VerticalAccuracy()));
+
+    // ver
+    TLocality localSetVer;
+    localSetVer.SetVerticalAccuracy(dumVerAcc);
+
+    CHECK(Math::IsNaN(localSetVer.HorizontalAccuracy()));
+    CHECK_REAL_EQUAL(localSetVer.VerticalAccuracy() , dumVerAcc);
+
+    // both
+    TLocality localSet;
+    localSet.SetAccuracy(dumHorAcc, dumVerAcc);
+
+    CHECK_REAL_EQUAL(localSet.HorizontalAccuracy(), dumHorAcc);
+    CHECK_REAL_EQUAL(localSet.VerticalAccuracy()  , dumVerAcc);
+
+    TLocality localVer(coord, dumHorAcc, dumVerAcc);
+
+    CHECK_REAL_EQUAL(localVer.Latitude() , dumLat);
+    CHECK_REAL_EQUAL(localVer.Longitude(), dumLon);
+    CHECK_REAL_EQUAL(localVer.Altitude() , dumAlt);
+
+    CHECK_REAL_EQUAL(localVer.HorizontalAccuracy(), dumHorAcc);
+    CHECK_REAL_EQUAL(localVer.VerticalAccuracy()  , dumVerAcc);
+
+    StandardCleanup();
+	}
+
+// 2.3.3. Compare constructor parameters setting and using setters, NANs
+TInt TLocality_Constructors_and_Setters_with_NANs(TAny* /*aPtr*/)
+	{
+    TRealX nan; nan.SetNaN();
+
+    const TReal64 dumLat(nan);
+    const TReal64 dumLon(nan);
+    const TReal32 dumAlt(nan);
+    const TReal32 dumHorAcc(nan);
+    const TReal32 dumVerAcc(nan);
+
+    TCoordinate coord(dumLat, dumLon, dumAlt);
+
+    // hor
+    TLocality localSetHor;
+    localSetHor.SetHorizontalAccuracy(dumHorAcc);
+
+    CHECK_PANIC(Math::IsNaN(localSetHor.HorizontalAccuracy()));
+    CHECK_PANIC(Math::IsNaN(localSetHor.VerticalAccuracy()));
+
+    TLocality localHor(coord, dumHorAcc);
+
+    CHECK_PANIC(Math::IsNaN(localHor.Latitude()));
+    CHECK_PANIC(Math::IsNaN(localHor.Longitude()));
+    CHECK_PANIC(Math::IsNaN(localHor.Altitude()));
+
+    CHECK_PANIC(Math::IsNaN(localHor.HorizontalAccuracy()));
+    CHECK_PANIC(Math::IsNaN(localHor.VerticalAccuracy()));
+
+    // ver
+    TLocality localSetVer;
+    localSetVer.SetVerticalAccuracy(dumVerAcc);
+
+    CHECK_PANIC(Math::IsNaN(localSetVer.HorizontalAccuracy()));
+    CHECK_PANIC(Math::IsNaN(localSetVer.VerticalAccuracy()));
+
+    // both
+    TLocality localSet;
+    localSet.SetAccuracy(dumHorAcc, dumVerAcc);
+
+    CHECK_PANIC(Math::IsNaN(localSet.HorizontalAccuracy()));
+    CHECK_PANIC(Math::IsNaN(localSet.VerticalAccuracy()));
+
+    TLocality localVer(coord, dumHorAcc, dumVerAcc);
+
+    CHECK_PANIC(Math::IsNaN(localVer.Latitude()));
+    CHECK_PANIC(Math::IsNaN(localVer.Longitude()));
+    CHECK_PANIC(Math::IsNaN(localVer.Altitude()));
+
+    CHECK_PANIC(Math::IsNaN(localVer.HorizontalAccuracy()));
+    CHECK_PANIC(Math::IsNaN(localVer.VerticalAccuracy()));
+
+    return KErrNone;
+	}
+
+
+void CDataClassesStep::TLocality_Constructors2L()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    DO_PANIC_TEST_L(
+        TLocality_Constructors_and_Setters_with_NANs,
+        KNoClientFault,
+        KErrNone,
+        KDefaultTestTimeout);
+
+    StandardCleanup();
+	}
+
+// 2.3.4 Negative Accuracy values
+TInt TLocality_Negative_Accuracy_Construct_HorAcc(TAny* /*aPtr*/)
+	{
+    const TReal32 dumAcc = TReal32(0.1);
+    TLocality locality(TCoordinate(1,2,3), -dumAcc);
+
+    locality.Altitude();
+    return KErrGeneral;
+	}
+
+
+TInt TLocality_Negative_Accuracy_Construct_VerAcc(TAny* /*aPtr*/)
+	{
+    const TReal32 dumAcc = TReal32(0.1);
+    TLocality locality(TCoordinate(1,2,3), dumAcc, -dumAcc);
+
+    locality.Altitude();
+    return KErrGeneral;
+	}
+
+
+TInt TLocality_Negative_Accuracy_Set_Both_HorNegative(TAny* /*aPtr*/)
+	{
+    const TReal32 dumAcc = TReal32(0.1);
+    TLocality locality;
+    locality.SetAccuracy(-dumAcc, dumAcc);
+    return KErrGeneral;
+	}
+
+
+TInt TLocality_Negative_Accuracy_Set_Both_VerNegative(TAny* /*aPtr*/)
+	{
+    const TReal32 dumAcc = TReal32(0.1);
+    TLocality locality;
+    locality.SetAccuracy(dumAcc, -dumAcc);
+    return KErrGeneral;
+	}
+
+
+TInt TLocality_Negative_Accuracy_Set_HorNegative(TAny* /*aPtr*/)
+	{
+    const TReal32 dumAcc = TReal32(0.1);
+    TLocality locality;
+    locality.SetHorizontalAccuracy(-dumAcc);
+    return KErrGeneral;
+	}
+
+
+TInt TLocality_Negative_Accuracy_Set_VerNegative(TAny* /*aPtr*/)
+	{
+    const TReal32 dumAcc = TReal32(0.1);
+    TLocality locality;
+    locality.SetVerticalAccuracy(-dumAcc);
+    return KErrGeneral;
+	}
+
+
+void CDataClassesStep::TLocality_NegativeL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    DO_PANIC_TEST_L(TLocality_Negative_Accuracy_Construct_HorAcc,
+        KPosClientFault, EPositionBadAccuracy, KDefaultTestTimeout);
+    DO_PANIC_TEST_L(TLocality_Negative_Accuracy_Construct_VerAcc,
+        KPosClientFault, EPositionBadAccuracy, KDefaultTestTimeout);
+
+    DO_PANIC_TEST_L(TLocality_Negative_Accuracy_Set_Both_HorNegative,
+        KPosClientFault, EPositionBadAccuracy, KDefaultTestTimeout);
+    DO_PANIC_TEST_L(TLocality_Negative_Accuracy_Set_Both_VerNegative,
+        KPosClientFault, EPositionBadAccuracy, KDefaultTestTimeout);
+
+    DO_PANIC_TEST_L(TLocality_Negative_Accuracy_Set_HorNegative,
+        KPosClientFault, EPositionBadAccuracy, KDefaultTestTimeout);
+    DO_PANIC_TEST_L(TLocality_Negative_Accuracy_Set_VerNegative,
+        KPosClientFault, EPositionBadAccuracy, KDefaultTestTimeout);
+
+    StandardCleanup();
+	}
+
+
+//
+//
+// TPosition
+//
+//
+
+// 2.5.1. Constructors
+void CDataClassesStep::TPosition_ConstructionL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    // blank
+    TPosition position;
+
+    CHECK(position.Time() == TTime(0));
+    CHECK(Math::IsNaN(position.Latitude()));
+    CHECK(Math::IsNaN(position.Longitude()));
+    CHECK(Math::IsNaN(position.Altitude()));
+    CHECK(Math::IsNaN(position.HorizontalAccuracy()));
+    CHECK(Math::IsNaN(position.VerticalAccuracy()));
+
+    // full
+
+    const TReal64 dumLat = 11.111;
+    const TReal64 dumLon = 22.222;
+    const TReal32 dumAlt = TReal32(33.333);
+    const TReal32 dumHorAcc = TReal32(0.444);
+    const TReal32 dumVerAcc = TReal32(0.555);
+
+    TTime dumTime;
+    dumTime.HomeTime();
+
+    TCoordinate coordinate(dumLat, dumLon, dumAlt);
+    TLocality locality(coordinate, dumHorAcc, dumVerAcc);
+    position = TPosition(locality, dumTime);
+
+    CHECK(position.Time() == dumTime);
+    CHECK_REAL_EQUAL(position.Latitude(), dumLat);
+    CHECK_REAL_EQUAL(position.Longitude(), dumLon);
+    CHECK_REAL_EQUAL(position.Altitude(), dumAlt);
+    CHECK_REAL_EQUAL(position.HorizontalAccuracy(), dumHorAcc);
+    CHECK_REAL_EQUAL(position.VerticalAccuracy(), dumVerAcc);
+
+    StandardCleanup();
+	}
+
+// 2.5.2. Setters/Getters (time)
+void CDataClassesStep::TPosition_SettersL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    // time
+    TTime dumTime;
+    dumTime.HomeTime();
+
+    TPosition pos;
+    pos.SetTime(dumTime);
+    CHECK_EQUAL_(dumTime, pos.Time());
+
+    // current time
+    TPosition position;
+    position.SetCurrentTime();
+
+    TTime uniTime;
+    uniTime.UniversalTime();
+
+    TTimeIntervalSeconds last;
+    uniTime.SecondsFrom(position.Time(), last);
+    CHECK(last <= TTimeIntervalSeconds(1));
+
+    StandardCleanup();
+	}
+
+
+//
+//
+// TPositionInfo
+//
+//
+
+// 3.1.1. TPositionInfo construction
+void CDataClassesStep::TPositionInfo_ConstructionL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    TPositionInfo posInfo;
+
+    // position
+    TPosition pos;
+    posInfo.GetPosition(pos);
+
+    CHECK(Math::IsNaN(pos.Latitude()));
+    CHECK(Math::IsNaN(pos.Longitude()));
+    CHECK(Math::IsNaN(pos.Altitude()));
+    CHECK(Math::IsNaN(pos.HorizontalAccuracy()));
+    CHECK(Math::IsNaN(pos.VerticalAccuracy()));
+    CHECK_EQUAL_(TTime(0), pos.Time());
+
+    // From Base
+
+    // class type
+    CHECK(posInfo.PositionClassType() == EPositionInfoClass);
+    CHECK(posInfo.PositionClassSize() == sizeof(TPositionInfo));
+
+    // module id
+    CHECK_EQUAL_((TInt)posInfo.ModuleId().iUid, (TInt)KPositionNullModuleId.iUid);
+
+    // update info
+    CHECK(posInfo.UpdateType() == EPositionUpdateGeneral);
+
+    StandardCleanup();
+	}
+
+// 3.1.2. TPositionInfo modification
+void CDataClassesStep::TPositionInfo_ModificationL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    const TReal64 dumLat = 11.111;
+    const TReal64 dumLon = 22.222;
+    const TReal32 dumAlt = TReal32(33.333);
+    const TReal32 dumHorAcc = TReal32(0.444);
+    const TReal32 dumVerAcc = TReal32(0.555);
+
+    TTime dumTime;
+    dumTime.HomeTime();
+
+    TPositionInfo posInfo;
+    TCoordinate dumCoordinate = TCoordinate(dumLat, dumLon, dumAlt);
+    TLocality dumLocality = TLocality(dumCoordinate, dumHorAcc, dumVerAcc);
+    
+    // position
+    TPosition pos(dumLocality, dumTime);
+    posInfo.SetPosition(pos);
+
+    TPosition pos2;
+    posInfo.GetPosition(pos2);
+
+    CHECK_REAL_EQUAL(pos2.Latitude(),  pos.Latitude());
+    CHECK_REAL_EQUAL(pos2.Longitude(), pos.Longitude());
+    CHECK_REAL_EQUAL(pos2.Altitude(),  pos.Altitude());
+    CHECK_REAL_EQUAL(pos2.HorizontalAccuracy(), pos.HorizontalAccuracy());
+    CHECK_REAL_EQUAL(pos2.VerticalAccuracy(),   pos.VerticalAccuracy());
+    CHECK_EQUAL_(pos2.Time(), pos.Time());
+
+    // From Base
+
+    // module id
+
+    const TPositionModuleId dumModId = {0x12345678};
+    posInfo.SetModuleId(dumModId);
+    CHECK_EQUAL_((TInt)dumModId.iUid, (TInt)posInfo.ModuleId().iUid);
+
+    // update info
+
+    posInfo.SetUpdateType(EPositionUpdateUnknown);
+    CHECK(posInfo.UpdateType() == EPositionUpdateUnknown);
+
+    posInfo.SetUpdateType(EPositionUpdateGeneral);
+    CHECK(posInfo.UpdateType() == EPositionUpdateGeneral);
+
+    StandardCleanup();
+	}
+
+
+//
+//
+// Course classes
+//
+//
+
+// 4.1.1. Construction
+void CDataClassesStep::CourseClasses_ConstructionL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    // course
+    TCourse course;
+    CHECK(Math::IsNaN(course.Speed()));
+    CHECK(Math::IsNaN(course.Heading()));
+    CHECK(Math::IsNaN(course.SpeedAccuracy()));
+    CHECK(Math::IsNaN(course.HeadingAccuracy()));
+
+        // course info
+    TPositionCourseInfo courseInfo;
+    CHECK(courseInfo.PositionClassType()==(EPositionInfoClass|EPositionCourseInfoClass));
+    CHECK_EQUAL_(courseInfo.PositionClassSize(), sizeof(TPositionCourseInfo));
+
+    CHECK_EQUAL_((TInt)courseInfo.ModuleId().iUid, (TInt)KPositionNullModuleId.iUid);
+    CHECK(courseInfo.UpdateType() == EPositionUpdateGeneral);
+
+    StandardCleanup();
+	}
+
+
+// 4.1.2. Modification
+void CDataClassesStep::CourseClasses_ModificationL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    const TReal32 KDummyValue1 = (TReal32)43.342;
+    const TReal32 KDummyValue2 = (TReal32)34.5236;
+    const TReal32 KDummyValue3 = (TReal32)983.45;
+    const TReal32 KDummyValue4 = (TReal32)12.432;
+
+    TCourse course;
+    course.SetSpeed(KDummyValue1);
+    course.SetHeading(KDummyValue2);
+    course.SetSpeedAccuracy(KDummyValue3);
+    course.SetHeadingAccuracy(KDummyValue4);
+
+    CHECK_REAL_EQUAL(course.Speed(), KDummyValue1);
+    CHECK_REAL_EQUAL(course.Heading(), KDummyValue2);
+    CHECK_REAL_EQUAL(course.SpeedAccuracy(), KDummyValue3);
+    CHECK_REAL_EQUAL(course.HeadingAccuracy(), KDummyValue4);
+
+    TCourse course2;        //Use new course object so we can be sure data is transfered properly
+
+    TPositionCourseInfo courseInfo;
+    courseInfo.SetCourse(course);
+        courseInfo.GetCourse(course2);
+
+    CHECK_REAL_EQUAL(course2.Speed(), KDummyValue1);
+    CHECK_REAL_EQUAL(course2.Heading(), KDummyValue2);
+    CHECK_REAL_EQUAL(course2.SpeedAccuracy(), KDummyValue3);
+    CHECK_REAL_EQUAL(course2.HeadingAccuracy(), KDummyValue4);
+
+    StandardCleanup();
+	}
+
+
+// 4.1.3. NaNs
+TInt CourseClasses_Setters_with_NANs(TAny* /*aPtr*/)
+	{
+    TRealX nan;
+    nan.SetNaN();
+
+    TCourse course;
+    course.SetSpeed(nan);
+    course.SetHeading(nan);
+    course.SetCourse(nan);
+    course.SetSpeedAccuracy(nan);
+    course.SetHeadingAccuracy(nan);
+    course.SetCourseAccuracy(nan);
+
+    CHECK_PANIC(Math::IsNaN(course.Speed()));
+    CHECK_PANIC(Math::IsNaN(course.Heading()));
+    CHECK_PANIC(Math::IsNaN(course.Course()));
+    CHECK_PANIC(Math::IsNaN(course.SpeedAccuracy()));
+    CHECK_PANIC(Math::IsNaN(course.HeadingAccuracy()));
+    CHECK_PANIC(Math::IsNaN(course.CourseAccuracy()));
+
+    return KErrNone;
+	}
+
+
+void CDataClassesStep::CourseClasses_Modification2L()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    DO_PANIC_TEST_L(CourseClasses_Setters_with_NANs,
+        KNoClientFault, KErrNone, KDefaultTestTimeout);
+
+    StandardCleanup();
+	}
+
+
+// 4.1.4. Invalid values
+TInt CourseClasses_Invalid_Input_HeadAcc(TAny* /*aPtr*/)
+	{
+    TCourse course;
+    course.SetHeadingAccuracy(TReal32(-0.1));
+    return KErrGeneral;
+	}
+
+
+TInt CourseClasses_Invalid_Input_SpeedAcc(TAny* /*aPtr*/)
+	{
+    TCourse course;
+    course.SetSpeedAccuracy(TReal32(-0.1));
+    return KErrGeneral;
+	}
+
+
+void CDataClassesStep::CourseClasses_InvalidL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    DO_PANIC_TEST_L(CourseClasses_Invalid_Input_HeadAcc,
+        KPosClientFault, EPositionBadAccuracy, KDefaultTestTimeout);
+
+    DO_PANIC_TEST_L(CourseClasses_Invalid_Input_SpeedAcc,
+        KPosClientFault, EPositionBadAccuracy, KDefaultTestTimeout);
+
+    StandardCleanup();
+	}
+
+//
+//
+// Satellite classes
+//
+//
+
+// 4.3.1. Construction
+void CDataClassesStep::SatelliteClasses_ConstructionL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    // satellite
+    TSatelliteData satData;
+
+    CHECK_EQUAL_(-1, satData.SatelliteId());
+    CHECK(Math::IsNaN(satData.Azimuth()));
+    CHECK(Math::IsNaN(satData.Elevation()));
+    CHECK(!satData.IsUsed());
+    CHECK_EQUAL_(0, satData.SignalStrength());
+    
+	//Sizeof(class) not always same in emulator and hardware as alignment restriction in hardware.
+    #if defined(_DEBUG) 
+	// Check the size of the TPositionSatelliteInfo class is unchanged
+    CHECK_EQUAL_(KPositionSatelliteInfoSize, sizeof(TPositionSatelliteInfo));
+    #endif 
+    
+	// satellite info
+    TPositionSatelliteInfo satInfo;
+
+    CHECK_EQUAL_(KErrNotFound, satInfo.GetSatelliteData(0, satData));
+    CHECK_EQUAL_(0, satInfo.NumSatellitesInView());
+    CHECK_EQUAL_(0, satInfo.NumSatellitesUsed());
+    CHECK(TTime(0) == satInfo.SatelliteTime());
+    CHECK(Math::IsNaN(satInfo.HorizontalDoP()));
+    CHECK(Math::IsNaN(satInfo.VerticalDoP()));
+    CHECK(Math::IsNaN(satInfo.TimeDoP()));
+
+    StandardCleanup();
+	}
+
+
+// 4.3.2. Properties
+void CDataClassesStep::SatelliteClasses_PropertiesL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    TSatelliteData satData;
+
+    const TInt dumSatelliteId = 11111;
+    const TInt dumSignalStrength = 22222;
+    const TReal32 dumAzimuth = TReal32(234.2345);
+    const TReal32 dumElevation = TReal32(4745.1231);
+
+    satData.SetSignalStrength(dumSignalStrength);
+    satData.SetSatelliteId(dumSatelliteId);
+    satData.SetAzimuth(dumAzimuth);
+    satData.SetElevation(dumElevation);
+
+    CHECK_EQUAL_(dumSatelliteId,     satData.SatelliteId());
+    CHECK_EQUAL_(dumSignalStrength,  satData.SignalStrength());
+    CHECK_REAL_EQUAL(dumAzimuth,    satData.Azimuth());
+    CHECK_REAL_EQUAL(dumElevation,  satData.Elevation());
+
+    satData.SetIsUsed(ETrue);
+    CHECK(satData.IsUsed());
+    satData.SetIsUsed(EFalse);
+    CHECK(!satData.IsUsed());
+
+    TPositionSatelliteInfo satInfo;
+
+    const TTime dumSatTime(TInt64(54));
+    const TReal32 dumHorzDoP = (TReal32) 345.2131;
+    const TReal32 dumVertDoP = (TReal32) 34.1;
+    const TReal32 dumTimeDoP = (TReal32) 876.68;
+
+    satInfo.SetSatelliteTime(dumSatTime);
+    satInfo.SetHorizontalDoP(dumHorzDoP);
+    satInfo.SetVerticalDoP(dumVertDoP);
+    satInfo.SetTimeDoP(dumTimeDoP);
+
+    CHECK_REAL_EQUAL(dumHorzDoP,    satInfo.HorizontalDoP());
+    CHECK_REAL_EQUAL(dumVertDoP,    satInfo.VerticalDoP());
+    CHECK_REAL_EQUAL(dumTimeDoP,    satInfo.TimeDoP());
+    CHECK_EQUAL_(     dumSatTime,    satInfo.SatelliteTime());
+
+    TPositionExtendedSatelliteInfo extSatInfo;
+    TGpsTimingMeasurementData gpsTimingData;
+           
+    // all max values for UTran/Fdd 
+    const TInt dumGpsTocMs  = (TInt) 16383;
+    const TUint dumGpsTocLs = (TUint) 4294967295UL;
+    const TInt dumRefId     = (TInt) 511;
+    const TInt dumSfn       = (TInt) 4095;
+   
+    gpsTimingData.SetDataType(TGpsTimingMeasurementData::EGpsTimingDataTypeUtran);
+    gpsTimingData.SetNetworkMode(TGpsTimingMeasurementData::ENetworkModeFdd);
+    gpsTimingData.SetGPSTimingOfCellMsPart(dumGpsTocMs);
+    gpsTimingData.SetGPSTimingOfCellLsPart(dumGpsTocLs);
+    gpsTimingData.SetReferenceIdentity(dumRefId);
+    gpsTimingData.SetSfn(dumSfn);
+       
+    extSatInfo.SetGpsTimingData(gpsTimingData);
+       
+    TGpsTimingMeasurementData gpsTimingDataReturned;
+    CHECK_EQUAL_(KErrNone, extSatInfo.GetGpsTimingData(gpsTimingDataReturned));
+      
+    CHECK_EQUAL_(TGpsTimingMeasurementData::EGpsTimingDataTypeUtran, gpsTimingData.DataType());
+    CHECK_EQUAL_(TGpsTimingMeasurementData::ENetworkModeFdd, gpsTimingData.NetworkMode());
+    CHECK_EQUAL_(dumGpsTocMs, gpsTimingDataReturned.GPSTimingOfCellMsPart());
+    CHECK_EQUAL_(dumGpsTocLs, gpsTimingDataReturned.GPSTimingOfCellLsPart());
+    CHECK_EQUAL_(dumRefId,    gpsTimingDataReturned.ReferenceIdentity());
+    CHECK_EQUAL_(dumSfn,      gpsTimingDataReturned.Sfn());
+
+    
+    TGpsTimingMeasurementData gpsTimingData2;
+   
+    // all max values for GSM 
+    const TInt refFrameMsb      = (TInt) 63;
+    const TInt gpsTowSubms      = (TInt) 9999;
+    const TInt deltaTow         = (TInt) 127;
+    const TInt gpsRefTimeUncert = (TInt) 127;
+
+    gpsTimingData2.SetDataType(TGpsTimingMeasurementData::EGpsTimingDataTypeGsm);
+
+    // check default GSM values
+    CHECK_EQUAL_(TGpsTimingMeasurementData::EGpsTimingDataTypeGsm, gpsTimingData2.DataType());
+    CHECK_EQUAL_(0,            gpsTimingData2.ReferenceFrameMsb());
+    CHECK_EQUAL_(KErrNotFound, gpsTimingData2.GpsTowSubms());
+    CHECK_EQUAL_(KErrNotFound, gpsTimingData2.DeltaTow());
+    CHECK_EQUAL_(KErrNotFound, gpsTimingData2.GpsReferenceTimeUncertainty());
+   
+    // update values
+    gpsTimingData2.SetReferenceFrameMsb(refFrameMsb);
+    gpsTimingData2.SetGpsTowSubms(gpsTowSubms);
+    gpsTimingData2.SetDeltaTow(deltaTow);
+    gpsTimingData2.SetGpsReferenceTimeUncertainty(gpsRefTimeUncert);
+   
+    CHECK_EQUAL_(refFrameMsb,      gpsTimingData2.ReferenceFrameMsb());
+    CHECK_EQUAL_(gpsTowSubms,      gpsTimingData2.GpsTowSubms());
+    CHECK_EQUAL_(deltaTow,         gpsTimingData2.DeltaTow());
+    CHECK_EQUAL_(gpsRefTimeUncert, gpsTimingData2.GpsReferenceTimeUncertainty());
+
+       
+    StandardCleanup();
+	}
+
+
+// 4.3.3. Properties with NANs
+void CDataClassesStep::SatelliteClasses_Properties2L()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    TRealX nan;
+    nan.SetNaN();
+
+    TSatelliteData satData;
+
+    const TReal32 dumAzimuth = nan;
+    const TReal32 dumElevation = nan;
+
+    satData.SetAzimuth(dumAzimuth);
+    satData.SetElevation(dumElevation);
+
+    CHECK(Math::IsNaN(satData.Azimuth()));
+    CHECK(Math::IsNaN(satData.Elevation()));
+
+    TPositionSatelliteInfo satInfo;
+
+    const TReal32 dumHorzDoP = nan;
+    const TReal32 dumVertDoP = nan;
+    const TReal32 dumTimeDoP = nan;
+
+    satInfo.SetHorizontalDoP(dumHorzDoP);
+    satInfo.SetVerticalDoP(dumVertDoP);
+    satInfo.SetTimeDoP(dumTimeDoP);
+
+    CHECK(Math::IsNaN(satInfo.HorizontalDoP()));
+    CHECK(Math::IsNaN(satInfo.VerticalDoP()));
+    CHECK(Math::IsNaN(satInfo.TimeDoP()));
+
+    StandardCleanup();
+	}
+
+
+// 4.3.4.   TPositionSatelliteInfo accepts TSatelliteData
+void CDataClassesStep::SatelliteClasses_InfoL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    TSatelliteData satData;
+
+    const TInt dumSatelliteId = 11111;
+    const TInt dumSignalStrength = 22222;
+    const TReal32 dumAzimuth = TReal32(111.111);
+    const TReal32 dumElevation = TReal32(222.222);
+
+    satData.SetSignalStrength(dumSignalStrength);
+    satData.SetSatelliteId(dumSatelliteId);
+    satData.SetAzimuth(dumAzimuth);
+    satData.SetElevation(dumElevation);
+    satData.SetIsUsed(ETrue);
+
+    TPositionSatelliteInfo satInfo;
+    TSatelliteData satData2;
+
+    // append data
+    satInfo.AppendSatelliteData(satData);
+
+    CHECK_EQUAL_(1,        satInfo.NumSatellitesInView());                //Have added 1 satellite
+    CHECK_EQUAL_(KErrNone, satInfo.GetSatelliteData(0, satData2));
+
+    // check data
+    CHECK_EQUAL_(dumSatelliteId,     satData2.SatelliteId());
+    CHECK_EQUAL_(dumSignalStrength,  satData2.SignalStrength());
+    CHECK_REAL_EQUAL(dumAzimuth,    satData2.Azimuth());
+    CHECK_REAL_EQUAL(dumElevation,  satData2.Elevation());
+    CHECK(satData2.IsUsed());
+
+    StandardCleanup();
+	}
+
+
+//
+//  Satellites list
+//
+
+// 4.4.1. Satellite data list integrity
+void CDataClassesStep::SatelliteClasses_SatelliteInfoL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    TSatelliteData satData, satData2;
+    TPositionSatelliteInfo satInfo;
+
+    // append data
+    for (TInt ii = 0; (TUint)ii < KPositionMaxSatellitesInView; ii++)
+    	{
+        TBool isUsed = ( ii % 2 != 0 );
+
+        satData.SetIsUsed( isUsed );
+
+        CHECK(KErrNotFound == satInfo.GetSatelliteData(ii, satData2));
+        CHECK_EQUAL_(KErrNone, satInfo.AppendSatelliteData(satData));
+
+        CHECK_EQUAL_(ii + 1,   satInfo.NumSatellitesInView());                //Have added 1 satellite
+        CHECK_EQUAL_((ii+1)/2, satInfo.NumSatellitesUsed());
+
+        CHECK_EQUAL_(KErrNone, satInfo.GetSatelliteData(ii, satData2));
+        CHECK_EQUAL_(isUsed,   satData2.IsUsed());
+    	}
+
+    satInfo.ClearSatellitesInView();
+    CHECK_EQUAL_(KErrNotFound, satInfo.GetSatelliteData(0, satData2));
+    CHECK_EQUAL_(0, satInfo.NumSatellitesInView());
+    CHECK_EQUAL_(0, satInfo.NumSatellitesUsed());
+
+    StandardCleanup();
+	}
+
+// 4.4.2. Too much SatelliteData is added
+void CDataClassesStep::SatelliteClasses_OverflowL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    TPositionSatelliteInfo satInfo;
+    TSatelliteData satData;
+    for (TInt i=0; i < static_cast<TInt>(KPositionMaxSatellitesInView); i++)
+        {
+        satData.SetSatelliteId(i);
+        CHECK_EQUAL_(KErrNone, satInfo.AppendSatelliteData(satData));
+        }
+
+    CHECK_EQUAL_(KErrOverflow, satInfo.AppendSatelliteData(satData));
+
+    StandardCleanup();
+	}
+void CDataClassesStep::GpsMeasurementClasses_PropertiesL()
+     {
+     DECLARE_ERROR_LOGGING;
+     StandardPrepareL();
+     
+     // Check the size of the TPositionGpsMeasurementInfo class is unchanged
+     CHECK_EQUAL_(KPositionGpsMeasurementInfoSize, sizeof(TPositionGpsMeasurementInfo));
+     
+     TPositionGpsMeasurementInfo gpsMeasurementInfo;
+     TGpsTimingMeasurementData gpsTimingData;
+     
+     // all max values for UTran/Fdd 
+     const TInt dumGpsTocMs  = (TInt) 16383;
+     const TUint dumGpsTocLs = (TUint) 4294967295UL; 
+     const TInt dumRefId     = (TInt) 511;
+     const TInt dumSfn       = (TInt) 4095;
+     
+     gpsTimingData.SetDataType(TGpsTimingMeasurementData::EGpsTimingDataTypeUtran);
+     gpsTimingData.SetNetworkMode(TGpsTimingMeasurementData::ENetworkModeFdd);
+     gpsTimingData.SetGPSTimingOfCellMsPart(dumGpsTocMs);
+     gpsTimingData.SetGPSTimingOfCellLsPart(dumGpsTocLs);
+     gpsTimingData.SetReferenceIdentity(dumRefId);
+     gpsTimingData.SetSfn(dumSfn);
+     
+     gpsMeasurementInfo.SetGpsTimingData(gpsTimingData);
+     
+     TGpsTimingMeasurementData gpsTimingDataReturned;
+     CHECK_EQUAL_(KErrNone, gpsMeasurementInfo.GetGpsTimingData(gpsTimingDataReturned));
+     
+     CHECK_EQUAL_(TGpsTimingMeasurementData::EGpsTimingDataTypeUtran, gpsTimingData.DataType());
+     CHECK_EQUAL_(TGpsTimingMeasurementData::ENetworkModeFdd, gpsTimingData.NetworkMode());
+     CHECK_EQUAL_(dumGpsTocMs, gpsTimingDataReturned.GPSTimingOfCellMsPart());
+     CHECK_EQUAL_(dumGpsTocLs, gpsTimingDataReturned.GPSTimingOfCellLsPart());
+     CHECK_EQUAL_(dumRefId,    gpsTimingDataReturned.ReferenceIdentity());
+     CHECK_EQUAL_(dumSfn,      gpsTimingDataReturned.Sfn());
+     StandardCleanup();
+     }
+
diff -r 7f293ed715ec -r a4835904093b LbsApi/src/genericinfostep.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/src/genericinfostep.cpp	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,1121 @@
+// 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 GenericInfoStep.cpp
+ @internalTechnology
+*/
+#include "genericinfostep.h"
+#include "te_lbsapisuitedefs.h"
+
+#include "lcfsbucommondefinitions.h"
+
+#include <lbs.h>
+#include <lbssatellite.h>
+
+CGenericInfoStep::~CGenericInfoStep()
+/**
+ * Destructor
+ */
+	{
+	}
+
+CGenericInfoStep::CGenericInfoStep()
+/**
+ * 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(KGenericInfoStep);
+	}
+
+TVerdict CGenericInfoStep::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 CGenericInfoStep::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 CGenericInfoStep::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 CGenericInfoStep::StartL (TInt aIndex)
+	{
+	switch (aIndex)
+		{
+	case 0:
+		HPositionGenericInfo_ConstructionL ();
+		break;
+	case 1:
+		HPositionGenericInfo_Construction2L ();
+		break;
+	case 2:
+		HPositionGenericInfo_RequestingL ();
+		break;
+	case 3:
+		HPositionGenericInfo_Requesting2L ();
+		break;
+	case 4:
+		HPositionGenericInfo_GetL ();
+		break;
+	case 5:
+		HPositionGenericInfo_GoodL ();
+		break;
+	case 6:
+		HPositionGenericInfo_MismatchedL ();
+		break;
+	case 7:
+		HPositionGenericInfo_HBufCL ();
+		break;
+	case 8:
+		HPositionGenericInfo_BufferL ();
+		break;
+	case 9:
+		HPositionGenericInfo_FieldsL ();
+		break;
+	case 10:
+		HPositionGenericInfo_OverflowL ();
+		break;
+	case 11:
+		HPositionGenericInfo_SetL ();
+		break;
+	default:
+		break;
+
+		}
+	}
+
+
+
+
+//
+//
+// HPositionGenericInfo
+//
+//  Construction
+//
+//
+
+// 3.2.1. Construction
+void CGenericInfoStep::HPositionGenericInfo_ConstructionL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+
+    HPositionGenericInfo *genInfo, *genInfoL, *genInfoLC, *genInfoDef;
+    const TInt KBufSize = 8;
+    const TInt KMaxFields = 2;
+
+    __UHEAP_MARK;
+
+    genInfo     = HPositionGenericInfo::New(KBufSize, KMaxFields);
+    genInfoL    = HPositionGenericInfo::NewL(KBufSize, KMaxFields);
+    genInfoLC   = HPositionGenericInfo::NewLC(KBufSize, KMaxFields);
+    genInfoDef  = HPositionGenericInfo::New();
+
+    __UHEAP_MARK;
+
+    //check genInfo not NULL
+    CHECK(genInfo);
+    CHECK(genInfoL);
+    CHECK(genInfoLC);
+    CHECK(genInfoDef);
+
+    // position class
+    CHECK(genInfo->PositionClassType() == (EPositionInfoClass|EPositionGenericInfoClass));
+    CHECK(genInfo->PositionClassSize() >= sizeof(HPositionGenericInfo) + KBufSize + KMaxFields);
+
+    CHECK(genInfoL->PositionClassType() == (EPositionInfoClass|EPositionGenericInfoClass));
+    CHECK(genInfoL->PositionClassSize() >= sizeof(HPositionGenericInfo) + KBufSize + KMaxFields);
+
+    CHECK(genInfoLC->PositionClassType() == (EPositionInfoClass|EPositionGenericInfoClass));
+    CHECK(genInfoLC->PositionClassSize() >= sizeof(HPositionGenericInfo) + KBufSize + KMaxFields);
+
+    CHECK(genInfoDef->PositionClassType() == (EPositionInfoClass|EPositionGenericInfoClass));
+    CHECK(genInfoDef->PositionClassSize() >= sizeof(HPositionGenericInfo) + KBufSize + KMaxFields);
+
+    // sizes
+    CHECK(genInfo->BufferSize() == KBufSize);
+    CHECK(genInfo->MaxFields() == KMaxFields);
+
+    CHECK(genInfoL->BufferSize() == KBufSize);
+    CHECK(genInfoL->MaxFields() == KMaxFields);
+
+    CHECK(genInfoLC->BufferSize() == KBufSize);
+    CHECK(genInfoLC->MaxFields() == KMaxFields);
+
+    CHECK(genInfoDef->BufferSize() == KPositionGenericInfoDefaultBufferSize);
+    CHECK(genInfoDef->MaxFields() == KPositionGenericInfoDefaultMaxFields);
+    CHECK_EQUAL_(KPositionGenericInfoDefaultBufferSize,  genInfoDef->BufferSize());
+    CHECK_EQUAL_(KPositionGenericInfoDefaultMaxFields,   genInfoDef->MaxFields());
+
+    // requested fields
+    for(TUint16 i=EPositionFieldNone; i<EPositionFieldIdLast; i++)
+    	{
+        CHECK(!genInfo->IsRequestedField(i));
+        CHECK(!genInfoL->IsRequestedField(i));
+        CHECK(!genInfoLC->IsRequestedField(i));
+        CHECK(!genInfoDef->IsRequestedField(i));
+    	}
+    // data fields
+    for(TUint16 j=EPositionFieldNone; j<EPositionFieldIdLast; j++)
+    	{
+        CHECK(!genInfo->IsFieldAvailable(j));
+        CHECK(!genInfoL->IsFieldAvailable(j));
+        CHECK(!genInfoLC->IsFieldAvailable(j));
+        CHECK(!genInfoDef->IsFieldAvailable(j));
+    	}
+    // field ids
+    CHECK_EQUAL_(genInfo->FirstRequestedFieldId(), TPositionFieldId(EPositionFieldNone));
+    CHECK_EQUAL_(genInfoL->FirstRequestedFieldId(), TPositionFieldId(EPositionFieldNone));
+    CHECK_EQUAL_(genInfoLC->FirstRequestedFieldId(), TPositionFieldId(EPositionFieldNone));
+    CHECK_EQUAL_(genInfoDef->FirstRequestedFieldId(), TPositionFieldId(EPositionFieldNone));
+    for(TUint16 k = EPositionFieldNone; k < EPositionFieldIdLast; k++)
+    	{
+        CHECK_EQUAL_(genInfo->NextRequestedFieldId(k), TPositionFieldId(EPositionFieldNone));
+        CHECK_EQUAL_(genInfoL->NextRequestedFieldId(k), TPositionFieldId(EPositionFieldNone));
+        CHECK_EQUAL_(genInfoLC->NextRequestedFieldId(k), TPositionFieldId(EPositionFieldNone));
+        CHECK_EQUAL_(genInfoDef->NextRequestedFieldId(k), TPositionFieldId(EPositionFieldNone));
+    	}
+
+    __UHEAP_MARKEND;
+
+    delete genInfo;
+    delete genInfoL;
+    CleanupStack::PopAndDestroy(genInfoLC);
+    delete genInfoDef;
+
+    __UHEAP_MARKEND;
+
+    StandardCleanup();
+	}
+
+
+// 3.2.2. NoMemory
+// see NoMemoryTests.cpp
+
+// 3.2.3 Invalid sizes
+struct THPGIdata
+    {
+    TInt defBufSize;
+    TInt defMaxFields;
+    };
+
+TInt Construction_New_Invalid(TAny* aPtr)
+	{
+    THPGIdata& data = *(static_cast<THPGIdata*>(aPtr));
+    HPositionGenericInfo* posInfo = HPositionGenericInfo::New(data.defBufSize, data.defMaxFields);
+    delete posInfo;
+    return KErrGeneral;
+	}
+
+
+TInt Construction_NewL_Invalid(TAny* aPtr)
+	{
+    THPGIdata& data = *(static_cast<THPGIdata*>(aPtr));
+    HPositionGenericInfo* posInfo = NULL;
+    TInt err;
+    TRAP(err, posInfo = HPositionGenericInfo::NewL(data.defBufSize, data.defMaxFields));
+    delete posInfo;
+    return KErrGeneral;
+	}
+
+
+TInt Construction_NewLC_Invalid(TAny* aPtr)
+	{
+    THPGIdata& data = *(static_cast<THPGIdata*>(aPtr));
+    TInt err;
+    TRAP(err, 
+        HPositionGenericInfo* posInfo = HPositionGenericInfo::NewLC(data.defBufSize, data.defMaxFields);
+        CleanupStack::PopAndDestroy(posInfo);
+        );
+    return KErrGeneral;
+	}
+
+#define TEST_CONSTRUCTION_NEW_INVALID(aPanicReason, aData)              \
+        DO_PANIC_TEST_L_PTR(Construction_New_Invalid, KPosClientFault,   \
+                aPanicReason, KDefaultTestTimeout, aData);
+
+#define TEST_CONSTRUCTION_NEWL_INVALID(aPanicReason, aData)             \
+        DO_PANIC_TEST_L_PTR(Construction_NewL_Invalid, KPosClientFault,  \
+                aPanicReason, KDefaultTestTimeout, aData);
+
+#define TEST_CONSTRUCTION_NEWLC_INVALID(aPanicReason, aData)            \
+        DO_PANIC_TEST_L_PTR(Construction_NewLC_Invalid, KPosClientFault, \
+                aPanicReason, KDefaultTestTimeout, aData);
+
+void CGenericInfoStep::HPositionGenericInfo_Construction2L()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+
+    THPGIdata data;
+
+    // zero max fields
+    data.defBufSize = 1;
+    data.defMaxFields = 0;
+    TEST_CONSTRUCTION_NEW_INVALID(EPositionGenericInfoZeroMaxFields, &data);
+    TEST_CONSTRUCTION_NEWL_INVALID(EPositionGenericInfoZeroMaxFields, &data);
+    TEST_CONSTRUCTION_NEWLC_INVALID(EPositionGenericInfoZeroMaxFields, &data);
+
+    // negative max fields
+    data.defBufSize = 1;
+    data.defMaxFields = -1;
+    TEST_CONSTRUCTION_NEW_INVALID(EPositionGenericInfoZeroMaxFields, &data);
+    TEST_CONSTRUCTION_NEWL_INVALID(EPositionGenericInfoZeroMaxFields, &data);
+    TEST_CONSTRUCTION_NEWLC_INVALID(EPositionGenericInfoZeroMaxFields, &data);
+
+    // zero buffer
+    data.defBufSize = 0;
+    data.defMaxFields = 1;
+    TEST_CONSTRUCTION_NEW_INVALID(EPositionGenericInfoZeroBufferSize, &data);
+    TEST_CONSTRUCTION_NEWL_INVALID(EPositionGenericInfoZeroBufferSize, &data);
+    TEST_CONSTRUCTION_NEWLC_INVALID(EPositionGenericInfoZeroBufferSize, &data);
+
+    // negative buffer
+    data.defBufSize = -1;
+    data.defMaxFields = 1;
+    TEST_CONSTRUCTION_NEW_INVALID(EPositionGenericInfoZeroBufferSize, &data);
+    TEST_CONSTRUCTION_NEWL_INVALID(EPositionGenericInfoZeroBufferSize, &data);
+    TEST_CONSTRUCTION_NEWLC_INVALID(EPositionGenericInfoZeroBufferSize, &data);
+
+    StandardCleanup();
+	}
+
+
+//
+//
+// HPositionGenericInfo
+//
+//  Requesting Fields
+//
+//
+
+// 3.3.1. Requesting Fields, ony-by-one
+void CGenericInfoStep::HPositionGenericInfo_RequestingL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+
+    __UHEAP_MARK;
+
+    HPositionGenericInfo* genInfo = HPositionGenericInfo::NewL();
+    TUint maxField = genInfo->MaxFields();
+
+    __UHEAP_MARK;
+
+    // request
+    CHECK_EQUAL_(KErrNone,           genInfo->SetRequestedField(TPositionFieldId(EPositionFieldNone-1))); // just very big value
+    CHECK_EQUAL_(KErrArgument,       genInfo->SetRequestedField(EPositionFieldNone));
+    CHECK_EQUAL_(EPositionFieldNone, genInfo->NextRequestedFieldId(TPositionFieldId(EPositionFieldNone-1)));
+
+    TUint i = 0;
+    for(i = EPositionFieldNone + 1; i < maxField; i++) // first is EPositionFieldNone-1
+    	{
+        CHECK_EQUAL_(KErrNone,       genInfo->SetRequestedField(TPositionFieldId(i)));
+    	}
+    CHECK_EQUAL_(KErrNone,           genInfo->SetRequestedField(TPositionFieldId(i-1))); // double setting doesn't fail
+    CHECK_EQUAL_(KErrOverflow,       genInfo->SetRequestedField(TPositionFieldId(maxField + 1)));
+
+    // check requested
+    CHECK(genInfo->IsRequestedField(TPositionFieldId(EPositionFieldNone - 1)));
+    CHECK(!genInfo->IsRequestedField(EPositionFieldNone));
+    for(i = EPositionFieldNone + 1; i < maxField; i++)  // first is EPositionFieldNone-1
+    	{
+        CHECK(genInfo->IsRequestedField(TPositionFieldId(i)));
+    	}
+    CHECK(!genInfo->IsRequestedField(TPositionFieldId(maxField + 1)));
+
+    // enumerate requested fields
+    TUint fieldsCount = 0;
+    for(TPositionFieldId field = genInfo->FirstRequestedFieldId();
+        field > EPositionFieldNone;
+        field = genInfo->NextRequestedFieldId(field))
+    	{
+        CHECK(genInfo->IsRequestedField(field));
+        fieldsCount++;
+    	}
+    CHECK(fieldsCount == maxField); // check count here
+
+    // clear all
+    genInfo->ClearRequestedFields();
+
+    CHECK_EQUAL_(EPositionFieldNone, genInfo->FirstRequestedFieldId());
+
+    for(i = EPositionFieldNone + 1; i < maxField + 1; i++)
+    	{
+        CHECK(!genInfo->IsRequestedField(TPositionFieldId(i)));
+        CHECK_EQUAL_(EPositionFieldNone, genInfo->NextRequestedFieldId(TPositionFieldId(i)));
+    	}
+
+    __UHEAP_MARKEND;
+
+    delete genInfo;
+
+    __UHEAP_MARKEND;
+
+    StandardCleanup();
+	}
+
+
+// 3.3.2 Requesting Array of fields
+void CGenericInfoStep::HPositionGenericInfo_Requesting2L()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+
+    __UHEAP_MARK;
+    HPositionGenericInfo* genInfo = HPositionGenericInfo::NewL();
+    TUint maxField = genInfo->MaxFields();
+    __UHEAP_MARK;
+
+    TPositionFieldId* fieldIds = new TPositionFieldId [maxField + 2];
+    TPositionFieldId fid = 0;
+    for (fid = 0; fid <= maxField; fid++)
+    	{
+        fieldIds[fid] = TPositionFieldId(fid + 1);
+    	};
+    fieldIds[maxField + 1] = EPositionFieldNone; // 1, 2, 3, 4, 5, ...  31,32,33,EPositionFieldNone
+
+    CHECK_EQUAL_(KErrOverflow, genInfo->SetRequestedFields(fieldIds));
+    fieldIds[maxField] = EPositionFieldNone; // 32 is replaced with EPositionFieldNone
+    // now it should work
+    CHECK_EQUAL_(KErrNone, genInfo->SetRequestedFields(fieldIds));
+
+    // check requested
+    CHECK(!genInfo->IsRequestedField(TPositionFieldId(EPositionFieldNone-1)));
+    CHECK(!genInfo->IsRequestedField(EPositionFieldNone));
+    CHECK_EQUAL_(EPositionFieldNone, genInfo->NextRequestedFieldId(TPositionFieldId(EPositionFieldNone-1)));
+    for(fid = EPositionFieldNone + 1; fid < maxField + 1; fid++)
+    	{
+        CHECK(genInfo->IsRequestedField(fid));
+    	}
+    CHECK(!genInfo->IsRequestedField(TPositionFieldId(maxField + 1)));
+    CHECK_EQUAL_(EPositionFieldNone, genInfo->NextRequestedFieldId(TPositionFieldId(maxField + 1)));
+
+    // enumerate requested fields
+    TUint fieldsCount = 0;
+    for(TPositionFieldId field = genInfo->FirstRequestedFieldId();
+        field > EPositionFieldNone;
+        field = genInfo->NextRequestedFieldId(field))
+    	{
+        CHECK(genInfo->IsRequestedField(field));
+        fieldsCount++;
+    	}
+    CHECK(fieldsCount == maxField); // check count here
+
+    // clear all
+    genInfo->ClearRequestedFields();
+
+    CHECK_EQUAL_(EPositionFieldNone, genInfo->FirstRequestedFieldId());
+
+    for(fid = EPositionFieldNone + 1; fid < maxField + 1; fid++)
+    	{
+        CHECK(!genInfo->IsRequestedField(fid));
+        CHECK_EQUAL_(EPositionFieldNone, genInfo->NextRequestedFieldId(fid));
+    	}
+
+    delete fieldIds;
+    __UHEAP_MARKEND;
+    delete genInfo;
+    __UHEAP_MARKEND;
+
+    StandardCleanup();
+	}
+
+
+// 3.3.3 NextRequestedField for unrequested
+// Implemented as part of 3.3.1 and 3.3.2
+
+//
+//
+// HPositionGenericInfo
+//
+//  Field Data
+//
+//
+
+
+// 3.4.1 Get/SetValue
+void CGenericInfoStep::HPositionGenericInfo_GetL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+
+    // SetData, Check data Availablity, Get, Check Data, Clear,
+    // Check data unAvailability
+
+    __UHEAP_MARK;
+
+    HPositionGenericInfo* genInfo = HPositionGenericInfo::NewL();
+
+    const TUint8 testUint8 = 0x25;									//Id == 1
+    const TUint16 testUint16 = 0x9811;								//Id == 2
+    const TUint32 testUint32 = 0xDEADBEEF;							//Id == 3
+    const TInt8 testInt8 = 23;										//Id == 4
+    const TInt16 testInt16 = 3452;									//Id == 5
+    const TInt32 testInt32 = 2345234;								//Id == 6
+    const TInt64 testInt64(0x0EAEFACEBEEFFACELL);					//Id == 7
+    const TReal32 testReal32 = TReal32(34.123);						//Id == 8
+    const TReal64 testReal64 = 3425.1234;							//Id == 9
+    const TTimeIntervalMicroSeconds testTimeInterval(TInt64(2345));	//Id == 10
+    const TTime testTime(TInt64(2345756));							//Id == 11
+    _LIT8(KEightBitDes, "Hello to all you lovely people.");			//Id == 12
+    _LIT16(KUnicodeDes, "Who likes a bit of Heavy Metal?");			//Id == 13
+
+    // Add Data
+
+    __UHEAP_MARK;
+
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(1, testUint8));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(2, testUint16));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(3, testUint32));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(4, testInt8));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(5, testInt16));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(6, testInt32));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(7, testInt64));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(8, testReal32));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(9, testReal64));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(10, testTimeInterval));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(11, testTime));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(12, KEightBitDes));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(13, KUnicodeDes));
+
+    // check that set fields are available ...
+    for(TUint16 i=1; i<14; i++)
+        {
+        CHECK(genInfo->IsFieldAvailable(i));
+        }
+    // ... and unset are not
+    for(TUint16 j=14; j<genInfo->MaxFields(); j++)
+        {
+        CHECK(!genInfo->IsFieldAvailable(j));
+        }
+
+    TUint8 checkUint8;
+    TUint16 checkUint16;
+    TUint32 checkUint32;
+    TInt8 checkInt8;
+    TInt16 checkInt16;
+    TInt32 checkInt32;
+    TInt64 checkInt64;
+    TReal32 checkReal32;
+    TReal64 checkReal64;
+    TTimeIntervalMicroSeconds checkTimeInterval;
+    TTime checkTime;
+    //Descriptors - test with TPrtC and TBuf objects.
+    TPtrC8 ptr8;
+    TBuf8<48> buf8;
+    TPtrC16 ptr16;
+    TBuf16<48> buf16;
+
+    // Check that data is available in fact
+
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(1, checkUint8));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(2, checkUint16));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(3, checkUint32));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(4, checkInt8));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(5, checkInt16));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(6, checkInt32));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(7, checkInt64));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(8, checkReal32));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(9, checkReal64));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(10, checkTimeInterval));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(11, checkTime));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(12, ptr8));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(12, buf8));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(13, ptr16));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(13, buf16));
+
+    // check data is returned correctly
+
+    CHECK_EQUAL_(testUint8, checkUint8);
+    CHECK_EQUAL_(testUint16, checkUint16);
+    CHECK_EQUAL_(testUint32, checkUint32);
+    CHECK_EQUAL_(testInt8, checkInt8);
+    CHECK_EQUAL_(testInt16, checkInt16);
+    CHECK_EQUAL_(testInt32, checkInt32);
+    CHECK_EQUAL_(testInt64, checkInt64);
+    CHECK_REAL_EQUAL(checkReal32, testReal32);
+    CHECK_REAL_EQUAL(checkReal64, testReal64);
+    CHECK(testTimeInterval == checkTimeInterval);
+    CHECK(testTime == checkTime);
+    CHECK(!ptr8.Compare(KEightBitDes));
+    CHECK(!buf8.Compare(KEightBitDes));
+    CHECK(!ptr16.Compare(KUnicodeDes));
+    CHECK(!buf16.Compare(KUnicodeDes));
+
+    //Do some checks for bad ids.
+    CHECK_EQUAL_(KErrArgument, genInfo->SetValue(EPositionFieldNone, TUint8(1)));
+    CHECK_EQUAL_(KErrArgument, genInfo->GetValue(EPositionFieldNone, checkInt8));
+
+    // Clear Data
+    genInfo->ClearPositionData();
+    __UHEAP_MARKEND;
+
+    // check that fields are not available any more
+    for(TUint16 k=1; k<genInfo->MaxFields(); k++)
+    	{
+        CHECK(!genInfo->IsFieldAvailable(k));
+    	}
+
+    // check that values are not available any more
+
+    CHECK_EQUAL_(KErrNotFound, genInfo->GetValue(1, checkUint8));
+    CHECK_EQUAL_(KErrNotFound, genInfo->GetValue(2, checkUint16));
+    CHECK_EQUAL_(KErrNotFound, genInfo->GetValue(3, checkUint32));
+    CHECK_EQUAL_(KErrNotFound, genInfo->GetValue(4, checkInt8));
+    CHECK_EQUAL_(KErrNotFound, genInfo->GetValue(5, checkInt16));
+    CHECK_EQUAL_(KErrNotFound, genInfo->GetValue(6, checkInt32));
+    CHECK_EQUAL_(KErrNotFound, genInfo->GetValue(7, checkInt64));
+    CHECK_EQUAL_(KErrNotFound, genInfo->GetValue(8, checkReal32));
+    CHECK_EQUAL_(KErrNotFound, genInfo->GetValue(9, checkReal64));
+    CHECK_EQUAL_(KErrNotFound, genInfo->GetValue(10, checkTimeInterval));
+    CHECK_EQUAL_(KErrNotFound, genInfo->GetValue(11, checkTime));
+    CHECK_EQUAL_(KErrNotFound, genInfo->GetValue(12, ptr8));
+    CHECK_EQUAL_(KErrNotFound, genInfo->GetValue(12, buf8));
+    CHECK_EQUAL_(KErrNotFound, genInfo->GetValue(13, ptr16));
+    CHECK_EQUAL_(KErrNotFound, genInfo->GetValue(13, buf16));
+
+    delete genInfo;
+    __UHEAP_MARKEND;
+
+    StandardCleanup();
+	}
+
+
+// 3.4.2 Check Overflow doesn't harm existing data
+#define CHECK_GOOD_OVERFLOW(type, val1, val2)                   \
+	{                                                               \
+    __UHEAP_MARK;                                               \
+    HPositionGenericInfo* genInfo =                             \
+            HPositionGenericInfo::NewL(sizeof(type));           \
+    __UHEAP_MARK;                                               \
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(1, type(val1)));    \
+    CHECK(genInfo->IsFieldAvailable(1));                        \
+    CHECK_EQUAL_(KErrPositionBufferOverflow, genInfo->SetValue(2, type(val2)));\
+    CHECK(genInfo->IsFieldAvailable(1));                        \
+    CHECK(!genInfo->IsFieldAvailable(2));                       \
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(1, type(val2)));    \
+    CHECK(genInfo->IsFieldAvailable(1));                        \
+    type var;                                                   \
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(1, var));           \
+    CHECK(var == type(val2));                                   \
+    __UHEAP_MARKEND;                                            \
+    delete genInfo;                                             \
+    __UHEAP_MARKEND;                                            \
+	}
+
+
+void CGenericInfoStep::HPositionGenericInfo_GoodL()
+	{
+    // we create a buffer with size precisely of size of tested
+    // data type.
+    // Then a value1 of this type is added to info. No error
+    // Another value2 of same type is added - overflow.
+    // check that value1 is available, value2 - is not
+    // Reset field1 with value2, check it is available and correct
+
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+
+    CHECK_GOOD_OVERFLOW(TInt8, 1, 2);
+    CHECK_GOOD_OVERFLOW(TInt16, 1, 2);
+    CHECK_GOOD_OVERFLOW(TInt32, 1, 2);
+    CHECK_GOOD_OVERFLOW(TInt64, 1, 2);
+    CHECK_GOOD_OVERFLOW(TUint8, 1, 2);
+    CHECK_GOOD_OVERFLOW(TUint16, 1, 2);
+    CHECK_GOOD_OVERFLOW(TUint32, 1, 2);
+    CHECK_GOOD_OVERFLOW(TReal32, 1, 2);
+    CHECK_GOOD_OVERFLOW(TReal64, 1, 2);
+    CHECK_GOOD_OVERFLOW(TTime, 1, 2);
+    CHECK_GOOD_OVERFLOW(TTimeIntervalMicroSeconds, 1, 2);
+
+    // a bit different for descriptors
+    // TBuf for descriptors
+    TBufC8<1> buf81(_L8("1"));
+    TBufC8<1> buf82(_L8("2"));
+    TBufC16<1> buf161(_L16("1"));
+    TBufC16<1> buf162(_L16("2"));
+
+    //CHECK_GOOD_OVERFLOW(TDesC8, buf81, buf82);
+    	{
+        __UHEAP_MARK;
+        HPositionGenericInfo* genInfo = HPositionGenericInfo::NewL(sizeof(buf81));
+        __UHEAP_MARK;
+        CHECK_EQUAL_(KErrNone, genInfo->SetValue(1, buf81));
+        CHECK(genInfo->IsFieldAvailable(1));
+        CHECK_EQUAL_(KErrPositionBufferOverflow, genInfo->SetValue(2, buf82));
+        CHECK(genInfo->IsFieldAvailable(1));
+        CHECK(!genInfo->IsFieldAvailable(2));
+        CHECK_EQUAL_(KErrNone, genInfo->SetValue(1, buf82));
+        CHECK(genInfo->IsFieldAvailable(1));
+        TBuf8<256> var;
+        CHECK_EQUAL_(KErrNone, genInfo->GetValue(1, var));
+        CHECK(var == buf82);
+        __UHEAP_MARKEND;
+        delete genInfo;
+        __UHEAP_MARKEND;
+    	}
+
+    //CHECK_GOOD_OVERFLOW(TDesC16, buf161, buf162);
+    	{
+        __UHEAP_MARK;
+        HPositionGenericInfo* genInfo = HPositionGenericInfo::NewL(sizeof(buf161));
+        __UHEAP_MARK;
+        CHECK_EQUAL_(KErrNone, genInfo->SetValue(1, buf161));
+        CHECK(genInfo->IsFieldAvailable(1));
+        CHECK_EQUAL_(KErrPositionBufferOverflow, genInfo->SetValue(2, buf162));
+        CHECK(genInfo->IsFieldAvailable(1));
+        CHECK(!genInfo->IsFieldAvailable(2));
+        CHECK_EQUAL_(KErrNone, genInfo->SetValue(1, buf162));
+        CHECK(genInfo->IsFieldAvailable(1));
+        TBuf16<256> var;
+        CHECK_EQUAL_(KErrNone, genInfo->GetValue(1, var));
+        CHECK(var == buf162);
+        __UHEAP_MARKEND;
+        delete genInfo;
+        __UHEAP_MARKEND;
+    	}
+
+    StandardCleanup();
+	}
+
+
+// 3.4.3 Mismatched data types
+TInt Do_Mismatched_Data_Types1(TAny* /*aPtr*/)
+	{
+    HPositionGenericInfo* posInfo = HPositionGenericInfo::New();
+    if(posInfo==NULL)
+            return KErrGeneral;        //Failure will get picked up.
+    if(posInfo->SetValue(1, TUint8(12))!=KErrNone)
+    	{
+        delete posInfo;
+        return KErrGeneral;
+    	}
+    TBuf<10> buf;
+    (void)posInfo->GetValue(1, buf);        //This line should panic. We ignore error, since failure gets picked up.
+    delete posInfo;
+    return KErrGeneral;
+	}
+
+
+void CGenericInfoStep::HPositionGenericInfo_MismatchedL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+
+    DO_PANIC_TEST_L(Do_Mismatched_Data_Types1, KPosClientFault,
+            EPositionGenericInfoMismatchDataType, KDefaultTestTimeout);
+
+    StandardCleanup();
+	}
+
+
+// 3.4.4 Test HBufC
+void CGenericInfoStep::HPositionGenericInfo_HBufCL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+
+    HBufC* hbuf = HBufC::NewL(256);
+    const TBuf<20> bufdata(_L("HBufC"));
+    *hbuf = (TDesC&)bufdata;
+
+    __UHEAP_MARK;
+    HPositionGenericInfo* genInfo = HPositionGenericInfo::NewL(sizeof(*hbuf) + hbuf->Size());
+    __UHEAP_MARK;
+
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(1, *hbuf));
+    CHECK(genInfo->IsFieldAvailable(1));
+    CHECK_EQUAL_(KErrPositionBufferOverflow, genInfo->SetValue(2, *hbuf));
+    CHECK(genInfo->IsFieldAvailable(1));
+    CHECK(!genInfo->IsFieldAvailable(2));
+
+    TBuf<20> newbuf;
+    // load again
+    CHECK(KErrNone == genInfo->GetValue(1, newbuf));
+    CHECK(newbuf == bufdata);
+
+    __UHEAP_MARKEND;
+    delete genInfo;
+    __UHEAP_MARKEND;
+
+    delete hbuf;
+
+    StandardCleanup();
+	}
+
+
+// 3.4.5 Buffer refill
+void CGenericInfoStep::HPositionGenericInfo_BufferL()
+	{
+    // Fill the buffer fully and refill it again, from last element to first one,
+    // in both cases set values from one with lowest size to biggest
+    // No overflow should be generated
+
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+
+    const TInt8 int8 = 23;									//Id == 1
+    const TUint8 uint8 = 0x25;								//Id == 2
+    const TInt16 int16 = 3452;								//Id == 3
+    const TUint16 uint16 = 0x9811;							//Id == 4
+    const TInt32 int32 = 2345234;							//Id == 5
+    const TUint32 uint32 = 0xDEADBEEF;						//Id == 6
+    const TReal32 real32 = TReal32(34.123);					//Id == 7
+    const TInt64 int64(0x0EAEFACEBEEFFACELL);				//Id == 8
+    const TReal64 real64 = 3425.1234;						//Id == 9
+    const TTimeIntervalMicroSeconds interval(TInt64(2345));	//Id == 10
+    const TTime time(TInt64(2345756));						//Id == 11
+
+    // calculate size
+    TUint size =
+        sizeof(int8) + sizeof(int16) + sizeof(int32) + sizeof(int64) +
+        sizeof(uint8) + sizeof(uint16) + sizeof(uint32) +
+        sizeof(real32) + sizeof(real64) +
+        sizeof(time) + sizeof(interval);
+
+    // create buffer
+    __UHEAP_MARK;
+    HPositionGenericInfo* genInfo = HPositionGenericInfo::NewL(size);
+    __UHEAP_MARK;
+
+    // fill with data. Note the sequence
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(1, int8));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(2, uint8));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(3, int16));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(4, uint16));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(5, int32));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(6, uint32));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(7, real32));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(8, int64));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(9, real64));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(10, interval));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(11, time));
+
+    // check that there is no more space
+    CHECK_EQUAL_(KErrPositionBufferOverflow, genInfo->SetValue(12, int8));
+
+    // check all are set
+    for(TUint16 i = 1; i < 12; i++)
+    {
+        CHECK(genInfo->IsFieldAvailable(i));
+    }
+    // check that 12th field is not really added
+    CHECK(!genInfo->IsFieldAvailable(12));
+
+    // now fill in reverse sequence
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(11, int8));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(10, uint8));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(9, int16));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(8, uint16));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(7, int32));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(6, uint32));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(5, real32));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(4, int64));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(3, real64));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(2, interval));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(1, time));
+
+    // check that there is no more space again
+    CHECK_EQUAL_(KErrPositionBufferOverflow, genInfo->SetValue(12, int8));
+
+    // Note, that no Overflow error must be generated
+    // because every time a field is replaced with value
+    // that is of less or same size that is stored in the field!!!
+
+    // check all are set
+    for(TUint16 j = 1; j < 12; j++)
+    {
+        CHECK(genInfo->IsFieldAvailable(j));
+    }
+    // except last one
+    CHECK(!genInfo->IsFieldAvailable(12));
+
+    // read and check them
+    TInt8 tint8;
+    TUint8 tuint8;
+    TInt16 tint16;
+    TUint16 tuint16;
+    TInt32 tint32;
+    TUint32 tuint32;
+    TReal32 treal32;
+    TInt64 tint64;
+    TReal64 treal64;
+    TTimeIntervalMicroSeconds tinterval;
+    TTime ttime;
+
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(11, tint8));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(10, tuint8));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(9, tint16));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(8, tuint16));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(7, tint32));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(6, tuint32));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(5, treal32));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(4, tint64));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(3, treal64));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(2, tinterval));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(1, ttime));
+
+    CHECK_EQUAL_(tint8, int8);
+    CHECK_EQUAL_(tuint8, uint8);
+    CHECK_EQUAL_(tint16, int16);
+    CHECK_EQUAL_(tuint16, uint16);
+    CHECK_EQUAL_(tint32, int32);
+    CHECK_EQUAL_(tuint32, uint32);
+    CHECK_EQUAL_(treal32, real32);
+    CHECK_EQUAL_(tint64, int64);
+    CHECK_EQUAL_(treal64, real64);
+    CHECK_EQUAL_(tinterval, interval);
+    CHECK_EQUAL_(ttime, time);
+
+    genInfo->ClearPositionData();
+
+    __UHEAP_MARKEND;
+    delete genInfo;
+    __UHEAP_MARKEND;
+
+    StandardCleanup();
+	}
+
+
+// 3.4.6 Buffer refill 2
+void CGenericInfoStep::HPositionGenericInfo_FieldsL()
+	{
+    // Allocate 8-byte buffer. Insert 1-byte value, 2-bytes value
+    // and 4-bytes value. 1 byte remains free.
+    // Replace second field (2-bytes) with 1-byte value.
+    // No 2 bytes free.
+    // Put 2-bytes value to the end of buffer. There is place certainly.
+    // Will there right reallocation be done? Check availability and values
+
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+
+    const TInt8     f8 = 1;        //Id == 1
+    const TInt16    f16 = 2;       //Id == 2
+    const TInt32    f32 = 3;       //Id == 3
+    const TInt8     newf16 = 5;    //Id == 2/2
+    const TInt16    f8_2 = 4;      //Id == 4
+
+    // calculate size
+    TUint size = sizeof(f8) + sizeof(f16) + sizeof(f32); // 7 bytes
+
+    // create buffer
+    __UHEAP_MARK;
+    HPositionGenericInfo* genInfo = HPositionGenericInfo::NewL(size + 1); // 8 bytes
+    __UHEAP_MARK;
+
+    // fill with data. Note the sequence
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(1, f8));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(2, f16));
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(3, f32));
+
+    // check them
+    CHECK(genInfo->IsFieldAvailable(1));
+    CHECK(genInfo->IsFieldAvailable(2));
+    CHECK(genInfo->IsFieldAvailable(3));
+
+    // replace second one
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(2, newf16)); // 2 bytes free
+    CHECK(genInfo->IsFieldAvailable(2));
+
+    // add 4th field
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(4, f8_2)); // 0 bytes free
+    CHECK(genInfo->IsFieldAvailable(4));
+
+    // 5th ?
+    CHECK_EQUAL_(KErrPositionBufferOverflow, genInfo->SetValue(5, f8_2)); // should fail
+    CHECK(!genInfo->IsFieldAvailable(5));
+
+    // check values
+    TInt8     tf8 = 7;    //Id == 1
+    TInt8     tf16 = 7;   //Id == 2
+    TInt32    tf32 = 7;   //Id == 3
+    TInt16    tf8_2 = 7;  //Id == 4
+
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(1, tf8));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(2, tf16));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(3, tf32));
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(4, tf8_2));
+
+    CHECK(tf8 == f8);
+    CHECK(tf16 == newf16);
+    CHECK(tf32 == f32);
+    CHECK(tf8_2 == f8_2);
+
+    genInfo->ClearPositionData();
+
+    __UHEAP_MARKEND;
+    delete genInfo;
+    __UHEAP_MARKEND;
+
+    // Here we do another test. Emulate situation
+    // when even compression doesn't help
+    // (the test is discovered after using CTC++)
+
+    __UHEAP_MARK;
+    genInfo = HPositionGenericInfo::NewL(5); // 5 bytes
+    __UHEAP_MARK;
+
+    // add fields
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(1, TUint8(1)));     // values are equal to
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(2, TUint16(2)));    // field indices
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(3, TUint8(3))); // one byte remains free
+    // check them
+    CHECK(genInfo->IsFieldAvailable(1));
+    CHECK(genInfo->IsFieldAvailable(2));
+    CHECK(genInfo->IsFieldAvailable(3));
+
+    // free one byte in the middle
+    CHECK_EQUAL_(KErrNone, genInfo->SetValue(2, TUint8(2)));
+    // now 2 bytes available
+    // add 4 bytes still
+    CHECK_EQUAL_(KErrPositionBufferOverflow, genInfo->SetValue(2, TUint32(4)));
+
+    TUint8 testUint = 0;
+    // check all is ok still
+    // ... and other two fields
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(1, testUint));
+    CHECK(testUint == 1);
+    CHECK_EQUAL_(KErrNone, genInfo->GetValue(3, testUint));
+    CHECK(testUint == 3);
+
+    genInfo->ClearPositionData();
+
+    __UHEAP_MARKEND;
+    delete genInfo;
+    __UHEAP_MARKEND;
+
+    StandardCleanup();
+	}
+
+// 3.4.7 Descriptors overflow
+void CGenericInfoStep::HPositionGenericInfo_OverflowL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+
+    HPositionGenericInfo* genInfo = HPositionGenericInfo::NewL();
+
+    // Byte
+    _LIT8(KBigNarrowDes, "The universe is estimated to be approx 13Gyr old");
+    TBuf8<10> smallNarrowBuf;
+    smallNarrowBuf.SetLength(5);
+
+    genInfo->SetValue(1, KBigNarrowDes);
+
+    CHECK_EQUAL_(5, smallNarrowBuf.Length());
+    CHECK_EQUAL_(KErrOverflow, genInfo->GetValue(1, smallNarrowBuf));
+    CHECK_EQUAL_(0, smallNarrowBuf.Length());
+
+    // Unicode
+    _LIT16(KBigUnicodeDes, "There is a greater mass of ants than of humans on earth");
+    TBuf16<10> smallUnicodeBuf;
+    smallUnicodeBuf.SetLength(5);
+
+    genInfo->SetValue(1, KBigUnicodeDes);
+
+    CHECK_EQUAL_(5, smallUnicodeBuf.Length());
+    CHECK_EQUAL_(KErrOverflow, genInfo->GetValue(1, smallUnicodeBuf));
+    CHECK_EQUAL_(0, smallUnicodeBuf.Length());
+
+    delete genInfo;
+
+    StandardCleanup();
+	}
+
+// 3.4.8 Set too many fields
+void CGenericInfoStep::HPositionGenericInfo_SetL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+
+    __UHEAP_MARK;
+    HPositionGenericInfo* genInfo = HPositionGenericInfo::NewL(0x40);
+    __UHEAP_MARK;
+
+    for(TUint16 i = 1; i < genInfo->MaxFields() + 1; i++)
+    	{
+        CHECK_EQUAL_(KErrNone, genInfo->SetValue(TPositionFieldId(i), TUint8(i)));
+    	}
+    CHECK_EQUAL_(KErrOverflow, genInfo->SetValue(
+    TPositionFieldId(genInfo->MaxFields() + 1), TUint8(1))); // some value
+
+    // Now check things are ok
+    for (TInt j = 2; j < genInfo->MaxFields() + 1; j++)
+    	{
+    	TUint8 testUint = 0;
+        CHECK_EQUAL_(KErrNone, genInfo->GetValue(TPositionFieldId(j), testUint));
+        CHECK_EQUAL_(j, testUint);
+    	}
+
+    genInfo->ClearPositionData();
+    __UHEAP_MARKEND;
+    delete genInfo;
+    __UHEAP_MARKEND;
+
+    StandardCleanup();
+	}
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();
+	}
+
diff -r 7f293ed715ec -r a4835904093b LbsApi/src/nomemorystep.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/src/nomemorystep.cpp	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,549 @@
+// 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 NoMemoryStep.cpp
+ @internalTechnology
+*/
+#include "nomemorystep.h"
+#include "te_lbsapisuitedefs.h"
+
+#include "lcfsbucommondefinitions.h"
+
+#include <lbs.h>
+#include <lbssatellite.h>
+
+#include <s32mem.h>
+
+CNoMemoryStep::~CNoMemoryStep()
+/**
+ * Destructor
+ */
+	{
+	}
+
+CNoMemoryStep::CNoMemoryStep()
+/**
+ * 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(KNoMemoryStep);
+	}
+
+TVerdict CNoMemoryStep::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 CNoMemoryStep::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 CNoMemoryStep::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 CNoMemoryStep::StartL (TInt aIndex)
+	{
+	switch (aIndex)
+		{
+	case 0:
+		OOM_RPositionServer_Open_NoMemoryL ();
+		break;
+	case 1:
+		OOM_RPositioner_OpenL ();
+		break;
+	case 2:
+		OOM_RPositioner_SetRequestorL ();
+		break;
+	case 3:
+		OOM_CRequestor_ConstructionL ();
+		break;
+	case 4:
+		OOM_CRequestor_SetRequestorL ();
+		break;
+	case 5:
+		OOM_CRequestor_StreamingL ();
+		break;
+	case 6:
+		OOM_RRequestorStack_StreamingL ();
+		break;
+	case 7:
+		OOM_HPositionGenericInfo_ConstructionL ();
+		break;
+	default:
+		break;
+		}
+	}
+
+
+#define DO_OOM_CUSTOMISED_LOOP(aType, aCreationCode, aDeletionCode, aLoopStartCode, aLoopEndCode)  \
+{                                                                            \
+    aType;                                                                   \
+    TInt failureRate;                                                        \
+    TBool doContinue = ETrue;                                                \
+    for (failureRate = 1; doContinue; failureRate++)                         \
+        {                                                                    \
+        aLoopStartCode;                                                      \
+        __UHEAP_SETFAIL(RHeap::EFailNext, failureRate);                      \
+        __UHEAP_MARK;                                                        \
+                                                                             \
+        TInt err;                                                            \
+        TRAP(err, aCreationCode);                                            \
+        if (err != KErrNoMemory)                                             \
+            {                                                                \
+            aDeletionCode;                                                   \
+            doContinue = EFalse;                                             \
+            }                                                                \
+                                                                             \
+        __UHEAP_MARKEND;                                                     \
+        __UHEAP_RESET;                                                       \
+        aLoopEndCode;                                                        \
+        }                                                                    \
+    CHECK( failureRate > 2 );                                                \
+    message.Format(_L("Checked %d allocations in \"%s\""), failureRate-2, L## #aCreationCode); \
+    LOG_DES(message); \
+}
+
+
+#define DO_OOM(aType, aCreationCode, aDeletionCode) \
+    DO_OOM_CUSTOMISED_LOOP(aType, aCreationCode, aDeletionCode, (void) 0, (void) 0)
+
+
+//
+//
+// RPositionServer
+//
+//
+
+//1.1.6 Connect with No Memory
+void CNoMemoryStep::OOM_RPositionServer_Open_NoMemoryL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    RPositionServer server;
+
+    // connect
+    __UHEAP_SETFAIL(RHeap::EFailNext, 1);
+    __UHEAP_MARK;
+    CHECK_EQUAL_(KErrNoMemory, server.Connect());
+    __UHEAP_MARKEND;
+    __UHEAP_RESET;
+
+    StandardCleanup();
+	}
+
+
+//
+//
+// RPositioner
+//
+//
+
+//1.10.7 Open with No Memory
+void CNoMemoryStep::OOM_RPositioner_OpenL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    RPositionServer server;
+    User::LeaveIfError(server.Connect());
+    CleanupClosePushL(server);
+
+    RPositioner positioner;
+
+    // open by default
+    __UHEAP_SETFAIL(RHeap::EFailNext, 1);
+    __UHEAP_MARK;
+    CHECK_EQUAL_(KErrNoMemory, positioner.Open(server));
+    __UHEAP_MARKEND;
+    __UHEAP_RESET;
+
+    // by module id
+    TPositionModuleId moduleId;
+    server.GetDefaultModuleId(moduleId);
+    __UHEAP_SETFAIL(RHeap::EFailNext, 1);
+    __UHEAP_MARK;
+    CHECK_EQUAL_(KErrNoMemory, positioner.Open(server, moduleId));
+    __UHEAP_MARKEND;
+    __UHEAP_RESET;
+
+    // by criteria
+    TPositionCriteria criteria;
+    criteria.ResetCriteria(); // defaults
+    __UHEAP_SETFAIL(RHeap::EFailNext, 1);
+    __UHEAP_MARK;
+    CHECK_EQUAL_(KErrNoMemory, positioner.Open(server, criteria));
+    __UHEAP_MARKEND;
+    __UHEAP_RESET;
+
+    CleanupStack::PopAndDestroy();
+
+    StandardCleanup();
+	}
+
+
+//1.13.5 SetRequestor Stack with No Memory
+void CNoMemoryStep::OOM_RPositioner_SetRequestorL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    RPositionServer server;
+    User::LeaveIfError(server.Connect());
+    CleanupClosePushL(server);
+
+    RPositioner positioner;
+    CHECK_EQUAL_(KErrNone, positioner.Open(server));
+    CleanupClosePushL(positioner);
+
+    RRequestorStack stack;
+    CRequestor* requestor = NULL;
+
+    // All Accepted
+    requestor = CRequestor::NewLC(
+            CRequestor::ERequestorContact,
+            DUMMY_REQUESTOR_FORMAT_ACCEPTED2,
+            DUMMY_REQUESTOR_NAME_ACCEPTED2);
+    stack.Append(requestor);
+    requestor = CRequestor::NewLC(
+            CRequestor::ERequestorService,
+            DUMMY_REQUESTOR_FORMAT_ACCEPTED1,
+            DUMMY_REQUESTOR_NAME_ACCEPTED1);
+    stack.Append(requestor);
+
+    // set requestor stack
+    __UHEAP_SETFAIL(RHeap::EFailNext, 1);
+    __UHEAP_MARK;
+
+    CHECK_EQUAL_(KErrNoMemory, positioner.SetRequestor(stack));
+    CHECK_EQUAL_(KErrNone, positioner.SetRequestor(stack));
+
+    __UHEAP_MARKEND;
+    __UHEAP_RESET;
+
+    CleanupStack::Pop(2); // requestors
+    CleanupStack::PopAndDestroy(2); // server & positioner
+    stack.ResetAndDestroy();
+
+    StandardCleanup();
+    }
+
+
+//
+//
+// CRequestor
+//
+//
+
+// 8.2.4. Constructors with No Memory
+void CNoMemoryStep::OOM_CRequestor_ConstructionL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    _LIT(KRequestorData, "+441223719800");
+
+    // New
+    CRequestor* requestor = NULL;
+    TBool doContinue = ETrue;
+    TInt failureRate = 0;
+
+    for (failureRate = 1; doContinue; failureRate++)
+        {
+        __UHEAP_SETFAIL(RHeap::EFailNext, failureRate);
+        __UHEAP_MARK;
+
+        TInt err;
+        TRAP(err, 
+            User::LeaveIfNull(requestor = 
+                CRequestor::New(CRequestor::ERequestorContact, 
+                                CRequestor::EFormatTelephone, 
+                                KRequestorData));
+        );
+        
+        if (err != KErrNoMemory)
+            {
+            delete requestor;
+            doContinue = EFalse;
+            }
+
+        __UHEAP_MARKEND;
+        __UHEAP_RESET;
+        }
+    CHECK( failureRate > 2 );
+    message.Format(_L("Checked %d allocations in \"New\""), failureRate-2);
+    LOG_DES(message);
+
+    // NewL
+    doContinue = ETrue;
+    for (failureRate = 1; doContinue; failureRate++)
+        {
+        __UHEAP_SETFAIL(RHeap::EFailNext, failureRate);
+        __UHEAP_MARK;
+
+        TInt err;
+        TRAP(err, 
+            requestor = CRequestor::NewL(CRequestor::ERequestorContact, 
+                                          CRequestor::EFormatTelephone, 
+                                          KRequestorData);
+        	);
+        
+        if (err != KErrNoMemory)
+            {
+            delete requestor;
+            doContinue = EFalse;
+            }
+
+        __UHEAP_MARKEND;
+        __UHEAP_RESET;
+        }
+    CHECK( failureRate > 2 );
+    message.Format(_L("Checked %d allocations in \"NewL\""), failureRate-2);
+    LOG_DES(message);
+
+    // NewLC
+    doContinue = ETrue;
+    for (failureRate = 1; doContinue; failureRate++)
+        {
+        __UHEAP_SETFAIL(RHeap::EFailNext, failureRate);
+        __UHEAP_MARK;
+
+        TInt err;
+        TRAP(err, 
+            requestor = CRequestor::NewLC(CRequestor::ERequestorContact, 
+                                          CRequestor::EFormatTelephone, 
+                                          KRequestorData);
+            CleanupStack::Pop(requestor);                                          
+        	);
+        
+        if (err != KErrNoMemory)
+            {
+            delete requestor;
+            doContinue = EFalse;
+            }
+
+        __UHEAP_MARKEND;
+        __UHEAP_RESET;
+        }
+    CHECK( failureRate > 2 );
+    message.Format(_L("Checked %d allocations in \"NewLC\""), failureRate-2);
+    LOG_DES(message);
+
+    StandardCleanup();   
+	}
+
+
+// 8.2.5. SetRequestor with No Memory
+void CNoMemoryStep::OOM_CRequestor_SetRequestorL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    _LIT(KRequestorData, "+441223719800");
+    _LIT(KRequestorData2, "+44122371980101");
+
+    // NOTE, this is a special case where the CRequestor is created at the start, then
+    // its member data is replaced (which is tested under OOM conditions).
+    DO_OOM(
+          CRequestor* requestor = CRequestor::NewLC(CRequestor::ERequestorContact, CRequestor::EFormatTelephone, KRequestorData),
+          requestor->SetRequestorL(CRequestor::ERequestorContact, CRequestor::EFormatTelephone, KRequestorData2),
+          CleanupStack::PopAndDestroy(requestor)
+          );
+
+    StandardCleanup();    
+	}
+
+
+// 8.3.3. Streaming with NoMemory
+void CNoMemoryStep::OOM_CRequestor_StreamingL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    _LIT(KRequestorData, "+441223719800");
+    CRequestor* requestor = NULL;
+
+    requestor = CRequestor::NewLC(CRequestor::ERequestorContact, CRequestor::EFormatTelephone, KRequestorData);
+    TBuf8<100> buffer;
+    RDesWriteStream writeStrm(buffer);
+    CleanupClosePushL(writeStrm);
+    TInt err;
+    TRAP(err, writeStrm << *requestor);
+    CleanupStack::PopAndDestroy(&writeStrm);
+
+    // Internalize
+    DO_OOM_CUSTOMISED_LOOP
+        (
+        (void) 0,
+        strm >> *requestor,
+        delete requestor,
+        RDesReadStream strm(buffer); CleanupClosePushL(strm),
+        CleanupStack::PopAndDestroy(&strm)
+        );
+
+    CleanupStack::Pop(requestor);
+
+    // Construction
+    DO_OOM_CUSTOMISED_LOOP
+        (
+        (void) 0,
+        requestor = CRequestor::NewL(strm),
+        delete requestor,
+        RDesReadStream strm(buffer); CleanupClosePushL(strm),
+        CleanupStack::PopAndDestroy(&strm)
+        );
+
+    StandardCleanup();
+    }
+
+
+//
+//
+// RRequestorStack
+//
+//
+
+void CleanupResetAndDestroy(TAny* aArray)
+    {
+    reinterpret_cast<RRequestorStack*>(aArray)->ResetAndDestroy();
+    }
+
+
+// 8.1.3. Streaming with No Memory
+void CNoMemoryStep::OOM_RRequestorStack_StreamingL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    _LIT(KRequestorData, "+441223719800");
+    const TInt KNumberOfRequestors = 3;
+    RRequestorStack stack;
+    CleanupStack::PushL(TCleanupItem(CleanupResetAndDestroy, &stack));
+    TInt i;
+    for (i = 0; i < KNumberOfRequestors; i++)
+            User::LeaveIfError(stack.Append(NULL));
+    for (i = 0; i < KNumberOfRequestors; i++)
+            stack[i] = CRequestor::NewL(CRequestor::ERequestorContact, CRequestor::EFormatTelephone, KRequestorData);
+
+    TBuf8<100> buffer;
+    RDesWriteStream writeStrm(buffer);
+    CleanupClosePushL(writeStrm);
+    TInt err;
+    TRAP(err, writeStrm << stack);
+    CleanupStack::PopAndDestroy(&writeStrm);
+
+    CleanupStack::PopAndDestroy(&stack);
+    CleanupStack::PushL(TCleanupItem(CleanupResetAndDestroy, &stack));
+
+    DO_OOM_CUSTOMISED_LOOP
+        (
+        (void) 0,
+        strm >> stack,
+        stack.ResetAndDestroy(),
+        RDesReadStream strm(buffer); CleanupClosePushL(strm),
+        CleanupStack::PopAndDestroy(&strm)
+        );
+
+    CleanupStack::Pop(&stack);
+
+    StandardCleanup();
+    }
+
+
+//
+//
+// HPositionGenericInfo
+//
+//
+
+// 3.2.2. NoMemory Construction
+void CNoMemoryStep::OOM_HPositionGenericInfo_ConstructionL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    
+    // New
+    DO_OOM
+            (
+            HPositionGenericInfo* genInfo = NULL,
+            User::LeaveIfNull(genInfo = HPositionGenericInfo::New(10)),
+            delete genInfo
+            );
+    // NewL
+    DO_OOM
+            (
+            HPositionGenericInfo* genInfo = NULL,
+            genInfo = HPositionGenericInfo::NewL(10),
+            delete genInfo
+            );
+    // NewLC
+    DO_OOM
+            (
+            HPositionGenericInfo* genInfo = NULL,
+            genInfo = HPositionGenericInfo::NewLC(10);
+            CleanupStack::Pop(genInfo),
+            delete genInfo
+            );
+
+    StandardCleanup();
+    }
+
diff -r 7f293ed715ec -r a4835904093b LbsApi/src/noserverstep.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/src/noserverstep.cpp	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,503 @@
+// 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 NoServerStep.cpp
+ @internalTechnology
+*/
+#include "noserverstep.h"
+#include "te_lbsapisuitedefs.h"
+
+#include "lcfsbucommondefinitions.h"
+
+#include <lbs.h>
+#include <lbssatellite.h>
+#include <e32math.h>
+#include <s32mem.h>
+#include <bautils.h>
+
+CNoServerStep::~CNoServerStep()
+/**
+ * Destructor
+ */
+	{
+	}
+
+CNoServerStep::CNoServerStep()
+/**
+ * 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(KNoServerStep);
+	}
+
+TVerdict CNoServerStep::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 CNoServerStep::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 CNoServerStep::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 CNoServerStep::StartL (TInt aIndex)
+	{
+	switch (aIndex)
+		{
+	case 0:
+		RPositionServer_NoConnectionL ();
+		break;
+	case 1:
+		RPositionServer_NoL ();
+		break;
+	case 2:
+		RPositioner_NoL ();
+		break;
+	default:
+		break;
+		}
+	}
+
+void CNoServerStep::CheckThereIsNoServerL()
+    {
+    DECLARE_ERROR_LOGGING;
+    
+    RPositionServer server;
+    CleanupClosePushL(server);
+    FAIL(server.Connect() == KErrNone, 
+        "Location Server must be deleted to run this test case");
+        
+    CleanupStack::PopAndDestroy(&server);
+    }
+
+
+// 1.1.2 Connect but server doesn't start
+// The test must be started when there is no server
+// See LBSAPIACCTESTNOSVR.BAT for details
+void CNoServerStep::RPositionServer_NoConnectionL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    CheckThereIsNoServerL();
+    
+    RPositionServer server;
+
+    __UHEAP_MARK;
+    CHECK( 0 == server.Handle() );
+    CHECK( KErrNone != server.Connect() );
+    CHECK( server.Handle() == 0 );
+    __UHEAP_MARKEND;
+
+    StandardCleanup();
+	}
+
+// x.x.x Connect and try to execute RPositionServer methods
+// This should fail with panic
+
+TInt No_Server_GetDefaultModuleId(TAny* /*aPtr*/)
+    {
+    RPositionServer server;
+    TPositionModuleId moduleId = KPositionNullModuleId;
+    server.GetDefaultModuleId(moduleId);
+    return KErrGeneral;
+    }
+
+
+TInt No_Server_GetNumModules(TAny* /*aPtr*/)
+    {
+    RPositionServer server;
+    TUint numModules;
+    server.GetNumModules(numModules);
+    return KErrGeneral;
+    }
+
+
+TInt No_Server_GetModuleInfoByIndex(TAny* /*aPtr*/)
+    {
+    RPositionServer server;
+    TUint index = 0;
+    TPositionModuleInfo info;
+    server.GetModuleInfoByIndex(index, info);
+    return KErrGeneral;
+    }
+
+
+TInt No_Server_GetModuleInfoById(TAny* /*aPtr*/)
+    {
+    RPositionServer server;
+    TPositionModuleId moduleId = KPositionNullModuleId;
+    TPositionModuleInfo info;
+    server.GetModuleInfoById(moduleId, info);
+    return KErrGeneral;
+    }
+
+
+TInt No_Server_GetModuleStatus(TAny* /*aPtr*/)
+    {
+    RPositionServer server;
+    TPositionModuleStatus moduleStatus;
+    TPositionModuleId moduleId = KPositionNullModuleId;
+    server.GetModuleStatus(moduleStatus, moduleId);
+    return KErrGeneral;
+    }
+
+
+TInt No_Server_NotifyModuleStatusEvent(TAny* /*aPtr*/)
+    {
+    RPositionServer server;
+    TPositionModuleStatusEvent event;
+    TPositionModuleId moduleId = KPositionNullModuleId;
+    TRequestStatus request;
+    server.NotifyModuleStatusEvent(event, request, moduleId);
+    return KErrGeneral;
+    }
+
+
+TInt No_Server_CancelRequest(TAny* /*aPtr*/)
+    {
+    RPositionServer server;
+    server.CancelRequest(EPositionServerNotifyModuleStatusEvent);
+    return KErrGeneral;
+    }
+
+
+void CNoServerStep::RPositionServer_NoL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    CheckThereIsNoServerL();
+    
+    RPositionServer server;
+
+    CHECK( KErrNone != server.Connect() );
+    FAIL( server.Handle() != 0 , "Server found, while should not be");
+        
+    DO_PANIC_TEST_L(
+        No_Server_GetDefaultModuleId,
+        KPosClientFault,
+        EPositionServerBadHandle,
+        KDefaultTestTimeout);
+       
+    DO_PANIC_TEST_L(
+        No_Server_GetNumModules,
+        KPosClientFault,
+        EPositionServerBadHandle,
+        KDefaultTestTimeout);
+
+    DO_PANIC_TEST_L(
+        No_Server_GetModuleInfoByIndex,
+        KPosClientFault,
+        EPositionServerBadHandle,
+        KDefaultTestTimeout);
+
+    DO_PANIC_TEST_L(
+        No_Server_GetModuleInfoById,
+        KPosClientFault,
+        EPositionServerBadHandle,
+        KDefaultTestTimeout);
+
+    DO_PANIC_TEST_L(
+        No_Server_GetModuleStatus,
+        KPosClientFault,
+        EPositionServerBadHandle,
+        KDefaultTestTimeout);
+
+    DO_PANIC_TEST_L(
+        No_Server_NotifyModuleStatusEvent,
+        KPosClientFault,
+        EPositionServerBadHandle,
+        KDefaultTestTimeout);
+
+    DO_PANIC_TEST_L(
+        No_Server_CancelRequest,
+        KPosClientFault,
+        EPositionServerBadHandle,
+        KDefaultTestTimeout);
+
+    StandardCleanup();
+    }
+
+
+// 9.1.3 Connect and try to execute RPositioner methods
+// This should fail with panic
+
+TInt No_Positioner_CancelRequest(TAny* /*aPtr*/)
+    {
+    RPositionServer server;
+    server.Connect();
+    
+    RPositioner positioner;
+    positioner.CancelRequest(EPositionerGetLastKnownPosition);
+    return KErrGeneral;
+    }
+
+
+TInt No_Positioner_Open(TAny* /*aPtr*/)
+    {
+    RPositionServer server;
+    server.Connect();
+    
+    RPositioner positioner;
+    positioner.Open(server);
+    return KErrGeneral;
+    }
+
+
+TInt No_Positioner_Open_ModuleId(TAny* /*aPtr*/)
+    {
+    RPositionServer server;
+    server.Connect();
+    
+    TPositionModuleId moduleId = {0x012345678};
+
+    RPositioner positioner;
+    positioner.Open(server, moduleId);
+    return KErrGeneral;
+    }
+
+
+TInt No_Positioner_Open_Criteria(TAny* /*aPtr*/)
+    {
+    RPositionServer server;
+    server.Connect();
+    
+    TPositionCriteria crit;
+    
+    RPositioner positioner;
+    positioner.Open(server, crit);
+    return KErrGeneral;
+    }
+    
+
+// Close method should not fail    
+TInt No_Positioner_Close(TAny* /*aPtr*/)
+    {
+    RPositionServer server;
+    server.Connect();
+    
+    RPositioner positioner;
+    positioner.Close();
+    return KErrNone;
+    }
+
+
+TInt No_Positioner_SetRequestor(TAny* /*aPtr*/)
+    {
+    RPositionServer server;
+    server.Connect();
+    
+    RPositioner positioner;
+    positioner.SetRequestor(0, 0, KNullDesC);
+    return KErrGeneral;
+    }
+
+
+TInt No_Positioner_SetRequestor_Stack(TAny* /*aPtr*/)
+    {
+    RPositionServer server;
+    server.Connect();
+    
+    RRequestorStack stack;
+    
+    RPositioner positioner;
+    positioner.SetRequestor(stack);
+    return KErrGeneral;
+    }
+
+
+TInt No_Positioner_SetUpdateOptions(TAny* /*aPtr*/)
+    {
+    RPositionServer server;
+    server.Connect();
+    
+    TPositionUpdateOptions options;
+
+    RPositioner positioner;
+    positioner.SetUpdateOptions(options);
+    return KErrGeneral;
+    }
+
+
+TInt No_Positioner_GetUpdateOptions(TAny* /*aPtr*/)
+    {
+    RPositionServer server;
+    server.Connect();
+    
+    TPositionUpdateOptions options;
+
+    RPositioner positioner;
+    positioner.GetUpdateOptions(options);
+    return KErrGeneral;
+    }
+
+
+TInt No_Positioner_GetLastKnownPosition(TAny* /*aPtr*/)
+    {
+    RPositionServer server;
+    server.Connect();
+    
+    TPositionInfo info;
+    TRequestStatus status;
+
+    RPositioner positioner;
+    positioner.GetLastKnownPosition(info, status);
+    return KErrGeneral;
+    }
+
+
+TInt No_Positioner_NotifyPositionUpdate(TAny* /*aPtr*/)
+    {
+    RPositionServer server;
+    server.Connect();
+    
+    TPositionInfo info;
+    TRequestStatus status;
+
+    RPositioner positioner;
+    positioner.NotifyPositionUpdate(info, status);
+    return KErrGeneral;
+    }
+
+
+void CNoServerStep::RPositioner_NoL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+    CheckThereIsNoServerL();
+    
+    RPositionServer server;
+
+    CHECK( KErrNone != server.Connect() );
+    FAIL( server.Handle() != 0, "Server found, while should not be" );
+        
+    DO_PANIC_TEST_L(
+        No_Positioner_CancelRequest,
+        KPosClientFault,
+        EPositionServerBadHandle,
+        KDefaultTestTimeout);
+       
+    DO_PANIC_TEST_L(
+        No_Positioner_Open,
+        KPosClientFault,
+        EPositionServerBadHandle,
+        KDefaultTestTimeout);
+
+    DO_PANIC_TEST_L(
+        No_Positioner_Open_ModuleId,
+        KPosClientFault,
+        EPositionServerBadHandle,
+        KDefaultTestTimeout);
+
+    DO_PANIC_TEST_L(
+        No_Positioner_Open_Criteria,
+        KPosClientFault,
+        EPositionServerBadHandle,
+        KDefaultTestTimeout);
+
+    DO_PANIC_TEST_L(
+        No_Positioner_Close,
+        KNoClientFault,
+        KErrNone,
+        KDefaultTestTimeout);
+
+    DO_PANIC_TEST_L(
+        No_Positioner_SetRequestor,
+        KPosClientFault,
+        EPositionServerBadHandle,
+        KDefaultTestTimeout);
+
+    DO_PANIC_TEST_L(
+        No_Positioner_SetRequestor_Stack,
+        KPosClientFault,
+        EPositionServerBadHandle,
+        KDefaultTestTimeout);
+
+    DO_PANIC_TEST_L(
+        No_Positioner_SetUpdateOptions,
+        KPosClientFault,
+        EPositionServerBadHandle,
+        KDefaultTestTimeout);
+
+    DO_PANIC_TEST_L(
+        No_Positioner_GetUpdateOptions,
+        KPosClientFault,
+        EPositionServerBadHandle,
+        KDefaultTestTimeout);
+
+    DO_PANIC_TEST_L(
+        No_Positioner_GetLastKnownPosition,
+        KPosClientFault,
+        EPositionServerBadHandle,
+        KDefaultTestTimeout);
+
+    DO_PANIC_TEST_L(
+        No_Positioner_NotifyPositionUpdate,
+        KPosClientFault,
+        EPositionServerBadHandle,
+        KDefaultTestTimeout);
+
+    StandardCleanup();
+	}
diff -r 7f293ed715ec -r a4835904093b LbsApi/src/reminderstep.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/src/reminderstep.cpp	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,84 @@
+// 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 reminderstep.cpp
+ @internalTechnology
+*/
+#include "reminderstep.h"
+#include "te_lbsapisuitedefs.h"
+
+#include "lcfsbucommondefinitions.h"
+
+#include <lbs.h>
+#include <lbssatellite.h>
+
+#include <s32mem.h>
+
+CReminderStep::~CReminderStep()
+/**
+ * Destructor
+ */
+	{
+	}
+
+CReminderStep::CReminderStep()
+/**
+ * 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(KReminderStep);
+	}
+
+TVerdict CReminderStep::doTestStepPreambleL()
+/**
+ * @return - TVerdict code
+ * Override of base class virtual
+ */
+	{
+	 CTe_LbsApiSuiteStepBase::doTestStepPreambleL();
+	return TestStepResult();
+	}
+
+
+TVerdict CReminderStep::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.
+ */
+	{
+	INFO_PRINTF1(KReminderCaption);
+	SetTestStepResult(EPass);
+	return TestStepResult();
+	}
+
+
+
+TVerdict CReminderStep::doTestStepPostambleL()
+/**
+ * @return - TVerdict code
+ * Override of base class virtual
+ */
+	{
+	return TestStepResult();
+	}
+
diff -r 7f293ed715ec -r a4835904093b LbsApi/src/requestorclassesstep.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/src/requestorclassesstep.cpp	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,567 @@
+// 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 RequestorClassesStep.cpp
+ @internalTechnology
+*/
+#include "requestorclassesstep.h"
+#include "te_lbsapisuitedefs.h"
+
+#include "lcfsbucommondefinitions.h"
+
+#include <lbs.h>
+#include <lbssatellite.h>
+
+#include <s32mem.h>
+
+CRequestorClassesStep::~CRequestorClassesStep()
+/**
+ * Destructor
+ */
+	{
+	}
+
+CRequestorClassesStep::CRequestorClassesStep()
+/**
+ * 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(KRequestorClassesStep);
+	}
+
+TVerdict CRequestorClassesStep::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 CRequestorClassesStep::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 CRequestorClassesStep::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 CRequestorClassesStep::StartL (TInt aIndex)
+	{
+	switch (aIndex)
+		{
+	case 0:
+		RRequestorStack_StreamingL ();
+		break;
+	case 1:
+		RRequestorStack_Streaming2L ();
+		break;
+	case 2:
+		CRequestor_ConstructionL ();
+		break;
+	case 3:
+		CRequestor_SetL ();
+		break;
+	case 4:
+		CRequestor_Construction2L ();
+		break;
+	case 5:
+		CRequestor_StreamingL ();
+		break;
+	case 6:
+		CRequestor_Streaming2L ();
+		break;
+	default:
+		break;
+		}
+	}
+
+
+//
+//
+// RRequestorStack
+//
+//
+
+void ResetAndDestroyRequestorStack(TAny* aArray)
+    {
+    RRequestorStack* stack = static_cast<RRequestorStack*>(aArray);
+    stack->ResetAndDestroy();
+    }
+
+// 8.1.1. Streaming
+void CRequestorClassesStep::RRequestorStack_StreamingL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+
+    RRequestorStack requestorStack;
+    CleanupStack::PushL(TCleanupItem(ResetAndDestroyRequestorStack, &requestorStack));
+
+    _LIT(KDummyLit1, "Hello");
+    const CRequestor::TRequestorType KDummyRequestorType1(CRequestor::ERequestorService);
+    const CRequestor::TRequestorFormat KDummyRequestorFormat1(CRequestor::EFormatTelephone);
+
+    CRequestor* requestor = CRequestor::NewLC(KDummyRequestorType1, KDummyRequestorFormat1, KDummyLit1);
+    User::LeaveIfError(requestorStack.Append(requestor));        //take ownership of requestor
+    CleanupStack::Pop(requestor);
+    requestor = NULL;        //Just to make it clear we don't one requestor.
+
+    _LIT(KDummyLit2, "Goodbye");
+    const CRequestor::TRequestorType KDummyRequestorType2(CRequestor::ERequestorContact);
+    const CRequestor::TRequestorFormat KDummyRequestorFormat2(CRequestor::EFormatUrl);
+
+    requestor = CRequestor::NewLC(KDummyRequestorType2, KDummyRequestorFormat2, KDummyLit2);
+    User::LeaveIfError(requestorStack.Append(requestor));        //take ownership of requestor
+    CleanupStack::Pop(requestor);
+    requestor = NULL;        //Just to make it clear we don't one requestor.
+
+    //All info in requestorStack. Now stream out and back into a new requestor stack.
+
+    CBufFlat* buffer = CBufFlat::NewL(512);        //Abritrary size chosen
+    CleanupStack::PushL(buffer);
+    RBufWriteStream writeStream;
+    writeStream.Open(*buffer);
+    writeStream.PushL();
+    // externalize
+    requestorStack.ExternalizeL(writeStream);
+    writeStream.CommitL();
+    writeStream.Pop();
+    //requestorStack now piped into buffer.
+    //get rid of requestorStack.
+    CleanupStack::Pop(buffer);
+    CleanupStack::PopAndDestroy(&requestorStack);
+    CleanupStack::PushL(buffer);
+
+    RBufReadStream readStream;
+    readStream.Open(*buffer);
+    readStream.PushL();
+
+    RRequestorStack requestorStack2;
+    CleanupStack::PushL(TCleanupItem(ResetAndDestroyRequestorStack, &requestorStack2));
+    // internalize
+    requestorStack2.InternalizeL(readStream);
+    //requestorStack2 should now be initialised.
+
+    CHECK_EQUAL_(2, requestorStack2.Count());
+
+    requestor = requestorStack2[0];
+    CHECK(!TPtrC(KDummyLit1).Compare(requestor->RequestorData()));
+    CHECK_EQUAL_(requestor->RequestorType(), KDummyRequestorType1);
+    CHECK_EQUAL_(requestor->RequestorFormat(), KDummyRequestorFormat1);
+
+    requestor = requestorStack2[1];
+    CHECK(!TPtrC(KDummyLit2).Compare(requestor->RequestorData()));
+    CHECK_EQUAL_(requestor->RequestorType(), KDummyRequestorType2);
+    CHECK_EQUAL_(requestor->RequestorFormat(), KDummyRequestorFormat2);
+
+    CleanupStack::PopAndDestroy(3, buffer);
+
+    StandardCleanup();
+	}
+
+
+// 8.1.2. Streaming with invalid stream
+TInt RRequestorStack_Streaming_Invalid(TAny* /*aPtr*/)
+	{
+    RBufReadStream readStream;
+
+    // buffer
+        CBufFlat* buffer = CBufFlat::NewL(512);        //Arbitrary size chosen
+    RBufWriteStream writeStream; // make sure it is empty
+    writeStream.Open(*buffer);
+    writeStream.WriteUint16L(12345); // put dummy value there (different from KRequestorStackVersion)
+    writeStream.Close();
+    writeStream.Release();
+
+    // read-stream
+    readStream.Open(*buffer);
+
+    TInt err;
+    TRAP(err,
+        // internalize it
+        RRequestorStack requestorStack2;
+        CleanupStack::PushL(TCleanupItem(ResetAndDestroyRequestorStack, &requestorStack2));
+
+        requestorStack2.InternalizeL(readStream);   //This should panic
+
+        CleanupStack::Pop();
+    	);
+
+    readStream.Release();
+    delete buffer;
+
+    return KErrGeneral;
+	}
+
+
+void CRequestorClassesStep::RRequestorStack_Streaming2L()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+
+    // attempt to internalize from invalid stream
+    DO_PANIC_TEST_L(
+        RRequestorStack_Streaming_Invalid,
+        KPosClientFault,
+        EPositionInvalidClassType,
+        KDefaultTestTimeout);
+
+    StandardCleanup();
+	}
+
+
+// 8.1.3. Streaming with No Memory
+// See NoMemoryTests.cpp
+
+//
+//
+// CRequestor
+//
+//
+
+// 8.2.1. Construction
+void CRequestorClassesStep::CRequestor_ConstructionL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+
+    _LIT(KDummyLit, "Hello");
+    const CRequestor::TRequestorType KDummyRequestorType(CRequestor::ERequestorService);
+    const CRequestor::TRequestorFormat KDummyRequestorFormat(CRequestor::EFormatTelephone);
+
+    CRequestor* requestor = NULL;
+
+    requestor = CRequestor::NewL(KDummyRequestorType, KDummyRequestorFormat, KDummyLit);
+    CHECK(requestor->RequestorData().Compare(KDummyLit) == 0);
+    CHECK(requestor->RequestorType()   == KDummyRequestorType);
+    CHECK(requestor->RequestorFormat() == KDummyRequestorFormat);
+    delete requestor;
+
+    requestor = CRequestor::NewLC(KDummyRequestorType, KDummyRequestorFormat, KDummyLit);
+    CHECK(requestor->RequestorData().Compare(KDummyLit) == 0);
+    CHECK(requestor->RequestorType()   == KDummyRequestorType);
+    CHECK(requestor->RequestorFormat() == KDummyRequestorFormat);
+    CleanupStack::PopAndDestroy(requestor);
+
+    requestor = static_cast<CRequestor*>( User::LeaveIfNull(CRequestor::New(KDummyRequestorType, KDummyRequestorFormat, KDummyLit)));
+    CHECK(requestor->RequestorData().Compare(KDummyLit) == 0);
+    CHECK(requestor->RequestorType()   == KDummyRequestorType);
+    CHECK(requestor->RequestorFormat() == KDummyRequestorFormat);
+    delete requestor;
+
+    StandardCleanup();
+	}
+
+
+// 8.2.2. Setters and Getters
+void CRequestorClassesStep::CRequestor_SetL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+
+    // Get
+    _LIT(KDummyLit, "Hello");
+    const CRequestor::TRequestorType KDummyRequestorType(CRequestor::ERequestorService);
+    const CRequestor::TRequestorFormat KDummyRequestorFormat(CRequestor::EFormatTelephone);
+    CRequestor* requestor = CRequestor::NewL(KDummyRequestorType, KDummyRequestorFormat, KDummyLit);
+    CleanupStack::PushL(requestor);
+
+    TPtrC ptr;
+    CRequestor::TRequestorType requestorType;
+    CRequestor::TRequestorFormat requestorFormat;
+
+    requestor->GetRequestor(requestorType, requestorFormat, ptr);
+
+    CHECK(ptr.Compare(KDummyLit)    == 0);
+    CHECK(requestorType             == KDummyRequestorType);
+    CHECK(requestorFormat           == KDummyRequestorFormat);
+
+    // Set
+    _LIT(KNewDummyLit, "Goodbye");
+    const CRequestor::TRequestorType KNewDummyRequestorType(CRequestor::ERequestorContact);
+    const CRequestor::TRequestorFormat KNewDummyRequestorFormat(CRequestor::EFormatUrl);
+    requestor->SetRequestorL(KNewDummyRequestorType, KNewDummyRequestorFormat, KNewDummyLit);
+
+    // check as properties
+    CHECK(requestor->RequestorData().Compare(KNewDummyLit) == 0);
+    CHECK(requestor->RequestorType()   == KNewDummyRequestorType);
+    CHECK(requestor->RequestorFormat() == KNewDummyRequestorFormat);
+
+    // check by GetRequestor
+    requestor->GetRequestor(requestorType, requestorFormat, ptr);
+
+    CHECK(ptr.Compare(KNewDummyLit) == 0);
+    CHECK(requestorType             == KNewDummyRequestorType);
+    CHECK(requestorFormat           == KNewDummyRequestorFormat);
+
+    CleanupStack::PopAndDestroy();
+
+    // Now set much longer requestor data, to check if
+    // doesn't matter :-)
+    TBuf<1> shortData;
+    shortData.Append('$');
+    requestor = CRequestor::NewLC(KDummyRequestorType, KDummyRequestorFormat, shortData);
+
+    TBuf<512> longData;
+    longData.Fill('@', longData.MaxLength());
+    requestor->SetRequestorL(KNewDummyRequestorType, KNewDummyRequestorFormat, longData);
+
+    // check it
+    CHECK(requestor->RequestorData().Compare(longData) == 0);
+    CHECK(requestor->RequestorType()   == KNewDummyRequestorType);
+    CHECK(requestor->RequestorFormat() == KNewDummyRequestorFormat);
+
+    // set smaller one again
+    requestor->SetRequestorL(KDummyRequestorType, KDummyRequestorFormat, shortData);
+    CHECK(requestor->RequestorData().Compare(shortData) == 0);
+
+    CleanupStack::PopAndDestroy();
+
+    StandardCleanup();
+	}
+
+
+/*
+// 8.2.3. Constructors with invalid parameters
+void CRequestorClassesStep::CRequestor_Construction3L()
+{
+    // there are no relevant parameters to pass invalid values.
+    // the only one is wrong stream, see 8.3.4 CRequestor_Streaming_Invalid
+}
+*/
+
+// 8.2.4. Constructors with No Memory
+// See NoMemoryTests.cpp
+
+// 8.2.5. SetRequestor with No Memory
+// See NoMemoryTests.cpp
+
+
+// 8.3.1. Construction from stream
+void CRequestorClassesStep::CRequestor_Construction2L()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+
+    _LIT(KDummyLit, "Hello");
+    const CRequestor::TRequestorType KDummyRequestorType(CRequestor::ERequestorService);
+    const CRequestor::TRequestorFormat KDummyRequestorFormat(CRequestor::EFormatTelephone);
+    CRequestor* requestor1 = CRequestor::NewLC(KDummyRequestorType, KDummyRequestorFormat, KDummyLit);
+
+    //Make a write stream
+    HBufC8* buffer = HBufC8::NewLC(0x100);        //Should be plenty big enough
+    TPtr8 ptr = buffer->Des();
+    RDesWriteStream writeStream(ptr);        //Opens the write stream
+    CleanupClosePushL(writeStream);
+    requestor1->ExternalizeL(writeStream);
+    writeStream.CommitL();
+    CleanupStack::PopAndDestroy(&writeStream);        //Close the write stream
+
+    //Make a read stream
+    RDesReadStream readStream(*buffer);
+    CleanupClosePushL(readStream);
+
+    // construct
+    CRequestor* requestor2 = CRequestor::NewL(readStream);
+
+    CHECK(!TPtrC(KDummyLit).Compare(requestor2->RequestorData()));
+    CHECK_EQUAL_(requestor2->RequestorType(), KDummyRequestorType);
+    CHECK_EQUAL_(requestor2->RequestorFormat(), KDummyRequestorFormat);
+
+    delete requestor2;
+    CleanupStack::PopAndDestroy(3, requestor1);        //readStream, buffer, requestor1
+
+    StandardCleanup();
+	}
+
+
+// 8.3.2. Externalize/Internalize
+void CRequestorClassesStep::CRequestor_StreamingL()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+
+    _LIT(KDummyLit1, "Hello");
+    const CRequestor::TRequestorType KDummyRequestorType1(CRequestor::ERequestorService);
+    const CRequestor::TRequestorFormat KDummyRequestorFormat1(CRequestor::EFormatTelephone);
+    CRequestor* requestor1 = CRequestor::NewLC(KDummyRequestorType1, KDummyRequestorFormat1, KDummyLit1);
+
+    // set r2 with other values
+    _LIT(KDummyLit2, "Goodbye");
+    const CRequestor::TRequestorType KDummyRequestorType2(CRequestor::ERequestorContact);
+    const CRequestor::TRequestorFormat KDummyRequestorFormat2(CRequestor::EFormatUrl);
+    CRequestor* requestor2 = CRequestor::NewLC(KDummyRequestorType2, KDummyRequestorFormat2, KDummyLit2);
+
+    // Make a write stream
+    HBufC8* buffer = HBufC8::NewLC(0x100);        //Should be plenty big enough
+    TPtr8 ptr = buffer->Des();
+    RDesWriteStream writeStream(ptr);        //Opens the write stream
+    CleanupClosePushL(writeStream);
+
+    // externalize r1
+    writeStream << *requestor1;
+    writeStream.CommitL();
+    CleanupStack::PopAndDestroy(&writeStream);        //Close the write stream
+
+    RDesReadStream readStream(*buffer);
+    CleanupClosePushL(readStream);
+    // internalize r2
+    requestor2->InternalizeL(readStream);
+    CleanupStack::PopAndDestroy(&readStream);        //Close the readStream
+
+    // check r2
+    CHECK(requestor2->RequestorData().Compare(KDummyLit1) == 0);
+    CHECK(requestor2->RequestorType()   == KDummyRequestorType1);
+    CHECK(requestor2->RequestorFormat() == KDummyRequestorFormat1);
+
+    CleanupStack::PopAndDestroy(3, requestor1);
+
+    StandardCleanup();
+	}
+
+
+// 8.3.3. Streaming with NoMemory
+// See NoMemoryTests.cpp
+
+// 8.3.4. Invalid stream
+TInt CRequestor_Internalize_Invalid_Stream(TAny* /*aPtr*/)
+	{
+    CRequestor* requestor = NULL;
+    RBufReadStream readStream;
+
+    // buffer
+    CBufFlat* buffer = CBufFlat::NewL(512);        //Abritrary size chosen
+    RBufWriteStream writeStream; // make sure it is empty
+    writeStream.Open(*buffer);
+    writeStream.WriteUint16L(12345); // put dummy value there (different from KRequestorVersion)
+    writeStream.Close();
+    writeStream.Release();
+    readStream.Open(*buffer);
+
+    TInt err;
+    TRAP(err,
+                // internalize it
+            requestor = CRequestor::New(DUMMY_REQUESTOR_TYPE_ACCEPTED1, DUMMY_REQUESTOR_FORMAT_ACCEPTED1, DUMMY_REQUESTOR_NAME_ACCEPTED1);
+                CleanupStack::PushL(requestor);
+
+            requestor->InternalizeL(readStream);   //This should panic
+
+            CleanupStack::PopAndDestroy();
+    	);
+    User::LeaveIfError(err);
+
+    readStream.Release();
+    delete buffer;
+
+    return KErrGeneral;
+	}
+
+
+TInt CRequestor_Construct_Invalid_Stream(TAny* /*aPtr*/)
+	{
+    CRequestor* requestor = NULL;
+    RBufReadStream readStream;
+
+    // buffer
+    CBufFlat* buffer = CBufFlat::NewL(512);        //Arbitrary size chosen
+    RBufWriteStream writeStream; // make sure it is empty
+    writeStream.Open(*buffer);
+    writeStream.WriteUint16L(12345); // put dummy value there (different from KRequestorVersion)
+    writeStream.Close();
+    writeStream.Release();
+
+    // read-stream
+    readStream.Open(*buffer);
+
+    TInt err;
+    TRAP(err,
+        // internalize it
+        requestor = CRequestor::NewL(readStream);   //This should panic
+    	);
+
+    delete requestor;
+    readStream.Release();
+    delete buffer;
+
+    return KErrGeneral;
+	}
+
+
+void CRequestorClassesStep::CRequestor_Streaming2L()
+	{
+    DECLARE_ERROR_LOGGING;
+    StandardPrepareL();
+
+    // attempt to internalize from invalid stream
+    DO_PANIC_TEST_L(
+        CRequestor_Internalize_Invalid_Stream,
+        KPosClientFault,
+        EPositionInvalidClassType,
+        KDefaultTestTimeout);
+    // attempt to construct from invalid stream
+    DO_PANIC_TEST_L(
+        CRequestor_Construct_Invalid_Stream,
+        KPosClientFault,
+        EPositionInvalidClassType,
+        KDefaultTestTimeout);
+
+    StandardCleanup();
+	}
+
diff -r 7f293ed715ec -r a4835904093b LbsApi/src/te_lbsapisuiteserver.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/src/te_lbsapisuiteserver.cpp	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,133 @@
+// 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:
+//
+
+/**
+ @file Te_LbsApiSuiteServer.cpp
+ @internalTechnology
+*/
+
+#include "te_lbsapisuiteserver.h"
+#include "calculationmethodsstep.h"
+#include "criteriaclassesstep.h"
+#include "dataclassesstep.h"
+#include "genericinfostep.h"
+#include "moduleclassesstep.h"
+#include "nomemorystep.h"
+#include "reminderstep.h"
+#include "noserverstep.h"
+#include "requestorclassesstep.h"
+
+_LIT(KServerName,"Te_LbsApiSuite");
+CTe_LbsApiSuite* CTe_LbsApiSuite::NewL()
+/**
+ * @return - Instance of the test server
+ * Same code for Secure and non-secure variants
+ * Called inside the MainL() function to create and start the
+ * CTestServer derived server.
+ */
+	{
+	CTe_LbsApiSuite * server = new (ELeave) CTe_LbsApiSuite();
+	CleanupStack::PushL(server);
+
+	server->ConstructL(KServerName);
+	CleanupStack::Pop(server);
+	return server;
+	}
+
+
+// Secure variants much simpler
+// For EKA2, just an E32Main and a MainL()
+LOCAL_C void MainL()
+/**
+ * Secure variant
+ * Much simpler, uses the new Rendezvous() call to sync with the client
+ */
+	{
+	// Leave the hooks in for platform security
+#if (defined __DATA_CAGING__)
+	RProcess().DataCaging(RProcess::EDataCagingOn);
+	RProcess().DataCaging(RProcess::ESecureApiOn);
+#endif
+	CActiveScheduler* sched=NULL;
+	sched=new(ELeave) CActiveScheduler;
+	CActiveScheduler::Install(sched);
+	CTe_LbsApiSuite* server = NULL;
+	// Create the CTestServer derived server
+	TRAPD(err,server = CTe_LbsApiSuite::NewL());
+	if(!err)
+		{
+		// Sync with the client and enter the active scheduler
+		RProcess::Rendezvous(KErrNone);
+		sched->Start();
+		}
+	delete server;
+	delete sched;
+	}
+
+
+
+GLDEF_C TInt E32Main()
+/**
+ * @return - Standard Epoc error code on process exit
+ * Secure variant only
+ * Process entry point. Called by client using RProcess API
+ */
+	{
+	__UHEAP_MARK;
+	CTrapCleanup* cleanup = CTrapCleanup::New();
+	if(cleanup == NULL)
+		{
+		return KErrNoMemory;
+		}
+	TRAPD(err,MainL());
+	delete cleanup;
+	__UHEAP_MARKEND;
+	return err;
+    }
+
+
+CTestStep* CTe_LbsApiSuite::CreateTestStep(const TDesC& aStepName)
+/**
+ * @return - A CTestStep derived instance
+ * Secure and non-secure variants
+ * Implementation of CTestServer pure virtual
+ */
+	{
+	CTestStep* testStep = NULL;
+	
+
+	
+	if(aStepName == KCalculationMethodsStep)
+		testStep = new CCalculationMethodsStep();
+	else if(aStepName == KCriteriaClassesStep)
+		testStep = new CCriteriaClassesStep();
+	else if(aStepName == KDataClassesStep)
+		testStep = new CDataClassesStep();
+	else if(aStepName == KGenericInfoStep)
+		testStep = new CGenericInfoStep();
+	else if(aStepName == KModuleClassesStep)
+		testStep = new CModuleClassesStep();
+	else if(aStepName == KNoMemoryStep)
+#if defined(__WINS__) && defined(__DEBUG__)
+		testStep = new CNoMemoryStep();
+#else
+		testStep = new CReminderStep();
+#endif
+	else if(aStepName == KNoServerStep)
+		testStep = new CNoServerStep();
+	else if(aStepName == KRequestorClassesStep)
+		testStep = new CRequestorClassesStep();
+	return testStep;
+	}
diff -r 7f293ed715ec -r a4835904093b LbsApi/src/te_lbsapisuitestepbase.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/src/te_lbsapisuitestepbase.cpp	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,234 @@
+// 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:
+//
+
+/**
+ @file Te_LbsApiSuiteStepBase.cpp
+ @internalTechnology
+*/
+
+#include "te_lbsapisuitestepbase.h"
+#include "te_lbsapisuitedefs.h"
+
+#include "lcfsbucommondefinitions.h"
+
+_LIT(KPanicThreadName, "TestPanicThread");
+const TInt KTestHeapMinSize = 0x4000;
+const TInt KTestHeapMaxSize = 0x8000;
+
+// Device driver constants
+
+TVerdict CTe_LbsApiSuiteStepBase::doTestStepPreambleL()
+/**
+ * @return - TVerdict
+ * Implementation of CTestStep base class virtual
+ * It is used for doing all initialisation common to derived classes in here.
+ * Make it being able to leave if there are any errors here as there's no point in
+ * trying to run a test step if anything fails.
+ * The leave will be picked up by the framework.
+ */
+	{
+	SetTestStepResult(EPass);
+	return TestStepResult();
+	}
+
+TVerdict CTe_LbsApiSuiteStepBase::doTestStepPostambleL()
+/**
+ * @return - TVerdict
+ * Implementation of CTestStep base class virtual
+ * It is used for doing all after test treatment common to derived classes in here.
+ * Make it being able to leave
+ * The leave will be picked up by the framework.
+ */
+	{
+	//SetTestStepResult(EPass);  // or EFail
+	return TestStepResult();
+	}
+
+CTe_LbsApiSuiteStepBase::~CTe_LbsApiSuiteStepBase()
+	{
+	}
+
+CTe_LbsApiSuiteStepBase::CTe_LbsApiSuiteStepBase()
+	{
+	}
+
+
+
+
+//
+//
+// TOOL FUNCTIONS
+//
+//
+void CTe_LbsApiSuiteStepBase::StandardPrepareL()
+{
+    START_ERROR_LOGGING;
+}
+
+void CTe_LbsApiSuiteStepBase::StandardCleanup()
+{
+}
+
+//
+// PANIC TEST SUPPORT
+//
+
+void TurnJITBackOn(TAny* /*aPtr*/)
+	{
+	User::SetJustInTime (ETrue);
+	}
+
+TInt PanicThreadFunction(TAny* aPtr)
+	{
+	CTrapCleanup* cs = CTrapCleanup::New ();
+	if ( cs == NULL)
+		return KErrNoMemory;
+
+	// we may need an ActiveScheduler
+	CActiveScheduler scheduler;
+	CActiveScheduler::Install (&scheduler);
+
+	SPanicThreadFunctionData* data =
+			reinterpret_cast<SPanicThreadFunctionData*>(aPtr);
+	TInt err;
+	TRAP(err, data->iPanicFunction(data->iPtr)); // should panic
+
+	delete cs;
+	User::Exit (err);
+	return err;
+	}
+
+TInt CTe_LbsApiSuiteStepBase::DoPanicTestL (
+		TThreadFunction aThreadFunction, TExitCategoryName aExpectedExitCat,
+		TInt aExpectedExitReason, TTimeIntervalMicroSeconds32 aTimeoutValue,
+		TAny* aPtr)
+
+	{
+	DECLARE_ERROR_LOGGING
+	;
+
+#ifdef __WINS__
+	User::SetJustInTime (EFalse);
+	CleanupStack::PushL (TCleanupItem (TurnJITBackOn));
+#endif
+	RThread panickingThread;
+
+	SPanicThreadFunctionData threadData;
+	threadData.iPanicFunction = aThreadFunction;
+	threadData.iPtr = aPtr;
+
+	// check that thread does not already exist
+	TInt result = KErrNone;
+	TBuf<24> threadName(KPanicThreadName);
+
+	result = panickingThread.Create (threadName, PanicThreadFunction,
+			KDefaultStackSize, KTestHeapMinSize, KTestHeapMaxSize, &threadData,
+			EOwnerProcess);
+
+	CHECK_EQUAL(result, KErrNone, "Unexpected error while creating panic thread")
+	;
+	User::LeaveIfError (result);
+
+	CleanupClosePushL (panickingThread);
+
+	RTimer timeoutTimer;
+	User::LeaveIfError (timeoutTimer.CreateLocal ());
+	CleanupClosePushL (timeoutTimer);
+
+	TRequestStatus timerStatus;
+	timeoutTimer.After (timerStatus, aTimeoutValue);
+
+	TRequestStatus threadStatus;
+
+	panickingThread.Rendezvous (threadStatus);
+	if ( threadStatus != KRequestPending)
+		{
+		// logon failed - thread is not yet running, so cannot have terminated
+		User::WaitForRequest (threadStatus); // eat signal
+		panickingThread.Kill (threadStatus.Int ()); // abort startup
+		}
+	else
+		{
+		panickingThread.Resume ();
+		User::WaitForRequest (threadStatus, timerStatus);
+		}
+
+	TInt exitReason = KErrNone;
+	if ( threadStatus == KRequestPending)
+		{
+		ERR("Thread didn't die. Killing it...");
+		panickingThread.Kill (KErrTimedOut);
+		User::WaitForRequest (threadStatus);
+		}
+	else // (timerStatus == KRequestPending)
+		{
+		// stop timer
+		timeoutTimer.Cancel ();
+		User::WaitForRequest (timerStatus);
+		}
+
+	exitReason = panickingThread.ExitReason ();
+
+	TExitCategoryName exitCat;
+	
+	switch (panickingThread.ExitType ())
+		{
+	case EExitKill:
+		message.Format (_L("Thread was Killed with Reason %d"), exitReason);
+		LOG_DES(message);
+		break;
+	case EExitTerminate:
+		message.Format (_L("Thread was Terminated with Reason %d"), exitReason);
+		LOG_DES(message);
+		break;
+	case EExitPanic:
+		// check exit reasons
+		exitCat = panickingThread.ExitCategory ();
+		if ( exitCat.Compare (aExpectedExitCat) != 0)
+			{
+			message.Format (_L("Unexpected panic category: Actual '%S', Expected '%S'"),
+			&exitCat, &aExpectedExitCat);
+			LOG_DES(message);
+			}
+		CHECK_EQUAL(exitReason, aExpectedExitReason, "Unexpected panic reason");
+		break;
+	default:
+		CHECK_EQUAL((TInt)EExitPanic, threadStatus.Int(), "Unexpected thread exit type!");
+		break;
+		}
+
+	CleanupStack::PopAndDestroy (&timeoutTimer);
+	CleanupStack::PopAndDestroy (&panickingThread);
+#ifdef __WINS__
+	CleanupStack::PopAndDestroy (); //TurnJITBackOn
+#endif
+	// wait a bit to make sure this thread is over
+	const TTimeIntervalMicroSeconds32 KThreadDelay = 1000 * 1000; // 1 s
+	User::After (KThreadDelay);
+
+	return exitReason;
+	}
+
+void CheckPanic(const char* aFileName, TInt aLine)
+	{
+    TBuf<64> file;
+    TBuf<80> panic;
+
+    file.Copy(TPtrC8(_S8(aFileName)).Right(file.MaxLength()));
+    file = file.Mid(file.LocateReverse('\\')+1);
+
+    panic.Format(_L("%d-%S"), aLine, &file);
+    User::Panic(panic, KErrGeneral);
+	}
diff -r 7f293ed715ec -r a4835904093b LbsApi/testdata/smoketest_lbs.ini
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LbsApi/testdata/smoketest_lbs.ini	Wed Jul 28 13:24:28 2010 +0100
@@ -0,0 +1,251 @@
+[LBS-CalculationInvalid-0001]
+Test = 0
+
+[LBS-CalculationBasics-0001]
+Test = 1
+
+[LBS-CalculationTCoordinateMoveBig-0001]
+Test = 2
+
+
+
+[LBS-TPositionSelectionOrderConstruction-0001]
+Test = 0
+			
+[LBS-TPositionSelectionOrderSet-0001]
+Test = 1
+			
+[LBS-TPositionSelectionOrderClear-0001]
+Test = 2
+
+[LBS-TPositionSelectionOrderNumSelectionItems-0001]
+Test = 3
+
+[LBS-TPositionCriteriaConstruction-0001]
+Test = 4
+
+[LBS-TPositionCriteriaSet-0001]
+Test = 5
+
+[LBS-TPositionCriteriaResetAndClear-0001]
+Test = 6
+
+
+
+
+
+
+[LBS-TCoordinateBlankConstruction-0001]
+Test = 0
+
+[LBS-TCoordinateConstructors-0001]
+Test = 1
+
+[LBS-TCoordinateConstructors-0002]
+Test = 2
+
+[LBS-TCoordinateInvalid-0001]
+Test = 3
+
+[LBS-TCoordinateNormalizationWithNans-0001]
+Test = 4
+
+[LBS-TLocalityBlankConstruction-0001]
+Test = 5
+
+[LBS-TLocalityConstructors-0001]
+Test = 6
+
+[LBS-TLocalityConstructors-0002]
+Test = 7
+
+[LBS-TLocalityNegative-0001]
+Test = 8
+
+[LBS-TPositionConstruction-0001]
+Test = 9
+
+[LBS-TPositionSetters-0001]
+Test = 10
+
+[LBS-TPositionInfoConstruction-0001]
+Test = 11
+
+[LBS-TPositionInfoModification-0001]
+Test = 12
+
+[LBS-CourseClassesConstruction-0001]
+Test = 13
+
+[LBS-CourseClassesModification-0002]
+Test = 14
+
+[LBS-CourseClassesModification-0001]
+Test = 15
+
+[LBS-CourseClassesInvalid-0001]
+Test = 16
+
+[LBS-SatelliteClassesConstruction-0001]
+Test = 17
+
+[LBS-SatelliteClassesProperties-0001]
+Test = 18
+
+[LBS-SatelliteClassesProperties-0002]
+Test = 19
+
+[LBS-SatelliteClassesInfo-0001]
+Test = 20
+
+[LBS-SatelliteClassesSatelliteInfo-0001]
+Test = 21
+
+[LBS-SatelliteClassesOverflow-0001]
+Test = 22
+
+[LBS-API2-GpsMeasurementClasses-0001]
+Test = 23
+
+
+
+
+
+
+
+[LBS-HPositionGenericInfoConstruction-0001]
+Test = 0
+
+[LBS-HPositionGenericInfoConstruction-0002]
+Test = 1	
+	
+[LBS-HPositionGenericInfoRequesting-0001]
+Test = 2
+	
+[LBS-HPositionGenericInfoRequesting-0002]
+Test = 3
+	
+[LBS-HPositionGenericInfoGet-0001]
+Test = 4
+	
+[LBS-HPositionGenericInfoGood-0001]
+Test = 5
+
+[LBS-HPositionGenericInfoMismatched-0001]
+Test = 6
+
+[LBS-HPositionGenericInfoHBufC-0001]
+Test = 7
+
+[LBS-HPositionGenericInfoBuffer-0001]
+Test = 8
+
+[LBS-HPositionGenericInfoFields-0001]
+Test = 9
+
+[LBS-HPositionGenericInfoOverflow-0001]
+Test = 10
+
+[LBS-HPositionGenericInfoSet-0001]
+Test = 11
+
+
+
+
+
+
+
+[LBS-TPositionModuleInfoConstruction-0001]
+Test = 0
+
+[LBS-TPositionModuleInfoGetters-0001]
+Test = 1
+
+[LBS-TPositionModuleInfoInvalid-0001]
+Test = 2
+
+[LBS-TPositionQualityConstruction-0001]
+Test = 3
+
+[LBS-TPositionQualitySetters-0001]
+Test = 4
+
+[LBS-TPositionQualityInvalid-0001]
+Test = 5
+
+[LBS-TPositionQualityComparison-0001]
+Test = 6
+
+[LBS-ModuleClassesConstruction-0001]
+Test = 7
+
+[LBS-ModuleClassesSetters-0001]
+Test = 8
+
+[LBS-TPositionUpdateOptionsInvalid-0001]
+Test = 9
+
+
+
+
+
+[LBS-RRequestorStackStreaming-0001]
+Test = 0
+
+[LBS-RRequestorStackStreaming-0002]
+Test = 1
+
+[LBS-CRequestorConstruction-0001]
+Test = 2
+
+[LBS-CRequestorSet-0001]
+Test = 3
+
+[LBS-CRequestorConstruction-0002]
+Test = 4
+
+[LBS-CRequestorStreaming-0001]
+Test = 5
+
+[LBS-CRequestorStreaming-0002]
+Test = 6
+
+
+
+
+
+[LBS-OOMRPositionServerOpenNoMemory-0001]
+Test = 0
+
+[LBS-OOMRPositionerOpen-0001]
+Test = 1
+
+[LBS-OOMRPositionerSetRequestor-0001]
+Test = 2
+
+[LBS-OOMCRequestorConstruction-0001]
+Test = 3
+
+[LBS-OOMCRequestorSetRequestor-0001]
+Test = 4
+
+[LBS-OOMCRequestorStreaming-0001]
+Test = 5
+
+[LBS-OOMRRequestorStackStreaming-0001]
+Test = 6
+
+[LBS-OOMHPositionGenericInfoConstruction-0001]
+Test = 7
+
+
+
+[LBS-RPositionServerNoConnection-0001]
+Test = 0
+
+[LBS-RPositionServerNo-0001]
+Test = 1
+
+[LBS-RPositionerNo-0001]
+Test = 3
+