1 /*

     2 * Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *   ?description_line

    16 *

    17 */

    18 

    19 

    20 //  INCLUDES

    21 #include "FT_CPosTp125.h"

    22 #include <EPos_CPosLandmarkDatabase.h>

    23 #include <EPos_CPosLmMultiDbSearch.h> 

    24 #include <EPos_CPosLmTextCriteria.h>

    25 #include <EPos_CPosLmCatNameCriteria.h>

    26 #include <EPos_CPosLMItemIterator.h>    

    27 #include <EPos_TPosLMSortPref.h>

    28 #include "FT_CSearchResult.h"

    29 #include <EPos_CPosLmDatabaseManager.h>

    30 #include <EPos_CPosLmDisplayData.h>

    31 #include <EPos_CPosLmDisplayItem.h>

    32 #include "FT_LandmarkConstants.h"

    33      

    34 // CONSTANTS

    35     

    36     _LIT(KPizzeria,          "Pizzeria");           // Db 1, id  1

    37     _LIT(KHambergerbar,      "Hamburgerbar");       // Db 1, id  2        

    38     _LIT(KKinarestaurang,    "Kinarestaurang");     // Db 1, id  3

    39     _LIT(KGaraget,           "Garaget");            // Db 1, id  4

    40     _LIT(KBilverkstad,       "Bilverkstad");        // Db 1, id  5

    41     _LIT(KPastaRestaurang,   "Pasta Restaurang");   // Db 2, id  6

    42     _LIT(KBilia,             "Bilia");              // Db 2, id  7

    43     _LIT(KVolksWagen,        "VolksWagen");         // Db 2, id  8

    44     _LIT(KTaxiGoteborg,      "Taxi Göteborg");      // Db 2, id  9

    45     _LIT(KTaxi,              "Taxi");               // Db 2, id 10

    46     _LIT(KStadsbibliotek,    "Stadsbibliotek");     // Db 2, id 11

    47     _LIT(KSystembolag,       "Systembolag");        // Db 2, id 12

    48     _LIT(KNokiKontor,        "Nokia Kontor");       // Db 2, id 13

    49     _LIT(KTietoEnatorKontor, "TietoEnator kontor"); // Db 2, id 14

    50     _LIT(KThaiRestaurang,    "Thai Restaurang");    // Db 3, id 15

    51     _LIT(KMcDonalds,         "McDonalds");          // Db 3, id 16

    52     _LIT(KBurgerKing,        "BurgerKing");         // Db 3, id 17

    53     _LIT(KFrisor,            "Frisör");             // Db 3, id 18

    54     _LIT(KHunddagis,         "Hunddagis");          // Db 3, id 19

    55     _LIT(KVeterinar,         "Veterinär");          // Db 3, id 20

    56     _LIT(KKyrkogard,         "Kyrkogård");          // Db 4, id 21

    57     _LIT(KMuseum,            "Museum");             // Db 4, id 22

    58     _LIT(KDagis,             "Dagis");              // Db 4, id 23

    59     _LIT(KStadspark,         "StadsPark");          // Db 4, id 24

    60     _LIT(KSjukhus,           "Sjukhus");            // Db 5, id 25

    61     _LIT(KLakare,            "Läkare");             // Db 5, id 26

    62  

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

    64 

    65 // ---------------------------------------------------------

    66 // CPosTp125::CloseTest

    67 //

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

    69 // ---------------------------------------------------------

    70 //

    71 void CPosTp125::CloseTest()

    72     {

    73     iLog->Log(_L("CloseTest"));

    74     delete iLandmarksMultiDbSearch;

    75     iLandmarksMultiDbSearch = NULL;

    76     

    77     delete iDatabase;

    78     iDatabase=NULL;

    79 

    80     iCategorySearchResults.ResetAndDestroy();

    81 

    82     TRAPD(err, RemoveGlobalCategoriesL());

    83     TBuf<50> buf;

    84     if (err != KErrNone) 

    85         {

    86         buf.Format(_L("RemoveGlobalCategoriesL leaved with %d"), err);

    87         iLog->Log(buf);

    88         }

    89     }

    90 

    91 // ---------------------------------------------------------

    92 // CPosTp125::StartL

    93 //

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

    95 // ---------------------------------------------------------

    96 //

    97 void CPosTp125::StartL()

    98     {

    99     

   100     RemoveAllLmDatabasesL();

   101     CopyTestDbFileL(KDb20);

   102     CopyTestDbFileL(KDb40);

   103     CopyTestDbFileL(KDb60);

   104     CopyTestDbFileL(KDb80);

   105     CopyTestDbFileL(KDb105);

   106     SetupDbArrayL();

   107     

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

   109     CDesCArray* dbList = new (ELeave) CDesCArrayFlat(8);

   110     

   111     CleanupStack::PushL(dbList);

   112     

   113     dbList->AppendL(KDb20);

   114     dbList->AppendL(KDb40);

   115     dbList->AppendL(KDb60);

   116     dbList->AppendL(KDb80);

   117     dbList->AppendL(KDb105);

   118     

   119     RemoveExtraCategoriesL();

   120     

   121     iLandmarksMultiDbSearch = CPosLmMultiDbSearch::NewL(*dbList);

   122     

   123     TInt err = KErrNone;

   124     CPosLmCatNameCriteria* nameCriteria = CPosLmCatNameCriteria::NewLC();

   125     

   126     // Start by testing some error flows, returning KErrArgument

   127     TRAP(err, iLandmarksMultiDbSearch->StartCategorySearchL(*nameCriteria, CPosLmCategoryManager::ECategorySortOrderNone)); 

   128     AssertTrueSecL(err == KErrArgument, KEmptyTextCriteriaErr);

   129 

   130     // Test empty string

   131     nameCriteria->SetSearchPatternL(_L(""));   

   132     TRAP(err, iLandmarksMultiDbSearch->StartCategorySearchL(*nameCriteria, CPosLmCategoryManager::ECategorySortOrderNone));

   133     AssertTrueSecL(err == KErrArgument, KEmptyTextCriteriaErr);

   134     CleanupStack::PopAndDestroy(nameCriteria);

   135     

   136     AppendCategorySearchResultsL();

   137 

   138 // Search synchronously

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

   140     SearchL(iCategorySearchResults, ESynchronous);

   141 

   142     iLog->Log(_L("Testing search with sort order"));

   143     SearchWithSortOrderL(iCategorySearchResults, ESynchronous);

   144 

   145 

   146     iLog->Log(_L("Testing search with maximum nr of matches"));

   147     SearchWithMaximumL(iCategorySearchResults, ESynchronous);

   148 

   149 

   150 // Search asynchronously

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

   152     SearchL(iCategorySearchResults, EAsynchronous);

   153 

   154     iLog->Log(_L("Testing search with sort order asynchronously"));

   155     SearchWithSortOrderL(iCategorySearchResults, EAsynchronous);

   156 

   157     iLog->Log(_L("Testing search with maximum nr of matches asynchronously"));

   158     SearchWithMaximumL(iCategorySearchResults, EAsynchronous);

   159 

   160 // Search for added categories

   161     iLog->Log(_L("Testing search after category has been added"));

   162     SearchAfterAddedCategoryL();

   163 

   164 // Cancel search test

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

   166     SearchAndCancelL();

   167 

   168     iLog->Log(_L("Testing category search and cancel in callback"));    

   169     SearchAndCancelL(ETrue);

   170 

   171     delete iDatabase;

   172     iDatabase = NULL;

   173     delete iLandmarksMultiDbSearch;

   174     iLandmarksMultiDbSearch = NULL;

   175     CPosLmDatabaseManager* dbMan = CPosLmDatabaseManager::NewL();

   176     CleanupStack::PushL(dbMan);

   177     dbMan->SetDefaultDatabaseUriL(KDb20);

   178     

   179     iDatabase = CPosLandmarkDatabase::OpenL();

   180     iLandmarksMultiDbSearch = CPosLmMultiDbSearch::NewL(*dbList);

   181     // Do reset so that global categories are included

   182     CPosLmCategoryManager* categoryManager = CPosLmCategoryManager::NewL(*iDatabase);

   183     ExecuteAndDeleteLD(iDatabase->InitializeL());

   184     CleanupStack::PushL(categoryManager);   

   185     

   186     CleanupStack::PopAndDestroy(categoryManager);

   187 

   188     iLog->Log(_L("Testing search with global categories included, sync"));

   189     SearchGlobalL(iCategorySearchResults, ETrue);

   190 

   191     iLog->Log(_L("Testing search with global categories included, asyncronously"));

   192     SearchGlobalL(iCategorySearchResults, EFalse);

   193     

   194     // Test to add the global categories to one more DB

   195     delete iDatabase;

   196     iDatabase = NULL;

   197     delete iLandmarksMultiDbSearch;

   198     iLandmarksMultiDbSearch = NULL;

   199     dbMan->SetDefaultDatabaseUriL(KDb40);

   200     CleanupStack::PopAndDestroy(dbMan);

   201     

   202     iDatabase = CPosLandmarkDatabase::OpenL();

   203     iLandmarksMultiDbSearch = CPosLmMultiDbSearch::NewL(*dbList);

   204     // Do reset so that global categories are included

   205     CPosLmCategoryManager* categoryManager2 = CPosLmCategoryManager::NewL(*iDatabase);

   206     ExecuteAndDeleteLD(iDatabase->InitializeL());

   207     CleanupStack::PushL(categoryManager2);   

   208     CleanupStack::PopAndDestroy(categoryManager2);

   209     

   210     iLog->Log(_L("Testing search with duplicate global categories included, sync"));

   211     TestDuplicateGlobalCategoriesL(iCategorySearchResults, ETrue);

   212     

   213     iLog->Log(_L("Testing search with duplicate global categories included, async"));

   214     TestDuplicateGlobalCategoriesL(iCategorySearchResults, EFalse);

   215 

   216     RemoveGlobalCategoriesL();

   217     CleanupStack::PopAndDestroy(dbList);

   218 

   219     }

   220 

   221 // ---------------------------------------------------------

   222 // CPosTp125::SearchL

   223 //

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

   225 // ---------------------------------------------------------

   226 //

   227 void CPosTp125::SearchL(

   228     const RPointerArray<CCategorySearchResult>& aSearchResults, 

   229     TExecutionMode aExecutionMode)

   230     {

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

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

   233     

   234     CPosLmDisplayData* displayData = CPosLmDisplayData::NewL();

   235     CleanupStack::PushL(displayData);

   236     iLandmarksMultiDbSearch->SetDisplayData(*displayData);

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

   238         {   

   239         CPosLmCatNameCriteria* nameCriteria = CPosLmCatNameCriteria::NewLC();

   240         nameCriteria->SetSearchPatternL(aSearchResults[i]->TextCriteria());

   241 

   242         iOperation = iLandmarksMultiDbSearch->StartCategorySearchL(*nameCriteria, CPosLmCategoryManager::ECategorySortOrderNone); 

   243 

   244         // The execution flow

   245         switch (aExecutionMode)

   246             {

   247             case ESynchronous:

   248                 ExecuteAndDeleteLD(iOperation);

   249                 break;

   250             case EAsynchronous:

   251                 RunAsyncOperationLD(iOperation);

   252                 break;

   253             }

   254 

   255         

   256         TInt matchesSum = 0;

   257         for (TInt count = 0; count < 5; count++)

   258             {

   259             matchesSum += iLandmarksMultiDbSearch->NumOfMatches(count);

   260             }

   261             

   262             

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

   264             {

   265            	iLog->Log(KNumOfMatchesErr);

   266     		User::Leave(-1);

   267             }

   268             

   269         // Test the display data:

   270         TInt displayCount = displayData->Count();

   271         

   272         if (displayCount != matchesSum)

   273             {

   274             iLog->Log(KNumOfMatchesErr);

   275     		User::Leave(-1);

   276 

   277             }

   278             

   279         TInt count = 0;

   280         TInt dbIndex = 0;

   281         TInt categoryId = 0;

   282         TPtrC categoryName;

   283         TBuf<100> categoryName2;

   284         _LIT(KErrCatMismatch, "Category wrong in display data");

   285         _LIT(KErrorWrongType, "Display data doesn't indicate ECategoryItem when it should.");

   286         

   287         for (count = 0; count < displayCount; count++)

   288             {

   289             CPosLmDisplayItem& displayItem = displayData->DisplayItem(count);

   290             

   291             // Check that the item indicates that it contains a category

   292             AssertTrueSecL(displayItem.DisplayItemType() == CPosLmDisplayItem::ECategoryItem, KErrorWrongType);

   293             const CPosLandmarkCategory& displayCategory = displayItem.Category();

   294             dbIndex = displayItem.DatabaseIndex();

   295             categoryId = displayCategory.CategoryId();

   296             

   297             // Check that the db index is correct

   298             AssertThatIdIsInCorrectDbL(dbIndex, categoryId);

   299             

   300             // Check that this match is correct

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

   302             displayCategory.GetCategoryName(categoryName);

   303             categoryName2 = (*iDbArray)[categoryId - 1]; // Compensate for 0-index

   304             

   305             // Check that the category name is correct

   306             AssertTrueSecL(categoryName == categoryName2, KErrCatMismatch);

   307             }

   308         

   309         

   310         CPosLmItemIterator* iter = NULL;

   311         

   312         for (count = 0; count < 5; count++)

   313             {

   314             iter = iLandmarksMultiDbSearch->MatchIteratorL(count);

   315             CleanupStack::PushL(iter);

   316             

   317             TPosLmItemId id = iter->NextL();

   318             

   319             while (id != KPosLmNullItemId)

   320                 {

   321                 AssertThatIdIsInCorrectDbL(count, id);

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

   323                 id = iter->NextL();            

   324                 }

   325             CleanupStack::PopAndDestroy(iter);

   326             iter = NULL;

   327             }

   328         

   329         CleanupStack::PopAndDestroy(nameCriteria);

   330         }

   331         iLandmarksMultiDbSearch->UnsetDisplayData();

   332         CleanupStack::PopAndDestroy(displayData);

   333     }

   334 

   335 // ---------------------------------------------------------

   336 // CPosTp125::SearchWithSortOrderL

   337 //

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

   339 // ---------------------------------------------------------

   340 //

   341 void CPosTp125::SearchWithSortOrderL(

   342     const RPointerArray<CCategorySearchResult>& aSearchResults, 

   343     TExecutionMode aExecutionMode)

   344     {

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

   346     _LIT(KErrorInSorting, "Error in sorting");

   347     

   348     CPosLmCategoryManager::TCategorySortPref sortPref;

   349     

   350     CPosLmDisplayData* displayData = CPosLmDisplayData::NewL();

   351     CleanupStack::PushL(displayData);

   352     iLandmarksMultiDbSearch->SetDisplayData(*displayData);

   353 

   354     for (TInt j=0;j<2;j++)

   355         {

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

   357             {   

   358             CPosLmCatNameCriteria* nameCriteria = CPosLmCatNameCriteria::NewLC();

   359             nameCriteria->SetSearchPatternL(aSearchResults[i]->TextCriteria());

   360             

   361             if (j==0) 

   362                 {

   363                 sortPref = CPosLmCategoryManager::ECategorySortOrderNameAscending;

   364                 iOperation = iLandmarksMultiDbSearch->StartCategorySearchL(*nameCriteria, sortPref);

   365                 }

   366             else 

   367                 {

   368                 sortPref = CPosLmCategoryManager::ECategorySortOrderNameDescending;

   369                 iOperation = iLandmarksMultiDbSearch->StartCategorySearchL(*nameCriteria, sortPref);

   370                 }

   371             

   372             // The execution flow

   373             switch (aExecutionMode)

   374                 {

   375                 case ESynchronous:

   376                     ExecuteAndDeleteLD(iOperation);

   377                     break;

   378                 case EAsynchronous:

   379                     RunAsyncOperationLD(iOperation);

   380                     break;

   381                 }

   382                 

   383             TInt matchesSum = 0;

   384             for (TInt count = 0; count < 5; count++)

   385                 {

   386                 matchesSum += iLandmarksMultiDbSearch->NumOfMatches(count);

   387                 }

   388 

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

   390                 {

   391                	iLog->Log(KNumOfMatchesErr);

   392     			User::Leave(-1);

   393                 }

   394 

   395             TInt displayCount = displayData->Count();

   396             

   397             if (displayCount != matchesSum)

   398                 {

   399                 iLog->Log(KNumOfMatchesErr);

   400     			User::Leave(-1);

   401                 }

   402              

   403             // Test the display data:

   404             // Create a sorted list out of the search result

   405             RArray<TPosLmItemId> searchResults = aSearchResults[i]->SearchResult();

   406             // To avoid User-44 create a copy of the aSearchResults[i]

   407             RArray<TPosLmItemId> searchResultsSorted;

   408             CleanupClosePushL(searchResultsSorted);

   409             

   410             for (TInt kk=0;kk<searchResults.Count();kk++)

   411                 {

   412                 searchResultsSorted.Append(searchResults[kk]);

   413                 }

   414             

   415             CDesCArrayFlat* sortedArray = NULL;

   416             

   417             SortResultsL(searchResultsSorted, sortedArray);

   418             CleanupStack::PopAndDestroy(); // searchResultsSorted

   419             CleanupStack::PushL(sortedArray);

   420             

   421             if (sortPref == CPosLmCategoryManager::ECategorySortOrderNameDescending)

   422                 {

   423                 InvertArrayL(sortedArray);

   424                 }

   425             

   426             TInt count = 0;

   427             TInt categoryId = 0;

   428             TBuf<100> categoryName2;

   429             TBuf<100> categoryName3;

   430             

   431             for (count = 0; count < displayCount; count++)

   432                 {

   433                 CPosLmDisplayItem& displayItem = displayData->DisplayItem(count);

   434                 const CPosLandmarkCategory& displayCategory = displayItem.Category();

   435                 categoryId = displayCategory.CategoryId();

   436                 categoryName2 = (*iDbArray)[categoryId - 1]; // Compensate for 0-index

   437                 categoryName3 = (*sortedArray)[count];

   438                 // Check that sort order is correct

   439                 AssertTrueSecL(categoryName3 == categoryName2, _L("Error in sorting"));

   440                 }

   441                 

   442             CleanupStack::PopAndDestroy(sortedArray);   

   443                 

   444             typedef RArray<TInt> myArrayType;

   445             RArray<myArrayType> resultArray;

   446             myArrayType array1;

   447             myArrayType array2;

   448             myArrayType array3;

   449             myArrayType array4;

   450             myArrayType array5;

   451             

   452             CleanupClosePushL(resultArray);

   453             CleanupClosePushL(array1);

   454             CleanupClosePushL(array2);

   455             CleanupClosePushL(array3);

   456             CleanupClosePushL(array4);

   457             CleanupClosePushL(array5);

   458             

   459             if (sortPref == CPosLmCategoryManager::ECategorySortOrderNameAscending)

   460                 {                        

   461                 array1.AppendL(5);

   462                 array1.AppendL(4);

   463                 array1.AppendL(2);

   464                 array1.AppendL(3);

   465                 array1.AppendL(1);

   466                 

   467                 array2.AppendL(7);

   468                 array2.AppendL(13);

   469                 array2.AppendL(6);

   470                 array2.AppendL(11);

   471                 array2.AppendL(12);

   472                 array2.AppendL(10);

   473                 array2.AppendL(9);

   474                 array2.AppendL(14);

   475                 array2.AppendL(8);

   476                 

   477                 array3.AppendL(17);

   478                 array3.AppendL(18);

   479                 array3.AppendL(19);

   480                 array3.AppendL(16);

   481                 array3.AppendL(15);

   482                 array3.AppendL(20);

   483                 

   484                 array4.AppendL(23);

   485                 array4.AppendL(21);

   486                 array4.AppendL(22);

   487                 array4.AppendL(24);

   488                 

   489                 array5.AppendL(26);

   490                 array5.AppendL(25);

   491                 }

   492             else

   493                 {

   494                 array1.AppendL(1);

   495                 array1.AppendL(3);

   496                 array1.AppendL(2);

   497                 array1.AppendL(4);

   498                 array1.AppendL(5);

   499                 

   500                 array2.AppendL(8);

   501                 array2.AppendL(14);

   502                 array2.AppendL(9);

   503                 array2.AppendL(10);

   504                 array2.AppendL(12);

   505                 array2.AppendL(11);

   506                 array2.AppendL(6);

   507                 array2.AppendL(13);

   508                 array2.AppendL(7);

   509                 

   510                 array3.AppendL(20);

   511                 array3.AppendL(15);

   512                 array3.AppendL(16);

   513                 array3.AppendL(19);

   514                 array3.AppendL(18);

   515                 array3.AppendL(17);

   516                 

   517                 array4.AppendL(24);

   518                 array4.AppendL(22);

   519                 array4.AppendL(21);

   520                 array4.AppendL(23);

   521                 

   522                 array5.AppendL(25);

   523                 array5.AppendL(26);

   524                 }

   525             

   526             resultArray.Append(array1);

   527             resultArray.Append(array2);

   528             resultArray.Append(array3);

   529             resultArray.Append(array4);

   530             resultArray.Append(array5);

   531             

   532             CPosLmItemIterator* iter = NULL;

   533             

   534             for (TInt dbCount = 0; dbCount < 5; dbCount++)

   535                 {

   536                 iter = iLandmarksMultiDbSearch->MatchIteratorL(dbCount);

   537                 CleanupStack::PushL(iter);

   538                 TPosLmItemId id = iter->NextL();

   539                 TInt itemCount = 0;

   540                 while (id != KPosLmNullItemId)

   541                     {

   542                     AssertThatIdIsInCorrectDbL(dbCount, id);

   543                     // Check that sort order is correct:

   544                     // Some elements will be missing after the search, so skip those.

   545                     while (itemCount < resultArray[dbCount].Count()

   546                            && resultArray[dbCount][itemCount] != id)

   547                         {

   548                         itemCount++;

   549                         }   

   550                     // Check that a match was found in the loop above.

   551                     AssertTrueSecL(itemCount < resultArray[dbCount].Count(), KErrorInSorting);        

   552                     id = iter->NextL();

   553                     itemCount++;

   554                     }

   555                 CleanupStack::PopAndDestroy(iter);

   556                 iter = NULL;

   557                 }

   558             

   559             CleanupStack::PopAndDestroy(6); // Arrays

   560             CleanupStack::PopAndDestroy(nameCriteria);

   561             }

   562         }

   563         iLandmarksMultiDbSearch->UnsetDisplayData();

   564         CleanupStack::PopAndDestroy(displayData);

   565     }

   566     

   567 

   568 // ---------------------------------------------------------

   569 // CPosTp125::SearchWithMaximumL

   570 //

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

   572 // ---------------------------------------------------------

   573 //

   574 void CPosTp125::SearchWithMaximumL(

   575     const RPointerArray<CCategorySearchResult>& aSearchResults, 

   576     TExecutionMode aExecutionMode)

   577     {

   578     _LIT(KNumOfMatchesErr, "No. of matches is incorrect when SearchWithMaximumL is performed");

   579     _LIT(KNumOfDisplayMatchesErr, "No. of matches for the display data is incorrect when SearchWithMaximumL is performed");

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

   581 

   582     CPosLmCatNameCriteria* nameCriteria = CPosLmCatNameCriteria::NewLC();

   583     

   584     CPosLmDisplayData* displayData = CPosLmDisplayData::NewL();

   585     CleanupStack::PushL(displayData);

   586     iLandmarksMultiDbSearch->SetDisplayData(*displayData);

   587     

   588     // Set max nr of matches from 1 to 10 and check that correct nr of matches for each value

   589     for (TInt j = 1; j <= 10; j++)

   590         {

   591         nameCriteria->SetSearchPatternL(_L("*"));

   592         iLandmarksMultiDbSearch->SetMaxNumOfMatches(j);

   593         iOperation = iLandmarksMultiDbSearch->StartCategorySearchL(*nameCriteria, CPosLmCategoryManager::ECategorySortOrderNone); 

   594         

   595         // The execution flow

   596         switch (aExecutionMode)

   597             {

   598             case ESynchronous:

   599                 ExecuteAndDeleteLD(iOperation);

   600                 break;

   601             case EAsynchronous:

   602                 RunAsyncOperationLD(iOperation);

   603                 break;

   604             }

   605         

   606         TInt displayCount = displayData->Count();

   607         

   608         switch(j)

   609             {

   610             case 1:

   611             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(0) == 1, KNumOfMatchesErr);

   612             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(1) == 1, KNumOfMatchesErr);

   613             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(2) == 1, KNumOfMatchesErr);

   614             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(3) == 1, KNumOfMatchesErr);

   615             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(4) == 1, KNumOfMatchesErr);

   616             AssertTrueSecL(displayCount == 5, KNumOfDisplayMatchesErr);

   617             break;

   618             case 2:

   619             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(0) == 2, KNumOfMatchesErr);

   620             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(1) == 2, KNumOfMatchesErr);

   621             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(2) == 2, KNumOfMatchesErr);

   622             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(3) == 2, KNumOfMatchesErr);

   623             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(4) == 2, KNumOfMatchesErr);

   624             AssertTrueSecL(displayCount == 10, KNumOfDisplayMatchesErr);

   625             break;

   626             case 3:

   627             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(0) == 3, KNumOfMatchesErr);

   628             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(1) == 3, KNumOfMatchesErr);

   629             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(2) == 3, KNumOfMatchesErr);

   630             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(3) == 3, KNumOfMatchesErr);

   631             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(4) == 2, KNumOfMatchesErr);

   632             AssertTrueSecL(displayCount == 14, KNumOfDisplayMatchesErr);

   633             break;

   634             case 4:

   635             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(0) == 4, KNumOfMatchesErr);

   636             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(1) == 4, KNumOfMatchesErr);

   637             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(2) == 4, KNumOfMatchesErr);

   638             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(3) == 4, KNumOfMatchesErr);

   639             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(4) == 2, KNumOfMatchesErr);

   640             AssertTrueSecL(displayCount == 18, KNumOfDisplayMatchesErr);

   641             break;

   642             case 5:

   643             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(0) == 5, KNumOfMatchesErr);

   644             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(1) == 5, KNumOfMatchesErr);

   645             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(2) == 5, KNumOfMatchesErr);

   646             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(3) == 4, KNumOfMatchesErr);

   647             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(4) == 2, KNumOfMatchesErr);

   648             AssertTrueSecL(displayCount == 21, KNumOfDisplayMatchesErr);

   649             break;

   650             case 6:

   651             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(0) == 5, KNumOfMatchesErr);

   652             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(1) == 6, KNumOfMatchesErr);

   653             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(2) == 6, KNumOfMatchesErr);

   654             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(3) == 4, KNumOfMatchesErr);

   655             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(4) == 2, KNumOfMatchesErr);

   656             AssertTrueSecL(displayCount == 23, KNumOfDisplayMatchesErr);

   657             break;

   658             case 7:

   659             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(0) == 5, KNumOfMatchesErr);

   660             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(1) == 7, KNumOfMatchesErr);

   661             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(2) == 6, KNumOfMatchesErr);

   662             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(3) == 4, KNumOfMatchesErr);

   663             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(4) == 2, KNumOfMatchesErr);

   664             AssertTrueSecL(displayCount == 24, KNumOfDisplayMatchesErr);

   665             break;

   666             case 8:

   667             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(0) == 5, KNumOfMatchesErr);

   668             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(1) == 8, KNumOfMatchesErr);

   669             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(2) == 6, KNumOfMatchesErr);

   670             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(3) == 4, KNumOfMatchesErr);

   671             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(4) == 2, KNumOfMatchesErr);

   672             AssertTrueSecL(displayCount == 25, KNumOfDisplayMatchesErr);

   673             break;

   674             case 9:

   675             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(0) == 5, KNumOfMatchesErr);

   676             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(1) == 9, KNumOfMatchesErr);

   677             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(2) == 6, KNumOfMatchesErr);

   678             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(3) == 4, KNumOfMatchesErr);

   679             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(4) == 2, KNumOfMatchesErr);

   680             AssertTrueSecL(displayCount == 26, KNumOfDisplayMatchesErr);

   681             break;

   682             case 10:

   683             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(0) == 5, KNumOfMatchesErr);

   684             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(1) == 9, KNumOfMatchesErr);

   685             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(2) == 6, KNumOfMatchesErr);

   686             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(3) == 4, KNumOfMatchesErr);

   687             AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(4) == 2, KNumOfMatchesErr);

   688             AssertTrueSecL(displayCount == 26, KNumOfDisplayMatchesErr);

   689             break;

   690             default:

   691             break;

   692             }

   693             

   694         // Check that the DB:s actually contains correct data:

   695         CPosLmItemIterator* iter = NULL;

   696         

   697         for (TInt count = 0; count < 5; count++)

   698             {

   699             iter = iLandmarksMultiDbSearch->MatchIteratorL(count);

   700             CleanupStack::PushL(iter);

   701             

   702             TPosLmItemId id = iter->NextL();

   703             

   704             while (id != KPosLmNullItemId)

   705                 {

   706                 AssertThatIdIsInCorrectDbL(count, id);

   707                 // Use search result for position 0, should always be for *

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

   709                 id = iter->NextL();            

   710                 }

   711             CleanupStack::PopAndDestroy(iter);

   712             iter = NULL;

   713             }    

   714         }

   715     

   716     iLandmarksMultiDbSearch->UnsetDisplayData();

   717     CleanupStack::PopAndDestroy(displayData);

   718     CleanupStack::PopAndDestroy(nameCriteria);

   719     }

   720 

   721 

   722 // ---------------------------------------------------------

   723 // CPosTp125::SearchAfterAddedCategoryL

   724 //

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

   726 // ---------------------------------------------------------

   727 //

   728 void CPosTp125::SearchAfterAddedCategoryL()

   729     {

   730     // _LIT(KNumOfMatchesErr, "No. of matches is incorrect when SearchAfterAddedCategoryL is performed");

   731     _LIT(KCategoryNotFound, "Added category could not be found");

   732     _LIT(KCategory, "StoraKoncernen");

   733     

   734     CPosLmDisplayData* displayData = CPosLmDisplayData::NewL();

   735     CleanupStack::PushL(displayData);

   736     iLandmarksMultiDbSearch->SetDisplayData(*displayData);

   737 

   738     //iDatabase = CP

   739     iDatabase = CPosLandmarkDatabase::OpenL(KDb40);

   740     CPosLmCategoryManager* categoryManager = CPosLmCategoryManager::NewL(*iDatabase);

   741     CleanupStack::PushL(categoryManager);

   742     CPosLmCatNameCriteria* nameCriteria = CPosLmCatNameCriteria::NewLC();

   743 

   744     CPosLandmarkCategory* cat1 = CPosLandmarkCategory::NewLC();

   745 

   746     // First do a search with wildcard

   747     nameCriteria->SetSearchPatternL(_L("S*"));  

   748     ExecuteAndDeleteLD(iLandmarksMultiDbSearch->StartCategorySearchL(*nameCriteria, CPosLmCategoryManager::ECategorySortOrderNone)); 

   749 

   750     // Then add a new category with a name starting with S

   751     cat1->SetCategoryNameL(KCategory);

   752     TPosLmItemId categoryId = categoryManager->AddCategoryL(*cat1);

   753     CleanupStack::PopAndDestroy(cat1);

   754 

   755     // Then use do another search within the results of previous search

   756     // should return Stadsbibliotek and Stadspark

   757     nameCriteria->SetSearchPatternL(_L("St*"));

   758     ExecuteAndDeleteLD(iLandmarksMultiDbSearch->StartCategorySearchL(*nameCriteria, CPosLmCategoryManager::ECategorySortOrderNone, ETrue)); 

   759     

   760     _LIT(KErrorNrOfMatchesRefined, "Wrong nr matches after refined search after adding a category.");

   761     AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(0) == 0, KErrorNrOfMatchesRefined);

   762     AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(1) == 1, KErrorNrOfMatchesRefined); // Stadsbibliotek

   763     AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(2) == 0, KErrorNrOfMatchesRefined);

   764     AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(3) == 1, KErrorNrOfMatchesRefined); // Stadspark

   765     AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(4) == 0, KErrorNrOfMatchesRefined);

   766     AssertTrueSecL(displayData->Count() == 2, KErrorNrOfMatchesRefined);

   767     // Set a maximum number of matches, should return only one of Stadsbibliotek and Stadspark

   768     iLandmarksMultiDbSearch->SetMaxNumOfMatches(1);

   769 

   770     // Do another search just to see that it is possible to find the added category

   771     nameCriteria->SetSearchPatternL(KCategory);

   772     ExecuteAndDeleteLD(iLandmarksMultiDbSearch->StartCategorySearchL(*nameCriteria, CPosLmCategoryManager::ECategorySortOrderNone)); 

   773 

   774     AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(0) == 0, KErrorNrOfMatchesRefined);

   775     AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(1) == 1, KErrorNrOfMatchesRefined); // StoraKoncernen

   776     AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(2) == 0, KErrorNrOfMatchesRefined);

   777     AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(3) == 0, KErrorNrOfMatchesRefined);

   778     AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(4) == 0, KErrorNrOfMatchesRefined);

   779     AssertTrueSecL(displayData->Count() == 1, KErrorNrOfMatchesRefined);

   780     

   781     CPosLmItemIterator* iter = iLandmarksMultiDbSearch->MatchIteratorL(1);

   782     CleanupStack::PushL(iter);

   783     TPosLmItemId id = iter->NextL();

   784     if (categoryId != id) 

   785     {

   786     	iLog->Log(KCategoryNotFound);

   787     	User::Leave(-1);

   788     }

   789 

   790     // Remove added category

   791     ExecuteAndDeleteLD(categoryManager->RemoveCategoryL(categoryId));

   792 

   793     CleanupStack::PopAndDestroy(iter);

   794     CleanupStack::PopAndDestroy(nameCriteria);

   795     CleanupStack::PopAndDestroy(categoryManager);

   796     delete iDatabase;

   797     iDatabase = NULL;

   798     

   799     iLandmarksMultiDbSearch->UnsetDisplayData();

   800     CleanupStack::PopAndDestroy(displayData);

   801     }

   802 

   803 

   804 // ---------------------------------------------------------

   805 // CPosTp125::SearchGlobalL

   806 //

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

   808 // ---------------------------------------------------------

   809 //

   810 void CPosTp125::SearchGlobalL(const RPointerArray<CCategorySearchResult>& aSearchResults, const TBool& aSync)

   811     {

   812     iLog->Log(_L("SearchGlobalL"));

   813     _LIT(KNumOfMatchesErr, "No. of matches is incorrect when SearchGlobalL is performed");

   814 

   815     // Nr of global categories, defined in resource file

   816     //const TInt KNrOfGlobalCategories = 8;

   817 

   818     CPosLmCategoryManager* categoryManager = CPosLmCategoryManager::NewL(*iDatabase);

   819     CleanupStack::PushL(categoryManager);

   820     CPosLmCatNameCriteria* nameCriteria = CPosLmCatNameCriteria::NewLC();

   821     CPosLmCategoryManager::TCategorySortPref sortPref = CPosLmCategoryManager::ECategorySortOrderNameAscending;

   822     

   823     CPosLmDisplayData* displayData = CPosLmDisplayData::NewL();

   824     CleanupStack::PushL(displayData);

   825     iLandmarksMultiDbSearch->SetDisplayData(*displayData);

   826     

   827     for (TInt l=0;l<2;l++)

   828     {

   829         if (l==0) sortPref = CPosLmCategoryManager::ECategorySortOrderNameAscending;

   830         else if (l==1) sortPref = CPosLmCategoryManager::ECategorySortOrderNameDescending;

   831 

   832         // i=0 the first entry in aSearchResults should be wildcard "*"

   833         TInt i = 0;

   834         // First do a search with wildcard

   835         nameCriteria->SetSearchPatternL(aSearchResults[i]->TextCriteria());

   836         iOperation = iLandmarksMultiDbSearch->StartCategorySearchL(*nameCriteria, sortPref);

   837         

   838         // The asynchronous flow

   839         if (aSync)

   840         {

   841             RunAsyncOperationLD(iOperation);

   842         }

   843         else

   844         {

   845             ExecuteAndDeleteLD(iOperation);

   846         }

   847         

   848        

   849 	    SetupDbArrayL();

   850                 

   851      iDbArray->Sort();

   852         

   853      if (sortPref == CPosLmCategoryManager::ECategorySortOrderNameDescending)

   854         {

   855             InvertArrayL(iDbArray);

   856         }

   857 

   858         //TUint expNr = (aSearchResults[i]->SearchResult()).Count() + KNrOfGlobalCategories;

   859         TUint expNr = (aSearchResults[i]->SearchResult()).Count();

   860         

   861         

   862         TInt matchesSum = 0;

   863         for (TInt count = 0; count < 5; count++)

   864             {

   865             matchesSum += iLandmarksMultiDbSearch->NumOfMatches(count);

   866             }

   867        

   868         if (expNr != matchesSum)

   869             {

   870             iLog->Log(KNumOfMatchesErr);

   871     		 		User::Leave(-1);

   872             }

   873             

   874         TInt displayCount = displayData->Count();

   875         

   876         if (displayCount != matchesSum)

   877             {

   878             iLog->Log(KNumOfMatchesErr);

   879     				User::Leave(-1);

   880             }

   881         

   882         TInt count = 0;

   883         TBuf<100> categoryName2;

   884         TPtrC categoryName;

   885        	RPointerArray<CCategorySearchResult> searchResults;

   886       

   887         for (count = 0; count < displayCount; count++)

   888             {

   889             CPosLmDisplayItem& displayItem = displayData->DisplayItem(count);

   890             const CPosLandmarkCategory& displayCategory = displayItem.Category();

   891             displayCategory.GetCategoryName(categoryName);

   892             categoryName2 = (*iDbArray)[count];

   893             // Check that sort order is correct

   894             AssertTrueSecL(categoryName == categoryName2, _L("Error in sorting"));

   895             }

   896 

   897         } // end for (TInt l=0 ...)

   898         

   899     iLandmarksMultiDbSearch->UnsetDisplayData();

   900     CleanupStack::PopAndDestroy(displayData);

   901     CleanupStack::PopAndDestroy(nameCriteria);

   902     CleanupStack::PopAndDestroy(categoryManager);

   903     iLog->Log(_L("SearchGlobalL Done"));

   904     }

   905 

   906 // ---------------------------------------------------------

   907 // CPosTp24::SearchAndCancelL

   908 //

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

   910 // ---------------------------------------------------------

   911 //

   912 void CPosTp125::SearchAndCancelL(const TBool& aInCallback)

   913     {

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

   915     _LIT(KCancelErr, "The search is canceled after progress has increased but no search result is found");

   916 

   917     CPosLmDisplayData* displayData = CPosLmDisplayData::NewL();

   918     CleanupStack::PushL(displayData);

   919     iLandmarksMultiDbSearch->SetDisplayData(*displayData);

   920     

   921     // Test search with one criteria

   922     const TInt KIndex=0;

   923 

   924     CPosLmCatNameCriteria* nameCriteria = CPosLmCatNameCriteria::NewLC();

   925     nameCriteria->SetSearchPatternL(iCategorySearchResults[KIndex]->TextCriteria());

   926 

   927     if (aInCallback)

   928         {

   929         RunAsyncOperationAndCancelInCallbackLD(iLandmarksMultiDbSearch->StartCategorySearchL(

   930                 *nameCriteria, 

   931                 CPosLmCategoryManager::ECategorySortOrderNone, 

   932                 iCategorySearchResults[KIndex]->Redefined()));

   933         }

   934     else

   935         {

   936         RunAsyncOperationAndCancelLD(iLandmarksMultiDbSearch->StartCategorySearchL(

   937                 *nameCriteria, 

   938                 CPosLmCategoryManager::ECategorySortOrderNone, 

   939                 iCategorySearchResults[KIndex]->Redefined()));

   940         }

   941  

   942     

   943     

   944     if (aInCallback)

   945         {

   946         CPosLmItemIterator* iter0 = iLandmarksMultiDbSearch->MatchIteratorL(0);

   947         CleanupStack::PushL(iter0);

   948         CPosLmItemIterator* iter1 = iLandmarksMultiDbSearch->MatchIteratorL(1);

   949         CleanupStack::PushL(iter1);

   950         CPosLmItemIterator* iter2 = iLandmarksMultiDbSearch->MatchIteratorL(2);

   951         CleanupStack::PushL(iter2);

   952         CPosLmItemIterator* iter3 = iLandmarksMultiDbSearch->MatchIteratorL(3);

   953         CleanupStack::PushL(iter3);

   954         CPosLmItemIterator* iter4 = iLandmarksMultiDbSearch->MatchIteratorL(4);

   955         CleanupStack::PushL(iter4);

   956         

   957         AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(0) == iter0->NumOfItemsL(), KNumOfMatchesErr);

   958         AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(1) == iter1->NumOfItemsL(), KNumOfMatchesErr);

   959         AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(2) == iter2->NumOfItemsL(), KNumOfMatchesErr);

   960         AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(3) == iter3->NumOfItemsL(), KNumOfMatchesErr);

   961         AssertTrueSecL(iLandmarksMultiDbSearch->NumOfMatches(4) == iter4->NumOfItemsL(), KNumOfMatchesErr);

   962 

   963         AssertTrueSecL(displayData->Count() > 0, KNumOfMatchesErr);

   964 

   965         AssertTrueSecL((iter0->NumOfItemsL() + 

   966                         iter0->NumOfItemsL() + 

   967                         iter0->NumOfItemsL() + 

   968                         iter0->NumOfItemsL() + 

   969                         iter0->NumOfItemsL()) == displayData->Count(), KCancelErr);

   970              

   971         CleanupStack::PopAndDestroy(5);

   972         }

   973         

   974     

   975         

   976     CleanupStack::PopAndDestroy(nameCriteria);

   977     iLandmarksMultiDbSearch->UnsetDisplayData();

   978     CleanupStack::PopAndDestroy(displayData);

   979     }

   980     

   981 void CPosTp125::TestDuplicateGlobalCategoriesL(const RPointerArray<CCategorySearchResult>& aSearchResults, const TBool& aSync)

   982     {

   983     iLog->Log(_L("SearchGlobalL with duplicates"));

   984     _LIT(KNumOfMatchesErr, "No. of matches is incorrect when SearchGlobalL with duplicates is performed");

   985 

   986     // Nr of global categories, defined in resource file

   987     //const TInt KNrOfGlobalCategories = 15 * 2;

   988 

   989     CPosLmCategoryManager* categoryManager = CPosLmCategoryManager::NewL(*iDatabase);

   990     CleanupStack::PushL(categoryManager);

   991     CPosLmCatNameCriteria* nameCriteria = CPosLmCatNameCriteria::NewLC();

   992     CPosLmCategoryManager::TCategorySortPref sortPref = CPosLmCategoryManager::ECategorySortOrderNameAscending;

   993     

   994     CPosLmDisplayData* displayData = CPosLmDisplayData::NewL();

   995     CleanupStack::PushL(displayData);

   996     iLandmarksMultiDbSearch->SetDisplayData(*displayData);

   997     

   998     for (TInt l=0;l<2;l++)

   999     {

  1000         if (l==0) sortPref = CPosLmCategoryManager::ECategorySortOrderNameAscending;

  1001         else if (l==1) sortPref = CPosLmCategoryManager::ECategorySortOrderNameDescending;

  1002 

  1003         // i=0 the first entry in aSearchResults should be wildcard "*"

  1004         TInt i = 0;

  1005         // First do a search with wildcard

  1006         nameCriteria->SetSearchPatternL(aSearchResults[i]->TextCriteria());

  1007         iOperation = iLandmarksMultiDbSearch->StartCategorySearchL(*nameCriteria, sortPref);

  1008         

  1009         // The asynchronous flow

  1010         if (aSync)

  1011         {

  1012             RunAsyncOperationLD(iOperation);

  1013         }

  1014         else

  1015         {

  1016             ExecuteAndDeleteLD(iOperation);

  1017         }

  1018                 

  1019         SetupDbArrayL();

  1020         

  1021         iDbArray->Sort();

  1022         

  1023         if (sortPref == CPosLmCategoryManager::ECategorySortOrderNameDescending)

  1024             {

  1025             InvertArrayL(iDbArray);

  1026             }

  1027 

  1028         TUint expNr = (aSearchResults[i]->SearchResult()).Count();

  1029         

  1030         TInt matchesSum = 0;

  1031         for (TInt count = 0; count < 5; count++)

  1032             {

  1033             matchesSum += iLandmarksMultiDbSearch->NumOfMatches(count);

  1034             }

  1035         

  1036         if (expNr != matchesSum)

  1037             {

  1038             iLog->Log(KNumOfMatchesErr);

  1039     		User::Leave(-1);

  1040             }

  1041             

  1042         TInt displayCount = displayData->Count();

  1043         

  1044         if (displayCount != matchesSum)

  1045             {

  1046             iLog->Log(KNumOfMatchesErr);

  1047     		User::Leave(-1);

  1048             }

  1049         

  1050         TInt count = 0;

  1051         

  1052         TBuf<100> categoryName2;

  1053         TPtrC categoryName;

  1054         

  1055         for (count = 0; count < displayCount; count++)

  1056             {

  1057             CPosLmDisplayItem& displayItem = displayData->DisplayItem(count);

  1058             const CPosLandmarkCategory& displayCategory = displayItem.Category();

  1059             displayCategory.GetCategoryName(categoryName);

  1060             categoryName2 = (*iDbArray)[count];

  1061             // Check that sort order is correct

  1062             AssertTrueSecL(categoryName == categoryName2, _L("Error in sorting"));

  1063             }

  1064 

  1065         } // end for (TInt l=0 ...)

  1066         

  1067     iLandmarksMultiDbSearch->UnsetDisplayData();

  1068     CleanupStack::PopAndDestroy(displayData);

  1069     CleanupStack::PopAndDestroy(nameCriteria);

  1070     CleanupStack::PopAndDestroy(categoryManager);

  1071     iLog->Log(_L("SearchGlobalL Done"));

  1072     }

  1073 

  1074 void CPosTp125::RemoveExtraCategoriesL()

  1075     {

  1076     TInt err = KErrNone;

  1077     iDatabase = CPosLandmarkDatabase::OpenL(KDb20);

  1078     

  1079     if (iDatabase->IsInitializingNeeded())

  1080        {

  1081        ExecuteAndDeleteLD(iDatabase->InitializeL());               

  1082        }       

  1083        

  1084     iLog->Log(_L(" Default database opened and initialised "));     

  1085     

  1086     CPosLmCategoryManager* catMan = CPosLmCategoryManager::NewL(*iDatabase);

  1087     CleanupStack::PushL(catMan);

  1088     

  1089     ExecuteAndDeleteLD(catMan->ResetGlobalCategoriesL());    

  1090     

  1091     RemoveCategoryL(catMan, 6);

  1092     RemoveCategoryL(catMan, 7);

  1093     RemoveCategoryL(catMan, 8);

  1094     RemoveCategoryL(catMan, 9);

  1095     RemoveCategoryL(catMan, 10);

  1096     RemoveCategoryL(catMan, 11);

  1097     RemoveCategoryL(catMan, 12);

  1098     RemoveCategoryL(catMan, 13);

  1099     RemoveCategoryL(catMan, 14);

  1100     RemoveCategoryL(catMan, 15);

  1101     RemoveCategoryL(catMan, 16);

  1102     RemoveCategoryL(catMan, 17);

  1103     RemoveCategoryL(catMan, 18);

  1104     RemoveCategoryL(catMan, 19);

  1105     RemoveCategoryL(catMan, 20);

  1106     RemoveCategoryL(catMan, 21);

  1107     RemoveCategoryL(catMan, 22);

  1108     RemoveCategoryL(catMan, 23);

  1109     RemoveCategoryL(catMan, 24);

  1110     RemoveCategoryL(catMan, 25);

  1111     RemoveCategoryL(catMan, 26);

  1112     

  1113     

  1114     RemoveCategoryL(catMan, catMan->GetGlobalCategoryL(3000));

  1115     RemoveCategoryL(catMan, catMan->GetGlobalCategoryL(6000));

  1116     RemoveCategoryL(catMan, catMan->GetGlobalCategoryL(9000));

  1117     RemoveCategoryL(catMan, catMan->GetGlobalCategoryL(12000));

  1118     RemoveCategoryL(catMan, catMan->GetGlobalCategoryL(15000));

  1119     RemoveCategoryL(catMan, catMan->GetGlobalCategoryL(18000));

  1120     RemoveCategoryL(catMan, catMan->GetGlobalCategoryL(21000));

  1121     RemoveCategoryL(catMan, catMan->GetGlobalCategoryL(24000));

  1122     RemoveCategoryL(catMan, catMan->GetGlobalCategoryL(27000));

  1123     RemoveCategoryL(catMan, catMan->GetGlobalCategoryL(30000));

  1124     RemoveCategoryL(catMan, catMan->GetGlobalCategoryL(33000));

  1125     RemoveCategoryL(catMan, catMan->GetGlobalCategoryL(36000));

  1126     RemoveCategoryL(catMan, catMan->GetGlobalCategoryL(39000));

  1127     RemoveCategoryL(catMan, catMan->GetGlobalCategoryL(42000));

  1128     RemoveCategoryL(catMan, catMan->GetGlobalCategoryL(45000));

  1129     

  1130     CleanupStack::PopAndDestroy(catMan);

  1131     delete iDatabase;

  1132     iDatabase = NULL;

  1133      

  1134     

  1135     iDatabase = CPosLandmarkDatabase::OpenL(KDb40);