/*

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

#include "FT_LandmarkConstants.h"

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLmCategoryManager.h>

#include <EPos_CPosLmTextCriteria.h>

#include <EPos_CPosLmDisplayData.h>

// CONSTANTS  

const TInt KNrOfDbs = 5;

const TInt KLmPerDb = 20;

const TInt KTotLms = 105;

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

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

// CPosTp101::CloseTest

//

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

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

//

void CPosTp101::CloseTest()

    {

    delete iDatabase;

    iDatabase = NULL;

    delete iDbArray;

    delete iLmMultiSearch;

    iLmMultiSearch = NULL;

    iSearchResults.ResetAndDestroy();

    REComSession::FinalClose();

    }

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

// CPosTp101::StartL

//

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

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

//

void CPosTp101::StartL()

    {    

    // Split databases, NrOfDBs db, LmPerDb lm in each, TotLms is last lm id from original db, debug

    iDbArray = CreateDatabasesL(KNrOfDbs, KLmPerDb, KTotLms); //, ETrue);    

    // Check setting of databases is correct

    // Should be move to TC119 - Multi Db - Extended testing

    VerifySetOfDatabasesL();

    // Constructing a lm multi search 

    iLmMultiSearch = CPosLmMultiDbSearch::NewL(*iDbArray);

    // Check that iterator is NOT NULL before search has started (and that iterator is empty)

    for (TInt i=0;i<iDbArray->Count();i++)

    	{

    	CPosLmItemIterator* iter = iLmMultiSearch->MatchIteratorL(i);

    	CleanupStack::PushL(iter);

    	AssertTrueSecL(iter->NumOfItemsL() == 0, _L("Iterator should be empty"));

    	CleanupStack::PopAndDestroy(iter);

    	}

    // Read search information from file    

    AppendSearchResultsL();

    // Do the search testing     

    iLog->Log(_L("Testing multi db search with criterias read from LmDbSearchResult.txt syncronously"));

    SearchL(iSearchResults, ESynchronous);

    iLog->Log(_L("Testing multi db search with criterias read from LmDbSearchResult.txt asyncronously"));

    SearchL(iSearchResults, EAsynchronous);

    // Not possible to use User::WaitForRequest when using Multi Db search!

    // iLog->Log(_L("Testing multi db search with criterias read from LmDbSearchResult.txt asyncronously using User::WaitForRequest"));

    // SearchL(SearchResults(), EWaitForRequest);

    iLog->Log(_L("Testing search with a defined sortorder"));

    SearchWithSortOrderL(iSearchResults);   

    iLog->Log(_L("Testing search and cancel"));

    SearchAndCancelL();

    iLog->Log(_L("Testing maximum number of matches"));

    SearchWithMaximumL(iSearchResults);

    iLog->Log(_L("Testing searching on the fly"));

    OnTheFlySearchL();

    iLog->Log(_L("Testing search after a landmark has been removed"));

    SearchAndDeleteL(iSearchResults);

    iLog->Log(_L("Testing search after landmarks have been renamed"));

    SearchAndRenameL(iSearchResults);

    // Test specific Text Criteria error case

    TUint attr = CPosLandmark::ELandmarkName | CPosLandmark::EDescription;

    CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();

    textCriteria->SetAttributesToSearch(attr);

    textCriteria->SetTextL(_L(""));

    _LIT(KEmptyTextCriteriaErr, "An empty string as text criteria should not be allowed");

    TRAPD(err, iLmMultiSearch->StartLandmarkSearchL(*textCriteria)); 

    AssertTrueSecL(err == KErrArgument, KEmptyTextCriteriaErr);

    CleanupStack::PopAndDestroy(textCriteria);

    delete iLmMultiSearch;

    iLmMultiSearch = NULL;

    // Constructing a lm multi search 

    iLmMultiSearch = CPosLmMultiDbSearch::NewL(*iDbArray);

    // Check that iterator is NOT NULL before search has started (and that iterator is empty)

    for (TInt i=0;i<iDbArray->Count();i++)

    	{

    	CPosLmItemIterator* iter = iLmMultiSearch->MatchIteratorL(i);

    	CleanupStack::PushL(iter);

    	AssertTrueSecL(iter->NumOfItemsL() == 0, _L("Iterator should be empty"));

    	CleanupStack::PopAndDestroy(iter);

    	}

	}

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

// CPosTp101::VerifySetOfDatabasesL

//

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

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

//

void CPosTp101::VerifySetOfDatabasesL()

    {

    // Testing error situations for multi db search

    _LIT(KEmptyError, "KErrArgument should be returned when no db's are specified.");

    CDesCArray* emptyArray = new (ELeave) CDesCArrayFlat(5); 

    CleanupStack::PushL(emptyArray);

    TRAPD(err, CPosLmMultiDbSearch::NewL(*emptyArray));

    AssertTrueSecL(err == KErrArgument, KEmptyError);

    CDesCArray* duplicateArray = new (ELeave) CDesCArrayFlat(5); 

    CleanupStack::PushL(duplicateArray);

    duplicateArray->AppendL(_L("eposlm.ldb"));

    duplicateArray->AppendL(_L("c:eposlm.ldb"));

    duplicateArray->AppendL(_L("file://c:eposlm.ldb"));

    VerifyDatabaseL(duplicateArray);

    duplicateArray->Reset();

    duplicateArray->AppendL(_L("eposlm.ldb"));

    duplicateArray->AppendL(_L("eposlm.ldb"));

    duplicateArray->AppendL(_L("eposlm.ldb"));

    VerifyDatabaseL(duplicateArray);

    CDesCArray* dupArray = new (ELeave) CDesCArrayFlat(5); 

    CleanupStack::PushL(dupArray);

    dupArray->AppendL(_L("eposlm.ldb"));

    dupArray->AppendL(_L("eposlm.ldb"));

    dupArray->AppendL(_L("eposlm.ldb"));

    dupArray->AppendL(_L("eposlm.ldb"));

    VerifyDatabaseL(duplicateArray, dupArray);

    dupArray->Reset();

    dupArray->AppendL(_L("eposlm.ldb"));

    dupArray->AppendL(_L("eposlm.ldb"));

    VerifyDatabaseL(duplicateArray, dupArray);

    CleanupStack::PopAndDestroy(dupArray);

    CleanupStack::PopAndDestroy(duplicateArray);

    // Check setting of empty databases

    iLmMultiSearch = CPosLmMultiDbSearch::NewL(*iDbArray);

    TRAP(err, iLmMultiSearch->SetDatabasesToSearchL(*emptyArray));

    AssertTrueSecL(err == KErrArgument, KEmptyError);

    CleanupStack::PopAndDestroy(emptyArray);

    delete iLmMultiSearch;

    VerifyDatabaseL(iDbArray);    

    }

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

// CPosTp101::VerifyDatabaseL

//

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

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

//

void CPosTp101::VerifyDatabaseL(

    CDesCArray* aLmUris, 

    CDesCArray* aNewLmUris)

    {

    iLmMultiSearch = CPosLmMultiDbSearch::NewL(*aLmUris);

    CheckDatabasesL(aLmUris);

    if (aNewLmUris)

        {

        iLmMultiSearch->SetDatabasesToSearchL(*aNewLmUris);

        CheckDatabasesL(aNewLmUris);

        }

    delete iLmMultiSearch;

    }

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

// CPosTp101::CheckDatabasesL

//

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

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

//

void CPosTp101::CheckDatabasesL(

    CDesCArray* aExpectedLmUris,

    TUint aExpectedMaxMatches)

    {

    CDesCArray* dbToSearch = iLmMultiSearch->DatabasesToSearchL();

    CleanupStack::PushL(dbToSearch);

    _LIT(KWrongNrDatabases, "Wrong number of databases to search!");

    AssertTrueSecL(aExpectedLmUris != dbToSearch, KWrongNrDatabases);

    AssertTrueSecL(aExpectedLmUris->Count() == dbToSearch->Count(), KWrongNrDatabases);

    CleanupStack::PopAndDestroy(dbToSearch);

    AssertTrueSecL(aExpectedLmUris->Count() == iLmMultiSearch->NumOfDatabasesToSearch(), 

        KWrongNrDatabases);

    for (TInt i=0; i<aExpectedLmUris->Count(); i++)

        {

        AssertTrueSecL(aExpectedLmUris->MdcaPoint(i) == iLmMultiSearch->DatabaseUriPtr(i), 

            KWrongNrDatabases);        

        }

    _LIT(KWrongNrMatches, "Wrong number of max matches!");

    AssertTrueSecL(iLmMultiSearch->MaxNumOfMatches() == aExpectedMaxMatches, 

        KWrongNrMatches);        

    }

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

// CPosTp101::SearchL

//

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

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

//

void CPosTp101::SearchL(

    const RPointerArray<CSearchResult>& aSearchResults, 

    TExecutionMode aExecutionMode)

    {

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

    _LIT(KNotFoundErr, "Id %d not found in parsed Lm search results when the search is performed syncronously");

    _LIT(KSearchNr, "Multi search test #%d executed ok.");

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

        {   

        CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();

        textCriteria->SetTextL(aSearchResults[i]->TextCriteria());

        textCriteria->SetAttributesToSearch(aSearchResults[i]->Attributes());

        textCriteria->SetPositionFieldsToSearchL(aSearchResults[i]->PositionFields()); 

        CPosLmOperation* operation = 

            iLmMultiSearch->StartLandmarkSearchL(*textCriteria, aSearchResults[i]->Redefined());

        CleanupStack::PushL(operation);

         switch (aExecutionMode)

            {

            case ESynchronous:

                ExecuteAndDeleteLD(operation);

                CleanupStack::Pop(operation);

                break;

            case EAsynchronous:

                RunAsyncOperationLD(operation);

                CleanupStack::Pop(operation);

                break;

            case EWaitForRequest:

                RunAsyncOperationByWaitForReqL(operation);

                CleanupStack::PopAndDestroy(operation);                

                break;

            }

        // Check database array

        CheckDatabasesL(iDbArray);

        // Check for errors        

        AssertTrueSecL(iLmMultiSearch->NumOfSearchErrors() == 0, 

            _L("Error(s) found during multi search."));

        // Check total number of matches       

        if ((TUint)(aSearchResults[i]->SearchResult()).Count() != 

            iLmMultiSearch->TotalNumOfMatches())

            {

            _LIT(KExpected, "Expected no. of matches: %d");

            _LIT(KReturned, "Returned no. of matches: %d");

            TBuf<100> info;

            info.Format(KExpected, (aSearchResults[i]->SearchResult()).Count());

            iLog->Log(info);

            info.Format(KReturned, iLmMultiSearch->TotalNumOfMatches());

            iLog->Log(info);

            iLog->Log(_L("Search criteria: "));

            iLog->Log(textCriteria->Text());

            iLog->Log(KNumOfMatchesErr);

            User::Leave(-1);

            }

        RArray<TPosLmItemId> lmids;

        CleanupClosePushL(lmids);

        for (TInt j=0; j<iLmMultiSearch->NumOfDatabasesToSearch(); j++) 

            {

            CPosLmItemIterator* iter = iLmMultiSearch->MatchIteratorL(j);

            // Check if there are any matches = iteration exists.

            if (iter) 

                {

                CleanupStack::PushL(iter);

                TPosLmItemId id = iter->NextL();    

                while (id != KPosLmNullItemId)

                    {

                    // Check that found id is expected

                    AssertTrueSecL(aSearchResults[i]->FindSearchResult(id), KNotFoundErr);

                    User::LeaveIfError(lmids.Append(id));                              

                    id = iter->NextL();

                    }

                CleanupStack::PopAndDestroy(iter);                

                }

            else 

                {

                _LIT(KIterNull, "MatchIterator returned null for a db");

                iLog->Log(KIterNull);

                }

            }

        AssertTrueSecL(aSearchResults[i]->SearchResult().Count() == lmids.Count(), 

            _L("Expected number of hits and found hits don't match"));

        for (TInt k=0; k<lmids.Count(); k++)

            {

            // Check that found id is expected from all ids

            AssertTrueSecL(aSearchResults[i]->FindSearchResult(lmids[k]), KNotFoundErr);

            }

        CleanupStack::PopAndDestroy(&lmids); // lmids

        CleanupStack::PopAndDestroy(textCriteria); 

        TBuf<100> buf;

        buf.Format(KSearchNr, i);        

        iLog->Log(buf);            

        }

    }

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

// CPosTp101::SearchWithSortOrderL

//

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

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

//

void CPosTp101::SearchWithSortOrderL(const RPointerArray<CSearchResult>& aSearchResults)

    {

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

    TPosLmSortPref sortPref(CPosLandmark::ELandmarkName, TPosLmSortPref::EAscending);  

    CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();

    for(TInt j=0; j<aSearchResults.Count(); j++)

        {   

        textCriteria->SetTextL(aSearchResults[j]->TextCriteria());

        textCriteria->SetAttributesToSearch(aSearchResults[j]->Attributes());

        textCriteria->SetPositionFieldsToSearchL(aSearchResults[j]->PositionFields()); 

        iLog->Log(aSearchResults[j]->TextCriteria());

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

            {

            switch (i)

                {

                //**** sync

                case 0:

                    sortPref.SetSortByLandmarkAttribute(CPosLandmark::ELandmarkName, TPosLmSortPref::EAscending);

                    ExecuteAndDeleteLD(iLmMultiSearch->StartLandmarkSearchL(

                        *textCriteria, 

                        sortPref, 

                        aSearchResults[j]->Redefined()));

                    break;

                case 1:

                    sortPref.SetSortByLandmarkAttribute(CPosLandmark::ELandmarkName, TPosLmSortPref::EDescending);

                    ExecuteAndDeleteLD(iLmMultiSearch->StartLandmarkSearchL(

                        *textCriteria, 

                        sortPref, 

                        aSearchResults[j]->Redefined()));

                    break;

                case 2:

                //**** async

                    sortPref.SetSortByLandmarkAttribute(CPosLandmark::ELandmarkName, TPosLmSortPref::EDescending);

                    RunAsyncOperationLD(iLmMultiSearch->StartLandmarkSearchL(

                        *textCriteria, 

                        sortPref, 

                        aSearchResults[j]->Redefined()));

                    break;

                case 3:

                    sortPref.SetSortByLandmarkAttribute(CPosLandmark::ELandmarkName, TPosLmSortPref::EAscending);

                    RunAsyncOperationLD(iLmMultiSearch->StartLandmarkSearchL(

                        *textCriteria, 

                        sortPref, 

                        aSearchResults[j]->Redefined()));

                    break;

                //**** asych with User::WaitForRequest()

                case 4:

                    {

                    CPosLmOperation* op = iLmMultiSearch->StartLandmarkSearchL(

                        *textCriteria, 

                        sortPref, 

                        aSearchResults[j]->Redefined());

                    CleanupStack::PushL(op);

                    RunAsyncOperationByWaitForReqL(op);

                    CleanupStack::PopAndDestroy(op);

                    }

                    break;

                case 5:

                    {

                    sortPref.SetSortByLandmarkAttribute(CPosLandmark::ELandmarkName, TPosLmSortPref::EAscending);

                    CPosLmOperation* op = iLmMultiSearch->StartLandmarkSearchL(

                        *textCriteria, 

                        sortPref, 

                        aSearchResults[j]->Redefined());

                    CleanupStack::PushL(op);

                    RunAsyncOperationByWaitForReqL(op);

                    CleanupStack::PopAndDestroy(op);

                    }

                    break;

                }

            }

        // Check database array

        CheckDatabasesL(iDbArray);

        // Check for errors        

        AssertTrueSecL(iLmMultiSearch->NumOfSearchErrors() == 0, 

            _L("Error(s) found during multi search."));

        // Check total number of matches       

        if ((TUint)(aSearchResults[j]->SearchResult()).Count() != 

            iLmMultiSearch->TotalNumOfMatches())

            {

            _LIT(KExpected, "Expected no. of matches: %d");

            _LIT(KReturned, "Returned no. of matches: %d");

            TBuf<100> info;

            info.Format(KExpected, (aSearchResults[j]->SearchResult()).Count());

            iLog->Log(info);

            info.Format(KReturned, iLmMultiSearch->TotalNumOfMatches());

            iLog->Log(info);

            iLog->Log(_L("Search criteria: "));

            iLog->Log(textCriteria->Text());

            iLog->Log(KNumOfMatchesErr);

            User::Leave(-1);

            }

        RArray<TPosLmItemId>* searchResults = &aSearchResults[j]->SearchResult();        

        for (TInt n=0; n<iLmMultiSearch->NumOfDatabasesToSearch(); n++) 

            {

            RArray<TPosLmItemId> lmids;

            CleanupClosePushL(lmids);

            GetLmIdsL(n, *searchResults, lmids);            

            iDatabase = CPosLandmarkDatabase::OpenL(iLmMultiSearch->DatabaseUriPtr(n));

            if (iDatabase->IsInitializingNeeded())

           {

           ExecuteAndDeleteLD(iDatabase->InitializeL());

           }

            LandmarksSortL(lmids, sortPref);

            CPosLmItemIterator* iter = iLmMultiSearch->MatchIteratorL(n);

            // Check if there are any matches = iteration exists.

            if (iter) 

                {

                CleanupStack::PushL(iter);

                TInt lmid = 0;

                TPosLmItemId id = iter->NextL();

                while (id != KPosLmNullItemId)

                    {

                    CheckEqualsLmsL(id, lmids[lmid]);

                    id = iter->NextL();

                    ++lmid;

                    }

                CleanupStack::PopAndDestroy(iter);

                }

            else 

                {

                _LIT(KIterNull, "MatchIterator returned null for a db");

                iLog->Log(KIterNull);

                }

            delete iDatabase;

            iDatabase = NULL;

            CleanupStack::PopAndDestroy(&lmids);

            }

        }

    CleanupStack::PopAndDestroy(textCriteria);

    }

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

// CPosTp101::GetLmIdsL

//

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

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