/*

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

#include <Lbs.h>

#include <EPos_CPosLmDatabaseManager.h>

#include <EPos_CPosLandmarkParser.h>

#include <EPos_CPosLandmarkEncoder.h>

#include <EPos_CPosLandmark.h>

#include <EPos_CPosLmMultiDbSearch.h>

#include <EPos_CPosLmCatNameCriteria.h>

#include <EPos_CPosLmTextCriteria.h>

#include <EPos_CPosLmCategoryCriteria.h>

#include "FT_LandmarkConstants.h"

// CONSTANTS

const TInt KShortExecutionTimeInSeconds = 15;

const TInt KLongExecutionTimeInSeconds = 5 * 60; // Five minutes. The longer the more errors seem appear...

const TInt KNrOfDatabases = 5;

const TInt KLockedDbIndex = 2;

const TInt KMaxNrOfLms = 20;

const TInt KLockThreadStartupTime = 500000;

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

_LIT(KLockThreadSearchPattern, "*TP127_LockThread*"); 

_LIT(KTestDbUri, "TestDatabase.ldb");

_LIT(KTestDbUriUC, "TESTDATABASE.LDB");

// ================= 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 AssertTrueL

//

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

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

//

LOCAL_C void AssertTrueL(

    TBool aCondition, 

    const TDesC& aBuf, 

    TDes* aMessage, 

    TInt aError = KErrGeneral)

    {

    if (!aCondition)

        {

        _LIT(KFormat, "%S, error = %d");

        aMessage->Format(KFormat, &aBuf, aError);

        aError == KErrNone ? User::Leave(KErrGeneral) : User::Leave(aError);

        }

    }

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

// LOCAL_C ThreadExistsL

//

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

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

//

LOCAL_C TBool ThreadExistsL(const TDesC& aSearchPattern)

    {

    TFindThread threadSearcher;

    threadSearcher.Find(aSearchPattern);

    TFullName fullName;

    return (threadSearcher.Next(fullName) == KErrNone);

    }

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

// LOCAL_C VerifyResultL

//

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

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

//

LOCAL_C void VerifyResultL(

    TBool aLockThreadExists, 

    CPosLmMultiDbSearch* aMultiDbSearcher, 

    TDes* aDes)

    {

    TInt nrOfErrors = aMultiDbSearcher->NumOfSearchErrors();

    if (aLockThreadExists)

        {

        // Reading locked db should result in KErrLocked

        AssertTrueL(nrOfErrors == 1, _L("Not one error as expected"), aDes);

        CPosLmMultiDbSearch::TSearchError error;

        aMultiDbSearcher->GetSearchError(0, error);

        AssertTrueL(error.iDatabaseIndex == KLockedDbIndex, _L("Error in wrong db"), aDes);

        AssertTrueL(error.iErrorCode == KErrLocked, _L("Wrong error"), aDes, error.iErrorCode);

        }

    else

        {

        AssertTrueL(nrOfErrors == 0, _L("Search failed with errors"), aDes);

        }

    aDes->Zero();    

    }

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

// Constructor

CThreadMonitor::CThreadMonitor(RThread* aThread) 

: CActive(CActive::EPriorityStandard), iThread(aThread)

    {

    CActiveScheduler::Add(this);

    }

// Destructor

CThreadMonitor::~CThreadMonitor()

    {

    Cancel();

    }

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

// CThreadMonitor::NewL

//

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

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

//

CThreadMonitor* CThreadMonitor::NewL(RThread* aThread)

    {

    CThreadMonitor* self = new (ELeave) CThreadMonitor(aThread);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CThreadMonitor::ConstructL

//

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

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

//

void CThreadMonitor::ConstructL()

    {

    iThread->Resume();

    iThread->Logon(iStatus);

    SetActive();

    }

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

// CThreadMonitor::DoCancel

//

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

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

//

void CThreadMonitor::DoCancel()

    {

    iThread->LogonCancel(iStatus);

    // Kill thread

    TRequestStatus status;

    iThread->Logon(status);

    iThread->Kill(KErrCancel);

    User::WaitForRequest(status);

    }

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

// CThreadMonitor::RunL

//

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

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

//

void CThreadMonitor::RunL()

    {

    CActiveScheduler::Stop();

    }

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

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

// CPosTp127::GetName

//

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

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

//

void CPosTp127::GetName(TDes& aName) const

    {

    _LIT(KTestName, "TP127 - Multiple databases, multiple clients");

    aName = KTestName;

    }

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

// CPosTp127::InitTestL

//

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

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

//

void CPosTp127::InitTestL()

    {

    MakeSurePanicDebugFileExistsL();

    // PrepareDatabases

    RemoveAllLmDatabasesL();

    CopyTestDbFileL(KDb20);

    CopyTestDbFileL(KDb40);

    CopyTestDbFileL(KDb60);

    CopyTestDbFileL(KDb80);

    CopyTestDbFileL(KDb105);

    // Initialize databases - is this really needed?

    CPosLmDatabaseManager* dbMan = CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbMan);

    CDesCArray* dbList = dbMan->ListDatabasesLC();

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

        {

        CPosLandmarkDatabase* db = CPosLandmarkDatabase::OpenL(dbList->operator[](i));

        CleanupStack::PushL(db);

        ExecuteAndDeleteLD(db->InitializeL());

        CleanupStack::PopAndDestroy(db);

        }

    // Remove the last 5 lms of the the last db

    CPosLandmarkDatabase* db = CPosLandmarkDatabase::OpenL(KDb105);

    CleanupStack::PushL(db);

    CPosLmItemIterator* iter = db->LandmarkIteratorL();

    CleanupStack::PushL(iter);

    RIdArray idArray;

    CleanupClosePushL(idArray);

    iter->GetItemIdsL(idArray, 20, iter->NumOfItemsL() - 20);

    ExecuteAndDeleteLD(db->RemoveLandmarksL(idArray));

    CleanupStack::PopAndDestroy(3, db);

    CleanupStack::PopAndDestroy(2, dbMan);

    }

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

// CPosTp127::CloseTest

//

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

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

//

void CPosTp127::CloseTest()

    {

    }

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

// CPosTp127::StartL

//

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

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

//

void CPosTp127::StartL()

    {

    // 1. Create multiple db search threads 

    iLog->Put(_L("<<<< 1. Create multiple db search threads >>>>"));

    TBool lockDb = ETrue;

    TBool successful = MultipleDbSearchClientsL(!lockDb);

    //TBool successful = MultipleDbSearchClientsL(lockDb);

    // Sometimes error ESLI-69LDJD DBMS - Error occurs

    // 2. One of the databases is locked

    iLog->Put(_L("<<<< 2. One of the databases is locked >>>>"));

    User::After(KLockThreadStartupTime); // Let previous thread instances really die

    if (!MultipleDbSearchClientsL(lockDb))

        {        

        successful = EFalse;

        }

    // 3. Copy database in use

    iLog->Put(_L("<<<< 3. Copy database in use >>>>"));

    if (!VerifyInUseWhenCopyL())

        {        

        successful = EFalse;

        }

    // 4. Copy databases continuously in parallel

    iLog->Put(_L("<<<< 4. Copy databases continuously in parallel >>>>"));

    if (!VerifyCopyStressL())

        {        

        successful = EFalse;

        }

    // 5. Use all LM APIs

    iLog->Put(_L("<<<< 5. Use all LM APIs simultaneously >>>>"));

    if (!MultipleLmClientsL())

        {        

        successful = EFalse;

        }

    // Leave if error    

    if (!successful)

        {        

        User::Leave(KErrGeneral);

        }

    }

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

// CPosTp127::MultipleDbSearchClientsL

//

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

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

//

TBool CPosTp127::MultipleDbSearchClientsL(TBool aLockDb)

    {

    RThread searchThread1, searchThread2, searchThread3, lockThread;

    TThreadParam params1, params2, params3, params4;

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

    RArray<TThreadParam> threadArray;

    CleanupClosePushL(threadArray);

    // Create search thread 1

    _LIT(KSearchThread1, "TP127 - Search thread 1");

    TInt err = searchThread1.Create(KSearchThread1, ThreadFunction, 

        KDefaultStackSize, KMinHeapSize, KMaxHeapSize, &params1);

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

    CleanupClosePushL(searchThread1);

    params1.iMessage = &threadMsg1;

    params1.iTestFunction = MultipleDbCategorySearchL;

    params1.iThread = &searchThread1;

    threadArray.AppendL(params1);

    // Create search thread 2

    _LIT(KSearchThread2, "TP127 - Search thread 2");

    err = searchThread2.Create(KSearchThread2, ThreadFunction, 

        KDefaultStackSize, KMinHeapSize, KMaxHeapSize, &params2);

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

    CleanupClosePushL(searchThread2);

    params2.iMessage = &threadMsg2;

    params2.iTestFunction = MultipleDbLandmarkSearchL;

    params2.iThread = &searchThread2;

    threadArray.AppendL(params2);

    // Create search thread 3

    _LIT(KSearchThread3, "TP127 - Search thread 3");

    err = searchThread3.Create(KSearchThread3, ThreadFunction, 

        KDefaultStackSize, KMinHeapSize, KMaxHeapSize, &params3);

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

    CleanupClosePushL(searchThread3);

    params3.iMessage = &threadMsg3;

    params3.iTestFunction = MultipleDbLandmarkWithoutCategorySearchL;

    params3.iThread = &searchThread3;

    threadArray.AppendL(params3);

    if (aLockDb)

        {

        // Create db lock thread

        _LIT(KLockThread, "TP127 - TP127_LockThread");        

        err = lockThread.Create(KLockThread, ThreadFunction, 

            KDefaultStackSize, KMinHeapSize, KMaxHeapSize, &params4);

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

        CleanupClosePushL(lockThread);

        params4.iMessage = &threadMsg4;

        params4.iTestFunction = LockDatabaseL;

        params4.iThread = &lockThread;

        threadArray.AppendL(params4);

        }

    TBool successful = ResumeThreadsAndVerifyExitL(threadArray); 

    if (aLockDb)

        {

        CleanupStack::PopAndDestroy(&lockThread);

        }

    CleanupStack::PopAndDestroy(4, &threadArray);

    return successful;

    }

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

// CPosTp127::MultipleLmClientsL

//

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

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

//

TBool CPosTp127::MultipleLmClientsL()

    {

    // Set default db

    CPosLmDatabaseManager* dbMan = CPosLmDatabaseManager::NewL();

    CleanupStack::PushL(dbMan);

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

    dbMan->CreateDatabaseL(*dbInfo);

    CleanupStack::PopAndDestroy(dbInfo);

    dbMan->SetDefaultDatabaseUriL(KTestDbUri);

    CleanupStack::PopAndDestroy(dbMan);

    RThread dbManThread, multiSearchThread, dbThread, singleSearchThread;

    TThreadParam params1, params2, params3, params4;

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

    RArray<TThreadParam> threadArray;

    CleanupClosePushL(threadArray);

    // Create db management thread

    _LIT(KDbManThread, "TP127 - Db manager thread");

    TInt err = dbManThread.Create(KDbManThread, ThreadFunction, 

        KDefaultStackSize, KMinHeapSize, KMaxHeapSize, &params1);

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

    CleanupClosePushL(dbManThread);

    params1.iMessage = &threadMsg1;

    params1.iTestFunction = DbManagementL;

    params1.iThread = &dbManThread;

    threadArray.AppendL(params1);

    // Create multi db search thread

    _LIT(KMultiSearchThread, "TP127 - Multi search thread");

    err = multiSearchThread.Create(KMultiSearchThread, ThreadFunction, 

        KDefaultStackSize, KMinHeapSize, KMaxHeapSize, &params2);

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

    CleanupClosePushL(multiSearchThread);

    params2.iMessage = &threadMsg2;

    params2.iTestFunction = MultipleDbSearchL;

    params2.iThread = &multiSearchThread;

    threadArray.AppendL(params2);

    // Create LM API thread

    _LIT(KDbThread, "TP127 - db thread");

    err = dbThread.Create(KDbThread, ThreadFunction, 

        KDefaultStackSize, KMinHeapSize, KMaxHeapSize, &params3);

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

    CleanupClosePushL(dbThread);

    params3.iMessage = &threadMsg3;

    params3.iTestFunction = DbAccessL;

    params3.iThread = &dbThread;

    threadArray.AppendL(params3);

    // Create single db search thread

    _LIT(KSingleSearchThread, "TP127 - Single search thread");        

    err = singleSearchThread.Create(KSingleSearchThread, ThreadFunction, 

        KDefaultStackSize, KMinHeapSize, KMaxHeapSize, &params4);

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

    CleanupClosePushL(singleSearchThread);

    params4.iMessage = &threadMsg4;

    params4.iTestFunction = SingleDbSearchL;

    params4.iThread = &singleSearchThread;

    threadArray.AppendL(params4);

    TBool successful = ResumeThreadsAndVerifyExitL(threadArray); 

    CleanupStack::PopAndDestroy(5, &threadArray);

    return successful;

    }

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

// CPosTp127::VerifyInUseWhenCopyL

//

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

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

//

TBool CPosTp127::VerifyInUseWhenCopyL()

    {

    RThread copyThread, lockThread;

    TThreadParam params1, params2;

    TBuf<200> threadMsg1, threadMsg2;

    RArray<TThreadParam> threadArray;

    CleanupClosePushL(threadArray);

    // Create copy thread

    _LIT(KCopyThread, "TP127 - Copy thread");

    TInt err = copyThread.Create(KCopyThread, ThreadFunction, 

        KDefaultStackSize, KMinHeapSize, KMaxHeapSize, &params1);

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

    CleanupClosePushL(copyThread);

    params1.iMessage = &threadMsg1;

    params1.iTestFunction = CopyLockedDatabaseL;

    params1.iThread = &copyThread;

    threadArray.AppendL(params1);

    // Create db lock thread

    _LIT(KLockThread, "TP127 - TP127_LockThread");

    err = KErrAlreadyExists;

    while (err == KErrAlreadyExists)

        {

        err = lockThread.Create(KLockThread, ThreadFunction, 

            KDefaultStackSize, KMinHeapSize, KMaxHeapSize, &params2);

        }

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

    CleanupClosePushL(lockThread);

    params2.iMessage = &threadMsg2;

    params2.iTestFunction = LockDatabaseL;

    params2.iThread = &lockThread;

    threadArray.AppendL(params2);

    TBool successful = ResumeThreadsAndVerifyExitL(threadArray); 

    CleanupStack::PopAndDestroy(3, &threadArray);

    return successful;

    }

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

// CPosTp127::VerifyCopyStressL

//

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

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

//

TBool CPosTp127::VerifyCopyStressL()

    {

    RThread copyThread1, copyThread2, copyThread3, copyThread4, copyThread5;

    TThreadParam params1, params2, params3, params4, params5;

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

    RArray<TThreadParam> threadArray;

    CleanupClosePushL(threadArray);

    // Create copy thread1

    _LIT(KCopyThread1, "TP127 - Copy thread1");

    TInt err = copyThread1.Create(KCopyThread1, ThreadFunction, 

        KDefaultStackSize, KMinHeapSize, KMaxHeapSize, &params1);

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