/*
* Copyright (c) 2002 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:   ?Description
*
*/




// INCLUDE FILES
#include <e32svr.h>
#include <StifParser.h>
#include <Stiftestinterface.h>
#include "SAPILocTest.h"
#include <f32file.h>
#include <LbsPosition.h>
#include <LbsPositionInfo.h> 
#include <LbsCommon.h>


_LIT(LogFileName , "C:\\tsapiloctest.txt") ;
TInt returnCode;
RFile LogFile ;
RFs LogSession ;

#define GETLOCATION 0
#define TRACE 1
void OpenFile()
	{
	LogSession.Connect() ;

	if(LogFile.Open(LogSession ,LogFileName , EFileWrite | EFileShareAny )  == KErrNotFound)
		{
		LogFile.Create(LogSession ,LogFileName , EFileWrite | EFileShareAny ) ;
		}

	TInt End = 0 ;
	LogFile.Seek(ESeekEnd , End) ; 
	}

void CloseFile()
	{
	LogFile.Close() ;
	LogSession.Close() ;
	}

TInt ValidatePosition(TPosition& aPos)
	{
	TReal64 aLatitude  = aPos.Latitude();
	TReal64 aLongitude = aPos.Longitude() ;
	TReal32 aAltitude  = aPos.Altitude() ;

	if( (-90<=aLatitude<=90) && (-180<=aLongitude<=180) && (aAltitude) )
		{
		OpenFile();
		TBuf8<50> buf ;
		TRealFormat format ;
		
	    //Logging Latitude 
		buf.Num(aLatitude , format) ;
		LogFile.Write(_L8("Latitude = "));
		LogFile.Write(buf) ;
		LogFile.Write(_L8("\n")) ;
		//Logging Longitude
		buf.Num(aLongitude , format); 
		LogFile.Write(_L8("Longitude = "));
		LogFile.Write(buf) ;
		LogFile.Write(_L8("\n")) ;
		//Logging Altitude 
		buf.Num(aAltitude , format) ;
		LogFile.Write(_L8("Altitude = "));
		LogFile.Write(buf) ;
		LogFile.Write(_L8("\n")) ;
		CloseFile();
	    return KErrNone; 
		 }
	 else
		 {
	     OpenFile();
	     LogFile.Write(_L8("Test case failed.."));
		 CloseFile();
		 return KErrGeneral;	
		 }
	}
    



// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CSAPILocTest::Delete
// Delete here all resources allocated and opened from test methods. 
// Called from destructor. 
// -----------------------------------------------------------------------------
//
void CSAPILocTest::Delete() 
    {

    }

// -----------------------------------------------------------------------------
// CSAPILocTest::RunMethodL
// Run specified method. Contains also table of test mothods and their names.
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::RunMethodL( 
    CStifItemParser& aItem ) 
    {

    static TStifFunctionInfo const KFunctions[] =
        {  
        // Copy this line for every implemented function.
        // First string is the function name used in TestScripter script file.
        // Second is the actual implementation member function. 
         ENTRY( "CreateLocObjWSer",    CSAPILocTest::CreateLocObjWSer ),
         ENTRY( "CreateLocObjs",    CSAPILocTest::CreateLocObjs ),
      // ENTRY( "CreateLocObjWOSer",    CSAPILocTest::CreateLocObjWOSer ),
         ENTRY( "GetPosition",    CSAPILocTest::GetPosition ),
         ENTRY( "GetPosition1",    CSAPILocTest::GetPosition1 ),
         ENTRY( "GetPosition2",    CSAPILocTest::GetPosition2 ),
      // ENTRY( "GetPositionTO",    CSAPILocTest::GetPositionTO ),
         ENTRY( "GetPositionAsync",    CSAPILocTest::GetPositionAsync ),
     //  ENTRY( "GetPositionAsyncTO",    CSAPILocTest::GetPositionAsyncTO ),
      // ENTRY( "GetPositionAsyncOpts",    CSAPILocTest::GetPositionAsyncOpts),
         ENTRY( "GetPositionAsyncOpts1",    CSAPILocTest::GetPositionAsyncOpts1),
         ENTRY( "GetPositionAsyncOpts2",    CSAPILocTest::GetPositionAsyncOpts2),
         ENTRY( "GetPositionAsyncOpts3",    CSAPILocTest::GetPositionAsyncOpts3),
         ENTRY( "GetPositionAsyncOpts4",    CSAPILocTest::GetPositionAsyncOpts4),
         ENTRY( "GetPositionAsyncOpts5",    CSAPILocTest::GetPositionAsyncOpts5),
         ENTRY( "GetPositionAsyncOpts6",    CSAPILocTest::GetPositionAsyncOpts6),
         ENTRY( "TraceLPosition",    CSAPILocTest::TraceLPosition),
         ENTRY( "TraceLPosition1",    CSAPILocTest::TraceLPosition1),
      // ENTRY( "TraceLPositionTO",    CSAPILocTest::TraceLPositionTO),
         ENTRY( "TraceLPosition2",    CSAPILocTest::TraceLPosition2),
         ENTRY( "TraceLPosition3",    CSAPILocTest::TraceLPosition3),
         ENTRY( "TraceLPosition4",    CSAPILocTest::TraceLPosition4),
         ENTRY( "TraceLPosition5",    CSAPILocTest::TraceLPosition5),
         ENTRY( "TraceLPosition6",    CSAPILocTest::TraceLPosition6),
         ENTRY( "TraceLPosition7",    CSAPILocTest::TraceLPosition7),
         ENTRY( "TraceLPosition8",    CSAPILocTest::TraceLPosition8),
         ENTRY( "TraceLPositionOpts",    CSAPILocTest::TraceLPositionOpts),
         ENTRY( "TraceLPositionOpts1",    CSAPILocTest::TraceLPositionOpts1),
         ENTRY( "TraceLPositionOpts2",    CSAPILocTest::TraceLPositionOpts2),
         ENTRY( "TraceLPositionOpts3",    CSAPILocTest::TraceLPositionOpts3),
         ENTRY( "CancelService1",    CSAPILocTest::CancelService1 ),
         ENTRY( "CancelService2",    CSAPILocTest::CancelService2 ),
         ENTRY( "GetTime",    CSAPILocTest::GetTime ),
         ENTRY( "GetSpeed",    CSAPILocTest::GetSpeed ),
         ENTRY( "GetPositionOpts",    CSAPILocTest::GetPositionOpts ),
         ENTRY( "GetPositionOpts1",    CSAPILocTest::GetPositionOpts1 ),
         ENTRY( "GetPositionOpts2",    CSAPILocTest::GetPositionOpts2 ),
         ENTRY( "GetPositionOpts3",    CSAPILocTest::GetPositionOpts3 ),
         ENTRY( "GetPositionOpts4",    CSAPILocTest::GetPositionOpts4 ),
         ENTRY( "GetPositionOpts5",    CSAPILocTest::GetPositionOpts5 ),
     //  ENTRY( "GetLastPosition",    CSAPILocTest::GetLastPosition ),
     //  ENTRY( "GetLastPosition1",    CSAPILocTest::GetLastPosition1 ),
         ENTRY( "GetDistance",    CSAPILocTest::GetDistance ),
         ENTRY( "GetDistance2",    CSAPILocTest::GetDistance2 ),
         ENTRY( "GetDistance3",    CSAPILocTest::GetDistance3 ),
         ENTRY( "GetDistance4",    CSAPILocTest::GetDistance4 ),
         ENTRY( "GetDistance5",    CSAPILocTest::GetDistance5 ),
         ENTRY( "GetDistance6",    CSAPILocTest::GetDistance6 ),
         ENTRY( "GetDistance7",    CSAPILocTest::GetDistance7 ),
         ENTRY( "GetDistance8",    CSAPILocTest::GetDistance8),
         ENTRY( "GetDistance9",    CSAPILocTest::GetDistance9),
         ENTRY( "GetDistance10",    CSAPILocTest::GetDistance10),
         ENTRY( "GetDistance11",    CSAPILocTest::GetDistance11),
         ENTRY( "GetDistance12",    CSAPILocTest::GetDistance12),
         ENTRY( "GetBearing",    CSAPILocTest::GetBearing),
         ENTRY( "GetBearing1",    CSAPILocTest::GetBearing1),
         ENTRY( "GetBearing2",    CSAPILocTest::GetBearing2),
         ENTRY( "GetBearing3",    CSAPILocTest::GetBearing3),
         ENTRY( "GetBearing4",    CSAPILocTest::GetBearing4),
         ENTRY( "GetBearing5",    CSAPILocTest::GetBearing5),
         ENTRY( "GetBearing6",    CSAPILocTest::GetBearing6),
         ENTRY( "GetBearing7",    CSAPILocTest::GetBearing7),
         ENTRY( "GetBearing8",    CSAPILocTest::GetBearing8),
         ENTRY( "GetBearing9",    CSAPILocTest::GetBearing9),
         ENTRY( "GetBearing10",    CSAPILocTest::GetBearing10),
         ENTRY( "GetBearing11",    CSAPILocTest::GetBearing11),
         ENTRY( "GetBearing12",    CSAPILocTest::GetBearing12),
         ENTRY( "GetBearing13",    CSAPILocTest::GetBearing13),
         ENTRY( "GetBearing14",    CSAPILocTest::GetBearing14),
         ENTRY( "Move1",    CSAPILocTest::Move1),
         ENTRY( "Move2",    CSAPILocTest::Move2),
         ENTRY( "Move3",    CSAPILocTest::Move3),
         ENTRY( "Move4",    CSAPILocTest::Move4),
         ENTRY( "Move5",    CSAPILocTest::Move5),
         ENTRY( "Move6",    CSAPILocTest::Move6),
         ENTRY( "Move7",    CSAPILocTest::Move7),
         ENTRY( "Move8",    CSAPILocTest::Move8),
         ENTRY( "Modinfo1",    CSAPILocTest::Modinfo1),
        };
        

    const TInt count = sizeof( KFunctions ) / 
                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }
    
    
    

// -----------------------------------------------------------------------------
// CSAPILocTest::CreateLocObjWSer
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::CreateLocObjWSer( CStifItemParser& /*aItem*/ )
    {
    returnCode = KErrNone;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "CreateLocationObjWSer" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );
    
    __UHEAP_MARK;
    
    CLocationService *CoreObj = CLocationService :: NewL();
    
    if( NULL == CoreObj)
	    {
    	OpenFile();
        LogFile.Write(_L8("\n<CreateLocObjWSer Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
    	CloseFile();
    	returnCode = KErrGeneral;
   		}
    else
	    {
        delete CoreObj;
    	OpenFile();
        LogFile.Write(_L8("\n<CreateLocObjWSer Test>\n"));
        LogFile.Write(_L8("Passed..\n"));
    	CloseFile();
     	returnCode = KErrNone;
	    }
    __UHEAP_MARKEND;
    return returnCode;
    }
    
    
// -----------------------------------------------------------------------------
// CSAPILocTest::CreateLocObjs
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::CreateLocObjs( CStifItemParser& /*aItem*/ )
    {
    // Print to UI
    TInt aLoopCount = 0;
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "CreateLocationObjs" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );
    
    __UHEAP_MARK;
    
    CLocationService *CoreObj[10];
     
    while( aLoopCount<10 )
	    {
	    CoreObj[aLoopCount] = CLocationService :: NewL();	
	    if( NULL == CoreObj)
	    	{
	     	OpenFile();
		    LogFile.Write(_L8("\n<CreateLocObjs Test>\n"));
		    LogFile.Write(_L8("Failed..\n"));
		    CloseFile();
		    __UHEAP_MARKEND;
		   	return KErrGeneral;		
	   	  	} 
	   	aLoopCount++;
	   	}
      
   	aLoopCount=0;
    
   	while( aLoopCount<10 )
    	{
    	delete CoreObj[aLoopCount];
    	aLoopCount++;
    	}
	    
	OpenFile();
    LogFile.Write(_L8("\n<CreateLocObjs  Test>\n"));
    LogFile.Write(_L8("Passed..\n"));
	CloseFile();
	
    __UHEAP_MARKEND;
    
    return KErrNone; 
      
	}


// -----------------------------------------------------------------------------
// CSAPILocTest::GetPosition
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetPosition( CStifItemParser& /*aItem*/ )
    {
    TInt aRet = KErrNone;
    TPositionInfo currPos;
    returnCode = KErrNone;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetLocation" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );
    
    __UHEAP_MARK;
    
    CLocationService *CoreObj = CLocationService :: NewL();
    	
    if( NULL == CoreObj)
	    {
	    OpenFile();
	    LogFile.Write(_L8("\n<GetPosition Test>\n"));
	    LogFile.Write(_L8("Failed..\n"));
	    CloseFile();
	   	return KErrGeneral;
	   	}
    //This is not required now
    /*TRAPD( error,aRet = CoreObj->GetLocationL(&currPos) );
    
    if( KErrAccessDenied == aRet)
    	{
    	OpenFile();
	    LogFile.Write(_L8("\n<GetPosition Test>\n"));
	    LogFile.Write(_L8("Passed..\n"));
	    CloseFile();
	    delete CoreObj;
    	__UHEAP_MARKEND;
    	return KErrNone;	
    	}
 
      else
    	{
    	OpenFile();
	    LogFile.Write(_L8("\n<GetPosition Test>\n"));
	    LogFile.Write(_L8("Failed..\n"));
	    CloseFile();
	    delete CoreObj;
    	__UHEAP_MARKEND;
    	return KErrGeneral;	
    	}*/
    else
    	{
    	OpenFile();
	    LogFile.Write(_L8("\n<GetPosition Test>\n"));
	    LogFile.Write(_L8("Passed..\n"));
	    CloseFile();
	    delete CoreObj;
    	__UHEAP_MARKEND;
    	return KErrNone;	
    		
    	}	
  }
    

// -----------------------------------------------------------------------------
// CSAPILocTest::GetPosition1
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetPosition1( CStifItemParser& /*aItem*/ )
    {
    TInt aRet = KErrNone,aFlag;
    TPositionInfo currPos;
    returnCode = KErrNone;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetLocation" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );
    
    __UHEAP_MARK;
    
    CLocationService *CoreObj = CLocationService :: NewL();
    	
    if( NULL == CoreObj)
	    {
	    OpenFile();
	    LogFile.Write(_L8("\n<GetPosition1 Test>\n"));
	    LogFile.Write(_L8("Failed..\n"));
	    CloseFile();
	   	return KErrGeneral;
	   	}
    
    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
	/*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);
    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    
    TRAP(aRet , CoreObj->GetLocationL(&currPos) );
    
    if( KErrNone == aRet )
    	{
    	OpenFile();
    	LogFile.Write(_L8("\n<GetPosition Test>\n"));
    	CloseFile();
    	TPosition currPos1; 
    	currPos.GetPosition(currPos1);
    	aFlag = ValidatePosition(currPos1);
    	returnCode = aFlag ;    
    	}
    
    else
    	{
        OpenFile();
	    LogFile.Write(_L8("\n<GetPosition1 Test>\n"));
	    LogFile.Write(_L8("Failed..\n"));
	    CloseFile();
    	returnCode = KErrGeneral;
    	}
 	/*aRequestorStack.Close();
    delete identityInfo;*/
    delete CoreObj;
   	__UHEAP_MARKEND;
	
	return returnCode;	
 	}
        
// -----------------------------------------------------------------------------
// CSAPILocTest::GetPosition2
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetPosition2( CStifItemParser& /*aItem*/ )
    {
	TInt aRet1,aRet2,aFlag1,aFlag2;
	TInt aError[2];
	TPositionInfo currPos1;
	TPositionInfo currPos2;
	TPosition currPosition1;
	TPosition currPosition2;
    returnCode = KErrNone;
    	
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetLocation2" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );
    
    __UHEAP_MARK;
    
    CLocationService *CoreObj = CLocationService :: NewL();
    
    if( NULL == CoreObj )
    	{
    	OpenFile();
	    LogFile.Write(_L8("\n<GetPosition2 Test>\n"));
	    LogFile.Write(_L8("Failed(Null CoreObj)..\n"));
	    CloseFile();
   		return KErrGeneral;
   		}
    
    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
	/*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);
    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/
	
    //User::After(120000000) ;	
    TRAP(aRet1,CoreObj->GetLocationL(&currPos1) );


    if (KErrNone == aRet1)
        {
        TRAPD(aRet2,CoreObj->GetLocationL(&currPos2)) ;

        OpenFile();
        LogFile.Write(_L8("\n<GetPosition2 Test>\n"));
        CloseFile();

        currPos1.GetPosition(currPosition1);
        currPos2.GetPosition(currPosition2);
        aFlag1 = ValidatePosition(currPosition1);
        aFlag2 = ValidatePosition(currPosition2);

        if((KErrNone == aFlag1) && (KErrNone == aFlag2))
            {
            OpenFile();
            LogFile.Write(_L8("Passed..\n"));
            CloseFile();
            returnCode = KErrNone;
            }
        else
            {
            OpenFile();
            LogFile.Write(_L8("Failed..\n"));
            CloseFile();
            returnCode = KErrGeneral;	
            }
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPosition2 Test>\n"));
        LogFile.Write(_L8("Failed(getloc error)..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    /*aRequestorStack.Close();
	 delete identityInfo;*/
    delete CoreObj;

    __UHEAP_MARKEND;

    return returnCode;	

    }




// -----------------------------------------------------------------------------
// CSAPILocTest::GetPositionAsync
// -----------------------------------------------------------------------------
//

class LocUpdateCallBack : public MLocationCallBack
    {
    TInt iCount ;
    TInt iRetStatus ;
    TInt iRequestType;
    TInt iTransactionId;
    public :
        TInt HandleNotifyL(HPositionGenericInfo* aOutPos , TInt aError) ;
        LocUpdateCallBack(TInt transId,TInt req) :iCount(0) , iRetStatus(KErrGeneral){
        iTransactionId = transId;
        iRequestType = req;
        }

        inline TUint GetRequestType(void) 
            {
            return iRequestType ;
            }


        /**
         * GetTransactionId function returns transcation id associated with current async object
         *
         */
        inline TInt32 GetTransactionId(void)
            {
            return iTransactionId ;
            }
    };


TInt LocUpdateCallBack :: HandleNotifyL(HPositionGenericInfo *currPos , TInt /*aError*/)
    {
    //	User::After(60000000);
    TInt aRetVal = KErrNone;

    OpenFile();
    LogFile.Write(_L8("\n<GetPositionAsync Test>\n "));
    CloseFile();
    TPosition outPos ;
    currPos->GetPosition(outPos) ;
    aRetVal = ValidatePosition(outPos);

    if( KErrNone == aRetVal )
        {
        OpenFile();
        LogFile.Write(_L8("Passed..\n"));
        CloseFile();
        returnCode = KErrNone;
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    CActiveScheduler *Current = CActiveScheduler :: Current() ;
    Current->Stop() ;
    return KErrNone ;
    }

TInt GetLocFunctionL()
    {
    TBuf8<20> retBuf;
    TRealFormat retFormat;
    __UHEAP_MARK ;
    CLocationService *CoreObj = CLocationService ::NewL() ;

    if( NULL == CoreObj )
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionAsync Test>\n"));
        LogFile.Write(_L8("Failed(CoreObj Creation)..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    LocUpdateCallBack MyUpdates(10,GETLOCATION)  ;

    CoreObj->GetLocationL(&MyUpdates) ;

    // User::After(60000000);
    CActiveScheduler :: Start() ;

    retBuf.Num(returnCode,retFormat) ;
    OpenFile();
    LogFile.Write(_L8("\nreturnCode : "));
    LogFile.Write(retBuf);
    CloseFile();
    /*aRequestorStack.Close();
    delete identityInfo;*/
    delete CoreObj;
    __UHEAP_MARKEND ;
    return 0;
    }

TInt CSAPILocTest::GetPositionAsync( CStifItemParser& /*aItem*/ )
    {
    TRequestStatus status = KRequestPending;
    TInt aRet = KErrNone;
    returnCode = KErrNone;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetPositionAsync" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TRAPD(err , aRet = GetLocFunctionL()) ;
    if( err || aRet )
        returnCode = KErrGeneral; 

    __UHEAP_MARKEND;

    return returnCode;  
    }



// -----------------------------------------------------------------------------
// CSAPILocTest::GetPositionAsyncOpts1
// -----------------------------------------------------------------------------
//
class LocUpdateCallBackOpts1 : public MLocationCallBack
    {
    TInt iCount ;
    TInt iRetStatus ;
    TInt iTransactionId;
    TInt iRequestType;
    public :
        TInt HandleNotifyL(HPositionGenericInfo* aOutPos , TInt aError) ;
        LocUpdateCallBackOpts1(TInt transId,TInt req) :iCount(0) , iRetStatus(KErrGeneral)  //Default constructor 
		        {
		        iTransactionId  = transId;
		        iRequestType = req;
		        }
        inline TUint GetRequestType(void) 
            {
            return iRequestType ;
            }


        /**
         * GetTransactionId function returns transcation id associated with current async object
         *
         */
        inline TInt32 GetTransactionId(void)
            {
            return iTransactionId ;
            }
    };

TInt LocUpdateCallBackOpts1 :: HandleNotifyL(HPositionGenericInfo* /*currPos*/ , TInt aError)
    {
    if(KErrTimedOut == aError)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionAsyncOpts1 Async test>\n "));
        LogFile.Write(_L8("Passed..\n "));
        CloseFile(); 
        returnCode = KErrNone;
        }

    else
        {
        OpenFile();
        LogFile.Write(_L8("GetPositionAsyncOpts1 Async failed "));
        CloseFile();
        returnCode = KErrGeneral;
        }


    CActiveScheduler *Current = CActiveScheduler :: Current() ;
    Current->Stop() ;

    return KErrNone ;
    }

TInt GetLocFunctionOpts1L()
    {
    __UHEAP_MARK ;
    TInt ret;
    TPositionUpdateOptions aOptions;
    TTimeIntervalMicroSeconds aTimeOut = 100;

    CLocationService *CoreObj = CLocationService ::NewL() ;
    if( NULL == CoreObj )
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionAsyncOpts1 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;

	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    LocUpdateCallBackOpts1 MyUpdates(11,GETLOCATION) ;

    aOptions.SetUpdateTimeOut(aTimeOut);

    TRAP(ret,CoreObj->GetLocationL(&MyUpdates,0,NULL ,&aOptions)) ;

    if(KErrNone == ret)
        {
        CActiveScheduler :: Start() ;	
        }

    else
        {
        returnCode = KErrGeneral;	
        }

    //aRequestorStack.Close();

    delete CoreObj;
    
    __UHEAP_MARKEND ;
    return KErrNone;;
    }


TInt CSAPILocTest::GetPositionAsyncOpts1( CStifItemParser& /*aItem*/ )
    {
    TRequestStatus status = KRequestPending;
    TInt aRet = KErrNone;
    returnCode = KErrNone;

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetPositionAsyncOpts1" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TInt start = User::CountAllocCells();
    TRAPD(err ,aRet = GetLocFunctionOpts1L()) ;
    if( err || aRet)
        returnCode = KErrGeneral;

    TInt end = User::CountAllocCells();

    __UHEAP_MARKEND;

    return returnCode;  
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetPositionAsyncOpts2
// -----------------------------------------------------------------------------
//

class LocUpdateCallBackOpts2 : public MLocationCallBack
    {
    TInt iCount ;
    TInt iRetStatus ;
    TInt iRequestType;
    TInt iTransactionId;
    public :
        TInt HandleNotifyL(HPositionGenericInfo* aOutPos , TInt aError) ;
        LocUpdateCallBackOpts2(TInt transId,TInt req) :iCount(0) , iRetStatus(KErrGeneral){
        iTransactionId = transId;
        iRequestType = req;
        }

        inline TUint GetRequestType(void) 
            {
            return iRequestType ;
            }


        /**
         * GetTransactionId function returns transcation id associated with current async object
         *
         */
        inline TInt32 GetTransactionId(void)
            {
            return iTransactionId ;
            }
    };


TInt LocUpdateCallBackOpts2 :: HandleNotifyL(HPositionGenericInfo* currPos , TInt aError)
    {
    // User::After(60000000);
    if(KErrNone == aError)
        {
        TPosition currPos1;
        currPos->GetPosition(currPos1);
        //	 ValidatePosition(currPos1);
        TBuf8<50> buf;
        TRealFormat format ;
        TInt64 aTime1;;
        TTime aTimeStamp1;
        aTimeStamp1 = currPos1.Time();
        aTime1 = aTimeStamp1.Int64();
        buf.Num(aTime1 , format) ;
        if(aTime1) 
            {
            OpenFile();
            LogFile.Write(_L8("Time = "));
            LogFile.Write(buf) ;
            CloseFile();
            returnCode = KErrNone;
            }
        else
            {
            OpenFile();
            LogFile.Write(_L8("\nFailed(Time value).."));
            CloseFile();
            returnCode = KErrGeneral;
            }

        }

    else
        {
        OpenFile();
        LogFile.Write(_L8("\nFailed(Handlenotifyl error).."));
        CloseFile();
        returnCode = KErrGeneral;
        }

    CActiveScheduler *Current = CActiveScheduler :: Current() ;
    Current->Stop() ;
    return KErrNone ;
    }


TInt GetLocFunctionOpts2L()
    {
    __UHEAP_MARK ;
    TInt ret;
    TPositionInfo aPosition1,aPosition2,aPosition3;  
    TPosition aPos1,aPos2,aPos3;
    TPositionUpdateOptions aOptions;
    TTime start,end;
    TTimeIntervalMicroSeconds aTimeOut =  6000000;
    TTimeIntervalMicroSeconds aInterval = 60000000;
    TTimeIntervalMicroSeconds aActualInterval;

    CLocationService *CoreObj = CLocationService ::NewL() ;

    if( NULL == CoreObj )
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionAsyncOpts2 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    LocUpdateCallBackOpts2 MyUpdates(12,GETLOCATION) ;
    aOptions.SetUpdateTimeOut(aTimeOut);
    aOptions.SetUpdateInterval(aInterval);

    TRAP(ret ,CoreObj->GetLocationL(&MyUpdates,0,NULL,&aOptions) );

    if( KErrArgument == ret )
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionAsyncOpts1 test>\n"));
        LogFile.Write(_L8("Passed\n"));
        CloseFile();
        returnCode = KErrNone;
        /*aRequestorStack.Close();
	    delete identityInfo;*/
        delete CoreObj;
        __UHEAP_MARKEND ;
        return returnCode;	
        }

    else
        {
        /*aRequestorStack.Close();
	    delete identityInfo;*/
        delete CoreObj;
        returnCode = KErrGeneral;
        __UHEAP_MARKEND ;
        return returnCode;
        }
    }


TInt CSAPILocTest::GetPositionAsyncOpts2( CStifItemParser& /*aItem*/ )
    {
    TRequestStatus status = KRequestPending;
    TInt aRet = KErrNone;
    returnCode = KErrNone;	    
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetPositionAsyncOpts2" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TRAPD(err ,aRet = GetLocFunctionOpts2L()) ;
    if( err || aRet )
        returnCode = KErrGeneral;

    __UHEAP_MARKEND;

    return returnCode;  
    }



// -----------------------------------------------------------------------------
// CSAPILocTest::GetPositionAsyncOpts3
// -----------------------------------------------------------------------------
//

class LocUpdateCallBackOpts3 : public MLocationCallBack
    {
    TInt iCount ;
    TInt iRetStatus ;
    TInt iTransactionId;
    TInt iRequestType;

    public :
        TInt HandleNotifyL(HPositionGenericInfo* aOutPos , TInt aError) ;
        LocUpdateCallBackOpts3(TInt transId,TInt req) :iCount(0) , iRetStatus(KErrGeneral){
        iTransactionId = transId;
        iRequestType = req;
        }

        inline TUint GetRequestType(void) 
            {
            return iRequestType ;
            }


        /**
         * GetTransactionId function returns transcation id associated with current async object
         *
         */
        inline TInt32 GetTransactionId(void)
            {
            return iTransactionId ;
            }
    };


TInt LocUpdateCallBackOpts3 :: HandleNotifyL(HPositionGenericInfo* currPos , TInt aError)
    {
    //  User::After(60000000);
    if(KErrNone == aError)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionAsyncOpts3 test>\n"));
        CloseFile();
        TBuf8<50> buf;
        TRealFormat format ;
        TInt64 aTime1;;
        TTime aTimeStamp1;
        TPosition currPos1;
        currPos->GetPosition(currPos1);
        aTimeStamp1 = currPos1.Time();
        aTime1 = aTimeStamp1.Int64();
        buf.Num(aTime1 , format) ;
        if(aTime1) 
            {
            OpenFile();
            LogFile.Write(_L8("Time = "));
            LogFile.Write(buf) ;
            LogFile.Write(_L8("\n"));
            CloseFile();
            returnCode = KErrNone;
            }
        else
            {
            OpenFile();
            LogFile.Write(_L8("\nFailed to write Time value"));
            CloseFile();
            returnCode = KErrGeneral;
            }
        }

    else
        {
        OpenFile();
        LogFile.Write(_L8("\nFailed.."));
        CloseFile();
        returnCode = KErrGeneral;
        }

    CActiveScheduler *Current = CActiveScheduler :: Current() ;
    Current->Stop() ;
    return KErrNone ;
    }


TInt GetLocFunctionOpts3L()
    {
    __UHEAP_MARK ;
    TInt ret;
    TPositionInfo aPosition1,aPosition2,aPosition3;  
    TPosition aPos1,aPos2,aPos3;
    TPositionUpdateOptions aOptions;
    TTimeIntervalMicroSeconds aTimeOut =  60000000;
    TTimeIntervalMicroSeconds aInterval = 6000000;
    TBool aAcceptPartialUpdates = ETrue;

    CLocationService *CoreObj = CLocationService ::NewL() ;
    if( NULL == CoreObj )
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionAsyncOpts3 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    LocUpdateCallBackOpts3 MyUpdates(29,GETLOCATION) ;

    aOptions.SetUpdateTimeOut(aTimeOut);
    aOptions.SetUpdateInterval(aInterval);
    aOptions.SetAcceptPartialUpdates(aAcceptPartialUpdates);

    TRAP(ret,CoreObj->GetLocationL(&MyUpdates,0,NULL,&aOptions)) ;

    if( KErrNone == ret)
        {
        CActiveScheduler :: Start() ;
        if( KErrNone == returnCode )
            {
            CoreObj->GetLocationL(&aPosition1,&aOptions);
            //CoreObj->GetLocationL(&aPosition2,&aOptions);
            //CoreObj->GetLocationL(&aPosition3,&aOptions);

            aPosition1.GetPosition(aPos1);

            returnCode = ValidatePosition(aPos1);

            /*    if( KErrNone == returnCode)
			    	{
			       	aPosition2.GetPosition(aPos2);
			       	returnCode = ValidatePosition(aPos2);
			    	}

			    if( KErrNone == returnCode)
			    	{
			       	aPosition3.GetPosition(aPos3);
			    	returnCode = ValidatePosition(aPos3);
			    	}
             */
            //aRequestorStack.Close();

            delete CoreObj;
            __UHEAP_MARKEND ;
            return returnCode;	
            }
        else
            {
            //aRequestorStack.Close();

            delete CoreObj;
            __UHEAP_MARKEND ;
            return returnCode;
            }
        }

    else
        {
        /*aRequestorStack.Close();
	    delete identityInfo;*/
        delete CoreObj;
        __UHEAP_MARKEND ;
        return KErrGeneral;
        }
    }


TInt CSAPILocTest::GetPositionAsyncOpts3( CStifItemParser& /*aItem*/ )
    {

    TRequestStatus status = KRequestPending;
    TInt aRet = KErrNone;
    returnCode = KErrNone;

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetPositionAsyncOpts3" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TRAPD(err , aRet = GetLocFunctionOpts3L()) ;
    if( err || aRet )
        returnCode = KErrGeneral;

    __UHEAP_MARKEND;

    return returnCode;  
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetPositionAsyncOpts4
// -----------------------------------------------------------------------------
//

class LocUpdateCallBackOpts4 : public MLocationCallBack
    {
    TInt iCount ;
    TInt iRetStatus ;
    TInt iTransactionId;
    TInt iRequestType;
    public :
        TInt HandleNotifyL(HPositionGenericInfo* aOutPos , TInt aError) ;
        LocUpdateCallBackOpts4(TInt transId,TInt req) :iCount(0) , iRetStatus(KErrGeneral){
        iTransactionId = transId;
        iRequestType = req;
        }

        inline TUint GetRequestType(void) 
            {
            return iRequestType ;
            }


        /**
         * GetTransactionId function returns transcation id associated with current async object
         *
         */
        inline TInt32 GetTransactionId(void)
            {
            return iTransactionId ;
            }
    };


TInt LocUpdateCallBackOpts4 :: HandleNotifyL(HPositionGenericInfo* currPos , TInt aError)
    {
    //User::After(120000000);

    if(KErrNone == aError)
        {
        TPosition currPos1;
        currPos->GetPosition(currPos1);

        TBuf8<50> buf;
        TRealFormat format ;
        TInt64 aTime1;
        TTime aTimeStamp1;

        aTimeStamp1 = currPos1.Time();
        aTime1 = aTimeStamp1.Int64();
        buf.Num(aTime1 , format) ;

        if(aTime1) 
            {
            OpenFile();
            LogFile.Write(_L8("Time = "));
            LogFile.Write(buf) ;
            LogFile.Write(_L8("\n"));
            CloseFile();
            returnCode = KErrNone;
            }
        else
            {
            OpenFile();
            LogFile.Write(_L8("\nFailed(No TimeStamp).. "));
            CloseFile();
            returnCode = KErrGeneral;
            }
        }

    else
        {
        OpenFile();
        LogFile.Write(_L8("\nFailed(HandleNotifyL error).."));
        CloseFile();
        returnCode = KErrGeneral;
        }

    CActiveScheduler *Current = CActiveScheduler :: Current() ;
    Current->Stop() ;
    return returnCode ;
    }


TInt GetLocFunctionOpts4L()
    {
    __UHEAP_MARK ;
    TInt ret;
    TPositionInfo aPosition1;  
    TPosition aPos1;
    TPositionUpdateOptions aOptions;
    TTimeIntervalMicroSeconds aTimeOut =  10000000;
    TTimeIntervalMicroSeconds aInterval = 6000000;
    TBool aAcceptPartialUpdates = EFalse;

    CLocationService *CoreObj = CLocationService ::NewL() ;

    if( NULL == CoreObj )
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionAsyncOpts4 Test>\n"));
        LogFile.Write(_L8("Failed(Null CoreObj)..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    LocUpdateCallBackOpts4 MyUpdates(30,GETLOCATION) ;

    aOptions.SetUpdateTimeOut(aTimeOut);
    aOptions.SetUpdateInterval(aInterval);
    aOptions.SetAcceptPartialUpdates(aAcceptPartialUpdates);

    OpenFile();
    LogFile.Write(_L8("\n<GetPositionAsyncOpts4 test>\n"));
    CloseFile();
    TRAP(ret , CoreObj->GetLocationL(&MyUpdates,0,NULL,&aOptions) );
    if( KErrNone == ret)
        {
        CActiveScheduler :: Start() ;
        if( KErrNone == returnCode )
            {
            CoreObj->GetLocationL(&aPosition1,&aOptions);
            aPosition1.GetPosition(aPos1);

            // ValidatePosition(aPos1);

            /*aRequestorStack.Close();
		    delete identityInfo;*/
            delete CoreObj;
            __UHEAP_MARKEND ;
            return returnCode;	
            }
        else
            {
            /*aRequestorStack.Close();
		    delete identityInfo;*/
            delete CoreObj;
            __UHEAP_MARKEND ;
            return returnCode;
            }
        }

    else
        {
        /*aRequestorStack.Close();
	    delete identityInfo;*/
        delete CoreObj;
        __UHEAP_MARKEND ;
        return returnCode;
        }
    }


TInt CSAPILocTest::GetPositionAsyncOpts4( CStifItemParser& /*aItem*/ )
    {

    TInt aRet = KErrNone;
    returnCode = KErrNone;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetPositionAsyncOpts4" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TRAPD(err , aRet = GetLocFunctionOpts4L()) ;
    if( err )
        returnCode = KErrGeneral; 

    __UHEAP_MARKEND;

    return returnCode;  
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetPositionAsyncOpts5
// -----------------------------------------------------------------------------
//

TInt GetLocFunctionOpts5L()
    {
    TInt ret1,ret2;
    TPositionInfo aPosition1,aPosition2,aPosition3;  
    TPosition aPos1,aPos2,aPos3;
    TPositionUpdateOptions aOptions;
    TTimeIntervalMicroSeconds aTimeOut =  10000000;
    TTimeIntervalMicroSeconds aInterval = 6000000;
    TBool aAcceptPartialUpdates = ETrue;
    __UHEAP_MARK ;
    CLocationService *CoreObj = CLocationService ::NewL() ;
    if( NULL == CoreObj )
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionAsyncOpts5 Test>\n"));
        LogFile.Write(_L8("Failed(CoreObj Creation)..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    LocUpdateCallBackOpts4 MyUpdates1(32,GETLOCATION) ;
    LocUpdateCallBackOpts4 MyUpdates2(33,GETLOCATION) ;

    aOptions.SetUpdateTimeOut(aTimeOut);
    aOptions.SetUpdateInterval(aInterval);
    aOptions.SetAcceptPartialUpdates(aAcceptPartialUpdates);

    OpenFile();
    LogFile.Write(_L8("\n<GetPositionAsyncOpts5 test>\n"));
    CloseFile();

    TRAP(ret1 ,CoreObj->GetLocationL(&MyUpdates1) );

    TRAP(ret2, CoreObj->GetLocationL(&MyUpdates2)) ;

    if( KErrNone == ret1 && KErrNone == ret2 )
        {
        TBuf8<20> retBuf;
        TRealFormat retFormat;

        CActiveScheduler :: Start() ;

        OpenFile();
        LogFile.Write(_L8("\nreturnCode : "));
        LogFile.Write(retBuf);
        CloseFile();
        }

    else
        {
        returnCode = KErrGeneral;	
        }
    //aRequestorStack.Close();

    delete CoreObj;
    __UHEAP_MARKEND ;
    return 0;
    }


TInt CSAPILocTest::GetPositionAsyncOpts5( CStifItemParser& /*aItem*/ )
    {
    TInt aRet = KErrNone;
    returnCode = KErrNone;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetPositionAsyncOpts5" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TRAPD(err ,aRet =  GetLocFunctionOpts5L()) ;
    if( err || aRet )
        returnCode = KErrGeneral;

    __UHEAP_MARKEND;

    return returnCode;  
    }



// -----------------------------------------------------------------------------
// CSAPILocTest::GetPositionAsyncOpts6
// -----------------------------------------------------------------------------
//
TInt GetLocFunctionOpts6L()
    {
    __UHEAP_MARK ;
    TInt aRet,aRet1;
    TPosition aPosition1;  
    TPositionUpdateOptions aOptions;
    TTimeIntervalMicroSeconds aTimeOut =  60000000;
    TTimeIntervalMicroSeconds aInterval = 6000000;
    TBool aAcceptPartialUpdates = ETrue;

    CLocationService *CoreObj = CLocationService ::NewL() ;
    if( NULL == CoreObj )
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionAsyncOpts6 Test>\n"));
        LogFile.Write(_L8("Failed(Null CoreObj)..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    LocUpdateCallBackOpts2 MyUpdates(13,GETLOCATION) ;

    aOptions.SetUpdateTimeOut(aTimeOut);
    aOptions.SetUpdateInterval(aInterval);
    aOptions.SetAcceptPartialUpdates(aAcceptPartialUpdates);

    TRAP(aRet , CoreObj->GetLocationL(&MyUpdates) );

    if( KErrNone == aRet )
        {
        aRet1 = CoreObj->CancelOnGoingService(0);
        if( KErrNone == aRet1 )
            {
            TBuf8<20> retBuf;
            TRealFormat retFormat;
            TRAP(aRet ,CoreObj->GetLocationL(&MyUpdates)) ;
            if( KErrNone == aRet)
                OpenFile();
            LogFile.Write(_L8("\n<GetPositionAsyncOpts6 test>\n"));
            CloseFile();
            CActiveScheduler :: Start() ;
            retBuf.Num(returnCode,retFormat);
            OpenFile();
            LogFile.Write(_L8("\nreturnCode : "));
            LogFile.Write(retBuf);
            CloseFile();
            }
        else
            {
            returnCode = KErrGeneral;
            }
        }
    else
        {
        returnCode = KErrGeneral;	
        }

    //aRequestorStack.Close();

    delete CoreObj;
    __UHEAP_MARKEND ;
    return 0;
    }


TInt CSAPILocTest::GetPositionAsyncOpts6( CStifItemParser& /*aItem*/ )
    {
    TInt aRet = KErrNone;
    returnCode = KErrNone;

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetPositionAsyncOpts6" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TRAPD(err , aRet = GetLocFunctionOpts6L()) ;

    __UHEAP_MARKEND;

    return returnCode;  
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::TraceLPosition
// -----------------------------------------------------------------------------
//

class TraceLCallBack : public MLocationCallBack
    {
    TInt iCount ;
    TInt iRetStatus ;
    TInt iRequestType;
    TInt iTransactionId;
    public :
        TInt HandleNotifyL(HPositionGenericInfo* aOutPos , TInt aError) ;
        TraceLCallBack(TInt transId,TInt req) :iCount(0) , iRetStatus(KErrGeneral){
        iTransactionId = transId;
        iRequestType = req;
        }

        inline TUint GetRequestType(void) 
            {
            return iRequestType ;
            }


        /**
         * GetTransactionId function returns transcation id associated with current async object
         *
         */
        inline TInt32 GetTransactionId(void)
            {
            return iTransactionId ;
            }
    };



TInt TraceLCallBack :: HandleNotifyL(HPositionGenericInfo* currPos , TInt aError)
    {
    //	User::After(60000000);
    if(KErrNone == aError && iCount<2)
        {
        TPosition currPos1;
        currPos->GetPosition(currPos1);
        //	ValidatePosition(currPos1);
        iCount++;	 
        }
    else
        {
        CActiveScheduler *Current = CActiveScheduler :: Current() ;
        Current->Stop() ;
        // returnCode = KErrNone;
        }
    return returnCode;
    }


TInt TraceLFunctionL()
    {
    __UHEAP_MARK ;
    TInt ret;
    TPosition aPosition1;  

    CLocationService *CoreObj = CLocationService ::NewL() ;
    if( NULL == CoreObj )
        {
        OpenFile();
        LogFile.Write(_L8("\n<TraceLPosition Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    TraceLCallBack MyUpdates(14,TRACE) ;

    TRAP(ret, CoreObj->TraceL(&MyUpdates) );
    if( KErrNone == ret)
        {
        TBuf8<20> retBuf;
        TRealFormat retFormat;

        OpenFile();
        LogFile.Write(_L8("\n<TraceLPosition test>\n"));
        CloseFile();
        CActiveScheduler :: Start() ;

        retBuf.Num(returnCode,retFormat);
        OpenFile();
        LogFile.Write(_L8("\nreturnCode : "));
        LogFile.Write(retBuf);
        CloseFile();
        }
    else
        {
        returnCode = KErrGeneral;	
        }

    //aRequestorStack.Close();

    delete CoreObj;
    __UHEAP_MARKEND ;
    return 0;
    }	


TInt CSAPILocTest::TraceLPosition( CStifItemParser& /*aItem*/ )
    {
    TInt aRet = KErrNone;
    returnCode = KErrNone;

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "TraceLPosition" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TRAPD(err ,aRet = TraceLFunctionL() ) ;

    if( err || aRet )
        returnCode = KErrGeneral;

    __UHEAP_MARKEND;

    return returnCode;  
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::TraceLPosition1
// -----------------------------------------------------------------------------
//
TInt TraceLFunction1L()
    {
    TInt ret1,ret2;
    TPosition aPosition1;  
    __UHEAP_MARK ;
    CLocationService *CoreObj = CLocationService ::NewL() ;
    if( NULL == CoreObj )
        {
        OpenFile();
        LogFile.Write(_L8("\n<TraceLPosition1 Test>\n"));
        LogFile.Write(_L8("Failed(Null CoreObj)..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    TraceLCallBack MyUpdates(15,TRACE) ;

    TRAP(ret1, CoreObj->TraceL(&MyUpdates)) ;
    TRAP(ret2 , CoreObj->TraceL(&MyUpdates) );

    if( KErrNone == ret1 && KErrNone == ret2)
        {
        TBuf8<20> retBuf;
        TRealFormat retFormat;

        OpenFile();
        LogFile.Write(_L8("\n<TraceLPosition1 test>\n"));
        CloseFile();

        CActiveScheduler :: Start() ;

        retBuf.Num(returnCode,retFormat);
        OpenFile();
        LogFile.Write(_L8("\nreturnCode : "));
        LogFile.Write(retBuf);
        CloseFile();
        }

    else
        {
        returnCode = KErrGeneral;	
        }
    //aRequestorStack.Close();

    delete CoreObj;
    __UHEAP_MARKEND ;
    return 0;
    }


TInt CSAPILocTest::TraceLPosition1( CStifItemParser& /*aItem*/ )
    {
    TInt aRet = KErrNone;
    returnCode = KErrNone;

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "TraceLPosition1" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TRAPD(err ,aRet = TraceLFunction1L()) ;

    if( err || aRet )
        returnCode = KErrGeneral;

    __UHEAP_MARKEND;

    return returnCode;  
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::TraceLPosition2
// -----------------------------------------------------------------------------
//

class TraceLCallBack2 : public MLocationCallBack
    {
    TInt iCount ;
    TInt iRetStatus ;
    TInt iRequestType;
    TInt iTransactionId;
    CLocationService *CoreObj;
    public :
        TInt HandleNotifyL(HPositionGenericInfo* aOutPos , TInt aError) ;
        TraceLCallBack2(TInt transId,TInt req,CLocationService* LocObj,TInt count = 0,TInt status = KErrGeneral)
            {
            iRequestType = req;
            iCount = count;
            iTransactionId = transId;
            iRetStatus = status;
            CoreObj = LocObj;	
            }

        inline TUint GetRequestType(void) 
            {
            return iRequestType ;
            }


        /**
         * GetTransactionId function returns transcation id associated with current async object
         *
         */
        inline TInt32 GetTransactionId(void)
            {
            return iTransactionId ;
            }
    };



TInt TraceLCallBack2 :: HandleNotifyL(HPositionGenericInfo* currPos , TInt aError)
    {
    //	 User::After(60000000);
    TInt aRet1;
    if(iCount<2)
        {
        TBuf8<20> retBuf;
        TRealFormat retFormat;
        retBuf.Num(aError,retFormat);

        OpenFile();
        LogFile.Write(_L8("\n<TraceLPosition2 HandleNotifyL>\n"));
        LogFile.Write(retBuf);
        CloseFile();
        TPosition currPos1;
        currPos->GetPosition(currPos1);
        //	ValidatePosition(currPos1);
        iCount++;	 

        }

    else
        {
        aRet1 = CoreObj->CancelOnGoingService(1);
        TBuf8<20> retBuf;
        TRealFormat retFormat;
        retBuf.Num(aRet1,retFormat);

        OpenFile();
        LogFile.Write(_L8("\n<TraceLPosition2 CancelOnGoingService>\n"));
        LogFile.Write(retBuf);
        CloseFile();
        if( KErrNone == aRet1 )
            {
            returnCode = KErrNone;
            CActiveScheduler *Current = CActiveScheduler :: Current() ;
            Current->Stop() ;
            }
        else
            {
            returnCode = KErrGeneral;
            CActiveScheduler *Current = CActiveScheduler :: Current() ;
            Current->Stop() ;
            }

        }
    return KErrNone; 
    }


TInt TraceLFunction2L()
    {
    __UHEAP_MARK ;
    TInt ret;
    TPosition aPosition1;  

    CLocationService *CoreObj = CLocationService ::NewL() ;
    if( NULL == CoreObj )
        {
        OpenFile();
        LogFile.Write(_L8("\n<TraceLPosition2 Test>\n"));
        LogFile.Write(_L8("Failed(CoreObj Creation)..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more

    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    TraceLCallBack2 MyUpdates(16,TRACE,CoreObj) ;

    TRAP(ret,CoreObj->TraceL(&MyUpdates) );

    if( KErrNone == ret)
        {
        TBuf8<20> retBuf;
        TRealFormat retFormat;
        OpenFile();
        LogFile.Write(_L8("\n<TraceLPosition2 test>\n"));
        CloseFile();
        CActiveScheduler :: Start() ;
        retBuf.Num(returnCode,retFormat);
        OpenFile();
        LogFile.Write(_L8("\nreturnCode : "));
        LogFile.Write(retBuf);
        CloseFile();
        }
    else
        {
        returnCode = KErrGeneral;	
        }

    //aRequestorStack.Close();

    delete CoreObj;
    __UHEAP_MARKEND ;
    return 0;
    }


TInt CSAPILocTest::TraceLPosition2( CStifItemParser& /*aItem*/ )
    {
    TInt aRet = KErrNone;
    returnCode = KErrNone; 

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "TraceLPosition2" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TRAPD(err , aRet = TraceLFunction2L()) ;
    if( err || aRet )
        returnCode = KErrGeneral;

    __UHEAP_MARKEND;

    return returnCode;  
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::TraceLPosition3
// -----------------------------------------------------------------------------
//
TInt TraceLFunction3L()
    {
    __UHEAP_MARK ;
    TInt ret1,ret2,ret3;
    TPosition aPosition1;  

    CLocationService *CoreObj = CLocationService ::NewL() ;
    if( NULL == CoreObj )
        {
        OpenFile();
        LogFile.Write(_L8("\n<TraceLPosition3 Test>\n"));
        LogFile.Write(_L8("Failed(Null CoreObj)..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more

    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    TraceLCallBack MyUpdates(31,TRACE) ;

    TRAP(ret1 , CoreObj->TraceL(&MyUpdates) );

    // ret2 = CoreObj->TraceL(&MyUpdates) ;

    if( KErrNone == ret1 )
        {
        ret3 = CoreObj->CancelOnGoingService(1);

        if( KErrNone == ret3 )
            {
            TBuf8<20> retBuf;
            TRealFormat retFormat;
            OpenFile();
            LogFile.Write(_L8("\n<TraceLPosition3 test>\n"));
            CloseFile();
            TRAP(ret1 , CoreObj->TraceL(&MyUpdates) );
            if(KErrNone == ret1)
                CActiveScheduler :: Start() ;
            retBuf.Num(returnCode,retFormat);
            OpenFile();
            LogFile.Write(_L8("\nreturnCode : "));
            LogFile.Write(retBuf);
            CloseFile();
            }
        else
            {
            returnCode = KErrGeneral;
            }
        }

    else
        {
        returnCode = KErrGeneral;
        }

    //aRequestorStack.Close();

    delete CoreObj;
    __UHEAP_MARKEND ;
    return KErrNone;
    }


TInt CSAPILocTest::TraceLPosition3( CStifItemParser& /*aItem*/ )
    {
    TInt aRet = KErrNone;
    returnCode = KErrNone;

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "TraceLPosition3" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TRAPD(err , aRet = TraceLFunction3L()) ;
    if( err || aRet )
        returnCode = KErrGeneral;

    __UHEAP_MARKEND;

    return returnCode;  
    }

// -----------------------------------------------------------------------------
// CSAPILocTest::TraceLPosition4
// -----------------------------------------------------------------------------
//
class TraceLCallBack4 : public MLocationCallBack
    {
    TInt iCount ;
    TInt iRetStatus ;
    TInt iCallIdentity;
    TInt iRequestType;
    TInt iTransactionId;
    public :
        TInt HandleNotifyL(HPositionGenericInfo* aOutPos , TInt aError) ;
        TraceLCallBack4(TInt transId,TInt req,TInt identity, TInt count = 0 , TInt status = KErrGeneral)
            {
            iTransactionId = transId;
            iRequestType = req;
            iCallIdentity = identity;
            iCount = count;
            iRetStatus = status;  
            }

        inline TUint GetRequestType(void) 
            {
            return iRequestType ;
            }


        /**
         * GetTransactionId function returns transcation id associated with current async object
         *
         */
        inline TInt32 GetTransactionId(void)
            {
            return iTransactionId ;
            }
    };


TInt TraceLCallBack4 :: HandleNotifyL(HPositionGenericInfo* currPos , TInt aError)
    {
    if(iCallIdentity == 1 && KErrNone == aError )
        {
        TPosition currPos1;
        currPos->GetPosition(currPos1);
        //  	ValidatePosition(currPos1);
        //  	returnCode = KErrNone ;
        }
    else if(KErrNone == aError && iCount<2)
        {
        TPosition currPos1;
        currPos->GetPosition(currPos1);
        //	 ValidatePosition(currPos1);
        iCount++;	 
        }

    else if(iCount>=2)
        {
        CActiveScheduler *Current = CActiveScheduler :: Current() ;
        Current->Stop() ;
        returnCode = KErrNone; 
        }
    else
        {
        returnCode = KErrGeneral;	
        }

    return returnCode;
    }

TInt TraceLFunction4L()
    {
    __UHEAP_MARK ;
    TInt ret1,ret2;
    TPosition aPosition1;  

    CLocationService *CoreObj = CLocationService ::NewL() ;

    TraceLCallBack4 MyUpdates1(17,GETLOCATION,1) ;

    TraceLCallBack4 MyUpdates2(18,TRACE,2) ;

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more

    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    TRAP(ret1 , CoreObj->GetLocationL(&MyUpdates1) );

    TRAP(ret2 , CoreObj->TraceL(&MyUpdates2) );


    if( KErrNone == ret1 && KErrNone == ret2)
        {
        TBuf8<50> buf ;
        TRealFormat format ;

        OpenFile();
        LogFile.Write(_L8("\n<TraceLPosition4 test>\n"));
        CActiveScheduler :: Start() ;

        //Logging returnCode 
        buf.Num(returnCode , format) ;
        LogFile.Write(_L8("returnCode = "));
        LogFile.Write(buf) ;
        LogFile.Write(_L8("\n")) ;
        CloseFile();
        }
    else
        {
        returnCode = KErrGeneral;
        }
    //aRequestorStack.Close();

    delete CoreObj;
    __UHEAP_MARKEND ;
    return KErrNone;

    }



TInt CSAPILocTest::TraceLPosition4( CStifItemParser& /*aItem*/ )
    {
    TInt aRet = KErrNone;
    returnCode = KErrNone;

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "TraceLPosition4" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TRAPD(err ,aRet = TraceLFunction4L()) ;
    if( err || aRet )
        returnCode = KErrGeneral;

    __UHEAP_MARKEND;

    return returnCode;  
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::TraceLPosition5
// -----------------------------------------------------------------------------
//

class CTraceLCallBack5 : public CBase , public MLocationCallBack 
    {
    TInt iCount ;
    TInt iRetStatus ;
    CLocationService *CoreObj;
    CTraceLCallBack5* iSelf;  
    TInt iRequestType;
    TInt iTransactionId;
    public :
        TInt HandleNotifyL(HPositionGenericInfo* aOutPos , TInt aError) ;
        CTraceLCallBack5(TInt transId,TInt req,CLocationService* LocObj,TInt count = 0,TInt status = KErrGeneral)
            {
            iTransactionId = transId;
            iRequestType = req;
            iCount = count;
            iRetStatus = status;
            CoreObj = LocObj;	
            }

        virtual ~CTraceLCallBack5();
        static CTraceLCallBack5* NewL(TInt aTransId,TInt req,CLocationService*) ;

        inline TUint GetRequestType(void) 
            {
            return iRequestType ;
            }


        /**
         * GetTransactionId function returns transcation id associated with current async object
         *
         */
        inline TInt32 GetTransactionId(void)
            {
            return iTransactionId ;
            }
    };

CTraceLCallBack5* CTraceLCallBack5 :: NewL(TInt aTransId,TInt req,CLocationService* obj)
    {
    CTraceLCallBack5* temp = new(ELeave) CTraceLCallBack5(aTransId,req,obj);
    temp->iSelf = temp;
    return temp;
    }

CTraceLCallBack5 :: ~CTraceLCallBack5()
    {
    delete (this->CoreObj);
    this->CoreObj = NULL;
    }

TInt CTraceLCallBack5 :: HandleNotifyL(HPositionGenericInfo* currPos , TInt aError)
    {
    // User::After(30000000);
    TInt aRet1;
    if(KErrNone == aError && iCount<2)
        {
        TPosition currPos1;
        currPos->GetPosition(currPos1);
        ValidatePosition(currPos1);
        iCount++;	 
        }

    else
        {
        aRet1 = CoreObj->CancelOnGoingService(1);
        if( KErrNone == aRet1 )
            {	
            returnCode = KErrNone;
            delete this;
            CActiveScheduler *Current = CActiveScheduler :: Current() ;
            Current->Stop() ;
            }
        else
            {
            returnCode = KErrGeneral;
            delete this;
            CActiveScheduler *Current = CActiveScheduler :: Current() ;
            Current->Stop() ;
            }	
        }

    return KErrNone; 
    }

class LocUpdateCallBack5 : public MLocationCallBack
    {
    TInt iCount ;
    TInt iRetStatus ;
    TInt iRequestType;
    TInt iTransactionId;
    public :
        TInt HandleNotifyL(HPositionGenericInfo* aOutPos , TInt aError) ;
        LocUpdateCallBack5(TInt transId,TInt req) :iCount(0) , iRetStatus(KErrGeneral){
        iTransactionId = transId;
        iRequestType = req;
        }

        inline TUint GetRequestType(void) 
            {
            return iRequestType ;
            }


        /**
         * GetTransactionId function returns transcation id associated with current async object
         *
         */
        inline TInt32 GetTransactionId(void)
            {
            return iTransactionId ;
            }
    };


TInt LocUpdateCallBack5 :: HandleNotifyL(HPositionGenericInfo* currPos , TInt /*aError*/)
    {

    TInt aRet;
    TPosition currPos1;
    currPos->GetPosition(currPos1);
    aRet = ValidatePosition(currPos1);

    if ( KErrNone == aRet )
        {
        TPosition aPosition2;  
        CLocationService *CoreObj1 = CLocationService ::NewL() ;

        _LIT(Kidentity ,"Coreclass Testing" ) ;
        //not needed any more
        /*RRequestorStack aRequestorStack;
		const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
	    aRequestorStack.Insert(identityInfo,0);

	    CoreObj1->SetRequestorIdentityL(aRequestorStack) ;*/

        CTraceLCallBack5 *MyUpdates2 = CTraceLCallBack5::NewL(18,TRACE,CoreObj1);

        CoreObj1->TraceL(MyUpdates2) ;

        //aRequestorStack.Close();

        }
    return KErrNone ;
    }


TInt TraceLFunction5L()
    {
    __UHEAP_MARK ;
    TInt ret1;
    TPosition aPosition1;  
    CLocationService *CoreObj = CLocationService ::NewL() ;
    LocUpdateCallBack5 MyUpdates1(28,GETLOCATION) ;

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    TRAP(ret1 ,CoreObj->GetLocationL(&MyUpdates1) );

    if( KErrNone == ret1)
        {
        TBuf8<20> retBuf;
        TRealFormat retFormat;
        OpenFile();
        LogFile.Write(_L8("\n<TraceLPosition5 test>\n"));
        CloseFile();
        CActiveScheduler :: Start() ;
        retBuf.Num(returnCode,retFormat);
        OpenFile();
        LogFile.Write(_L8("\nreturn code : "));
        LogFile.Write(retBuf);
        CloseFile();
        }
    else
        {
        returnCode = KErrGeneral;
        }

    //aRequestorStack.Close();

    delete CoreObj;
    __UHEAP_MARKEND ;
    return KErrNone;
    }

TInt CSAPILocTest::TraceLPosition5( CStifItemParser& /*aItem*/ )
    {
    returnCode = KErrNone;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "TraceLPosition5" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TRAPD(err , TraceLFunction5L()) ;
    if(err)
        returnCode = KErrGeneral;

    __UHEAP_MARKEND;

    return returnCode;  
    }

// -----------------------------------------------------------------------------
// CSAPILocTest::TraceLPosition6
// -----------------------------------------------------------------------------
//

class CLocUpdateCallBack6 : public CBase , public MLocationCallBack
    {
    TInt iCount ;
    TInt iRetStatus ;
    CLocUpdateCallBack6* iSelf;
    CLocationService *CoreObj;
    TInt iTransactionId;
    TInt iRequestType;
    public :
        TInt HandleNotifyL(HPositionGenericInfo* aOutPos , TInt aError) ;
        CLocUpdateCallBack6(TInt transId,TInt req,CLocationService* LocObj,TInt count = 0,TInt status = KErrGeneral) 
            {
            iCount = count;
            iRetStatus = status;
            CoreObj = LocObj;
            iTransactionId =transId;
            iRequestType = req;
            }
        static CLocUpdateCallBack6* NewL(TInt transid,TInt req,CLocationService* obj);
        virtual ~CLocUpdateCallBack6();

        inline TUint GetRequestType(void) 
            {
            return iRequestType ;
            }


        /**
         * GetTransactionId function returns transcation id associated with current async object
         *
         */
        inline TInt32 GetTransactionId(void)
            {
            return iTransactionId ;
            }

    };

CLocUpdateCallBack6* CLocUpdateCallBack6 :: NewL(TInt transid,TInt req,CLocationService* obj)
    {
    CLocUpdateCallBack6* temp = new(ELeave) CLocUpdateCallBack6(transid,req,obj);
    temp->iSelf = temp;
    return temp;
    }

CLocUpdateCallBack6 :: ~CLocUpdateCallBack6()
    {
    delete (this->CoreObj);
    }
TInt CLocUpdateCallBack6 :: HandleNotifyL(HPositionGenericInfo* currPos , TInt /*aError*/)
    {
    TInt aRet;
    TPosition currPos1;
    currPos->GetPosition(currPos1);

    aRet = ValidatePosition(currPos1);

    if( KErrNone == aRet )
        {
        CActiveScheduler *Current = CActiveScheduler :: Current() ;
        Current->Stop() ;
        returnCode = KErrNone;
        delete this;
        }
    else  
        {
        CActiveScheduler *Current = CActiveScheduler :: Current() ;
        Current->Stop() ;
        returnCode = KErrGeneral;
        delete this;
        }
    OpenFile();  
    LogFile.Write(_L8("CLocUpdateCallBack6 :: Before retrunin to runl"));
    LogFile.Write(_L8("\n")) ;
    CloseFile();
    return KErrNone ;
    }

class TraceLCallBack6 : public MLocationCallBack
    {
    TInt iCount ;
    TInt iRetStatus ;
    CLocationService *CoreObj;
    TInt iTransactionId;
    TInt iRequestType;
    public :
        TInt HandleNotifyL(HPositionGenericInfo* aOutPos , TInt aError) ;
        TraceLCallBack6(TInt transId,TInt req,CLocationService* LocObj,TInt count = 0,TInt status = KErrGeneral)
            {
            iTransactionId = transId;
            iRequestType = req;
            iCount = count;
            iRetStatus = status;
            CoreObj = LocObj;	
            }

        inline TUint GetRequestType(void) 
            {
            return iRequestType ;
            }


        /**
         * GetTransactionId function returns transcation id associated with current async object
         *
         */
        inline TInt32 GetTransactionId(void)
            {
            return iTransactionId ;
            }



    };


TInt TraceLCallBack6 :: HandleNotifyL(HPositionGenericInfo* currPos , TInt aError)
    {
    TInt aRet1;
    if(KErrNone == aError && iCount<1)
        {
        TPosition currPos1;
        currPos->GetPosition(currPos1);
        ValidatePosition(currPos1);
        iCount++;	 
        }

    else
        {
        aRet1 = CoreObj->CancelOnGoingService(1);

        if( KErrNone == aRet1 )
            {
            TPosition aPosition2;  
            CLocationService *CoreObj1 = CLocationService ::NewL() ;

            _LIT(Kidentity ,"Coreclass Testing" ) ;
            //not needed any more
            /*RRequestorStack aRequestorStack;
			const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
		    aRequestorStack.Insert(identityInfo,0);

		    CoreObj1->SetRequestorIdentityL(aRequestorStack) ;*/

            CLocUpdateCallBack6 *MyUpdates1 =  CLocUpdateCallBack6 :: NewL(26,GETLOCATION,CoreObj1);

            CoreObj1->GetLocationL(MyUpdates1) ;

            //aRequestorStack.Close();


            returnCode = KErrNone;
            }
        else
            {
            returnCode = KErrGeneral;
            }	
        }
    return KErrNone; 
    }


TInt TraceLFunction6L()
    {
    __UHEAP_MARK;

    CActiveScheduler *Scheduler = new CActiveScheduler ;

    CActiveScheduler :: Install(Scheduler) ;
    TInt ret1;
    TPosition aPosition1;  
    CLocationService *CoreObj = CLocationService ::NewL() ;
    TraceLCallBack6 MyUpdates2(36,TRACE,CoreObj) ;

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/
    TPositionUpdateOptions updateOpts;
    updateOpts.SetUpdateInterval(5000000);

    TRAP(ret1 , CoreObj->TraceL(&MyUpdates2,0,NULL,&updateOpts) );

    if( KErrNone == ret1)
        {	
        OpenFile();
        LogFile.Write(_L8("\n<TraceLPosition6 test>\n"));
        CloseFile();
        CActiveScheduler :: Start() ;
        }
    else
        {
        returnCode = KErrGeneral;
        }

    //aRequestorStack.Close();

    delete CoreObj;
    delete Scheduler ;
    __UHEAP_MARKEND;
    OpenFile();
    LogFile.Write(_L8("\n<TraceLPosition6 test after uheap>\n"));
    CloseFile();
    return KErrNone;
    }



TInt CSAPILocTest::TraceLPosition6( CStifItemParser& /*aItem*/ )
    {

    _LIT(KTLocTest ,"TLocTest");
    iLog->Log(KTLocTest) ;

    TRequestStatus Status = KRequestPending  ;
    RThread FunctionThread ;

    FunctionThread.Create(_L("GetLocationAsynch Thread") , TraceLPosition6T ,KDefaultStackSize , 
            KMinHeapSize , KDefaultStackSize ,(TAny *) NULL);

    FunctionThread.Logon(Status)    ;
    FunctionThread.Resume() ;

    User :: WaitForRequest (Status) ;               
    FunctionThread.Close();

    return Status.Int() ;   
    }

TInt TraceLPosition6T( TAny */*Arg*/)
    {
    returnCode = KErrNone;

    TInt err = KErrNone;

    CTrapCleanup* cleanup = CTrapCleanup::New();
    TRAP(err , TraceLFunction6L()) ;
    if(err)
        {

        returnCode = KErrGeneral;
        }
    //TInt alloc1 = User::CountAllocCells();


    delete cleanup ;
    return returnCode;
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::TraceLPosition7
// -----------------------------------------------------------------------------
//

class TraceLCallBack7 : public MLocationCallBack
    {
    TInt iCount ;
    TInt iRetStatus ;
    CLocationService *CoreObj;
    TInt iTransactionId;
    TInt iRequestType;
    public :
        TInt HandleNotifyL(HPositionGenericInfo* aOutPos , TInt aError) ;
        TraceLCallBack7(TInt transId,TInt req,CLocationService* LocObj,TInt count = 0,TInt status = KErrGeneral)
            {
            iTransactionId= transId;
            iRequestType = req;
            iCount = count;
            iRetStatus = status;
            CoreObj = LocObj;	
            }
        inline TUint GetRequestType(void) 
            {
            return iRequestType ;
            }


        /**
         * GetTransactionId function returns transcation id associated with current async object
         *
         */
        inline TInt32 GetTransactionId(void)
            {
            return iTransactionId ;
            }
    };


TInt TraceLCallBack7 :: HandleNotifyL(HPositionGenericInfo* currPos , TInt aError)
    {
    //User::After(30000000);
    TInt aRet1;
    if(KErrNone == aError && iCount<2)
        {
        TPosition currPos1;
        currPos->GetPosition(currPos1);
        //   	ValidatePosition(currPos1);
        iCount++;	 
        }

    else
        {
        aRet1 = CoreObj->CancelOnGoingService(1);
        if( KErrNone == aRet1 )
            {
            TPosition aPosition2;  
            CLocationService *CoreObj1 = CLocationService ::NewL() ;

            _LIT(Kidentity ,"Coreclass Testing" ) ;
            //not needed any more
            /*RRequestorStack aRequestorStack;
			const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
		    aRequestorStack.Insert(identityInfo,0);

		    CoreObj1->SetRequestorIdentityL(aRequestorStack) ;*/

            CTraceLCallBack5 *MyUpdates2 = CTraceLCallBack5::NewL(19,TRACE,CoreObj1);

            CoreObj1->TraceL(MyUpdates2) ;

            // User::After(30000000) ;
            //aRequestorStack.Close();


            returnCode = KErrNone;
            }
        else
            {
            returnCode = KErrGeneral;
            }	
        }
    return KErrNone; 
    }


TInt TraceLFunction7L()
    {
    __UHEAP_MARK ;
    TInt ret1;
    TPosition aPosition1;  
    CLocationService *CoreObj = CLocationService ::NewL() ;

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more

    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    TraceLCallBack7 MyUpdates1(20,TRACE,CoreObj) ;

    TRAP(ret1 , CoreObj->TraceL(&MyUpdates1) );

    if( KErrNone == ret1)
        {	
        OpenFile();
        LogFile.Write(_L8("\n<TraceLPosition7 test>\n"));
        CloseFile();
        CActiveScheduler :: Start() ;
        }
    else
        {
        returnCode = KErrGeneral;
        }

    //aRequestorStack.Close();

    delete CoreObj;
    __UHEAP_MARKEND ;
    return KErrNone;
    }



TInt CSAPILocTest::TraceLPosition7( CStifItemParser& /*aItem*/ )
    {
    returnCode = KErrNone;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "TraceLPosition7" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TRAPD(err , TraceLFunction7L()) ;
    if(err)
        returnCode = KErrGeneral;

    __UHEAP_MARKEND;

    return returnCode;  
    }

// -----------------------------------------------------------------------------
// CSAPILocTest::TraceLPosition8
// -----------------------------------------------------------------------------
//

class LocUpdateCallBack8 : public MLocationCallBack
    {
    TInt iCount ;
    TInt iRetStatus ;
    TInt iRequestType;
    TInt iTransactionId;
    public :
        TInt HandleNotifyL(HPositionGenericInfo* aOutPos , TInt aError) ;
        LocUpdateCallBack8(TInt transId,TInt req) :iCount(0) , iRetStatus(KErrGeneral){
        iTransactionId = transId;
        iRequestType = req;
        }

        inline TUint GetRequestType(void) 
            {
            return iRequestType ;
            }


        /**
         * GetTransactionId function returns transcation id associated with current async object
         *
         */
        inline TInt32 GetTransactionId(void)
            {
            return iTransactionId ;
            }
    };


TInt LocUpdateCallBack8 :: HandleNotifyL(HPositionGenericInfo* currPos , TInt /*aError*/)
    {

    TInt aRet;
    TPosition currPos1;
    currPos->GetPosition(currPos1);
    aRet = ValidatePosition(currPos1);
    if ( KErrNone == aRet)
        {
        TPosition aPosition2;  
        CLocationService *CoreObj1 = CLocationService ::NewL() ;

        _LIT(Kidentity ,"Coreclass Testing" ) ;
        //not needed any more
        /*RRequestorStack aRequestorStack;
		const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;

	    aRequestorStack.Insert(identityInfo,0);

	    CoreObj1->SetRequestorIdentityL(aRequestorStack) ;*/

        CLocUpdateCallBack6 *MyUpdates2 =  CLocUpdateCallBack6 :: NewL(27,GETLOCATION,CoreObj1);

        CoreObj1->GetLocationL(MyUpdates2) ;

        /*aRequestorStack.Close();
    	delete identityInfo;*/
        }
    return KErrNone ;
    }


TInt TraceLFunction8L()
    {
    __UHEAP_MARK ;
    TInt ret1;
    TPosition aPosition1;  
    CLocationService *CoreObj = CLocationService ::NewL() ;
    LocUpdateCallBack8 MyUpdates1(21,GETLOCATION) ;

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/
    TPositionUpdateOptions updateOpts;
    updateOpts.SetUpdateInterval(5000000);      

    TRAP(ret1 , CoreObj->GetLocationL(&MyUpdates1,0,NULL,&updateOpts) );

    if( KErrNone == ret1)
        {
        OpenFile();
        LogFile.Write(_L8("\n<TraceLPosition8 test>\n"));
        CloseFile();
        CActiveScheduler :: Start() ;
        }
    else
        {
        returnCode = KErrGeneral;
        }

    /*aRequestorStack.Close();
    delete identityInfo;*/
    delete CoreObj;
    __UHEAP_MARKEND ;
    return KErrNone;
    }

TInt CSAPILocTest::TraceLPosition8( CStifItemParser& /*aItem*/ )
    {
    returnCode = KErrNone;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "TraceLPosition8" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );


    __UHEAP_MARK;

    TRAPD(err , TraceLFunction8L()) ;
    if(err)
        returnCode = KErrGeneral;

    __UHEAP_MARKEND;

    return returnCode;  
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::TraceLPositionOpts
// -----------------------------------------------------------------------------
//
class TraceLCallBackTO : public MLocationCallBack
    {
    TInt iCount ;
    TInt iRetStatus ;
    TInt iTransactionId;
    TInt iRequestType;
    public :
        TInt HandleNotifyL(HPositionGenericInfo* aOutPos , TInt aError) ;
        TraceLCallBackTO(TInt transId,TInt req) :iCount(0) , iRetStatus(KErrGeneral){
        iTransactionId = transId;
        iRequestType = req;
        }

        inline TUint GetRequestType(void) 
            {
            return iRequestType ;
            }


        /**
         * GetTransactionId function returns transcation id associated with current async object
         *
         */
        inline TInt32 GetTransactionId(void)
            {
            return iTransactionId ;
            }
    };

TInt TraceLCallBackTO :: HandleNotifyL(HPositionGenericInfo* /*currPos*/ , TInt aError)
    {
    if(KErrTimedOut == aError)
        {
        CActiveScheduler *Current = CActiveScheduler :: Current() ;
        Current->Stop() ;
        OpenFile();
        LogFile.Write(_L8("Passed..\n"));
        CloseFile();
        returnCode = KErrNone;
        return KErrNone ;	
        }
    else
        {
        CActiveScheduler *Current = CActiveScheduler :: Current() ;
        Current->Stop() ;
        OpenFile();
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        return KErrNone; 
        }
    }


TInt TraceLFunctionOptsL()
    {
    __UHEAP_MARK ;
    TInt ret1;
    TPosition aPosition1;
    TPositionUpdateOptions aOptions;
    TTimeIntervalMicroSeconds aTimeOut = 10;  
    CLocationService *CoreObj = CLocationService ::NewL() ;

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    aOptions.SetUpdateTimeOut(aTimeOut);

    TraceLCallBackTO MyUpdates(22,TRACE);

    TRAP(ret1 , CoreObj->TraceL(&MyUpdates,0,NULL,&aOptions) );

    if( KErrNone == ret1)
        {
        OpenFile();
        LogFile.Write(_L8("\n<TraceLPositionOpts test>\n"));
        CloseFile();
        CActiveScheduler::Start();
        }

    else
        {
        returnCode = KErrGeneral;	
        }
    /*aRequestorStack.Close();
    delete identityInfo;*/
    delete CoreObj;
    __UHEAP_MARKEND ;
    return 0;
    }

TInt CSAPILocTest::TraceLPositionOpts( CStifItemParser& /*aItem*/ )
    {
    returnCode = KErrNone;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "TraceLPositionOpts" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TRAPD(err , TraceLFunctionOptsL()) ;
    if(err)
        returnCode = KErrGeneral;

    __UHEAP_MARKEND;

    return returnCode;  
    }

// -----------------------------------------------------------------------------
// CSAPILocTest::TraceLPositionOpts1
// -----------------------------------------------------------------------------
//
class TraceLCallBackOpts1 : public MLocationCallBack
    {
    TInt iCount ;
    TInt iRetStatus ;
    CLocationService *CoreObj;
    TInt iTransactionId;
    TInt iRequestType;
    public :
        TInt HandleNotifyL(HPositionGenericInfo* aOutPos , TInt aError) ;
        TraceLCallBackOpts1(TInt transId,TInt req,TInt count = 0,TInt status = KErrGeneral)
            {
            iRequestType = req;
            iTransactionId = transId;
            iCount = count;
            iRetStatus = status;
            }

        inline TUint GetRequestType(void) 
            {
            return iRequestType ;
            }


        /**
         * GetTransactionId function returns transcation id associated with current async object
         *
         */
        inline TInt32 GetTransactionId(void)
            {
            return iTransactionId ;
            }
    };


TInt TraceLCallBackOpts1 :: HandleNotifyL(HPositionGenericInfo* /*currPos*/ , TInt /*aError*/){return 0;}



TInt TraceLFunctionOpts1L()
    {
    TInt ret1;
    TPosition aPosition1;
    TPositionUpdateOptions aOptions;
    TTimeIntervalMicroSeconds aTimeOut = 10000000; 
    TTimeIntervalMicroSeconds aTimeInterval = 30000000; 

    CLocationService *CoreObj = CLocationService ::NewL() ;

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    aOptions.SetUpdateTimeOut(aTimeOut);
    aOptions.SetUpdateInterval(aTimeInterval);

    TraceLCallBackOpts1 MyUpdates(23,TRACE);

    TRAP(ret1 , CoreObj->TraceL(&MyUpdates,0,NULL,&aOptions) );

    if( KErrArgument == ret1)
        {
        OpenFile();
        LogFile.Write(_L8("\n<TraceLPositionOpts1 test>\n"));
        LogFile.Write(_L8("Passed\n"));
        CloseFile();
        returnCode = KErrNone;
        }

    else
        {
        returnCode = KErrGeneral;
        }

    /*aRequestorStack.Close();
    delete identityInfo;*/
    delete CoreObj;
    return 0;
    }


TInt CSAPILocTest::TraceLPositionOpts1( CStifItemParser& /*aItem*/ )
    {
    returnCode = KErrNone;

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "TraceLPositionOpts1" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TRAPD(err , TraceLFunctionOpts1L()) ;
    if(err)
        returnCode = KErrGeneral;

    __UHEAP_MARKEND;

    return returnCode;  
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::TraceLPositionOpts2
// -----------------------------------------------------------------------------
//
TInt TraceLFunctionOpts2L()
    {
    __UHEAP_MARK ;
    TInt ret1;
    TPosition aPosition1;
    TPositionUpdateOptions aOptions;
    TTimeIntervalMicroSeconds aTimeOut = 60000000; 
    TTimeIntervalMicroSeconds aTimeInterval = 30000000;
    TTimeIntervalMicroSeconds aInterval;
    TTime start,end;

    CLocationService *CoreObj = CLocationService ::NewL() ;
    //not needed any more
    /*_LIT(Kidentity ,"Coreclass Testing" ) ;
	RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    aOptions.SetUpdateTimeOut(aTimeOut);
    aOptions.SetUpdateInterval(aTimeInterval);

    TraceLCallBack MyUpdates(34,TRACE);

    TRAP(ret1 , CoreObj->TraceL(&MyUpdates,0,NULL,&aOptions) );

    if( KErrNone == ret1)
        {
        OpenFile();
        LogFile.Write(_L8("\n<TraceLPositionOpts2 test>\n"));
        CloseFile();
        start.HomeTime();
        CActiveScheduler::Start();
        end.HomeTime();
        aInterval = end.MicroSecondsFrom(start);
        //	 	if(aInterval<150000000)
        //	 	returnCode = KErrGeneral;
        }

    else
        {
        returnCode = KErrGeneral;	
        }

    /*aRequestorStack.Close();
    delete identityInfo;*/
    delete CoreObj;
    __UHEAP_MARKEND ;
    return 0;
    }

TInt CSAPILocTest::TraceLPositionOpts2( CStifItemParser& /*aItem*/ )
    {
    returnCode = KErrNone;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "TraceLPositionOpts2" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TRAPD(err , TraceLFunctionOpts2L()) ;
    if(err)
        returnCode = KErrGeneral;

    __UHEAP_MARKEND;

    return returnCode;  
    }

// -----------------------------------------------------------------------------
// CSAPILocTest::TraceLPositionOpts3
// -----------------------------------------------------------------------------
//
class TraceLCallBackOpts3 : public MLocationCallBack
    {
    TInt iCount ;
    TInt iRetStatus ;
    TInt iTransactionId;
    TInt iRequestType;
    public :
        TInt HandleNotifyL(HPositionGenericInfo* aOutPos , TInt aError) ;
        TraceLCallBackOpts3(TInt transId,TInt req) :iCount(0) , iRetStatus(KErrGeneral){+
        iTransactionId = transId;
        iRequestType = req;
        }

        inline TUint GetRequestType(void) 
            {
            return iRequestType ;
            }


        /**
         * GetTransactionId function returns transcation id associated with current async object
         *
         */
        inline TInt32 GetTransactionId(void)
            {
            return iTransactionId ;
            }
    };



TInt TraceLCallBackOpts3 :: HandleNotifyL(HPositionGenericInfo* currPos , TInt aError)
    {
    TTime timeStamp;
    TInt64 timeInt;
    TBuf8<50> buf ;
    TRealFormat format ;
    if(KErrNone == aError && iCount<2)
        {
        //User::After(60000000);
        TPosition currPos1;
        currPos->GetPosition(currPos1);
        timeStamp = currPos1.Time();
        timeInt = timeStamp.Int64();
        if(timeInt)
            {
            OpenFile();
            buf.Num(timeInt , format) ;
            LogFile.Write(_L8("\nTimestamp = "));
            LogFile.Write(buf) ;
            CloseFile();
            returnCode = KErrNone;
            }
        else
            {
            returnCode = KErrGeneral;
            return 0;
            }
        iCount++;	 
        }

    else
        {
        CActiveScheduler *Current = CActiveScheduler :: Current() ;
        Current->Stop() ;
        }
    return 0;
    }

TInt TraceLFunctionOpts3L()
    {
    __UHEAP_MARK ;
    TInt ret1;
    TPosition aPosition1;
    TPositionUpdateOptions aOptions;
    TTimeIntervalMicroSeconds aTimeOut = 20000000; 
    TTimeIntervalMicroSeconds aTimeInterval = 5000000;
    TTimeIntervalMicroSeconds aInterval;
    TTime start,end;
    TBool aAcceptPartialUpdates = ETrue;

    CLocationService *CoreObj = CLocationService ::NewL() ;

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    aOptions.SetUpdateTimeOut(aTimeOut);
    aOptions.SetUpdateInterval(aTimeInterval);
    aOptions.SetAcceptPartialUpdates(aAcceptPartialUpdates);

    TraceLCallBackOpts3 MyUpdates(24,TRACE);

    TRAP(ret1 , CoreObj->TraceL(&MyUpdates,0,NULL,&aOptions) );

    if( KErrNone == ret1)
        {
        TBuf8<20> retBuf;
        TRealFormat retFormat;
        OpenFile();
        LogFile.Write(_L8("\n<TraceLPositionOpts3 test>\n"));
        CloseFile();

        start.HomeTime();
        CActiveScheduler::Start();
        end.HomeTime();
        aInterval = end.MicroSecondsFrom(start);
        // 	if(aInterval<150000000)
        // 	returnCode = KErrGeneral;
        retBuf.Num(returnCode,retFormat);
        OpenFile();
        LogFile.Write(_L8("\nreturnCode : "));
        LogFile.Write(retBuf);
        CloseFile();
        }

    else
        {
        returnCode = KErrGeneral;	
        }
    /*aRequestorStack.Close();
    delete identityInfo;*/
    delete CoreObj;
    __UHEAP_MARKEND ;
    return 0;
    }


TInt CSAPILocTest::TraceLPositionOpts3( CStifItemParser& /*aItem*/ )
    {
    returnCode = KErrNone;      
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "TraceLPositionOpts3" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TRAPD(err , TraceLFunctionOpts3L()) ;

    if(err)
        returnCode = KErrGeneral;

    __UHEAP_MARKEND;

    return returnCode;  
    }

// -----------------------------------------------------------------------------
// CSAPILocTest::CancelService1
// -----------------------------------------------------------------------------
//
TInt CancelFunction1L()
    {
    __UHEAP_MARK ;
    TInt ret1,ret2;
    CLocationService *CoreObj = CLocationService ::NewL() ;

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    ret1 = CoreObj->CancelOnGoingService(0) ;

    ret2 = CoreObj->CancelOnGoingService(1) ;

    if( KErrNotFound == ret1 && KErrNotFound == ret2 )
        {
        OpenFile();
        LogFile.Write(_L8("\n<CancelService1 test>\n"));
        LogFile.Write(_L8("Passed..\n"));
        CloseFile();
        returnCode = KErrNone; 
        }

    else
        {
        returnCode = KErrGeneral;	
        }

    /*aRequestorStack.Close();
    delete identityInfo;*/
    delete CoreObj;
    __UHEAP_MARKEND ;
    return 0;
    }

TInt CSAPILocTest::CancelService1( CStifItemParser& /*aItem*/ )
    {
    returnCode = KErrNone;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "CancelService1" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TRAPD(err , CancelFunction1L()) ;
    if(err)
        returnCode = KErrGeneral;

    __UHEAP_MARKEND;

    return returnCode;  
    }

// -----------------------------------------------------------------------------
// CSAPILocTest::CancelService2
// -----------------------------------------------------------------------------
//
TInt CancelFunction2L()
    {
    __UHEAP_MARK ;
    TInt ret1,ret2;
    CLocationService *CoreObj = CLocationService ::NewL() ;

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    ret1 = CoreObj->CancelOnGoingService(4) ;

    ret2 = CoreObj->CancelOnGoingService(6) ;

    if( KErrArgument == ret1 && KErrArgument == ret2 )
        {
        OpenFile();
        LogFile.Write(_L8("\n<CancelService2 test>\n"));
        LogFile.Write(_L8("Passed..\n"));
        CloseFile();
        returnCode = KErrNone; 
        }

    else
        {
        returnCode = KErrGeneral;	
        }

    /*aRequestorStack.Close();
    delete identityInfo;*/
    delete CoreObj;
    __UHEAP_MARKEND ;
    return 0;
    }


TInt CSAPILocTest::CancelService2( CStifItemParser& /*aItem*/ )
    {
    returnCode = KErrNone;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "CancelService2" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );
    __UHEAP_MARK;

    TRAPD(err , CancelFunction2L()) ;
    if(err)
        returnCode = KErrGeneral;
    __UHEAP_MARKEND;

    return returnCode;  
    }

// -----------------------------------------------------------------------------
// CSAPILocTest::GetTime
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetTime( CStifItemParser& /*aItem*/ )
    {
    TInt ret;
    TPositionInfo currPos;
    TPosition currPos1;
    TTime currPosTime;
    TDateTime currPosDateTime;
    TBuf8<50> buf ;
    TRealFormat format ;
    returnCode = KErrNone;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetTime" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetTime Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    TRAP(ret , CoreObj->GetLocationL(&currPos));

    if(KErrNone == ret)
        {
        currPos.GetPosition(currPos1);
        currPosTime = currPos1.Time();
        currPosDateTime = currPosTime.DateTime();

        TInt aDay = currPosDateTime.Day();
        TInt aHour = currPosDateTime.Hour();
        TInt aMicroSecond = currPosDateTime.MicroSecond();
        TInt aMinute = currPosDateTime.Minute();
        TInt aMonth = currPosDateTime.Month();
        TInt aSecond = currPosDateTime.Second();
        TInt aYear = currPosDateTime.Year();
        TReal32 aVerAcc = currPos1.VerticalAccuracy();
        TReal32 aHorAcc = currPos1.HorizontalAccuracy();

        OpenFile();

        LogFile.Write(_L8("\n<GetTime test> \n"));
        buf.Num(aHorAcc,format);
        LogFile.Write(_L8("Horizontal Acc = "));
        LogFile.Write(buf) ;
        LogFile.Write(_L8("\n")) ;

        buf.Num(aVerAcc,format);
        LogFile.Write(_L8("Vertical Acc = "));
        LogFile.Write(buf) ;
        LogFile.Write(_L8("\n")) ;

        buf.Num(aDay , format) ;
        LogFile.Write(_L8("Time = "));
        LogFile.Write(buf) ;
        LogFile.Write(_L8("-")) ;

        buf.Num(aMonth , format) ;
        LogFile.Write(buf) ;
        LogFile.Write(_L8("-")) ;

        buf.Num(aYear , format) ;
        LogFile.Write(buf) ;
        LogFile.Write(_L8("  ")) ;

        buf.Num(aHour , format) ;
        LogFile.Write(buf) ;
        LogFile.Write(_L8(":")) ;

        buf.Num(aMinute , format) ;
        LogFile.Write(buf) ;
        LogFile.Write(_L8(":")) ;

        buf.Num(aSecond , format) ;
        LogFile.Write(buf) ;
        LogFile.Write(_L8(":")) ;

        buf.Num(aMicroSecond , format) ;
        LogFile.Write(buf) ;
        LogFile.Write(_L8("\n")) ;
        CloseFile();

        ValidatePosition(currPos1);
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetTime Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;	
        }
    /*aRequestorStack.Close();
	    delete identityInfo;*/
    delete CoreObj;

    __UHEAP_MARKEND;       

    return returnCode;    
    }



// -----------------------------------------------------------------------------
// CSAPILocTest::GetSpeed
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetSpeed( CStifItemParser& /*aItem*/ )
    {
    TInt ret;
    TPositionInfo currPos;
    TPosition currPos1,fromPos;
    TTime currPosTime;
    TTime fromPosTime;
    TDateTime currPosDateTime;
    TReal64 aLatitude1  = 8;
    TReal64 aLongitude1 = 70;
    TReal32 aAltitude1  = 700;
    TReal32 aSpeed;
    fromPosTime = 63342890700000000;

    fromPos.SetCoordinate(aLatitude1,aLongitude1,aAltitude1);
    fromPos.SetTime(fromPosTime);

    returnCode =KErrNone;

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetSpeed" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetSpeed Test>\n"));
        LogFile.Write(_L8("Failed(CoreObj creation)..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }
    //not needed any more
    /*_LIT(Kidentity ,"Coreclass Testing" ) ;
	RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);
    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    // User::After(120000000);
    TRAP(ret , CoreObj->GetLocationL(&currPos));

    if(KErrNone == ret)
        {
        currPos.GetPosition(currPos1);
        currPos1.Speed(fromPos,aSpeed);

        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format ;
        LogFile.Write(_L8("\n<GetSpeed test> \n"));
        buf.Num(aSpeed , format) ;
        LogFile.Write(_L8("Speed = "));
        LogFile.Write(buf) ;
        LogFile.Write(_L8("\n")) ;
        CloseFile();
        ValidatePosition(currPos1);
        returnCode = KErrNone;
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetSpeed Test>\n"));
        LogFile.Write(_L8("Failed(getloc error)..\n"));

        TBuf8<50> buf ;
        TRealFormat format ;
        LogFile.Write(_L8("\n<GetSpeed test> \n"));
        buf.Num(ret , format) ;
        LogFile.Write(buf);
        CloseFile();
        returnCode = KErrGeneral;

        }

    /*aRequestorStack.Close();
	delete identityInfo;*/
    delete CoreObj;
    __UHEAP_MARKEND;       

    return returnCode;    
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetPositionOpts
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetPositionOpts( CStifItemParser& /*aItem*/ )
    {
    TInt ret;
    TPositionInfo currPos;
    TPosition currPos1;
    TPositionUpdateOptions aOptions;
    TTimeIntervalMicroSeconds aTimeOut = 100;
    returnCode = KErrNone;

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetPositionOpts" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionOpts Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }
    //not needed any more
    /*_LIT(Kidentity ,"Coreclass Testing" ) ;
	RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);
    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    aOptions.SetUpdateTimeOut(aTimeOut);

    TRAP(ret , CoreObj->GetLocationL(&currPos,&aOptions));

    if(KErrTimedOut==ret)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionOpts Test>\n"));
        LogFile.Write(_L8("Passed..\n"));
        CloseFile();
        returnCode = KErrNone;	
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionOpts Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    /*aRequestorStack.Close();
    delete identityInfo;*/
    delete CoreObj;

    __UHEAP_MARKEND; 

    return returnCode;

    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetPositionOpts1
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetPositionOpts1( CStifItemParser& /*aItem*/ )
    {
    TInt ret;
    TPositionInfo currPos;
    TPositionUpdateOptions options;
    TTimeIntervalMicroSeconds aTimeOut = 0;
    returnCode = KErrNone;

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetPositionOpts1" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionOpts1 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;

    options.SetUpdateTimeOut(aTimeOut);

    ret = CoreObj->GetLocationL(&currPos,&options);*/

    if(KErrTimedOut==ret)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionOpts1 Test>\n"));
        LogFile.Write(_L8("Failed(timed out)..\n"));
        CloseFile();
        returnCode = KErrGeneral;	
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionOpts1 Test>\n"));
        LogFile.Write(_L8("Passed..\n"));
        CloseFile();
        returnCode = KErrNone;
        }

    /*aRequestorStack.Close();
    delete identityInfo;*/
    delete CoreObj;
    __UHEAP_MARKEND; 

    return returnCode;
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetPositionOpts2
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetPositionOpts2( CStifItemParser& /*aItem*/ )
    {
    TInt ret1,ret2;
    TPositionInfo currPos1,currPos2;
    TPosition cPos1,cPos2;
    TPositionUpdateOptions options;
    //	TTimeIntervalMicroSeconds aTimeOut = 0;
    //	TTimeIntervalMicroSeconds aInterval = 30000000;
    TTimeIntervalMicroSeconds aActualInterval;
    TTime start;
    TTime end;
    TInt64 aActualInt;
    returnCode = KErrNone;

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetPostionOpts2" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionOpts2 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    //   options.SetUpdateTimeOut(aTimeOut);

    //   options.SetUpdateInterval(aInterval);

    //User::After(120000000);
    TRAP(ret1 , CoreObj->GetLocationL(&currPos1/*,&options*/));



    if( (KErrNone != ret1))
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionOpts2 Test>\n"));
        LogFile.Write(_L8("Failed(coreobj 1)..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }
    else
        {

        start.HomeTime();
        TRAP(ret2 , CoreObj->GetLocationL(&currPos2/*,&options*/));
        end.HomeTime();

        aActualInterval=end.MicroSecondsFrom(start);
        aActualInt = aActualInterval.Int64();
        if(KErrNone == ret2)
            {
            OpenFile();
            TBuf8<50> buf ;
            TRealFormat format ;
            LogFile.Write(_L8("\n<GetPositionOpts2 Test>\n"));
            buf.Num(aActualInt, format) ;
            LogFile.Write(_L8("TimeTaken = "));
            LogFile.Write(buf) ;
            CloseFile();
            currPos1.GetPosition(cPos1);
            currPos2.GetPosition(cPos2);
            ValidatePosition(cPos1);
            ValidatePosition(cPos2);
            returnCode = KErrNone;	
            }
        else
            {
            OpenFile();
            LogFile.Write(_L8("\n<GetPositionOpts2 Test>\n"));
            LogFile.Write(_L8("Failed(coreObj 2)..\n"));
            CloseFile();
            returnCode = KErrGeneral;	
            }
        }

    /*aRequestorStack.Close();
    delete identityInfo;*/
    delete CoreObj;

    __UHEAP_MARKEND; 

    return returnCode;
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetPositionOpts3
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetPositionOpts3( CStifItemParser& /*aItem*/ )
    {
    TInt ret1,ret2,ret3;
    TPositionInfo currPos1,currPos2,currPos3;
    TPosition cPos1,cPos2,cPos3;
    TPositionUpdateOptions options;
    TTimeIntervalMicroSeconds aTimeOut =  30000000;
    TTimeIntervalMicroSeconds aInterval = 120000000;
    TTimeIntervalMicroSeconds aActualInterval;
    returnCode = KErrNone;

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetPostionOpts3");
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionOpts3 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
  

    options.SetUpdateTimeOut(aTimeOut);
    options.SetUpdateInterval(aInterval);

    TRAP(ret1 , CoreObj->GetLocationL(&currPos1,&options));
    TRAP(ret2 , CoreObj->GetLocationL(&currPos2,&options));
    TRAP(ret3 , CoreObj->GetLocationL(&currPos2,&options));


    if( KErrArgument == ret1 && KErrArgument == ret2 && KErrArgument == ret3 )
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionOpts3 Test>\n"));
        LogFile.Write(_L8("Passed..\n"));
        CloseFile();
        returnCode = KErrNone;
        }

    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionOpts3 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    /*aRequestorStack.Close();
  delete identityInfo;*/
    delete CoreObj;

    __UHEAP_MARKEND; 

    return returnCode; 
    }

// -----------------------------------------------------------------------------
// CSAPILocTest::GetPositionOpts4
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetPositionOpts4( CStifItemParser& /*aItem*/ )
    {
    TInt ret1,ret2;
    TPositionInfo currPos1,currPos2,currPos3;
    TPosition cPos1,cPos2,cPos3;
    TPositionUpdateOptions options;
    TTimeIntervalMicroSeconds aTimeOut =  80000000;
    TTimeIntervalMicroSeconds aInterval = 10000000;
    TTimeIntervalMicroSeconds aMaxAge = 5000000;
    TTimeIntervalMicroSeconds aActualInterval;
    TTime start;
    TTime end;
    TInt64 aActualInt;
    returnCode = KErrNone;

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetPostionOpts4");
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionOpts4 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);
    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    options.SetUpdateTimeOut(aTimeOut);
    options.SetUpdateInterval(aInterval);
    options.SetMaxUpdateAge(aMaxAge);

    TRAP(ret1 , CoreObj->GetLocationL(&currPos1,&options));

    start.HomeTime();
    TRAP(ret2 , CoreObj->GetLocationL(&currPos2,&options));
    end.HomeTime();

    aActualInterval=end.MicroSecondsFrom(start);

    //  if( aActualInterval<=10000000 || ret1 || ret2 )
    if( (KErrNone == ret1) && (KErrNone == ret2 ))
        {
        aActualInt = aActualInterval.Int64();
        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format ;
        LogFile.Write(_L8("\n<GetPositionOpts4 Test> \n"));
        buf.Num(aActualInt, format) ;
        LogFile.Write(_L8("TimeTaken = "));
        LogFile.Write(buf) ;
        CloseFile();
        currPos1.GetPosition(cPos1);
        currPos2.GetPosition(cPos2);
        //	ValidatePosition(cPos1);
        //	ValidatePosition(cPos2);
        returnCode = KErrNone;	

        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionOpts4 Test>\n"));
        LogFile.Write(_L8("Failed(error in ret values)..\n"));
        CloseFile();	
        returnCode = KErrGeneral;
        }

    /*aRequestorStack.Close();
    delete identityInfo;*/
    delete CoreObj;

    __UHEAP_MARKEND; 

    return returnCode;
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetPositionOpts5
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetPositionOpts5( CStifItemParser& /*aItem*/ )
    {
    TInt ret1,ret2;
    TInt64 aTime1,aTime2;
    TPositionInfo currPos1,currPos2;
    TPosition cPos1,cPos2;
    TPositionUpdateOptions options;
    TTimeIntervalMicroSeconds aTimeOut =  10000000;
    TTimeIntervalMicroSeconds aInterval = 2000000;
    TTimeIntervalMicroSeconds aActualInterval;
    TTime aTimeStamp1,aTimeStamp2;
    TBool aAcceptPartialUpdates = ETrue;
    returnCode = KErrNone;

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetPostionOpts5");
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionOpts5 Test>\n"));
        LogFile.Write(_L8("Failed(Null CoreObj)..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    options.SetUpdateTimeOut(aTimeOut);
    options.SetUpdateInterval(aInterval);
    options.SetAcceptPartialUpdates(aAcceptPartialUpdates);

    //User::After(120000000);
    TRAP(ret1 , CoreObj->GetLocationL(&currPos1,&options));

    if(KErrNone == ret1)
        {
        TRAP(ret2 , CoreObj->GetLocationL(&currPos2,&options));
        if(KErrNone == ret2)
            {
            currPos1.GetPosition(cPos1);
            currPos2.GetPosition(cPos2);
            aTimeStamp1 = cPos1.Time();
            aTimeStamp2 = cPos2.Time();
            aTime1 = aTimeStamp1.Int64();
            aTime2 = aTimeStamp2.Int64();
            if((aTime1) && (aTime2))
                {
                OpenFile();
                LogFile.Write(_L8("\n<GetPositionOpts5 Test>\n"));
                LogFile.Write(_L8("Passed..\n"));
                CloseFile();
                returnCode = KErrNone;	
                }
            else
                {
                OpenFile();
                LogFile.Write(_L8("\n<GetPositionOpts5 Test>\n"));
                LogFile.Write(_L8("Failed(no timeStamp)..\n"));
                CloseFile();
                returnCode = KErrGeneral;	
                }
            }
        else
            {
            OpenFile();
            LogFile.Write(_L8("\n<GetPositionOpts5 Test>\n"));
            LogFile.Write(_L8("Failed(getLoc2 error)..\n"));
            CloseFile();
            returnCode = KErrGeneral;		
            }
        }

    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetPositionOpts5 Test>\n"));
        LogFile.Write(_L8("Failed(getLoc error)..\n"));
        CloseFile();
        returnCode = KErrGeneral;	
        }

    /*aRequestorStack.Close();
	delete identityInfo;*/
    delete CoreObj;
    __UHEAP_MARKEND;   
    return returnCode;
    }

// -----------------------------------------------------------------------------
// CSAPILocTest::GetLastPosition
// -----------------------------------------------------------------------------
//
//TInt CSAPILocTest::GetLastPosition( CStifItemParser& /*aItem*/ )
/*  {
    	TInt ret;
    	TPosition currPos;
    	TTime currPosTime;
    	TDateTime currPosDateTime;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetLastPosition" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    // Print to log file
    iLog->Log( KExample );

    __UHEAP_MARK;
    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
    {
    	iLog->Log( _L("CLocationService object creation failed") );	
   		return KErrGeneral;
   	}

    ret = CoreObj->GetLastKnownLoc(currPos);
    if( KErrUnknown==ret )
    {
    	iLog->Log( _L("GetLastLocation failed to return values") );
    	 aRequestorStack.Close();
	    delete identityInfo;
	    delete CoreObj;
    	 __UHEAP_MARKEND;
    	return KErrNone;	
    }

    else
    {
    	iLog->Log( _L("GetLastLocation returned") );
    	 aRequestorStack.Close();
	    delete identityInfo;
	    delete CoreObj;
    	 __UHEAP_MARKEND;
    	return KErrGeneral;
    }


    }*/


// -----------------------------------------------------------------------------
// CSAPILocTest::GetLastPosition1
// -----------------------------------------------------------------------------
//
//TInt CSAPILocTest::GetLastPosition1( CStifItemParser& /*aItem*/ )
/*    {
    	TInt aRet,aRet1;
    	TPosition aCurrPos,aLastPos;
    	TTime aCurrPosTime,aLastPosTime;
    	TDateTime aCurrPosDateTime;
    	TReal64 aLatitude1,aLatitude2;  
    	TReal64 aLongitude1,aLongitude2;
    	TReal32 aAltitude1,aAltitude2; 
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetLastPosition1" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    // Print to log file
    iLog->Log( KExample );

    __UHEAP_MARK;
    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
    {
    	iLog->Log( _L("CLocationService object creation failed") );	
   		__UHEAP_MARKEND;
   		return KErrGeneral;
   	}

    aRet = CoreObj->GetLocationL(aCurrPos);
    if(aRet)
    {
    	iLog->Log( _L("GetLocationL failed") );
    	 aRequestorStack.Close();
	    delete identityInfo;
	    delete CoreObj;
    	__UHEAP_MARKEND;
    	return KErrGeneral;	
    }

    aCurrPosTime = aCurrPos.Time();
    aRet1 = CoreObj->GetLastKnownLoc(aLastPos);
    if(!aRet1)
    {
    	aLastPosTime = aLastPos.Time();
    	if( aCurrPosTime != aLastPosTime )
    	{
    		iLog->Log( _L("Timestamp mismatch") );
    		 aRequestorStack.Close();
	    delete identityInfo;
	    delete CoreObj;
    		__UHEAP_MARKEND;
    		return KErrGeneral;	
    	}
    	else
    	{
    		aLatitude1  = aCurrPos.Latitude();
    		aLongitude1 = aCurrPos.Longitude();
    		aAltitude1 = aCurrPos.Altitude();
            aLatitude2  = aLastPos.Latitude();
    		aLongitude2 = aLastPos.Longitude();
    		aAltitude2 = aLastPos.Altitude();

    		if( (aLatitude1 != aLatitude2) || (aLongitude1 != aLongitude2) || (aAltitude1 != aAltitude2 ))
    		{
    			iLog->Log( _L("Returned coordinates are wrong") );
    			 aRequestorStack.Close();
	    delete identityInfo;
	    delete CoreObj;
    			__UHEAP_MARKEND;
    			return KErrGeneral;	
   			}
            else
            {
            	iLog->Log( _L("Last postion value returned") );
    			 aRequestorStack.Close();
	    delete identityInfo;
	    delete CoreObj;
    			__UHEAP_MARKEND;
    			return KErrNone;	
            }  

        }
    }


    else
    {
    	iLog->Log( _L("GetLastKnownLoc failed"));
         aRequestorStack.Close();
	    delete identityInfo;
	    delete CoreObj;
	    __UHEAP_MARKEND;       
        return KErrNone;    
    }


    }*/


// -----------------------------------------------------------------------------
// CSAPILocTest::GetDistance
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetDistance( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetDistance" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 0;
    aRet = CoreObj->MathOperation(aInputParam);
    if( KErrArgument == aRet )
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance test> \n"));
        LogFile.Write(_L8("Passed..\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance test> \n"));
        LogFile.Write(_L8("Failed..\n")) ;
        CloseFile();
        returnCode = KErrGeneral;     	
        }		


    delete CoreObj;

    __UHEAP_MARKEND;       
    return KErrNone;    
    }

// -----------------------------------------------------------------------------
// CSAPILocTest::GetDistance2
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetDistance2( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    // 	TPositionInfo currPos[2];
    TPosition currPos1[2];
    inpparam aInputParam;
    TReal64 aLatitude1 = 10,aLatitude2 = 20;
    TReal64 aLongitude1 = 120,aLongitude2 = 140;
    TReal32 aAltitude1 = 500,aAltitude2 = 500; 
    returnCode = KErrNone;

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetDistance2" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance2 Test>\n"));
        LogFile.Write(_L8("Failed(CoreObj Creation)..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    /*for( TInt i=0;i<2;i++)
    	{
        ret[i] = CoreObj->GetLocationL(&currPos[i]);
    	}
    if( !ret[0] && !ret[1])
    	{


   		currPos[0].GetPosition(currPos1[0]);
    	currPos[1].GetPosition(currPos1[1]);

    	aLatitude1  = currPos1[0].Latitude();
		aLongitude1 = currPos1[0].Longitude() ;
		aAltitude1  = currPos1[0].Altitude() ;
	   	aLatitude2  = currPos1[1].Latitude();
		aLongitude2 = currPos1[1].Longitude() ;
		aAltitude2  = currPos1[1].Altitude() ;
     */	
    aInputParam.servicechoice = 10;
    aInputParam.source.SetCoordinate(aLatitude1,aLongitude1,aAltitude1);
    aInputParam.destination.SetCoordinate(aLatitude2,aLongitude2,aAltitude2);

    aRet = CoreObj->MathOperation(aInputParam);

    if(KErrNotSupported == aRet)
        {
        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format; 
        LogFile.Write(_L8("\n<GetDistance2 test> \n"));
        LogFile.Write(_L8("Passed..\n"));
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance2 test> \n"));
        LogFile.Write(_L8("Failed(Wrong error)..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }
    /*	}
    else
    	{
    	OpenFile();
    	LogFile.Write(_L8("\n<GetDistance2 test> \n"));
 	    LogFile.Write(_L8("Failed..\n"));
 	    CloseFile();
 	    returnCode = KErrGeneral;	
    	}
     */
    /*aRequestorStack.Close();
   delete identityInfo;*/
    delete CoreObj;

    __UHEAP_MARKEND;
    return returnCode;
    }
// -----------------------------------------------------------------------------
// CSAPILocTest::GetDistance3
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetDistance3( CStifItemParser& /*aItem*/ )
    {
    TInt ret[2],aRet;
    TPositionInfo currPos[2];
    TPosition currPos1[2];
    inpparam aInputParam;
    returnCode = KErrNone;
    TReal64 aLatitude1,aLatitude2;
    TReal64 aLongitude1,aLongitude2;
    TReal32 aAltitude1,aAltitude2; 
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetDistance3" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance3 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    for( TInt i=0;i<2;i++)
        {
        TRAP(ret[i] , CoreObj->GetLocationL(&currPos[i]));
        }
    if( (KErrNone == ret[0]) && (KErrNone == ret[1] ))
        {
        currPos[0].GetPosition(currPos1[0]);
        currPos[1].GetPosition(currPos1[1]);
        aLatitude1  = currPos1[0].Latitude();
        aLongitude1 = currPos1[0].Longitude() ;
        aAltitude1  = currPos1[0].Altitude() ;
        aLatitude2  = currPos1[1].Latitude();
        aLongitude2 = currPos1[1].Longitude() ;
        aAltitude2  = currPos1[1].Altitude() ;

        aInputParam.servicechoice = 0;
        aInputParam.source.SetCoordinate(aLatitude1,aLongitude1,aAltitude1);
        aInputParam.destination.SetCoordinate(aLatitude2,aLongitude2,aAltitude2);

        aRet = CoreObj->MathOperation(aInputParam);

        if( KErrNone == aRet )
            {
            OpenFile();
            TBuf8<50> buf ;
            TRealFormat format; 
            LogFile.Write(_L8("\n<GetDistance3 test> \n"));
            buf.Num(aInputParam.result, format) ;
            LogFile.Write(_L8("Distance = "));
            LogFile.Write(buf) ;
            LogFile.Write(_L8("\n")) ;
            CloseFile();
            if( aInputParam.result<0 )
                {
                returnCode = KErrGeneral; 
                }
            else
                {
                returnCode = KErrNone;  
                }
            }
        else
            {
            OpenFile();
            LogFile.Write(_L8("\n<GetDistance3 test> \n"));
            LogFile.Write(_L8("Failed(Math op).. \n"));
            CloseFile();
            returnCode = KErrGeneral;
            }
        }
    else
        {  
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance3 test> \n"));
        LogFile.Write(_L8("Failed(getloc error).. \n"));
        CloseFile();
        returnCode = KErrGeneral;	
        }

    /*aRequestorStack.Close();
   delete identityInfo;*/
    delete CoreObj;

    __UHEAP_MARKEND; 	

    return returnCode;
    }

// -----------------------------------------------------------------------------
// CSAPILocTest::GetDistance4
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetDistance4( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    TTime aCurrentTime;
    returnCode = KErrNone;

    TCoordinate  aCoordinate1(90,180),aCoordinate2(-90,0);
    //	TLocality aLocality1(aCordinate1,5),aLocality2(aCordinate2,5);
    //	TPosition aPosition1(aLocality1,aCurrentTime),aPosition2(aLocality2,aCurrentTime);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetDistance4" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance4 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }


    aInputParam.servicechoice = 0;
    aInputParam.source = aCoordinate1;
    aInputParam.destination = aCoordinate2;
    //	aInputParam.source.SetPosition(aPosition1);
    //	aInputParam.destination.SetPosition(aPosition2);

    aRet = CoreObj->MathOperation(aInputParam);
    if(KErrNone == aRet)
        {
        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format; 
        LogFile.Write(_L8("\n<GetDistance4 test> \n"));
        buf.Num(aInputParam.result, format) ;
        LogFile.Write(_L8("Distance = "));
        LogFile.Write(buf) ;
        LogFile.Write(_L8("\n")) ;
        CloseFile();

        if( aInputParam.result<0 )
            {
            returnCode = KErrGeneral; 
            }
        else
            {
            returnCode = KErrNone;  
            }

        }

    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance4 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;	
        }
    delete CoreObj;

    __UHEAP_MARKEND;	

    return returnCode;	
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetDistance5
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetDistance5( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    TTime aCurrentTime;
    returnCode = KErrNone;

    TCoordinate  aCoordinate1(0,0),aCoordinate2(0,0);
    //	TLocality aLocality1(aCordinate1,5),aLocality2(aCordinate2,5);
    //	TPosition aPosition1(aLocality1,aCurrentTime),aPosition2(aLocality2,aCurrentTime);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetDistance5" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance5 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }


    aInputParam.servicechoice = 0;
    aInputParam.source = aCoordinate1;
    aInputParam.destination = aCoordinate2;
    //	aInputParam.source.SetPosition(aPosition1);
    //	aInputParam.destination.SetPosition(aPosition2);

    aRet = CoreObj->MathOperation(aInputParam);

    if(( KErrNone == aRet ) && (aInputParam.result == 0))
        {
        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format; 
        LogFile.Write(_L8("\n<GetDistance5 test> \n"));
        buf.Num(aInputParam.result, format) ;
        LogFile.Write(_L8("Distance = "));
        LogFile.Write(buf) ;
        LogFile.Write(_L8("\n")) ;
        CloseFile();

        if( aInputParam.result<0 )
            {
            returnCode = KErrGeneral; 
            }
        else
            {
            returnCode = KErrNone;  
            } 
        }

    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance5 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;	
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;  		
    }

// -----------------------------------------------------------------------------
// CSAPILocTest::GetDistance6
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetDistance6( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    TTime aCurrentTime;
    returnCode = KErrNone;
    TCoordinate  aCordinate1(80,190),aCordinate2(-80,-210);
    //	TLocality aLocality1(aCordinate1,5),aLocality2(aCordinate2,5);
    //	TPosition aPosition1(aLocality1,aCurrentTime),aPosition2(aLocality2,aCurrentTime);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetDistance6" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance6 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }


    aInputParam.servicechoice = 0;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;
    //  	aInputParam.source.SetPosition(aPosition1);
    //  	aInputParam.destination.SetPosition(aPosition2);

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrNone == aRet )
        {
        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format; 
        LogFile.Write(_L8("\n<GetDistance6 test> \n"));
        buf.Num(aInputParam.result, format) ;
        LogFile.Write(_L8("Distance = "));
        LogFile.Write(buf) ;
        LogFile.Write(_L8("\n")) ;
        CloseFile();

        if( aInputParam.result<0 )
            {
            returnCode = KErrGeneral; 
            }
        else
            {
            returnCode = KErrNone;  
            }
        }

    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance6 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;	
        } 

    delete CoreObj;
    __UHEAP_MARKEND; 
    return returnCode; 		
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetDistance7
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetDistance7( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    TTime aCurrentTime;
    returnCode = KErrNone;

    TCoordinate  aCordinate1(105,190),aCordinate2(-105,-210);
    //	TLocality aLocality1(aCordinate1,5),aLocality2(aCordinate2,5);
    //	TPosition aPosition1(aLocality1,aCurrentTime),aPosition2(aLocality2,aCurrentTime);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetDistance7" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance7 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 0;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;
    //    	aInputParam.source.SetPosition(aPosition1);
    //    	aInputParam.destination.SetPosition(aPosition2);
    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrNone == aRet)
        {
        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format; 
        LogFile.Write(_L8("\n<GetDistance7 test> \n"));
        buf.Num(aInputParam.result, format) ;
        LogFile.Write(_L8("Distance = "));
        LogFile.Write(buf) ;
        LogFile.Write(_L8("\n")) ;
        CloseFile();

        if( aInputParam.result<0 )
            {
            returnCode = KErrGeneral; 
            }
        else
            {
            returnCode = KErrNone;  
            }
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance7 position returned error> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }

// -----------------------------------------------------------------------------
// CSAPILocTest::GetDistance8
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetDistance8( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    TTime aCurrentTime;
    returnCode = KErrNone;

    TCoordinate  aCordinate1(360,400),aCordinate2(200,480);
    //	TLocality aLocality1(aCordinate1,5),aLocality2(aCordinate2,5);
    //	TPosition aPosition1(aLocality1,aCurrentTime),aPosition2(aLocality2,aCurrentTime);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetDistance8" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance8 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }


    aInputParam.servicechoice = 0;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;
    //    	aInputParam.source.SetPosition(aPosition1);
    //    	aInputParam.destination.SetPosition(aPosition2);

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrNone == aRet )
        {
        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format; 
        LogFile.Write(_L8("\n<GetDistance8 test> \n"));
        buf.Num(aInputParam.result, format) ;
        LogFile.Write(_L8("Distance = "));
        LogFile.Write(buf) ;
        LogFile.Write(_L8("\n")) ;
        CloseFile();
        if( aInputParam.result<0 )
            {
            returnCode = KErrGeneral; 
            }
        else
            {
            returnCode = KErrNone;  
            }  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance8 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }

// -----------------------------------------------------------------------------
// CSAPILocTest::GetDistance9
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetDistance9( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    TTime aCurrentTime;
    returnCode = KErrNone;
    TRealX nan;
    nan.SetNaN();
    TCoordinate  aCordinate1(nan,170),aCordinate2(70,170);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetDistance9" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance9 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }


    aInputParam.servicechoice = 0;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;
    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrArgument == aRet )
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance9 test> \n"));
        LogFile.Write(_L8("Passed..\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance9 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetDistance10
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetDistance10( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    TTime aCurrentTime;
    returnCode = KErrNone;
    TRealX nan;
    nan.SetNaN();
    TCoordinate  aCordinate1(30,nan),aCordinate2(70,170);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetDistance10" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance10 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }


    aInputParam.servicechoice = 0;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;
    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrArgument == aRet )
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance10 test> \n"));
        LogFile.Write(_L8("Passed..\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance10 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetDistance11
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetDistance11( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    TTime aCurrentTime;
    returnCode = KErrNone;
    TRealX nan;
    nan.SetNaN();
    TCoordinate  aCordinate1(30,110),aCordinate2(nan,170);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetDistance11" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance11 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }


    aInputParam.servicechoice = 0;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;
    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrArgument == aRet )
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance11 test> \n"));
        LogFile.Write(_L8("Passed..\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance11 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetDistance12
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetDistance12( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    TTime aCurrentTime;
    returnCode = KErrNone;
    TRealX nan;
    nan.SetNaN();
    TCoordinate  aCordinate1(30,110),aCordinate2(40,nan);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetDistance12" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance12 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }


    aInputParam.servicechoice = 0;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;
    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrArgument == aRet )
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance12 test> \n"));
        LogFile.Write(_L8("Passed..\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetDistance12 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }

// -----------------------------------------------------------------------------
// CSAPILocTest::GetBearing
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetBearing( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    TTime aCurrentTime;
    returnCode = KErrNone;

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetBearing" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }


    aInputParam.servicechoice = 1;
    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrArgument == aRet )
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing test> \n"));
        LogFile.Write(_L8("Passed..\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetBearing1
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetBearing1( CStifItemParser& /*aItem*/ )
    {
    TInt ret[2],aRet;
    TPositionInfo currPos[2];
    TPosition currPos1[2];
    inpparam aInputParam;
    TReal64 aLatitude1,aLatitude2;
    TReal64 aLongitude1,aLongitude2;
    TReal32 aAltitude1,aAltitude2; 
    returnCode = KErrNone;

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetBearing1" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing1 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);

    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    /* for( TInt i=0;i<2;i++)
    	{
      ret[i] = CoreObj->GetLocationL(&currPos[i]);
    	}
     */

    TRAP(ret[0] , CoreObj->GetLocationL(&currPos[0]) );

    //User::After(30000000) ;

    TRAP(ret[1] , CoreObj->GetLocationL(&currPos[1]) );

    if( !ret[0] && !ret[1])
        {
        aInputParam.servicechoice = 1;
        currPos[0].GetPosition(currPos1[0]);
        currPos[1].GetPosition(currPos1[1]);
        aLatitude1  = currPos1[0].Latitude();
        aLongitude1 = currPos1[0].Longitude() ;
        //aAltitude1  = currPos1[0].Altitude() ;
        //aAltitude1  = NaN;
        aLatitude2  = currPos1[1].Latitude();
        aLongitude2 = currPos1[1].Longitude() ;
        //aAltitude2  = currPos1[1].Altitude() ;

        aInputParam.source.SetCoordinate(aLatitude1,aLongitude1/*,aAltitude1*/);
        aInputParam.destination.SetCoordinate(aLatitude2,aLongitude2/*,aAltitude2*/);

        aRet = CoreObj->MathOperation(aInputParam);

        if(KErrNone == aRet)
            {
            OpenFile();
            TBuf8<50> buf ;
            TRealFormat format; 
            LogFile.Write(_L8("\n<GetBearing1 test> \n"));
            buf.Num(aInputParam.result, format) ;
            LogFile.Write(_L8("Bearing = "));
            LogFile.Write(buf) ;
            LogFile.Write(_L8("\n")) ;
            CloseFile();
            returnCode = KErrNone;  
            }
        else if(aRet == KErrPositionIncalculable )
            {
            CloseFile();
            returnCode = KErrNone; 

            }
        else
            {
            OpenFile();
            LogFile.Write(_L8("\n<GetBearing1 test> \n"));
            LogFile.Write(_L8("Failed @ math op..\n"));
            CloseFile();
            returnCode = KErrGeneral;
            }
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing1 test> \n"));
        LogFile.Write(_L8("Failed * coreob..\n"));
        CloseFile();
        returnCode = KErrGeneral;	
        }


    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetBearing2
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetBearing2( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;

    TCoordinate  aCordinate1(90,90),aCordinate2(90,90);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetBearing2" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing2 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 1;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;

    aRet = CoreObj->MathOperation(aInputParam);

    if(KErrPositionIncalculable == aRet)
        {
        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format; 
        LogFile.Write(_L8("\n<GetBearing2 test> \n"));
        LogFile.Write(_L8("Passed..\n"));
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing2 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }
    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetBearing3
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetBearing3( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;

    TCoordinate  aCordinate1(0,0),aCordinate2(0,0);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetBearing3" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing3 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 1;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;

    aRet = CoreObj->MathOperation(aInputParam);

    if(KErrPositionIncalculable == aRet )
        {
        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format; 
        LogFile.Write(_L8("\n<GetBearing3 test> \n"));
        LogFile.Write(_L8("Passed..\n"));
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing3 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }
    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetBearing4
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetBearing4( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;

    TCoordinate  aCordinate1(40,90),aCordinate2(30,120);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetBearing4" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing4 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 1;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrNone == aRet )
        {
        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format; 
        LogFile.Write(_L8("\n<GetBearing4 test> \n"));
        buf.Num(aInputParam.result, format) ;
        LogFile.Write(_L8("Bearing = "));
        LogFile.Write(buf) ;
        LogFile.Write(_L8("\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing4 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }
    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetBearing5
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetBearing5( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;

    TCoordinate  aCordinate1(90,180),aCordinate2(-90,-180);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetBearing5" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing5 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 1;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;

    aRet = CoreObj->MathOperation(aInputParam);

    if(KErrPositionIncalculable == aRet )
        {
        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format; 
        LogFile.Write(_L8("\n<GetBearing5 test> \n"));
        LogFile.Write(_L8("Passed..\n"));
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing5 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }
    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetBearing6
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetBearing6( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;

    TCoordinate  aCordinate1(-120,-180),aCordinate2(160,180);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetBearing6" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing6 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 1;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrNone == aRet )
        {
        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format; 
        LogFile.Write(_L8("\n<GetBearing6 test> \n"));
        buf.Num(aInputParam.result, format) ;
        LogFile.Write(_L8("Bearing = "));
        LogFile.Write(buf) ;
        LogFile.Write(_L8("\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing6 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetBearing7
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetBearing7( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;

    TCoordinate  aCordinate1(35,360),aCordinate2(-80,-200);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetBearing7" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing7 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 1;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrNone == aRet )
        {
        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format; 
        LogFile.Write(_L8("\n<GetBearing7 test> \n"));
        buf.Num(aInputParam.result, format) ;
        LogFile.Write(_L8("Bearing = "));
        LogFile.Write(buf) ;
        LogFile.Write(_L8("\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing7 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetBearing8
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetBearing8( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;

    TCoordinate  aCordinate1(-30,160),aCordinate2(120,240);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetBearing8" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing8 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 1;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrNone == aRet )
        {
        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format; 
        LogFile.Write(_L8("\n<GetBearing8 test> \n"));
        buf.Num(aInputParam.result, format) ;
        LogFile.Write(_L8("Bearing = "));
        LogFile.Write(buf) ;
        LogFile.Write(_L8("\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing8 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetBearing9
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetBearing9( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;

    TCoordinate  aCordinate1(105,190),aCordinate2(-105,-210);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetBearing9" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing9 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 1;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrNone == aRet )
        {
        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format; 
        LogFile.Write(_L8("\n<GetBearing9 test> \n"));
        buf.Num(aInputParam.result, format) ;
        LogFile.Write(_L8("Bearing = "));
        LogFile.Write(buf) ;
        LogFile.Write(_L8("\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing9 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetBearing10
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetBearing10( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;

    TCoordinate  aCordinate1(75,190),aCordinate2(-20,-220);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetBearing10" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing10 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 1;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrNone == aRet )
        {
        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format; 
        LogFile.Write(_L8("\n<GetBearing10 test> \n"));
        buf.Num(aInputParam.result, format) ;
        LogFile.Write(_L8("Bearing = "));
        LogFile.Write(buf) ;
        LogFile.Write(_L8("\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing10 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetBearing11
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetBearing11( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;
    TRealX nan;
    nan.SetNaN();
    TCoordinate  aCordinate1(nan,190),aCordinate2(-20,-220);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetBearing11" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing11 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 1;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrArgument == aRet )
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing11 test> \n"));
        LogFile.Write(_L8("Passed..\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing11 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }
    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::GetBearing12
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetBearing12( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;
    TRealX nan;
    nan.SetNaN();
    TCoordinate  aCordinate1(40,nan),aCordinate2(-20,-220);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetBearing12" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing12 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 1;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrArgument == aRet )
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing12 test> \n"));
        LogFile.Write(_L8("Passed..\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing12 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }
    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }



// -----------------------------------------------------------------------------
// CSAPILocTest::GetBearing13
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetBearing13( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;
    TRealX nan;
    nan.SetNaN();
    TCoordinate  aCordinate1(40,140),aCordinate2(nan,-220);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetBearing13" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing13 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 1;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrArgument == aRet )
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing13 test> \n"));
        LogFile.Write(_L8("Passed..\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing13 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }



// -----------------------------------------------------------------------------
// CSAPILocTest::GetBearing14
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::GetBearing14( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;
    TRealX nan;
    nan.SetNaN();
    TCoordinate  aCordinate1(40,140),aCordinate2(60,nan);

    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "GetBearing14" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing14 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 1;
    aInputParam.source = aCordinate1;
    aInputParam.destination = aCordinate2;

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrArgument == aRet )
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing14 test> \n"));
        LogFile.Write(_L8("Passed..\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<GetBearing14 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }
    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::Move1
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::Move1( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;
    TRealX nan;
    nan.SetNaN();
    TCoordinate  aCordinate1(nan,140);
    TReal32 aDist=1000,aBearing=100;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "Move1" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move1 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 2;
    aInputParam.source = aCordinate1;
    aInputParam.bearing = aBearing;
    aInputParam.distance = aDist;

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrArgument == aRet )
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move1 test> \n"));
        LogFile.Write(_L8("Passed..\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move1 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }
    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }



// -----------------------------------------------------------------------------
// CSAPILocTest::Move2
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::Move2( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;
    TRealX nan;
    nan.SetNaN();
    TCoordinate  aCordinate1(40,nan);
    TReal32 aDist=1000,aBearing=100;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "Move2" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move2 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 2;
    aInputParam.source = aCordinate1;
    aInputParam.bearing = aBearing;
    aInputParam.distance = aDist;

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrArgument == aRet )
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move2 test> \n"));
        LogFile.Write(_L8("Passed..\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move2 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }
    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }



// -----------------------------------------------------------------------------
// CSAPILocTest::Move3
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::Move3( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;
    TRealX nan;
    nan.SetNaN();
    TCoordinate  aCordinate1(90,0);
    TReal32 aDist=1000,aBearing=100;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "Move3" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move3 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 2;
    aInputParam.source = aCordinate1;
    aInputParam.bearing = aBearing;
    aInputParam.distance = aDist;

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrPositionIncalculable == aRet )
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move3 test> \n"));
        LogFile.Write(_L8("Passed..\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move3 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }




// -----------------------------------------------------------------------------
// CSAPILocTest::Move4
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::Move4( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;
    TRealX nan;
    nan.SetNaN();
    TCoordinate  aCordinate1(-90,0);
    TReal32 aDist=1000,aBearing=100;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "Move4" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move4 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 2;
    aInputParam.source = aCordinate1;
    aInputParam.bearing = aBearing;
    aInputParam.distance = aDist;

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrPositionIncalculable == aRet )
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move4 test> \n"));
        LogFile.Write(_L8("Passed..\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move4 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }




// -----------------------------------------------------------------------------
// CSAPILocTest::Move5
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::Move5( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;
    TRealX nan;
    nan.SetNaN();
    TCoordinate  aCordinate1(0,0);
    TReal32 aDist=1000,aBearing=100;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "Move5" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move5 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 2;
    aInputParam.source = aCordinate1;
    aInputParam.bearing = aBearing;
    aInputParam.distance = aDist;

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrNone == aRet )
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move5 test> \n"));
        LogFile.Write(_L8("Passed..\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move5 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::Move6
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::Move6( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;
    TRealX nan;
    nan.SetNaN();
    TCoordinate  aCordinate1(20,120);
    TReal32 aDist=1000,aBearing=100;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "Move6" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move6 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 2;
    aInputParam.source = aCordinate1;
    aInputParam.bearing = aBearing;
    aInputParam.distance = aDist;

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrNone == aRet )
        {
        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format; 
        LogFile.Write(_L8("\n<Move6 test> \n"));
        TReal64 aLatitude  = aCordinate1.Latitude();
        buf.Num(aLatitude, format) ;
        LogFile.Write(_L8("Latitude = "));
        LogFile.Write(buf) ;
        TReal64 aLongitude  = aCordinate1.Longitude();
        buf.Num(aLongitude, format) ;
        LogFile.Write(_L8("Longitude = "));
        LogFile.Write(buf) ;
        LogFile.Write(_L8("Passed..\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move6 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }

// -----------------------------------------------------------------------------
// CSAPILocTest::Move7
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::Move7( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;
    TRealX nan;
    nan.SetNaN();
    TCoordinate  aCordinate1(-30,-70);
    TReal32 aDist=1000,aBearing=100;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "Move7" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move7 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 2;
    aInputParam.source = aCordinate1;
    aInputParam.bearing = aBearing;
    aInputParam.distance = aDist;

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrNone == aRet )
        {
        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format; 
        LogFile.Write(_L8("\n<Move7 test> \n"));
        TReal64 aLatitude  = aCordinate1.Latitude();
        buf.Num(aLatitude, format) ;
        LogFile.Write(_L8("Latitude = "));
        LogFile.Write(buf) ;
        TReal64 aLongitude  = aCordinate1.Longitude();
        buf.Num(aLongitude, format) ;
        LogFile.Write(_L8("Longitude = "));
        LogFile.Write(buf) ;
        LogFile.Write(_L8("Passed..\n")) ;
        CloseFile();
        returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move7 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }


// -----------------------------------------------------------------------------
// CSAPILocTest::Move8
// -----------------------------------------------------------------------------
//
TInt CSAPILocTest::Move8( CStifItemParser& /*aItem*/ )
    {
    TInt aRet;
    inpparam aInputParam;
    returnCode = KErrNone;
    TRealX nan;
    nan.SetNaN();
    TCoordinate  aCordinate1(20,120);
    TReal32 aDist=0,aBearing=0;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "Move8" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move8 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    aInputParam.servicechoice = 2;
    aInputParam.source = aCordinate1;
    aInputParam.bearing = aBearing;
    aInputParam.distance = aDist;

    aRet = CoreObj->MathOperation(aInputParam);

    if( KErrNone == aRet )
        {
        OpenFile();
        TBuf8<50> buf ;
        TRealFormat format; 
        LogFile.Write(_L8("\n<Move8 test> \n"));
        TReal64 aLatitude  = aCordinate1.Latitude();
        buf.Num(aLatitude, format) ;
        LogFile.Write(_L8("Latitude = "));
        LogFile.Write(buf) ;
        TReal64 aLongitude  = aCordinate1.Longitude();
        buf.Num(aLongitude, format) ;
        LogFile.Write(_L8("Longitude = "));
        LogFile.Write(buf) ;
        CloseFile();
        if( aLatitude != 20 || aLongitude != 120)
            returnCode = KErrGeneral;
        else
            returnCode = KErrNone;  
        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("\n<Move8 test> \n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    delete CoreObj;
    __UHEAP_MARKEND;
    return returnCode;	
    }

// -----------------------------------------------------------------------------
// CSAPILocTest::Modinfo1
// -----------------------------------------------------------------------------
//
//TInt CSAPILocTest::Modinfo1( CStifItemParser& /*aItem*/ )
/*  {
    TInt aRet;
    TPositionModuleInfo currPos;
  	inpparam aInputParam;
    returnCode = KErrNone;
    TReal32 aDist=0,aBearing=0;
	// Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "Modinfo1" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    CLocationService *CoreObj = CLocationService :: NewL();

    if( NULL == CoreObj)
    	{
    	OpenFile();
	    LogFile.Write(_L8("\n<Move8 Test>\n"));
	    LogFile.Write(_L8("Failed..\n"));
	    CloseFile();
   		return KErrGeneral;
   		}

	aRet = CoreObj->GetModuleInfo(currPos);
	TPositionModuleInfo :: TCapabilities  currCapability  = currPos.Capabilities() ;

	if ( iLocinfoCategory == EGenericInfo )
	    {
	    if(currCapability & TPositionModuleInfo :: ECapabilitySpeed) //Populate output param with speed info
        {
        TReal32 speedinfo = 0 ;

        if(!aGenericInfo->GetValue(EPositionFieldHorizontalSpeed , speedinfo) ) //Extract speed 
            {
            iOutParmList->AppendL(TAiwGenericParam(KPositionFieldHorizontalSpeed , TAiwVariant((TReal)speedinfo))) ;
            }

        if(!aGenericInfo->GetValue(EPositionFieldHorizontalSpeedError , speedinfo))
            {
            iOutParmList->AppendL(TAiwGenericParam(KPositionFieldHorizontalSpeedError , TAiwVariant((TReal)speedinfo))) ;	
            }



        }   //End of EcapabilitySpeed 


	    if(currCapability & TPositionModuleInfo :: ECapabilitySatellite) //Extract satellitinfo if any and append it
	        {																//as part of out parm list
	        TInt8 satinfo  = 0;

	        if(!aGenericInfo->GetValue(EPositionFieldSatelliteNumInView , satinfo))
	            {
	            iOutParmList->AppendL(TAiwGenericParam(KPositionFieldSatelliteNumInView ,TAiwVariant((TInt32)satinfo) )) ;	
	            }


	        }

	    if(currCapability & TPositionModuleInfo :: ECapabilityDirection) //Extract direction info if any and append it 
	        {                                                               // as part of out parm list
	        TReal32 direcinfo = 0;

	        if(!aGenericInfo->GetValue(EPositionFieldTrueCourse , direcinfo) )
	            {
	            iOutParmList->AppendL(TAiwGenericParam(KPositionFieldTrueCourse , TAiwVariant((TInt32)direcinfo))) ;	
	            }


	        if(!aGenericInfo->GetValue(EPositionFieldTrueCourseError , direcinfo) )
	            {
	            iOutParmList->AppendL(TAiwGenericParam(KPositionFieldTrueCourseError , TAiwVariant((TInt32)direcinfo))) ;
	            }


	        if(!aGenericInfo->GetValue(EPositionFieldMagneticCourseError , direcinfo) )
	            {
	            iOutParmList->AppendL(TAiwGenericParam(KPositionFieldMagneticCourseError , TAiwVariant((TInt32)direcinfo))) ;
	            }

	        if(!aGenericInfo->GetValue(EPositionFieldMagneticCourse , direcinfo) )
	            {
	            iOutParmList->AppendL(TAiwGenericParam(KPositionFieldMagneticCourse , TAiwVariant((TInt32)direcinfo))) ;	
	            }

	        }


	    if(currCapability & TPositionModuleInfo :: ECapabilityCompass) //Extract compass info if any and append it 
	        {                                                               // as part of out parm list
	        TReal32 compassinfo ;

	        if(!aGenericInfo->GetValue(EPositionFieldHeading , compassinfo) )
	            {
	            iOutParmList->AppendL(TAiwGenericParam(KPositionFieldHeading , TAiwVariant((TInt32)compassinfo))) ;
	            }


	        if(!aGenericInfo->GetValue(EPositionFieldHeadingError , compassinfo) )
	            {
	            iOutParmList->AppendL(TAiwGenericParam(KPositionFieldHeadingError , TAiwVariant((TInt32)compassinfo))) ;
	            }

	        if(!aGenericInfo->GetValue(EPositionFieldMagneticHeading , compassinfo) )
	            {
	            iOutParmList->AppendL(TAiwGenericParam(KPositionFieldMagneticHeading , TAiwVariant((TInt32)compassinfo))) ;
	            }



	        if(!aGenericInfo->GetValue(EPositionFieldMagneticHeadingError , compassinfo) )
	            {
	            iOutParmList->AppendL(TAiwGenericParam(KPositionFieldMagneticHeadingError , TAiwVariant((TInt32)compassinfo))) ;	
	            }



	        }

	    if( currCapability & TPositionModuleInfo :: ECapabilityNmea ) //Extract Nmea info if any and append it 	
	        {                                                             //as part of out param list  
	        TUint8 numSentences ;

	        if(!aGenericInfo->GetValue(EPositionFieldNMEASentences , numSentences) )
	            {
	            iOutParmList->AppendL(TAiwGenericParam (KPositionFieldNMEASentences ,TAiwVariant((TInt32)numSentences) )) ;	
	            }


	        TBuf8 <20> nmeaSentences ;

	        if(!aGenericInfo->GetValue(EPositionFieldNMEASentencesStart , nmeaSentences) )
	            {
	            iOutParmList->AppendL(TAiwGenericParam (KPositionFieldNMEASentencesStart , TAiwVariant(nmeaSentences))) ;	
	            }
	        }


    aRequestorStack.Close();
	    delete identityInfo;
	    delete CoreObj;
   __UHEAP_MARKEND;
   return returnCode;	
   }*/


// -----------------------------------------------------------------------------
// CSAPILocTest::Modinfo1
// -----------------------------------------------------------------------------
//
class Modinfo1CallBack : public MLocationCallBack
    {
    TInt iCount ;
    TInt iRetStatus ;
    CLocationService *iCoreObj; 
    TInt iTransactionId;
    TInt iRequestType;
    public :
        TInt HandleNotifyL(HPositionGenericInfo* aOutPos , TInt aError) ;
        Modinfo1CallBack(TInt transId,TInt req,CLocationService *obj,TInt cnt=0,TInt retStatus=KErrGeneral) 
            {
            iTransactionId = transId;
            iRequestType = req;
            iCoreObj = obj;
            iCount = cnt;
            iRetStatus = retStatus;    
            }

        inline TUint GetRequestType(void) 
            {
            return iRequestType ;
            }


        /**
         * GetTransactionId function returns transcation id associated with current async object
         *
         */
        inline TInt32 GetTransactionId(void)
            {
            return iTransactionId ;
            }
    };


TInt Modinfo1CallBack :: HandleNotifyL(HPositionGenericInfo *currPos , TInt /*aError*/)
    {
    TInt aRetVal = KErrNone;
    TPositionModuleInfo modInfo;
    OpenFile();
    LogFile.Write(_L8("\n<Modinfo1 Test>\n "));
    CloseFile();
    TPosition outPos ;
    currPos->GetPosition(outPos) ;
    aRetVal = ValidatePosition(outPos);

    if( KErrNone == aRetVal )
        {
        aRetVal = iCoreObj->GetModuleInfo(modInfo);
        TPositionModuleInfo :: TCapabilities  currCapability  = modInfo.Capabilities() ;

        //	if ( iLocinfoCategory == EGenericInfo )
        //   	{
        //if( (currCapability & TPositionModuleInfo :: ECapabilitySpeed) && returnCode == KErrNone) //Populate output param with speed info
        if (currCapability & TPositionModuleInfo :: ECapabilitySpeed)	
            {
            TReal32 speedinfo = 0 ;

            if(!currPos->GetValue(EPositionFieldHorizontalSpeed , speedinfo) ) //Extract speed 
                {
                TBuf8<50> buf ;
                TRealFormat format ;
                buf.Num(speedinfo , format) ;
                OpenFile();
                LogFile.Write(_L8("HorizontalSpeed = "));
                LogFile.Write(buf) ;
                LogFile.Write(_L8("\n")) ;
                CloseFile();
                }

            else if(!currPos->GetValue(EPositionFieldHorizontalSpeedError , speedinfo))
                {
                TBuf8<50> buf ;
                TRealFormat format ;
                buf.Num(speedinfo , format) ;
                OpenFile();
                LogFile.Write(_L8("HorizontalSpeedError = "));
                LogFile.Write(buf) ;
                LogFile.Write(_L8("\n")) ;
                CloseFile();
                }
            /*   else
		         {
		         	returnCode = KErrGeneral;
		         }
             */    
            }   //End of EcapabilitySpeed 


        //  if((currCapability & TPositionModuleInfo :: ECapabilitySatellite) && returnCode == KErrNone ) //Extract satellitinfo if any and append it
        if(currCapability & TPositionModuleInfo :: ECapabilitySatellite)   
            {																//as part of out parm list
            TInt8 satinfo  = 0;

            if(!currPos->GetValue(EPositionFieldSatelliteNumInView , satinfo))
                {
                TBuf8<50> buf ;
                TRealFormat format ;
                buf.Num(satinfo , format) ;
                OpenFile();
                LogFile.Write(_L8("SatelliteNumInView = "));
                LogFile.Write(buf) ;
                LogFile.Write(_L8("\n")) ;
                CloseFile();
                }
            /* else
	         	{
	         	returnCode = KErrGeneral;
	         	}
             */
            }

        if( (currCapability & TPositionModuleInfo :: ECapabilityDirection) && returnCode == KErrNone) //Extract direction info if any and append it 
            {                                                               // as part of out parm list
            TReal32 direcinfo = 0;

            if(!currPos->GetValue(EPositionFieldTrueCourse , direcinfo) )
                {
                TBuf8<50> buf ;
                TRealFormat format ;
                buf.Num(direcinfo , format) ;
                OpenFile();
                LogFile.Write(_L8("TrueCourse  = "));
                LogFile.Write(buf) ;
                LogFile.Write(_L8("\n")) ;
                CloseFile();
                }

            else if(!currPos->GetValue(EPositionFieldTrueCourseError , direcinfo) )
                {
                TBuf8<50> buf ;
                TRealFormat format ;
                buf.Num(direcinfo , format) ;
                OpenFile();
                LogFile.Write(_L8("TrueCourseError = "));
                LogFile.Write(buf) ;
                LogFile.Write(_L8("\n")) ;
                CloseFile();	            
                }

            else if(!currPos->GetValue(EPositionFieldMagneticCourseError , direcinfo) )
                {
                TBuf8<50> buf ;
                TRealFormat format ;
                buf.Num(direcinfo , format) ;
                OpenFile();
                LogFile.Write(_L8("MagneticCourseError = "));
                LogFile.Write(buf) ;
                LogFile.Write(_L8("\n")) ;
                CloseFile();	           
                }

            else if(!currPos->GetValue(EPositionFieldMagneticCourse , direcinfo) )
                {
                TBuf8<50> buf ;
                TRealFormat format ;
                buf.Num(direcinfo , format) ;
                OpenFile();
                LogFile.Write(_L8("MagneticCourse = "));
                LogFile.Write(buf) ;
                LogFile.Write(_L8("\n")) ;
                CloseFile();	 	            
                }
            /*else
				{
				returnCode = KErrGeneral;
				}
             */
            }


        //if((currCapability & TPositionModuleInfo :: ECapabilityCompass) && returnCode == KErrNone) //Extract compass info if any and append it 
        if(currCapability & TPositionModuleInfo :: ECapabilityCompass)
            {                                                               // as part of out parm list
            TReal32 compassinfo ;

            if(!currPos->GetValue(EPositionFieldHeading , compassinfo) )
                {
                TBuf8<50> buf ;
                TRealFormat format ;
                buf.Num(compassinfo , format) ;
                OpenFile();
                LogFile.Write(_L8("FieldHeading = "));
                LogFile.Write(buf) ;
                LogFile.Write(_L8("\n")) ;
                CloseFile();	           
                }


            else if(!currPos->GetValue(EPositionFieldHeadingError , compassinfo) )
                {
                TBuf8<50> buf ;
                TRealFormat format ;
                buf.Num(compassinfo , format) ;
                OpenFile();
                LogFile.Write(_L8("FieldHeadingError = "));
                LogFile.Write(buf) ;
                LogFile.Write(_L8("\n")) ;
                CloseFile();		           
                }

            else if(!currPos->GetValue(EPositionFieldMagneticHeading , compassinfo) )
                {
                TBuf8<50> buf ;
                TRealFormat format ;
                buf.Num(compassinfo , format) ;
                OpenFile();
                LogFile.Write(_L8("MagneticHeading = "));
                LogFile.Write(buf) ;
                LogFile.Write(_L8("\n")) ;
                CloseFile();		           
                }

            else if(!currPos->GetValue(EPositionFieldMagneticHeadingError , compassinfo) )
                {
                TBuf8<50> buf ;
                TRealFormat format ;
                buf.Num(compassinfo , format) ;
                OpenFile();
                LogFile.Write(_L8("MagneticHeadingError = "));
                LogFile.Write(buf) ;
                LogFile.Write(_L8("\n")) ;
                CloseFile();	            
                }

            /*else
				{
				returnCode = KErrGeneral; 
				}
             */  
            }

        //if( (currCapability & TPositionModuleInfo :: ECapabilityNmea) && returnCode == KErrNone )//Extract Nmea info if any and append it 	
        if(currCapability & TPositionModuleInfo :: ECapabilityNmea)  
            {                                                             //as part of out param list  
            TUint8 numSentences ;
            TBuf8 <20> nmeaSentences ;
            if(!currPos->GetValue(EPositionFieldNMEASentences , numSentences) )
                {
                TBuf8<50> buf ;
                TRealFormat format ;
                buf.Num(numSentences , format) ;
                OpenFile();
                LogFile.Write(_L8("NMEASentences = "));
                LogFile.Write(buf) ;
                LogFile.Write(_L8("\n")) ;
                CloseFile();	            
                }

            else if(!currPos->GetValue(EPositionFieldNMEASentencesStart , nmeaSentences) )
                {
                TRealFormat format ;
                OpenFile();
                LogFile.Write(_L8("NMEASentencesStart = "));
                LogFile.Write(nmeaSentences) ;
                LogFile.Write(_L8("\n")) ;
                CloseFile();	            
                }
            /*	else
				{
				returnCode = KErrGeneral;
				}
             */ 
            }

        }
    else
        {
        OpenFile();
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        returnCode = KErrGeneral;
        }

    CActiveScheduler *Current = CActiveScheduler :: Current() ;
    Current->Stop() ;
    return KErrNone ;
    }

TInt ModinfoFunctionL()
    {
    __UHEAP_MARK ;
    CLocationService *CoreObj = CLocationService ::NewL() ;

    if( NULL == CoreObj )
        {
        OpenFile();
        LogFile.Write(_L8("\n<Modinfo1 Test>\n"));
        LogFile.Write(_L8("Failed..\n"));
        CloseFile();
        return KErrGeneral;
        }

    _LIT(Kidentity ,"Coreclass Testing" ) ;
    //not needed any more
    /*RRequestorStack aRequestorStack;
	const CRequestor* identityInfo = CRequestor::NewL(1 , 1 , Kidentity) ;
    aRequestorStack.Insert(identityInfo,0);
    CoreObj->SetRequestorIdentityL(aRequestorStack) ;*/

    Modinfo1CallBack MyUpdates(25,GETLOCATION,CoreObj)  ;
    CoreObj->GetLocationL(&MyUpdates) ;
    CActiveScheduler :: Start() ;
    /*aRequestorStack.Close();
	    delete identityInfo;*/
    delete CoreObj;
    __UHEAP_MARKEND ;
    return 0;
    }

TInt CSAPILocTest::Modinfo1( CStifItemParser& /*aItem*/ )
    {
    TRequestStatus status = KRequestPending;
    TInt aRet = KErrNone;
    returnCode = KErrNone;
    // Print to UI
    _LIT( KSAPILocTest, "SAPILocTest" );
    _LIT( KExample, "Modinfo1" );
    TestModuleIf().Printf( 0, KSAPILocTest, KExample );

    __UHEAP_MARK;

    TRAPD(err , aRet = ModinfoFunctionL()) ;
    if( err || aRet )
        returnCode = KErrGeneral; 

    __UHEAP_MARKEND;

    return returnCode;  
    }

