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

    21 

    22 //  EXTERNAL INCLUDES

    23 #include <EUnitMacros.h>

    24 #include <cfcontextsourcesettingsmanager.h>

    25 #include <cfcontextsourcesetting.h>

    26 #include <cfcontextsourcesettingarray.h>

    27 #include <cfcontextsourcesettingparameter.h>

    28 #include <cfkeyvaluepair.h>

    29 

    30 #include "cfenvutils.h"

    31 

    32 //  INTERNAL INCLUDES

    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 MT_CFContextSourceSettingsManager* MT_CFContextSourceSettingsManager::NewL()

    49     {

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

    51     CleanupStack::Pop();

    52 

    53     return self;

    54     }

    55 

    56 MT_CFContextSourceSettingsManager* MT_CFContextSourceSettingsManager::NewLC()

    57     {

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

    59     CleanupStack::PushL( self );

    60 

    61     self->ConstructL();

    62 

    63     return self;

    64     }

    65 

    66 // Destructor (virtual by CBase)

    67 MT_CFContextSourceSettingsManager::~MT_CFContextSourceSettingsManager()

    68     {

    69     Teardown();

    70 

    71     // Enable screen saver

    72     CFEnvUtils::EnableScreenSaver( ETrue );

    73     }

    74 

    75 // Default constructor

    76 MT_CFContextSourceSettingsManager::MT_CFContextSourceSettingsManager()

    77     {

    78     }

    79 

    80 // Second phase construct

    81 void MT_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 

    94 

    95 void MT_CFContextSourceSettingsManager::SetupEmptyL(  )

    96     {

    97     

    98     }

    99 

   100 void MT_CFContextSourceSettingsManager::SetupL(  )

   101     {

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

   103     

   104     iContextSourceSettingsManager =

   105         CCFContextSourceSettingsManager::NewL( iFs );

   106     }

   107 

   108 void MT_CFContextSourceSettingsManager::Teardown(  )

   109     {

   110     delete iContextSourceSettingsManager;

   111     iContextSourceSettingsManager = NULL;

   112     

   113     iFs.Close();

   114     }

   115 

   116 //-----------------------------------------------------------------------------

   117 // MT_CFContextSourceSettingsManager::MT_CCFContextSourceSettingsManager_NewLL

   118 //-----------------------------------------------------------------------------

   119 //

   120 void MT_CFContextSourceSettingsManager::MT_CCFContextSourceSettingsManager_NewLL(  )

   121     {

   122     RFs fs;

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

   124     CleanupClosePushL( fs );

   125     CCFContextSourceSettingsManager* obj =

   126         CCFContextSourceSettingsManager::NewL( fs );

   127     CleanupStack::PushL( obj );

   128     

   129     EUNIT_ASSERT_DESC( obj, "CCFContextSourceSettingsManager instance not created!" );

   130     

   131     CleanupStack::PopAndDestroy( obj );

   132     CleanupStack::PopAndDestroy( &fs );

   133     }

   134 

   135 //-----------------------------------------------------------------------------

   136 // MT_CFContextSourceSettingsManager::MT_CCFContextSourceSettingsManager_NewLCL

   137 //-----------------------------------------------------------------------------

   138 //

   139 void MT_CFContextSourceSettingsManager::MT_CCFContextSourceSettingsManager_NewLCL(  )

   140     {

   141     RFs fs;

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

   143     CleanupClosePushL( fs );

   144     CCFContextSourceSettingsManager* obj =

   145         CCFContextSourceSettingsManager::NewLC( fs );

   146     

   147     EUNIT_ASSERT_DESC( obj, "CCFContextSourceSettingsManager instance not created!" );

   148     

   149     CleanupStack::PopAndDestroy( obj );

   150     CleanupStack::PopAndDestroy( &fs );

   151     }

   152 

   153 //-----------------------------------------------------------------------------

   154 // MT_CFContextSourceSettingsManager::MT_CCFContextSourceSettingsManager_ParseSettingsL1L

   155 //-----------------------------------------------------------------------------

   156 //

   157 void MT_CFContextSourceSettingsManager::MT_CCFContextSourceSettingsManager_ParseSettingsL1L(  )

   158     {

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

   160     

   161     _LIT( KSettingName, "PluginName" );

   162     _LIT( KParamName, "Param" );

   163 

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

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

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

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

   168     

   169     TBuf<20> key( KNullDesC );

   170     TBuf<20> value( KNullDesC );

   171     

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

   173     iContextSourceSettingsManager->ParseSettingsL( KSettingsPath, *array );

   174             

   175     // Check settings -

   176     // Should have two setting blocks

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

   178     

   179     // Check setting names

   180     TInt count = array->Count();

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

   182         {

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

   184         }

   185         

   186     // Check attributes

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

   188         {

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

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

   191         TInt attributeCount = attributes.Count();

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

   193             {

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

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

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

   197                 "Invalid key!" );

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

   199                 "Invalid value!" );

   200             }

   201         }

   202         

   203     // Check parameters

   204     count = array->Count();

   205     TInt parameterCount = 0;

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

   207         {

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

   209         parameterCount = paramArray.Count();

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

   211             {

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

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

   214             TInt attributesCount = attributes.Count();

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

   216                 {

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

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

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

   220                     "Invalid key!" );

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

   222                     "Invalid value!" );

   223                 }

   224             }

   225         }

   226             

   227     CleanupStack::PopAndDestroy( array );

   228     }

   229 

   230 //-----------------------------------------------------------------------------

   231 // MT_CFContextSourceSettingsManager::MT_CCFContextSourceSettingsManager_ParseSettingsL2L

   232 //-----------------------------------------------------------------------------

   233 //

   234 void MT_CFContextSourceSettingsManager::MT_CCFContextSourceSettingsManager_ParseSettingsL2L(  )

   235     {

   236     _LIT( KSettingsPath, "z:\\data\\cftestdata\\testsettings\\validsettingsfile2.xml" );

   237     

   238     _LIT( KSettingNameNode, "SettingNameNode" );

   239     _LIT( KParamNameNode, "ParamNameNode" );

   240 

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

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

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

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

   245 

   246     TBuf<20> key( KNullDesC );

   247     TBuf<20> value( KNullDesC );

   248     

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

   250     CleanupStack::PushL( array );

   251     iContextSourceSettingsManager->ParseSettingsL( KSettingsPath, *array );

   252     

   253     // Should have one setting block

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

   255 

   256     // Check setting names

   257     TInt count = array->Count();

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

   259         {

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

   261         }

   262 

   263     // Check attributes

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

   265         {

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

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

   268         TInt attributeCount = attributes.Count();

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

   270             {

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

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

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

   274                 "Invalid key!" );

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

   276                 "Invalid value!" );

   277             }

   278         }

   279 

   280     // Check parameters

   281     count = array->Count();

   282     TInt parameterCount = 0;

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

   284         {

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

   286         parameterCount = paramArray.Count();

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

   288             {

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

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

   291             TInt attributesCount = attributes.Count();

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

   293                 {

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

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

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

   297                     "Invalid key!" );

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

   299                     "Invalid value!" );

   300                 }

   301             }

   302         }

   303 

   304     CleanupStack::PopAndDestroy( array );

   305     }

   306 

   307 //-----------------------------------------------------------------------------

   308 // MT_CFContextSourceSettingsManager::MT_CCFContextSourceSettingsManager_ParseSettingsL3L

   309 //-----------------------------------------------------------------------------

   310 //

   311 void MT_CFContextSourceSettingsManager::MT_CCFContextSourceSettingsManager_ParseSettingsL3L(  )

   312     {

   313     _LIT( KSettingsPath, "z:\\data\\cftestdata\\testsettings\\invalidsettingsfile.xml" );

   314 

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

   316     iContextSourceSettingsManager->ParseSettingsL( KSettingsPath, *array );

   317     

   318     // Should have one setting block

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

   320     

   321     CleanupStack::PopAndDestroy( array );

   322     }

   323 

   324 //  TEST TABLE

   325 

   326 EUNIT_BEGIN_TEST_TABLE(

   327     MT_CFContextSourceSettingsManager,

   328     "CFContextSourceSettingsManager module test.",

   329     "MODULE" )

   330 

   331 EUNIT_TEST(

   332     "NewL - test ",

   333     "CCFContextSourceSettingsManager",

   334     "NewL",

   335     "FUNCTIONALITY",

   336     SetupEmptyL, MT_CCFContextSourceSettingsManager_NewLL, Teardown)

   337 

   338 EUNIT_TEST(

   339     "NewLC - test ",

   340     "CCFContextSourceSettingsManager",

   341     "NewLC",

   342     "FUNCTIONALITY",

   343     SetupEmptyL, MT_CCFContextSourceSettingsManager_NewLCL, Teardown)

   344 

   345 EUNIT_TEST(

   346     "ParseSettingsL 1 - test ",

   347     "CCFContextSourceSettingsManager",

   348     "ParseSettingsL",

   349     "FUNCTIONALITY",

   350     SetupL, MT_CCFContextSourceSettingsManager_ParseSettingsL1L, Teardown)

   351 

   352 EUNIT_TEST(

   353     "ParseSettingsL 2 - test ",

   354     "CCFContextSourceSettingsManager",

   355     "ParseSettingsL",

   356     "FUNCTIONALITY",

   357     SetupL, MT_CCFContextSourceSettingsManager_ParseSettingsL2L, Teardown)

   358 

   359 EUNIT_TEST(

   360     "ParseSettingsL 3 - test ",

   361     "CCFContextSourceSettingsManager",

   362     "ParseSettingsL",

   363     "FUNCTIONALITY",

   364     SetupL, MT_CCFContextSourceSettingsManager_ParseSettingsL3L, Teardown)

   365 

   366 EUNIT_END_TEST_TABLE

   367 

   368 //  END OF FILE