1 /*

     2 * Copyright (c) 2004 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 #define private public

    21 #include "aioperatornamepublisher.h"

    22 #undef private

    23 #define protected public

    24 #include "aibtsappublisher.h"

    25 #include "aimulticontentobserver.h"

    26 #include "aicontentobserveroptimizer.h"

    27 #include "aioperatorlogopublisher.h"

    28 #define private public

    29 #include "aiprofilepublisher.h"

    30 #include "aidatepublisher.h"

    31 #undef private

    32 #undef protected

    33 #include "UT_DevStaPlg2.h"

    34 #include <hscontentpublisher.h>

    35 #include "aidevicestatuscontentmodel.h"

    36 #include "caouserafter.h"

    37 #include "logotools.h"

    38 #include "testingtools.h"

    39 #include "contentobserver.h"

    40 #include "ainativeuiplugins.h"

    41 #include <aicontentrequest.h>

    42 #include "ainwidpriorities.h"

    43 

    44 //  EXTERNAL INCLUDES

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

    46 #include <digia/eunit/ceunitalloctestcasedecorator.h>

    47 #include <settingsinternalcrkeys.h>

    48 #include <profile.hrh>

    49 #include <mprofilechangeobserver.h>

    50 #include <e32cmn.h>

    51 #include <gulicon.h>

    52 

    53 #include "aidevicestatusplugin.h"

    54 

    55 //  INTERNAL INCLUDES

    56 

    57 

    58 const TInt KCountryCode = 244;

    59 const TInt KNetworkId = 91;

    60 

    61 

    62 

    63 

    64 // CONSTRUCTION

    65 UT_DevStaPlg2* UT_DevStaPlg2::NewL()

    66     {

    67     UT_DevStaPlg2* self = UT_DevStaPlg2::NewLC();

    68     CleanupStack::Pop();

    69 

    70     return self;

    71     }

    72 

    73 UT_DevStaPlg2* UT_DevStaPlg2::NewLC()

    74     {

    75     UT_DevStaPlg2* self = new( ELeave ) UT_DevStaPlg2();

    76     CleanupStack::PushL( self );

    77 

    78     self->ConstructL();

    79 

    80     return self;

    81     }

    82 

    83 // Destructor (virtual by CBase)

    84 UT_DevStaPlg2::~UT_DevStaPlg2()

    85     {

    86     }

    87 

    88 // Default constructor

    89 UT_DevStaPlg2::UT_DevStaPlg2()

    90     {

    91     }

    92 

    93 // Second phase construct

    94 void UT_DevStaPlg2::ConstructL()

    95     {

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

    97     // It generates the test case table.

    98     CEUnitTestSuiteClass::ConstructL();

    99     }

   100 

   101 

   102 void UT_DevStaPlg2::SetupL(  )

   103     {

   104     //    __UHEAP_MARK;

   105     CStubDataHolder::InstanceL();

   106     iCache = this;

   107 

   108     TUid uid = { AI_UID_ECOM_IMPLEMENTATION_CONTENTPUBLISHER_DEVSTAPLUGIN };

   109     

   110     _LIT8( KNameSpace, "1" );

   111     

   112     THsPublisherInfo pubInfo( uid, KDeviceStatusPluginName, KNameSpace );

   113     

   114     iPublisher = CHsContentPublisher::NewL( pubInfo );

   115     

   116     RAiSettingsItemArray settings;

   117     iPublisher->ConfigureL( settings );

   118     iPublisher->SubscribeL( *iCache );

   119     iPublisher->Start( CHsContentPublisher::ESystemStartup );    

   120     /*

   121 //    __UHEAP_MARK;

   122     CStubDataHolder::InstanceL();

   123     iCache = this;

   124 

   125     TUid uid = { AI_UID_ECOM_IMPLEMENTATION_CONTENTPUBLISHER_DEVSTAPLUGIN };

   126     iPublisher = CAiContentPublisher::NewL( uid );

   127     //User::LeaveIfError( err );

   128 

   129     TAny* temp = NULL;

   130     MAiPropertyExtension* extension = NULL;

   131     TRAPD( err, temp = iPublisher->Extension( KExtensionUidProperty ) );

   132 

   133     if( temp /*&& err == KErrNone )

   134         {

   135         TAiPublisherInfo publisher;

   136         publisher.iUid = KDeviceStatusPluginUid;

   137         publisher.iName.Copy( KDeviceStatusPluginName );

   138         

   139         extension = static_cast<MAiPropertyExtension*>(temp);

   140         extension->SetPropertyL( EAiPublisherInfo, (TAny*)&publisher );

   141         

   142         const TAiPublisherInfo* result = NULL;

   143         

   144         TRAPD( err2, result = extension->PublisherInfoL() );

   145         

   146         }

   147         

   148     */

   149         

   150     /*

   151     else

   152         {

   153         EUNIT_PRINT( _L("Publisher extension not found, cannot set logger") );

   154         User::Leave( KErrNotFound );

   155         }

   156 */

   157     iPublisher->SubscribeL( *iCache );

   158 

   159     iLogoPublisher = CAiOperatorLogoPublisher::NewL();

   160         

   161     iNamePublisher = CAiOperatorNamePublisher::NewL();

   162 

   163     iMultiObserver = CAiMultiContentObserver::NewL();

   164 

   165     iBTSAP = CAiBTSAPPublisher::NewL();

   166 

   167     iDatePublisher = CAiDatePublisher::NewL();

   168     }

   169 

   170 void UT_DevStaPlg2::SetupEmptyL()

   171     {

   172 //    __UHEAP_MARK;

   173     }

   174 

   175 

   176 

   177 

   178 void UT_DevStaPlg2::Teardown(  )

   179     {

   180     delete iDatePublisher;

   181     

   182     delete iMultiObserver;

   183 

   184     delete iBTSAP;

   185 

   186     iInternalCache.ResetAndDestroy();

   187 

   188     delete iLogoPublisher;

   189         

   190     delete iNamePublisher;

   191 

   192     if( iPublisher )

   193         {

   194         iPublisher->Stop( CHsContentPublisher::ESystemShutdown );

   195         delete iPublisher;

   196         iPublisher = NULL;        

   197         }

   198         

   199     /*if( iUtils )

   200         {

   201         delete iUtils;

   202         iUtils =NULL;

   203         }*/

   204         

   205     if( iCache )

   206         {

   207         iCache->Reset();

   208         iCache = NULL;        

   209         }

   210 

   211     CStubDataHolder::Release();

   212     #if _BullseyeCoverage

   213         cov_write();

   214     #endif

   215     }

   216     

   217 void UT_DevStaPlg2::TestOperatorLogoPublisherL()

   218     {

   219     iLogoPublisher->Subscribe( *this,

   220                         *iPublisher,

   221                         *this,

   222                         *this );    	

   223 

   224     RFbsSession::Connect();

   225 

   226     // StoreOTALogoL( KCountryCode, KNetworkId );

   227     

   228     //only OTA logo

   229     iPublisher->Resume( CHsContentPublisher::EForeground );

   230 

   231     TNWInfo* nwInfo = CStubDataHolder::Instance()->NWInfo();

   232     nwInfo->iCountryCode.Format( _L("%i"), KCountryCode );

   233     nwInfo->iNetworkId.Format( _L("%i"), KNetworkId );

   234     nwInfo->iRegistrationStatus = ENWRegisteredOnHomeNetwork;

   235   

   236 	nwInfo->iStatus = ENWStatusCurrent;

   237     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkInfoChange );

   238     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageProgrammableOperatorInfoChange );

   239     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkProviderNameChange );

   240     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkRegistrationStatusChange );

   241     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageServiceProviderNameChange );

   242 

   243     //wait for publish

   244     CAOUserAfter::AfterLD( 2 * 1000000 );

   245 

   246     CContentCache* cache = iCache->GetContent( EAiDeviceStatusContentNetworkIdentity );

   247     

   248     /*

   249     if( !cache )

   250         {

   251         User::Leave( KErrNoMemory );

   252         }

   253 

   254     TPckgBuf<CGulIcon*> logoBuf;

   255     logoBuf.Copy( *cache->iData );

   256 

   257     EUNIT_ASSERT( logoBuf()->Bitmap() );

   258     EUNIT_ASSERT( logoBuf()->Mask() );

   259     */

   260         

   261 	nwInfo->iRegistrationStatus = ENWNotRegisteredNoService;

   262 	nwInfo->iStatus = ENWStatusCurrent;

   263     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkInfoChange );    

   264     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageProgrammableOperatorInfoChange );

   265     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkProviderNameChange );

   266     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkRegistrationStatusChange );

   267     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageServiceProviderNameChange );

   268 

   269 	//TODO Assert

   270 

   271 	nwInfo->iRegistrationStatus = ENWRegistrationUnknown ;

   272     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkInfoChange );    

   273     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageProgrammableOperatorInfoChange );

   274     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkProviderNameChange );

   275     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkRegistrationStatusChange );

   276     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageServiceProviderNameChange );

   277     

   278 	//TODO Assert

   279 

   280     RFbsSession::Disconnect();

   281     }    

   282     

   283 void UT_DevStaPlg2::TestOperatorProgNamePublisherL()

   284     {

   285 #if defined(WINSCW) || defined(__WINS__)    

   286     _LIT( KOperatorName, "Operator" );

   287 #else

   288     _LIT( KOperatorName, "ProgName" );

   289 #endif

   290     

   291     iPublisher->Resume( CHsContentPublisher::EForeground );

   292 

   293     TNWInfo* nwInfo = CStubDataHolder::Instance()->NWInfo();

   294     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameNitzFull;

   295     nwInfo->iOperatorNameInfo.iName.Copy( KOperatorName );

   296     nwInfo->iRegistrationStatus = ENWRegisteredOnHomeNetwork;

   297     nwInfo->iServiceProviderNameDisplayReq |= ENWDisplayPLMNRequired;

   298     nwInfo->iServiceProviderNameDisplayReq |= ENWDisplaySPNRequired;

   299     nwInfo->iStatus = ENWStatusCurrent;

   300 

   301     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkInfoChange );

   302     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkRegistrationStatusChange );

   303     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageProgrammableOperatorInfoUpdating );

   304     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageProgrammableOperatorInfoChange );

   305     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkProviderNameUpdating );

   306     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkProviderNameChange );

   307     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageServiceProviderNameUpdating );

   308     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageServiceProviderNameChange );

   309     

   310     /*

   311     CContentCache* cache = iCache->GetLastContent( EAiDeviceStatusContentNetworkIdentity );

   312 

   313     if( !cache )

   314         {

   315         User::Leave( KErrNoMemory );

   316         }

   317     */

   318 

   319     // EUNIT_ASSERT( *cache->iText == KOperatorName );

   320         

   321     CAOUserAfter::AfterLD( 100000 );

   322 

   323     nwInfo->iNPName.Copy( _L("NpName") );

   324     

   325     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkInfoChange );

   326     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkRegistrationStatusChange );

   327     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageProgrammableOperatorInfoUpdating );

   328     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageProgrammableOperatorInfoChange );

   329     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkProviderNameUpdating );

   330     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkProviderNameChange );

   331     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageServiceProviderNameUpdating );

   332     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageServiceProviderNameChange );

   333 

   334     CAOUserAfter::AfterLD( 100000 );

   335     

   336     nwInfo->iNPName.Copy( _L("") );

   337     nwInfo->iSPName.Copy( _L("OpName") );

   338 

   339     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkInfoChange );

   340     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkRegistrationStatusChange );

   341     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageProgrammableOperatorInfoUpdating );

   342     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageProgrammableOperatorInfoChange );

   343     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkProviderNameUpdating );

   344     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkProviderNameChange );

   345     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageServiceProviderNameUpdating );

   346     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageServiceProviderNameChange );

   347 

   348     CAOUserAfter::AfterLD( 100000 );

   349 

   350     nwInfo->iRegistrationStatus = ENWRegisteredRoaming;

   351 

   352     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkInfoChange );

   353     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkRegistrationStatusChange );

   354     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageProgrammableOperatorInfoUpdating );

   355     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageProgrammableOperatorInfoChange );

   356     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkProviderNameUpdating );

   357     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkProviderNameChange );

   358     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageServiceProviderNameUpdating );

   359     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageServiceProviderNameChange );

   360     

   361     CAOUserAfter::AfterLD( 100000 );

   362 

   363     nwInfo->iServiceProviderNameDisplayReq &= !ENWDisplayPLMNRequired;

   364     nwInfo->iRegistrationStatus = ENWRegisteredOnHomeNetwork;

   365     

   366     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkInfoChange );

   367     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkRegistrationStatusChange );

   368     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageProgrammableOperatorInfoUpdating );

   369     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageProgrammableOperatorInfoChange );

   370     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkProviderNameUpdating );

   371     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkProviderNameChange );

   372     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageServiceProviderNameUpdating );

   373     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageServiceProviderNameChange );

   374 

   375     CAOUserAfter::AfterLD( 100000 );

   376     

   377     nwInfo->iOperatorNameInfo.iName.Copy( _L("") );

   378 

   379     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkInfoChange );

   380     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkRegistrationStatusChange );

   381     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageProgrammableOperatorInfoUpdating );

   382     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageProgrammableOperatorInfoChange );

   383     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkProviderNameUpdating );

   384     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageNetworkProviderNameChange );

   385     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageServiceProviderNameUpdating );

   386     CStubDataHolder::Instance()->NWMessageObserver()->HandleNetworkMessage( MNWMessageObserver::ENWMessageServiceProviderNameChange );

   387 

   388 

   389 	//wait for publish

   390 	CAOUserAfter::AfterLD( 2 * 1000000 );

   391 	

   392     TInt prio;

   393     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameFlexiblePlmn;

   394     EUNIT_ASSERT( iNamePublisher->OperatorNamePriority( prio ) );

   395     

   396     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameNitzFull;

   397     EUNIT_ASSERT( iNamePublisher->OperatorNamePriority( prio ) );

   398     

   399     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameNitzShort;

   400     EUNIT_ASSERT( iNamePublisher->OperatorNamePriority( prio ) );

   401     

   402     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameProgrammableUcs2;

   403     EUNIT_ASSERT( iNamePublisher->OperatorNamePriority( prio ) );

   404     

   405     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameProgrammableLatin;

   406     EUNIT_ASSERT( iNamePublisher->OperatorNamePriority( prio ) );

   407     

   408     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameHardcodedUcs2;

   409     EUNIT_ASSERT( iNamePublisher->OperatorNamePriority( prio ) );

   410     

   411     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameHardcodedLatin;

   412     EUNIT_ASSERT( iNamePublisher->OperatorNamePriority( prio ) );

   413     

   414     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameCountryMcn;

   415     EUNIT_ASSERT( iNamePublisher->OperatorNamePriority( prio ) );

   416 

   417     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameMccMnc;

   418     EUNIT_ASSERT( iNamePublisher->OperatorNamePriority( prio ) );

   419 

   420     nwInfo->iOperatorNameInfo.iType = (RMmCustomAPI::TOperatorNameType)0xdeafdead;

   421     EUNIT_ASSERT( !iNamePublisher->OperatorNamePriority( prio ) );      

   422     }

   423     

   424 void UT_DevStaPlg2::TestMultiObserverL()

   425     {

   426     	/*

   427     RFs fss;

   428     fss.Connect();

   429     RFile file;

   430     iMultiObserver->AddObserverL( *this );

   431     iMultiObserver->AddObserverL( *this );

   432     iMultiObserver->Publish( *static_cast<CHsContentPublisher*>(iPublisher->Extension( KExtensionUidProperty )), 0,

   433                              file, 0 );

   434     iMultiObserver->Publish( *static_cast<CHsContentPublisher*>(iPublisher->Extension( KExtensionUidProperty )), 0,

   435                              _L8("dkorks"), 0 );

   436     iMultiObserver->Extension( TUid::Uid( 0 ) );

   437     iMultiObserver->CanPublish( *static_cast<CHsContentPublisher*>(iPublisher->Extension( KExtensionUidProperty )),

   438                                 0, 0 );

   439     fss.Close();

   440     EUNIT_ASSERT( iBufPublished )

   441     EUNIT_ASSERT( iFilePublished )

   442     */

   443     }

   444 

   445 void UT_DevStaPlg2::TestBTSAPPublisherL()

   446     {

   447     	/*

   448     iBTSAP->Subscribe( *this,

   449                        *static_cast<CHsContentPublisher*>(iPublisher->Extension( KExtensionUidProperty )),

   450                        *this,

   451                        *this );

   452     iBTSAP->RefreshL( 0, ETrue );

   453     iBTSAP->RefreshL( EAiDeviceStatusContentNetworkIdentity, EFalse );

   454     iBTSAP->RefreshL( EAiDeviceStatusContentNetworkIdentity, ETrue );

   455     iBTSAP->RefreshL( 0, EFalse );

   456     iBTSAP->RefreshL( ETrue );

   457     iBTSAP->RefreshL( EFalse );

   458     iBTSAP->RefreshContentWithPriorityL( EAiDeviceStatusContentNetworkIdentity,

   459                                          EAiBTSAP );

   460     iBTSAP->RefreshContentWithPriorityL( 0,

   461                                          EAiBTSAP );

   462     iBTSAP->RefreshContentWithPriorityL( EAiDeviceStatusContentNetworkIdentity,

   463                                          0 );

   464                                          */

   465     }

   466 

   467 /*

   468 void UT_DevStaPlg2::TestProfilePublisherL()

   469     {

   470 

   471     iProfilePublisher = CAiProfilePublisher::NewL();

   472 

   473     CStubDataHolder::Instance()->SetCurrentProfileL(_L("General"),EProfileGeneralId);

   474     iProfilePublisher->Subscribe( *this,

   475                                   *static_cast<CHsContentPublisher*>(iPublisher->Extension( KExtensionUidProperty )),

   476                                   *this,

   477                                   *this );

   478     iProfilePublisher->RefreshL( ETrue );

   479     iProfilePublisher->RefreshL( EFalse );

   480     

   481     iProfilePublisher->RefreshProfileL( ETrue );

   482     iProfilePublisher->RefreshProfileL( EFalse );

   483     

   484     iProfilePublisher->RefreshL( EAiDeviceStatusContentProfileName, ETrue );

   485     iProfilePublisher->RefreshL( EAiDeviceStatusContentGeneralProfileName, EFalse );

   486     iProfilePublisher->RefreshL( EAiDeviceStatusContentNetworkIdentity, ETrue );

   487     

   488     iProfilePublisher->RefreshContentWithPriorityL( EAiDeviceStatusContentNetworkIdentity,

   489                                          EAiOfflineProfile );

   490     iProfilePublisher->RefreshContentWithPriorityL( 0,

   491                                          EAiOfflineProfile );

   492     iProfilePublisher->RefreshContentWithPriorityL( EAiDeviceStatusContentNetworkIdentity,

   493                                                     0 );

   494     delete iProfilePublisher;

   495 

   496     }

   497     */    

   498     

   499 void UT_DevStaPlg2::TestDatePublisherL()

   500     {

   501     	/*

   502     iDatePublisher->Subscribe( *this,

   503                                   *static_cast<CHsContentPublisher*>(iPublisher->Extension( KExtensionUidProperty )),

   504                                   *this,

   505                                   *this );

   506     HBufC* string;

   507     string = iDatePublisher->GetDayNameStringLC( EMonday, *CCoeEnv::Static() );

   508     EUNIT_ASSERT( string )

   509     CleanupStack::PopAndDestroy( string );

   510     string = iDatePublisher->GetDayNameStringLC( ETuesday, *CCoeEnv::Static() );

   511     EUNIT_ASSERT( string )

   512     CleanupStack::PopAndDestroy( string );

   513     string = iDatePublisher->GetDayNameStringLC( EWednesday, *CCoeEnv::Static() );

   514     EUNIT_ASSERT( string )

   515     CleanupStack::PopAndDestroy( string );

   516     string = iDatePublisher->GetDayNameStringLC( EThursday, *CCoeEnv::Static() );

   517     EUNIT_ASSERT( string )

   518     CleanupStack::PopAndDestroy( string );

   519     string = iDatePublisher->GetDayNameStringLC( EFriday, *CCoeEnv::Static() );

   520     EUNIT_ASSERT( string )

   521     CleanupStack::PopAndDestroy( string );

   522     string = iDatePublisher->GetDayNameStringLC( ESaturday, *CCoeEnv::Static() );

   523     EUNIT_ASSERT( string )

   524     CleanupStack::PopAndDestroy( string );

   525     string = iDatePublisher->GetDayNameStringLC( ESunday, *CCoeEnv::Static() );

   526     EUNIT_ASSERT( string )

   527     CleanupStack::PopAndDestroy( string );

   528     */

   529     }

   530 

   531 void UT_DevStaPlg2::TestPluginL()

   532     {

   533     iLogoPublisher->Subscribe( *this,

   534                         *iPublisher,

   535                         *this,

   536                         *this );

   537     iDatePublisher->Subscribe( *this,

   538                                   *iPublisher,

   539                                   *this,

   540                                   *this );

   541     iNamePublisher->Subscribe( *this,

   542                         *iPublisher,

   543                         *this,

   544                         *this );

   545     

   546     iPublisher->SubscribeL( *this );

   547     iPublisher->Resume( CHsContentPublisher::EForeground );

   548 

   549     EUNIT_ASSERT( !iPublisher->Extension( TUid::Uid(0xdeafd0de) ) );

   550     // EUNIT_ASSERT( iPublisher->Extension( KExtensionUidProperty ) );

   551     

   552     EUNIT_ASSERT( iPublisher->GetProperty( CHsContentPublisher::EPublisherResources ) );

   553     

   554     iPublisher->SetProperty( CHsContentPublisher::EPublisherResources, NULL );

   555     iLogoPublisher->RefreshL( 0xdee, ETrue );

   556     iLogoPublisher->RefreshL( 0xdee, EFalse );

   557     iLogoPublisher->RefreshL( EAiDeviceStatusContentNetworkIdentity, EFalse );

   558     iLogoPublisher->RefreshL( EAiDeviceStatusContentNetworkIdentity, ETrue );

   559     iLogoPublisher->HandleNotifyInt( 0xd00, 6 );

   560     iLogoPublisher->HandleNotifyInt( 0, 6 );

   561     iLogoPublisher->HandleNotifyInt( KSettingsDisplayOperatorLogo, 6 );

   562 

   563     _LIT( KOperatorName, "ProgName" );

   564 

   565     TNWInfo* nwInfo = CStubDataHolder::Instance()->NWInfo();

   566     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameNitzFull;

   567     nwInfo->iOperatorNameInfo.iName.Copy( KOperatorName );

   568     nwInfo->iRegistrationStatus = ENWRegisteredOnHomeNetwork;

   569     nwInfo->iServiceProviderNameDisplayReq |= ENWDisplayPLMNRequired;

   570     nwInfo->iServiceProviderNameDisplayReq |= ENWDisplaySPNRequired;

   571     nwInfo->iStatus = ENWStatusCurrent;

   572     iNamePublisher->ShowNetworkIdentityNameL( ETrue );

   573     

   574     nwInfo->iNPName.Copy(_L("NPN"));

   575     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameFlexiblePlmn;

   576     iNamePublisher->ShowNetworkIdentityNameL( ETrue );

   577     

   578     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameNitzFull;

   579     nwInfo->iRegistrationStatus = ENWRegisteredRoaming;

   580     iNamePublisher->ShowNetworkIdentityNameL( ETrue );

   581     

   582     nwInfo->iNPName.Copy(_L(""));

   583     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameFlexiblePlmn;

   584     iNamePublisher->ShowNetworkIdentityNameL( ETrue );

   585 

   586     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameMccMnc;

   587     iNamePublisher->ShowNetworkIdentityNameL( ETrue );

   588 

   589     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameCountryMcn;

   590     iNamePublisher->ShowNetworkIdentityNameL( ETrue );

   591 

   592     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameProgrammableUcs2;

   593     iNamePublisher->ShowNetworkIdentityNameL( ETrue );

   594 

   595     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameProgrammableLatin;

   596     iNamePublisher->ShowNetworkIdentityNameL( ETrue );

   597 

   598     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameHardcodedUcs2;

   599     iNamePublisher->ShowNetworkIdentityNameL( ETrue );

   600 

   601     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameHardcodedLatin;

   602     iNamePublisher->ShowNetworkIdentityNameL( ETrue );

   603     nwInfo->iOperatorNameInfo.iType = RMmCustomAPI::EOperatorNameMccMnc;

   604     iNamePublisher->ShowNetworkIdentityNameL( ETrue );

   605     nwInfo->iOperatorNameInfo.iType = (RMmCustomAPI::TOperatorNameType)0xdeafdead;

   606     iNamePublisher->ShowNetworkIdentityNameL( ETrue );

   607     }

   608         

   609 #include "contentobserver.h"

   610 

   611 

   612 void UT_DevStaPlg2::Reset()

   613     {

   614     iInternalCache.ResetAndDestroy();

   615     }

   616 

   617 

   618 CContentCache* UT_DevStaPlg2::GetContent( TInt aContentId, TBool aClean )

   619     {

   620     const TInt count( iInternalCache.Count() );

   621     for( TInt i( 0 ); i < count; i++ )

   622         {

   623         if( iInternalCache[i]->iId == aContentId )

   624             {

   625             if( !aClean && iInternalCache[i]->iClean)

   626                 {

   627                 continue;

   628                 }

   629             return iInternalCache[i];

   630             }

   631         }

   632 

   633     return NULL;

   634     }

   635 

   636 

   637 CContentCache* UT_DevStaPlg2::GetLastContent( TInt aContentId, TBool aClean )

   638     {

   639     const TInt count( iInternalCache.Count() );

   640     for( TInt i( count - 1 ); i >= 0; i-- )

   641         {

   642         if( iInternalCache[i]->iId != aContentId )

   643             {

   644             return NULL;

   645             }

   646         if( !aClean && iInternalCache[i]->iClean)

   647             {

   648             continue;

   649             }

   650         return iInternalCache[i];

   651         }

   652     return NULL;

   653     }

   654 

   655 

   656 TInt UT_DevStaPlg2::StartTransaction(TInt /*aTxId*/)

   657     {

   658     return 0;

   659     }

   660 

   661 

   662 TInt UT_DevStaPlg2::Commit(TInt /*aTxId*/)

   663     {

   664     return 0;

   665     }

   666 

   667 

   668 TInt UT_DevStaPlg2::CancelTransaction(TInt /*aTxId*/)

   669     {

   670     return 0;

   671     }

   672     

   673 

   674 TBool UT_DevStaPlg2::CanPublish(CHsContentPublisher& /*aPlugin*/, TInt /*aContent*/, TInt /*aIndex*/ )

   675     {

   676     return EFalse;

   677     }

   678 

   679     void UT_DevStaPlg2::TryToPublishL( MAiPublisherBroadcaster& /*aBroadcaster*/, 

   680                                 TInt aContent, 

   681                                 TInt aResource, 

   682                                 TInt aPriority )

   683         {

   684         Publish( *((CHsContentPublisher*)(0x0)),

   685                  aContent, 

   686                  aResource, 

   687                  aPriority );

   688         }

   689     void UT_DevStaPlg2::TryToPublishL( MAiPublisherBroadcaster& /*aBroadcaster*/, 

   690                                 TInt aContent, 

   691                                 const TDesC16& aText, 

   692                                 TInt aPriority )

   693         {

   694         Publish( *((CHsContentPublisher*)(0x0)),

   695                  aContent, 

   696                  aText, 

   697                  aPriority );

   698         }

   699     void UT_DevStaPlg2::TryToPublishL( MAiPublisherBroadcaster& /*aBroadcaster*/, 

   700                                 TInt aContent, 

   701                                 const TDesC8& aBuf, 

   702                                 TInt aPriority )

   703         {

   704         Publish( *((CHsContentPublisher*)(0x0)),

   705                  aContent, 

   706                  aBuf, 

   707                  aPriority );

   708         }

   709     void UT_DevStaPlg2::TryToCleanL( MAiPublisherBroadcaster& /*aBroadcaster*/, 

   710                                 TInt aContent, 

   711                                 TInt aPriority )

   712         {

   713         Clean( *((CHsContentPublisher*)(0x0)),

   714                  aContent, 

   715                  aPriority );

   716         }

   717 

   718 TInt UT_DevStaPlg2::Publish(CHsContentPublisher& /*aPlugin*/, TInt aContent, TInt aResource, TInt aIndex )

   719     {

   720     RDebug::Print( _L("Publish(%d, %d, %d)"), aContent, aResource, aIndex );

   721     CContentCache* cache = new( ELeave )CContentCache;

   722     CleanupStack::PushL( cache );

   723     cache->iId = aContent;

   724     cache->iResource = aResource;

   725     cache->iIndex = aIndex;

   726     User::LeaveIfError( iInternalCache.Append( cache ) );

   727     CleanupStack::Pop( cache );

   728     return 0;

   729     }

   730 

   731 TInt UT_DevStaPlg2::Publish(CHsContentPublisher& /*aPlugin*/, TInt aContent, const TDesC16& aText, TInt aIndex )

   732     {

   733     RDebug::Print( _L("Publish(%d, \"%S\", %d)"), aContent, &aText, aIndex );

   734     CContentCache* cache = new( ELeave )CContentCache;

   735     CleanupStack::PushL( cache );

   736     cache->iId = aContent;

   737     cache->iText = aText.AllocL();

   738     cache->iIndex = aIndex;

   739     User::LeaveIfError( iInternalCache.Append( cache ) );

   740     CleanupStack::Pop( cache );

   741     return 0;

   742     }

   743 

   744 

   745 TInt UT_DevStaPlg2::Publish(CHsContentPublisher& /*aPlugin*/, TInt aContent, const TDesC8& aBuf, TInt aIndex )

   746     {

   747     iBufPublished = ETrue;

   748     RDebug::Print( _L("Publish(%d, Buf.Len=%d, %d)"), aContent, aBuf.Length(), aIndex );

   749     CContentCache* cache = new( ELeave )CContentCache;

   750     CleanupStack::PushL( cache );

   751     cache->iId = aContent;

   752     cache->iData = aBuf.AllocL();

   753     cache->iIndex = aIndex;

   754     User::LeaveIfError( iInternalCache.Append( cache ) );

   755     CleanupStack::Pop( cache );

   756     return 0;

   757     }

   758 

   759 

   760 TInt UT_DevStaPlg2::Publish(CHsContentPublisher& /*aPlugin*/, TInt aContent, RFile& /*aFile*/, TInt aIndex )

   761     {

   762     iFilePublished = ETrue;

   763     CContentCache* cache = new( ELeave )CContentCache;

   764     CleanupStack::PushL( cache );

   765     cache->iId = aContent;

   766     cache->iIndex = aIndex;

   767     User::LeaveIfError( iInternalCache.Append( cache ) );

   768     CleanupStack::Pop( cache );

   769     return 0;

   770     }

   771 

   772 

   773 TInt UT_DevStaPlg2::Clean(CHsContentPublisher& /*aPlugin*/, TInt aContent, TInt aIndex)

   774     {

   775     RDebug::Print( _L("Clean(%d, %d)"), aContent, aIndex );

   776     CContentCache* cache = new( ELeave )CContentCache;

   777     CleanupStack::PushL( cache );

   778     cache->iId = aContent;

   779     cache->iIndex = aIndex;

   780     cache->iClean = ETrue;

   781     User::LeaveIfError( iInternalCache.Append( cache ) );

   782     CleanupStack::Pop( cache );

   783     return 0;

   784     }

   785     

   786 // ---------------------------------------------------------------------------

   787 // SetProperty

   788 // ---------------------------------------------------------------------------

   789 //

   790 TInt UT_DevStaPlg2::SetProperty( CHsContentPublisher& /*aPlugin*/,

   791 									          const TDesC8& /*aElementId*/,

   792 									          const TDesC8& /*aPropertyName*/,

   793 									          const TDesC8& /*aPropertyValue*/ )

   794 {

   795 	return KErrNone;

   796 }				

   797 

   798 // ---------------------------------------------------------------------------

   799 // SetProperty

   800 // ---------------------------------------------------------------------------

   801 //

   802 TInt UT_DevStaPlg2::SetProperty( CHsContentPublisher& /*aPlugin*/,

   803 									          const TDesC8& /*aElementId*/,

   804 									          const TDesC8& /*aPropertyName*/,

   805 									          const TDesC8& /*aPropertyValue*/,

   806 									          MAiContentObserver::TValueType /*aValueType*/ )

   807 {

   808 	return KErrNone;

   809 }				    

   810 

   811 

   812 TAny* UT_DevStaPlg2::Extension(TUid /*aUid*/)

   813     {

   814     return NULL;

   815     }

   816 

   817 TBool UT_DevStaPlg2::RequiresSubscription( const THsPublisherInfo& aPublisherInfo ) const

   818     {

   819     return EFalse;

   820     }

   821 

   822 

   823 //  END OF FILE

   824 

   825          

   826 //  TEST TABLE

   827 

   828 EUNIT_BEGIN_TEST_TABLE(

   829     UT_DevStaPlg2,

   830     "Device Status Plugin test cases",

   831     "MODULE" )

   832 

   833 EUNIT_TEST(

   834     "Test op logo publish",

   835     "Add tested class name here",

   836     "Add tested function name here",

   837     "FUNCTIONALITY",

   838     SetupL, TestOperatorLogoPublisherL, Teardown)

   839 

   840 EUNIT_TEST(

   841     "Test op name publish",

   842     "Add tested class name here",

   843     "Add tested function name here",

   844     "FUNCTIONALITY",

   845     SetupL, TestOperatorProgNamePublisherL, Teardown)

   846 

   847 EUNIT_TEST(

   848     "Test multiobserver",

   849     "Add tested class name here",

   850     "Add tested function name here",

   851     "FUNCTIONALITY",

   852     SetupL, TestMultiObserverL, Teardown)

   853 

   854 EUNIT_TEST(

   855     "Test BTSAP",

   856     "Add tested class name here",

   857     "Add tested function name here",

   858     "FUNCTIONALITY",

   859     SetupL, TestBTSAPPublisherL, Teardown)

   860   

   861 EUNIT_TEST(

   862     "Test date publisher",

   863     "Add tested class name here",

   864     "Add tested function name here",

   865     "FUNCTIONALITY",

   866     SetupL, TestDatePublisherL, Teardown)

   867 

   868 EUNIT_TEST(

   869     "Test date plugin",

   870     "Add tested class name here",

   871     "Add tested function name here",

   872     "FUNCTIONALITY",

   873     SetupL, TestPluginL, Teardown)

   874 

   875 EUNIT_END_TEST_TABLE

   876 

   877 //  END OF FILE