/*

* 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 <EPos_CPosLandmarkDatabase.h> 

#include <EPos_CPosLMItemIterator.h> 

#include <EPos_CPosLandmark.h> 

#include <EPos_CPosLMCategoryManager.h>

#include <EPos_CPosLandmarkCategory.h>

#include <EPos_CPosLandmarkSearch.h> 

#include <EPos_CPosLmTextCriteria.h>

#include <EPos_CPosLMItemIterator.h>    

#include "FT_CSearchResult.h"  

#include <LbsPosition.h> 

#include <e32std.h>

#include <ss_std.h>

#include "FT_CPosTp30.h"

#include "FT_LandmarkConstants.h"

//#include "FT_CActiveSearch.h"

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

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

// CPosTp30::GetName

//

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

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

//

void CPosTp30::GetName(TDes& aName) const

    {

    _LIT(KTestName, "TP30 - Multiple clients in search");

    aName = KTestName;

    }

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

// CPosTp30::CloseTest

//

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

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

//

void CPosTp30::CloseTest()

    {

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

        {

        iThreads[i].Close();

        }

    iThreads.Close();

    delete iDatabase;

    iDatabase=NULL;

    iUseLogFromThreadIsDisabled = EFalse;

    }

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

// CPosTp30::StartL

//

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

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

//

void CPosTp30::StartL()

    {

    _LIT(KTimeErr, "The request time for several simultaneously requests is > n*'request time for one request'");

    MakeSurePanicDebugFileExistsL();

    iDatabase = UseGeneratedDbFileL();

    delete iDatabase;

    iDatabase=NULL;

    iUseLogFromThreadIsDisabled = ETrue;

    AppendSearchResultsL();

    iAsyncSearch = ETrue;

    TTime start, stop;

    start.UniversalTime();

    StartMultipleClientsL(1);

    stop.UniversalTime();

	TInt64 msecOne = (stop.Int64() - start.Int64())/1000;

    _LIT8(KTrace, "%d simultaneously search request(s) = %d mseconds");

	TBuf8<100> msg;

	msg.Format(KTrace, 1, msecOne);

    iLog->Put(msg);

    start.UniversalTime();

    StartMultipleClientsL(KNoMultipleClients);

    stop.UniversalTime();

	iAsyncSearch = EFalse;

	TInt64 msecSeveral = (stop.Int64() - start.Int64())/1000;

    msg.Format(KTrace, KNoMultipleClients, msecSeveral);

    iLog->Put(msg);

    AssertTrueSecL((msecOne*KNoMultipleClients) >= msecSeveral, KTimeErr);

    iLog->Put(_L("Testing simultaneously search syncronously and remove all syncronously"));

    iRemoveTest=ETrue;

    StartMultipleClientsL(3);

    iRemoveTest=EFalse;

    delete iDatabase;

    iDatabase = NULL;

    iDatabase = UseGeneratedDbFileL();

    iLog->Put(_L("Testing simultaneously search asyncronously"));

    iAsyncSearch =  ETrue;

    StartMultipleClientsL(KNoMultipleClients);

////

    iLog->Put(_L("Testing simultaneously search asyncronously and remove all syncronously"));

    iRemoveTest=ETrue;

    StartMultipleClientsL(3);

    }

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

// CPosTp30::StartMultipleClientsL

//

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

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

//

void CPosTp30::StartMultipleClientsL(const TUint aNoClients)

    {

    _LIT(KMultipleErr, "Error %d when multiple clients access the landmarks db");

    _LIT(KPanicErr, "Thread has panicked or is still alive when multiple clients searched the databse");

    CreateThreadsL(aNoClients);

    RArray<TRequestStatus> statuses;

    CleanupClosePushL(statuses);

    for (TUint j=0; j<aNoClients; j++)

        {

        TRequestStatus status;

        statuses.Append(status);

        }

    TInt i=0; 

    for (i=0; i<iThreads.Count(); i++)

        { 

        iThreads[i].Logon(statuses[i]);

        iThreads[i].Resume();

        }

    for (i=0; i<iThreads.Count(); i++)

        {

        User::WaitForRequest(statuses[i]);

        }

    for (i=0; i<iThreads.Count(); i++)

        {

        TInt exitReason = iThreads[i].ExitReason();

        AssertTrueSecL(exitReason == KErrNone, KMultipleErr, exitReason);

        AssertTrueSecL(iThreads[i].ExitType() == EExitKill, KPanicErr);

        }

    for (i=0; i<iThreads.Count(); i++)

        {

        iThreads[i].Close();

        }

    iThreadIndex=0;

    iThreads.Close();

    CleanupStack::PopAndDestroy(&statuses);

    }

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

// CPosTp30::RunTestL

//

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

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

//

void CPosTp30::RunTestL(TAny* aData)

    {

    _LIT(KNumOfMatchesErr, "No. of matches is incorrect when a multiple search is performed");

    CPosLandmarkDatabase* lmd = CPosLandmarkDatabase::OpenL();

    CleanupStack::PushL(lmd);

    if (lmd->IsInitializingNeeded())

       {

       ExecuteAndDeleteLD(lmd->InitializeL()); 

       }

    CPosTp30* self = reinterpret_cast<CPosTp30*>(aData);

    ++self->iThreadIndex;

    if (self->iRemoveTest && self->iThreadIndex == 3)

        {

        CPosLmOperation* lmo=NULL;

        TRAPD(err,lmo = lmd->RemoveAllLandmarksL());

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

            {

            User::Leave(err);

            }

        else if(!err)

            {

            TRAP(err, ExecuteAndDeleteLD(lmo));

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

                {

                User::Leave(err);

                }

            }

        }

    else

        {

        CPosLandmarkSearch* lms = CPosLandmarkSearch::NewL(*lmd);

        CleanupStack::PushL(lms);

        CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();

        textCriteria->SetTextL(self->iSearchResults[0]->TextCriteria());

        textCriteria->SetAttributesToSearch(self->iSearchResults[0]->Attributes());  

        textCriteria->SetPositionFieldsToSearchL(self->iSearchResults[0]->PositionFields()); 

        if (!self->iAsyncSearch)

            {

            ExecuteAndDeleteLD(lms->StartLandmarkSearchL(*textCriteria));

            }

        else

            {

            self->RunAsyncOperationLD(lms->StartLandmarkSearchL(*textCriteria));

            }

        CPosLmItemIterator* iter = lms->MatchIteratorL();

        CleanupStack::PushL(iter);

        self->AssertTrueSecL((TUint)(self->iSearchResults[0]->SearchResult()).Count() == lms->NumOfMatches(), KNumOfMatchesErr);      

        CleanupStack::PopAndDestroy(3, lms);    

        }

    CleanupStack::PopAndDestroy(lmd);

    }

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

// 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);

    TRAPD(err, CPosTp30::RunTestL(aData));

    delete actSch;

    delete cleanup;

    return err;

    }

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

// CPosTp30::CreateThreadsL

//

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

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

//

void CPosTp30::CreateThreadsL(const TUint aNoThreads)

    {

    _LIT(KThreadName, "LM test thread%d");

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

    for (TUint i=0; i<aNoThreads; i++)

        {

        RThread thread;

        TBuf<32> name;

	    name.Format(KThreadName, 1+iThreads.Count());

        TInt err;

        err = thread.Create(name, ThreadFunction, KDefaultStackSize, KMinHeapSize, KMaxHeapSize, reinterpret_cast<TAny*>(this));

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

        iThreads.Append(thread);

        }

    }

//  End of File