/*

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

#include <Lbs.h>

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLandmarkParser.h>

#include <EPos_CPosLandmarkEncoder.h>

#include <EPos_CPosLandmark.h>

// CONSTANTS

const TInt KExectionTimeInMinutes = 60 * 10; // 10 hours

// ================= LOCAL FUNCTIONS =======================

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

// LOCAL_C ThreadFunction

//

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

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

//

LOCAL_C TInt ThreadFunction(TAny* aData)

    {

    CTrapCleanup* cleanup = CTrapCleanup::New(); 

    CActiveScheduler* actSch = new (ELeave) CActiveScheduler;

    CActiveScheduler::Install(actSch);

    TThreadParam* params = reinterpret_cast<TThreadParam*> (aData);

    TRAPD(err, (*params->iTestFunction)(params->iMessage));

    delete actSch;

    delete cleanup;

    return err;

    }

LOCAL_C void AddLandmarksL(

    TInt aNrOfLmsToAdd,

    const TDesC& aName,

    CPosLandmarkDatabase* aDb, 

    RArray<TPosLmItemId>& aIdArray)

    {

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

        {

        CPosLandmark* landmark = CPosLandmark::NewLC();

        landmark->SetLandmarkNameL(aName);

        landmark->SetPositionL(TLocality(TCoordinate(64, 85, 20), 25, 53));

        landmark->SetCoverageRadius(18);

        landmark->AddCategoryL(1);

        landmark->SetIconL(_L("Icon"), 23, KPosLmIconMaskNotUsed);

        landmark->SetLandmarkDescriptionL(_L("Desc"));

        User::LeaveIfError(aIdArray.Append(aDb->AddLandmarkL(*landmark)));

        CleanupStack::PopAndDestroy(landmark);

        }

    }

LOCAL_C void VerifyErrorL(const TDesC& aFormat, TInt aErr, TDes* aMessage)

    {

    if (aErr != KErrNone && aErr != KErrLocked)

        {

        aMessage->Format(aFormat, aErr);

        // Append time

        _LIT(KTimeFormat, " %F%Y-%M-%D at %H.%T:%S");

        TTime now;

        now.HomeTime();

        TBuf<50> time;

        now.FormatL(time, KTimeFormat);

        aMessage->Append(time);

        User::Leave(aErr);

        }

    }

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

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

// CPosTp78::GetName

//

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

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

//

void CPosTp78::GetName(TDes& aName) const

    {

    _LIT(KTestName, "TP78 - CPosLandmarkDatabase duration tests");

    aName = KTestName;

    }

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

// CPosTp78::InitTestL

//

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

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

//

void CPosTp78::InitTestL()

    {

    MakeSurePanicDebugFileExistsL();

    InitDbL();

    }

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

// CPosTp78::CloseTest

//

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

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

//

void CPosTp78::CloseTest()

    {

    }

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

// CPosTp78::StartL

//

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

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

//

void CPosTp78::StartL()

    {

// Test Open database duration test

    ResumeThreadsAndVerifyExitL();

    }

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

// CPosTp78::InitDbL

//

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

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

//

void CPosTp78::InitDbL()

    {

    RemoveDefaultDbL();

    CPosLandmarkDatabase* database = CPosLandmarkDatabase::OpenL();

    CleanupStack::PushL(database);

    if (database->IsInitializingNeeded())

        {

        ExecuteAndDeleteLD(database->InitializeL());

        }

    CleanupStack::PopAndDestroy(database);

    // Wait for LM server to die

    User::After(2000000);

    }

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

// CPosTp78::ResumeThreadsAndVerifyExitL

//

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

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

//

void CPosTp78::ResumeThreadsAndVerifyExitL()

    {

    _LIT(KCreateThreadErr, "Creating thread failed with %d");

    TInt nrOfThreads = 0;

    RThread openDbThread, addRemoveLmThread, impExpLmThread, dbEventThread, readAndUpdateThread;

    TThreadParam params1, params2, params3, params4, params5;

    TBuf<200> threadMsg1, threadMsg2, threadMsg3, threadMsg4, threadMsg5;

    // Create open database thread

    _LIT(KOpenDatabase, "TP78 - Open database duration thread");

    params1.iMessage = &threadMsg1;

    params1.iTestFunction = RunOpenDbTestL;

    TInt err = openDbThread.Create(KOpenDatabase, ThreadFunction, 

        KDefaultStackSize, KMinHeapSize, KDefaultHeapSize, &params1);

    AssertTrueSecL(err == KErrNone, KCreateThreadErr, err);

    CleanupClosePushL(openDbThread);

    nrOfThreads++;

    // Create add remove LMs thread

    _LIT(KAddRemoveLandmarks, "TP78 - Add remove landmarks duration thread");

    params2.iMessage = &threadMsg2;

    params2.iTestFunction = RunAddRemoveLmTestL;

    err = addRemoveLmThread.Create(KAddRemoveLandmarks, ThreadFunction, 

        KDefaultStackSize, KMinHeapSize, 5 * KDefaultHeapSize, &params2);

    AssertTrueSecL(err == KErrNone, KCreateThreadErr, err);

    CleanupClosePushL(addRemoveLmThread);

    nrOfThreads++;

    // Create import/export LMs thread

    _LIT(KImpExpLandmarks, "TP78 - Import/Export landmarks duration thread");

    params3.iMessage = &threadMsg3;

    params3.iTestFunction = RunImportExportLmTestL;

    err = impExpLmThread.Create(KImpExpLandmarks, ThreadFunction, 

        KDefaultStackSize, KMinHeapSize, 5 * KDefaultHeapSize, &params3);

    AssertTrueSecL(err == KErrNone, KCreateThreadErr, err);

    CleanupClosePushL(impExpLmThread);

    nrOfThreads++;

    // Create db event thread

    _LIT(KDbEventThread, "TP78 - Database events duration thread");

    params4.iMessage = &threadMsg4;

    params4.iTestFunction = RunDbEventTestL;

    err = dbEventThread.Create(KDbEventThread, ThreadFunction, 

        KDefaultStackSize, KMinHeapSize, KDefaultHeapSize, &params4);

    AssertTrueSecL(err == KErrNone, KCreateThreadErr, err);

    CleanupClosePushL(dbEventThread);

    nrOfThreads++;

    // Create read and update thread

    _LIT(KReadAndUpdateThread, "TP78 - Read and update landmarks duration thread");

    params5.iMessage = &threadMsg5;

    params5.iTestFunction = RunReadAndUpdateTestL;

    err = readAndUpdateThread.Create(KReadAndUpdateThread, ThreadFunction, 

        KDefaultStackSize, KMinHeapSize, 5 * KDefaultHeapSize, &params5);

    AssertTrueSecL(err == KErrNone, KCreateThreadErr, err);

    CleanupClosePushL(readAndUpdateThread);

    nrOfThreads++;

    // Start threads.

    RThread* threads[] = {&openDbThread, &addRemoveLmThread, &impExpLmThread, &dbEventThread, &readAndUpdateThread};

    RPointerArray<CThreadMonitor> threadMonitors;

    for (TInt j = 0; j < nrOfThreads; j++)

        {

        threadMonitors.Append(CThreadMonitor::NewL(threads[j]));

        }

    // Log time stamp

    _LIT(KTimeFormat, "Threads started on %F%Y-%M-%D at %H.%T:%S");

    TTime now;

    now.HomeTime();    

    now.FormatL(iBuf, KTimeFormat);

    iLog->Put(iBuf);

    // Wait until any of the threads exits.

    TDes* messages[] = {&threadMsg1, &threadMsg2, &threadMsg3, &threadMsg4, &threadMsg5};

    TInt errors = KErrNone;

    TBool allThreadsTerminated = EFalse;

    while (!allThreadsTerminated && errors == KErrNone)

        {

        CActiveScheduler::Start();

        // Assume all threads are terminated

        allThreadsTerminated = ETrue;

        for (TInt i = 0; i < nrOfThreads && errors == KErrNone; i++)

            {

            if (threadMonitors[i]->IsActive())

                {

                // Thread is still alive

                allThreadsTerminated = EFalse;

                }

            else

                {

                // Thread is terminated, check exit codes

                if (*messages[i] != KNullDesC)

                    {

                    iLog->Put(*(messages[i]));

                    }

                if (threads[i]->ExitType() != EExitKill)

                    {

                    iBuf.Format(_L("Thread %i was not killed!"), i);

                    iLog->PutError(iBuf);

                    TExitCategoryName category = threads[i]->ExitCategory();

                    iBuf.Format(_L("Exit Category = %S %d"), &category, threads[i]->ExitReason());

                    iLog->Put(iBuf);

                    errors = KErrGeneral;

                    }

                else

                    {

                    TInt exitReason = threads[i]->ExitReason();

                    if (exitReason != 0)

                        {

                        iBuf.Format(_L("Thread's exit reason wasn't 0 but %d."), exitReason);

                        iLog->PutError(iBuf);

                        errors = exitReason;

                        }

                    }

                }

            }

        }

    // Terminate all remaining threads

    threadMonitors.ResetAndDestroy();

    // Log time stamp

    _LIT(KTimeFormat2, "Threads terminated on %F%Y-%M-%D at %H.%T:%S");

    now.HomeTime();    

    now.FormatL(iBuf, KTimeFormat2);

    iLog->Put(iBuf);

    User::LeaveIfError(errors);

    CleanupStack::PopAndDestroy(nrOfThreads, &openDbThread);

    }

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

// CPosTp78::RunOpenDbTestL

//

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

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

//

void CPosTp78::RunOpenDbTestL(TDes* aMessage)

    {

    // Execute thread for a number of hours

    TTime startTime, stopTime;

    startTime.HomeTime();

    stopTime.HomeTime();

    TTimeIntervalMinutes executionTime;

    User::LeaveIfError(stopTime.MinutesFrom(startTime, executionTime));

    while (executionTime.Int() < KExectionTimeInMinutes)

        {

        CPosLandmarkDatabase* db = NULL;

        TRAPD(err, db = CPosLandmarkDatabase::OpenL());

        CleanupStack::PushL(db);

        VerifyErrorL(_L("<-- OpenDbThread: CPosLandmarkDatabase::OpenL() left with %d -->"), err, aMessage);

        if (err == KErrNone)

            {

            // Try to initialize the db

            db->IsInitializingNeeded(); // don't care about the result. Init anyway

            CPosLmOperation* operation = NULL;

            TRAP(err, operation = db->InitializeL());

            CleanupStack::PushL(operation);

            VerifyErrorL(_L("<-- OpenDbThread: InitializeL() left with %d -->"), err, aMessage);

            if (err == KErrNone)

                {

                TRAP(err, operation->ExecuteL());

                VerifyErrorL(_L("<-- OpenDbThread: ExecuteAndDeleteLD(InitializeL()) left with %d -->"), err, aMessage);

                }

            CleanupStack::PopAndDestroy(operation);

            }

        CleanupStack::PopAndDestroy(db);

        // Let other threads get access to the database

        User::After(10000);

        stopTime.HomeTime();

        User::LeaveIfError(stopTime.MinutesFrom(startTime, executionTime));

        }

    }

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

// CPosTp78::RunAddRemoveLmTestL

//

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

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

//

void CPosTp78::RunAddRemoveLmTestL(TDes* aMessage)

    {

    // Execute thread for a number of hours

    TTime startTime, stopTime;

    startTime.HomeTime();

    stopTime.HomeTime();

    TTimeIntervalMinutes executionTime;

    User::LeaveIfError(stopTime.MinutesFrom(startTime, executionTime));

    CPosLandmarkDatabase* db = CPosLandmarkDatabase::OpenL();

    CleanupStack::PushL(db);

    while (executionTime.Int() < KExectionTimeInMinutes)

        {

        RArray<TPosLmItemId> dbItems;

        CleanupClosePushL(dbItems);

        // Remove all landmarks

        CPosLmOperation* operation = NULL;

        TRAPD(err, operation = db->RemoveAllLandmarksL());

        VerifyErrorL(_L("<-- AddRemoveThread: RemoveAllLandmarksL() left with %d -->"), err, aMessage);

        if (err == KErrNone)

            {

            TRAP(err, ExecuteAndDeleteLD(operation));

            VerifyErrorL(_L("<-- AddRemoveThread: ExecuteAndDeleteLD(RemoveAllLandmarksL()) left with %d -->"), err, aMessage);

            }

        // Add some landmarks

        const TInt KNrOfLms = 10;

        TRAP(err, AddLandmarksL(KNrOfLms, _L("AddRemoveThread"), db, dbItems));

        VerifyErrorL(_L("<-- AddRemoveThread: AddLandmarksL() left with %d -->"), err, aMessage);

        if (err == KErrNone)

            {

            // Remove some items one by one

            for (TInt i = 0; i < KNrOfLms / 2; i++)

                {

                dbItems.Remove(0);

                TRAP(err, db->RemoveLandmarkL(dbItems[0]));

                VerifyErrorL(_L("<-- AddRemoveThread: RemoveLandmarkL(TPosLmItemId) left with %d -->"), err, aMessage);

                }

            // Remove 5 items in one step

            operation = NULL;

            TRAPD(err, operation = db->RemoveLandmarksL(dbItems));

            VerifyErrorL(_L("<-- AddRemoveThread: RemoveLandmarksL(RArray) left with %d -->"), err, aMessage);

            if (err == KErrNone)

                {

                TRAP(err, ExecuteAndDeleteLD(operation));

                VerifyErrorL(_L("<-- AddRemoveThread: ExecuteAndDeleteLD(RemoveLandmarksL(dbItems)) left with %d -->"), err, aMessage);

                }

            dbItems.Reset();

            CPosLandmarkDatabase::TSize dbSize; dbSize.iUsage = 0;

            TRAP(err, dbSize = db->SizeL());

            VerifyErrorL(_L("<-- AddRemoveThread: SizeL() left with %d -->"), err, aMessage);

            if (dbSize.iUsage < 0.9)

                {

                operation = NULL;

                TRAP(err, operation = db->CompactL());

                VerifyErrorL(_L("<-- AddRemoveThread: CompactL() left with %d -->"), err, aMessage);

                if (err == KErrNone)

                    {

                    CleanupStack::PushL(operation);

                    TRAP(err, operation->ExecuteL());

                    VerifyErrorL(_L("<-- AddRemoveThread: ExecuteAndDeleteLD(CompactL()) left with %d -->"), err, aMessage);

                    CleanupStack::PopAndDestroy(operation);

                    }

                }

            HBufC* dbUri = NULL;

            TRAP(err, CleanupStack::Pop(dbUri = db->DatabaseUriLC()));

            CleanupStack::PushL(dbUri);

            VerifyErrorL(_L("<-- AddRemoveThread: DatabaseUriLC() left with %d -->"), err, aMessage);

            CleanupStack::PopAndDestroy(dbUri);

            }

        dbItems.Reset();

        CleanupStack::PopAndDestroy(&dbItems);

        // Let other threads get access to the database

        User::After(300000);

        stopTime.HomeTime();

        User::LeaveIfError(stopTime.MinutesFrom(startTime, executionTime));

        }

    CleanupStack::PopAndDestroy(db);

    }

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

// CPosTp78::RunImportExportLmTestL

//

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

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

//

void CPosTp78::RunImportExportLmTestL(TDes* aMessage)

    {

    // Execute thread for a number of hours

    TTime startTime, stopTime;

    startTime.HomeTime();

    stopTime.HomeTime();

    TTimeIntervalMinutes executionTime;

    User::LeaveIfError(stopTime.MinutesFrom(startTime, executionTime));

    CPosLandmarkDatabase* db = CPosLandmarkDatabase::OpenL();

    CleanupStack::PushL(db);

    while (executionTime.Int() < KExectionTimeInMinutes)

        {

// Export landmarks

        TBool exportSuccessful = EFalse;

        CPosLmOperation* operation = NULL;

        CPosLandmarkEncoder* encoder = NULL;

        TRAPD(err, encoder = CPosLandmarkEncoder::NewL(KMimeType));

        VerifyErrorL(_L("<-- ImportExportThread: CPosLandmarkEncoder::NewL left with %d -->"), err, aMessage);

        CleanupStack::PushL(encoder);

        // Use buffer as output

        CBufBase* outputBuffer = NULL;

        TRAP(err, outputBuffer = encoder->SetUseOutputBufferL());

        VerifyErrorL(_L("<-- ImportExportThread: SetUseOutputBufferL left with %d -->"), err, aMessage);

        CleanupStack::PushL(outputBuffer);

        // Add collection data

        TRAP(err, encoder->AddCollectionDataL(EPosLmCollDataCollectionName, _L("collection Name")));

        VerifyErrorL(_L("<-- ImportExportThread: AddCollectionDataL(Name) left with %d -->"), err, aMessage);

        TRAP(err, encoder->AddCollectionDataL(EPosLmCollDataCollectionDescription, _L("collection Desc")));

        VerifyErrorL(_L("<-- ImportExportThread: AddCollectionDataL(Desc) left with %d -->"), err, aMessage);

        // Export landmarks

        RArray<TPosLmItemId> lmIdArray;

        CleanupClosePushL(lmIdArray);

        TRAP(err, AddLandmarksL(5, _L("ImportExportThread"), db, lmIdArray));

        VerifyErrorL(_L("<-- ImportExportThread: AddLandmarksL() left with %d -->"), err, aMessage);

        if (err == KErrNone)

            {

            TRAP(err, operation = db->ExportLandmarksL(*encoder, lmIdArray, 

                CPosLandmarkDatabase::EIncludeCategories | CPosLandmarkDatabase::EIncludeGlobalCategoryNames));

            VerifyErrorL(_L("<-- ImportExportThread: ExportLandmarksL left with %d -->"), err, aMessage);

            if (err == KErrNone)

                {

                CleanupStack::PushL(operation);

                TRAP(err, ExecuteAndDeleteLD(operation));

                CleanupStack::Pop(operation);

                VerifyErrorL(_L("<-- ImportExportThread: ExecuteAndDeleteLD(ExportLandmarksL) left with %d -->"), err, aMessage);

                // finalize encoding

                operation = NULL;

                TRAP(err, operation = encoder->FinalizeEncodingL());

                VerifyErrorL(_L("<-- ImportExportThread: FinalizeEncodingL left with %d -->"), err, aMessage);

                if (err == KErrNone)

                    {

                    CleanupStack::PushL(operation);

                    TRAP(err, ExecuteAndDeleteLD(operation));

                    CleanupStack::Pop(operation);

                    VerifyErrorL(_L("<-- ImportExportThread: ExecuteAndDeleteLD(FinalizeEncodingL) left with %d -->"), err, aMessage);

                    exportSuccessful = ETrue;

                    }

                }

            }

        CleanupStack::PopAndDestroy(&lmIdArray);

// Import landmarks

        if (exportSuccessful)

            {

            CPosLandmarkParser* parser = NULL;

            TRAP(err, parser = CPosLandmarkParser::NewL(KMimeType));

            CleanupStack::PushL(parser);

            VerifyErrorL(_L("<-- ImportExportThread: CPosLandmarkParser::NewL left with %d -->"), err, aMessage);

            // Use buffer as input

            TInt size = outputBuffer->Size();

            HBufC8* inputBuffer = HBufC8::New(size);

            if (!inputBuffer)

                {

                aMessage->Copy(_L8("Unable to allocate inputBuffer. Error: KErrNoMemory"));

                }