/*

* 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_CPosTp104.h"

#include <EPos_CPosLandmarkDatabase.h>

#include "FT_LandmarkConstants.h"

#include <centralrepository.h>

// CONSTANTS

const TUint32 KLandmarkDefaultUri = 0x00000001;

const TUid KCRUidLandmarks = {0x101FE99B}; 

// _LIT(KSettingsFileInRom, "c:\\system\\data\\cenrep\\[101FE99B].txt");

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

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

// CPosTp104::StartL

//

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

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

//

void CPosTp104::StartL()

    {

    _LIT(KLmA, "LandmarkA");

    _LIT(KLmB, "LandmarkB");

    _LIT(KLmC, "LandmarkC");

    _LIT(KNonExistingDb, "nonexistingdb.ldb");

    _LIT(KLogAboutToSetDefaultDB, "About to set default landmark DB to a non existing DB.");

    _LIT(KLogAboutToDeleteAllDbs, "About to delete all landmark DBs");

    _LIT(KLogAboutToReadBackLmA, "About to read back landmark A");

    _LIT(KLogAboutToReadBackLmB, "About to read back landmark B");

    _LIT(KLogAboutToReadBackLmC, "About to read back landmark C");

    _LIT(KErrorNonExisting, "Was able to set an non-existing DB as default.");

    _LIT(KLandmarksDbB, "lmdb104b.ldb");

    _LIT(KLandmarksDbBFull, "file://c:lmdb104b.ldb");

    _LIT(KErrorWrongDefaultDB, "Unexpected default database");

    _LIT(KCopyOfDefaultDB, "lmdb104copy.ldb");

    _LIT(KFailedToDeleteDB, "Failed to delete default database");

    _LIT(KLogAboutToSetLmDbBAsDefault, "About to set landmarks DB B as default DB.");

    _LIT(KOriginalDb, "file://c:eposlm.ldb");

    #ifdef __WINS__

    _LIT(KRemovableMediaDB, "d:removabledb.ldb");

    #else

    _LIT(KRemovableMediaDB, "f:removabledb.ldb");

    #endif

    _LIT(KNr01, "01");

    _LIT(KNr02, "02");

    _LIT(KNr03, "03");

    _LIT(KNr04, "04");

    _LIT(KNr05, "05");

    _LIT(KNr06, "06");

    _LIT(KNr07, "07");

    _LIT(KNr08, "08");

    _LIT(KNr10, "10");

    _LIT(KNr11, "11");

    _LIT(KNr12, "12");

    _LIT(KNr13, "13");

    _LIT(KNr14, "14");

    _LIT(KNr15, "15");

    _LIT(KNr16, "16");

    _LIT(KNr17, "17");

    _LIT(KNr18, "18");

    _LIT(KNr19, "19");

    _LIT(KNr20, "20");

    _LIT(KNr21, "21");

    _LIT(KNr22, "22");

    _LIT(KNr23, "23");

    _LIT(KNr24, "24");

    _LIT(KNr25, "25");

    _LIT(KNr26, "26");

    iLog->Log(_L("Warning: this test case requires E: drive"));

    iRepository = CRepository::NewL(KCRUidLandmarks);   

    iDbMan = CPosLmDatabaseManager::NewL();

    RemoveAllLmDatabasesL();

    ArgumentTestsL();

    TInt err;

    TBuf16<NCentralRepositoryConstants::KMaxUnicodeStringLength> defaultUriRep;

    //NCentralRepositoryConstants::KMaxUnicodeStringLength

    User::LeaveIfError(iRepository->Get(KLandmarkDefaultUri, defaultUriRep));

    // 3

    iLog->Log(KNr03);

    // Open and initialize default db

    iLandmarksDb = CPosLandmarkDatabase::OpenL();

    ExecuteAndDeleteLD(iLandmarksDb->InitializeL());

    // Add landmark A to DB:

    CPosLandmark* lmA = CreateXMLLandmarkLC(KLmA);

    TPosLmItemId lmAId = iLandmarksDb->AddLandmarkL(*lmA);

    CleanupStack::PopAndDestroy(lmA);

    User::After(2000000);

    ExecuteAndDeleteLD(iLandmarksDb->CompactL());

    // User::After(2000000);

    // Check that it was actually added:

    iLog->Log(KLogAboutToReadBackLmA);

    lmA = iLandmarksDb->ReadLandmarkLC(lmAId);

    iLog->Log(KLogAboutToReadBackLmA);

    CleanupStack::PopAndDestroy(lmA);

    // 4

    iLog->Log(KNr04);

    // Test to set a non-existing db as default:

    iLog->Log(KLogAboutToSetDefaultDB);

    TRAP(err, iDbMan->SetDefaultDatabaseUriL(KNonExistingDb));

    if (err != KErrNotFound)

        {

        iLog->Log(KErrorNonExisting);

    	User::Leave(err);

        }

    // 5

    iLog->Log(KNr05);

    // Create a new db and add a landmark to it:

    delete iLandmarksDb;

    iLandmarksDb = NULL;

    HPosLmDatabaseInfo* dbInfoB = HPosLmDatabaseInfo::NewLC(KLandmarksDbB);

    iDbMan->CreateDatabaseL(*dbInfoB);

    CleanupStack::PopAndDestroy(dbInfoB);

    iLandmarksDb = CPosLandmarkDatabase::OpenL(KLandmarksDbB);

    ExecuteAndDeleteLD(iLandmarksDb->InitializeL());

    CPosLandmark* lmB = CreateXMLLandmarkLC(KLmB);

    TPosLmItemId lmBId = iLandmarksDb->AddLandmarkL(*lmB);

    User::After(2000000);

    CleanupStack::PopAndDestroy(lmB);

    ExecuteAndDeleteLD(iLandmarksDb->CompactL());

    // Read back the landmark:

    iLog->Log(KLogAboutToReadBackLmB);

    lmB = iLandmarksDb->ReadLandmarkLC(lmBId);

    CleanupStack::PopAndDestroy(lmB);

    delete iLandmarksDb;

    iLandmarksDb = NULL;

    // 6

    iLog->Log(KNr06);

    // Set the new DB as default, and check that it worked OK:

    iLog->Log(KLogAboutToSetLmDbBAsDefault);

    iDbMan->SetDefaultDatabaseUriL(KLandmarksDbB);

    HBufC* defaultURI = iDbMan->DefaultDatabaseUriLC();

    // 7

    iLog->Log(KNr07);

    if (defaultURI->Des().CompareF(KLandmarksDbBFull))

        {

        iLog->Log(KErrorWrongDefaultDB);

        User::Leave(-1);

        }

     CleanupStack::PopAndDestroy(defaultURI);

    // 8

    iLog->Log(KNr08);

    // Open the default DB and try to find the landmark that was added before:

    iLandmarksDb = CPosLandmarkDatabase::OpenL();

    if (iLandmarksDb->IsInitializingNeeded())

   {

   ExecuteAndDeleteLD(iLandmarksDb->InitializeL());

   }

    iLog->Log(KLogAboutToReadBackLmB);

    lmB = iLandmarksDb->ReadLandmarkLC(lmBId);

    CleanupStack::PopAndDestroy(lmB);

    delete iLandmarksDb;

    iLandmarksDb = NULL;

    // 9

    iLog->Log(KNr01);

    // Change the default db:

    iDbMan->SetDefaultDatabaseUriL(defaultUriRep);

    defaultURI = iDbMan->DefaultDatabaseUriLC();

    if (defaultURI->Des().CompareF(defaultUriRep))

        {

        iLog->Log(KErrorWrongDefaultDB);

        User::Leave(-1);

        }

    CleanupStack::PopAndDestroy(defaultURI);

    // 10

    iLog->Log(KNr10);

    // Open the default DB and check that it contains landmark A:

    iLandmarksDb = CPosLandmarkDatabase::OpenL();

    if (iLandmarksDb->IsInitializingNeeded())

   {

   ExecuteAndDeleteLD(iLandmarksDb->InitializeL());

   }

    iLog->Log(KLogAboutToReadBackLmA);

    lmA = iLandmarksDb->ReadLandmarkLC(lmAId);

    CleanupStack::PopAndDestroy(lmA);

    delete iLandmarksDb;

    iLandmarksDb = NULL;

    // ********************** Test Copy **********************

    // 11

    iLog->Log(KNr11);

    // Copy the default DB:

    iDbMan->CopyDatabaseL(defaultUriRep, KCopyOfDefaultDB);

    // 12

    iLog->Log(KNr12);

    // 13

    iLog->Log(KNr13);

    // Check which DB that is the default:

    defaultURI = iDbMan->DefaultDatabaseUriLC();

    if (defaultURI->Des().CompareF(defaultUriRep))

        {

        iLog->Log(KErrorWrongDefaultDB);

        User::Leave(-1);

        }

    CleanupStack::PopAndDestroy(defaultURI);

    // 14

    iLog->Log(KNr14);

    iDbMan->SetDefaultDatabaseUriL(KCopyOfDefaultDB);

    // Open the default DB and check that it contains landmark A:

    iLandmarksDb = CPosLandmarkDatabase::OpenL();

    if (iLandmarksDb->IsInitializingNeeded())

   {

   ExecuteAndDeleteLD(iLandmarksDb->InitializeL());

   }

    iLog->Log(KLogAboutToReadBackLmA);

    lmA = iLandmarksDb->ReadLandmarkLC(lmAId);

    CleanupStack::PopAndDestroy(lmA);

    // 15

    delete iLandmarksDb;

    iLandmarksDb = NULL;

    iLog->Log(KNr15);

    // Create a landmarks DB on the memory card:

    HPosLmDatabaseInfo* dbInfoRemMedia = HPosLmDatabaseInfo::NewLC(KRemovableMediaDB);

    iDbMan->CreateDatabaseL(*dbInfoRemMedia);

    CleanupStack::PopAndDestroy(dbInfoRemMedia);

    iLandmarksDb = CPosLandmarkDatabase::OpenL(KRemovableMediaDB);

    ExecuteAndDeleteLD(iLandmarksDb->InitializeL());

    // Add a landmark to it:

    CPosLandmark* lmC = CreateXMLLandmarkLC(KLmC);

    TPosLmItemId lmCId = iLandmarksDb->AddLandmarkL(*lmC);

    CleanupStack::PopAndDestroy(lmC);

    User::After(200000);

    ExecuteAndDeleteLD(iLandmarksDb->CompactL());

    delete iLandmarksDb;

    iLandmarksDb = NULL;

    // 16

    iLog->Log(KNr16);

    iDbMan->SetDefaultDatabaseUriL(KRemovableMediaDB);

    iLandmarksDb = CPosLandmarkDatabase::OpenL();

    if (iLandmarksDb->IsInitializingNeeded())

   {

   ExecuteAndDeleteLD(iLandmarksDb->InitializeL());

   }

    // Check that landmark C exists:

    iLog->Log(KLogAboutToReadBackLmC);

    lmC = iLandmarksDb->ReadLandmarkLC(lmCId);

    CleanupStack::PopAndDestroy(lmC);

    delete iLandmarksDb;

    iLandmarksDb = NULL;

    // URI Testing:

    _LIT(KTestDB104A, "file://c:TestDb104a.ldb");

    _LIT(KTestDB104B, "file://c:TestDb104b.ldb");

    #ifdef __WINS__

    _LIT(KTestDB104MMC, "file://d:TestDbMMC.ldb");

    #else

    _LIT(KTestDB104MMC, "file://f:TestDbMMC.ldb");

    #endif

    // Create some testdb:s

    HPosLmDatabaseInfo* dbInfo104A = HPosLmDatabaseInfo::NewLC(KTestDB104A);

    HPosLmDatabaseInfo* dbInfo104B = HPosLmDatabaseInfo::NewLC(KTestDB104B);

    HPosLmDatabaseInfo* dbInfo104MMC = HPosLmDatabaseInfo::NewLC(KTestDB104MMC);

    iDbMan->CreateDatabaseL(*dbInfo104A);

    iDbMan->CreateDatabaseL(*dbInfo104B);

    iDbMan->CreateDatabaseL(*dbInfo104MMC);

    CleanupStack::PopAndDestroy(dbInfo104MMC);

    CleanupStack::PopAndDestroy(dbInfo104B);

    CleanupStack::PopAndDestroy(dbInfo104A);

    _LIT(KNonsenseURI, "&t87%(s!,uy.poffd");

    _LIT(KNotEndingWithLdbURI, "file://c:TestDb104a");

    _LIT(KEmptyURI, "");

    _LIT(KLongerThanAllowedURI, "longdatabaseewjktgjfkdnbnbfjghskwuwrqtrccxbdhfbbjgnmglkytiyitiugjqoiwiejakxngjhdygrgdskhdhdbxvafarqtwyrjgjtihjkjbnbjyhkjltoyouiylhjrnbmdngfhurtwgewvetqwsahdgfey4756eyrg8328yrgfgggbbnnmnkjgjdhajaqiwuwueytriutiiiutuithjhgergfbfhgnbmbmnmklkrjsfadadeqwyteutiyibnvcbxvdafsdgdhey.ldb"); // more than 256 (KMaxUnicodeStringLength)

    _LIT(KCorrectURI, "file://c:TestDb104b.ldb");

    _LIT(KCorrectButWithoutDriveURI, "file://TestDb104a.LDB");

    _LIT(KOnMmcButWithoutDriveURI, "file://TestDb104c.ldb");

    _LIT(KRemoteURI, "http://www.landmarks.com/dbs/remote104.ldb");

    _LIT(KNoProtocolURI, "c:TestDb104b.ldb");

    // 17

    iLog->Log(KNr17);

    TestSetUriL(KNonsenseURI, KErrArgument);

    // 18

    iLog->Log(KNr18);

    TestSetUriL(KNotEndingWithLdbURI, KErrArgument);

    // 19

    iLog->Log(KNr19);

    TestSetUriL(KEmptyURI, KErrArgument);

    // 20

    iLog->Log(KNr20);

    TestSetUriL(KLongerThanAllowedURI, KErrArgument);

    // 21

    iLog->Log(KNr21);

    TestSetUriL(KCorrectURI, KErrNone);

    // 22

    iLog->Log(KNr22);

    TestSetUriL(KCorrectButWithoutDriveURI, KErrNone);

    // 23

    iLog->Log(KNr23);

    TestSetUriL(KOnMmcButWithoutDriveURI, KErrNotFound);

    // 24

    iLog->Log(KNr24);

    TestSetUriL(KRemoteURI, KErrNotSupported);

    // 25

    iLog->Log(KNr25);

    TestSetUriL(KNoProtocolURI, KErrNone);

    // 26

    iLog->Log(KNr26);

    TestSetUriL(KNoProtocolURI, KErrNone);

    delete iDbMan;

    iDbMan = NULL;

    delete iLandmarksDb;

    iLandmarksDb = NULL;

    delete iRepository;

    iRepository = NULL;

    }

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

// CPosTp104::TestSetUriL()

//

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

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

//    

void CPosTp104::TestSetUriL(const TDesC& aUriString, TInt aExpectedErrorCode)

    {

    TRAPD(err,iDbMan->SetDefaultDatabaseUriL(aUriString));

    if (err != aExpectedErrorCode)

        {

        _LIT(KErrorText, "Received wrong error code when setting URI. Expected %d, Received %d");

        TBuf<100> buf;

        buf.Format(KErrorText, aExpectedErrorCode, err);

       iLog->Log(buf);

        User::Leave(err);

        }

    }

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

// CPosTp104::ArgumentTests

//

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

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

//

void CPosTp104::ArgumentTestsL()

	{

	_LIT(KErrorWrongCode, "Didn't receive correct error code");

	_LIT(KMaxLengthString64,    "1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.ldb");

    _LIT(KMaxLengthString64Bad, "x1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.ldb");

    _LIT(KMaxLengthString66,    "c:2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.ldb");

    _LIT(KMaxLengthString66Bad, "c:x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.ldb");

    _LIT(KMaxLengthString71,    "file://3aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.ldb");

    _LIT(KMaxLengthString71Bad, "file://x3aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.ldb");

    _LIT(KMaxLengthString73,    "file://c:4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.ldb");

    _LIT(KMaxLengthString73Bad, "file://c:x4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.ldb");

    TInt err = 0;

        // Should work OK:

    HPosLmDatabaseInfo* dbInfo64 = HPosLmDatabaseInfo::NewLC(KMaxLengthString64);

    HPosLmDatabaseInfo* dbInfo64Bad = HPosLmDatabaseInfo::NewLC(KMaxLengthString64Bad);

    HPosLmDatabaseInfo* dbInfo66 = HPosLmDatabaseInfo::NewLC(KMaxLengthString66);

    HPosLmDatabaseInfo* dbInfo66Bad = HPosLmDatabaseInfo::NewLC(KMaxLengthString66Bad);

    HPosLmDatabaseInfo* dbInfo71 = HPosLmDatabaseInfo::NewLC(KMaxLengthString71);

    HPosLmDatabaseInfo* dbInfo71Bad = HPosLmDatabaseInfo::NewLC(KMaxLengthString71Bad);

    HPosLmDatabaseInfo* dbInfo73 = HPosLmDatabaseInfo::NewLC(KMaxLengthString73);

    HPosLmDatabaseInfo* dbInfo73Bad = HPosLmDatabaseInfo::NewLC(KMaxLengthString73Bad);

    iDbMan->CreateDatabaseL(*dbInfo64);

    iDbMan->CreateDatabaseL(*dbInfo66);

    iDbMan->CreateDatabaseL(*dbInfo71);

    iDbMan->CreateDatabaseL(*dbInfo73);

    TRAP(err, iDbMan->CreateDatabaseL(*dbInfo64Bad));

    AssertTrueSecL(err == KErrArgument, KErrorWrongCode);

    TRAP(err, iDbMan->CreateDatabaseL(*dbInfo66Bad));

    AssertTrueSecL(err == KErrArgument, KErrorWrongCode);

    TRAP(err, iDbMan->CreateDatabaseL(*dbInfo71Bad));

    AssertTrueSecL(err == KErrArgument, KErrorWrongCode);

    TRAP(err, iDbMan->CreateDatabaseL(*dbInfo73Bad));

    AssertTrueSecL(err == KErrArgument, KErrorWrongCode);

    CleanupStack::PopAndDestroy(dbInfo73Bad);

    CleanupStack::PopAndDestroy(dbInfo73);

    CleanupStack::PopAndDestroy(dbInfo71Bad);

    CleanupStack::PopAndDestroy(dbInfo71);

    CleanupStack::PopAndDestroy(dbInfo66Bad);

    CleanupStack::PopAndDestroy(dbInfo66);

    CleanupStack::PopAndDestroy(dbInfo64Bad);

    CleanupStack::PopAndDestroy(dbInfo64);

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

    // Should work OK:

    iDbMan->DatabaseExistsL(KMaxLengthString64);

    iDbMan->DatabaseExistsL(KMaxLengthString66);

    iDbMan->DatabaseExistsL(KMaxLengthString71);

    iDbMan->DatabaseExistsL(KMaxLengthString73);

    TRAP(err, iDbMan->DatabaseExistsL(KNullDesC));

    AssertTrueSecL(err == KErrArgument, KErrorWrongCode);

    TRAP(err, iDbMan->DatabaseExistsL(KMaxLengthString64Bad));

    AssertTrueSecL(err == KErrNone, KErrorWrongCode);

    TRAP(err, iDbMan->DatabaseExistsL(KMaxLengthString66Bad));

    AssertTrueSecL(err == KErrNone, KErrorWrongCode);

    TRAP(err, iDbMan->DatabaseExistsL(KMaxLengthString71Bad));

    AssertTrueSecL(err == KErrNone, KErrorWrongCode);

    TRAP(err, iDbMan->DatabaseExistsL(KMaxLengthString73Bad));

    AssertTrueSecL(err == KErrNone, KErrorWrongCode);

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

    // Should work OK:

    iDbMan->SetDefaultDatabaseUriL(KMaxLengthString64);

    iDbMan->SetDefaultDatabaseUriL(KMaxLengthString66);

    iDbMan->SetDefaultDatabaseUriL(KMaxLengthString71);

    iDbMan->SetDefaultDatabaseUriL(KMaxLengthString73);

    // Should not work:

    TRAP(err, iDbMan->SetDefaultDatabaseUriL(KNullDesC));

    AssertTrueSecL(err == KErrArgument, KErrorWrongCode);

    TRAP(err, iDbMan->SetDefaultDatabaseUriL(KMaxLengthString64Bad));

    AssertTrueSecL(err == KErrNotFound, KErrorWrongCode);

    TRAP(err, iDbMan->SetDefaultDatabaseUriL(KMaxLengthString66Bad));

    AssertTrueSecL(err == KErrNotFound, KErrorWrongCode);

    TRAP(err, iDbMan->SetDefaultDatabaseUriL(KMaxLengthString71Bad));

    AssertTrueSecL(err == KErrNotFound, KErrorWrongCode);

    TRAP(err, iDbMan->SetDefaultDatabaseUriL(KMaxLengthString73Bad));

    AssertTrueSecL(err == KErrNotFound, KErrorWrongCode);

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

    // Should work OK:

    iDbMan->DeleteDatabaseL(KMaxLengthString64);

    iDbMan->DeleteDatabaseL(KMaxLengthString66);

    iDbMan->DeleteDatabaseL(KMaxLengthString71);

    iDbMan->DeleteDatabaseL(KMaxLengthString73);

    // Should not work: 

    TRAP(err, iDbMan->DeleteDatabaseL(KMaxLengthString64Bad));

    AssertTrueSecL(err == KErrArgument, KErrorWrongCode);

    TRAP(err, iDbMan->DeleteDatabaseL(KMaxLengthString66Bad));

    AssertTrueSecL(err == KErrArgument, KErrorWrongCode);

    TRAP(err, iDbMan->DeleteDatabaseL(KMaxLengthString71Bad));

    AssertTrueSecL(err == KErrArgument, KErrorWrongCode);

    TRAP(err, iDbMan->DeleteDatabaseL(KMaxLengthString73Bad));

    AssertTrueSecL(err == KErrArgument, KErrorWrongCode);

	}

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

// CPosTp104::CloseTest

//

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

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

//

void CPosTp104::CloseTest()

	{

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

	delete iDbMan;

    iDbMan = NULL;

    delete iLandmarksDb;

    iLandmarksDb = NULL;

    delete iRepository;

    iRepository = NULL;

	}