1 /*

     2 * Copyright (c) 2007 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:    CGlxAttributeContext unit tests

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 //  CLASS HEADER

    22 #include "UT_CGlxAttributeContext.h"

    23 

    24 //  EXTERNAL INCLUDES

    25 #include <digia/eunit/eunitmacros.h>

    26 

    27 #include <e32std.h>

    28 

    29 #include <mpxmediageneraldefs.h>

    30 

    31 #include <glxdrmutility.h>

    32 

    33 //  INTERNAL INCLUDES

    34 #include "glxattributecontext.h"

    35 

    36 const TInt KNumberOfMedia = 9;

    37 const TInt KFrontOffset = 2;

    38 const TInt KRearOffset = 2;

    39 const TInt KItemsInRange = 1 + KFrontOffset + KRearOffset;

    40 const TInt KOneItem = 1;

    41 const TInt KGranularityLessThanRange = 2;

    42 const TInt KGranularityGreaterThanRange = KItemsInRange + 2;

    43 

    44 void CGlxDRMUtility::Close()

    45     {

    46     delete this;

    47     }

    48     

    49 TBool CGlxDRMUtility::CheckOpenRightsL(const TDesC&, TBool)

    50     {

    51     return ETrue;

    52     }

    53     

    54 CGlxDRMUtility* CGlxDRMUtility::InstanceL()

    55     {

    56     CGlxDRMUtility* drm = new(ELeave)CGlxDRMUtility();

    57     return drm;

    58     }

    59     

    60 TSize CGlxDRMUtility::DRMThumbnailSize(TSize& aSize)

    61     {

    62     return aSize;

    63     }

    64     

    65 CGlxDRMUtility::CGlxDRMUtility()

    66     {

    67     

    68     }

    69     

    70 CGlxDRMUtility::~CGlxDRMUtility()

    71     {

    72     

    73     }

    74 

    75 // CONSTRUCTION

    76 UT_CGlxAttributeContext* UT_CGlxAttributeContext::NewL()

    77     {

    78     UT_CGlxAttributeContext* self = UT_CGlxAttributeContext::NewLC();

    79     CleanupStack::Pop();

    80 

    81     return self;

    82     }

    83 

    84 UT_CGlxAttributeContext* UT_CGlxAttributeContext::NewLC()

    85     {

    86     UT_CGlxAttributeContext* self = new( ELeave ) UT_CGlxAttributeContext();

    87     CleanupStack::PushL( self );

    88 

    89     self->ConstructL();

    90 

    91     return self;

    92     }

    93 

    94 // Destructor (virtual by CBase)

    95 UT_CGlxAttributeContext::~UT_CGlxAttributeContext()

    96     {

    97     }

    98 

    99 // Default constructor

   100 UT_CGlxAttributeContext::UT_CGlxAttributeContext()

   101     {

   102     }

   103 

   104 // Second phase construct

   105 void UT_CGlxAttributeContext::ConstructL()

   106     {

   107     // The ConstructL from the base class CEUnitTestSuiteClass must be called.

   108     // It generates the test case table.

   109     CEUnitTestSuiteClass::ConstructL();

   110     }

   111 

   112 //  METHODS

   113 

   114 void UT_CGlxAttributeContext::SetupL(  )

   115     {

   116     iAttributeContext = CGlxDefaultAttributeContext::NewL();

   117     }

   118 

   119 void UT_CGlxAttributeContext::Teardown(  )

   120     {

   121     delete iAttributeContext;

   122     iAttributeContext = NULL;

   123     }

   124 

   125 void UT_CGlxAttributeContext::UT_CGlxAttributeContext_CGlxAttributeContextL(  )

   126     {

   127     EUNIT_ASSERT( EFalse );

   128     }

   129 

   130 void UT_CGlxAttributeContext::UT_CGlxAttributeContext_AddAttributeLL(  )

   131     {

   132     EUNIT_ASSERT( EFalse );

   133     }

   134 

   135 void UT_CGlxAttributeContext::UT_CGlxAttributeContext_RemoveAttributeL(  )

   136     {

   137     EUNIT_ASSERT( EFalse );

   138     }

   139 

   140 void UT_CGlxAttributeContext::UT_CGlxAttributeContext_AllAttributesLL(  )

   141     {

   142     EUNIT_ASSERT( EFalse );

   143     }

   144 

   145 void UT_CGlxAttributeContext::UT_CGlxAttributeContext_AttributeRequestLL(  )

   146     {

   147     // Setup test

   148     SetupAttributeRequestTestL();

   149 

   150     FetchItems_NoMediaL();

   151     FetchOneItem_IndexZeroL();

   152     FetchOneItem_IndexOneL();

   153     FetchOneItem_IndexTwoL();

   154     FetchOneItem_IndexThreeL();

   155     FetchOneItem_IndexFourL();

   156     FetchItems_GranularityLessThanRange_IndexZeroL();

   157     FetchItems_GranularityLessThanRange_IndexOneL();

   158     FetchItems_GranularityLessThanRange_IndexTwoL();

   159     FetchItems_GranularityLessThanRange_IndexThreeL();

   160     FetchItems_GranularityLessThanRange_IndexFourL();

   161     FetchItems_GranularityLessThanRange_IndexFiveL();

   162     FetchItems_GranularityGreaterThanRangeL();

   163     }

   164 

   165 void UT_CGlxAttributeContext::SetupAttributeRequestTestL()

   166     {

   167     // Initial offsets, rear is 2 and front is 2

   168     EUNIT_PRINT(_L("Initial offsets: rear is 2 and front is 2"));

   169     iAttributeContext->SetRangeOffsets(KRearOffset, KFrontOffset);

   170 

   171     // Initial attributes to fetch

   172     EUNIT_PRINT(_L("Initial attributes: Title and date"));

   173     iAttributeContext->AddAttributeL(KMPXMediaGeneralTitle);

   174     iAttributeContext->AddAttributeL(KMPXMediaGeneralDate);

   175     }

   176 

   177 void UT_CGlxAttributeContext::FetchItems_NoMediaL()

   178     {

   179     // Fetch items with empty media list

   180     CGlxMediaListTest* mediaList = CGlxMediaListTest::NewL(0);

   181     CleanupStack::PushL(mediaList);

   182 

   183     RArray<TInt> itemIndices;

   184     CleanupClosePushL(itemIndices);

   185 

   186     RArray<TMPXAttribute> attributes;

   187     CleanupClosePushL(attributes);

   188 

   189     CMPXAttributeSpecs* attributeSpecs = NULL;

   190 

   191     EUNIT_PRINT(_L("Fetch items with empty media list"));

   192     iAttributeContext->AttributeRequestL(mediaList, itemIndices, attributes, attributeSpecs);

   193 

   194     EUNIT_PRINT(_L("Check no item indices returned"));

   195     EUNIT_ASSERT(itemIndices.Count() == 0);

   196 

   197     EUNIT_PRINT(_L("Check no attributes returned"));

   198     EUNIT_ASSERT(attributes.Count() == 0);

   199 

   200     delete attributeSpecs;

   201     attributeSpecs = NULL;

   202 

   203     CleanupStack::Pop();

   204     attributes.Close();

   205 

   206     CleanupStack::Pop();

   207     itemIndices.Close();

   208 

   209     CleanupStack::PopAndDestroy();

   210     }

   211 

   212 void UT_CGlxAttributeContext::FetchOneItem_IndexZeroL()

   213     {

   214     // Fetch 1 item with focus on index 0

   215     CGlxMediaListTest* mediaList = CGlxMediaListTest::NewL(KNumberOfMedia);

   216     CleanupStack::PushL(mediaList);

   217 

   218     mediaList->SetFocusL(NGlxListDefs::EAbsolute, 0);

   219 

   220     RArray<TInt> itemIndices;

   221     CleanupClosePushL(itemIndices);

   222 

   223     RArray<TMPXAttribute> attributes;

   224     CleanupClosePushL(attributes);

   225 

   226     CMPXAttributeSpecs* attributeSpecs = NULL;

   227 

   228     EUNIT_PRINT(_L("Fetch items with focus on index 0: granularity is 1"));

   229     iAttributeContext->SetGranularity(KOneItem);

   230     iAttributeContext->AttributeRequestL(mediaList, itemIndices, attributes, attributeSpecs);

   231 

   232     EUNIT_PRINT(_L("Check 1 item index is returned: Item index is 0"));

   233     EUNIT_ASSERT((itemIndices.Count() == KOneItem) && itemIndices[0] == 0);

   234 

   235     TBool titleAttributeFound = FindAttribute(attributes, KMPXMediaGeneralTitle);

   236     TBool dateAttributeFound = FindAttribute(attributes, KMPXMediaGeneralDate);

   237 

   238     EUNIT_PRINT(_L("Check 2 attributes returned: Title and date"));

   239     EUNIT_ASSERT((attributes.Count() == 2) && titleAttributeFound && dateAttributeFound);

   240 

   241     delete attributeSpecs;

   242     attributeSpecs = NULL;

   243 

   244     CleanupStack::Pop();

   245     attributes.Close();

   246 

   247     CleanupStack::Pop();

   248     itemIndices.Close();

   249 

   250     CleanupStack::PopAndDestroy();

   251     }

   252 

   253 void UT_CGlxAttributeContext::FetchOneItem_IndexOneL()

   254     {

   255     // Fetch 1 item with focus on index 1

   256     CGlxMediaListTest* mediaList = CGlxMediaListTest::NewL(KNumberOfMedia);

   257     CleanupStack::PushL(mediaList);

   258 

   259     mediaList->SetFocusL(NGlxListDefs::EAbsolute, 1);

   260 

   261     RArray<TInt> itemIndices;

   262     CleanupClosePushL(itemIndices);

   263 

   264     RArray<TMPXAttribute> attributes;

   265     CleanupClosePushL(attributes);

   266 

   267     CMPXAttributeSpecs* attributeSpecs = NULL;

   268 

   269     EUNIT_PRINT(_L("Fetch items with focus on index 1: granularity is 1"));

   270     iAttributeContext->SetGranularity(KOneItem);

   271     iAttributeContext->AttributeRequestL(mediaList, itemIndices, attributes, attributeSpecs);

   272 

   273     EUNIT_PRINT(_L("Check 1 item index is returned: Item index is 1"));

   274     EUNIT_ASSERT((itemIndices.Count() == KOneItem) && itemIndices[0] == 1);

   275 

   276     TBool titleAttributeFound = FindAttribute(attributes, KMPXMediaGeneralTitle);

   277     TBool dateAttributeFound = FindAttribute(attributes, KMPXMediaGeneralDate);

   278 

   279     EUNIT_PRINT(_L("Check 2 attributes returned: Title and date"));

   280     EUNIT_ASSERT((attributes.Count() == 2) && titleAttributeFound && dateAttributeFound);

   281 

   282     delete attributeSpecs;

   283     attributeSpecs = NULL;

   284 

   285     CleanupStack::Pop();

   286     attributes.Close();

   287 

   288     CleanupStack::Pop();

   289     itemIndices.Close();

   290 

   291     CleanupStack::PopAndDestroy();

   292     }

   293 

   294 void UT_CGlxAttributeContext::FetchOneItem_IndexTwoL()

   295     {

   296     // Fetch 1 item with focus on index 2

   297     CGlxMediaListTest* mediaList = CGlxMediaListTest::NewL(KNumberOfMedia);

   298     CleanupStack::PushL(mediaList);

   299 

   300     mediaList->SetFocusL(NGlxListDefs::EAbsolute, 2);

   301 

   302     RArray<TInt> itemIndices;

   303     CleanupClosePushL(itemIndices);

   304 

   305     RArray<TMPXAttribute> attributes;

   306     CleanupClosePushL(attributes);

   307 

   308     CMPXAttributeSpecs* attributeSpecs = NULL;

   309 

   310     EUNIT_PRINT(_L("Fetch items with focus on index 2: granularity is 1"));

   311     iAttributeContext->SetGranularity(KOneItem);

   312     iAttributeContext->AttributeRequestL(mediaList, itemIndices, attributes, attributeSpecs);

   313 

   314     EUNIT_PRINT(_L("Check 1 item index is returned: Item index is 2"));

   315     EUNIT_ASSERT((itemIndices.Count() == KOneItem) && itemIndices[0] == 2);

   316 

   317     TBool titleAttributeFound = FindAttribute(attributes, KMPXMediaGeneralTitle);

   318     TBool dateAttributeFound = FindAttribute(attributes, KMPXMediaGeneralDate);

   319 

   320     EUNIT_PRINT(_L("Check 1 attribute returned: Date"));

   321     EUNIT_ASSERT((attributes.Count() == 1) && !titleAttributeFound && dateAttributeFound);

   322 

   323     delete attributeSpecs;

   324     attributeSpecs = NULL;

   325 

   326     CleanupStack::Pop();

   327     attributes.Close();

   328 

   329     CleanupStack::Pop();

   330     itemIndices.Close();

   331 

   332     CleanupStack::PopAndDestroy();

   333     }

   334 

   335 void UT_CGlxAttributeContext::FetchOneItem_IndexThreeL()

   336     {

   337     // Fetch 1 item with focus on index 3

   338     CGlxMediaListTest* mediaList = CGlxMediaListTest::NewL(KNumberOfMedia);

   339     CleanupStack::PushL(mediaList);

   340 

   341     mediaList->SetFocusL(NGlxListDefs::EAbsolute, 3);

   342 

   343     RArray<TInt> itemIndices;

   344     CleanupClosePushL(itemIndices);

   345 

   346     RArray<TMPXAttribute> attributes;

   347     CleanupClosePushL(attributes);

   348 

   349     CMPXAttributeSpecs* attributeSpecs = NULL;

   350 

   351     EUNIT_PRINT(_L("Fetch items with focus on index 3: granularity is 1"));

   352     iAttributeContext->SetGranularity(KOneItem);

   353     iAttributeContext->AttributeRequestL(mediaList, itemIndices, attributes, attributeSpecs);

   354 

   355     EUNIT_PRINT(_L("Check 1 item index is returned: Item index is 3"));

   356     EUNIT_ASSERT((itemIndices.Count() == KOneItem) && itemIndices[0] == 3);

   357 

   358     TBool titleAttributeFound = FindAttribute(attributes, KMPXMediaGeneralTitle);

   359     TBool dateAttributeFound = FindAttribute(attributes, KMPXMediaGeneralDate);

   360 

   361     EUNIT_PRINT(_L("Check 1 attribute returned: Title"));

   362     EUNIT_ASSERT((attributes.Count() == 1) && titleAttributeFound && !dateAttributeFound);

   363 

   364     delete attributeSpecs;

   365     attributeSpecs = NULL;

   366 

   367     CleanupStack::Pop();

   368     attributes.Close();

   369 

   370     CleanupStack::Pop();

   371     itemIndices.Close();

   372 

   373     CleanupStack::PopAndDestroy();

   374     }

   375 

   376 void UT_CGlxAttributeContext::FetchOneItem_IndexFourL()

   377     {

   378     // Fetch 1 item with focus on index 4

   379     CGlxMediaListTest* mediaList = CGlxMediaListTest::NewL(KNumberOfMedia);

   380     CleanupStack::PushL(mediaList);

   381 

   382     mediaList->SetFocusL(NGlxListDefs::EAbsolute, 4);

   383 

   384     RArray<TInt> itemIndices;

   385     CleanupClosePushL(itemIndices);

   386 

   387     RArray<TMPXAttribute> attributes;

   388     CleanupClosePushL(attributes);

   389 

   390     CMPXAttributeSpecs* attributeSpecs = NULL;

   391 

   392     EUNIT_PRINT(_L("Fetch items with focus on index 4: granularity is 1"));

   393     iAttributeContext->SetGranularity(KOneItem);

   394     iAttributeContext->AttributeRequestL(mediaList, itemIndices, attributes, attributeSpecs);

   395 

   396     EUNIT_PRINT(_L("Check 1 item index is returned: Item index is 5"));

   397     EUNIT_ASSERT((itemIndices.Count() == KOneItem) && itemIndices[0] == 5);

   398 

   399     TBool titleAttributeFound = FindAttribute(attributes, KMPXMediaGeneralTitle);

   400     TBool dateAttributeFound = FindAttribute(attributes, KMPXMediaGeneralDate);

   401 

   402     EUNIT_PRINT(_L("Check 2 attributes returned: Title and date"));

   403     EUNIT_ASSERT((attributes.Count() == 2) && titleAttributeFound && dateAttributeFound);

   404 

   405     delete attributeSpecs;

   406     attributeSpecs = NULL;

   407 

   408     CleanupStack::Pop();

   409     attributes.Close();

   410 

   411     CleanupStack::Pop();

   412     itemIndices.Close();

   413 

   414     CleanupStack::PopAndDestroy();

   415     }

   416 

   417 void UT_CGlxAttributeContext::FetchItems_GranularityLessThanRange_IndexZeroL()

   418     {

   419     // Fetch items with focus on index 0 (granularity less than range)

   420     CGlxMediaListTest* mediaList = CGlxMediaListTest::NewL(KNumberOfMedia);

   421     CleanupStack::PushL(mediaList);

   422 

   423     mediaList->SetFocusL(NGlxListDefs::EAbsolute, 0);

   424 

   425     RArray<TInt> itemIndices;

   426     CleanupClosePushL(itemIndices);

   427 

   428     RArray<TMPXAttribute> attributes;

   429     CleanupClosePushL(attributes);

   430 

   431     CMPXAttributeSpecs* attributeSpecs = NULL;

   432 

   433     EUNIT_PRINT(_L("Fetch items with focus on index 0: granularity is 2"));

   434     iAttributeContext->SetGranularity(KGranularityLessThanRange);

   435     iAttributeContext->AttributeRequestL(mediaList, itemIndices, attributes, attributeSpecs);

   436 

   437     EUNIT_PRINT(_L("Check 2 item indices are returned: Item indices 0 and 1"));

   438     EUNIT_ASSERT((itemIndices.Count() == KGranularityLessThanRange) && itemIndices[0] == 0 && itemIndices[1] == 1);

   439 

   440     TBool titleAttributeFound = FindAttribute(attributes, KMPXMediaGeneralTitle);

   441     TBool dateAttributeFound = FindAttribute(attributes, KMPXMediaGeneralDate);

   442 

   443     EUNIT_PRINT(_L("Check 2 attributes returned: Title and date"));

   444     EUNIT_ASSERT((attributes.Count() == 2) && titleAttributeFound && dateAttributeFound);

   445 

   446     delete attributeSpecs;

   447     attributeSpecs = NULL;

   448 

   449     CleanupStack::Pop();

   450     attributes.Close();

   451 

   452     CleanupStack::Pop();

   453     itemIndices.Close();

   454 

   455     CleanupStack::PopAndDestroy();

   456     }

   457 

   458 void UT_CGlxAttributeContext::FetchItems_GranularityLessThanRange_IndexOneL()

   459     {

   460     // Fetch items with focus on index 1 (granularity less than range)

   461     CGlxMediaListTest* mediaList = CGlxMediaListTest::NewL(KNumberOfMedia);

   462     CleanupStack::PushL(mediaList);

   463 

   464     mediaList->SetFocusL(NGlxListDefs::EAbsolute, 1);

   465 

   466     RArray<TInt> itemIndices;

   467     CleanupClosePushL(itemIndices);

   468 

   469     RArray<TMPXAttribute> attributes;

   470     CleanupClosePushL(attributes);

   471 

   472     CMPXAttributeSpecs* attributeSpecs = NULL;

   473 

   474     EUNIT_PRINT(_L("Fetch items with focus on index 1: granularity is 2"));

   475     iAttributeContext->SetGranularity(KGranularityLessThanRange);

   476     iAttributeContext->AttributeRequestL(mediaList, itemIndices, attributes, attributeSpecs);

   477 

   478     EUNIT_PRINT(_L("Check 2 item indices are returned: Item indices 1 and 2"));

   479     EUNIT_ASSERT((itemIndices.Count() == KGranularityLessThanRange) && itemIndices[0] == 1 && itemIndices[1] == 2);

   480 

   481     TBool titleAttributeFound = FindAttribute(attributes, KMPXMediaGeneralTitle);

   482     TBool dateAttributeFound = FindAttribute(attributes, KMPXMediaGeneralDate);

   483 

   484     EUNIT_PRINT(_L("Check 2 attributes returned: Title and date"));

   485     EUNIT_ASSERT((attributes.Count() == 2) && titleAttributeFound && dateAttributeFound);

   486 

   487     delete attributeSpecs;

   488     attributeSpecs = NULL;

   489 

   490     CleanupStack::Pop();

   491     attributes.Close();

   492 

   493     CleanupStack::Pop();

   494     itemIndices.Close();

   495 

   496     CleanupStack::PopAndDestroy();

   497     }

   498 

   499 void UT_CGlxAttributeContext::FetchItems_GranularityLessThanRange_IndexTwoL()

   500     {

   501     // Fetch items with focus on index 2 (granularity less than range)

   502     CGlxMediaListTest* mediaList = CGlxMediaListTest::NewL(KNumberOfMedia);

   503     CleanupStack::PushL(mediaList);

   504 

   505     mediaList->SetFocusL(NGlxListDefs::EAbsolute, 2);

   506 

   507     RArray<TInt> itemIndices;

   508     CleanupClosePushL(itemIndices);

   509 

   510     RArray<TMPXAttribute> attributes;

   511     CleanupClosePushL(attributes);

   512 

   513     CMPXAttributeSpecs* attributeSpecs = NULL;

   514 

   515     EUNIT_PRINT(_L("Fetch items with focus on index 2: granularity is 2"));

   516     iAttributeContext->SetGranularity(KGranularityLessThanRange);

   517     iAttributeContext->AttributeRequestL(mediaList, itemIndices, attributes, attributeSpecs);

   518 

   519     EUNIT_PRINT(_L("Check 2 item indices are returned: Item indices 2 and 3"));

   520     EUNIT_ASSERT((itemIndices.Count() == KGranularityLessThanRange) && itemIndices[0] == 2 && itemIndices[1] == 3);

   521 

   522     TBool titleAttributeFound = FindAttribute(attributes, KMPXMediaGeneralTitle);

   523     TBool dateAttributeFound = FindAttribute(attributes, KMPXMediaGeneralDate);

   524 

   525     EUNIT_PRINT(_L("Check 2 attributes returned: Title and date"));

   526     EUNIT_ASSERT((attributes.Count() == 2) && titleAttributeFound && dateAttributeFound);

   527 

   528     delete attributeSpecs;

   529     attributeSpecs = NULL;

   530 

   531     CleanupStack::Pop();

   532     attributes.Close();

   533 

   534     CleanupStack::Pop();

   535     itemIndices.Close();

   536 

   537     CleanupStack::PopAndDestroy();

   538     }

   539 

   540 void UT_CGlxAttributeContext::FetchItems_GranularityLessThanRange_IndexThreeL()

   541     {

   542     // Fetch items with focus on index 3 (granularity less than range)

   543     CGlxMediaListTest* mediaList = CGlxMediaListTest::NewL(KNumberOfMedia);

   544     CleanupStack::PushL(mediaList);

   545 

   546     mediaList->SetFocusL(NGlxListDefs::EAbsolute, 3);

   547 

   548     RArray<TInt> itemIndices;

   549     CleanupClosePushL(itemIndices);

   550 

   551     RArray<TMPXAttribute> attributes;

   552     CleanupClosePushL(attributes);

   553 

   554     CMPXAttributeSpecs* attributeSpecs = NULL;

   555 

   556     EUNIT_PRINT(_L("Fetch items with focus on index 3: granularity is 2"));

   557     iAttributeContext->SetGranularity(KGranularityLessThanRange);

   558     iAttributeContext->AttributeRequestL(mediaList, itemIndices, attributes, attributeSpecs);

   559 

   560     EUNIT_PRINT(_L("Check 2 item indices are returned: Item indices 3 and 2"));

   561     EUNIT_ASSERT((itemIndices.Count() == KGranularityLessThanRange) && itemIndices[0] == 3 && itemIndices[1] == 2);

   562 

   563     TBool titleAttributeFound = FindAttribute(attributes, KMPXMediaGeneralTitle);

   564     TBool dateAttributeFound = FindAttribute(attributes, KMPXMediaGeneralDate);

   565 

   566     EUNIT_PRINT(_L("Check 2 attributes returned: Title and date"));

   567     EUNIT_ASSERT((attributes.Count() == 2) && titleAttributeFound && dateAttributeFound);

   568 

   569     delete attributeSpecs;

   570     attributeSpecs = NULL;

   571 

   572     CleanupStack::Pop();

   573     attributes.Close();

   574 

   575     CleanupStack::Pop();

   576     itemIndices.Close();

   577 

   578     CleanupStack::PopAndDestroy();

   579     }

   580 

   581 void UT_CGlxAttributeContext::FetchItems_GranularityLessThanRange_IndexFourL()

   582     {

   583     // Fetch items with focus on index 4 (granularity less than range)

   584     CGlxMediaListTest* mediaList = CGlxMediaListTest::NewL(KNumberOfMedia);

   585     CleanupStack::PushL(mediaList);

   586 

   587     mediaList->SetFocusL(NGlxListDefs::EAbsolute, 4);

   588 

   589     RArray<TInt> itemIndices;

   590     CleanupClosePushL(itemIndices);

   591 

   592     RArray<TMPXAttribute> attributes;

   593     CleanupClosePushL(attributes);

   594 

   595     CMPXAttributeSpecs* attributeSpecs = NULL;

   596 

   597     EUNIT_PRINT(_L("Fetch items with focus on index 4: granularity is 2"));

   598     iAttributeContext->SetGranularity(KGranularityLessThanRange);

   599     iAttributeContext->AttributeRequestL(mediaList, itemIndices, attributes, attributeSpecs);

   600 

   601     EUNIT_PRINT(_L("Check 2 item indices are returned: Item indices 5 and 3"));

   602     EUNIT_ASSERT((itemIndices.Count() == KGranularityLessThanRange) && itemIndices[0] == 5 && itemIndices[1] == 3);

   603 

   604     TBool titleAttributeFound = FindAttribute(attributes, KMPXMediaGeneralTitle);

   605     TBool dateAttributeFound = FindAttribute(attributes, KMPXMediaGeneralDate);

   606 

   607     EUNIT_PRINT(_L("Check 2 attributes returned: Title and date"));

   608     EUNIT_ASSERT((attributes.Count() == 2) && titleAttributeFound && dateAttributeFound);

   609 

   610     delete attributeSpecs;

   611     attributeSpecs = NULL;

   612 

   613     CleanupStack::Pop();

   614     attributes.Close();

   615 

   616     CleanupStack::Pop();

   617     itemIndices.Close();

   618 

   619     CleanupStack::PopAndDestroy();

   620     }

   621 

   622 void UT_CGlxAttributeContext::FetchItems_GranularityLessThanRange_IndexFiveL()

   623     {

   624     // Fetch items with focus on index 5 (granularity less than range)

   625     CGlxMediaListTest* mediaList = CGlxMediaListTest::NewL(KNumberOfMedia);

   626     CleanupStack::PushL(mediaList);

   627 

   628     mediaList->SetFocusL(NGlxListDefs::EAbsolute, 5);

   629 

   630     RArray<TInt> itemIndices;

   631     CleanupClosePushL(itemIndices);

   632 

   633     RArray<TMPXAttribute> attributes;

   634     CleanupClosePushL(attributes);

   635 

   636     CMPXAttributeSpecs* attributeSpecs = NULL;

   637 

   638     EUNIT_PRINT(_L("Fetch items with focus on index 5: granularity is 2"));

   639     iAttributeContext->SetGranularity(KGranularityLessThanRange);

   640     iAttributeContext->AttributeRequestL(mediaList, itemIndices, attributes, attributeSpecs);

   641 

   642     EUNIT_PRINT(_L("Check 2 item indices are returned: Item indices 5 and 6"));

   643     EUNIT_ASSERT((itemIndices.Count() == KGranularityLessThanRange) && itemIndices[0] == 5 && itemIndices[1] == 6);

   644 

   645     TBool titleAttributeFound = FindAttribute(attributes, KMPXMediaGeneralTitle);

   646     TBool dateAttributeFound = FindAttribute(attributes, KMPXMediaGeneralDate);

   647 

   648     EUNIT_PRINT(_L("Check 2 attributes returned: Title and date"));

   649     EUNIT_ASSERT((attributes.Count() == 2) && titleAttributeFound && dateAttributeFound);

   650 

   651     delete attributeSpecs;

   652     attributeSpecs = NULL;

   653 

   654     CleanupStack::Pop();

   655     attributes.Close();

   656 

   657     CleanupStack::Pop();

   658     itemIndices.Close();

   659 

   660     CleanupStack::PopAndDestroy();

   661     }

   662 

   663 void UT_CGlxAttributeContext::FetchItems_GranularityGreaterThanRangeL()

   664     {

   665     // Fetch items with focus on index 4 (granularity greater than range)

   666     CGlxMediaListTest* mediaList = CGlxMediaListTest::NewL(KNumberOfMedia);

   667     CleanupStack::PushL(mediaList);

   668 

   669     mediaList->SetFocusL(NGlxListDefs::EAbsolute, 4);

   670 

   671     RArray<TInt> itemIndices;

   672     CleanupClosePushL(itemIndices);

   673 

   674     RArray<TMPXAttribute> attributes;

   675     CleanupClosePushL(attributes);

   676 

   677     CMPXAttributeSpecs* attributeSpecs = NULL;

   678 

   679     EUNIT_PRINT(_L("Fetch items with focus on index 4: granularity is 7"));

   680     iAttributeContext->SetGranularity(KGranularityGreaterThanRange);

   681     iAttributeContext->AttributeRequestL(mediaList, itemIndices, attributes, attributeSpecs);

   682 

   683     EUNIT_PRINT(_L("Check 4 item indices are returned: Item indices 5, 3, 6 and 2"));

   684     EUNIT_ASSERT((itemIndices.Count() == 4) && itemIndices[0] == 5 && itemIndices[1] == 3 && itemIndices[2] == 6 && itemIndices[3] == 2);

   685 

   686     TBool titleAttributeFound = FindAttribute(attributes, KMPXMediaGeneralTitle);

   687     TBool dateAttributeFound = FindAttribute(attributes, KMPXMediaGeneralDate);

   688 

   689     EUNIT_PRINT(_L("Check 2 attributes returned: Title and date"));

   690     EUNIT_ASSERT((attributes.Count() == 2) && titleAttributeFound && dateAttributeFound);

   691 

   692     delete attributeSpecs;

   693     attributeSpecs = NULL;

   694 

   695     CleanupStack::Pop();

   696     attributes.Close();

   697 

   698     CleanupStack::Pop();

   699     itemIndices.Close();

   700 

   701     CleanupStack::PopAndDestroy();

   702     }

   703 

   704 TBool UT_CGlxAttributeContext::FindAttribute(RArray<TMPXAttribute>& aAttributes, const TMPXAttribute& aAttribute)

   705     {

   706     TIdentityRelation<TMPXAttribute> match(&TMPXAttribute::Match);

   707     TInt index = aAttributes.Find(aAttribute, match);

   708     if (index == KErrNotFound)

   709         {

   710         return EFalse;

   711         }

   712 

   713     return ETrue;

   714     }

   715 

   716 UT_CGlxAttributeContext::CGlxMediaListTest* UT_CGlxAttributeContext::CGlxMediaListTest::NewL(TUint aNumberOfMedia)

   717     {

   718     CGlxMediaListTest* self = new (ELeave) CGlxMediaListTest();

   719     CleanupStack::PushL(self);

   720     self->ConstructL(aNumberOfMedia);

   721     CleanupStack::Pop();

   722     return self;

   723     }

   724 

   725 UT_CGlxAttributeContext::CGlxMediaListTest::~CGlxMediaListTest()

   726     {

   727     for (TInt count = 0; count < iMedias.Count(); ++count)

   728         {

   729         delete iMedias[count];

   730         }

   731 

   732     iMedias.Close();

   733     iItems.Close();

   734     iSelectedItems.Close();

   735     }

   736 

   737 UT_CGlxAttributeContext::CGlxMediaListTest::CGlxMediaListTest() :

   738         iFocusIndex(KErrNotFound), iMedias(), iItems(), iSelectedItems()

   739     {

   740     }

   741 

   742 void UT_CGlxAttributeContext::CGlxMediaListTest::ConstructL(TUint aNumberOfMedia)

   743     {

   744     for (TInt count = 0; count < aNumberOfMedia; ++count)

   745         {

   746         CreateMediaL(count + 1);

   747         }

   748     }

   749 

   750 void UT_CGlxAttributeContext::CGlxMediaListTest::CreateMediaL(TUint aMediaId)

   751     {

   752     TGlxMediaId id(aMediaId);

   753     CGlxMedia* cGlxMedia = NULL;

   754 

   755     TInt modulo = (aMediaId - 1) % 5;

   756     if (modulo > 0)

   757         {

   758         cGlxMedia = new (ELeave) CGlxMedia(id);

   759         CleanupStack::PushL(cGlxMedia);

   760 

   761         if (modulo == 1)

   762             {

   763             // No attributes

   764             }

   765         else if (modulo == 2)

   766             {

   767             cGlxMedia->SetTextValueL(KMPXMediaGeneralTitle, _L("Title"));

   768             }

   769         else if (modulo == 3)

   770             {

   771             cGlxMedia->SetTextValueL(KMPXMediaGeneralDate, _L("Date"));

   772             }

   773         else if (modulo == 4)

   774             {

   775             cGlxMedia->SetTextValueL(KMPXMediaGeneralTitle, _L("Title"));

   776             cGlxMedia->SetTextValueL(KMPXMediaGeneralDate, _L("Date"));

   777             }

   778 

   779         iMedias.AppendL(cGlxMedia);

   780         CleanupStack::Pop();

   781         }

   782 

   783     TGlxMedia tGlxMedia(id, cGlxMedia);

   784     iItems.AppendL(tGlxMedia);

   785     }

   786 

   787 //  TEST TABLE

   788 

   789 EUNIT_BEGIN_TEST_TABLE(

   790     UT_CGlxAttributeContext,

   791     "Unit tests for CGlxAttributeContext",

   792     "UNIT" )

   793 /*

   794 EUNIT_TEST(

   795     "CGlxAttributeContext - test ",

   796     "CGlxAttributeContext",

   797     "CGlxAttributeContext",

   798     "FUNCTIONALITY",

   799     SetupL, UT_CGlxAttributeContext_CGlxAttributeContextL, Teardown)

   800 

   801 EUNIT_TEST(

   802     "AddAttributeL - test ",

   803     "CGlxAttributeContext",

   804     "AddAttributeL",

   805     "FUNCTIONALITY",

   806     SetupL, UT_CGlxAttributeContext_AddAttributeLL, Teardown)

   807 

   808 EUNIT_TEST(

   809     "RemoveAttribute - test ",

   810     "CGlxAttributeContext",

   811     "RemoveAttribute",

   812     "FUNCTIONALITY",

   813     SetupL, UT_CGlxAttributeContext_RemoveAttributeL, Teardown)

   814 

   815 EUNIT_TEST(

   816     "AllAttributesL - test ",

   817     "CGlxAttributeContext",

   818     "AllAttributesL",

   819     "FUNCTIONALITY",

   820     SetupL, UT_CGlxAttributeContext_AllAttributesLL, Teardown)

   821 */

   822 EUNIT_TEST(

   823     "AttributeRequestL - test ",

   824     "CGlxAttributeContext",

   825     "AttributeRequestL",

   826     "FUNCTIONALITY",

   827     SetupL, UT_CGlxAttributeContext_AttributeRequestLL, Teardown)

   828 

   829 

   830 EUNIT_END_TEST_TABLE

   831 

   832 //  END OF FILE