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 #include "MT_DevStaPlg.h"

    21 #include "hscontentpublisher.h"

    22 #include "aidevicestatuscontentmodel.h"

    23 #include "caouserafter.h"

    24 #include "logotools.h"

    25 #include "testingtools.h"

    26 #include "contentobserver.h"

    27 #include "ainativeuiplugins.h"

    28 #include "aidevicestatusplugin.h"

    29 #include <aicontentrequest.h>

    30 #include <aidevstaplgres.rsg>

    31 

    32 //  EXTERNAL INCLUDES

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

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

    35 #include <profile.hrh>

    36 #include <mprofilechangeobserver.h>

    37 #include <e32cmn.h>

    38 #include <gulicon.h>

    39 

    40 //  INTERNAL INCLUDES

    41 

    42 const TInt KCountryCode = 244;

    43 const TInt KNetworkId = 91;

    44 

    45 // CONSTRUCTION

    46 MT_DevStaPlg* MT_DevStaPlg::NewL()

    47     {

    48     MT_DevStaPlg* self = MT_DevStaPlg::NewLC();

    49     CleanupStack::Pop();

    50 

    51     return self;

    52     }

    53 

    54 MT_DevStaPlg* MT_DevStaPlg::NewLC()

    55     {

    56     MT_DevStaPlg* self = new( ELeave ) MT_DevStaPlg();

    57     CleanupStack::PushL( self );

    58 

    59     self->ConstructL();

    60 

    61     return self;

    62     }

    63 

    64 // Destructor (virtual by CBase)

    65 MT_DevStaPlg::~MT_DevStaPlg()

    66     {

    67 	//iLibrary.Close();

    68     }

    69 

    70 // Default constructor

    71 MT_DevStaPlg::MT_DevStaPlg()

    72     {

    73     }

    74 

    75 // Second phase construct

    76 void MT_DevStaPlg::ConstructL()

    77     {

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

    79     // It generates the test case table.

    80     CEUnitTestSuiteClass::ConstructL();

    81 

    82     //User::LeaveIfError( iLibrary.Load( _L("AiDevStaPlg.dll") ) );

    83 

    84     //create test cases;

    85 

    86     }

    87 

    88 

    89 void MT_DevStaPlg::SetupL(  )

    90     {

    91 //    __UHEAP_MARK;

    92     CStubDataHolder::InstanceL();

    93     iCache = &CContentObserver::InstanceL();

    94 

    95     TUid uid = { AI_UID_ECOM_IMPLEMENTATION_CONTENTPUBLISHER_DEVSTAPLUGIN };

    96     

    97     _LIT8( KNameSpace, "1" );

    98     

    99     THsPublisherInfo pubInfo( uid, KDeviceStatusPluginName, KNameSpace );

   100     

   101     iPublisher = CHsContentPublisher::NewL( pubInfo );

   102     

   103     RAiSettingsItemArray settings;

   104     iPublisher->ConfigureL( settings );

   105     iPublisher->SubscribeL( *iCache );

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

   107     }

   108 

   109 void MT_DevStaPlg::SetupEmptyL()

   110     {

   111 //    __UHEAP_MARK;

   112     }

   113 

   114 

   115 

   116 

   117 void MT_DevStaPlg::Teardown(  )

   118     {

   119     if( iPublisher )

   120         {

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

   122         delete iPublisher;

   123         iPublisher = NULL;        

   124         }

   125         

   126     /*if( iUtils )

   127     	{

   128     	delete iUtils;

   129     	iUtils =NULL;

   130     	}*/

   131         

   132     if( iCache )

   133         {

   134         iCache->Reset();

   135         iCache->Release();

   136         iCache = NULL;        

   137         }

   138 

   139     CStubDataHolder::Release();

   140     //delete iTestObserver;

   141     //REComSession::FinalClose();

   142 	#if _BullseyeCoverage

   143 	    cov_write();

   144     #endif

   145     }

   146 

   147 void MT_DevStaPlg::TestPropertyL()

   148     { 

   149    	EUNIT_ASSERT( iPublisher );

   150 

   151     TAny* result = iPublisher->GetProperty( CHsContentPublisher::EPublisherContent );

   152     EUNIT_ASSERT( result );

   153     

   154     MAiContentItemIterator* iter = static_cast<MAiContentItemIterator*>( result );

   155     EUNIT_ASSERT( iter );

   156     }

   157 

   158 void MT_DevStaPlg::TestOperatorLogoPublisherL()

   159     {

   160     RFbsSession::Connect();

   161     

   162     // StoreOTALogoL( KCountryCode, KNetworkId );

   163     

   164     //only OTA logo

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

   166 

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

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

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

   170     nwInfo->iStatus = ENWStatusCurrent;

   171     nwInfo->iRegistrationStatus = ENWRegisteredRoaming;

   172     //TNWInfo nwInfo;

   173     

   174     // CStubDataHolder::Instance()->SetNWMessageObserver(*iTestObserver, nwInfo);

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

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

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

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

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

   180     

   181     //wait for publish

   182     CAOUserAfter::AfterLD( 2 * 1000000 );

   183 

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

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

   186 

   187     // EUNIT_ASSERT(cache);

   188 

   189     /*

   190     TPckgBuf<CGulIcon*> logoBuf;

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

   192     

   193     //EUNIT_ASSERT( cache.iId );

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

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

   196     */

   197     

   198     RFbsSession::Disconnect();

   199     }

   200 

   201 

   202 void MT_DevStaPlg::TestOperatorProgNamePublisherL()

   203     {

   204     _LIT( KOperatorName, "ProgName" );

   205 

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

   207 

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

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

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

   211     nwInfo->iStatus = ENWStatusCurrent;

   212     nwInfo->iRegistrationStatus = ENWRegisteredRoaming;

   213     //TNWInfo nwInfo;

   214     //CStubDataHolder::Instance()->SetNWMessageObserver(*iTestObserver, nwInfo);

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

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

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

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

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

   220 

   221     //wait for publish

   222     CAOUserAfter::AfterLD( 2 * 1000000 );

   223 

   224                                                  

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

   226     //CContentCache* cache = iCache->GetContent( MNWMessageObserver::ENWMessageProgrammableOperatorInfoChange );

   227 

   228     EUNIT_ASSERT(cache);

   229 

   230     EUNIT_ASSERT( *cache->iText == KOperatorName );

   231     }

   232 

   233 

   234 void MT_DevStaPlg::TestOperatorNetinfoNamePublisher_LongL()

   235     {

   236     // BUG IN THE CODE, WILL NOT WORK UNTIL IT'S FIXED

   237     _LIT( KOperatorNameLong, "OPERATOR II" );

   238     _LIT( KOperatorName, "KEKS" );

   239 

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

   241 

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

   243     nwInfo->iLongName.Copy( KOperatorName );

   244     nwInfo->iStatus = ENWStatusCurrent;

   245     nwInfo->iRegistrationStatus = ENWRegisteredRoaming;

   246     //nwInfo->iOperatorNameInfo.iName=KOperatorNameLong;

   247 

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

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

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

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

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

   253 

   254     //wait for publish

   255     CAOUserAfter::AfterLD( 2 * 1000000 );

   256 

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

   258 

   259     EUNIT_ASSERT(cache);

   260 

   261     EUNIT_ASSERT( *cache->iText == KOperatorNameLong );

   262     }

   263 

   264 void MT_DevStaPlg::TestOperatorNetinfoNamePublisher_ShortL()

   265     {

   266     // BUG IN THE CODE, WILL NOT WORK UNTIL IT'S FIXED

   267     _LIT( KOperatorNameShort, "OPERATOR" );

   268 

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

   270 

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

   272     nwInfo->iShortName.Copy( KOperatorNameShort );

   273     nwInfo->iStatus = ENWStatusCurrent;

   274     nwInfo->iRegistrationStatus = ENWRegisteredRoaming;

   275     

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

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

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

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

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

   281     

   282     //wait for publish

   283     CAOUserAfter::AfterLD( 2 * 1000000 );

   284 

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

   286 

   287     EUNIT_ASSERT(cache);

   288     

   289     EUNIT_ASSERT( *cache->iText == KOperatorNameShort );

   290     }

   291 

   292 void MT_DevStaPlg::TestOperatorNetinfoNamePublisher_TagL()

   293     {

   294     // BUG IN THE CODE, WILL NOT WORK UNTIL IT'S FIXED

   295     _LIT( KOperatorNameTag, "OP2" );

   296 

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

   298 

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

   300     nwInfo->iDisplayTag.Copy( KOperatorNameTag );

   301     nwInfo->iStatus = ENWStatusCurrent;

   302     nwInfo->iRegistrationStatus = ENWRegisteredRoaming;

   303 

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

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

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

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

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

   309 

   310     //wait for publish

   311     CAOUserAfter::AfterLD( 2 * 1000000 );

   312 

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

   314 

   315     EUNIT_ASSERT(cache);

   316 

   317     EUNIT_ASSERT( *cache->iText == KOperatorNameTag );

   318     }

   319     

   320     

   321 void MT_DevStaPlg::TestOperatorProviderNamePublisher_InSPDINoPLMNL()

   322     {    

   323     _LIT( KOperatorProviderName, "Provider" );

   324 

   325     // Delete logo, so it will not be published.

   326     // DeleteOTALogoL(KCountryCode, KNetworkId);

   327     

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

   329 

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

   331     nwInfo->iSPName.Copy( KOperatorProviderName );

   332     nwInfo->iServiceProviderNameDisplayReq |= ENWDisplaySPNRequired;

   333 //    nwInfo->iServiceProviderNameDisplayReq |= ENWDisplayPLMNRequired;

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

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

   336     nwInfo->iStatus = ENWStatusCurrent;

   337     nwInfo->iRegistrationStatus = ENWRegisteredOnHomeNetwork;

   338     EncodePLMNField( nwInfo->iPLMNField, ETrue, KCountryCode, KNetworkId );

   339     

   340 

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

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

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

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

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

   346 

   347     //wait for publish

   348     CAOUserAfter::AfterLD( 500000 );

   349 

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

   351     

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

   353 

   354     EUNIT_ASSERT( cache );

   355 

   356     EUNIT_ASSERT( *cache->iText == KOperatorProviderName );

   357     

   358     iPublisher->Suspend( CHsContentPublisher::EBackground );

   359     }

   360     

   361 void MT_DevStaPlg::TestOperatorProviderNamePublisher_InSPDIPLMNL()

   362     {    

   363     _LIT( KOperatorProviderName, "Provider" );

   364 

   365     // Delete logo, so it will not be published.

   366     // DeleteOTALogoL(KCountryCode, KNetworkId);

   367     

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

   369 

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

   371     nwInfo->iSPName.Copy( KOperatorProviderName );

   372     nwInfo->iServiceProviderNameDisplayReq |= ENWDisplaySPNRequired;

   373     nwInfo->iServiceProviderNameDisplayReq |= ENWDisplayPLMNRequired;

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

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

   376     nwInfo->iStatus = ENWStatusCurrent;

   377     nwInfo->iRegistrationStatus = ENWRegisteredOnHomeNetwork;

   378     EncodePLMNField( nwInfo->iPLMNField, ETrue, KCountryCode, KNetworkId );

   379     

   380 

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

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

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

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

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

   386 

   387     //wait for publish

   388     CAOUserAfter::AfterLD( 500000 );

   389 

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

   391 

   392     EUNIT_ASSERT(cache);

   393 

   394     // EUNIT_ASSERT( *cache->iText == KOperatorProviderName );

   395     

   396     iCache->Reset();

   397     

   398     //wait for clean

   399     CAOUserAfter::AfterLD( 3 * 1000000 );

   400 

   401     /*

   402     cache = iCache->GetLastContent( EAiDeviceStatusContentNetworkIdentity, ETrue );

   403     EUNIT_ASSERT( cache->iClean );

   404     */

   405     

   406     iPublisher->Suspend( CHsContentPublisher::EBackground );

   407     }

   408     

   409     

   410     

   411     

   412 void MT_DevStaPlg::TestBTSAPPublisherL()

   413     {    

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

   415     

   416     //fake BTSAP change

   417     

   418     ChangeBTSAPValueL( EBTSapConnected );

   419     

   420     CAOUserAfter::AfterLD( 1000000 );

   421                                

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

   423 

   424     EUNIT_ASSERT( cache );

   425 

   426     EUNIT_ASSERT( cache->iResource == R_ACTIVEIDLE_BT_SIM_ACCESS_PROFILE_STRING );

   427 

   428     iCache->Reset();

   429                                 

   430     DeleteBTSAPKey();

   431                                 

   432     CAOUserAfter::AfterLD( 1000000 );

   433     

   434     cache = iCache->GetContent( EAiDeviceStatusContentNetworkIdentity, ETrue );

   435 

   436     EUNIT_ASSERT( cache );

   437 

   438     iPublisher->Suspend( CHsContentPublisher::EBackground );

   439     }

   440     

   441     

   442 void MT_DevStaPlg::TestSimRegPublisherL()

   443     {

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

   445     

   446     EmulateSimRegFailEvent();

   447     

   448     CAOUserAfter::AfterLD( 1000000 );

   449                                

   450     CContentCache* cache = iCache->GetContent( EAiDeviceStatusContentSIMRegStatus );

   451 

   452     if( !cache )

   453         {

   454         User::Leave( KErrNoMemory );

   455         }

   456 

   457     EUNIT_ASSERT( cache->iResource == EAiDeviceStatusResourceSIMRegFail );

   458     

   459     iCache->Reset();

   460                                 

   461     iPublisher->Suspend( CHsContentPublisher::EBackground );

   462     }

   463     

   464 void MT_DevStaPlg::TestHCZPublisherL()

   465     {    

   466     _LIT( KZoneName, "ZoneName" );

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

   468     

   469     EmulateHCZEvent( KZoneName );

   470     

   471     CAOUserAfter::AfterLD( 1000000 );

   472                                

   473     CContentCache* cache = iCache->GetContent( EAiDeviceStatusContentVHZText );

   474 

   475 

   476     if( !cache )

   477         {

   478         User::Leave( KErrNoMemory );

   479         }

   480 

   481     EUNIT_ASSERT( *cache->iText == KZoneName );

   482     

   483     iCache->Reset();

   484                                 

   485     iPublisher->Suspend( CHsContentPublisher::EBackground );

   486     }

   487     

   488 void MT_DevStaPlg::TestCUGPublisherL()

   489     {    

   490     _LIT( KCUGMessage, "Group 7" );

   491     const TInt KCUGIndex = 7;

   492     

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

   494     

   495     EmulateCUGEvent( KCUGIndex );

   496     

   497     CAOUserAfter::AfterLD( 1000000 );

   498                                

   499     CContentCache* cache = iCache->GetContent( EAiDeviceStatusContentCUGIndicator );

   500 

   501     if( !cache )

   502         {

   503         User::Leave( KErrNoMemory );

   504         }

   505 

   506     EUNIT_ASSERT( *cache->iText == KCUGMessage );

   507     

   508     iCache->Reset();

   509                                 

   510     iPublisher->Suspend( CHsContentPublisher::EBackground );

   511     }

   512     

   513 void MT_DevStaPlg::TestMCNPublisherL()

   514     {

   515     _LIT( KMCNMessage, "MCN" );

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

   517     

   518     EmulateMCNEvent( KMCNMessage );

   519     

   520     CAOUserAfter::AfterLD( 1000000 );

   521                                

   522     CContentCache* cache = iCache->GetContent( EAiDeviceStatusContentMCNIndicator );

   523 

   524     if( !cache )

   525         {

   526         User::Leave( KErrNoMemory );

   527         }

   528 

   529     EUNIT_ASSERT( *cache->iText == KMCNMessage );                               

   530     

   531     iCache->Reset();    

   532     

   533     iPublisher->Suspend( CHsContentPublisher::EBackground );    

   534     }

   535 

   536 /*

   537 void MT_DevStaPlg::TestContentRequest1L()

   538     {    

   539     _LIT( KProfile, "Outdoor" );

   540     

   541     RFbsSession::Connect();

   542     

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

   544     

   545     CStubDataHolder::Instance()->SetCurrentProfileL( KProfile, EProfileGeneralId );

   546 

   547     StoreOTALogoL( KCountryCode, KNetworkId );

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

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

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

   551 	

   552     TAny* ptr = iPublisher->GetProperty( CHsContentPublisher::EContentRequest );

   553     MAiContentRequest* request = static_cast<MAiContentRequest*>( ptr );

   554     request->RefreshContent( EAiDeviceStatusContentNetworkIdentity );

   555     

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

   557     

   558     if( !cache )

   559         {

   560         User::Leave( KErrNoMemory );

   561         }    

   562 		/*

   563     MAiPropertyExtension* ext = static_cast<MAiPropertyExtension*>( iPublisher->Extension( KExtensionUidProperty ) ); 

   564     MAiContentRequest* request = static_cast<MAiContentRequest*>( ext->GetPropertyL( EAiContentRequest ) );

   565     

   566     request->RefreshContent( EAiDeviceStatusContentNetworkIdentity );

   567 

   568 		

   569     iCache->Reset();

   570     RFbsSession::Disconnect();

   571     }

   572 */

   573 

   574 void MT_DevStaPlg::TestContentRequest2L()

   575     {

   576     _LIT( KOperatorProviderName, "Provider" );

   577 

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

   579 

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

   581     nwInfo->iSPName.Copy( KOperatorProviderName );

   582     nwInfo->iServiceProviderNameDisplayReq |= ENWDisplaySPNRequired;

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

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

   585     nwInfo->iStatus = ENWStatusCurrent;

   586     nwInfo->iRegistrationStatus = ENWRegisteredOnHomeNetwork;

   587     EncodePLMNField( nwInfo->iPLMNField, ETrue, KCountryCode, KNetworkId );

   588     

   589     TAny* ptr = iPublisher->GetProperty( CHsContentPublisher::EContentRequest );

   590     MAiContentRequest* request = static_cast<MAiContentRequest*>( ptr );

   591     request->RefreshContent( EAiDeviceStatusContentNetworkIdentity );

   592     

   593     /*

   594     MAiPropertyExtension* ext = static_cast<MAiPropertyExtension*>( iPublisher->Extension( KExtensionUidProperty ) ); 

   595     MAiContentRequest* request = static_cast<MAiContentRequest*>( ext->GetPropertyL( EAiContentRequest ) );

   596     

   597     request->RefreshContent( EAiDeviceStatusContentNetworkIdentity );

   598         */

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

   600 

   601     if( !cache )

   602         {

   603         User::Leave( KErrNoMemory );

   604         }

   605 

   606     iCache->Reset();

   607     }

   608          

   609 

   610 void MT_DevStaPlg::TestContentRequest3L()

   611     {

   612     _LIT( KOperatorName, "ProgName" );

   613 

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

   615 

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

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

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

   619     nwInfo->iStatus = ENWStatusCurrent;

   620     nwInfo->iRegistrationStatus = ENWRegisteredOnHomeNetwork;

   621     

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

   623 

   624     // shouldn't have content...

   625     // EUNIT_ASSERT( !cache );

   626 

   627     // ...until now:

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

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

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

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

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

   633     

   634     TAny* ptr = iPublisher->GetProperty( CHsContentPublisher::EContentRequest );

   635     MAiContentRequest* request = static_cast<MAiContentRequest*>( ptr );

   636     request->RefreshContent( EAiDeviceStatusContentNetworkIdentity );    

   637     

   638     // request->RefreshContent( EAiDeviceStatusContentNetworkIdentity );

   639     cache = iCache->GetContent( EAiDeviceStatusContentNetworkIdentity );

   640     

   641     EUNIT_ASSERT( cache );

   642 

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

   644     iCache->Reset();

   645     }

   646          

   647 /*

   648 void MT_DevStaPlg::TestContentRequest4L()

   649     {

   650     _LIT( KOperatorNameTag, "NetInfo" );

   651     _LIT( KProfGeneral, "General" );

   652 

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

   654 

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

   656     nwInfo->iDisplayTag.Copy( KOperatorNameTag );

   657     

   658     CStubDataHolder::Instance()->SetCurrentProfileL( KProfGeneral, EProfileGeneralId );

   659         

   660     /*

   661     MAiPropertyExtension* ext = static_cast<MAiPropertyExtension*>( iPublisher->Extension( KExtensionUidProperty ) ); 

   662     MAiContentRequest* request = static_cast<MAiContentRequest*>( ext->GetPropertyL( EAiContentRequest ) );

   663     

   664     request->RefreshContent( EAiDeviceStatusContentNetworkIdentity );

   665     

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

   667 

   668     EUNIT_ASSERT( cache );

   669 

   670     iCache->Reset();

   671     }

   672          */

   673 

   674 void MT_DevStaPlg::TestContentRequest5L()

   675     {    

   676     _LIT( KOperatorName, "ProgName" );

   677 

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

   679 

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

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

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

   683     

   684     TAny* ptr = iPublisher->GetProperty( CHsContentPublisher::EContentRequest );

   685     MAiContentRequest* request = static_cast<MAiContentRequest*>( ptr );

   686     request->RefreshContent( EAiDeviceStatusContentNetworkIdentity );    

   687     /*

   688     MAiPropertyExtension* ext = static_cast<MAiPropertyExtension*>( iPublisher->Extension( KExtensionUidProperty ) ); 

   689     MAiContentRequest* request = static_cast<MAiContentRequest*>( ext->GetPropertyL( EAiContentRequest ) );

   690     

   691     request->RefreshContent( EAiDeviceStatusContentNetworkIdentity );

   692     */

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

   694 

   695     // shouldn't have content...

   696     // EUNIT_ASSERT( !cache );

   697 

   698     // ...until now:

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

   700     request->RefreshContent( EAiDeviceStatusContentNetworkIdentity );

   701 

   702     cache = iCache->GetContent( EAiDeviceStatusContentNetworkIdentity );

   703 

   704     if( !cache )

   705         {

   706         User::Leave( KErrNoMemory );

   707         }

   708 

   709     iCache->Reset();

   710     }

   711          

   712 

   713 void MT_DevStaPlg::TestContentRequest6L()

   714     {

   715     _LIT( KProfile, "Outdoor" );

   716 

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

   718 

   719     CStubDataHolder::Instance()->SetCurrentProfileL( KProfile, EProfileOutdoorId );

   720         

   721     /*

   722     MAiPropertyExtension* ext = static_cast<MAiPropertyExtension*>( iPublisher->Extension( KExtensionUidProperty ) ); 

   723     MAiContentRequest* request = static_cast<MAiContentRequest*>( ext->GetPropertyL( EAiContentRequest ) );

   724     

   725     request->RefreshContent( EAiDeviceStatusContentProfileName );

   726     */

   727     CContentCache* cache = iCache->GetLastContent( EAiDeviceStatusContentProfileName );

   728 

   729     if( !cache )

   730         {

   731         User::Leave( KErrNoMemory );

   732         }

   733 

   734     iCache->Reset();

   735     }

   736          

   737 

   738 void MT_DevStaPlg::TestContentRequest7L()

   739     {    

   740     _LIT( KProfile, "General" );

   741 

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

   743 

   744     CStubDataHolder::Instance()->SetCurrentProfileL( KProfile, EProfileGeneralId );

   745 

   746 		/*

   747     MAiPropertyExtension* ext = static_cast<MAiPropertyExtension*>( iPublisher->Extension( KExtensionUidProperty ) ); 

   748     MAiContentRequest* request = static_cast<MAiContentRequest*>( ext->GetPropertyL( EAiContentRequest ) );

   749     

   750     request->RefreshContent( EAiDeviceStatusContentGeneralProfileName );

   751     */

   752     CContentCache* cache = iCache->GetLastContent( EAiDeviceStatusContentGeneralProfileName );

   753 

   754     if( !cache )

   755         {

   756         User::Leave( KErrNoMemory );

   757         }

   758 

   759     iCache->Reset();

   760     }

   761          

   762 

   763 void MT_DevStaPlg::TestContentRequest8L()

   764     {

   765     _LIT( KProfile, "Offline" );

   766 

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

   768 

   769     CStubDataHolder::Instance()->SetCurrentProfileL( KProfile, EProfileOffLineId );

   770         

   771     /*

   772     MAiPropertyExtension* ext = static_cast<MAiPropertyExtension*>( iPublisher->Extension( KExtensionUidProperty ) ); 

   773     MAiContentRequest* request = static_cast<MAiContentRequest*>( ext->GetPropertyL( EAiContentRequest ) );

   774     

   775     request->RefreshContent( EAiDeviceStatusContentNetworkIdentity );

   776     */

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

   778 

   779     if( !cache )

   780         {

   781         User::Leave( KErrNoMemory );

   782         }

   783 

   784     iCache->Reset();

   785     }

   786          

   787 

   788 void MT_DevStaPlg::TestContentRequest9L()

   789     {    

   790     TAny* ptr = iPublisher->GetProperty( CHsContentPublisher::EContentRequest );

   791     MAiContentRequest* request = static_cast<MAiContentRequest*>( ptr );    

   792     /*

   793     MAiPropertyExtension* ext = static_cast<MAiPropertyExtension*>( iPublisher->Extension( KExtensionUidProperty ) ); 

   794     MAiContentRequest* request = static_cast<MAiContentRequest*>( ext->GetPropertyL( EAiContentRequest ) );

   795     */

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

   797 

   798     request->RefreshContent( EAiDeviceStatusContentDate ); 

   799     // request->RefreshContent( EAiDeviceStatusContentDate );

   800     CContentCache* cache = iCache->GetLastContent( EAiDeviceStatusContentDate );

   801 

   802     if( !cache )

   803         {

   804         User::Leave( KErrNoMemory );

   805         }

   806 

   807     iCache->Reset();

   808     }

   809          

   810 

   811 void MT_DevStaPlg::TestContentRequest10L()

   812     {

   813     _LIT( KProfile, "Silent" );

   814 

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

   816 

   817     CStubDataHolder::Instance()->SetCurrentProfileL( KProfile, EProfileSilentId );

   818     

   819     /*

   820     MAiPropertyExtension* ext = static_cast<MAiPropertyExtension*>( iPublisher->Extension( KExtensionUidProperty ) ); 

   821     MAiContentRequest* request = static_cast<MAiContentRequest*>( ext->GetPropertyL( EAiContentRequest ) );

   822     */

   823     

   824     // EAiDeviceStatusContentProfileName and EAiDeviceStatusContentSilentIndicator

   825     // are published in same class

   826     // request->RefreshContent( EAiDeviceStatusContentProfileName );

   827     CContentCache* cache = iCache->GetContent( EAiDeviceStatusContentSilentIndicator );

   828 

   829     if( !cache )

   830         {

   831         User::Leave( KErrNoMemory );

   832         }

   833 

   834     iCache->Reset();

   835     }

   836          

   837 

   838 void MT_DevStaPlg::TestContentRequest13L()

   839     {    

   840     _LIT( KZoneName, "ZoneName" );

   841 

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

   843 

   844     EmulateHCZEvent( KZoneName );

   845     

   846     TAny* ptr = iPublisher->GetProperty( CHsContentPublisher::EContentRequest );

   847     MAiContentRequest* request = static_cast<MAiContentRequest*>( ptr );    

   848     request->RefreshContent( EAiDeviceStatusContentVHZIndicator );     

   849     

   850     CContentCache* cache = iCache->GetContent( EAiDeviceStatusContentVHZText );

   851 

   852     if( !cache )

   853         {

   854         User::Leave( KErrNoMemory );

   855         }

   856 

   857     iCache->Reset();

   858     }

   859          

   860 

   861 void MT_DevStaPlg::TestContentRequest14L()

   862     {    

   863     _LIT( KCUGMessage, "Group 7" );

   864     const TInt KCUGIndex = 7;

   865 

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

   867 

   868     EmulateCUGEvent( KCUGIndex );

   869     

   870     /*

   871     MAiPropertyExtension* ext = static_cast<MAiPropertyExtension*>( iPublisher->Extension( KExtensionUidProperty ) ); 

   872     MAiContentRequest* request = static_cast<MAiContentRequest*>( ext->GetPropertyL( EAiContentRequest ) );

   873     

   874     request->RefreshContent( EAiDeviceStatusContentCUGIndicator );

   875     */

   876     TAny* ptr = iPublisher->GetProperty( CHsContentPublisher::EContentRequest );

   877     MAiContentRequest* request = static_cast<MAiContentRequest*>( ptr );    

   878     request->RefreshContent( EAiDeviceStatusContentCUGIndicator );

   879     

   880     CContentCache* cache = iCache->GetLastContent( EAiDeviceStatusContentCUGIndicator );

   881 

   882     if( !cache )

   883         {

   884         User::Leave( KErrNoMemory );

   885         }

   886 

   887     EUNIT_ASSERT( *cache->iText == KCUGMessage );

   888 

   889     iCache->Reset();

   890     }

   891          

   892 

   893 void MT_DevStaPlg::TestContentRequest15L()

   894     {    

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

   896 

   897     ChangeBTSAPValueL( EBTSapConnected );

   898     

   899     /*

   900     MAiPropertyExtension* ext = static_cast<MAiPropertyExtension*>( iPublisher->Extension( KExtensionUidProperty ) ); 

   901     MAiContentRequest* request = static_cast<MAiContentRequest*>( ext->GetPropertyL( EAiContentRequest ) );

   902     

   903     request->RefreshContent( EAiDeviceStatusContentNetworkIdentity );

   904     */

   905     TAny* ptr = iPublisher->GetProperty( CHsContentPublisher::EContentRequest );

   906     MAiContentRequest* request = static_cast<MAiContentRequest*>( ptr );    

   907     request->RefreshContent( EAiDeviceStatusContentNetworkIdentity );

   908     

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

   910 

   911     if( !cache )

   912         {

   913         User::Leave( KErrNoMemory );

   914         }

   915 

   916     iCache->Reset();

   917     DeleteBTSAPKey();

   918     }

   919          

   920          

   921 //  TEST TABLE

   922 

   923 EUNIT_BEGIN_TEST_TABLE(

   924     MT_DevStaPlg,

   925     "Device Status Plugin test cases",

   926     "MODULE" )

   927 

   928 /*

   929 EUNIT_TEST(

   930     "Test initializing",

   931     "Add tested class name here",

   932     "Add tested function name here",

   933     "FUNCTIONALITY",

   934     SetupEmptyL, TestL, Teardown)

   935 */

   936     

   937 EUNIT_TEST(

   938     "Operator log publisher",

   939     "Add tested class name here",

   940     "Add tested function name here",

   941     "FUNCTIONALITY",

   942     SetupL, TestOperatorLogoPublisherL, Teardown)    

   943 

   944 EUNIT_TEST(

   945     "Test plugin property",

   946     "Add tested class name here",

   947     "Add tested function name here",

   948     "FUNCTIONALITY",

   949     SetupL, TestPropertyL, Teardown)

   950 

   951 /*

   952 EUNIT_TEST(

   953     "Publisher - silent & offline",

   954     "Add tested class name here",

   955     "Add tested function name here",

   956     "FUNCTIONALITY",

   957     SetupL, TestProfilePublisher2L, Teardown)

   958 */

   959     

   960 EUNIT_TEST(

   961     "Test SimReg publisher",

   962     "Add tested class name here",

   963     "Add tested function name here",

   964     "FUNCTIONALITY",

   965     SetupL, TestSimRegPublisherL, Teardown)

   966 

   967 EUNIT_TEST(

   968     "Test HCZ publisher",

   969     "Add tested class name here",

   970     "Add tested function name here",

   971     "FUNCTIONALITY",

   972     SetupL, TestHCZPublisherL, Teardown)

   973 

   974 EUNIT_TEST(

   975     "Test CUG publisher",

   976     "Add tested class name here",

   977     "Add tested function name here",

   978     "FUNCTIONALITY",

   979     SetupL, TestCUGPublisherL, Teardown)

   980 

   981 EUNIT_TEST(

   982     "Test MCN publisher",

   983     "Add tested class name here",

   984     "Add tested function name here",

   985     "FUNCTIONALITY",

   986     SetupL, TestMCNPublisherL, Teardown)

   987        

   988 EUNIT_TEST(

   989     "Cont. Request 2",

   990     "Add tested class name here",

   991     "Add tested function name here",

   992     "FUNCTIONALITY",

   993     SetupL, TestContentRequest2L, Teardown)

   994     

   995 EUNIT_TEST(

   996     "Cont. Request 3",

   997     "Add tested class name here",

   998     "Add tested function name here",

   999     "FUNCTIONALITY",

  1000     SetupL, TestContentRequest3L, Teardown)   

  1001     

  1002 EUNIT_TEST(

  1003     "Cont. Request 5",

  1004     "Add tested class name here",

  1005     "Add tested function name here",

  1006     "FUNCTIONALITY",

  1007     SetupL, TestContentRequest5L, Teardown)  

  1008     

  1009 EUNIT_TEST(

  1010     "Cont. Request 9",

  1011     "Add tested class name here",

  1012     "Add tested function name here",

  1013     "FUNCTIONALITY",

  1014     SetupL, TestContentRequest9L, Teardown)   

  1015 

  1016 EUNIT_TEST(

  1017     "Cont. Request 13",

  1018     "Add tested class name here",

  1019     "Add tested function name here",

  1020     "FUNCTIONALITY",

  1021     SetupL, TestContentRequest13L, Teardown) 

  1022     

  1023 EUNIT_TEST(

  1024     "Cont. Request 14",

  1025     "Add tested class name here",

  1026     "Add tested function name here",

  1027     "FUNCTIONALITY",

  1028     SetupL, TestContentRequest14L, Teardown) 

  1029     

  1030 EUNIT_TEST(

  1031     "Cont. Request 15",

  1032     "Add tested class name here",

  1033     "Add tested function name here",

  1034     "FUNCTIONALITY",

  1035     SetupL, TestContentRequest15L, Teardown)     

  1036 

  1037 EUNIT_TEST(

  1038     "SPDI show PLMN",

  1039     "Add tested class name here",

  1040     "Add tested function name here",

  1041     "FUNCTIONALITY",

  1042     SetupL, TestOperatorProviderNamePublisher_InSPDIPLMNL, Teardown)    

  1043 

  1044 EUNIT_END_TEST_TABLE

  1045 

  1046 //  END OF FILE