1 /*

     2 * Copyright (c) 2006 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 *

    16 */

    17 

    18 

    19 //  CLASS HEADER

    20 #include "UT_CFContextSourceSettingsManager.h"

    21 

    22 //  EXTERNAL INCLUDES

    23 #include <EUnitMacros.h>

    24 

    25 

    26 //  INTERNAL INCLUDES

    27 #include "cfcontextsourcesettingimpl.h"

    28 #include "cfcontextsourcesettingarrayimpl.h"

    29 #include "cfcontextsourcesettingparameterimpl.h"

    30 #include "cfcontextsourcesettingsmanagerimpl.h"

    31 #include "cfcontextsourcesettingarrayimpl.h"

    32 #include "cfenvutils.h"

    33 

    34 // Cleans up RKeyValueArray instance

    35 LOCAL_C void CleanupKeyValueArray( TAny* aArray )

    36     {

    37     static_cast<RKeyValueArray*>( aArray )->ResetAndDestroy();

    38     }

    39 

    40 // Cleanup item for RKeyValueArray object

    41 LOCAL_C void CleanupResetAndDestroyPushL( RKeyValueArray& aArray )

    42     {

    43     TCleanupItem item( CleanupKeyValueArray, &aArray );

    44     CleanupStack::PushL( item );

    45     }

    46 

    47 // CONSTRUCTION

    48 UT_CFContextSourceSettingsManager* UT_CFContextSourceSettingsManager::NewL()

    49     {

    50     UT_CFContextSourceSettingsManager* self = UT_CFContextSourceSettingsManager::NewLC();

    51     CleanupStack::Pop();

    52 

    53     return self;

    54     }

    55 

    56 UT_CFContextSourceSettingsManager* UT_CFContextSourceSettingsManager::NewLC()

    57     {

    58     UT_CFContextSourceSettingsManager* self = new( ELeave ) UT_CFContextSourceSettingsManager();

    59     CleanupStack::PushL( self );

    60 

    61     self->ConstructL();

    62 

    63     return self;

    64     }

    65 

    66 // Destructor (virtual by CBase)

    67 UT_CFContextSourceSettingsManager::~UT_CFContextSourceSettingsManager()

    68     {

    69     Teardown();

    70 

    71     // Enable screen saver

    72     CFEnvUtils::EnableScreenSaver( ETrue );

    73     }

    74 

    75 // Default constructor

    76 UT_CFContextSourceSettingsManager::UT_CFContextSourceSettingsManager()

    77     {

    78     }

    79 

    80 // Second phase construct

    81 void UT_CFContextSourceSettingsManager::ConstructL()

    82     {

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

    84     // It generates the test case table.

    85     CEUnitTestSuiteClass::ConstructL();

    86 

    87     // Disable screen saver

    88     CFEnvUtils::EnableScreenSaver( EFalse );

    89     }

    90 

    91 //  METHODS

    92 

    93 void UT_CFContextSourceSettingsManager::SetupEmptyL(  )

    94     {

    95 

    96     }

    97 

    98 void UT_CFContextSourceSettingsManager::SetupL(  )

    99     {

   100     User::LeaveIfError( iFs.Connect() );

   101     

   102     iContextSourceSettingImpl = CCFContextSourceSettingImpl::NewL();

   103     

   104     iContextSourceSettingParameterImpl =

   105         CCFContextSourceSettingParameterImpl::NewL();

   106     

   107     iContextSourceSettingsManagerImpl =

   108         CCFContextSourceSettingsManagerImpl::NewL( iFs );

   109     }

   110 

   111 void UT_CFContextSourceSettingsManager::Teardown(  )

   112     {

   113     delete iContextSourceSettingsManagerImpl;

   114     iContextSourceSettingsManagerImpl = NULL;

   115     

   116     delete iContextSourceSettingImpl;

   117     iContextSourceSettingImpl = NULL;

   118     

   119     delete iContextSourceSettingParameterImpl;

   120     iContextSourceSettingParameterImpl = NULL;

   121     

   122     iFs.Close();

   123     }

   124 

   125 //-----------------------------------------------------------------------------

   126 // UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingParameterImpl_NewLL

   127 //-----------------------------------------------------------------------------

   128 //

   129 void UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingParameterImpl_NewLL(  )

   130     {

   131     CCFContextSourceSettingParameterImpl* obj =

   132         CCFContextSourceSettingParameterImpl::NewL();

   133     CleanupStack::PushL( obj );

   134     

   135     EUNIT_ASSERT_DESC( obj, "CCFContextSourceSettingParameterImpl instance not created!" );

   136     

   137     CleanupStack::PopAndDestroy( obj );

   138     }

   139     

   140 //-----------------------------------------------------------------------------

   141 // UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingParameterImpl_NewLCL

   142 //-----------------------------------------------------------------------------

   143 //

   144 void UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingParameterImpl_NewLCL(  )

   145     {

   146     CCFContextSourceSettingParameterImpl* obj =

   147         CCFContextSourceSettingParameterImpl::NewLC();

   148     

   149     EUNIT_ASSERT_DESC( obj, "CCFContextSourceSettingParameterImpl instance not created!" );

   150     

   151     CleanupStack::PopAndDestroy( obj );

   152     }

   153 

   154 //-----------------------------------------------------------------------------

   155 // UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingParameterImpl_NameL

   156 //-----------------------------------------------------------------------------

   157 //

   158 void UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingParameterImpl_NameL(  )

   159     {

   160     _LIT( KMedium, "Meeeeeeeeeeddddiiiiuuuuumm" );

   161     _LIT( KShort, "Short" );

   162     _LIT( KLong, "Llllllllllllllllllllllloooooooooooooooonnnnnnnnnnnnggg" );

   163     TPtrC buf;

   164 

   165     buf.Set( iContextSourceSettingParameterImpl->Name() );

   166     EUNIT_ASSERT_DESC( buf == KNullDesC, "Incorrect name returned!" );

   167 

   168     iContextSourceSettingParameterImpl->SetNameL( KMedium );

   169     buf.Set( iContextSourceSettingParameterImpl->Name() );

   170     EUNIT_ASSERT_DESC( buf == KMedium, "Incorrect name returned!" );

   171 

   172     iContextSourceSettingParameterImpl->SetNameL( KShort );

   173     buf.Set( iContextSourceSettingParameterImpl->Name() );

   174     EUNIT_ASSERT_DESC( buf == KShort, "Incorrect name returned!" );

   175 

   176     iContextSourceSettingParameterImpl->SetNameL( KLong );

   177     buf.Set( iContextSourceSettingParameterImpl->Name() );

   178     EUNIT_ASSERT_DESC( buf == KLong, "Incorrect name returned!" );

   179     

   180     iContextSourceSettingParameterImpl->SetNameL( KNullDesC );

   181     buf.Set( iContextSourceSettingParameterImpl->Name() );

   182     EUNIT_ASSERT_DESC( buf == KNullDesC, "Incorrect name returned!" );    

   183     }

   184 

   185 //-----------------------------------------------------------------------------

   186 // UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingParameterImpl_AttributesL

   187 //-----------------------------------------------------------------------------

   188 //

   189 void UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingParameterImpl_AttributesL(  )

   190     {

   191     const TInt KCount = 10;

   192     _LIT( KKey, "key%d" );

   193     _LIT( KValue, "value%d" );

   194     TInt count = 0;

   195     TBuf<KCount> key( KNullDesC );

   196     TBuf<KCount> value( KNullDesC );

   197     

   198     count = iContextSourceSettingParameterImpl->Attributes().Count();

   199     EUNIT_ASSERT_DESC( count == 0, "Incorrect attribute count returned!" );

   200     

   201     for( TInt i = 0; i < KCount; i++ )

   202         {

   203         key.Format( KKey, i );

   204         value.Format( KValue, i );

   205         

   206         CCFKeyValuePair* keyValue = CCFKeyValuePair::NewLC( key, value );

   207         iContextSourceSettingParameterImpl->AddAttributeL( keyValue );

   208         CleanupStack::Pop( keyValue );

   209         }

   210         

   211     const RKeyValueArray& array = iContextSourceSettingParameterImpl->Attributes();

   212     count = array.Count();

   213     EUNIT_ASSERT_DESC( count == KCount,

   214         "Incorrect attribute count!" );

   215     for( TInt i = 0; i < count; i++ )

   216         {

   217         key.Format( KKey, i );

   218         value.Format( KValue, i );

   219         EUNIT_ASSERT_DESC( array[i]->Key() == key,

   220             "Incorrect key!" );

   221         EUNIT_ASSERT_DESC( array[i]->Value() == value,

   222             "Incorrect value!" );

   223         }

   224     }

   225 

   226 //-----------------------------------------------------------------------------

   227 // UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingImpl_NewLL

   228 //-----------------------------------------------------------------------------

   229 //

   230 void UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingImpl_NewLL(  )

   231     {

   232     CCFContextSourceSettingImpl* obj = CCFContextSourceSettingImpl::NewL();

   233     CleanupStack::PushL( obj );

   234     

   235     EUNIT_ASSERT_DESC( obj, "CCFContextSourceSettingImpl instance not created!" );

   236     

   237     CleanupStack::PopAndDestroy( obj );

   238     }

   239 

   240 //-----------------------------------------------------------------------------

   241 // UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingImpl_NewLCL

   242 //-----------------------------------------------------------------------------

   243 //

   244 void UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingImpl_NewLCL(  )

   245     {

   246     CCFContextSourceSettingImpl* obj = CCFContextSourceSettingImpl::NewLC();

   247     

   248     EUNIT_ASSERT_DESC( obj, "CCFContextSourceSettingImpl instance not created!" );

   249     

   250     CleanupStack::PopAndDestroy( obj );

   251     }

   252 

   253 //-----------------------------------------------------------------------------

   254 // UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingImpl_NameL

   255 //-----------------------------------------------------------------------------

   256 //

   257 void UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingImpl_NameL(  )

   258     {

   259     _LIT( KMedium, "Meeeeeeeeeeddddiiiiuuuuumm" );

   260     _LIT( KShort, "Short" );

   261     _LIT( KLong, "Llllllllllllllllllllllloooooooooooooooonnnnnnnnnnnnggg" );

   262     TPtrC buf;

   263 

   264     buf.Set( iContextSourceSettingImpl->Name() );

   265     EUNIT_ASSERT_DESC( buf == KNullDesC, "Incorrect name returned!" );

   266 

   267     iContextSourceSettingImpl->SetNameL( KMedium );

   268     buf.Set( iContextSourceSettingImpl->Name() );

   269     EUNIT_ASSERT_DESC( buf == KMedium, "Incorrect name returned!" );

   270 

   271     iContextSourceSettingImpl->SetNameL( KShort );

   272     buf.Set( iContextSourceSettingImpl->Name() );

   273     EUNIT_ASSERT_DESC( buf == KShort, "Incorrect name returned!" );

   274 

   275     iContextSourceSettingImpl->SetNameL( KLong );

   276     buf.Set( iContextSourceSettingImpl->Name() );

   277     EUNIT_ASSERT_DESC( buf == KLong, "Incorrect name returned!" );

   278     

   279     iContextSourceSettingImpl->SetNameL( KNullDesC );

   280     buf.Set( iContextSourceSettingImpl->Name() );

   281     EUNIT_ASSERT_DESC( buf == KNullDesC, "Incorrect name returned!" );

   282     }

   283 

   284 //-----------------------------------------------------------------------------

   285 // UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingImpl_AttributesL

   286 //-----------------------------------------------------------------------------

   287 //

   288 void UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingImpl_AttributesL(  )

   289     {

   290     const TInt KCount = 10;

   291     _LIT( KKey, "key%d" );

   292     _LIT( KValue, "value%d" );

   293     TInt count = 0;

   294     TBuf<KCount> key( KNullDesC );

   295     TBuf<KCount> value( KNullDesC );

   296     

   297     count = iContextSourceSettingImpl->Attributes().Count();

   298     EUNIT_ASSERT_DESC( count == 0, "Incorrect attribute count returned!" );

   299     

   300     for( TInt i = 0; i < KCount; i++ )

   301         {

   302         key.Format( KKey, i );

   303         value.Format( KValue, i );

   304         

   305         CCFKeyValuePair* keyValue = CCFKeyValuePair::NewLC( key, value );

   306         iContextSourceSettingImpl->AddAttributeL( keyValue );

   307         CleanupStack::Pop( keyValue );

   308         }

   309         

   310     const RKeyValueArray& array = iContextSourceSettingImpl->Attributes();

   311     count = array.Count();

   312     EUNIT_ASSERT_DESC( count == KCount,

   313         "Incorrect attribute count!" );

   314     for( TInt i = 0; i < count; i++ )

   315         {

   316         key.Format( KKey, i );

   317         value.Format( KValue, i );

   318         EUNIT_ASSERT_DESC( array[i]->Key() == key,

   319             "Incorrect key!" );

   320         EUNIT_ASSERT_DESC( array[i]->Value() == value,

   321             "Incorrect value!" );

   322         }

   323     }

   324 

   325 //-----------------------------------------------------------------------------

   326 // UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingImpl_NumOfParametersL

   327 //-----------------------------------------------------------------------------

   328 //

   329 void UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingImpl_NumOfParametersL(  )

   330     {

   331     const TInt KCount = 10;

   332     TInt count = iContextSourceSettingImpl->Parameters().Count();

   333     EUNIT_ASSERT_DESC( count == 0, "Invalid number of parameters!" );

   334 

   335     for( TInt i = 0; i < KCount; i++ )

   336         {

   337         CCFContextSourceSettingParameterImpl* parameter =

   338             CCFContextSourceSettingParameterImpl::NewLC();

   339         iContextSourceSettingImpl->AddParameterL( parameter );

   340         count = iContextSourceSettingImpl->Parameters().Count();

   341         EUNIT_ASSERT_DESC( count == i + 1, "Invalid number of parameters!" );

   342         CleanupStack::Pop( parameter );

   343         }

   344     }

   345 

   346 //-----------------------------------------------------------------------------

   347 // UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingImpl_ParametersL

   348 //-----------------------------------------------------------------------------

   349 //

   350 void UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingImpl_ParametersL(  )

   351     {

   352     const TInt KParameterCount = 10;

   353     const TInt KAttributeCountInParameter = 5;

   354     _LIT( KKey, "key%d" );

   355     _LIT( KValue, "value%d" );

   356     TInt count = 0;

   357     TBuf<KParameterCount> key( KNullDesC );

   358     TBuf<KParameterCount> value( KNullDesC );

   359     

   360     count = iContextSourceSettingImpl->Parameters().Count();

   361     EUNIT_ASSERT_DESC( count == 0, "Invalid number of parameters!" );

   362     

   363     // Add parameters

   364     for( TInt i = 0; i < KParameterCount; i++ )

   365         {

   366         CCFContextSourceSettingParameterImpl* param =

   367             CCFContextSourceSettingParameterImpl::NewLC();

   368         for( TInt j = 0; j < KAttributeCountInParameter; j++ )

   369             {

   370             key.Format( KKey, j );

   371             value.Format( KValue, j );

   372             CCFKeyValuePair* keyValue = CCFKeyValuePair::NewLC( key, value );

   373             param->AddAttributeL( keyValue );

   374             CleanupStack::Pop( keyValue );

   375             }

   376         iContextSourceSettingImpl->AddParameterL( param );

   377         CleanupStack::Pop( param );

   378         }

   379         

   380     // Check parameters

   381     TInt attributeCount = 0;

   382     const RSettingParameterArray& params = iContextSourceSettingImpl->Parameters();

   383     count = params.Count();

   384     EUNIT_ASSERT_DESC( count == KParameterCount, "Invalid number of parameters!" );

   385     for( TInt i = 0; i < count; i++ )

   386         {

   387         const RKeyValueArray& attributes = params[i]->Attributes();

   388         attributeCount = attributes.Count();

   389         EUNIT_ASSERT_DESC( attributeCount == KAttributeCountInParameter, "Invalid number of attributes!" );

   390         for( TInt j = 0; j < attributeCount; j++ )

   391             {

   392             key.Format( KKey, j );

   393             value.Format( KValue, j );

   394             EUNIT_ASSERT_DESC( attributes[j]->Key() == key,

   395                 "Invalid attribute key!" );

   396             EUNIT_ASSERT_DESC( attributes[j]->Value() == value,

   397                 "Invalid attribute key!" );

   398             }

   399         }

   400     }

   401 

   402 //-----------------------------------------------------------------------------

   403 // UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingsManagerImpl_NewLL

   404 //-----------------------------------------------------------------------------

   405 //

   406 void UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingsManagerImpl_NewLL(  )

   407     {

   408     RFs fs;

   409     CleanupClosePushL( fs );

   410     User::LeaveIfError( fs.Connect() );

   411     CCFContextSourceSettingsManagerImpl* obj =

   412         CCFContextSourceSettingsManagerImpl::NewL( fs );

   413     CleanupStack::PushL( obj );

   414     

   415     EUNIT_ASSERT_DESC( obj,

   416         "CCFContextSourceSettingsManager instance not created!" );

   417         

   418     CleanupStack::PopAndDestroy( 2, &fs );

   419     }

   420 

   421 //-----------------------------------------------------------------------------

   422 // UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingsManagerImpl_NewLCL

   423 //-----------------------------------------------------------------------------

   424 //

   425 void UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingsManagerImpl_NewLCL(  )

   426     {

   427     RFs fs;

   428     CleanupClosePushL( fs );

   429     User::LeaveIfError( fs.Connect() );

   430     CCFContextSourceSettingsManagerImpl* obj =

   431         CCFContextSourceSettingsManagerImpl::NewLC( fs );

   432     

   433     EUNIT_ASSERT_DESC( obj,

   434         "CCFContextSourceSettingsManager instance not created!" );

   435         

   436     CleanupStack::PopAndDestroy( 2, &fs );

   437     }

   438 

   439 //-----------------------------------------------------------------------------

   440 // UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingsManagerImpl_ParseSettingsLL

   441 //-----------------------------------------------------------------------------

   442 //

   443 void UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingsManagerImpl_ParseSettingsLL(  )

   444     {

   445     _LIT( KSettingsPath, "z:\\data\\cftestdata\\testsettings\\validsettingsfile.xml" );

   446     

   447     _LIT( KSettingName, "PluginName" );

   448     _LIT( KParamName, "Param" );

   449 

   450     _LIT( KAttributeFormat, "attribute%d" );

   451     _LIT( KAttributeValueFormat, "attributevalue%d" );

   452     _LIT( KParamFormat, "param%d" );

   453     _LIT( KParamValueFormat, "value%d" );

   454     

   455     TBuf<20> key( KNullDesC );

   456     TBuf<20> value( KNullDesC );

   457     

   458     CCFContextSourceSettingArray* array = CCFContextSourceSettingArray::NewLC();

   459     static_cast<CCFContextSourceSettingsManager*>(

   460         iContextSourceSettingsManagerImpl )->ParseSettingsL(

   461             KSettingsPath,

   462             *array );

   463             

   464     // Check settings -

   465     // Should have two setting blocks

   466     EUNIT_ASSERT_DESC( array->Count() == 2, "Invalid number of settings!" );

   467     

   468     // Check setting names

   469     TInt count = array->Count();

   470     for( TInt i = 0; i < count; i++ )

   471         {

   472         EUNIT_ASSERT_DESC( array->Item( i ).Name() == KSettingName, "Invalid setting name!" );

   473         }

   474         

   475     // Check attributes

   476     for( TInt i = 0; i < count; i++ )

   477         {

   478         const RKeyValueArray& attributes = array->Item( i ).Attributes();

   479         EUNIT_ASSERT_DESC( attributes.Count() == i + 1, "Invalid attribute count!" );

   480         TInt attributeCount = attributes.Count();

   481         for( TInt j = 0; j < attributeCount; j++ )

   482             {

   483             key.Format( KAttributeFormat, j + 1 );

   484             value.Format( KAttributeValueFormat, j + 1 );

   485             EUNIT_ASSERT_DESC( attributes[j]->Key() == key,

   486                 "Invalid key!" );

   487             EUNIT_ASSERT_DESC( attributes[j]->Value() == value,

   488                 "Invalid value!" );

   489             }

   490         }

   491         

   492     // Check parameters

   493     count = array->Count();

   494     TInt parameterCount = 0;

   495     for( TInt a = 0; a < count; a++ )

   496         {

   497         const RSettingParameterArray& paramArray = array->Item( a ).Parameters();

   498         parameterCount = paramArray.Count();

   499         for( TInt b = 0; b < parameterCount; b++ )

   500             {

   501             EUNIT_ASSERT_DESC( paramArray[b]->Name() == KParamName, "Invalid parameter name!" );

   502             const RKeyValueArray& attributes = paramArray[b]->Attributes();

   503             TInt attributesCount = attributes.Count();

   504             for( TInt c = 0; c < attributesCount; c++ )

   505                 {

   506                 key.Format( KParamFormat, c + 1 );

   507                 value.Format( KParamValueFormat, c + 1 );

   508                 EUNIT_ASSERT_DESC( attributes[c]->Key() == key,

   509                     "Invalid key!" );

   510                 EUNIT_ASSERT_DESC( attributes[c]->Value() == value,

   511                     "Invalid value!" );

   512                 }

   513             }

   514         }

   515             

   516     CleanupStack::PopAndDestroy( array );

   517     }

   518     

   519 //-----------------------------------------------------------------------------

   520 // UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingArray_NewLL

   521 //-----------------------------------------------------------------------------

   522 //

   523 void UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingArray_NewLL()

   524     {

   525     CCFContextSourceSettingArray* array = CCFContextSourceSettingArray::NewL();

   526     CleanupStack::PushL( array );

   527     

   528     EUNIT_ASSERT_DESC( array, "CCFContextSourceSettingArray class instance not created!" )

   529     

   530     CleanupStack::PopAndDestroy( array );

   531     }

   532 

   533 //-----------------------------------------------------------------------------

   534 // UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingArray_NewLCL

   535 //-----------------------------------------------------------------------------

   536 //

   537 void UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingArray_NewLCL()

   538     {

   539     CCFContextSourceSettingArray* array = CCFContextSourceSettingArray::NewLC();

   540     

   541     EUNIT_ASSERT_DESC( array, "CCFContextSourceSettingArray class instance not created!" )

   542     

   543     CleanupStack::PopAndDestroy( array );

   544     }

   545 

   546 //-----------------------------------------------------------------------------

   547 // UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingArrayImpl_NewLL

   548 //-----------------------------------------------------------------------------

   549 //

   550 void UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingArrayImpl_NewLL()

   551     {

   552     CCFContextSourceSettingArrayImpl* array = CCFContextSourceSettingArrayImpl::NewL();

   553     CleanupStack::PushL( array );

   554     

   555     EUNIT_ASSERT_DESC( array, "CCFContextSourceSettingArrayImpl class instance not created!" )

   556     

   557     CleanupStack::PopAndDestroy( array );

   558     }

   559 

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

   561 // UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingArrayImpl_NewLCL

   562 //-----------------------------------------------------------------------------

   563 //

   564 void UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingArrayImpl_NewLCL()

   565     {

   566     CCFContextSourceSettingArrayImpl* array = CCFContextSourceSettingArrayImpl::NewLC();

   567     

   568     EUNIT_ASSERT_DESC( array, "CCFContextSourceSettingArrayImpl class instance not created!" )

   569     

   570     CleanupStack::PopAndDestroy( array );

   571     }

   572 

   573 //-----------------------------------------------------------------------------

   574 // UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingArrayImpl_AppendItemLL

   575 //-----------------------------------------------------------------------------

   576 //

   577 void UT_CFContextSourceSettingsManager::UT_CCFContextSourceSettingArrayImpl_AppendItemLL()

   578     {

   579     CCFContextSourceSettingImpl* settingItem = NULL;

   580     CCFContextSourceSettingArray* array = CCFContextSourceSettingArray::NewLC();

   581     

   582     EUNIT_ASSERT_DESC( !array->Count(), "Invalid setting array count!" );

   583 

   584     _LIT( KFormat, "Setting item %d" );

   585     TBuf<20> name( KNullDesC );

   586     static const TInt KCount = 5;

   587     for( TInt i = 0; i < KCount; i++ )

   588         {

   589         name.Format( KFormat, i );

   590         settingItem = CCFContextSourceSettingImpl::NewLC();

   591         settingItem->SetNameL( name );

   592         array->AppendItemL( settingItem );

   593         CleanupStack::Pop( settingItem );

   594         }

   595         

   596     EUNIT_ASSERT_DESC( array->Count() == KCount, "Invalid setting array count!" );

   597     for( TInt i = 0; i < KCount; i++ )

   598         {

   599         name.Format( KFormat, i );

   600         EUNIT_ASSERT_DESC( array->Item( i ).Name() == name, "Invalid setting item!" );

   601         }

   602     

   603     // Clean up

   604     CleanupStack::PopAndDestroy( array );

   605     }

   606 

   607 //  TEST TABLE

   608 

   609 EUNIT_BEGIN_TEST_TABLE(

   610     UT_CFContextSourceSettingsManager,

   611     "CFContextSourceSettingsManager unit test.",

   612     "UNIT" )

   613 

   614 EUNIT_TEST(

   615     "NewL - test ",

   616     "CCFContextSourceSettingParameterImpl",

   617     "NewL",

   618     "FUNCTIONALITY",

   619     SetupEmptyL, UT_CCFContextSourceSettingParameterImpl_NewLL, Teardown)

   620 

   621 EUNIT_TEST(

   622     "NewLC - test ",

   623     "CCFContextSourceSettingParameterImpl",

   624     "NewLC",

   625     "FUNCTIONALITY",

   626     SetupEmptyL, UT_CCFContextSourceSettingParameterImpl_NewLCL, Teardown)

   627 

   628 EUNIT_TEST(

   629     "Attributes - test ",

   630     "CCFContextSourceSettingParameterImpl",

   631     "Attributes",

   632     "FUNCTIONALITY",

   633     SetupL, UT_CCFContextSourceSettingParameterImpl_AttributesL, Teardown)

   634 

   635 EUNIT_TEST(

   636     "Name - test ",

   637     "CCFContextSourceSettingParameterImpl",

   638     "Name",

   639     "FUNCTIONALITY",

   640     SetupL, UT_CCFContextSourceSettingParameterImpl_NameL, Teardown)

   641 

   642 EUNIT_TEST(

   643     "NewL - test ",

   644     "CCFContextSourceSettingImpl",

   645     "NewL",

   646     "FUNCTIONALITY",

   647     SetupEmptyL, UT_CCFContextSourceSettingImpl_NewLL, Teardown)

   648 

   649 EUNIT_TEST(

   650     "NewLC - test ",

   651     "CCFContextSourceSettingImpl",

   652     "NewLC",

   653     "FUNCTIONALITY",

   654     SetupEmptyL, UT_CCFContextSourceSettingImpl_NewLCL, Teardown)

   655 

   656 EUNIT_TEST(

   657     "Name - test ",

   658     "CCFContextSourceSettingImpl",

   659     "Name",

   660     "FUNCTIONALITY",

   661     SetupL, UT_CCFContextSourceSettingImpl_NameL, Teardown)

   662 

   663 EUNIT_TEST(

   664     "Attributes - test ",

   665     "CCFContextSourceSettingImpl",

   666     "Attributes",

   667     "FUNCTIONALITY",

   668     SetupL, UT_CCFContextSourceSettingImpl_AttributesL, Teardown)

   669 

   670 EUNIT_TEST(

   671     "NumOfParameters - test ",

   672     "CCFContextSourceSettingImpl",

   673     "NumOfParameters",

   674     "FUNCTIONALITY",

   675     SetupL, UT_CCFContextSourceSettingImpl_NumOfParametersL, Teardown)

   676 

   677 EUNIT_TEST(

   678     "Parameters - test ",

   679     "CCFContextSourceSettingImpl",

   680     "Parameters",

   681     "FUNCTIONALITY",

   682     SetupL, UT_CCFContextSourceSettingImpl_ParametersL, Teardown)

   683 

   684 EUNIT_TEST(

   685     "NewL - test ",

   686     "CCFContextSourceSettingsManagerImpl",

   687     "NewL",

   688     "FUNCTIONALITY",

   689     SetupEmptyL, UT_CCFContextSourceSettingsManagerImpl_NewLL, Teardown)

   690 

   691 EUNIT_TEST(

   692     "NewLC - test ",

   693     "CCFContextSourceSettingsManagerImpl",

   694     "NewLC",

   695     "FUNCTIONALITY",

   696     SetupEmptyL, UT_CCFContextSourceSettingsManagerImpl_NewLCL, Teardown)

   697 

   698 EUNIT_TEST(

   699     "ParseSettingsL - test ",

   700     "CCFContextSourceSettingsManagerImpl",

   701     "ParseSettingsL",

   702     "FUNCTIONALITY",

   703     SetupL, UT_CCFContextSourceSettingsManagerImpl_ParseSettingsLL, Teardown)

   704 

   705 EUNIT_TEST(

   706     "NewL - test ",

   707     "CCFContextSourceSettingArray",

   708     "NewL",

   709     "FUNCTIONALITY",

   710     SetupL, UT_CCFContextSourceSettingArray_NewLL, Teardown)

   711 

   712 EUNIT_TEST(

   713     "NewLC - test ",

   714     "CCFContextSourceSettingArray",

   715     "NewLC",

   716     "FUNCTIONALITY",

   717     SetupL, UT_CCFContextSourceSettingArray_NewLCL, Teardown)

   718 

   719 EUNIT_TEST(

   720     "NewL - test ",

   721     "CCFContextSourceSettingArrayImpl",

   722     "NewL",

   723     "FUNCTIONALITY",

   724     SetupL, UT_CCFContextSourceSettingArrayImpl_NewLL, Teardown)

   725 

   726 EUNIT_TEST(

   727     "NewLC - test ",

   728     "CCFContextSourceSettingArrayImpl",

   729     "NewLC",

   730     "FUNCTIONALITY",

   731     SetupL, UT_CCFContextSourceSettingArrayImpl_NewLCL, Teardown)

   732 

   733 EUNIT_TEST(

   734     "AppendItemL - test ",

   735     "CCFContextSourceSettingArrayImpl",

   736     "AppendItemL",

   737     "FUNCTIONALITY",

   738     SetupL, UT_CCFContextSourceSettingArrayImpl_AppendItemLL, Teardown)

   739 

   740 EUNIT_END_TEST_TABLE

   741 

   742 //  END OF FILE