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_CPosTp18.h"

    23 #include <EPos_CPosLandmarkDatabase.h>

    24 #include <EPos_CPosLMPartialReadParameters.h>  

    25 #include <EPos_CPosLMOperation.h> 

    26 #include <LbsPosition.h>

    27 

    28 

    29 // CONSTANTS

    30 const TInt KNoPreparePartial = 40;

    31 _LIT(KTakePreparedPartialErr, "Method TakePreparedPartialLandmarksL doesn't leave with KErrNotFound");

    32 _LIT(KNoPreparedPartialErr, "Method TakePreparedPartialLandmarksL returns incorrect no. landmarks");

    33 _LIT(KNoPreparedPartialErr2, "Method TakePreparedPartialLandmarksL returns incorrect landmarks");

    34 

    35 _LIT(KTp18DbFile, "TP18Test.ldb");

    36 _LIT(KTp18DbFile1, "TP18Test1.ldb");

    37 

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

    39 

    40 

    41 // ---------------------------------------------------------

    42 // CPosTp10::CloseTest

    43 //

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

    45 // ---------------------------------------------------------

    46 //

    47 void CPosTp18::CloseTest()

    48     {

    49     if (iArrayPtr)

    50         {

    51         iArrayPtr->ResetAndDestroy();

    52         }

    53     delete iArrayPtr;

    54     iArrayPtr = NULL;

    55     

    56     delete iDatabase;

    57     iDatabase = NULL;

    58     

    59     delete iOperation;

    60     iOperation = NULL;

    61     }

    62 

    63 // ---------------------------------------------------------

    64 // CPosTp18::StartL

    65 //

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

    67 // ---------------------------------------------------------

    68 //

    69 void CPosTp18::StartL()

    70     {

    71     _LIT(KNotPartialErr, "Landmark is not a partial landmark");

    72     CopyTestDbFileL(KTp18DbFile);

    73     iDatabase = CPosLandmarkDatabase::OpenL(KTp18DbFile);

    74     

    75     if (iDatabase->IsInitializingNeeded())

    76        {

    77        ExecuteAndDeleteLD(iDatabase->InitializeL());

    78        }

    79     

    80     // Test some non-existing landmark ids

    81     TPosLmItemId id = KPosLmNullItemId;

    82     TRAPD(err, iDatabase->ReadPartialLandmarkLC(id));

    83     if (err != KErrNotFound)

    84     {

    85     	iLog->Log(_L("ReadPartialLandmarkLC should leave with KErrnotFound"));

    86     	User::Leave(err);

    87     }

    88     id = 2000;

    89     TRAP(err, iDatabase->ReadPartialLandmarkLC(id));

    90     if (err != KErrNotFound) 

    91     {

    92     	iLog->Log(_L("ReadPartialLandmarkLC should leave with KErrnotFouns"));

    93     	User::Leave(err);

    94     }

    95 

    96     TestAllPartialAttributesL();

    97     

    98     TestPartialPositionFieldsL();

    99 

   100     PreparePartialLandmarksL();

   101 

   102     PreparePartialLandmarksAsyncL(EAsynchronous);

   103 

   104     PreparePartialLandmarksAsyncL(EWaitForRequest);

   105 

   106     iLog->Log(_L("TESTS BELOW ARE TESTING CANCEL"));

   107     PreparePartialLandmarksAsyncAndCancelL();

   108     

   109     iLog->Log(_L("TEST BELOW IS TESTING CANCEL IN CALLBACK"));

   110     PreparePartialLandmarksAsyncAndCancelL(ETrue);

   111 

   112     TUint attr=CPosLandmark::ELandmarkName;

   113     CPosLmPartialReadParameters* partialParam = iDatabase->PartialReadParametersLC();

   114     partialParam->SetRequestedAttributes(attr);    

   115     CPosLandmark* lm = GetPartialLandmarkLC(1, *partialParam);

   116     CheckPartialLandmarkL(*lm, attr);

   117     

   118     CPosLandmark* copy = CPosLandmark::NewLC(*lm);

   119     

   120     iDatabase->AddLandmarkL(*copy);

   121     

   122     CPosLandmark* lm2 = iDatabase->ReadLandmarkLC(copy->LandmarkId());

   123   

   124     AssertTrueSecL(!lm2->IsPartial(), KNotPartialErr);

   125     CleanupStack::PopAndDestroy(4,partialParam);

   126 	}

   127 

   128 // ---------------------------------------------------------

   129 // CPosTp18::TestAllPartialAttributes

   130 //

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

   132 // ---------------------------------------------------------

   133 //

   134 void CPosTp18::TestAllPartialAttributesL()

   135     {

   136      iLog->Log(_L("TestAllPartialAttributesL"));

   137      iLog->Log(_L("Testing GetPartialLandmarks with all combination of attributes requested"));

   138     _LIT(KNoAttrReqErr, "No attributes have been requested -> RequestedAttributes should return ENoAttribute");

   139     

   140     CPosLmPartialReadParameters* partialParam = iDatabase->PartialReadParametersLC();

   141     

   142     AssertTrueSecL(partialParam->RequestedAttributes() == CPosLandmark::ENoAttribute, KNoAttrReqErr);

   143     

   144     iDatabase->SetPartialReadParametersL(*partialParam);

   145     

   146     TPosLmItemId  id=1; // landmarks Id with all attr set

   147 

   148     TUint max = CPosLandmark::EDescription;

   149     max <<= 1;

   150     max -= 1;

   151     CPosLandmark* lm = NULL;

   152     

   153     TUint attr=0;

   154     for (attr=0; attr<=max; attr++)

   155         {

   156         partialParam->SetRequestedAttributes(attr);    

   157         lm = GetPartialLandmarkLC(id, *partialParam);

   158         CheckPartialLandmarkL(*lm, attr);

   159         CleanupStack::PopAndDestroy(lm);         

   160         }

   161    

   162     id = 2; // attr coverage radius not availible  

   163     attr = 0x003F; // req all

   164     partialParam->SetRequestedAttributes(attr);    

   165     lm = GetPartialLandmarkLC(id, *partialParam);

   166     attr = attr & 0x00FB; // remove coverage radius

   167     CheckPartialLandmarkL(*lm, attr);

   168     CleanupStack::PopAndDestroy(lm);         

   169 

   170     id = 3; // Description not available

   171     attr = 0x003F; // req all

   172     partialParam->SetRequestedAttributes(attr);    

   173     lm = GetPartialLandmarkLC(id, *partialParam);

   174     

   175    

   176     // After error report "ESLI-5ZDH4N Landmarks - Empty descriptors"

   177     // Even if name or description not has been set it will return empty string "" when reading

   178     // it from landmarks db, thus GetLandmarkDescription will KErrNone (instead of KErrNotFound as earlier)

   179     //attr = attr & 0x00DF; // remove description

   180     CheckPartialLandmarkL(*lm, attr);

   181     CleanupStack::PopAndDestroy(lm);

   182 

   183     id= 5; // IconName and IconIndex not availible

   184     attr = 0x003F; // req all

   185     partialParam->SetRequestedAttributes(attr);    

   186     lm = GetPartialLandmarkLC(id, *partialParam);

   187     attr = attr & 0x00EF; // remove IconName and IconIndex

   188     CheckPartialLandmarkL(*lm, attr);

   189     CleanupStack::PopAndDestroy(lm);         

   190 

   191     CleanupStack::PopAndDestroy(partialParam); 

   192     }

   193 

   194 // ---------------------------------------------------------

   195 // CPosTp18::TestPartialPositionFields

   196 //

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

   198 // ---------------------------------------------------------

   199 //

   200 void CPosTp18::TestPartialPositionFieldsL()

   201     {

   202     iLog->Log(_L("TestPartialPositionFieldsL"));

   203     iLog->Log(_L("Testing GetPartialLandmarks with different combinations of positionfields requested"));

   204     _LIT(KNoFieldsReqErr, "No fields have been requested -> GetRequestedPositionFields should return 0");

   205         

   206     CPosLmPartialReadParameters* partialParam = CPosLmPartialReadParameters::NewLC(); 

   207 

   208     RArray<TUint> reqFields;

   209     partialParam->GetRequestedPositionFields(reqFields);

   210     CleanupClosePushL(reqFields);

   211     

   212     AssertTrueSecL(partialParam->GetRequestedPositionFields(reqFields) == 0, KNoFieldsReqErr);

   213     iDatabase->SetPartialReadParametersL(*partialParam);

   214     

   215         

   216     // Landmark Id with Street, PostalCode, City, LocationName, 

   217     // Country, MediaLinks, MediaLink1, MediaLink2 fields

   218     TPosLmItemId  id=2;

   219    

   220     AppendFields(reqFields);

   221     RArray<TBool> availFields;

   222     CleanupClosePushL(availFields);

   223     for(TInt i=0; i<8; i++)

   224         {

   225         availFields.Append(ETrue);

   226         }

   227 

   228     partialParam->SetRequestedPositionFields(reqFields);  

   229    

   230     CPosLandmark* lm = NULL;

   231     lm = GetPartialLandmarkLC(id, *partialParam);

   232     CheckPartialLandmarkL(*lm, reqFields, availFields);

   233     CleanupStack::PopAndDestroy(lm);         

   234 

   235     // Landmark Id with PostalCode, City, LocationName, 

   236     // Country, MediaLinks, MediaLink1, MediaLink2 fields

   237     id=3;

   238     availFields[0] = EFalse;

   239     lm = GetPartialLandmarkLC(id, *partialParam);

   240     CheckPartialLandmarkL(*lm, reqFields, availFields);

   241     CleanupStack::PopAndDestroy(lm);

   242     

   243     // Landmark Id with Street, City, LocationName, 

   244     // Country, MediaLinks, MediaLink1, MediaLink2 fields

   245     id=4;

   246     availFields[0] = ETrue;

   247     availFields[1] = EFalse;

   248     lm = GetPartialLandmarkLC(id, *partialParam);

   249     CheckPartialLandmarkL(*lm, reqFields, availFields);

   250     CleanupStack::PopAndDestroy(lm);

   251 

   252     // Landmark Id with Street, PostalCode, LocationName, 

   253     // Country, MediaLinks, MediaLink1, MediaLink2 fields

   254     id=5;

   255     availFields[1] = ETrue;

   256     availFields[2] = EFalse;

   257     lm = GetPartialLandmarkLC(id, *partialParam);

   258     CheckPartialLandmarkL(*lm, reqFields, availFields);

   259     CleanupStack::PopAndDestroy(lm);

   260 

   261     // Landmark Id with Street,PostalCode, City, 

   262     // Country, MediaLinks, MediaLink1, MediaLink2 fields

   263     id=6;

   264     availFields[2] = ETrue;

   265     availFields[3] = EFalse;

   266     lm = GetPartialLandmarkLC(id, *partialParam);

   267     CheckPartialLandmarkL(*lm, reqFields, availFields);

   268     CleanupStack::PopAndDestroy(lm);

   269 

   270     // Landmark Id with Street,PostalCode, City, 

   271     // MediaLinks, MediaLink1, MediaLink2 fields

   272     id=7;

   273     availFields[3] = ETrue;

   274     availFields[4] = EFalse;

   275     lm = GetPartialLandmarkLC(id, *partialParam);

   276     CheckPartialLandmarkL(*lm, reqFields, availFields);

   277     CleanupStack::PopAndDestroy(lm);

   278 

   279     // Landmark Id with Street,PostalCode, City, 

   280     // Country fields

   281     id=8;

   282     availFields[4] = ETrue;

   283     availFields[5] = EFalse;

   284     availFields[6] = EFalse;

   285     availFields[7] = EFalse;

   286 

   287     lm = GetPartialLandmarkLC(id, *partialParam);

   288     CheckPartialLandmarkL(*lm, reqFields, availFields);

   289     CleanupStack::PopAndDestroy(lm);

   290 

   291     // Landmark Id with Street,PostalCode, City, 

   292     // Country, MediaLinks, MediaLink1 fields

   293     id=9;

   294     availFields[5] = ETrue;

   295     availFields[6] = ETrue;

   296     availFields[7] = EFalse;

   297 

   298     lm = GetPartialLandmarkLC(id, *partialParam);

   299     CheckPartialLandmarkL(*lm, reqFields, availFields);

   300     CleanupStack::PopAndDestroy(lm);

   301     

   302     availFields[0] = EFalse;

   303     

   304     reqFields[0] = EPositionFieldMagneticCourse;

   305 

   306     partialParam->SetRequestedPositionFields(reqFields);

   307     lm = GetPartialLandmarkLC(id, *partialParam);

   308     

   309     reqFields[0] = EPositionFieldStreet; // To verify that street is not return when not requested

   310     CheckPartialLandmarkL(*lm, reqFields, availFields);

   311     

   312     CleanupStack::PopAndDestroy(4, partialParam);

   313    

   314     }

   315 

   316 // ---------------------------------------------------------

   317 // CPosTp18::PreparePartialLandmarksL

   318 //

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

   320 // ---------------------------------------------------------

   321 //

   322 void CPosTp18::PreparePartialLandmarksL()

   323     {

   324     iLog->Log(_L("PreparePartialLandmarksL"));

   325     iLog->Log(_L("Testing Prepare and TakePartialLandmarks syncronously"));

   326 

   327     CPosLmPartialReadParameters* partialParam = CPosLmPartialReadParameters::NewLC(); 

   328     

   329     TUint attr = CPosLandmark::ELandmarkName;

   330     partialParam->SetRequestedAttributes(attr);

   331     iDatabase->SetPartialReadParametersL(*partialParam);

   332     

   333     RArray<TPosLmItemId> ids;

   334     CleanupClosePushL(ids);

   335     

   336     for (TInt i=0; i<KNoPreparePartial; i++)

   337         {

   338         TPosLmItemId id= i+1;

   339         ids.Append(id);

   340         }

   341     // Test with non-existing id

   342     ids.Append(13112321);

   343    

   344     //*** Add time measurements

   345     iOperation = iDatabase->PreparePartialLandmarksL(ids); 

   346     iOperation->ExecuteL();

   347 

   348     iArrayPtr = iDatabase->TakePreparedPartialLandmarksL(iOperation);

   349     AssertTrueSecL(iArrayPtr->Count() == ids.Count(), KNoPreparedPartialErr);

   350 

   351     for (TInt j=0; j<iArrayPtr->Count()-1; j++)

   352         {

   353         CheckPartialLandmarkL(*iArrayPtr->At(j), CPosLandmark::ELandmarkName);

   354         }

   355     AssertTrueSecL(iArrayPtr->At(iArrayPtr->Count()-1) == NULL, KNoPreparedPartialErr2); 

   356 

   357     TRAPD(err, iArrayPtr=iDatabase->TakePreparedPartialLandmarksL(iOperation));

   358     AssertTrueSecL(err == KErrNotFound, KTakePreparedPartialErr); 

   359 

   360     delete iOperation;

   361     iOperation = NULL;

   362 

   363     // landmarks with Name, coverage radius, description and fields street and country set 

   364     const TInt idsStart = 8;

   365     const TInt idsEnd = 28;

   366 

   367     attr = attr | CPosLandmark::ECoverageRadius | CPosLandmark::EDescription;

   368     partialParam->SetRequestedAttributes(attr);

   369     

   370     RArray<TUint> reqFields;

   371     CleanupClosePushL(reqFields);

   372 

   373     reqFields.Append(EPositionFieldStreet);

   374     reqFields.Append(EPositionFieldCountry);

   375     partialParam->SetRequestedPositionFields(reqFields);

   376 

   377     iDatabase->SetPartialReadParametersL(*partialParam);

   378     

   379     RArray<TBool> availFields;

   380     CleanupClosePushL(availFields);

   381     for(TInt jj=0; jj<2; jj++)

   382         {

   383         availFields.Append(ETrue);

   384         }

   385     

   386     ids.Reset();

   387     for (TInt k=idsStart; k<=idsEnd; k++)

   388         {

   389         ids.Append(k);    

   390         }

   391     

   392     iOperation = iDatabase->PreparePartialLandmarksL(ids);

   393     iOperation->ExecuteL();

   394 

   395     iArrayPtr->ResetAndDestroy();

   396     delete iArrayPtr; 

   397     iArrayPtr = NULL;

   398 

   399     iArrayPtr = iDatabase->TakePreparedPartialLandmarksL(iOperation);

   400     delete iOperation;

   401     iOperation = NULL;

   402  

   403     AssertTrueSecL(iArrayPtr->Count() == ids.Count(),KNoPreparedPartialErr);

   404     for (TInt ii=0; ii<iArrayPtr->Count()-1; ii++)

   405         {

   406         CheckPartialLandmarkL(*iArrayPtr->At(ii), attr);

   407         CheckPartialLandmarkL(*iArrayPtr->At(ii), reqFields, availFields);

   408         }

   409     

   410     CleanupStack::PopAndDestroy(4, partialParam);

   411         

   412     iArrayPtr->ResetAndDestroy();

   413     delete iArrayPtr; 

   414     iArrayPtr = NULL;

   415 

   416     // Test not setting any attributes with SetRequestedAttributes,

   417     // should only return empty landmarks

   418     delete iDatabase;

   419     iDatabase = NULL;

   420     CopyTestDbFileL(KTp18DbFile1);

   421 	iDatabase = CPosLandmarkDatabase::OpenL(KTp18DbFile1);

   422     

   423     if (iDatabase->IsInitializingNeeded()) ExecuteAndDeleteLD(iDatabase->InitializeL());

   424        

   425     CleanupClosePushL(ids);

   426     ids.Append(1);

   427     ids.Append(2);

   428     ids.Append(10);

   429     ids.Append(20);

   430     iOperation = iDatabase->PreparePartialLandmarksL(ids);

   431     iOperation->ExecuteL();

   432     

   433     iArrayPtr = iDatabase->TakePreparedPartialLandmarksL(iOperation);

   434     AssertTrueSecL(iArrayPtr->Count() == ids.Count(), _L("Nr of Ids not correct"));

   435     delete iOperation;

   436     iOperation = NULL;

   437     

   438     // Check that returned landmarks are empty

   439     for (TInt ii=0; ii<iArrayPtr->Count()-1; ii++)

   440         {

   441         for (TInt j=0;j<KMaxTUint16;j++)

   442             {            

   443             AssertTrueSecL(!iArrayPtr->At(ii)->IsPositionFieldAvailable(j), _L("Only empty landmarks should be returned"));

   444             }

   445         }

   446     iArrayPtr->ResetAndDestroy();

   447     delete iArrayPtr; 

   448     iArrayPtr = NULL;

   449 

   450     CleanupStack::PopAndDestroy(&ids);

   451     

   452     // Test with empty list, should cause error

   453     partialParam = CPosLmPartialReadParameters::NewLC();

   454     attr = CPosLandmark::ELandmarkName;

   455     partialParam->SetRequestedAttributes(attr);

   456     iDatabase->SetPartialReadParametersL(*partialParam);

   457     

   458     CleanupClosePushL(ids);

   459     TRAP(err, iDatabase->PreparePartialLandmarksL(ids));

   460    

   461     CleanupStack::PopAndDestroy();

   462     if (err != KErrArgument) 

   463     {

   464     	iLog->Log(_L("PreparePartialLandmarksL should leave with KErrArgument"));

   465     	User::Leave(err);

   466     }

   467     

   468     CleanupStack::PopAndDestroy(partialParam);

   469 //    CleanupStack::PopAndDestroy(&ids);

   470 

   471     }

   472 

   473 // ---------------------------------------------------------

   474 // CPosTp18::PreparePartialLandmarksAsyncL

   475 //

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

   477 // ---------------------------------------------------------

   478 //

   479 void CPosTp18::PreparePartialLandmarksAsyncL(TExecutionMode aExecutionMode)

   480     {

   481     iLog->Log(_L("Testing Prepare and TakePartialLandmarks asyncronously"));

   482    

   483     CPosLmPartialReadParameters* partialParam = iDatabase->PartialReadParametersLC();

   484     

   485     TUint attr = CPosLandmark::ELandmarkName;

   486     partialParam->SetRequestedAttributes(attr);

   487     iDatabase->SetPartialReadParametersL(*partialParam);

   488       

   489     RArray<TPosLmItemId> ids;

   490     CleanupClosePushL(ids);

   491     for (TInt i=0; i<KNoPreparePartial; i++)

   492         {

   493         TPosLmItemId id= i+1;

   494         ids.Append(id);

   495         }

   496     ids.Append(13112321);

   497     

   498     iOperation = iDatabase->PreparePartialLandmarksL(ids);

   499     

   500     TRAPD(err, iArrayPtr=iDatabase->TakePreparedPartialLandmarksL(iOperation));

   501     AssertTrueSecL(err == KErrNotFound, KTakePreparedPartialErr); 

   502     

   503     switch (aExecutionMode)

   504         {

   505         case EAsynchronous:

   506             RunAsyncOperationL(iOperation);

   507             break;

   508         case EWaitForRequest:

   509             RunAsyncOperationByWaitForReqL(iOperation);

   510             break;

   511         default:

   512             User::Leave(KErrArgument);

   513             break;

   514         }

   515  

   516     if (iArrayPtr != NULL)

   517         {

   518         iArrayPtr->ResetAndDestroy();

   519         delete iArrayPtr;

   520         iArrayPtr=NULL;

   521     }

   522     

   523     iArrayPtr = iDatabase->TakePreparedPartialLandmarksL(iOperation);

   524 

   525     AssertTrueSecL(iArrayPtr->Count() == ids.Count(),KNoPreparedPartialErr);

   526     AssertTrueSecL(iArrayPtr->At(iArrayPtr->Count()-1) == NULL, KNoPreparedPartialErr2); 

   527 

   528     for (TInt j=0; j<iArrayPtr->Count()-1; j++)

   529       {

   530       CheckPartialLandmarkL(*iArrayPtr->At(j), CPosLandmark::ELandmarkName);

   531       }

   532 

   533     iArrayPtr->ResetAndDestroy();

   534     delete iArrayPtr;

   535     iArrayPtr = NULL;

   536 

   537     delete iOperation;

   538     iOperation = NULL;

   539    

   540     // landmarks with Name, Icon, Position MediaLink1 set 

   541     const TInt idsStart = 10;

   542     const TInt idsEnd = 35;

   543     

   544     attr = attr | CPosLandmark::EIcon | CPosLandmark::EPosition;

   545     partialParam->SetRequestedAttributes(attr);

   546 

   547     RArray<TUint> reqFields;

   548     CleanupClosePushL(reqFields);

   549     reqFields.Append(EPositionFieldMediaLinks);

   550     reqFields.Append(EPositionFieldMediaLinksStart);

   551     partialParam->SetRequestedPositionFields(reqFields);

   552     

   553     iDatabase->SetPartialReadParametersL(*partialParam);

   554 

   555     RArray<TBool> availFields;

   556     CleanupClosePushL(availFields);

   557     for(TInt jj=0; jj<2; jj++)

   558         {

   559         availFields.Append(ETrue);

   560         }

   561 

   562     ids.Reset();

   563     for (TInt k=idsStart; k<=idsEnd; k++)

   564         {

   565         ids.Append(k);

   566         }

   567     

   568     iOperation = iDatabase->PreparePartialLandmarksL(ids);

   569 

   570     switch (aExecutionMode)

   571         {

   572         case EAsynchronous:

   573             RunAsyncOperationL(iOperation);

   574             break;

   575         case EWaitForRequest:

   576             RunAsyncOperationByWaitForReqL(iOperation);

   577             break;

   578         default:

   579             User::Leave(KErrArgument);

   580             break;

   581         }

   582  

   583     iArrayPtr = iDatabase->TakePreparedPartialLandmarksL(iOperation);

   584 

   585     AssertTrueSecL(iArrayPtr->Count() == ids.Count(),KNoPreparedPartialErr);

   586       

   587     for (TInt x=0; x<iArrayPtr->Count()-1; x++)

   588         {  

   589         CheckPartialLandmarkL(*iArrayPtr->At(x), attr);        

   590         CheckPartialLandmarkL(*iArrayPtr->At(x), reqFields, availFields);

   591         }

   592     

   593     delete iOperation;

   594     iOperation = NULL;

   595     

   596     CleanupStack::PopAndDestroy(4, partialParam);

   597     }

   598 

   599 // ---------------------------------------------------------

   600 // CPosTp18::PreparePartialLandmarksAndCancelL

   601 //

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

   603 // ---------------------------------------------------------

   604 //

   605 void CPosTp18::PreparePartialLandmarksAsyncAndCancelL(const TBool& aInCallback)

   606     {

   607     iLog->Log(_L("Testing Prepare and TakePartialLandmarks asyncronously with cancel"));

   608    

   609     CPosLmPartialReadParameters* partialParam = iDatabase->PartialReadParametersLC();

   610     

   611     TUint attr = CPosLandmark::ELandmarkName;

   612     partialParam->SetRequestedAttributes(attr);

   613     iDatabase->SetPartialReadParametersL(*partialParam);

   614       

   615     RArray<TPosLmItemId> ids;

   616     CleanupClosePushL(ids);

   617     for (TInt i=0; i<KNoPreparePartial; i++)

   618         {

   619         TPosLmItemId id= i+1;

   620         ids.Append(id);

   621         }

   622     ids.Append(13112321);

   623     

   624     iOperation = iDatabase->PreparePartialLandmarksL(ids);

   625     

   626     TRAPD(err, iArrayPtr=iDatabase->TakePreparedPartialLandmarksL(iOperation));

   627     AssertTrueSecL(err == KErrNotFound, KTakePreparedPartialErr); 

   628     

   629     if (aInCallback)

   630         {

   631         RunAsyncOperationAndCancelInCallbackLD(iOperation);

   632         iOperation = NULL;

   633         }

   634     else

   635         {

   636         RunAsyncOperationAndCancelLD(iOperation);

   637         }

   638     

   639     // landmarks with Name, Icon, Position MediaLink1 set 

   640     const TInt idsStart = 10;

   641     const TInt idsEnd = 35;

   642     

   643     attr = attr | CPosLandmark::EIcon | CPosLandmark::EPosition;

   644     partialParam->SetRequestedAttributes(attr);

   645 

   646     RArray<TUint> reqFields;

   647     CleanupClosePushL(reqFields);

   648     reqFields.Append(EPositionFieldMediaLinks);

   649     reqFields.Append(EPositionFieldMediaLinksStart);

   650     partialParam->SetRequestedPositionFields(reqFields);

   651     

   652     iDatabase->SetPartialReadParametersL(*partialParam);

   653 

   654     RArray<TBool> availFields;

   655     CleanupClosePushL(availFields);

   656     for(TInt jj=0; jj<2; jj++)

   657         {

   658         availFields.Append(ETrue);

   659         }

   660 

   661     ids.Reset();

   662     for (TInt k=idsStart; k<=idsEnd; k++)

   663         {

   664         ids.Append(k);

   665         }

   666     

   667     iOperation = iDatabase->PreparePartialLandmarksL(ids);

   668      if (aInCallback)

   669         {

   670         RunAsyncOperationAndCancelInCallbackLD(iOperation);

   671         iOperation = NULL;

   672         }

   673     else

   674         {

   675         RunAsyncOperationAndCancelLD(iOperation);

   676         }

   677    

   678     CleanupStack::PopAndDestroy(4, partialParam);

   679     }

   680 

   681 // ---------------------------------------------------------

   682 // CPosTp18::GetPartialLandmarkLC

   683 //

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

   685 // ---------------------------------------------------------

   686 //

   687 CPosLandmark* CPosTp18::GetPartialLandmarkLC(const TPosLmItemId aId,

   688                                              const CPosLmPartialReadParameters& aPartialParam)

   689     {

   690     _LIT(KIsPartialErr, "Method Landmark->IsPartial returns incorrect value");

   691     _LIT(KUpdateErr, "It should not be possible to update a partial landmark");

   692 

   693     iDatabase->SetPartialReadParametersL(aPartialParam);

   694     

   695     CPosLandmark* lm = iDatabase->ReadPartialLandmarkLC(aId);

   696     AssertTrueSecL(lm->IsPartial(), KIsPartialErr);

   697     

   698     TRAPD(err, iDatabase->UpdateLandmarkL(*lm));

   699     AssertTrueSecL(err == KErrArgument, KUpdateErr);

   700     

   701     return lm;

   702     }

   703 

   704 // ---------------------------------------------------------

   705 // CPosTp18::AppendFields

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

   707 // ---------------------------------------------------------

   708 //

   709 void CPosTp18::AppendFields(RArray<TUint>& aArray)

   710     {

   711     // Appends fields availible to set with Landmarks db generator

   712     aArray.Append(EPositionFieldStreet);

   713     aArray.Append(EPositionFieldPostalCode);

   714     aArray.Append(EPositionFieldCity);

   715     aArray.Append(EPositionFieldLocationName);

   716     aArray.Append(EPositionFieldCountry);

   717     aArray.Append(EPositionFieldMediaLinks);

   718     aArray.Append(EPositionFieldMediaLinksStart);

   719 

   720     TUint16 tmp = (TUint16)EPositionFieldMediaLinksStart;

   721     aArray.Append(++tmp);

   722     

   723     }

   724 

   725 // ---------------------------------------------------------

   726 // CPosTp18::ChechPartialLandmarkL

   727 //

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

   729 // ---------------------------------------------------------

   730 //

   731 void CPosTp18::CheckPartialLandmarkL(const CPosLandmark& aLandmark, 

   732                                      const RArray<TUint>& aReqFields,

   733                                      const RArray<TBool>& aAvailFields)

   734     {

   735 

   736     _LIT(KPosFieldAvailableErr, "Method IsPositionFieldAvailable return incorrect value, should be availabe");

   737     _LIT(KPosFieldAvailableErr2, "Method IsPositionFieldAvailable return incorrect value, should not be available");

   738     

   739     TInt err=0;

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

   741         {

   742         if (aAvailFields[i])

   743             {

   744             AssertTrueSecL(aLandmark.IsPositionFieldAvailable((TUint16)aReqFields[i]), KPosFieldAvailableErr);

   745             TPtrC value;

   746             err = aLandmark.GetPositionField((TUint16)aReqFields[i], value); 

   747             AssertTrueSecL(err == KErrNone, KPosFieldAvailableErr, err);

   748             }

   749         else

   750             {

   751             AssertTrueSecL(!aLandmark.IsPositionFieldAvailable((TUint16)aReqFields[i]), KPosFieldAvailableErr);

   752             TPtrC value;

   753             err = aLandmark.GetPositionField((TUint16)aReqFields[i], value); 

   754             AssertTrueSecL(err == KErrNotFound, KPosFieldAvailableErr2, err); 

   755             }

   756         }

   757     

   758     // Check some fields not avail

   759     

   760     for (TUint16 j = EPositionFieldCompassCapabilitiesBegin; j <=EPositionFieldCompassCapabilitiesBegin+50; j++)

   761         {

   762 	    AssertTrueSecL(!aLandmark.IsPositionFieldAvailable(j), KPosFieldAvailableErr2);

   763         TPtrC value;

   764         err = aLandmark.GetPositionField(j, value); 

   765         AssertTrueSecL(err == KErrNotFound, KPosFieldAvailableErr2, err); 

   766         }

   767     for (TUint16 k =EPositionFieldSatelliteCapabilitiesBegin; k <=EPositionFieldSatelliteGeoidalSeparation; k++)

   768         {

   769         AssertTrueSecL(!aLandmark.IsPositionFieldAvailable(k), KPosFieldAvailableErr2);

   770         TPtrC value;

   771         err = aLandmark.GetPositionField(k, value); 

   772         AssertTrueSecL(err == KErrNotFound, KPosFieldAvailableErr2, err); 

   773         }

   774 

   775     AssertTrueSecL(!aLandmark.IsPositionFieldAvailable(EPositionFieldIdLast), KPosFieldAvailableErr2);

   776     TPtrC value;

   777     err = aLandmark.GetPositionField(EPositionFieldIdLast, value); 

   778     AssertTrueSecL(err == KErrNotFound, KPosFieldAvailableErr2, err); 

   779     }

   780 

   781 // ---------------------------------------------------------

   782 // CPosTp18::ChechPartialLandmarkL

   783 //

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

   785 // ---------------------------------------------------------

   786 //

   787 void CPosTp18::CheckPartialLandmarkL(const CPosLandmark& aLandmark, 

   788                                      const CPosLandmark::TAttributes& aAttr)

   789     {

   790     _LIT(KPartialIdErr, "Incorrect Id when reading from a Partial landmark");

   791     _LIT(KPartialCategoryInfoErr, "Incorrect Category info when reading from a Partial landmark");

   792 

   793     TPosLmItemId id = aLandmark.LandmarkId();

   794     AssertTrueSecL(id != 0, KPartialIdErr); 

   795     

   796     TInt err;

   797     TPtrC name;

   798     err = aLandmark.GetLandmarkName(name);

   799     CheckPartialErrorCodeL(aAttr & CPosLandmark::ELandmarkName, err); 

   800     

   801     TReal32 coverageR;     

   802     err = aLandmark.GetCoverageRadius(coverageR);

   803     CheckPartialErrorCodeL(aAttr & CPosLandmark::ECoverageRadius, err);

   804     

   805     TPtrC desc;

   806     err = aLandmark.GetLandmarkDescription(desc); 

   807     CheckPartialErrorCodeL(aAttr & CPosLandmark::EDescription, err);

   808     

   809     TPtrC iconName;

   810     TInt iconIndex;

   811     TInt iconMaskIndex;

   812     err = aLandmark.GetIcon(iconName, iconIndex, iconMaskIndex); 

   813     CheckPartialErrorCodeL(aAttr & CPosLandmark::EIcon, err);

   814     

   815     RArray<TPosLmItemId> categories;

   816     CleanupClosePushL(categories);

   817 

   818     aLandmark.GetCategoriesL(categories);

   819     if (aAttr & CPosLandmark::ECategoryInfo)

   820         {

   821         AssertTrueSecL(categories.Count() != 0, KPartialCategoryInfoErr);

   822         }

   823     else

   824         {

   825         AssertTrueSecL(categories.Count() == 0, KPartialCategoryInfoErr);

   826         }

   827     CleanupStack::PopAndDestroy(&categories);

   828 

   829     TLocality loc;

   830     err = aLandmark.GetPosition(loc); 

   831     CheckPartialErrorCodeL(aAttr & CPosLandmark::EPosition, err);

   832    

   833     }

   834 

   835 // ---------------------------------------------------------

   836 // CPosTp18::ChechPartialErrorCodeL

   837 //

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

   839 // ---------------------------------------------------------

   840 //

   841 void CPosTp18::CheckPartialErrorCodeL(const TBool aPartial, const TInt aErr)

   842     {

   843     _LIT(KPartialLmErr, "Incorrect error code returned when reading from a Partial landmark");

   844 

   845     if (aPartial)

   846         {

   847         AssertTrueSecL(aErr == KErrNone, KPartialLmErr); 

   848         }

   849     else

   850         {

   851         AssertTrueSecL(aErr == KErrNotFound, KPartialLmErr);

   852         }

   853     }

   854 

   855 //  End of File