/*

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

#include <EPos_CPosLmCategoryCriteria.h>

#include <EPos_CPosLMItemIterator.h>    

#include "FT_CPosTp21.h"

#include "FT_CCategoryLandmarkSearchResult.h"

#include <EPos_CPosLmCatNameCriteria.h>

//CONSTANTS

const TInt KNoCategoriesTp21  = 40;

const TInt KNoLandmarksTp21 = 40; 

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

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

// CPosTp29::CloseTest

//

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

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

//

void CPosTp21::CloseTest()

    {       

    iCategories.ResetAndDestroy();

    iCategories.Close();        

    iReferencedCategories.Close();    

    iLandmarks.ResetAndDestroy();

    iLandmarks.Close();         

    delete iCategoryManager; 

    iCategoryManager = NULL;  

    delete iLandmarkSearch;

    iLandmarkSearch = NULL;    

    delete iDatabase;

    iDatabase = NULL;    

    }

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

// CPosTp21::StartL

//

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

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

//

void CPosTp21::StartL()

    {        

    iLog->Log(_L("***Testing CPosLandmarkSearch:: ( LM Search Category Criteria) *** "));

    iDatabase = CPosLandmarkDatabase::OpenL();  

    if (iDatabase->IsInitializingNeeded())

       {

       ExecuteAndDeleteLD(iDatabase->InitializeL());

       }   

    iCategoryManager = CPosLmCategoryManager::NewL(*iDatabase);    

    iLog->Log(_L("Default database initialized"));

    // Remove all the categories and landmarks from database to make it empty

    MakeEmptyLmDatabaseL( *iDatabase, *iCategoryManager);    

    // Add some landmarks to db

    // Add some categories to db

    // Add categories to lms in the database    

    AddCategoriesL();

    AddLandmarksL();    

    iLandmarkSearch = CPosLandmarkSearch::NewL(*iDatabase);

    // Test some leave codes

    iLog->Log(_L("Check that StartLandmarkSearchL leaves with correct codes "));

    SearchWithSortOrderL();   

	// Search synchronously

    iLog->Log(_L("Testing search with criterias read from LmDbSearchResult.txt syncronously, \

using CategoryName"));

    SearchL(iCategoryLandmarkSearchResults, ETrue);

    iLog->Log(_L("Testing search with criterias read from LmDbSearchResult.txt syncronously, \

using CategoryId"));

    SearchL(iCategoryLandmarkSearchResults);

    iLog->Log(_L("Searching fon nonexisting entries synchronously"));

    SearchNonExistingL(ESynchronous);    

	// Search asynchronously

    iLog->Log(_L("Testing search with criterias read from LmDbSearchResult.txt asynchronously, \

using CategoryName"));

    SearchL(iCategoryLandmarkSearchResults, ETrue, EAsynchronous);

    iLog->Log(_L("Testing search with criterias read from LmDbSearchResult.txt asynchronously, \

using Categoryid"));

    SearchL(iCategoryLandmarkSearchResults, EFalse, EAsynchronous);

    iLog->Log(_L("Searching for nonexisting entries asynchronously"));

    SearchNonExistingL(EAsynchronous);   

	// Search asynchronously using User::WaitForRequest()

    iLog->Log(_L("Testing search with criterias read from LmDbSearchResult.txt asynchronously, \

with User::WaitForRequest() using CategoryName"));

    SearchL(iCategoryLandmarkSearchResults, ETrue, EWaitForRequest);

    iLog->Log(_L("Testing search with criterias read from LmDbSearchResult.txt asynchronously, \

with User::WaitForRequest() using Categoryid"));

    SearchL(iCategoryLandmarkSearchResults, EFalse, EWaitForRequest);

    iLog->Log(_L("Searching for nonexisting entries asynchronously"));

    SearchNonExistingL(EWaitForRequest);

	// Test cancel

    iLog->Log(_L("Search and cancels the search"));

    SearchAndCancelL();

    iLog->Log(_L("Search and cancels the search in a callback"));

    SearchAndCancelL(ETrue);

	// Search in global categories

    iLog->Log(_L("SearchForLandmarksInGlobalCategoriesL asynchronously"));

    SearchForLandmarksInGlobalCategoriesL(EAsynchronous);

    iLog->Log(_L("SearchForLandmarksInGlobalCategoriesL synchronously"));

    SearchForLandmarksInGlobalCategoriesL(ESynchronous);

    iLog->Log(_L("SearchForLandmarksInGlobalCategoriesL synchronously"));

    SearchForLandmarksInGlobalCategoriesL(EWaitForRequest);   

    iLog->Log(_L("Check maximum length of search pattern"));

    TestSearchPatternLengthL();

    }

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

// CPosTp21::SearchL

//

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

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

// 

void CPosTp21::SearchL(

    const RPointerArray<CCategoryLandmarkSearchResult>& /* aSearchResults */, 

    TBool aNameOrId, 

    TExecutionMode aExecutionMode)

    {

    /*

     * Positive test cases 

     * Test for referenced category search

     */

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

    //Test SetMaxNumOfMatches, first set to one and then back to unlimited

    iLandmarkSearch->SetMaxNumOfMatches(1);

    iLandmarkSearch->SetMaxNumOfMatches();    

    TPtrC refCatName;

    TPosLmItemId refCatId(0);

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

        {

        CPosLmCategoryCriteria* catSearchCriteria = CPosLmCategoryCriteria::NewLC();

        // Perform search with either name or id

        if (aNameOrId)

            {

            // Set cearch criteria based on category name             

            TInt retErr = iReferencedCategories[i]->GetCategoryName( refCatName );

            if ( retErr == KErrNone)

                {

                catSearchCriteria->SetCategoryNameL( refCatName );

                //iLog->Log( refCatName );

                }   

            }            

        else

            {

            refCatId = iReferencedCategories[i]->CategoryId();

            catSearchCriteria->SetCategoryItemId( refCatId );

            }   

        //aSearchOnlyPreviousMatches is set to false by default    

        iOperation = iLandmarkSearch->StartLandmarkSearchL( *catSearchCriteria );         

        switch (aExecutionMode)

            {

            case ESynchronous:

                ExecuteAndDeleteLD(iOperation);

                break;

            case EAsynchronous:

                RunAsyncOperationLD(iOperation);

                break;

            case EWaitForRequest:

                RunAsyncOperationByWaitForReqL(iOperation);

                delete iOperation;

            break;

            }

        CPosLmItemIterator* iter = iLandmarkSearch->MatchIteratorL();

        CleanupStack::PushL(iter);

        /* iter->NumOfItems() contains the number of items that are contained in this search 

         *  iteration

         */  

        TPosLmItemId id = iter->NextL(); // First item from the search results

        if ( iLandmarkSearch->NumOfMatches() != iter->NumOfItemsL() )

            {

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

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

            TBuf<100> info;

            info.Format( KExpected, iter->NumOfItemsL() );

            iLog->Log( info );

            info.Format( KReturned, iLandmarkSearch->NumOfMatches() );

            iLog->Log(info);                        

            iLog->Log(KNumOfMatchesErr);            

            CleanupStack::PopAndDestroy( 2 ); // Iter,catSearchCriteria                

            User::Leave(-1);

            }

        CleanupStack::PopAndDestroy( iter );

        // Test by setting Max num of matches and also set aSearchOnlyPreviousMatches to true        

        iLandmarkSearch->SetMaxNumOfMatches(1);

        if ( aNameOrId )

            {            

            refCatId = iReferencedCategories[i]->CategoryId();

            catSearchCriteria->SetCategoryItemId( refCatId );

            }            

        else

            {

            // Set cearch criteria based on category name             

            TInt retErr = iReferencedCategories[i]->GetCategoryName( refCatName );

            if ( retErr == KErrNone)

                {

                catSearchCriteria->SetCategoryNameL( refCatName );

                //iLog->Log( refCatName );

                }                

            } 

        iOperation = iLandmarkSearch->StartLandmarkSearchL(*catSearchCriteria, ETrue);

        switch (aExecutionMode)

            {

            case ESynchronous:

                ExecuteAndDeleteLD(iOperation);

                break;

            case EAsynchronous:

                RunAsyncOperationLD(iOperation);

                break;

            case EWaitForRequest:

                RunAsyncOperationByWaitForReqL(iOperation);

                delete iOperation;

            break;

            }

        iter = iLandmarkSearch->MatchIteratorL();

        CleanupStack::PushL(iter);

        id = iter->NextL();

        if (iLandmarkSearch->NumOfMatches() != 1)

            {

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

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

            TBuf<100> info;

            info.Format(KExpected, 1);

            iLog->Log(info);

            info.Format(KReturned, iLandmarkSearch->NumOfMatches());

            iLog->Log(info);

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

            iLog->Log(catSearchCriteria->CategoryName());            

            iLog->Log(KNumOfMatchesErr);

            CleanupStack::PopAndDestroy( 2 ); // Iter,catSearchCriteria                

            User::Leave(-1);

            }   

        // Set back to unlimited

        iLandmarkSearch->SetMaxNumOfMatches();     

        CleanupStack::PopAndDestroy( 2 ); // Iter,catSearchCriteria                           

        }                 

    }

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

// CPosTp21::SearchForLandmarksInGlobalCategoriesL

//

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

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

//

void CPosTp21::SearchForLandmarksInGlobalCategoriesL(

    TExecutionMode aExecutionMode)

    {        

    iLog->Log(_L("SearchForGlobalCategoriesL"));

    TBuf<150> buf; // Buffer used for log messages

    buf.Zero(); 

    /*  

     *Default db is open in the beginning of the test procedure anyway

     *Use it for global categories related testing

     */      

    delete iLandmarkSearch;

    iLandmarkSearch = NULL;

    iLandmarkSearch = CPosLandmarkSearch::NewL(*iDatabase);

    // Using default database with global cateegories initialized    

    // Add some more landmarks

    AddLandmarksToGlobalCategoriesL();     

    CPosLmCategoryCriteria* catSearchCriteria = CPosLmCategoryCriteria::NewLC();

    // Set the criteria for global category search     

    catSearchCriteria->SetGlobalCategory( KAccommodation );    

    if ( catSearchCriteria->GlobalCategory() == KPosLmNullGlobalCategory ) // Error in setting category search criteria

        {

        iLog->Log(_L("Error in setting Search criteria for global category search"));

        buf.Format(_L("What should be set : global cat id %d, "), KAccommodation);

        buf.Format(_L("What is set now    : global cat id %d, "), catSearchCriteria->GlobalCategory() );         

        iLog->Log( buf );

        buf.Zero();

        CleanupStack::PopAndDestroy( catSearchCriteria );

        User::Leave(-1);    

        }

    iOperation = iLandmarkSearch->StartLandmarkSearchL( *catSearchCriteria );

     switch (aExecutionMode)

        {

        case ESynchronous:

            ExecuteAndDeleteLD(iOperation);

            break;

        case EAsynchronous:

            RunAsyncOperationLD(iOperation);

            break;

        case EWaitForRequest:

            RunAsyncOperationByWaitForReqL(iOperation);

            delete iOperation;

            break;

        }

    CPosLmItemIterator* iter = iLandmarkSearch->MatchIteratorL();

    CleanupStack::PushL(iter);

    /*

     * Verify the search result

     * iter->NumOfItems holds the total number of searched items in this iteration

     */

    if ( iLandmarkSearch->NumOfMatches() != iter->NumOfItemsL() )     

        {

        iLog->Log(_L("Wrong number of landmarks returned global category search (Accomodation)"));    

        buf.Format(_L("Expected : Num %d, "), iter->NumOfItemsL());

        buf.Format(_L("Found    : Num %d, "), iLandmarkSearch->NumOfMatches() );

        buf.Zero();

        CleanupStack::PopAndDestroy(iter);

        CleanupStack::PopAndDestroy(catSearchCriteria);

        User::Leave( -1 );  

        }

    CleanupStack::PopAndDestroy(iter);

    CleanupStack::PopAndDestroy(catSearchCriteria);   

    }

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

// CPosTp21::AddLandmarksToGlobalCategoriesL

//

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

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

//

void CPosTp21::AddLandmarksToGlobalCategoriesL()

    {      

    iLog->Log(_L("AddLandmarksToGlobalCategoriesL"));

    ExecuteAndDeleteLD(iDatabase->CompactL());    

    CPosLandmark* lm = NULL;

    // Add some new landmarks to the db, associate some with global categories

    // lm1

    lm = CPosLandmark::NewLC();

    lm->SetLandmarkNameL(_L("LandmarkName1"));

    lm->SetLandmarkDescriptionL(_L("SomeLandmarkDescription"));    

    lm->AddCategoryL( KAccommodation );

    lm->AddCategoryL( KBusiness );

    TPosLmItemId id = iDatabase->AddLandmarkL(*lm);

    iRestaurantId1 = id;    

    CleanupStack::PopAndDestroy(lm);

    // lm2

    lm = CPosLandmark::NewLC();

    lm->SetLandmarkNameL(_L("LandmarkName2"));

    lm->SetLandmarkDescriptionL(_L("SomeLandmarkDescription2"));    

    lm->AddCategoryL(KAccommodation );

    lm->AddCategoryL( KBusiness );

    id = iDatabase->AddLandmarkL(*lm);

    CleanupStack::PopAndDestroy(lm);

    // lm3 

    lm = CPosLandmark::NewLC();

    lm->SetLandmarkNameL(_L("LandmarkName3"));

    lm->SetLandmarkDescriptionL(_L("SomeLandmarkDescription3"));    

    lm->AddCategoryL( KAccommodation );

    lm->AddCategoryL( KBusiness );

    lm->AddCategoryL( KEducational );

    id = iDatabase->AddLandmarkL(*lm);

    CleanupStack::PopAndDestroy(lm);

    }

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

// CPosTp21::SearchNonExistingL

//

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

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

//

void CPosTp21::SearchNonExistingL(TExecutionMode aExecutionMode)

    {

    iLog->Log(_L("SearchNonExistingL"));

    CPosLmCategoryCriteria* catSearchCriteria = CPosLmCategoryCriteria::NewLC();

    catSearchCriteria->SetCategoryNameL(_L("NonExistingLandmark"));

    iOperation = iLandmarkSearch->StartLandmarkSearchL(*catSearchCriteria);        

    switch (aExecutionMode)

        {

        case ESynchronous:

            ExecuteAndDeleteLD(iOperation);

            break;

        case EAsynchronous:

            RunAsyncOperationLD(iOperation);

            break;

        case EWaitForRequest:

            RunAsyncOperationByWaitForReqL(iOperation);

            delete iOperation;

            break;

        }

    CPosLmItemIterator* iter = iLandmarkSearch->MatchIteratorL();

    CleanupStack::PushL(iter);

    TPosLmItemId id = iter->NextL();

    if (id != KPosLmNullItemId)

        {

        //LogErrorAndLeave(_L("Should return KPosLmNullItemId"));

        iLog->Log(_L("Should return KPosLmNullItemId"));

        User::Leave(-1);

        }

    CleanupStack::PopAndDestroy(iter);

    TPosLmItemId nonExistingId = 56789; 

    catSearchCriteria->SetCategoryItemId(nonExistingId);

    iOperation = iLandmarkSearch->StartLandmarkSearchL(*catSearchCriteria);

    switch (aExecutionMode)

        {

        case ESynchronous:

            ExecuteAndDeleteLD(iOperation);

            break;

        case EAsynchronous:

            RunAsyncOperationLD(iOperation);

            break;

        case EWaitForRequest:

            RunAsyncOperationByWaitForReqL(iOperation);

            delete iOperation;

            break;

        }

    iter = iLandmarkSearch->MatchIteratorL();

    CleanupStack::PushL(iter);

    id = iter->NextL();

    if (id != KPosLmNullItemId)

        {

        //LogErrorAndLeave(_L("Should return KPosLmNullItemId"));

        iLog->Log(_L("Should return KPosLmNullItemId"));

        User::Leave(-1);

        }

    CleanupStack::PopAndDestroy(iter);

    //Test with invalid id as global category id

    catSearchCriteria->SetGlobalCategory((TPosLmGlobalCategory)nonExistingId);

    iOperation = iLandmarkSearch->StartLandmarkSearchL(*catSearchCriteria);

    ExecuteAndDeleteLD(iOperation);

    iter = iLandmarkSearch->MatchIteratorL();

    CleanupStack::PushL(iter);

    id = iter->NextL();

    if (id != KPosLmNullItemId)

        {

        //LogErrorAndLeave(_L("Should return KPosLmNullItemId"));

        iLog->Log(_L("Should return KPosLmNullItemId"));

        User::Leave(-1);

        }

    CleanupStack::PopAndDestroy(iter);

    CleanupStack::PopAndDestroy(catSearchCriteria);

    }

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

// CPosTp21::SearchWithSortOrderL

//

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

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

//

void CPosTp21::SearchWithSortOrderL()

    {

    iLog->Log(_L("SearchWithSortOrderL"));

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