1 /*

     2 * Copyright (c) 2002-2009 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 the License "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:   Specific class for SIM tests

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 // INCLUDE FILES

    22 #include <e32svr.h>

    23 #include <stifparser.h>

    24 #include <stiftestinterface.h>

    25 #include "sim.h"

    26 

    27 

    28 // CONSTANTS

    29 _LIT8( KLine, "---------------------------------" );

    30 

    31 _LIT8( KAdnPhoneBook, "AdnPhoneBook" );

    32 _LIT8( KBdnPhoneBook, "BdnPhoneBook" );

    33 _LIT8( KSdnPhoneBook, "SdnPhoneBook" );

    34 _LIT8( KFdnPhoneBook, "FdnPhoneBook" );

    35 _LIT8( KMBDN, "MBDN" );

    36 _LIT8( KVoiceMailBox, "VoiceMailBox" );

    37 

    38 _LIT( KViagInactive, "Inactive" );

    39 _LIT( KViagCZActive, "CZActive" );

    40 _LIT( KViagHZActive, "HZActive" );

    41 

    42 const TPtrC PhoneALSLine[] =

    43     {

    44     _L("EAlternateLinePrimary"),

    45     _L("EAlternateLineAuxiliary"),

    46     _L("EAlternateLineUnknown"),

    47     _L("EAlternateLineNotAvailable")

    48     };

    49 

    50 // Indicator what kind of test is on going.

    51 enum TAuthenticationTestPurpose

    52     {

    53     EGbaBootOk = 1,

    54     EGbaBootAuthFail,

    55     EGbaBootVerificationFail,

    56     EGbaNafDerOk,

    57     EGbaNafDerAuthFail,

    58     EGbaBootUpdateOk,

    59     EGbaBootUpdateError,

    60     EGbaBootError,

    61     EGbaBootNafError,

    62     EMgvMskUpdateOk = 11,

    63     EMgvMskUpdateNull,

    64     EMgvMskUpdateError,

    65     EMgvMtkGenerationOk,

    66     EMgvMtkGenerationError,

    67     EMgvMskDeletionOk,

    68     EMgvMskDeletionError,

    69     EMgvMskDeletionAuthFail,

    70     EMgvMskUpdateWithOmaBCastExtension,

    71     EMgvMtkGenerationWithBcastManagementData,

    72     EMgvMtkGenerationWithBCastParentalControlData,

    73     };

    74 

    75 // ============================ MEMBER FUNCTIONS ===============================

    76 

    77 // -----------------------------------------------------------------------------

    78 // CSIM::Delete

    79 // Delete here all resources allocated and opened from test methods.

    80 // Called from destructor.

    81 // -----------------------------------------------------------------------------

    82 //

    83 void CSIM::Delete()

    84     {

    85 

    86     }

    87 

    88 // -----------------------------------------------------------------------------

    89 // CSIM::RunMethodL

    90 // Run specified method. Contains also table of test mothods and their names.

    91 // -----------------------------------------------------------------------------

    92 //

    93 TInt CSIM::RunMethodL(

    94     CStifItemParser& aItem )

    95     {

    96    _LIT8 (KLog, "SIM: RunMethodL" );

    97    iSIMLog->Log((TDesC8)KLog);

    98 

    99     static TStifFunctionInfo const KFunctions[] =

   100         {

   101         // Copy this line for every implemented function.

   102         // First string is the function name used in TestScripter script file.

   103         // Second is the actual implementation member function.

   104         ENTRY( "PbInit",                  CSIM::PbInitL ),

   105         ENTRY( "PbStoreCache",            CSIM::PbStoreCacheL ),

   106         ENTRY( "PbStoreCacheCancel",      CSIM::PbStoreCacheCancelL ),

   107         ENTRY( "ReadEntries",             CSIM::ReadEntriesL ),

   108         ENTRY( "WriteEntries",            CSIM::WriteEntriesL ),

   109         ENTRY( "DeleteEntry",             CSIM::DeleteEntryL ),

   110         ENTRY( "DeleteAllEntries",        CSIM::DeleteAllEntriesL ),

   111         ENTRY( "GetPbStoreInfo",          CSIM::GetPbStoreInfoL ),

   112         ENTRY( "ReadENStore",             CSIM::ReadENStore ),

   113         ENTRY( "ReadENStoreAll",          CSIM::ReadENStoreAll ),

   114         ENTRY( "GetENStoreInfo",          CSIM::GetENStoreInfo ),

   115         ENTRY( "ReadONStore",             CSIM::ReadONStore ),

   116         ENTRY( "ReadONStoreEntry",        CSIM::ReadONStoreEntry ),

   117         ENTRY( "GetONStoreInfo",          CSIM::GetONStoreInfo ),

   118         ENTRY( "DeleteONStoreEntry",      CSIM::DeleteONStoreEntry ),

   119         ENTRY( "DeleteAllONStoreEntries", CSIM::DeleteAllONStoreEntries ),

   120         ENTRY( "WriteONStore",            CSIM::WriteONStore ),

   121         ENTRY( "ReadONStoreSize",         CSIM::ReadONStoreSize ),

   122         ENTRY( "GetMailboxNumbers",       CSIM::GetMailboxNumbers ),

   123         ENTRY( "WriteONStoreAll",         CSIM::WriteONStoreAll ),

   124         ENTRY( "OnStoreWriteSize",        CSIM::OnStoreWriteSize ),

   125         ENTRY( "GetServiceTable",         CSIM::GetServiceTable ),

   126         ENTRY( "GetALSLine",              CSIM::GetALSLine ),

   127         ENTRY( "SetALSLine",              CSIM::SetALSLine ),

   128         ENTRY( "GetCustomerServiceProfile", CSIM::GetCustomerServiceProfile ),

   129         ENTRY( "GetPin1DisableSupported", CSIM::GetPin1DisableSupported ),

   130         ENTRY( "SimRefreshRegister",      CSIM::SimRefreshRegister ),

   131         ENTRY( "SimRefreshDone",          CSIM::SimRefreshDone ),

   132         ENTRY( "GetSubscriberId",         CSIM::GetSubscriberId ),

   133         ENTRY( "GetServiceProviderName",  CSIM::GetServiceProviderName ),

   134         ENTRY( "ReadSimFile",             CSIM::ReadSimFile ),

   135         ENTRY( "GetNetworkProviderName",  CSIM::GetNetworkProviderName ),

   136         ENTRY( "GetSimAuthenticationData",CSIM::GetSimAuthenticationData ),

   137         ENTRY( "AuthenticateIMSData",     CSIM::AuthenticateIMSData ),

   138         ENTRY( "GetIMSAuthorizationInfo", CSIM::GetIMSAuthorizationInfo ),

   139         ENTRY( "GetALSBlockedStatus",     CSIM::GetALSBlockedStatus ),

   140         ENTRY( "SetALSBlockedStatus",     CSIM::SetALSBlockedStatus ),

   141         ENTRY( "SendSIMRefreshNtf",       CSIM::SendSIMRefreshNtf),

   142         ENTRY( "CheckAlsPpSupport",       CSIM::CheckAlsPpSupport),

   143         ENTRY( "FdnDataSizesReq",         CSIM::FdnDataSizesReq),

   144         ENTRY( "GetServiceSupport",       CSIM::CheckServiceSupport),

   145         ENTRY( "SetExpectedNumberOfPbEntries", CSIM::SetExpectedNumberOfPbEntries),

   146         ENTRY( "ViagHomeZoneReadParam",   CSIM::ViagHomeZoneReadParamL),

   147         ENTRY( "ViagHomeZoneReadCache",   CSIM::ViagHomeZoneReadCacheL),

   148         ENTRY( "ViagHomeZoneWriteSettings", CSIM::ViagHomeZoneWriteSettingsL),

   149         ENTRY( "ViagHomeZoneWriteCache",  CSIM::ViagHomeZoneWriteCacheL),

   150         ENTRY( "InvalidReadEntries",      CSIM::InvalidReadEntries),

   151         ENTRY( "InvalidWriteEntries",     CSIM::InvalidWriteEntries),

   152         ENTRY( "InvalidPbStoreCache",     CSIM::InvalidPbStoreCache),

   153 

   154 

   155 #ifdef INTERNAL_RD_USIM_PHONEBOOK_GAS_AND_AAS

   156         ENTRY( "WriteAlphaString",        CSIM::WriteAlphaString),

   157         ENTRY( "ReadAlphaString",         CSIM::ReadAlphaString),

   158         ENTRY( "DeleteAlphaString",       CSIM::DeleteAlphaString),

   159 #endif // INTERNAL_RD_USIM_PHONEBOOK_GAS_AND_AAS

   160 

   161         ENTRY( "HandleSpecifiedRequests", CCore::HandleSpecifiedRequests),

   162         ENTRY( "InitializeIPCRequestTable", CCore::InitializeIPCRequestTable),

   163         ENTRY( "SetExpectedCompleteIPC",  CCore::SetExpectedCompleteIPC),

   164         ENTRY( "SetTestOngoingFlag",      CSIM::SetTestOngoingFlag),

   165         ENTRY( "HandleSpecifiedRequests", CCore::HandleSpecifiedRequests),

   166         ENTRY( "SetOperInfoAPAC",         CCore::SetOperInfoAPAC ),

   167         ENTRY( "RunIscTestCase",          CCore::RunIscTestCase),

   168         ENTRY( "SyncIscTestCase",         CCore::SyncIscTestCase),

   169         ENTRY( "RunIscTestCaseStartNTSYAfterTestToolStart",

   170                 CCore::RunIscTestCaseStartNTSYAfterTestToolStart),

   171         ENTRY( "SyncIscTestCaseStartNTSYAfterTestToolStart",

   172                 CCore::SyncIscTestCaseStartNTSYAfterTestToolStart),

   173         };

   174 

   175 

   176     const TInt count = sizeof( KFunctions ) / sizeof( TStifFunctionInfo );

   177 

   178     return RunInternalL( KFunctions, count, aItem );

   179 

   180     }

   181 

   182 // -----------------------------------------------------------------------------

   183 // CSIM::PbInitL

   184 // Phonebook initialization

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

   186 //

   187 TInt CSIM::PbInitL( CStifItemParser& aItem )

   188     {

   189     _LIT8(KPbInit, "SIM::PbInit");

   190     iSIMLog->Log((TDesC8)KPbInit);

   191 

   192     TInt ret( KErrNotFound );

   193     TBool supported( ETrue );

   194     TPtrC string;

   195     aItem.GetNextString( string );

   196 

   197     if ( _L("Adn") == string )

   198         {

   199         iSIMLog->Log((TDesC8)KAdnPhoneBook);

   200         iPhoneBookName = KETelIccAdnPhoneBook;

   201         if ( iHandleSpecifiedRequests )

   202             {

   203             // Check for card Type 

   204             TInt value;

   205             aItem.GetNextString( string );

   206 

   207             if ( _L("UICC") == string )

   208                 {

   209                 iCardType = _L("UICC");

   210                 aItem.GetNextInt( value );

   211                 iStorageDataAnr.iXXXTextLengthMax = value;

   212                 aItem.GetNextInt( value );

   213                 iStorageDataAnr.iXXXNumOfEntriesPerEntry = value;

   214                 aItem.GetNextInt( value );

   215                 iStorageDataAnr.iXXXNumOfEntries = value;

   216 

   217                 aItem.GetNextInt( value );

   218                 iStorageDataSne.iXXXNumOfEntries = value;

   219                 aItem.GetNextInt( value );

   220                 iStorageDataSne.iXXXNumOfEntriesPerEntry = value;

   221                 aItem.GetNextInt( value );

   222                 iStorageDataSne.iXXXTextLengthMax = value;

   223                 

   224                 aItem.GetNextInt( value );

   225                 iStorageDataEmail.iXXXNumOfEntries = value;

   226                 aItem.GetNextInt( value );

   227                 iStorageDataEmail.iXXXNumOfEntriesPerEntry = value;

   228                 aItem.GetNextInt( value );

   229                 iStorageDataEmail.iXXXTextLengthMax = value;

   230                 }

   231             // store phonebook info

   232             aItem.GetNextInt( value );

   233             iPbStorageDataAdn.iIsPhonebookInitialized = ( TBool )value;

   234             aItem.GetNextInt( value );

   235             iPbStorageDataAdn.iIsPhonebookInitializeFailed = ( TBool )value;

   236             aItem.GetNextInt( value );

   237             iPbStorageDataAdn.iXXXNumOfEntries = value;

   238             aItem.GetNextInt( value );

   239             iPbStorageDataAdn.iXXXTextLengthMax = value;

   240             aItem.GetNextInt( value );

   241             iPbStorageDataAdn.iXXXNumberLengthMax = value;

   242             

   243             aItem.GetNextInt( value );

   244             iPbStorageDataFdn.iXXXNumOfEntries = value;

   245             aItem.GetNextInt( value );

   246             iPbStorageDataFdn.iXXXTextLengthMax = value;

   247             aItem.GetNextInt( value );

   248             iPbStorageDataFdn.iXXXNumberLengthMax = value;

   249             aItem.GetNextInt( value );

   250             iPbStorageDataSdn.iXXXNumOfEntries = value;

   251             aItem.GetNextInt( value );

   252             iPbStorageDataSdn.iXXXTextLengthMax = value;

   253             aItem.GetNextInt( value );

   254             iPbStorageDataSdn.iXXXNumberLengthMax = value;

   255             aItem.GetNextInt( value );

   256             iPbStorageDataMbdn.iXXXNumOfEntries = value;

   257             aItem.GetNextInt( value );

   258             iPbStorageDataMbdn.iXXXTextLengthMax = value;

   259             aItem.GetNextInt( value );

   260             iPbStorageDataMbdn.iXXXNumberLengthMax = value;

   261             aItem.GetNextInt( value );

   262             iPbStorageDataMsisdn.iXXXNumOfEntries = value;

   263             aItem.GetNextInt( value );

   264             iPbStorageDataMsisdn.iXXXTextLengthMax = value;

   265             aItem.GetNextInt( value );

   266             iPbStorageDataMsisdn.iXXXNumberLengthMax = value;

   267             

   268             if( _L("ICC") == string )

   269                 {

   270                 iCardType = _L("ICC");

   271 

   272                 aItem.GetNextInt( value );

   273                 iPbStorageDataVmbx.iXXXNumOfEntries = value;

   274                 aItem.GetNextInt( value );

   275                 iPbStorageDataVmbx.iXXXTextLengthMax = value;

   276                 aItem.GetNextInt( value );

   277                 iPbStorageDataVmbx.iXXXNumberLengthMax = value;

   278                 }

   279             aItem.GetNextInt( value );

   280             iPbType[value] = TPhoneBookTypeAdn;

   281             }

   282         }

   283     else if ( _L("Bdn") == string )

   284         {

   285         iSIMLog->Log((TDesC8)KBdnPhoneBook);

   286         iPhoneBookName = KETelIccBdnPhoneBook;

   287         }

   288     else if ( _L("Sdn") == string )

   289         {

   290         iSIMLog->Log((TDesC8)KSdnPhoneBook);

   291         iPhoneBookName = KETelIccSdnPhoneBook;

   292         if ( iHandleSpecifiedRequests )

   293             {

   294             // store phonebook info

   295             TInt value;

   296             aItem.GetNextInt( value );

   297             iPbStorageDataSdn.iIsPhonebookInitialized = ( TBool )value;

   298             aItem.GetNextInt( value );

   299             iPbStorageDataSdn.iIsPhonebookInitializeFailed = ( TBool )value;

   300             aItem.GetNextInt( value );

   301             iPbStorageDataSdn.iXXXNumOfEntries = value;

   302             aItem.GetNextInt( value );

   303             iPbStorageDataSdn.iXXXTextLengthMax = value;

   304             aItem.GetNextInt( value );

   305             iPbStorageDataSdn.iXXXNumberLengthMax = value;

   306             aItem.GetNextInt( value );

   307             iPbType[value] = TPhoneBookTypeSdn;

   308             }

   309         }

   310     else if ( _L("Fdn") == string )

   311         {

   312         iSIMLog->Log((TDesC8)KFdnPhoneBook);

   313         iPhoneBookName = KETelIccFdnPhoneBook;

   314         if ( iHandleSpecifiedRequests )

   315             {

   316             // store phonebook info

   317             TInt value;

   318             aItem.GetNextInt( value );

   319             iPbStorageDataFdn.iIsPhonebookInitialized = ( TBool )value;

   320             aItem.GetNextInt( value );

   321             iPbStorageDataFdn.iIsPhonebookInitializeFailed = ( TBool )value;

   322             aItem.GetNextInt( value );

   323             iPbStorageDataFdn.iXXXNumOfEntries = value;

   324             aItem.GetNextInt( value );

   325             iPbStorageDataFdn.iXXXTextLengthMax = value;

   326             aItem.GetNextInt( value );

   327             iPbStorageDataFdn.iXXXNumberLengthMax = value;

   328             aItem.GetNextInt( value );

   329             iPbType[value] = TPhoneBookTypeFdn;

   330             }

   331         }

   332     else if ( _L("VoiceMailBox") == string )

   333         {

   334         iSIMLog->Log((TDesC8)KVoiceMailBox);

   335         iPhoneBookName = KETelIccVoiceMailBox;

   336         }

   337     else

   338         {

   339         _LIT8(KNotSupp, "SIM::Selected PB not supported");

   340         iSIMLog->Log((TDesC8)KNotSupp);

   341         supported = EFalse;

   342         }

   343 

   344     if ( supported )

   345         {

   346         //Create package

   347         CPhoneBookDataPackage package;

   348         // Set package data

   349         package.SetPhoneBookName( iPhoneBookName );

   350 

   351         ret = HandleRequestL( EMmTsyPhoneBookStoreInitIPC,

   352                              &package );

   353 

   354         if ( KErrNone == ret )

   355             {

   356             _LIT8( KSendOk, "PbInit request send ok" );

   357             iSIMLog->Log((TDesC8)KSendOk );

   358             }

   359         else

   360             {

   361              _LIT8( KSendFailed, "PbInit request send failed: %d" );

   362             iSIMLog->Log((TDesC8)KSendFailed, ret );

   363             }

   364         }

   365     else

   366         {

   367         ret = KErrNotSupported;

   368         }

   369 

   370     return ret;

   371     }

   372 

   373 // -----------------------------------------------------------------------------

   374 // CSIM::CompletePbInit

   375 // Complete PbInit method function.

   376 // -----------------------------------------------------------------------------

   377 //

   378 void CSIM::CompletePbInit

   379         (

   380         TInt aResult,

   381         CMmDataPackage* aDataPackage

   382         )

   383     {

   384     _LIT8( KResult, "CompletePbInit result: %d" );

   385     iSIMLog->Log((TDesC8)KResult, aResult );

   386     // Response information

   387     CStorageInfoData* pbInitResp;

   388     TInt i;

   389 

   390     if ( KErrNone == aResult )

   391         {

   392         aDataPackage->UnPackData ( &pbInitResp );

   393         PrintPbInitInfo( pbInitResp );

   394 

   395         if ( iHandleSpecifiedRequests )

   396             {

   397             // select used phonebook type for data validation

   398             TPhoneBookType pbType( TPhoneBookTypeUnknown );

   399             for ( i = 0; i < 2; i++)

   400                 {

   401                 if ( iPbType[i] != TPhoneBookTypeUnknown )

   402                     {

   403                     pbType = iPbType[i];

   404                     break;

   405                     }

   406                 }

   407             aResult = CheckPbData( pbInitResp, pbType );

   408             // reset phonebook type

   409             iPbType[i] = TPhoneBookTypeUnknown;

   410             }

   411         }

   412     else

   413         {

   414         _LIT8( KFail, "CompletePbInit Failed: %d" );

   415         iSIMLog->Log((TDesC8)KFail, aResult );

   416         }

   417 

   418     // in case of failure, send result immediately

   419     if( KErrNone != aResult )

   420         {

   421         Signal( aResult );

   422         }

   423 

   424     // in successful case, send result if test is not ongoing

   425     else if( ! iTestOngoing )

   426         {

   427         Signal( aResult );

   428         }

   429 

   430     iTestOngoing = EFalse;

   431     }

   432 

   433 // -----------------------------------------------------------------------------

   434 // CSIM::PrintPbInitInfo

   435 // Prints Pb info

   436 // -----------------------------------------------------------------------------

   437 //

   438 void CSIM::PrintPbInitInfo

   439         (

   440         CStorageInfoData* aPbInitInfo

   441         )

   442     {

   443     iSIMLog->Log((TDesC8)KLine );

   444     _LIT8( KText, "Pb Init Info" );

   445     iSIMLog->Log((TDesC8)KText );

   446 

   447     _LIT8( KADNNumOfEntries, "ADNNumOfEntries: %d" );

   448     iSIMLog->Log((TDesC8)KADNNumOfEntries, aPbInitInfo->iADNNumOfEntries );

   449 

   450     _LIT8( KADNTextLengthMax, "ADNTextLengthMax: %d" );

   451     iSIMLog->Log((TDesC8)KADNTextLengthMax, aPbInitInfo->iADNTextLengthMax );

   452 

   453     _LIT8( KADNNumberLengthMax, "ADNNumberLengthMax: %d" );

   454     iSIMLog->Log((TDesC8)KADNNumberLengthMax, aPbInitInfo->iADNNumberLengthMax );

   455 

   456     _LIT8( KFDNNumOfEntries, "FDNNumOfEntries: %d" );

   457     iSIMLog->Log((TDesC8)KFDNNumOfEntries, aPbInitInfo->iFDNNumOfEntries );

   458 

   459     _LIT8( KFDNTextLengthMax, "FDNTextLengthMax: %d" );

   460     iSIMLog->Log((TDesC8)KFDNTextLengthMax, aPbInitInfo->iFDNTextLengthMax );

   461 

   462     _LIT8( KFDNNumberLengthMax, "FDNNumberLengthMax: %d" );

   463     iSIMLog->Log((TDesC8)KFDNNumberLengthMax, aPbInitInfo->iFDNNumberLengthMax );

   464 

   465     _LIT8( KSDNNumOfEntries, "SDNNumOfEntries: %d" );

   466     iSIMLog->Log((TDesC8)KSDNNumOfEntries, aPbInitInfo->iSDNNumOfEntries );

   467 

   468     _LIT8( KSDNTextLengthMax, "SDNTextLengthMax: %d" );

   469     iSIMLog->Log((TDesC8)KSDNTextLengthMax, aPbInitInfo->iSDNTextLengthMax );

   470 

   471     _LIT8( KSDNNumberLengthMax, "SDNNumberLengthMax: %d" );

   472     iSIMLog->Log((TDesC8)KSDNNumberLengthMax, aPbInitInfo->iSDNNumberLengthMax );

   473 

   474     _LIT8( KVMBXNumOfEntries, "VMBXNumOfEntries: %d" );

   475     iSIMLog->Log((TDesC8)KVMBXNumOfEntries, aPbInitInfo->iVMBXNumOfEntries );

   476 

   477     _LIT8( KVMBXTextLengthMax, "VMBXTextLengthMax: %d" );

   478     iSIMLog->Log((TDesC8)KVMBXTextLengthMax, aPbInitInfo->iVMBXTextLengthMax );

   479 

   480     _LIT8( KVMBXNumberLengthMax, "VMBXNumberLengthMax: %d" );

   481     iSIMLog->Log((TDesC8)KVMBXNumberLengthMax, aPbInitInfo->iVMBXNumberLengthMax );

   482 

   483     _LIT8( KGRPNumOfEntriesPerEntry, "GRPNumOfEntriesPerEntry: %d" );

   484     iSIMLog->Log((TDesC8)KGRPNumOfEntriesPerEntry, aPbInitInfo->iGRPNumOfEntriesPerEntry );

   485 

   486     _LIT8( KANRNumOfEntries, "ANRNumOfEntries: %d" );

   487     iSIMLog->Log((TDesC8)KANRNumOfEntries, aPbInitInfo->iANRNumOfEntries );

   488 

   489     _LIT8( KANRNumOfEntriesPerEntry, "ANRNumOfEntriesPerEntry: %d" );

   490     iSIMLog->Log((TDesC8)KANRNumOfEntriesPerEntry, aPbInitInfo->iANRNumOfEntriesPerEntry );

   491 

   492     _LIT8( KANRNumLengthMax, "ANRNumLengthMax: %d" );

   493     iSIMLog->Log((TDesC8)KANRNumLengthMax, aPbInitInfo->iANRNumLengthMax );

   494 

   495 #ifdef INTERNAL_RD_USIM_PHONEBOOK_GAS_AND_AAS

   496     _LIT8( KANRTextLengthMax, "ANRTextLengthMax (AAS): %d" );

   497     iSIMLog->Log((TDesC8)KANRTextLengthMax, aPbInitInfo->iANRTextLengthMax );

   498 

   499     _LIT8( KNumOfAasMax, "NumOfAasMax: %d" );

   500     iSIMLog->Log((TDesC8)KNumOfAasMax, aPbInitInfo->iNumOfAasMax );

   501 

   502     _LIT8( KGRPTextLengthMax, "GRPTextLengthMax: %d" );

   503     iSIMLog->Log((TDesC8)KGRPTextLengthMax, aPbInitInfo->iGRPTextLengthMax );

   504 

   505     _LIT8( KNumOfGasMax, "NumOfGasMax: %d" );

   506     iSIMLog->Log((TDesC8)KNumOfGasMax, aPbInitInfo->iNumOfGasMax );

   507 #endif // INTERNAL_RD_USIM_PHONEBOOK_GAS_AND_AAS

   508     }

   509 

   510 

   511 // -----------------------------------------------------------------------------

   512 // CSIM::PbStoreCacheL

   513 // Phonebook-cache (ADN & FDN)

   514 // -----------------------------------------------------------------------------

   515 //

   516 TInt CSIM::PbStoreCacheL( CStifItemParser& aItem )

   517     {

   518     _LIT8(KPbStoreCache, "SIM::PbStoreCache");

   519     iSIMLog->Log((TDesC8)KPbStoreCache);

   520 

   521     TInt ret( KErrNotFound );

   522     TBool supported( ETrue );

   523     TPtrC string;

   524     aItem.GetNextString( string );

   525     CPhoneBookDataPackage package;

   526 

   527     if ( _L("Adn") == string )

   528         {

   529         iSIMLog->Log((TDesC8)KAdnPhoneBook);

   530         iPhoneBookName = KETelIccAdnPhoneBook;

   531         // Set package data

   532         package.SetPhoneBookName( iPhoneBookName );

   533         package.PackData( &iPBStoreCacheAdn );

   534         }

   535     else if ( _L("Fdn") == string )

   536         {

   537         iSIMLog->Log((TDesC8)KFdnPhoneBook);

   538         iPhoneBookName = KETelIccFdnPhoneBook;

   539 

   540         // Set package data

   541         package.SetPhoneBookName( iPhoneBookName );

   542         package.PackData( &iPBStoreCacheFdn );

   543         }

   544     else if ( _L("Sdn") == string )

   545         {

   546         iSIMLog->Log((TDesC8)KSdnPhoneBook);

   547         iPhoneBookName = KETelIccSdnPhoneBook;

   548 

   549         // Set package data

   550         package.SetPhoneBookName( iPhoneBookName );

   551         package.PackData( &iPBStoreCacheSdn );

   552         }

   553     else

   554         {

   555          _LIT8(KNotSupp, "SIM::Selected PB not supported");

   556         iSIMLog->Log((TDesC8)KNotSupp);

   557         supported = EFalse;

   558         }

   559 

   560     if ( supported )

   561         {

   562         ret = HandleRequestL( EMmTsyPhoneBookStoreCacheIPC,

   563                              &package );

   564 

   565         if ( KErrNone == ret )

   566             {

   567             _LIT8( KSendOk, "PbStoreCache request send ok" );

   568             iSIMLog->Log((TDesC8)KSendOk );

   569             }

   570         else

   571             {

   572              _LIT8( KSendFailed, "PbStoreCache request send failed: %d" );

   573             iSIMLog->Log((TDesC8)KSendFailed, ret );

   574             }

   575         }

   576     else

   577         {

   578         ret = KErrNotSupported;

   579         }

   580 

   581     return ret;

   582 

   583     }

   584 

   585 // -----------------------------------------------------------------------------

   586 // CSIM::PbStoreCacheCancelL

   587 // Phonebook-cacheing cancel (ADN, FDN, SDN)

   588 // -----------------------------------------------------------------------------

   589 //

   590 TInt CSIM::PbStoreCacheCancelL( CStifItemParser& aItem )

   591     {

   592     _LIT8(KPbStoreCacheCancel, "SIM::PbStoreCacheCancel");

   593     iSIMLog->Log((TDesC8)KPbStoreCacheCancel);

   594 

   595     TInt ret( KErrNotFound );

   596     TBool supported( ETrue );

   597     TPtrC string;

   598     aItem.GetNextString( string );

   599     CPhoneBookDataPackage package;

   600 

   601     if ( _L("Adn") == string )

   602         {

   603         iSIMLog->Log((TDesC8)KAdnPhoneBook);

   604         iPhoneBookName = KETelIccAdnPhoneBook;

   605         // Set package data

   606         package.SetPhoneBookName( iPhoneBookName );

   607         package.PackData( &iPBStoreCacheAdn );

   608         // Reallocating ADN phonebook store array to simulate error case

   609         delete iPBStoreCacheAdn;

   610         iPBStoreCacheAdn = NULL;

   611         iPBStoreCacheAdn = new ( ELeave )

   612                            CArrayPtrSeg<CPhoneBookStoreEntry>( 1 );

   613         _LIT8(KAdnPBReallocation, "ADN PB entries array reallocated");

   614         iSIMLog->Log((TDesC8)KAdnPBReallocation);

   615         }

   616     else if ( _L("Fdn") == string )

   617         {

   618         iSIMLog->Log((TDesC8)KFdnPhoneBook);

   619         iPhoneBookName = KETelIccFdnPhoneBook;

   620         // Set package data

   621         package.SetPhoneBookName( iPhoneBookName );

   622         package.PackData( &iPBStoreCacheFdn );

   623         // Reallocating FDN phonebook store array to simulate error case

   624         delete iPBStoreCacheFdn;

   625         iPBStoreCacheFdn = NULL;

   626         iPBStoreCacheFdn = new ( ELeave )

   627                            CArrayPtrSeg<CPhoneBookStoreEntry>( 1 );

   628         _LIT8(KFdnPBReallocation, "FDN PB entries array reallocated");

   629         iSIMLog->Log((TDesC8)KFdnPBReallocation);

   630         }

   631     else if ( _L("Sdn") == string )

   632         {

   633         iSIMLog->Log((TDesC8)KSdnPhoneBook);

   634         iPhoneBookName = KETelIccSdnPhoneBook;

   635         // Set package data

   636         package.SetPhoneBookName( iPhoneBookName );

   637         package.PackData( &iPBStoreCacheSdn );

   638         // Reallocating SDN phonebook store array to simulate error case

   639         delete iPBStoreCacheSdn;

   640         iPBStoreCacheSdn = NULL;

   641         iPBStoreCacheSdn = new ( ELeave )

   642                            CArrayPtrSeg<CPhoneBookStoreEntry>( 1 );

   643         _LIT8(KSdnPBReallocation, "SDN PB entries array reallocated");

   644         iSIMLog->Log((TDesC8)KSdnPBReallocation);

   645         }

   646     else

   647         {

   648          _LIT8(KNotSupp, "SIM::Selected PB not supported");

   649         iSIMLog->Log((TDesC8)KNotSupp);

   650         supported = EFalse;

   651         }

   652 

   653     if ( supported )

   654         {

   655         ret = HandleRequestL( EMmTsyPhoneBookStoreCacheCancelIPC,

   656                              &package );

   657         if ( KErrNone == ret )

   658             {

   659             _LIT8( KSendOk, "PbStoreCacheCancel request send ok" );

   660             iSIMLog->Log((TDesC8)KSendOk );

   661             }

   662         else

   663             {

   664              _LIT8( KSendFailed, "PbStoreCacheCancel request send failed: %d" );

   665             iSIMLog->Log((TDesC8)KSendFailed, ret );

   666             }

   667         }

   668     else

   669         {

   670         ret = KErrNotSupported;

   671         }

   672 

   673     return ret;

   674     }

   675 

   676 // -----------------------------------------------------------------------------

   677 // CSIM::CompletePbStoreCache

   678 // Complete PbStoreCache method function.

   679 // -----------------------------------------------------------------------------

   680 //

   681 void CSIM::CompletePbStoreCache

   682         (

   683         TInt aResult,

   684         CMmDataPackage* aDataPackage

   685         )

   686     {

   687     _LIT8( KResult, "CompletePbStoreCache result: %d" );

   688     iSIMLog->Log((TDesC8)KResult, aResult );

   689 

   690     if ( KErrNone == aResult )

   691         {

   692         const CPhoneBookDataPackage* phoneBookData =

   693             static_cast<const CPhoneBookDataPackage*>(aDataPackage);

   694 

   695         TName pbName;

   696         phoneBookData->GetPhoneBookName( pbName );

   697 

   698         // Later return value will be set as a value for aResult if

   699         // response data is checked for this case in function called below

   700         ( void ) ReadEntriesFromArray( EPBStoreCacheArray, pbName );

   701 

   702         // check phonebook name

   703         if( iHandleSpecifiedRequests )

   704             {

   705             if( iPhoneBookName != pbName )

   706                 {

   707                 aResult = KErrGeneral;

   708                 }

   709             }

   710 

   711         // Check number of cached phonebook entries

   712         if ( -1 != iSavedPbEntriesCount )

   713             {

   714             aResult = CheckNumberOfPbEntries( EPBStoreCacheArray, pbName );

   715             }

   716         }

   717     else

   718         {

   719         _LIT8( KFail, "CompletePbStoreCache Failed: %d" );

   720         iSIMLog->Log((TDesC8)KFail, aResult );

   721         }

   722 

   723     // complete if failure

   724     if( KErrNone != aResult )

   725         {

   726         Signal( aResult );

   727         }

   728     // complete if test is not ongoing

   729     else if( ! iTestOngoing )

   730         {

   731         Signal( aResult );

   732         }

   733     iTestOngoing = EFalse;

   734     }

   735 

   736 // -----------------------------------------------------------------------------

   737 // CSIM::ReadEntriesL

   738 // Read phone book entries

   739 // -----------------------------------------------------------------------------

   740 //

   741 TInt CSIM::ReadEntriesL( CStifItemParser& aItem )

   742     {

   743     _LIT8(KReadEntries, "SIM::ReadEntries");

   744     iSIMLog->Log((TDesC8)KReadEntries);

   745 

   746     TInt ret( KErrNotFound );

   747     TBool supported( ETrue );

   748     TPtrC string;

   749     TPtrC string2;

   750     TInt indexToRead;

   751     TInt numEntriesToRead;

   752 

   753     // 1. parameter = phonebook name

   754     aItem.GetNextString( string );

   755     // 2. parameter = index to be read

   756     aItem.GetNextInt( indexToRead );

   757     // 3. parameter = number of entries to be read

   758     aItem.GetNextInt( numEntriesToRead );

   759 

   760     // for checking the validity of response data

   761 

   762     // 4. parameter = name

   763     aItem.GetNextString( string2 );

   764     iSavedNameForComparison[0].Zero();

   765     iSavedNameForComparison[0].Append( string2 );

   766 

   767     // 5. parameter = number

   768     aItem.GetNextString( string2 );

   769     iSavedNumberForComparison[0].Zero();

   770     iSavedNumberForComparison[0].Append( string2 );

   771 

   772     // 6. parameter = email

   773     aItem.GetNextString( string2 );

   774     iSavedEmailForComparison[0].Zero();

   775     iSavedEmailForComparison[0].Append( string2 );

   776 

   777     // 7. parameter = SNE

   778     aItem.GetNextString( string2 );

   779     iSavedSneForComparison[0].Zero();

   780     iSavedSneForComparison[0].Append( string2 );

   781 

   782     // 8.parameter = ANR

   783     aItem.GetNextString( string2 );

   784     iSavedAnrForComparison[0].Zero();

   785     iSavedAnrForComparison[0].Append( string2 );

   786 

   787     // if there is second entry to be read, use index 1

   788     // 9. parameter = name

   789     aItem.GetNextString( string2 );

   790     iSavedNameForComparison[1].Zero();

   791     iSavedNameForComparison[1].Append( string2 );

   792 

   793     // 10. parameter = number

   794     aItem.GetNextString( string2 );

   795     iSavedNumberForComparison[1].Zero();

   796     iSavedNumberForComparison[1].Append( string2 );

   797 

   798     // 11. parameter = email

   799     aItem.GetNextString( string2 );

   800     iSavedEmailForComparison[1].Zero();

   801     iSavedEmailForComparison[1].Append( string2 );

   802 

   803     // 12. parameter = SNE

   804     aItem.GetNextString( string2 );

   805     iSavedSneForComparison[1].Zero();

   806     iSavedSneForComparison[1].Append( string2 );

   807 

   808     // 13.parameter = ANR

   809     aItem.GetNextString( string2 );

   810     iSavedAnrForComparison[1].Zero();

   811     iSavedAnrForComparison[1].Append( string2 );

   812 

   813 

   814     if ( _L("Adn") == string )

   815         {

   816         iSIMLog->Log((TDesC8)KAdnPhoneBook);

   817         iPhoneBookName = KETelIccAdnPhoneBook;

   818         }

   819     else if ( _L("Fdn") == string )

   820         {

   821         iSIMLog->Log((TDesC8)KFdnPhoneBook);

   822         iPhoneBookName = KETelIccFdnPhoneBook;

   823         }

   824     else if ( _L("MBDN") == string )

   825         {

   826         iSIMLog->Log((TDesC8)KMBDN);

   827         iPhoneBookName = KETelIccMbdnPhoneBook;

   828         }

   829     else

   830         {

   831          _LIT8(KNotSupp, "SIM::Selected PB not supported");

   832         iSIMLog->Log((TDesC8)KNotSupp);

   833         supported = EFalse;

   834         }

   835 

   836     if ( supported )

   837         {

   838         iIndexAndEntries->iIndex = indexToRead;

   839         iIndexAndEntries->iNumSlots = numEntriesToRead;

   840 

   841         //Create package

   842         CPhoneBookDataPackage package;

   843         // Set package data

   844         package.SetPhoneBookName( iPhoneBookName );

   845         package.PackData( &iIndexAndEntries, &iPBStoreReadEntries );

   846 

   847         ret = HandleRequestL( EMmTsyPhoneBookStoreReadIPC,

   848                              &package );

   849 

   850         if ( KErrNone == ret )

   851             {

   852             _LIT8( KSendOk, "ReadEntries request send ok" );

   853             iSIMLog->Log((TDesC8)KSendOk );

   854             }

   855         else

   856             {

   857              _LIT8( KSendFailed, "ReadEntries request send failed: %d" );

   858             iSIMLog->Log((TDesC8)KSendFailed, ret );

   859             }

   860         }

   861     else

   862         {

   863         ret = KErrNotSupported;

   864         }

   865 

   866     return ret;

   867 

   868     }

   869 

   870 // -----------------------------------------------------------------------------

   871 // CSIM::CompleteReadEntries

   872 // Complete ReadEntries method function.

   873 // -----------------------------------------------------------------------------

   874 //

   875 void CSIM::CompleteReadEntries

   876         (

   877         TInt aResult

   878         )

   879     {

   880     _LIT8( KResult, "CompleteReadEntries result: %d" );

   881     iSIMLog->Log((TDesC8)KResult, aResult );

   882 

   883     if( KErrNone == aResult )

   884         {

   885         aResult = ReadEntriesFromArray( EPBStoreReadEntriesArray, iPhoneBookName );

   886         }

   887     else

   888         {

   889         _LIT8( KFail, "CompleteReadEntries Failed: %d" );

   890         iSIMLog->Log((TDesC8)KFail, aResult );

   891         }

   892 

   893     Signal( aResult );

   894     }

   895 

   896 // -----------------------------------------------------------------------------

   897 // CSIM::ReadEntriesFromArray

   898 // Prints Pb entries

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

   900 //

   901 TInt CSIM::ReadEntriesFromArray(

   902     TPBArrayTypeToRead aArrayType,

   903     TDesC16& aPbName )

   904 

   905     {

   906     TInt result = KErrNone;

   907     TInt num;

   908 

   909     _LIT8(KReadEntriesFromArray, "SIM::ReadEntriesFromArray");

   910     iSIMLog->Log((TDesC8)KReadEntriesFromArray);

   911 

   912     CArrayPtrSeg<CPhoneBookStoreEntry>* ptrToArray = NULL;

   913 

   914     if ( EPBStoreCacheArray == aArrayType )

   915         {

   916         if ( 0 == aPbName.CompareF( KETelIccAdnPhoneBook ) )

   917             {

   918             ptrToArray = iPBStoreCacheAdn;

   919             _LIT8(KADN, "ADN entries: ");

   920             iSIMLog->Log((TDesC8)KADN);

   921             }

   922         else if ( 0 == aPbName.CompareF( KETelIccFdnPhoneBook ) )

   923             {

   924             ptrToArray = iPBStoreCacheFdn;

   925             _LIT8(KFDN, "FDN entries: ");

   926             iSIMLog->Log((TDesC8)KFDN);

   927             }

   928         else if ( 0 == aPbName.CompareF( KETelIccSdnPhoneBook ) )

   929             {

   930             ptrToArray = iPBStoreCacheSdn;

   931             _LIT8(KSDN, "SDN entries: ");

   932             iSIMLog->Log((TDesC8)KSDN);

   933             }

   934         }

   935     else if ( EPBStoreReadEntriesArray == aArrayType )

   936         {

   937         ptrToArray = iPBStoreReadEntries;

   938         }

   939 

   940     for ( TInt locationIndex = 0; locationIndex < ptrToArray->Count();

   941           locationIndex++ )

   942         {

   943         CPhoneBookStoreEntry* ptr;

   944         ptr = ptrToArray->At( locationIndex );

   945 

   946         iSIMLog->Log((TDesC8)KLine);

   947         _LIT8( KLocation, "Location: %d" );

   948         iSIMLog->Log((TDesC8)KLocation, ptr->iLocation );

   949 

   950         // Name

   951         if ( ptr->iText && ( 0 < ptr->iText->Size() ) )

   952             {

   953             _LIT8( KName, "Name:" );

   954             iSIMLog->Log((TDesC8)KName);

   955             iSIMLog->Log( *(ptr->iText ));

   956 

   957             if ( ( 0 != iSavedNameForComparison[locationIndex].Compare ( _L ( "DONTCARE" ) ) ) &&

   958                  ( KErrNone == result ) )

   959                 {

   960                 if ( iSavedNameForComparison[locationIndex] != *(ptr->iText ) )

   961                     {

   962                     result = KErrGeneral;

   963                     }

   964                 }

   965             }

   966 

   967         // Number

   968         if ( ptr->iNumber && ( 0 < ptr->iNumber->Size() ) )

   969             {

   970             _LIT8( KNumber, "Number:" );

   971             iSIMLog->Log((TDesC8)KNumber);

   972             iSIMLog->Log( *(ptr->iNumber ));

   973 

   974             if ( ( 0 != iSavedNumberForComparison[locationIndex].Compare ( _L ( "DONTCARE" ) ) ) &&

   975                  ( KErrNone == result ) )

   976                 {

   977                 if ( iSavedNumberForComparison[locationIndex] != *(ptr->iNumber ) )

   978                     {

   979                     result = KErrGeneral;

   980                     }

   981                 }

   982             }

   983 

   984         // Email

   985         if (ptr->iEmail && (0 < ptr->iEmail->MdcaCount()))

   986             {

   987             for( num = 0; num < ptr->iEmail->MdcaCount(); num++)

   988                 {

   989                 _LIT8( KEmail, "Email:" );

   990                 iSIMLog->Log((TDesC8)KEmail);

   991                 iSIMLog->Log( (ptr->iEmail->MdcaPoint( num ) ));

   992 

   993                 if ( ( 0 != iSavedEmailForComparison[locationIndex].Compare ( _L ( "DONTCARE" ) ) ) &&

   994                         ( KErrNone == result ) )

   995                     {

   996                     TBuf<100> tempBuffer( ptr->iEmail->MdcaPoint( num ) );

   997                     if ( iSavedEmailForComparison[locationIndex] != tempBuffer )

   998                         {

   999                         result = KErrGeneral;

  1000                         }

  1001                     }

  1002                 }

  1003             }

  1004 

  1005         // Sne

  1006         if (ptr->iSne && (0 < ptr->iSne->MdcaCount()))

  1007             {

  1008             for( num = 0; num < ptr->iSne->MdcaCount(); num++)

  1009                 {

  1010                 _LIT8( KSne, "Sne:" );

  1011                 iSIMLog->Log((TDesC8)KSne);

  1012                 iSIMLog->Log( (ptr->iSne->MdcaPoint( num ) ));

  1013 

  1014                 if ( ( 0 != iSavedSneForComparison[locationIndex].Compare ( _L ( "DONTCARE" ) ) ) &&

  1015                         ( KErrNone == result ) )

  1016                     {

  1017                     TBuf<100> tempBuffer( ptr->iSne->MdcaPoint( num ) );

  1018                     if ( iSavedSneForComparison[locationIndex] != tempBuffer )

  1019                         {

  1020                         result = KErrGeneral;

  1021                         }

  1022                     }

  1023                 }

  1024             }

  1025 

  1026 #ifdef INTERNAL_RD_USIM_PHONEBOOK_GAS_AND_AAS

  1027         if (ptr->iGrp && (0 < ptr->iGrp->MdcaCount()))

  1028             {

  1029             for(TInt num = 0; num < ptr->iGrp->MdcaCount(); num++)

  1030                 {

  1031                 _LIT8( KGrp, "Grp:" );

  1032                 iSIMLog->Log((TDesC8)KGrp);

  1033                 iSIMLog->Log( (ptr->iGrp->MdcaPoint( num ) ));

  1034                 }

  1035             }

  1036         if (ptr->iAnr && (0 < ptr->iAnr->Count()))

  1037             {

  1038             for(TInt num = 0; num < ptr->iAnr->Count(); num++)

  1039                 {

  1040                 TPhBkAdditionalEntry entry = ptr->iAnr->At(num);

  1041                 _LIT8( KAnrNum, "AnrNum:" );

  1042                 iSIMLog->Log((TDesC8)KAnrNum);

  1043                 iSIMLog->Log( entry.iTelNum );

  1044 

  1045                 if ( entry.iAlphaTag.Length())

  1046                     {

  1047                     _LIT8( KAas, "Aas:" );

  1048                     iSIMLog->Log((TDesC8)KAas);

  1049                     iSIMLog->Log( entry.iAlphaTag );

  1050                     }

  1051                 }

  1052             }

  1053 #else

  1054 

  1055         // Anr

  1056         if ( ptr->iAnr && (0 < ptr->iAnr->MdcaCount()))

  1057             {

  1058             for( num = 0; num < ptr->iAnr->MdcaCount(); num++)

  1059                 {

  1060                 _LIT8( KAnr, "Anr:" );

  1061                 iSIMLog->Log((TDesC8)KAnr);

  1062                 iSIMLog->Log( (ptr->iAnr->MdcaPoint( num ) ));

  1063                 if ( ( 0 != iSavedAnrForComparison[locationIndex].Compare ( _L ( "DONTCARE" ) ) ) &&

  1064                         ( KErrNone == result ) )

  1065                     {

  1066                     TBuf<100> tempBuffer( ptr->iAnr->MdcaPoint( num )  );

  1067                     if ( iSavedAnrForComparison[locationIndex] != tempBuffer )

  1068                         {

  1069                         result = KErrGeneral;

  1070                         }

  1071                     }

  1072                 }

  1073              }

  1074 #endif // INTERNAL_RD_USIM_PHONEBOOK_GAS_AND_AAS

  1075 

  1076         iSIMLog->Log((TDesC8)KLine);

  1077         }

  1078     return result;

  1079     }

  1080 

  1081 // -----------------------------------------------------------------------------

  1082 // CSIM::WriteEntriesL

  1083 // Checks number of PB entries in the cache

  1084 // -----------------------------------------------------------------------------

  1085 //

  1086 TInt CSIM::CheckNumberOfPbEntries( TPBArrayTypeToRead aArrayType,

  1087         TDesC16& aPbName )

  1088     {

  1089     TInt result( KErrNone );

  1090 

  1091     _LIT8(KCheckNumberOfPbEntries, "SIM::CheckNumberOfPbEntries");

  1092     iSIMLog->Log((TDesC8)KCheckNumberOfPbEntries);

  1093 

  1094     CArrayPtrSeg<CPhoneBookStoreEntry>* ptrToArray = NULL;

  1095 

  1096     if ( EPBStoreCacheArray == aArrayType )

  1097         {

  1098         if ( 0 == aPbName.CompareF( KETelIccAdnPhoneBook ) )

  1099             {

  1100             ptrToArray = iPBStoreCacheAdn;

  1101             _LIT8(KADN, "Checking number of ADN entries: ");

  1102             iSIMLog->Log((TDesC8)KADN);

  1103             }

  1104         else if ( 0 == aPbName.CompareF( KETelIccFdnPhoneBook ) )

  1105             {

  1106             ptrToArray = iPBStoreCacheFdn;

  1107             _LIT8(KFDN, "Checking number of FDN entries: ");

  1108             iSIMLog->Log((TDesC8)KFDN);

  1109             }

  1110         else if ( 0 == aPbName.CompareF( KETelIccSdnPhoneBook ) )

  1111             {

  1112             ptrToArray = iPBStoreCacheSdn;

  1113             _LIT8(KSDN, "Checking number of SDN entries: ");

  1114             iSIMLog->Log((TDesC8)KSDN);

  1115             }

  1116         }

  1117     else if ( EPBStoreReadEntriesArray == aArrayType )

  1118         {

  1119         ptrToArray = iPBStoreReadEntries;

  1120         }

  1121 

  1122     if ( ptrToArray->Count() != iSavedPbEntriesCount )

  1123         {

  1124         _LIT8(KEntriesNumberDoesNotMatch, "PB entries number does not match: \

  1125                 exp=%d, act=%d");

  1126         iSIMLog->Log((TDesC8)KEntriesNumberDoesNotMatch,

  1127                 iSavedPbEntriesCount, ptrToArray->Count());

  1128         result = KErrGeneral;

  1129         }

  1130 

  1131     return result;

  1132     }

  1133 

  1134 // -----------------------------------------------------------------------------