/*

* Copyright (c) 2005 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: 

*   ?description_line

*

*/

//  INCLUDES

#include "FT_CPosTp10.h"

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLandmarkCategory.h>

#include <EPos_CPosLandmark.h>

#include <EPos_CPosLMOperation.h> 

#include <e32math.h> 

#include "FT_LandmarkConstants.h"

// CONSTANTS

const TInt KNoCategoriesTp10  = 100;

const TInt KNoLandmarksTp10 = 100;      

const TInt KAddStartIndex=5;

const TInt KAddEndIndex=20;

const TInt KAddCategoryIndex=8;

const TInt KAddStartIndexAsync=21;

const TInt KAddEndIndexAsync=82;

const TInt KAddCategoryIndexAsync=10;

const TInt KRemoveStartIndex=85;

const TInt KRemoveEndIndex=95;

const TInt KRemoveStartIndexAsync=75;

const TInt KRemoveEndIndexAsync=84;

const TInt KRemoveSetStartIndex=50;

const TInt KRemoveSetEndIndex=74;

const TInt KRemoveSetStartIndexAsync=0;

const TInt KRemoveSetEndIndexAsync=49;

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

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

// CPosTp10::StartL

//

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

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

//

void CPosTp10::StartL()

    {

    _LIT(KLogFileName, "c:\\documents\\TP10TimeMeasurements.txt");

    RemoveDefaultDbL();

    RemoveAllLmDatabasesL();

    // Test LMREQ121 below

    TestMissingCategories1L();

    RemoveDefaultDbL();

    RemoveAllLmDatabasesL();

    TestMissingCategories2L();

    RemoveDefaultDbL();

    RemoveAllLmDatabasesL();

    _LIT(KTestPath, "c:\\system\\test\\testdata\\");

    // copy the test db to the private path

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

    CleanupStack::PushL(fileMan);

    TBuf<150> srcPath;

    srcPath.Append(KTestPath);

    srcPath.Append(KTp10TestDb);

    TInt err = fileMan->Copy(srcPath, KLmTp10DefaultDbPath,

            CFileMan::EOverWrite);

    if (err != KErrNone)

        iLog->Log(_L("Error when copying file"));

    CleanupStack::PopAndDestroy(fileMan);

    CPosLmDatabaseManager* manager = CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(manager);

    // This db must exist

    manager->SetDefaultDatabaseUriL(KTp10TestDb);

    CleanupStack::PopAndDestroy(manager);

    iDatabase= CPosLandmarkDatabase::OpenL(KTp10TestDb);

    if (iDatabase->IsInitializingNeeded())

       {

       ExecuteAndDeleteLD(iDatabase->InitializeL()); // Synchronous since no argument

       }

    TTime start, stop, totalStart, totalStop;

    totalStart.UniversalTime();

	start.UniversalTime();

    iCategoryManager = CPosLmCategoryManager::NewL(*iDatabase); 

    stop.UniversalTime();

    TInt64 msec = (stop.Int64() - start.Int64());

	TBuf8<KMsgBufSize> msg;

	_LIT8(KTrace, "CPosLmCategoryManager::NewL = %d usec");

	msg.Format(KTrace, msec);

	LogToFileL(KLogFileName, msg);

// Add Category    

    start.UniversalTime();

    AddCategoriesL();

    stop.UniversalTime();

    msec = (stop.Int64() - start.Int64())/1000;

	_LIT8(KTrace2, "AddCategoriesL = %d msec");

	msg.Format(KTrace2, msec);

	LogToFileL(KLogFileName, msg);

// Read Category    

	start.UniversalTime();

    ReadCategoriesL();

    stop.UniversalTime();

    msec = (stop.Int64() - start.Int64())/1000;

    _LIT8(KTrace3, "ReadCategoriesL = %d msec");

	msg.Format(KTrace3, msec);

	LogToFileL(KLogFileName, msg);

// Update Category    

	start.UniversalTime();

    UpdateCategoriesL();

    stop.UniversalTime();

    msec = (stop.Int64() - start.Int64())/1000;

    _LIT8(KTrace4, "UpdateCategoriesL = %d msec");

	msg.Format(KTrace4, msec);

	LogToFileL(KLogFileName, msg);

    ReadCategoriesL();

    AddLandmarksL();

// Add Categories to LM synch

    start.UniversalTime();

    AddCategoriesToLandmarksL();

    stop.UniversalTime();

    msec = (stop.Int64() - start.Int64())/1000;

    _LIT8(KTrace5, "AddCategoriesToLandmarksL = %d msec");

	msg.Format(KTrace5, msec);

	LogToFileL(KLogFileName, msg);

// Add Categories to LM asynch

	start.UniversalTime();

    AddCategoriesToLandmarksAsyncL();

    stop.UniversalTime();

    msec = (stop.Int64() - start.Int64())/1000;

    _LIT8(KTrace6, "AddCategoriesToLandmarksAsyncL = %d msec");

	msg.Format(KTrace6, msec);

	LogToFileL(KLogFileName, msg);

    AddCategoriesToLandmarksAsyncErrCheckL();

// Add Categories to LM using WaitForReq

	start.UniversalTime();

    AddCategoriesToLandmarksUsingWaitForReqL();

    stop.UniversalTime();

    msec = (stop.Int64() - start.Int64())/1000;

    _LIT8(KTrace6b, "AddCategoriesToLandmarksUsingWaitForReqL = %d msec");

	msg.Format(KTrace6b, msec);

	LogToFileL(KLogFileName, msg);

    AddCategoriesToLandmarksAsyncErrCheckL();

// Remove Category synchronously

    ExecuteAndDeleteLD(iDatabase->CompactL());

    start.UniversalTime();

    RemoveCategoryL();

    stop.UniversalTime();

    msec = (stop.Int64() - start.Int64())/1000;

    _LIT8(KTrace7, "RemoveCategoryL = %d msec");

	msg.Format(KTrace7, msec);

	LogToFileL(KLogFileName, msg);

// Remove Category asynchronously

    start.UniversalTime();

    RemoveCategoryAsyncL();

    stop.UniversalTime();

    ExecuteAndDeleteLD(iDatabase->CompactL());

    msec = (stop.Int64() - start.Int64())/1000;

    _LIT8(KTrace8, "RemoveCategoryAsyncL = %d msec");

	msg.Format(KTrace8, msec);

	LogToFileL(KLogFileName, msg);

// Remove Category using WaitForRequest

    start.UniversalTime();

    RemoveCategoryUsingWaitForReqL();

    stop.UniversalTime();

    ExecuteAndDeleteLD(iDatabase->CompactL());

    msec = (stop.Int64() - start.Int64())/1000;

    _LIT8(KTrace8b, "RemoveCategoryUsingWaitForReqL = %d msec");

	msg.Format(KTrace8b, msec);

	LogToFileL(KLogFileName, msg);

// Remove set of categories synchronously

    start.UniversalTime();

    RemoveSetOfCategoriesL();

    stop.UniversalTime();

    ExecuteAndDeleteLD(iDatabase->CompactL());

    msec = (stop.Int64() - start.Int64())/1000;

    _LIT8(KTrace9, "RemoveSetOfCategoriesL = %d msec");

	msg.Format(KTrace9, msec);

	LogToFileL(KLogFileName, msg);

// Remove set of categories asynchronously

    start.UniversalTime();

    RemoveSetOfCategoriesAsyncL();

    stop.UniversalTime();

    ExecuteAndDeleteLD(iDatabase->CompactL());

    msec = (stop.Int64() - start.Int64())/1000;

    _LIT8(KTrace10, "RemoveSetOfCategoriesAsyncL = %d msec");

	msg.Format(KTrace10, msec);

	LogToFileL(KLogFileName, msg);

// Remove set of categories using WaitForRequest

    start.UniversalTime();

    RemoveSetOfCategoriesUsingWaitForReqL();

    stop.UniversalTime();

    ExecuteAndDeleteLD(iDatabase->CompactL());

    msec = (stop.Int64() - start.Int64())/1000;

    _LIT8(KTrace10b, "RemoveSetOfCategoriesUsingWaitForReqL = %d msec");

	msg.Format(KTrace10b, msec);

	LogToFileL(KLogFileName, msg);

// Remove category from set of landmarks synchronously

    iCategories.ResetAndDestroy();

    AddCategoriesL();

    AddCategoriesToLandmarksL();

    ExecuteAndDeleteLD(iDatabase->CompactL());

    start.UniversalTime();

    RemoveCategoryFromSetOfLandmarksL();

    stop.UniversalTime();

    msec = (stop.Int64() - start.Int64())/1000;

    _LIT8(KTrace11, "RemoveCategoryFromSetOfLandmarksL = %d msec");

	msg.Format(KTrace11, msec);

	LogToFileL(KLogFileName, msg);

// Remove category from set of landmarks asynchronously

	start.UniversalTime();

    RemoveCategoryFromSetOfLandmarksAsyncL();

    stop.UniversalTime();

    ExecuteAndDeleteLD(iDatabase->CompactL());

    msec = (stop.Int64() - start.Int64())/1000;

    _LIT8(KTrace12, "RemoveCategoryFromSetOfLandmarksAsyncL = %d msec");

	msg.Format(KTrace12, msec);

	LogToFileL(KLogFileName, msg);

// Remove category from set of landmarks using User::WaitForRequest()

	start.UniversalTime();

    RemoveCategoryFromSetOfLandmarksUsingWaitForReqL();

    stop.UniversalTime();

    ExecuteAndDeleteLD(iDatabase->CompactL());

    msec = (stop.Int64() - start.Int64())/1000;

    _LIT8(KTrace12b, "RemoveCategoryFromSetOfLandmarksUsingWaitForReqL = %d msec");

	msg.Format(KTrace12b, msec);

	LogToFileL(KLogFileName, msg);

    AddCategoriesToLandmarksL();

    delete iDatabase;

    iDatabase=NULL;

    delete iCategoryManager;

    iCategoryManager = NULL;

    iLog->Log(_L("BEFORE : BackupDbFileL"));

    iDatabase = BackupTp10DbFileL();

    iLog->Log(_L("AFTER : BackupDbFileL"));

    if (iDatabase->IsInitializingNeeded())

       {

       ExecuteAndDeleteLD(iDatabase->InitializeL());

       }

    iCategoryManager = CPosLmCategoryManager::NewL(*iDatabase); 

	// Cancel tests immediately

    iLog->Log(_L("TESTS BELOW ARE TESTING CANCEL"));

    AddCategoriesToLandmarksAsyncAndCancelL();

    RemoveCategoryAsyncAndCancelL();

    RemoveSetOfCategoriesAsyncAndCancelL();

    RemoveCategoryFromSetOfLandmarksAsyncAndCancelL();

	// Cancel tests after a while

    iLog->Log(_L("TESTS BELOW ARE CANCEL IN CALLBACK"));

    delete iDatabase;

    iDatabase=NULL;

    iLog->Log(_L("BEFORE : RestoreDbFileL"));

    iDatabase = RestoreTp10DbFileL();

    iLog->Log(_L("AFTER : RestoreDbFileL"));

    if (iDatabase->IsInitializingNeeded())

       {

       ExecuteAndDeleteLD(iDatabase->InitializeL());

       }

    delete iCategoryManager;

    iCategoryManager = NULL;

    iCategoryManager = CPosLmCategoryManager::NewL(*iDatabase); 

    ExecuteAndDeleteLD(iDatabase->CompactL());

    AddCategoriesToLandmarksAsyncAndCancelL(ETrue);

    RemoveCategoryAsyncAndCancelL(ETrue);

    RemoveSetOfCategoriesAsyncAndCancelL(ETrue);

    delete iDatabase;

    iDatabase=NULL;

    iDatabase = RestoreTp10DbFileL();

    if (iDatabase->IsInitializingNeeded())

       {

       ExecuteAndDeleteLD(iDatabase->InitializeL());

       }

    delete iCategoryManager;

    iCategoryManager = NULL;

    iCategoryManager = CPosLmCategoryManager::NewL(*iDatabase); 

    ExecuteAndDeleteLD(iDatabase->CompactL());

    RemoveCategoryFromSetOfLandmarksAsyncAndCancelL(ETrue);

    totalStop.UniversalTime();   

    msec = (totalStop.Int64() - totalStart.Int64())/1000;

    _LIT8(KTrace13, "Complete test case = %d msec");

	msg.Format(KTrace13, msec);

	LogToFileL(KLogFileName, msg);

    }

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

// CPosTp10::CloseTest

//

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

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

//

void CPosTp10::CloseTest()

    {

    iCategories.ResetAndDestroy();

    iCategories.Close();

    iLandmarks.ResetAndDestroy();

    iLandmarks.Close();

    delete iDatabase;

    iDatabase=NULL;

    delete iCategoryManager;

    iCategoryManager=NULL;

    }

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

// CPosTp10::AddCategoriesL

//

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

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

//

void CPosTp10::AddCategoriesL()

    {

    iLog->Log(_L("Adding and copying categories"));

    _LIT(KAlreadyExistErr, "A category with the same name is already added so add should return KErrAlreadyExists");    

    _LIT(KNoNameErr, "The Category has no name so add should return KErrArgument");

    _LIT(KCategoryName, "CategoryTP10 - %d");

    TInt index=0;

    while (index < KNoCategoriesTp10)

        {

        TBuf<100> name;

        name.Format(KCategoryName, ++index);

        CPosLandmarkCategory* category = CreateCategoryLC(name);

        CPosLandmarkCategory* copy = CPosLandmarkCategory::NewLC(*category);

        name.Format(KCategoryName, ++index);

        copy->SetCategoryNameL(name); 

        CPosLandmarkCategory* category2 = CPosLandmarkCategory::NewL();

        CleanupStack::PushL(category2);

        name.Format(KCategoryName, ++index);

        category2->SetCategoryNameL(name); 

        CPosLandmarkCategory* copy2 = CPosLandmarkCategory::NewL(*category2);

        CleanupStack::PushL(copy2); 

        name.Format(KCategoryName, ++index);

        copy2->SetCategoryNameL(name); 

        ExecuteAndDeleteLD(iDatabase->CompactL());

        iCategoryManager->AddCategoryL(*category);

        iCategoryManager->AddCategoryL(*copy);

        iCategoryManager->AddCategoryL(*category2);

        iCategoryManager->AddCategoryL(*copy2);

        CPosLandmarkCategory* category3 = CPosLandmarkCategory::NewLC();

        category3->SetCategoryNameL(name);

        TInt err = 0;

        TRAP(err, iCategoryManager->AddCategoryL(*category3));

        AssertTrueSecL(err == KErrAlreadyExists, KAlreadyExistErr);    

        CleanupStack::PopAndDestroy(category3);

        CPosLandmarkCategory* category4 = CPosLandmarkCategory::NewLC();

        TRAP(err, iCategoryManager->AddCategoryL(*category3));

        AssertTrueSecL(err == KErrArgument, KNoNameErr);    

        CleanupStack::PopAndDestroy(category4);

        iCategories.Append(category);

        iCategories.Append(copy);

        iCategories.Append(category2);

        iCategories.Append(copy2);

        CleanupStack::Pop(4); 

        }

    }

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

// CPosTp10::CompareTwoCategoriesL

//

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

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

//

void CPosTp10::CompareTwoCategoriesL(TInt aIndex)

    {

    CPosLandmarkCategory* category = iCategoryManager->ReadCategoryLC(iCategories[aIndex]->CategoryId());

    CompareCategoriesL(*iCategories[aIndex], *category);    

    CleanupStack::PopAndDestroy(category);

    }

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

// CPosTp10::ReadCategoriesL

//

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

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

//

void CPosTp10::ReadCategoriesL()

    {

    iLog->Log(_L("Reading categories"));

    _LIT(KReadNotFoundErr, "The category id doesn't exist so ReadCategory should return not found");    

    for (TInt i = 0; i<iCategories.Count(); i++)

        {

        TInt err = KErrLocked;

        while (err == KErrLocked)

            {

            TRAP(err, CompareTwoCategoriesL(i));

            if (err == KErrLocked) 

                {

                iLog->Log(_L("KErrLocked from CompareTwoCategoriesL, try again"));

                User::After(100000);

                }

            }

        }

    TPosLmItemId id = 5123321;

    CPosLandmarkCategory* category=NULL;

    TRAPD(err, category=iCategoryManager->ReadCategoryLC(id));

    delete category;

    AssertTrueSecL(err == KErrNotFound, KReadNotFoundErr);

    }

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

// CPosTp10::UpdateCategoriesL

//

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

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

//

void CPosTp10::UpdateCategoriesL()

    {

    iLog->Log(_L("Updating categories"));    

    _LIT(KCategoryNameNotSetErr, "UpdateCategory does not leave with KErrArgumenet when name is not set");

    _LIT(KCategoryExistsErr, "UpdateCategory does not leave with KErrAlreadyExist");

    TInt err;

    ExecuteAndDeleteLD(iDatabase->CompactL());

    CPosLandmarkCategory* category = CPosLandmarkCategory::NewLC();

    TRAP(err, iCategoryManager->UpdateCategoryL(*category));

    AssertTrueSecL(err == KErrArgument, KCategoryNameNotSetErr);    

    CleanupStack::PopAndDestroy(category);

    CPosLandmarkCategory* category2 = CPosLandmarkCategory::NewLC(*iCategories[0]);

    TPtrC nameThatExist;

    User::LeaveIfError(iCategories[1]->GetCategoryName(nameThatExist));

    category2->SetCategoryNameL(nameThatExist);

    TRAP(err, iCategoryManager->UpdateCategoryL(*category2));

    AssertTrueSecL(err == KErrAlreadyExists, KCategoryExistsErr);    

    CleanupStack::PopAndDestroy(category2);

    _LIT(KUpdatedCategoryName, "UpdatedCategoryTP10 - %d");

    for (TInt i = 0; i<iCategories.Count(); i++)

        {

        TBuf<100> name;

        name.Format(KUpdatedCategoryName, i);

        iCategories[i]->SetCategoryNameL(name);

        iCategories[i]->SetIconL(KMbmFileName2, KIconIndex2, KPosLmIconMaskNotUsed);

        err = KErrLocked;

        while (err == KErrLocked)

            {

            TRAP(err, iCategoryManager->UpdateCategoryL(*iCategories[i]));

            }