/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  provides testing of CPosLandmark class methods

*

*/

// INCLUDE FILES

#include <EPos_CPosLandmark.h>

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLmCategoryManager.h>

#include <EPos_CPosLandmarkCategory.h>

#include <LbsPosition.h>

#include "testcposlandmark.h"

#include <StifParser.h>

#include <Stiftestinterface.h>

// Literals

// Test Database URI

_LIT( KDBUri, "file://c:eposlmtest.ldb" );

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

// -----------------------------------------------------------------------------

// CTestPosLandmark::CTestPosLandmark

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CTestPosLandmark::CTestPosLandmark( CStifLogger* aLog )

	{

	iLog = aLog;

	}

// -----------------------------------------------------------------------------

// CTestPosLandmark::NewL

// 

// 

// -----------------------------------------------------------------------------

//	

CTestPosLandmark* CTestPosLandmark::NewL( CStifLogger* aLog )

	{

	CTestPosLandmark* self = new (ELeave) CTestPosLandmark( aLog );

	CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(); 

    return self; 

	}

// -----------------------------------------------------------------------------

// CTestPosLandmark::ConstructL

// 

// 

// -----------------------------------------------------------------------------

//	

void CTestPosLandmark::ConstructL()

	{

	}

// -----------------------------------------------------------------------------

// CTestPosLandmark::~CTestPosLandmark

// 

// 

// -----------------------------------------------------------------------------

//		

CTestPosLandmark::~CTestPosLandmark()

	{

	}

// -----------------------------------------------------------------------------

// CTestPosLandmark::CreateNewLandmarkL

// 

// 

// -----------------------------------------------------------------------------

//

TInt CTestPosLandmark::CreateNewLandmarkL( CStifItemParser& /*aItem*/ )

	{

	//Create an object using NewL()

	CPosLandmark* lmk = CPosLandmark::NewL();

	delete lmk;

	return KErrNone;

	}

// -----------------------------------------------------------------------------

// CTestPosLandmark::CreateNewLandmarkLC

// 

// 

// -----------------------------------------------------------------------------

//

TInt CTestPosLandmark::CreateNewLandmarkLC( CStifItemParser& /*aItem*/ )

	{

	//Create an object using NewLC()

	CPosLandmark* lmk = CPosLandmark::NewLC();

	CleanupStack::PopAndDestroy( lmk );

	return KErrNone;

	}

// -----------------------------------------------------------------------------

// CTestPosLandmark::CreateLandmarkCopyL

// 

// 

// -----------------------------------------------------------------------------

//

TInt CTestPosLandmark::CreateLandmarkCopyL( CStifItemParser& /*aItem*/ )

	{

	// Create an object using NewL()

	CPosLandmark* lmk = CPosLandmark::NewL();

	CleanupStack::PushL( lmk );

	// Set radius of original landmark

	lmk->SetCoverageRadius( 2104 );

	// Create another object using copy constructor NewL

	CPosLandmark* lmkCopy = CPosLandmark::NewL( *lmk );

	CleanupStack::PushL( lmkCopy );

	// Get radius of new landmark

	TReal32 radius;

	lmkCopy->GetCoverageRadius( radius );

	// Check radius

	if( radius == 2104 )

		{

		iLog->Log( _L( "Landmark Creation passed" ) );

		//delete both the landmarks

		CleanupStack::PopAndDestroy( 2, lmk ); // lmkCopy

		return KErrNone; 	

		}

	else

		{

		iLog->Log( _L( "Landmark Creation failed" ) );

		CleanupStack::PopAndDestroy( 2, lmk ); // lmkCopy

		return KErrGeneral;

		}

	}

// -----------------------------------------------------------------------------

// CTestPosLandmark::CreateLandmarkCopyLC

// 

// 

// -----------------------------------------------------------------------------

//

TInt CTestPosLandmark::CreateLandmarkCopyLC( CStifItemParser& /*aItem*/ )

	{

	//Create an object using NewL()

	CPosLandmark* lmk = CPosLandmark::NewL();

	CleanupStack::PushL( lmk );

	// Create another landmark object using copy constructor NewLC

	CPosLandmark* lmkCopy = CPosLandmark::NewLC( *lmk );

	//

	CleanupStack::PopAndDestroy( 2, lmk ); // lmkCopy

	return KErrNone; 	

	}

// -----------------------------------------------------------------------------

// CTestPosLandmark::SetLandmarkNameL

// 

// 

// -----------------------------------------------------------------------------

//

TInt CTestPosLandmark::SetLandmarkNameL( CStifItemParser& aItem )

	{

	TPtrC name;

	TInt err = aItem.GetNextString( name ); // Landmark name

	//Create a new landmark object using NewL()

	CPosLandmark* lmk = CPosLandmark::NewL();

	CleanupStack::PushL( lmk );

	// Set name of landmark

	lmk->SetLandmarkNameL( name );

	// Get name

	TPtrC getNamePtr;

	lmk->GetLandmarkName( getNamePtr );

	//

	iLog->Log( _L("Name of landmark was set...") );

	iLog->Log( getNamePtr );

	// Delete object

	CleanupStack::PopAndDestroy( lmk );	

	return KErrNone;

	}

// -----------------------------------------------------------------------------

// CTestPosLandmark::GetLandmarkNameL

// 

// 

// -----------------------------------------------------------------------------

//

TInt CTestPosLandmark::GetLandmarkNameL( CStifItemParser& aItem )

	{

	TInt num;

	TInt err = aItem.GetNextInt( num ); // To set Landmark name or not

	//Create a new landmark object using NewL()

	CPosLandmark* lmk = CPosLandmark::NewL();

	CleanupStack::PushL( lmk );

	// Set name of landmark if integer value passed from cfg file is 1

	if( num == 1 )

		{

		_LIT( KLmkName, "A landmark Name" );

		TBufC<20> nameBuf( KLmkName );

		lmk->SetLandmarkNameL( KLmkName );

		}

	// Get name

	TPtrC getNamePtr;

	TInt error = lmk->GetLandmarkName( getNamePtr );

	// Check name

	iLog->Log( _L("Got the name of landmark...") );

	iLog->Log( getNamePtr );

	// Delete object

	CleanupStack::PopAndDestroy( lmk );		

	return error;

	}

// -----------------------------------------------------------------------------

// CTestPosLandmark::SetAndGetLmkDescL

// 

// 

// -----------------------------------------------------------------------------

//

TInt CTestPosLandmark::SetAndGetLmkDescL( CStifItemParser& aItem )

	{

	// For setting or not setting desc

	TInt num;

	TInt err = aItem.GetNextInt( num );	

	// Description

	TPtrC setDescPtr;

	err = aItem.GetNextString( setDescPtr ); // Landmark Desc

	//Create a new landmark object using NewL()

	CPosLandmark* lmk = CPosLandmark::NewL();

	CleanupStack::PushL( lmk );

	// Set description of landmark if num == 1

	if( num == 1 )

		{

		lmk->SetLandmarkDescriptionL( setDescPtr );

		}

	// Get desc

	TPtrC getDescPtr;

	TInt error = lmk->GetLandmarkDescription( getDescPtr );

	if( KErrNone != error )

		{

		// Error

		iLog->Log( _L( "Error in getting description of landmark..." ) );

		User::Leave( error );

		}

	// Print desc

	iLog->Log( _L("Got the description of landmark...") );

	iLog->Log( getDescPtr );

	//Compare desc

	if( getDescPtr.Compare( setDescPtr ) != 0 )

		{

		iLog->Log( _L("Error in getting description of landmark...") );

		User::Leave( error );

		}

	//Test successful

	iLog->Log( _L("Set and get description of landmark successful...") );	

	// Delete object

	CleanupStack::PopAndDestroy( lmk );

	return KErrNone;

	}

// -----------------------------------------------------------------------------

// CTestPosLandmark::SetAndGetCovRadiusL

// 

// 

// -----------------------------------------------------------------------------

//

TInt CTestPosLandmark::SetAndGetCovRadiusL( CStifItemParser& aItem )

	{

	// For setting or not setting radius

	TInt num;

	TInt err = aItem.GetNextInt( num );

	// Radius

	TPtrC radiusPtr;

	err = aItem.GetNextString( radiusPtr );

	TLex lex( radiusPtr );

	TReal32 radius = 23.56;

	lex.Val( radius );

	//Create a new landmark object using NewL()

	CPosLandmark* lmk = CPosLandmark::NewL();

	CleanupStack::PushL( lmk );

	// Set coverage radius of landmark if num == 1

	if( num == 1 )

		{

		lmk->SetCoverageRadius( radius ); //Return type void

		}

	// Get cov radius

	TInt error;

	TReal32 getRadius;

	error = lmk->GetCoverageRadius( getRadius );

	if( KErrNone != error )

		{

		// Error

		iLog->Log( _L("Error in getting radius of landmark...") );

		User::Leave( error );

		}

	//Compare radius

	if( radius != getRadius )

		{

		iLog->Log( _L("Error in getting radius of landmark...") );

		User::Leave( error );

		}

	//Test successful

	iLog->Log( _L("Set and get radius of landmark successful...") );	

	// Delete object

	CleanupStack::PopAndDestroy( lmk );

	return KErrNone;

	}

// -----------------------------------------------------------------------------

// CTestPosLandmark::SetAndGetPositionL

// 

// 

// -----------------------------------------------------------------------------

//

TInt CTestPosLandmark::SetAndGetPositionL( CStifItemParser& aItem )

	{

	// Decides whether to use or not Wgs84 data, and to set the position or not 

	TInt num;

	TInt err = aItem.GetNextInt( num );

	TPtrC latPtr;

	TPtrC longPtr;

	err = aItem.GetNextString( latPtr );

	err = aItem.GetNextString( longPtr );

	TLex lex1( latPtr );

	TLex lex2( longPtr );

	TReal64 latitude = 21.2435; 

	TReal64 longitude = 89.0001;

	lex1.Val( latitude );

	lex2.Val( longitude );	

	//Create a new landmark object using NewL()

	CPosLandmark* lmk = CPosLandmark::NewL();

	CleanupStack::PushL( lmk );

	// Set position of landmark

	TInt error;

	TLocality position;

	position.SetCoordinate( latitude, longitude );

	// if num is -1 then use datum other than Wsg84

	if( num == -1 )

		{

		const TPositionDatumId KId = {0x00}; // Wgs84 is 0x101FAA29

		position.SetDatum( KId );

		}

	// set position only if num is not 0	

	if( num != 0 )

		{

		lmk->SetPositionL( position );

		}

	// Get position

	TLocality getPosition;

	error = lmk->GetPosition( getPosition );

	if( KErrNone != error )

		{

		// Error

		iLog->Log( _L("Error in getting position of landmark...") );

		User::Leave( error );

		}

	//Compare position

	//Latitude

	if( getPosition.Latitude() != latitude )

		{

		iLog->Log( _L("Error in getting position of landmark...") );

		User::Leave( KErrGeneral );

		}

	//Longitude

	if( getPosition.Longitude() != longitude )

		{

		iLog->Log( _L("Error in getting position of landmark...") );

		User::Leave( KErrGeneral );

		}

	//Test successful

	iLog->Log( _L("Set and get position of landmark successful...") );	

	// Delete object

	CleanupStack::PopAndDestroy( lmk );

	return KErrNone;

	}

// -----------------------------------------------------------------------------

// CTestPosLandmark::SetAndGetPositionFieldL

// 

// 

// -----------------------------------------------------------------------------

//

TInt CTestPosLandmark::SetAndGetPositionFieldL( CStifItemParser& aItem )

	{

	// Decides whether to set position field or not

	TInt num;

	TInt err = aItem.GetNextInt( num );

	TPtrC fieldNamePtr;

	err = aItem.GetNextString( fieldNamePtr );

	// Create a new landmark object using NewL()

	CPosLandmark* lmk = CPosLandmark::NewL();

	CleanupStack::PushL( lmk );

	// Set Position field

	TPositionFieldId fieldId = 1;

	TInt error;

	// Set only if num == 1

	if( num == 1 )

		{

		lmk->SetPositionFieldL( fieldId, fieldNamePtr );	

		}

	//Get Position field

	TPtrC getPosField; 

	error = lmk->GetPositionField( fieldId, getPosField );

	if( KErrNone != error )

		{

		iLog->Log( _L("Error in getting position field...") );

		User::Leave( error );

		}

	//Print Position field

	iLog->Log( _L("Getting position field of landmark successful...") );

	iLog->Log(getPosField);

	//Compare position fields

	if( getPosField.Compare( fieldNamePtr ) != 0)

		{

		//Error

		iLog->Log( _L("Error in getting position field...") );

		User::Leave( KErrGeneral );//return KErrGeneral;

		}

	iLog->Log( _L("Get and set position field of landmark successful...") );

	CleanupStack::PopAndDestroy( lmk );

	return KErrNone;

	}

// -----------------------------------------------------------------------------

// CTestPosLandmark::NumOfPosFieldsL

// 

// 

// -----------------------------------------------------------------------------

//

TInt CTestPosLandmark::NumOfPosFieldsL( CStifItemParser& /*aItem*/ )

	{

	// Create a new landmark object using NewL()

	CPosLandmark* lmk = CPosLandmark::NewL();

	CleanupStack::PushL( lmk );

	//

	TUint numOfPosFields;

	numOfPosFields = lmk->NumOfAvailablePositionFields();

	if( numOfPosFields != 0 )

		{

		iLog->Log( _L("Error in getting number of position fields of landmark...") );

		User::Leave( KErrGeneral );

		}

	iLog->Log( _L("Getting number of position fields of landmark successful...") );	

	CleanupStack::PopAndDestroy( lmk );

	return KErrNone;

	}

// -----------------------------------------------------------------------------

// CTestPosLandmark::IsPosFieldAvailableL

// 

// 

// -----------------------------------------------------------------------------

//

TInt CTestPosLandmark::IsPosFieldAvailableL( CStifItemParser& /*aItem*/ )

	{

	// Create a new landmark object using NewL()

	CPosLandmark* lmk = CPosLandmark::NewL();

	CleanupStack::PushL( lmk );

	// Check for position field with id 1, should return EFalse

	TPositionFieldId fieldId = 1;

	TBool result;

	result = lmk->IsPositionFieldAvailable( fieldId );

	if ( result )

		{

		iLog->Log( _L("Error in IsPositionFieldAvailable1...") );

		User::Leave( KErrGeneral );

		}

	// Add a position field to landmark at index 'fieldId'

	_LIT( KFieldName, "The City Name" );

	lmk->SetPositionFieldL( fieldId, KFieldName );

	// Check for position field, should return ETrue

	result = lmk->IsPositionFieldAvailable( fieldId );

	if ( !result )

		{

		iLog->Log( _L("Error in IsPositionFieldAvailable2...") );

		User::Leave( KErrGeneral );

		}

	iLog->Log( _L("IsPositionFieldAvailable successful...") );	

	CleanupStack::PopAndDestroy( lmk );

	return KErrNone;

	}

// -----------------------------------------------------------------------------

// CTestPosLandmark::RemovePositionField

// 

// 

// -----------------------------------------------------------------------------

//

TInt CTestPosLandmark::RemovePositionFieldL( CStifItemParser& /*aItem*/ )

	{

	// Create a new landmark object using NewL()

	CPosLandmark* lmk = CPosLandmark::NewL();

	CleanupStack::PushL( lmk );

	// Add a position field

	TPositionFieldId fieldId = 1;

	_LIT( KFieldName, "The City Name" );

	//TInt error;

	lmk->SetPositionFieldL( fieldId, KFieldName );

	// Check if field is available, should return ETrue

	TBool result;

	result = lmk->IsPositionFieldAvailable( fieldId );

	if ( !result )

		{

		iLog->Log( _L("Error in setting position field, can not test RemovePositionField.") );

		User::Leave( KErrGeneral );

		}

	// Remove position field

	lmk->RemovePositionField( fieldId ); // No return

	// Check if field is available, should return EFalse

	result = lmk->IsPositionFieldAvailable( fieldId );

	if ( result )