/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* which accompanies this distribution, and is available

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*   ?description_line

*

*/

//  INCLUDES

#include "FT_CPosTp118.h"

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLmDatabaseManager.h>

#include <d32dbms.h>

#include "FT_DatabaseUtility.h"

//  CONSTANTS

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

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

// CPosTp118::CloseTest

//

// (other items were commented in a header).

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

//

void CPosTp118::CloseTest()

    {

	iLog->Log(_L("CloseTest"));

    TRAPD(err, RemoveAllLmDatabasesL());

    if (err != KErrNone) iLog->Log(_L("RemoveAllLmDatabasesL() leaved"));

    TRAP(err, DeleteTp118FilesL());

    if (err != KErrNone) iLog->Log(_L("DeleteTp118FilesL() leaved"));

    delete iDatabases;

    iDatabases=NULL;

    }

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

// CPosTp118::StartL

//

// (other items were commented in a header).

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

//

void CPosTp118::StartL()

    {

    TInt err = KErrNone;

    // Remove all databases

    RemoveAllLmDatabasesL();

    DeleteTp118FilesL();

    TBuf<100> buf;

    CPosLandmarkDatabase* lmd = NULL;

    iLog->Log(_L("1) Create a valid landmark db"));

    // 1) Create a valid landmark db, it should be listed

	FTDatabaseUtility::CreateDatabaseL(_L("c:TP118.ldb"));

	// 2) List an verify that db created in step 1 is listed

	iLog->Log(_L("2) Verify that db created in step1 is listed:"));

	CPosLmDatabaseManager* dbManager = CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbManager);

	iDatabases = dbManager->ListDatabasesLC();

	CleanupStack::Pop(iDatabases);

	TInt res = VerifyList(iDatabases, _L("file://C:TP118.ldb"));

	AssertTrueSecL(res, _L("file://C:TP118.LDB was not found"));

	CleanupStack::PopAndDestroy(dbManager);

	// 3) Create a valid landmark db, but without correct file extension

	iLog->Log(_L("3) Create a valid landmark db, but without correct file extension"));

	FTDatabaseUtility::CreateDatabaseL(_L("c:TP118_NoExtension"), EFalse);

	dbManager = CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbManager);

	// 4) List all databases and verify that db created in step 3 is not listed

	iLog->Log(_L("List all databases and verify that db created in step 3 is not listed"));

	delete iDatabases; iDatabases=NULL;

	iDatabases = dbManager->ListDatabasesLC();

	CleanupStack::Pop(iDatabases);

	res = VerifyList(iDatabases, _L("file://c:TP118_NoExtension"));

	AssertTrueSecL(!res, _L("file://c:TP118_NoExtension should not have been found"));

	CleanupStack::PopAndDestroy(dbManager);

	// 5) Create lm db without correct secure id

	iLog->Log(_L("5) Create lm db without correct secure id"));

	FTDatabaseUtility::CreateDatabaseL(_L("c:TP118_WrongId.ldb"), ETrue, ETrue);

	dbManager = CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbManager);

    // 6) List all databases and verify that db created in step 5 is not listed

    iLog->Log(_L("6) List all databases and verify that db created in step 5 is not listed"));

    delete iDatabases; iDatabases=NULL;

	iDatabases = dbManager->ListDatabasesLC();

	CleanupStack::Pop(iDatabases);

	res = VerifyList(iDatabases, _L("c:TP118_WrongId.ldb"));

	AssertTrueSecL(!res, _L("file://c:TP118_WrongId.ldb should not have been found"));

	CleanupStack::PopAndDestroy(dbManager);

	// 7 Create lm db with invalid landmarks tables

	iLog->Log(_L("7) Create lm db with invalid landmarks tables"));

	FTDatabaseUtility::CreateDatabaseL(_L("C:TP118_INVALIDTABLES.ldb"), ETrue, EFalse, ETrue);

	dbManager = CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbManager);

    // 8) List all databases and verify that db created in step 7 is listed

    iLog->Log(_L("8) List all databases and verify that db created in step 7 is listed"));

    delete iDatabases; iDatabases=NULL;

	iDatabases = dbManager->ListDatabasesLC();

	CleanupStack::Pop(iDatabases);

	res = VerifyList(iDatabases, _L("file://C:TP118_INVALIDTABLES.ldb"));

	AssertTrueSecL(res, _L("file://C:TP118_INVALIDTABLES.ldb should have been found"));

	CleanupStack::PopAndDestroy(dbManager);

	// CleanupStack::PopAndDestroy(dbManager);

	// This causes DBMS to panic UTFW (this TestProgram)

	// Adds landmarks but needed tables are already removed

	// CreateLandmarksInDbL(_L("C:TP118_INVALIDTABLES.LDB"));

	/*

	/////////////////////////////////////////////

	// Add extra test here, set this db to default

	iLog->Log(_L("SetDefaultDatabaseL"));

    dbManager->SetDefaultDatabaseL(_L("C:TP118_INVALIDTABLES.LDB"));

	CleanupStack::PopAndDestroy(dbManager);

    //  Try to open defaultdb which is the db created in step18

    // Check that the default db is re-created when it is corrupt

    CPosLandmarkDatabase* lmdb = NULL;

    TRAP(err, lmdb = CPosLandmarkDatabase::OpenL());

    if (err == KErrNone)

    	{

    	CleanupStack::PushL(lmdb);

        CheckLandmarkDbL(lmdb);

        CleanupStack::PopAndDestroy(lmdb);

        //This causes DBMS to panic UTFW (this TestProgram)

	    // Adds landmarks but needed tables are already removed

        CreateLandmarksInDbL(_L("C:TP118_INVALIDTABLES.LDB"));

    	}

    else

    	{

    	LogErrorAndLeave(_L("OpenL should not leave with err"), err);

    	}

    */

	/////////////////////////////////////////////

	// 9) Try to open db created in step7

	iLog->Log(_L("9) Open db created in step 7"));

	lmd = CPosLandmarkDatabase::OpenL(_L("file://C:TP118_INVALIDTABLES.ldb"));

	CleanupStack::PushL(lmd);

	CheckLandmarkDbL(lmd);

	CleanupStack::PopAndDestroy(lmd);

    // 10) Drop table in db

    iLog->Log(_L("10) Create db and then drop tables in db"));

    dbManager=CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbManager);

    _LIT(KDropTableLmDb, "C:TP118_DROPTABLELMDB.ldb");

    HPosLmDatabaseInfo* dbInfo = HPosLmDatabaseInfo::NewLC(KDropTableLmDb);

    dbManager->CreateDatabaseL(*dbInfo);

    CleanupStack::PopAndDestroy(dbInfo);

    CreateLandmarksInDbL(KDropTableLmDb);

    DropTableL(KDropTableLmDb, KPosLmLandmarkTable);

    delete iDatabases; iDatabases=NULL;

    iDatabases = dbManager->ListDatabasesLC();

    CleanupStack::Pop(iDatabases);

    res = VerifyList(iDatabases, _L("file://C:TP118_DROPTABLELMDB.ldb"));

    AssertTrueSecL(res, _L("C:TP118_DropTableLmDb.ldb was not found"));

    CleanupStack::PopAndDestroy(dbManager);

    // 11) Try to open db created in step10

	iLog->Log(_L("11) Open db created in step 10"));

	lmd = CPosLandmarkDatabase::OpenL(_L("file://C:TP118_DROPTABLELMDB.ldb"));

	// Error when opening db

	CleanupStack::PushL(lmd);

	TRAP(err, CheckLandmarkDbL(lmd));

	AssertTrueSecL(err == KErrNotFound, _L("11) CheckLandmarkDbL did not leave with KErrNotFound"));

	CleanupStack::PopAndDestroy(lmd);

	// Try to add landmarks to this db

	// Leaves with KErrNotFound

	//CreateLandmarksInDbL(_L("C:TP118_DROPTABLELMDB.LDB"),1);

    // 12) DropIndexL

    iLog->Log(_L("Step12: DropIndexL"));

    dbManager=CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbManager);

    _LIT(KTP118_DROPINDEXLMDB_LDB, "C:TP118_DROPINDEXLMDB.ldb");

    HPosLmDatabaseInfo* dbInfoDrop = HPosLmDatabaseInfo::NewLC(KTP118_DROPINDEXLMDB_LDB);

    dbManager->CreateDatabaseL(*dbInfoDrop);

    CleanupStack::PopAndDestroy(dbInfoDrop);

    CreateLandmarksInDbL(_L("C:TP118_DROPINDEXLMDB.ldb"));

    iLog->Log(_L("12) DropIndex"));

    DropIndexL(_L("C:TP118_DROPINDEXLMDB.LDB"), KPosLmCategoryTable, KPosLmGlobalCategoryIdIndex);   

    CleanupStack::PopAndDestroy(dbManager);

    // 13) Try to open db created in step12

	iLog->Log(_L("13) Open db created in step 12"));

	lmd = CPosLandmarkDatabase::OpenL(_L("C:TP118_DROPINDEXLMDB.ldb"));

    CleanupStack::PushL(lmd);

	CheckLandmarkDbL(lmd);

	CleanupStack::PopAndDestroy(lmd);

    // Try to add landmarks to this db

	CreateLandmarksInDbL(_L("C:TP118_DROPINDEXLMDB.LDB"), 1);

	// 14)

    iLog->Log(_L("14) DropIndex"));

    dbManager=CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbManager);

    _LIT(KTP118_DROPINDEXLMDB2_LDB, "C:TP118_DROPINDEXLMDB2.ldb");

    HPosLmDatabaseInfo* dbInfoDrop2 = HPosLmDatabaseInfo::NewLC(KTP118_DROPINDEXLMDB2_LDB);

    dbManager->CreateDatabaseL(*dbInfoDrop2);

    CleanupStack::PopAndDestroy(dbInfoDrop2);

    CreateLandmarksInDbL(_L("C:TP118_DROPINDEXLMDB2.ldb"));

    DropIndexL(_L("C:TP118_DROPINDEXLMDB2.LDB"), KPosLmLandmarkTable, KPosLmLandmarkIdIndex);

    CleanupStack::PopAndDestroy(dbManager);

    // 15) Try to open db created in step13

	iLog->Log(_L("15) Open db created in step 14"));

	lmd = CPosLandmarkDatabase::OpenL(_L("C:TP118_DROPINDEXLMDB2.ldb"));

    CleanupStack::PushL(lmd);

	CheckLandmarkDbL(lmd);

	CleanupStack::PopAndDestroy(lmd);

	// Try to add landmarks to this db

	CreateLandmarksInDbL(_L("C:TP118_DROPINDEXLMDB2.ldb"), 1);

	////////////

    // 16) Create an ordinary database with some landmarks and then remove some parts of the binary file

    // Create db by manually removing some parts with notepad

    /*

    //Use this part to create db "TP118HalfLmDb.ldb" containing some landmarks, then use notepad to remove

    // some parts from physical file 

    dbManager=CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbManager);

    dbManager->CreateDatabaseL(_L("TP118HalfLmDb.ldb"));

    CreateLandmarksInDbL(_L("TP118HalfLmDb.ldb"));

    CleanupStack::PopAndDestroy(dbManager);

    */

    // Use corrupted file

    iLog->Log(_L("16) Use corrupted file"));

    CopyTestDbFileL(_L("TP118HALFLMDB_2.ldb"));

    dbManager = CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbManager);

    delete iDatabases; iDatabases = NULL;

    iDatabases = dbManager->ListDatabasesLC();

    CleanupStack::Pop(iDatabases);

    res = VerifyList(iDatabases, _L("file://C:TP118HALFLMDB_2.ldb"));

	AssertTrueSecL(res, _L("file://C:TP118HALFLMDB_2.LDB should have been found"));

    CleanupStack::PopAndDestroy(dbManager);

    // 17) Try to open db created in step16m it should not be possible

    // Before it returned KErrCorrupt(?) but now with Mars wk21 SDK it returns KErrNotSupported

    CPosLandmarkDatabase* someLmDb = NULL;

    TRAP(err, someLmDb = CPosLandmarkDatabase::OpenL(_L("TP118HalfLmDb_2.ldb")));

    if (err == KErrNone)

    	{

    	CleanupStack::PushL(someLmDb);

    	ExecuteAndDeleteLD(someLmDb->InitializeL());

    	CleanupStack::PopAndDestroy(someLmDb);

        AssertTrueSecL(EFalse,_L("OpenL should leave with error"));

    	}

    else

        {

        buf.Format(_L("OpenL leaved with %d"), err);

        iLog->Log(buf);

        }

    // 18) Use same file as in 16 and set this file to default db

    iLog->Log(_L("Use same file as in 16 and set this file to default db"));

    CopyTestDbFileL(_L("TP118HALFLMDB_2.LDB"));

    dbManager = CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbManager);

    iLog->Log(_L("SetDefaultDatabaseL"));

    dbManager->SetDefaultDatabaseUriL(_L("Tp118HALFLMDB_2.ldb"));

	CleanupStack::PopAndDestroy(dbManager);

    // 19) Try to open defaultdb which is the db created in step18

    // Before Mars wk21 SDK the default db is re-created when it is corrupt

    // but now instead KErrNotSUpported is returned

    iLog->Log(_L("Try to open defaultdb which is the db created in step18"));

    TRAP(err, someLmDb = CPosLandmarkDatabase::OpenL());

    if (err == KErrNone)

    	{

    	CleanupStack::PushL(someLmDb);

        CheckLandmarkDbL(someLmDb);

        CleanupStack::PopAndDestroy(someLmDb);

        // Try to add landmarks to this db

	    CreateLandmarksInDbL(_L("Tp118HALFLMDB_2.ldb"));

    	}

    else

    	{

    	//LogErrorAndLeave(_L("OpenL should not leave with err"), err);

    	buf.Format(_L("open defaultdb leaved with %d"), err);

    	iLog->Log(buf);

    	}

	}

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

// CPosTp118::CheckLandmarkDbL

//

// (other items were commented in a header).

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

//

void CPosTp118::CheckLandmarkDbL(CPosLandmarkDatabase* aDb)

    {

    iLog->Log(_L("CheckLandmarkDbL"));

    if (aDb->IsInitializingNeeded()) ExecuteAndDeleteLD(aDb->InitializeL());

    CPosLmItemIterator* iter = aDb->LandmarkIteratorL();

    CleanupStack::PushL(iter);

    TInt size = iter->NumOfItemsL();

    TBuf<100> buf;

    buf.Format(_L("DB contains %d nr of landmarks"), size);

    iLog->Log(buf);

    TPosLmItemId id = iter->NextL();

    while (id != KPosLmNullItemId)

        {

        CPosLandmark* lm = aDb->ReadLandmarkLC(id);

        TPtrC name;

        lm->GetLandmarkName(name);

        // Debugging iLog->Log(name);

        id = iter->NextL();

        CleanupStack::PopAndDestroy(lm);

        }

    // Try to get an non existing landmark

    CPosLandmark* lm = NULL;

    TRAPD(err, lm = aDb->ReadLandmarkLC(123456));

    if (err != KErrNotFound) 

        {

        CleanupStack::PopAndDestroy(lm);

        CleanupStack::PopAndDestroy(iter);

        AssertTrueSecL(EFalse,_L("ReadLandmarkLC should leave with KErrNotFound"));

        }

    CleanupStack::PopAndDestroy(iter);

    // Check categories

    CPosLmCategoryManager* categoryManager = CPosLmCategoryManager::NewL(*aDb);

    CleanupStack::PushL(categoryManager);

	CPosLmItemIterator* catIter = categoryManager->CategoryIteratorL();

	CleanupStack::PushL(catIter);

	TInt catCount = catIter->NumOfItemsL();

	buf.Format(_L("Found %d nr of categories items in db"), catCount);

	iLog->Log(buf);

	id = catIter->NextL();

	while (id != KPosLmNullItemId)

    	{

    	CPosLandmarkCategory* cat = categoryManager->ReadCategoryLC(id);

    	TPtrC name;

    	cat->GetCategoryName(name);

    	// Debugging iLog->Log(name);

    	CleanupStack::PopAndDestroy(cat);

    	id = catIter->NextL();

    	}

    CleanupStack::PopAndDestroy(catIter);

    CleanupStack::PopAndDestroy(categoryManager);

    }

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

// CPosTp118::DeleteTp118FilesL

//

// (other items were commented in a header).

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

//

void CPosTp118::DeleteTp118FilesL()

	{

	iLog->Log(_L("DeleteTp118FilesL"));

    RFs fs;

    TInt err = fs.Connect();

    AssertTrueSecL(err == KErrNone, _L("fs.Connect returned with error"), err);

    CleanupClosePushL(fs);

    CFileMan* fileMan = CFileMan::NewL(fs);

    CleanupStack::PushL(fileMan);

    // delete all TP118 files

    err = fileMan->Delete(_L("c:\\private\\100012a5\\*TP118*.*"));

    AssertTrueSecL(err == KErrNone || err == KErrNotFound, _L("CFileMan could not delete files1"), err);

    err = fileMan->Delete(_L("c:\\private\\100012a5\\*TP118*"));

    AssertTrueSecL(err == KErrNone || err == KErrNotFound, _L("CFileMan could not delete files2"), err);

    CleanupStack::PopAndDestroy(1); //fileMan

    CleanupStack::PopAndDestroy(1); //fs

    iLog->Log(_L("DeleteTp118FilesL Done"));

	}

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

// CPosTp118::CreateLandmarksInDbL

//

// (other items were commented in a header).

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

//

void CPosTp118::CreateLandmarksInDbL(const TDesC& aDbName, TInt aIndex)

	{

	iLog->Log(_L("CreateLandmarksInDbL"));

	const TInt KNrOfLandmarks = 50;

	const TInt KNrOfCategories = 10;

	CPosLandmarkDatabase* lmd = CPosLandmarkDatabase::OpenL(aDbName);

	CleanupStack::PushL(lmd);

    ExecuteAndDeleteLD(lmd->InitializeL());

    CPosLmCategoryManager* cm = CPosLmCategoryManager::NewL(*lmd);

    CleanupStack::PushL(cm);

    RArray<TPosLmItemId> arr;

   	CleanupClosePushL(arr);

    TInt i=0;

    TBuf<150> buf;

    // Create categories

   	for (i=0; i<KNrOfCategories; i++)

   		{

    	CPosLandmarkCategory* category = CPosLandmarkCategory::NewLC();

    	buf.Zero();

    	buf.Format(_L("VeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongCategoryName%d_%d"), i, aIndex);

    	category->SetCategoryNameL(buf);

    	TPosLmItemId id=0;

    	TInt err = KErrLocked;

    	while (err == KErrLocked)

    	    {

    	    TRAP(err, id = cm->AddCategoryL(*category));

    	    }

    	arr.Append(id);

    	CleanupStack::PopAndDestroy(category);

   		}

	// Create landmarks and attach every category to every landmark

    for (i=0;i<KNrOfLandmarks;i++)

    	{

    	buf.Zero();

    	buf.Format(_L("VeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongLandmarkName%d_%d"), i, aIndex);

    	CPosLandmark* lm1 = CPosLandmark::NewLC();

    	lm1->SetLandmarkNameL(buf);

    	lm1->SetLandmarkDescriptionL(_L("SomeVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription"));

    	for (TInt j=0;j<arr.Count();j++)

    		{

    		lm1->AddCategoryL(arr[j]);

    		}

   		TInt err = KErrLocked;

   		while (err==KErrLocked)

   		    {

   		    TRAP(err, lmd->AddLandmarkL(*lm1));

   		    }

   		CleanupStack::PopAndDestroy(lm1);

   		}

    CleanupStack::PopAndDestroy(&arr);

    CleanupStack::PopAndDestroy(cm);

    ExecuteAndDeleteLD(lmd->CompactL());

    CleanupStack::PopAndDestroy(lmd);

	}

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

// CPosTp118::VerifyList

//

// (other items were commented in a header).

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

//

TBool CPosTp118::VerifyList(CDesCArray* aList, const TDesC& aDbName)

	{

	TBool found = EFalse;

	TInt count = aList->Count();

	TBuf<100> buf;

	buf.Format(_L("Found %d nr of dbs"), count);

	iLog->Log(buf);

	for (TInt i=0;i<count;i++)

		{

		iLog->Log((*aList)[i]);

		if ((*aList)[i].Compare(aDbName) == KErrNone)

			{

			found = ETrue;

			}

		}

		return found;

	}

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

// CPosTp118::DropTableL

//

// (other items were commented in a header).

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