/*

* 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 CPosLandmarkDatabase class methods

*

*/

// INCLUDE FILES

#include <EPos_CPosLandmark.h>

#include <EPos_CPosLandmarkDatabase.h>

#include <epos_cposlandmarkdatabaseextended.h>

#include <EPos_CPosLmCategoryManager.h>

#include <EPos_CPosLandmarkCategory.h>

#include <EPos_CPosLandmarkEncoder.h>

#include <EPos_CPosLandmarkParser.h>

#include <LbsPosition.h>

#include <EPos_CPosLmDatabaseManager.h> 

#include "testcposlandmarkdatabase.h"

#include <StifParser.h>

#include <Stiftestinterface.h>

// Literals

_LIT8( KPosMimeTypeLandmarkCollectionXml, "application/vnd.nokia.landmarkcollection+xml" );

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

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

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

// CTestPosLandmarkDatabase::CTestPosLandmarkDatabase

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

// might leave.

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

//

CTestPosLandmarkDatabase::CTestPosLandmarkDatabase( CStifLogger* aLog ) :

				CActive(EPriorityStandard), iLog(aLog)

	{

	CActiveScheduler::Add(this);

	}

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

// CTestPosLandmarkDatabase::NewL

// 

// 

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

//		

CTestPosLandmarkDatabase* CTestPosLandmarkDatabase::NewL(CStifLogger* aLog)

	{

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

	CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(); 	

    return self; 

	}

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

// CTestPosLandmarkDatabase::ConstructL

// 

// 

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

//	

void CTestPosLandmarkDatabase::ConstructL()

	{

	}

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

// CTestPosLandmarkDatabase::~CTestPosLandmarkDatabase

// 

// 

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

//		

CTestPosLandmarkDatabase::~CTestPosLandmarkDatabase()

	{

	Cancel();

	}

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

// CTestPosLandmarkDatabase::OpenDefaultDatabase

// 

// 

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

//

TInt CTestPosLandmarkDatabase::OpenDefaultDatabaseL( CStifItemParser& /*aItem*/ )

	{

	// Open default database

	CPosLandmarkDatabase* lmkDatabase = CPosLandmarkDatabase::OpenL();

	delete lmkDatabase;

	ReleaseLandmarkResources();

	return KErrNone;

	}

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

// CTestPosLandmarkDatabase::OpenDatabase

// 

// 

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

//

TInt CTestPosLandmarkDatabase::OpenDatabaseL( CStifItemParser& aItem )

	{

	TPtrC uriPtr;

	TInt err = aItem.GetNextString( uriPtr );	

	// Open database

	CPosLandmarkDatabase* lmkDatabase = CPosLandmarkDatabase::OpenL( KDBUri );

	delete lmkDatabase;

	ReleaseLandmarkResources();

	return KErrNone;

	}

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

// CTestPosLandmarkDatabase::IsInitializingNeeded

// 

// 

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

//

TInt CTestPosLandmarkDatabase::IsInitializingNeededL( CStifItemParser& /*aItem*/ )

	{	

	// Open default database

	CPosLandmarkDatabase* lmkDatabase = CPosLandmarkDatabase::OpenL(KDBUri);

	CleanupStack::PushL( lmkDatabase );	

	// Check if init required

	TBool result = lmkDatabase->IsInitializingNeeded();

	if( result )

		{

		// Initializing needed

		iLog->Log(_L("IsInitializingNeeded successful, initialization needed"));

		CleanupStack::PopAndDestroy( lmkDatabase );

		ReleaseLandmarkResources();

		return KErrNone;

		}

	else

		{

		// Initializing not needed

		iLog->Log(_L("IsInitializingNeeded successful, initialization not needed"));

		CleanupStack::PopAndDestroy( lmkDatabase );

		ReleaseLandmarkResources();

		return KErrNone;

		}		

	}

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

// CTestPosLandmarkDatabase::Initialize

// 

// 

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

//

TInt CTestPosLandmarkDatabase::InitializeL( CStifItemParser& /*aItem*/ )

	{

	// Open default database

	CPosLandmarkDatabase* lmkDatabase = CPosLandmarkDatabase::OpenL(KDBUri);

	CleanupStack::PushL( lmkDatabase );	

	// Init

	CPosLmOperation* initOperation = lmkDatabase->InitializeL();

	CleanupStack::PushL( initOperation );

	// Perform initialization

	initOperation->ExecuteL();

	iLog->Log(_L("Initialize successful"));

	CleanupStack::PopAndDestroy( 2, lmkDatabase );

	ReleaseLandmarkResources();

	return KErrNone;

	}

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

// CTestPosLandmarkDatabase::GetDatabaseUri

// 

// 

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

//

TInt CTestPosLandmarkDatabase::GetDatabaseUriL( CStifItemParser& /*aItem*/ )

	{

	// Open default database

	CPosLandmarkDatabase* lmkDatabase = CPosLandmarkDatabase::OpenL( KDBUri );

	CleanupStack::PushL( lmkDatabase );	

	// Init

	ExecuteAndDeleteLD( lmkDatabase->InitializeL() );

	// Get URI

	HBufC* uri = lmkDatabase->DatabaseUriLC(); 

	// Print URI

	iLog->Log(uri->Des());

	iLog->Log(_L("GetDatabaseUri successful"));

	CleanupStack::PopAndDestroy( 2, lmkDatabase );

	ReleaseLandmarkResources();

	return KErrNone;

	}

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

// CTestPosLandmarkDatabase::GetDatabaseSize

// 

// 

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

//

TInt CTestPosLandmarkDatabase::GetDatabaseSizeL( CStifItemParser& /*aItem*/ )

	{	

	// Open default database

	CPosLandmarkDatabase* lmkDatabase = CPosLandmarkDatabase::OpenL( KDBUri );

	CleanupStack::PushL( lmkDatabase );	

	// Init

	ExecuteAndDeleteLD( lmkDatabase->InitializeL() );

	// Get Size

	CPosLandmarkDatabase::TSize size;

	size = lmkDatabase->SizeL();

	// Print size

	_LIT( KSize, "Size = " );

	TBuf<25> sizebuf(KSize);

	sizebuf.AppendNum(size.iFileSize);

	iLog->Log(sizebuf);	

	// Size retrieved	

	iLog->Log(_L("GetDatabaseSize successful"));

	CleanupStack::PopAndDestroy( lmkDatabase );

	ReleaseLandmarkResources();

	return KErrNone;

	}

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

// CTestPosLandmarkDatabase::LandmarkIterator

// 

// 

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

//

TInt CTestPosLandmarkDatabase::LandmarkIteratorL( CStifItemParser& /*aItem*/ )

	{

	// Open default database

	CPosLandmarkDatabase* lmkDatabase = CPosLandmarkDatabase::OpenL( KDBUri );

	CleanupStack::PushL( lmkDatabase );	

	// Init

	ExecuteAndDeleteLD( lmkDatabase->InitializeL() );

	// Get Landmark Iterator

	CPosLmItemIterator* iterator = lmkDatabase->LandmarkIteratorL();

	CleanupStack::PushL( iterator );	

	// print number of lmks

	TInt numOfLmks = iterator->NumOfItemsL();

	_LIT( KTotal, "Total = " );

	TBuf<20> buffer;

	buffer.Copy(KTotal);

	buffer.AppendNum(numOfLmks);

	iLog->Log(buffer);

	iLog->Log(_L("LandmarkIterator successful"));

	CleanupStack::PopAndDestroy( 2, lmkDatabase );

	ReleaseLandmarkResources();

	return KErrNone;	

	}

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

// CTestPosLandmarkDatabase::LmkIteratorSortPref

// 

// 

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

//

TInt CTestPosLandmarkDatabase::LmkIteratorSortPrefL( CStifItemParser& /*aItem*/ )

	{

	// Open default database

	CPosLandmarkDatabase* lmkDatabase = CPosLandmarkDatabase::OpenL( KDBUri );

	CleanupStack::PushL( lmkDatabase );	

	// Init

	ExecuteAndDeleteLD( lmkDatabase->InitializeL() );

	// Create sort preference

	TPosLmSortPref sortPref( CPosLandmark::ELandmarkName );

	// Get Landmark Iterator with sort preference

	CPosLmItemIterator* iterator = lmkDatabase->LandmarkIteratorL( sortPref );

	CleanupStack::PushL( iterator );

	// LandmarkIterator successful

	iLog->Log(_L("LmkIteratorSortPref successful"));

	CleanupStack::PopAndDestroy( 2, lmkDatabase );

	ReleaseLandmarkResources();

	return KErrNone;	

	}	

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

// CTestPosLandmarkDatabase::ReadLandmark

// 

// 

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

//

TInt CTestPosLandmarkDatabase::ReadLandmarkL( CStifItemParser& /*aItem*/ )

	{

	// Open default database

	CPosLandmarkDatabase* lmkDatabase = CPosLandmarkDatabase::OpenL( KDBUri );

	CleanupStack::PushL( lmkDatabase );	

	// Init

	ExecuteAndDeleteLD( lmkDatabase->InitializeL() );

	// Get Landmark Iterator

	CPosLmItemIterator* iterator = lmkDatabase->LandmarkIteratorL();

	CleanupStack::PushL( iterator );	

	// Call NextL to get id of next landmark in database

	TPosLmItemId id = iterator->NextL();

	if( KPosLmNullItemId == id )

		{

		iLog->Log(_L("ReadLandmark fails, no landmark in database"));

		User::Leave( KErrGeneral );

		}

	// Read landmark

	CPosLandmark* landmark = lmkDatabase->ReadLandmarkLC( id );

	// ReadLandmark successful

	iLog->Log(_L("ReadLandmark successful"));

	CleanupStack::PopAndDestroy( 3, lmkDatabase );

	ReleaseLandmarkResources();

	return KErrNone;	

	}	

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

// CTestPosLandmarkDatabase::AddAndRemoveLandmark

// 

// 

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

//

TInt CTestPosLandmarkDatabase::AddAndRemoveLandmarkL( CStifItemParser& aItem )

	{

	TPtrC lmkNamePtr;

	TInt err = aItem.GetNextString( lmkNamePtr );	

	// Open default database

	CPosLandmarkDatabase* lmkDatabase = CPosLandmarkDatabase::OpenL( KDBUri );

	CleanupStack::PushL( lmkDatabase );	

	// Init

	ExecuteAndDeleteLD( lmkDatabase->InitializeL() );

	// Create a new landmark

	CPosLandmark* landmark = CPosLandmark::NewL();

	CleanupStack::PushL( landmark );	

	// Set name

	landmark->SetLandmarkNameL( lmkNamePtr );

	// Add to database

	TPosLmItemId lmkId = lmkDatabase->AddLandmarkL( *landmark );

	// Check if added

	lmkId = landmark->LandmarkId(); // Should return valid id of landmark

	if( KPosLmNullItemId == lmkId )

		{

		iLog->Log(_L("Error in adding landmark to database, AddAndRemoveLandmark failed"));

		User::Leave( KErrGeneral );

		}

	// Remove from database

	lmkDatabase->RemoveLandmarkL( lmkId );

	// Success

	iLog->Log(_L("AddAndRemoveLandmark successful"));

	CleanupStack::PopAndDestroy( 2, lmkDatabase );

	ReleaseLandmarkResources();

	return KErrNone;

	}

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

// CTestPosLandmarkDatabase::UpdateLandmark

// 

// 

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

//

TInt CTestPosLandmarkDatabase::UpdateLandmarkL( CStifItemParser& aItem )

	{

	TPtrC lmkNamePtr;

	TInt err = aItem.GetNextString( lmkNamePtr );

	// Open default database

	CPosLandmarkDatabase* lmkDatabase = CPosLandmarkDatabase::OpenL( KDBUri );

	CleanupStack::PushL( lmkDatabase );	

	// Init

	ExecuteAndDeleteLD( lmkDatabase->InitializeL() );

	// Read a landmark

	// Get a valid id

	CPosLmItemIterator* iter = lmkDatabase->LandmarkIteratorL();

	CleanupStack::PushL( iter );

	TPosLmItemId id = iter->NextL();

	if( KPosLmNullItemId == id )

		{

		iLog->Log(_L("No landmark found in database"));	

		User::Leave( KErrNotFound );

		}

	CPosLandmark* landmark = lmkDatabase->ReadLandmarkLC( id );

	// Save original name

	TPtrC originalName;

	landmark->GetLandmarkName( originalName );

	// Change name of landmark

	landmark->SetLandmarkNameL( lmkNamePtr );

	// Update landmark in DB

	lmkDatabase->UpdateLandmarkL( *landmark );

	// Reset the original name

	landmark->SetLandmarkNameL( originalName );

	// Update landmark in DB

	lmkDatabase->UpdateLandmarkL( *landmark );

	iLog->Log(_L("UpdateLandmark successful"));

	CleanupStack::PopAndDestroy( 3, lmkDatabase );

	ReleaseLandmarkResources();

	return KErrNone;

	}

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

// CTestPosLandmarkDatabase::RemoveLandmarks

// 

// 

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

//

TInt CTestPosLandmarkDatabase::RemoveLandmarksL( CStifItemParser& /*aItem*/ )

	{

	// Open Database

	CPosLandmarkDatabase* lmkDatabase = CPosLandmarkDatabase::OpenL( KDBUri );

	CleanupStack::PushL( lmkDatabase );

	// Initialize database

	ExecuteAndDeleteLD( lmkDatabase->InitializeL() );

	// Add 3 test landmarks, which will be removed by RemoveLandmarksL()

	TPosLmItemId id;

	RArray<TPosLmItemId> idArray;

	CPosLandmark* landmark = CPosLandmark::NewL();

	CleanupStack::PushL( landmark );

	_LIT( KName, "A Test Landmark " );

	TBuf<25> nameBuffer;

	for(TInt i=1;i<4;i++)

		{

		nameBuffer.Copy( KName );

		nameBuffer.AppendNum( i );

		landmark->SetLandmarkNameL( nameBuffer );

		id = lmkDatabase->AddLandmarkL( *landmark );

		idArray.AppendL( id );

		}

	// Create iterator and get number of landmarks	

	CPosLmItemIterator* iterator = lmkDatabase->LandmarkIteratorL();

	CleanupStack::PushL( iterator );

	TInt totalLmkBeforeRemove = iterator->NumOfItemsL();

	nameBuffer.Copy( KName );

		nameBuffer.AppendNum( totalLmkBeforeRemove );

	iLog->Log(nameBuffer);	

	CleanupStack::PopAndDestroy( iterator );

	// Remove landmarks (3 landmarks)

	ExecuteAndDeleteLD( lmkDatabase->RemoveLandmarksL( idArray ) );

	// Get 	number of landmarks	after remove

	iterator = lmkDatabase->LandmarkIteratorL();

	CleanupStack::PushL( iterator );

	TInt totalLmkAfterRemove = iterator->NumOfItemsL();

	nameBuffer.Copy( KName );

		nameBuffer.AppendNum( totalLmkAfterRemove );

	iLog->Log(nameBuffer);

	// Check

	if( totalLmkAfterRemove != (totalLmkBeforeRemove - 3) )

		{

		iLog->Log(_L("RemoveLandmarks fails"));

		User::Leave( KErrGeneral );

		}

	iLog->Log(_L("RemoveLandmarks succeeds"));

	CleanupStack::PopAndDestroy( 3, lmkDatabase );

	ReleaseLandmarkResources();			

	return KErrNone;	

	}

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

// CTestPosLandmarkDatabase::RemoveAllLandmarks

// 

// 

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

//

TInt CTestPosLandmarkDatabase::RemoveAllLandmarksL( CStifItemParser& /*aItem*/ )

	{

	// Open database

	CPosLandmarkDatabase* lmkDatabase = CPosLandmarkDatabase::OpenL( KDBUri );

	CleanupStack::PushL( lmkDatabase );

	// Initialize database

	ExecuteAndDeleteLD( lmkDatabase->InitializeL() );

	// Save 

	// Remova All landmarks from database

	ExecuteAndDeleteLD( lmkDatabase->RemoveAllLandmarksL() );

	// Restore

	iLog->Log(_L("RemoveAllLandmarks successful"));

	CleanupStack::PopAndDestroy( lmkDatabase );

	ReleaseLandmarkResources();		

	return KErrNone;	

	}

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

// CTestPosLandmarkDatabase::Compact

// 

// 

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

//

TInt CTestPosLandmarkDatabase::CompactL( CStifItemParser& /*aItem*/ )

	{

	// Open database

	CPosLandmarkDatabase* lmkDatabase = CPosLandmarkDatabase::OpenL( KDBUri );

	CleanupStack::PushL( lmkDatabase );

	// Initialize database

	ExecuteAndDeleteLD( lmkDatabase->InitializeL() );

	// Compact DB

	CPosLmOperation* operation = lmkDatabase->CompactL();

	CleanupStack::PushL( operation );

	operation->ExecuteL();

	iLog->Log(_L("Compact successful"));

	CleanupStack::PopAndDestroy( 2, lmkDatabase );

	ReleaseLandmarkResources();	

	return KErrNone;	

	}

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

// CTestPosLandmarkDatabase::SetAndGetPartialReadParams

// 

// 

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

//

TInt CTestPosLandmarkDatabase::SetAndGetPartialReadParamsL( CStifItemParser& /*aItem*/ )

	{

	// Open and initialize DB

	CPosLandmarkDatabase* lmkDatabase = CPosLandmarkDatabase::OpenL( KDBUri );

	CleanupStack::PushL( lmkDatabase );

	// Initialize database

	ExecuteAndDeleteLD( lmkDatabase->InitializeL() );

	// Partial read params

	CPosLmPartialReadParameters* setReadParams = CPosLmPartialReadParameters::NewLC();

	// Set 2 attributes, position and coverage radius

	setReadParams->SetRequestedAttributes( CPosLandmark::EPosition | CPosLandmark::ECoverageRadius );

	// Set partial read params

	lmkDatabase->SetPartialReadParametersL( *setReadParams );

	// Read a landmark, and check for name, name should not be found

	CPosLmItemIterator* iterator = lmkDatabase->LandmarkIteratorL();

	CleanupStack::PushL( iterator );

	TPosLmItemId id = iterator->NextL();

	CPosLandmark* landmark = lmkDatabase->ReadPartialLandmarkLC( id );

	TInt error = KErrNone;

	TPtrC namePtr;

	// Check for name, should return KErrNotFound

	error = landmark->GetLandmarkName( namePtr );