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 

    22 #include "FT_CPosTp101.h"

    23 #include "FT_LandmarkConstants.h"

    24 #include <EPos_CPosLandmarkDatabase.h>

    25 #include <EPos_CPosLmCategoryManager.h>

    26 #include <EPos_CPosLmTextCriteria.h>

    27 #include <EPos_CPosLmDisplayData.h>

    28 

    29 // CONSTANTS  

    30 const TInt KNrOfDbs = 5;

    31 const TInt KLmPerDb = 20;

    32 const TInt KTotLms = 105;

    33 

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

    35 

    36 // ---------------------------------------------------------

    37 // CPosTp101::CloseTest

    38 //

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

    40 // ---------------------------------------------------------

    41 //

    42 void CPosTp101::CloseTest()

    43     {

    44     delete iDatabase;

    45     iDatabase = NULL;

    46     

    47     delete iDbArray;

    48 

    49     delete iLmMultiSearch;

    50     iLmMultiSearch = NULL;

    51     

    52     iSearchResults.ResetAndDestroy();

    53     

    54     REComSession::FinalClose();

    55     }

    56     

    57 // ---------------------------------------------------------

    58 // CPosTp101::StartL

    59 //

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

    61 // ---------------------------------------------------------

    62 //

    63 void CPosTp101::StartL()

    64     {    

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

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

    67     

    68     

    69     // Check setting of databases is correct

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

    71     VerifySetOfDatabasesL();

    72 

    73     // Constructing a lm multi search 

    74     iLmMultiSearch = CPosLmMultiDbSearch::NewL(*iDbArray);

    75     

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

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

    78     	{

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

    80     	CleanupStack::PushL(iter);

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

    82     	CleanupStack::PopAndDestroy(iter);

    83     	}

    84     

    85     // Read search information from file    

    86     AppendSearchResultsL();

    87 

    88     // Do the search testing     

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

    90     SearchL(iSearchResults, ESynchronous);

    91 

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

    93     SearchL(iSearchResults, EAsynchronous);

    94 

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

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

    97     // SearchL(SearchResults(), EWaitForRequest);

    98 

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

   100     SearchWithSortOrderL(iSearchResults);   

   101 

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

   103     SearchAndCancelL();

   104    

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

   106     SearchWithMaximumL(iSearchResults);

   107 

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

   109     OnTheFlySearchL();

   110 

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

   112     SearchAndDeleteL(iSearchResults);

   113 

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

   115     SearchAndRenameL(iSearchResults);

   116 

   117 

   118     // Test specific Text Criteria error case

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

   120     CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();

   121     textCriteria->SetAttributesToSearch(attr);

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

   123 

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

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

   126     AssertTrueSecL(err == KErrArgument, KEmptyTextCriteriaErr);

   127 

   128     CleanupStack::PopAndDestroy(textCriteria);

   129     

   130     delete iLmMultiSearch;

   131     iLmMultiSearch = NULL;

   132     // Constructing a lm multi search 

   133     iLmMultiSearch = CPosLmMultiDbSearch::NewL(*iDbArray);

   134     

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

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

   137     	{

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

   139     	CleanupStack::PushL(iter);

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

   141     	CleanupStack::PopAndDestroy(iter);

   142     	}

   143 	}

   144 

   145 // ---------------------------------------------------------

   146 // CPosTp101::VerifySetOfDatabasesL

   147 //

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

   149 // ---------------------------------------------------------

   150 //

   151 void CPosTp101::VerifySetOfDatabasesL()

   152     {

   153     // Testing error situations for multi db search

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

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

   156     CleanupStack::PushL(emptyArray);

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

   158     AssertTrueSecL(err == KErrArgument, KEmptyError);

   159 

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

   161     CleanupStack::PushL(duplicateArray);

   162 

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

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

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

   166 

   167     VerifyDatabaseL(duplicateArray);

   168     

   169     duplicateArray->Reset();

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

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

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

   173 

   174     VerifyDatabaseL(duplicateArray);

   175 

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

   177     CleanupStack::PushL(dupArray);

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

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

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

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

   182    

   183     VerifyDatabaseL(duplicateArray, dupArray);

   184 

   185     dupArray->Reset();

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

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

   188 

   189     VerifyDatabaseL(duplicateArray, dupArray);

   190    

   191     CleanupStack::PopAndDestroy(dupArray);

   192     CleanupStack::PopAndDestroy(duplicateArray);

   193 

   194     // Check setting of empty databases

   195     iLmMultiSearch = CPosLmMultiDbSearch::NewL(*iDbArray);

   196  

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

   198     AssertTrueSecL(err == KErrArgument, KEmptyError);

   199     CleanupStack::PopAndDestroy(emptyArray);

   200     delete iLmMultiSearch;

   201 

   202     VerifyDatabaseL(iDbArray);    

   203     }

   204 

   205 // ---------------------------------------------------------

   206 // CPosTp101::VerifyDatabaseL

   207 //

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

   209 // ---------------------------------------------------------

   210 //

   211 void CPosTp101::VerifyDatabaseL(

   212     CDesCArray* aLmUris, 

   213     CDesCArray* aNewLmUris)

   214     {

   215     iLmMultiSearch = CPosLmMultiDbSearch::NewL(*aLmUris);

   216     CheckDatabasesL(aLmUris);

   217     

   218     if (aNewLmUris)

   219         {

   220         iLmMultiSearch->SetDatabasesToSearchL(*aNewLmUris);

   221         CheckDatabasesL(aNewLmUris);

   222         }

   223         

   224     delete iLmMultiSearch;

   225     }

   226 

   227 // ---------------------------------------------------------

   228 // CPosTp101::CheckDatabasesL

   229 //

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

   231 // ---------------------------------------------------------

   232 //

   233 void CPosTp101::CheckDatabasesL(

   234     CDesCArray* aExpectedLmUris,

   235     TUint aExpectedMaxMatches)

   236     {

   237     CDesCArray* dbToSearch = iLmMultiSearch->DatabasesToSearchL();

   238     CleanupStack::PushL(dbToSearch);

   239     

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

   241     AssertTrueSecL(aExpectedLmUris != dbToSearch, KWrongNrDatabases);

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

   243     CleanupStack::PopAndDestroy(dbToSearch);

   244     

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

   246         KWrongNrDatabases);

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

   248         {

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

   250             KWrongNrDatabases);        

   251         }

   252     

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

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

   255         KWrongNrMatches);        

   256     }

   257     

   258 // ---------------------------------------------------------

   259 // CPosTp101::SearchL

   260 //

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

   262 // ---------------------------------------------------------

   263 //

   264 void CPosTp101::SearchL(

   265     const RPointerArray<CSearchResult>& aSearchResults, 

   266     TExecutionMode aExecutionMode)

   267     {

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

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

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

   271 

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

   273         {   

   274         CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();

   275         

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

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

   278         

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

   280 

   281         CPosLmOperation* operation = 

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

   283         CleanupStack::PushL(operation);

   284          switch (aExecutionMode)

   285             {

   286             case ESynchronous:

   287                 ExecuteAndDeleteLD(operation);

   288                 CleanupStack::Pop(operation);

   289                 break;

   290             case EAsynchronous:

   291                 RunAsyncOperationLD(operation);

   292                 CleanupStack::Pop(operation);

   293                 break;

   294             case EWaitForRequest:

   295                 RunAsyncOperationByWaitForReqL(operation);

   296                 CleanupStack::PopAndDestroy(operation);                

   297                 break;

   298             }

   299 

   300         // Check database array

   301         CheckDatabasesL(iDbArray);

   302 

   303         // Check for errors        

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

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

   306 

   307         // Check total number of matches       

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

   309             iLmMultiSearch->TotalNumOfMatches())

   310             {

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

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

   313             TBuf<100> info;

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

   315             iLog->Log(info);

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

   317             iLog->Log(info);

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

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

   320             iLog->Log(KNumOfMatchesErr);

   321             User::Leave(-1);

   322             }

   323 

   324         RArray<TPosLmItemId> lmids;

   325         CleanupClosePushL(lmids);

   326 

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

   328             {

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

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

   331             if (iter) 

   332                 {

   333                 CleanupStack::PushL(iter);

   334                 TPosLmItemId id = iter->NextL();    

   335                 while (id != KPosLmNullItemId)

   336                     {

   337                     // Check that found id is expected

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

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

   340                     id = iter->NextL();

   341                     }

   342                 CleanupStack::PopAndDestroy(iter);                

   343                 }

   344             else 

   345                 {

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

   347                 iLog->Log(KIterNull);

   348                 }

   349             }

   350 

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

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

   353 

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

   355             {

   356             // Check that found id is expected from all ids

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

   358             }

   359 

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

   361 

   362         CleanupStack::PopAndDestroy(textCriteria); 

   363         

   364         TBuf<100> buf;

   365         buf.Format(KSearchNr, i);        

   366         iLog->Log(buf);            

   367         }

   368     }

   369 

   370 // ---------------------------------------------------------

   371 // CPosTp101::SearchWithSortOrderL

   372 //

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

   374 // ---------------------------------------------------------

   375 //

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

   377     {

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

   379     

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

   381     CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();

   382 

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

   384         {   

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

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

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

   388 

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

   390         

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

   392             {

   393             switch (i)

   394                 {

   395                 //**** sync

   396                 case 0:

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

   398                     ExecuteAndDeleteLD(iLmMultiSearch->StartLandmarkSearchL(

   399                         *textCriteria, 

   400                         sortPref, 

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

   402                     break;

   403                 case 1:

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

   405                     ExecuteAndDeleteLD(iLmMultiSearch->StartLandmarkSearchL(

   406                         *textCriteria, 

   407                         sortPref, 

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

   409                     break;

   410                 case 2:

   411                 //**** async

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

   413                     RunAsyncOperationLD(iLmMultiSearch->StartLandmarkSearchL(

   414                         *textCriteria, 

   415                         sortPref, 

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

   417                     break;

   418                 case 3:

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

   420                     RunAsyncOperationLD(iLmMultiSearch->StartLandmarkSearchL(

   421                         *textCriteria, 

   422                         sortPref, 

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

   424                     break;

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

   426                 case 4:

   427                     {

   428                     CPosLmOperation* op = iLmMultiSearch->StartLandmarkSearchL(

   429                         *textCriteria, 

   430                         sortPref, 

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

   432                     CleanupStack::PushL(op);

   433                     RunAsyncOperationByWaitForReqL(op);

   434                     CleanupStack::PopAndDestroy(op);

   435                     }

   436                     break;

   437                 case 5:

   438                     {

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

   440                     CPosLmOperation* op = iLmMultiSearch->StartLandmarkSearchL(

   441                         *textCriteria, 

   442                         sortPref, 

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

   444                     CleanupStack::PushL(op);

   445                     RunAsyncOperationByWaitForReqL(op);

   446                     CleanupStack::PopAndDestroy(op);

   447                     }

   448                     break;

   449                 }

   450             }

   451             

   452         // Check database array

   453         CheckDatabasesL(iDbArray);

   454 

   455         // Check for errors        

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

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

   458 

   459         // Check total number of matches       

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

   461             iLmMultiSearch->TotalNumOfMatches())

   462             {

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

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

   465             TBuf<100> info;

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

   467             iLog->Log(info);

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

   469             iLog->Log(info);

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

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

   472             iLog->Log(KNumOfMatchesErr);

   473             User::Leave(-1);

   474             }

   475         

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

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

   478             {

   479             RArray<TPosLmItemId> lmids;

   480             CleanupClosePushL(lmids);

   481             GetLmIdsL(n, *searchResults, lmids);            

   482 

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

   484             if (iDatabase->IsInitializingNeeded())

   485            {

   486            ExecuteAndDeleteLD(iDatabase->InitializeL());

   487            }

   488             LandmarksSortL(lmids, sortPref);

   489         

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

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

   492             if (iter) 

   493                 {

   494                 CleanupStack::PushL(iter);

   495                 TInt lmid = 0;

   496                 TPosLmItemId id = iter->NextL();

   497         

   498                 while (id != KPosLmNullItemId)

   499                     {

   500                     CheckEqualsLmsL(id, lmids[lmid]);

   501                     

   502                     id = iter->NextL();

   503                     ++lmid;

   504                     }

   505                 CleanupStack::PopAndDestroy(iter);

   506                 }

   507             else 

   508                 {

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

   510                 iLog->Log(KIterNull);

   511                 }

   512                 

   513             delete iDatabase;

   514             iDatabase = NULL;

   515             

   516             CleanupStack::PopAndDestroy(&lmids);

   517             }

   518 

   519         }

   520         

   521     CleanupStack::PopAndDestroy(textCriteria);

   522     }

   523 

   524 // ---------------------------------------------------------

   525 // CPosTp101::GetLmIdsL

   526 //

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

   528 // ---------------------------------------------------------

   529 //

   530 void CPosTp101::GetLmIdsL(

   531     TInt aDbId, 

   532     RArray<TPosLmItemId> aSearchResults,

   533     RArray<TPosLmItemId>& aLmIdForADb)

   534     {

   535     TInt startId = aDbId * KLmPerDb + 1;

   536     TInt stopId = 0;

   537     

   538     if (aDbId == KNrOfDbs - 1)

   539         {

   540         stopId = KTotLms;            

   541         }

   542     else 

   543         {

   544         stopId = (aDbId+1) * KLmPerDb;            

   545         }

   546     

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

   548         {

   549         if (aSearchResults[i] >= startId && aSearchResults[i] <= stopId)

   550             {

   551             User::LeaveIfError(aLmIdForADb.Append(aSearchResults[i]));

   552             }

   553         }

   554     }

   555     

   556 // ---------------------------------------------------------

   557 // CPosTp101::CheckEqualsLmsL

   558 //

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

   560 // ---------------------------------------------------------

   561 //

   562 void CPosTp101::CheckEqualsLmsL(

   563     TPosLmItemId aSource, 

   564     TPosLmItemId aTarget)

   565     {

   566     _LIT(KSortorderErr, "The sortorder is incorrect");

   567 

   568     if (aSource != aTarget)

   569         {                

   570         // Check if same name then don't Leave

   571         CPosLandmark* source = iDatabase->ReadLandmarkLC(aSource);

   572         CPosLandmark* target = iDatabase->ReadLandmarkLC(aTarget);

   573         TPtrC sourceName, targetName;

   574         source->GetLandmarkName(sourceName);

   575         target->GetLandmarkName(targetName);

   576 

   577         if (EFalse)

   578             {

   579             // For debugging purposes

   580             TBuf<100> buf;

   581             buf.Append(_L("Name:"));

   582             buf.Append(sourceName);

   583             buf.Append(targetName);

   584             iLog->Log(buf);

   585             }

   586 

   587         AssertTrueSecL(!sourceName.CompareC(targetName), KSortorderErr, aSource);

   588         CleanupStack::PopAndDestroy(2, source); // target, source

   589         }

   590     }

   591 

   592 // ---------------------------------------------------------

   593 // CPosTp101::OnTheFlySearchL

   594 //

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

   596 // ---------------------------------------------------------

   597 //

   598 void CPosTp101::OnTheFlySearchL()

   599     {

   600     TInt KTestIndex = 4;

   601                 

   602     CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();

   603     textCriteria->SetTextL(iSearchResults[KTestIndex]->TextCriteria());

   604     textCriteria->SetAttributesToSearch(iSearchResults[KTestIndex]->Attributes());

   605     textCriteria->SetPositionFieldsToSearchL(iSearchResults[KTestIndex]->PositionFields()); 

   606     

   607     COnTheFlyTester* onTheFlyTester = COnTheFlyTester::NewLC();

   608     onTheFlyTester->StartSearchCampaignL(iLmMultiSearch, 

   609         iSearchResults[KTestIndex]->SearchResult(), 

   610         textCriteria);

   611 

   612     TInt result = onTheFlyTester->Err();

   613     if (result != KErrNone)

   614         {

   615         TPtrC msg;

   616         onTheFlyTester->GetErrMsg(msg);

   617         iLog->Log(msg);

   618         User::Leave(result);

   619         }

   620         

   621     CleanupStack::PopAndDestroy(2, textCriteria);

   622     

   623     iLmMultiSearch->UnsetDisplayData();

   624     }

   625 

   626 // ---------------------------------------------------------

   627 // CPosTp101::SearchAndDeleteL

   628 //

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

   630 // ---------------------------------------------------------

   631 //

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

   633     {

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

   635     const TInt KTestIndex = 11;

   636     

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

   638     

   639     CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();

   640         

   641     textCriteria->SetTextL(aSearchResults[KTestIndex]->TextCriteria());

   642     textCriteria->SetAttributesToSearch(aSearchResults[KTestIndex]->Attributes());

   643     textCriteria->SetPositionFieldsToSearchL(aSearchResults[KTestIndex]->PositionFields()); 

   644     

   645     ExecuteAndDeleteLD(iLmMultiSearch->StartLandmarkSearchL(*textCriteria, sortPref));

   646     

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

   648     

   649     TPosLmItemId lmid = (*searchResults)[0];

   650     iDatabase = CPosLandmarkDatabase::OpenL();  

   651     if (iDatabase->IsInitializingNeeded())

   652    {

   653    ExecuteAndDeleteLD(iDatabase->InitializeL());

   654    }

   655     iDatabase->RemoveLandmarkL(lmid); 

   656     searchResults->Remove(0);

   657     searchResults->Compress();

   658     delete iDatabase;

   659     iDatabase = NULL;

   660 

   661     // Search

   662     ExecuteAndDeleteLD(iLmMultiSearch->StartLandmarkSearchL(*textCriteria, sortPref, ETrue));

   663 

   664     // Check result    

   665     // Check database array

   666     CheckDatabasesL(iDbArray);

   667 

   668     // Check for errors        

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

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

   671 

   672     AssertTrueSecL((TUint)searchResults->Count() == iLmMultiSearch->TotalNumOfMatches(), 

   673         KNumOfMatchesErr);    

   674 

   675     RArray<TPosLmItemId> lmids;

   676     CleanupClosePushL(lmids);

   677     _LIT(KNotFoundErr, "Id %d not found in parsed Lm search results");

   678 

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

   680         {

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

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

   683         if (iter) 

   684             {

   685             CleanupStack::PushL(iter);

   686             TPosLmItemId id = iter->NextL();    

   687             while (id != KPosLmNullItemId)

   688                 {

   689                 // Check that found id is expected

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

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

   692                 id = iter->NextL();

   693                 }

   694             CleanupStack::PopAndDestroy(iter);                

   695             }

   696         else 

   697             {

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

   699             iLog->Log(KIterNull);

   700             }

   701         }

   702 

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

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

   705 

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

   707         {

   708         // Check that found id is expected from all ids

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

   710         }

   711 

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

   713        

   714     CleanupStack::PopAndDestroy(textCriteria);

   715     }

   716 

   717 // ---------------------------------------------------------

   718 // CPosTp101::SearchAndRenameL

   719 //

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

   721 // ---------------------------------------------------------

   722 //

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

   724     {

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

   726     const TInt KTestIndex=4;

   727 

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

   729     

   730     CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();

   731         

   732     textCriteria->SetTextL(aSearchResults[KTestIndex]->TextCriteria());

   733     textCriteria->SetAttributesToSearch(aSearchResults[KTestIndex]->Attributes());

   734     textCriteria->SetPositionFieldsToSearchL(aSearchResults[KTestIndex]->PositionFields()); 

   735     

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

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

   738     ExecuteAndDeleteLD(iLmMultiSearch->StartLandmarkSearchL(*textCriteria, sortPref));

   739     

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

   741     

   742     // Check database array

   743     CheckDatabasesL(iDbArray);

   744 

   745     // Check for errors        

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

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

   748 

   749     AssertTrueSecL((TUint) searchResults->Count() == 

   750         iLmMultiSearch->TotalNumOfMatches(), KNumOfMatchesErr);    

   751 

   752     _LIT(KNotFoundErr, "Id %d not found in parsed Lm search results");

   753     

   754     _LIT(KLmName, "l");

   755 

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

   757         {

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

   759         iDatabase = 

   760             CPosLandmarkDatabase::OpenL(iLmMultiSearch->DatabaseUriPtr(j));

   761         if (iDatabase->IsInitializingNeeded())

   762        {

   763        ExecuteAndDeleteLD(iDatabase->InitializeL());

   764        }

   765             

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

   767         if (iter)

   768             {

   769             CleanupStack::PushL(iter);

   770             TPosLmItemId id = iter->NextL();    

   771             while (id != KPosLmNullItemId)

   772                 {

   773                 // Check that found id is expected

   774                 AssertTrueSecL(aSearchResults[KTestIndex]->FindSearchResult(id), 

   775                     KNotFoundErr);

   776               

   777                 CPosLandmark* lm = iDatabase->ReadLandmarkLC(id);

   778         

   779                 TBuf<30> lmName;

   780                 lmName = KLmName;

   781                lm->SetLandmarkNameL(lmName);

   782                 iDatabase->UpdateLandmarkL(*lm);

   783                 CleanupStack::PopAndDestroy(lm);   

   784                                 

   785                 id = iter->NextL();

   786                 }

   787             CleanupStack::PopAndDestroy(iter);                

   788             }

   789         else 

   790             {

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

   792             iLog->Log(KIterNull);

   793             }

   794             

   795         delete iDatabase;

   796         iDatabase = NULL;

   797         }

   798     

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

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

   801     ExecuteAndDeleteLD(iLmMultiSearch->StartLandmarkSearchL(*textCriteria, sortPref, ETrue));

   802     

   803     // Check database array

   804     CheckDatabasesL(iDbArray);

   805 

   806     // Check for errors        

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

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

   809 

   810     AssertTrueSecL((TUint) searchResults->Count() == 

   811         iLmMultiSearch->TotalNumOfMatches(), KNumOfMatchesErr);    

   812 

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

   814         {

   815         iDatabase = 

   816             CPosLandmarkDatabase::OpenL(iLmMultiSearch->DatabaseUriPtr(j));

   817         if (iDatabase->IsInitializingNeeded())

   818        {

   819        ExecuteAndDeleteLD(iDatabase->InitializeL());

   820        }

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

   822             

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

   824         if (iter)

   825             {

   826             CleanupStack::PushL(iter);

   827             TPosLmItemId id = iter->NextL();    

   828             while (id != KPosLmNullItemId)

   829                 {

   830                 // Check that found id is expected

   831                 AssertTrueSecL(aSearchResults[KTestIndex]->FindSearchResult(id), 

   832                     KNotFoundErr);

   833    

   834                 CPosLandmark* lm = iDatabase->ReadLandmarkLC(id);

   835         

   836                 TPtrC16 lmName;

   837                 lm->GetLandmarkName(lmName);

   838                 AssertTrueSecL(lmName == KLmName, _L("Wrong landmark name"));

   839                 

   840                 CleanupStack::PopAndDestroy(lm);   

   841                  

   842                 id = iter->NextL();

   843                 }

   844             CleanupStack::PopAndDestroy(iter);                

   845             }

   846         else 

   847             {

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

   849             iLog->Log(KIterNull);

   850             }   

   851             

   852         delete iDatabase;

   853         iDatabase = NULL;

   854         }

   855   

   856     CleanupStack::PopAndDestroy(textCriteria);

   857     }

   858 

   859 // ---------------------------------------------------------

   860 // CPosTp101::SearchAndCancelL

   861 //

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

   863 // ---------------------------------------------------------

   864 //

   865 void CPosTp101::SearchAndCancelL(const TBool& aInCallback)

   866     {

   867     // Test search with one criteria

   868     const TInt KIndex=0;

   869 

   870     CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();

   871     textCriteria->SetTextL(iSearchResults[KIndex]->TextCriteria());

   872     textCriteria->SetAttributesToSearch(iSearchResults[KIndex]->Attributes());

   873     textCriteria->SetPositionFieldsToSearchL(iSearchResults[KIndex]->PositionFields()); 

   874 

   875     if (aInCallback)

   876         {

   877         TReal threshold = 0;

   878         for (TReal i=0; i<100; i+=10) 

   879             {

   880             threshold = i/100;

   881             RunAsyncOperationAndCancelInCallbackLD(iLmMultiSearch->StartLandmarkSearchL(

   882                     *textCriteria, iSearchResults[KIndex]->Redefined()), threshold);

   883                     

   884             _LIT(KCancelNr, "Multi search test, cancel after progress %f, canceled ok.");

   885             TBuf<100> buf;

   886             buf.Format(KCancelNr, threshold);

   887             iLog->Log(buf);         

   888             }

   889         }

   890     else

   891         {

   892         RunAsyncOperationAndCancelLD(iLmMultiSearch->StartLandmarkSearchL(

   893                 *textCriteria, iSearchResults[KIndex]->Redefined()));

   894         }

   895         

   896     CleanupStack::PopAndDestroy(textCriteria);       

   897     }

   898      

   899 // ---------------------------------------------------------

   900 // CPosTp101::SearchWithMaximumL

   901 //

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

   903 // ---------------------------------------------------------

   904 //

   905 void CPosTp101::SearchWithMaximumL(

   906     const RPointerArray<CSearchResult>& aSearchResults)

   907     {

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

   909 

   910     // Test search with one criteria

   911     const TInt KTestIndex = 0;

   912 

   913     CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();

   914  

   915     textCriteria->SetTextL(iSearchResults[KTestIndex]->TextCriteria());

   916     textCriteria->SetAttributesToSearch(iSearchResults[KTestIndex]->Attributes());

   917     textCriteria->SetPositionFieldsToSearchL(iSearchResults[KTestIndex]->PositionFields()); 

   918 

   919     TPosLmSortPref sortPref(CPosLandmark::ELandmarkName, TPosLmSortPref::EDescending);

   920 

   921     // First get the maximum number of matches

   922     TInt maxMatches = KNrOfDbs;  

   923     iLmMultiSearch->SetMaxNumOfMatches(maxMatches);

   924     _LIT(KErrNrOfMatches, "Number of matches is incorrect");

   925     AssertTrueSecL(iLmMultiSearch->MaxNumOfMatches() == maxMatches, KErrNrOfMatches);

   926     

   927     ExecuteAndDeleteLD(iLmMultiSearch->StartLandmarkSearchL(*textCriteria, sortPref)); 

   928 

   929     AssertTrueSecL(iLmMultiSearch->MaxNumOfMatches() == maxMatches, KErrNrOfMatches);

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

   931     TInt totalMatches = iLmMultiSearch->TotalNumOfMatches();

   932     

   933     // Check database array

   934     CheckDatabasesL(iDbArray, maxMatches);

   935     // Check for errors        

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

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

   938     // Check that nr is not expected number of results

   939     AssertTrueSecL((TUint) searchResults->Count() != 

   940         totalMatches, KNumOfMatchesErr);    

   941 

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

   943         {

   944         RArray<TPosLmItemId> lmids;

   945         CleanupClosePushL(lmids);

   946         GetLmIdsL(n, *searchResults, lmids);            

   947     

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

   949         if (iDatabase->IsInitializingNeeded())

   950        {

   951        ExecuteAndDeleteLD(iDatabase->InitializeL());

   952        }

   953         LandmarksSortL(lmids, sortPref);

   954     

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

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

   957         if (iter) 

   958             {

   959             CleanupStack::PushL(iter);

   960             AssertTrueSecL(iter->NumOfItemsL() == iLmMultiSearch->NumOfMatches(n), 

   961                 KNumOfMatchesErr);

   962     

   963             TInt lmid = 0;

   964             TPosLmItemId id = iter->NextL();

   965     

   966             while (id != KPosLmNullItemId)

   967                 {

   968                 CheckEqualsLmsL(id, lmids[lmid]);

   969                 

   970                 id = iter->NextL();

   971                 ++lmid;

   972                 }

   973             CleanupStack::PopAndDestroy(iter);

   974             }

   975         else 

   976             {

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

   978             iLog->Log(KIterNull);

   979             }

   980             

   981         delete iDatabase;

   982         iDatabase = NULL;

   983         

   984         CleanupStack::PopAndDestroy(&lmids);

   985         }

   986 

   987     // Test max matches again

   988     TInt incMatches = 2;

   989     maxMatches = maxMatches + incMatches;  

   990     iLmMultiSearch->SetMaxNumOfMatches(maxMatches);

   991     AssertTrueSecL(iLmMultiSearch->MaxNumOfMatches() == maxMatches, KErrNrOfMatches);

   992     

   993     ExecuteAndDeleteLD(iLmMultiSearch->StartLandmarkSearchL(*textCriteria)); 

   994 

   995     AssertTrueSecL(iLmMultiSearch->MaxNumOfMatches() == maxMatches, KErrNrOfMatches);

   996     TInt reTotalMatches = iLmMultiSearch->TotalNumOfMatches();

   997     

   998     AssertTrueSecL(reTotalMatches != totalMatches, 

   999         _L("Total number of matches should not be that same."));

  1000     

  1001     // Check database array

  1002     CheckDatabasesL(iDbArray, maxMatches);

  1003     // Check for errors        

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

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

  1006     // Check that nr is not expected number of results

  1007     AssertTrueSecL((TUint) searchResults->Count() != 

  1008         reTotalMatches, KNumOfMatchesErr); 

  1009 

  1010     CleanupStack::PopAndDestroy(textCriteria);

  1011 

  1012     // Unset max number of matches to normal/unlimited again

  1013     iLmMultiSearch->SetMaxNumOfMatches();

  1014     }

  1015 

  1016 // ---------------------------------------------------------

  1017 // CPosTp101::CreateDatabasesL

  1018 //

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

  1020 // ---------------------------------------------------------

  1021 //

  1022 CDesCArray* CPosTp101::CreateDatabasesL(TInt aNrOfLmDbs, TInt aLmPerDb, 

  1023     TInt aLastId, TBool aDebug)

  1024     {

  1025             

  1026     CDesCArray* iDbArray = new (ELeave) CDesCArrayFlat(aNrOfLmDbs); 

  1027     CleanupStack::PushL(iDbArray);     

  1028          

  1029     RemoveDefaultDbL();

  1030     

  1031     // Populate default db

  1032     iDatabase = UseGeneratedDbFileL();

  1033     if (iDatabase->IsInitializingNeeded())

  1034        {

  1035        ExecuteAndDeleteLD(iDatabase->InitializeL());

  1036        }

  1037     ExecuteAndDeleteLD(iDatabase->CompactL());

  1038     delete iDatabase;

  1039     iDatabase = NULL;

  1040         

  1041     CFileMan* fileMan = CFileMan::NewL(iFileSession);

  1042     CleanupStack::PushL(fileMan);

  1043 

  1044     // Create databases

  1045     TInt i=0;

  1046     for (i=1; i < aNrOfLmDbs; i++)

  1047         {

  1048         TBuf<100> db;

  1049         db.Format(KDbNamePath, i * aLmPerDb);

  1050         

  1051         iFileSession.Delete(db);

  1052         User::LeaveIfError(fileMan->Copy(KLmFullDefaultDbPath, db, CFileMan::EOverWrite));    

  1053         }

  1054     CleanupStack::PopAndDestroy(fileMan);               

  1055 

  1056     for (TInt db=0; db < aNrOfLmDbs; db++)

  1057         {

  1058         TInt dbform = db;

  1059         if (db == aNrOfLmDbs)

  1060             {

  1061             dbform = aNrOfLmDbs - 1;

  1062             }

  1063             

  1064         CPosLandmarkDatabase* lmd = NULL;

  1065         TBuf<100> name;

  1066         if (db == 0)

  1067             {

  1068             _LIT(KDefLmDb, "eposlm.ldb");

  1069             name = KDefLmDb;

  1070             lmd = CPosLandmarkDatabase::OpenL();

  1071             if (lmd->IsInitializingNeeded())

  1072            {

  1073            ExecuteAndDeleteLD(lmd->InitializeL());

  1074            }

  1075             }

  1076         else 

  1077             {

  1078             name.Format(KDbName, dbform * aLmPerDb);        

  1079             lmd = CPosLandmarkDatabase::OpenL(name);

  1080             if (lmd->IsInitializingNeeded())

  1081            {

  1082            ExecuteAndDeleteLD(lmd->InitializeL());

  1083            }

  1084             }

  1085         CleanupStack::PushL(lmd);

  1086         // Append db name to array

  1087         iDbArray->AppendL(name);

  1088 

  1089         if (aDebug)

  1090             {

  1091             iLog->Log(name);

  1092             }

  1093         

  1094         TInt startItemid = dbform * aLmPerDb + 1;

  1095         TInt stopItemid = dbform * aLmPerDb + aLmPerDb;            

  1096         if (dbform == aNrOfLmDbs - 1)

  1097             {

  1098             stopItemid = aLastId;

  1099             }

  1100         

  1101         for (TInt lmid=1; lmid <= aLastId; lmid++) 

  1102             {

  1103             TBuf<100> lmidbuf;

  1104                 

  1105             if (aDebug)

  1106                 {

  1107                 _LIT(KLmId, "Landmark with LmId: %d");

  1108                 lmidbuf.Format(KLmId, lmid);

  1109                 iLog->Log(lmidbuf);                                

  1110                 }

  1111 

  1112             if (lmid < startItemid || lmid > stopItemid)

  1113                 {

  1114                 if (aDebug)

  1115                     {

  1116                     _LIT(KDelLmId, "Removing LmId: %d");

  1117                     lmidbuf.Format(KDelLmId, lmid);

  1118                     iLog->Log(lmidbuf);                                

  1119                     }

  1120                 TInt err = KErrLocked;

  1121                 while (err == KErrLocked)

  1122                     {

  1123                     TRAP(err, lmd->RemoveLandmarkL(lmid));

  1124                     }

  1125                 }

  1126             }

  1127 

  1128         // Compact database

  1129         ExecuteAndDeleteLD(lmd->CompactL());    

  1130         CleanupStack::PopAndDestroy(lmd);  

  1131         }

  1132         

  1133     // Log/print landmark databases.

  1134     if (aDebug)

  1135         {