1 /*

     2 * Copyright (c) 2008 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:  EUnit module test class for CPS Wrapper

    15 *

    16 */

    17 

    18 // System include files

    19 #include <hsccapiclient.h>

    20 #include <hscontentcontrol.h>

    21 #include <hscontentinfo.h>

    22 #include <hscontentinfoarray.h>

    23 #include <ccresource.h>

    24 

    25 // User include files

    26 #include "mthsccapiclient.h"

    27 

    28 // Local constants

    29 _LIT8( KInfoTypeWidget, "widget" );

    30 _LIT8( KInfoTypeTemplate, "template" );

    31 _LIT8( KInfoTypeView, "view" );

    32 _LIT8( KInfoTypeApp, "application" );

    33 _LIT8( KTemplateViewUid, "0x20026f50" );

    34 _LIT8( KHsViewUid, "0x2001f48b" );

    35 _LIT8( KDesktopWidgetUid, "0x20026f4f" );

    36 _LIT8( KNotFoundAppUid, "0xffffffff" );

    37 _LIT8( KNotFoundViewUid, "0xffffffff" );

    38 _LIT8( KNotFoundWidgetUid, "0xffffffff" );

    39 _LIT8( KNotFoundViewPluginId, "999" );

    40 

    41 // ======== MEMBER FUNCTIONS ========

    42 

    43 // -----------------------------------------------------------------------

    44 // CMTHsCcApiClient::NewL()

    45 // -----------------------------------------------------------------------

    46 //

    47 CMTHsCcApiClient* CMTHsCcApiClient::NewL()

    48     {

    49     CMTHsCcApiClient* self = new ( ELeave ) CMTHsCcApiClient();

    50     CleanupStack::PushL( self );

    51     self->ConstructL();

    52     CleanupStack::Pop( self );

    53     return self;

    54     }

    55 

    56 // -----------------------------------------------------------------------

    57 // CMTHsCcApiClient::ConstructL()

    58 // -----------------------------------------------------------------------

    59 //

    60 void CMTHsCcApiClient::ConstructL()

    61     {

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

    63     // It generates the test case table.

    64     CEUnitTestSuiteClass::ConstructL();

    65     }

    66 

    67 // -----------------------------------------------------------------------

    68 // CMTHsCcApiClient::CMTHsCcApiClient()

    69 // -----------------------------------------------------------------------

    70 //

    71 CMTHsCcApiClient::CMTHsCcApiClient()

    72     :iApiClient( NULL )

    73     {

    74     }

    75 

    76 // -----------------------------------------------------------------------

    77 // CMTHsCcApiClient::~CMTHsCcApiClient()

    78 // -----------------------------------------------------------------------

    79 //

    80 CMTHsCcApiClient::~CMTHsCcApiClient()

    81     {

    82     delete iApiClient;

    83     }

    84 

    85 // -----------------------------------------------------------------------

    86 // CMTHsCcApiClient::SetupL()

    87 // -----------------------------------------------------------------------

    88 //

    89 void CMTHsCcApiClient::SetupL()

    90     {

    91     iWidgetListNtfExpected = EFalse;

    92     iWidgetListNtfReceived = EFalse;

    93     iViewListNtfExpected = EFalse;

    94     iViewListNtfReceived = EFalse;

    95     iAppListNtfExpected = EFalse;

    96     iAppListNtfReceived = EFalse;

    97 

    98     if ( iApiClient )

    99         {

   100         delete iApiClient;

   101         iApiClient = NULL;

   102         }

   103     iApiClient = CHsCcApiClient::NewL( NULL );

   104 

   105     // Remove all removable views from Home screen

   106     CHsContentInfo* app = CHsContentInfo::NewL();

   107     CleanupStack::PushL( app );

   108     iApiClient->ActiveAppL( *app );

   109     

   110     CHsContentInfoArray* views = CHsContentInfoArray::NewL();

   111     CleanupStack::PushL( views );

   112     iApiClient->ViewListL( *app, *views );

   113 

   114     for ( TInt i = 0; i < views->Array().Count(); i++ )

   115         {

   116         CHsContentInfo* info = views->Array()[ i ];

   117         if ( info->CanBeRemoved() )

   118             {

   119             iApiClient->RemoveViewL( *info );

   120             }

   121         }

   122 

   123     CleanupStack::PopAndDestroy( views );

   124 

   125     // Remove all removable widgets from Home screen

   126     CHsContentInfoArray* widgets = CHsContentInfoArray::NewL();

   127     CleanupStack::PushL( widgets );

   128     iApiClient->WidgetListL( *app, *widgets );

   129 

   130     for ( TInt i = 0; i < widgets->Array().Count(); i++ )

   131         {

   132         CHsContentInfo* info = widgets->Array()[ i ];

   133         if ( info->CanBeRemoved() )

   134             {

   135             iApiClient->RemoveWidgetL( *info );

   136             }

   137         }

   138 

   139     CleanupStack::PopAndDestroy( widgets );

   140 

   141     CleanupStack::PopAndDestroy( app );

   142         

   143     delete iApiClient;

   144     iApiClient = NULL;

   145         

   146     }

   147 

   148 // -----------------------------------------------------------------------

   149 // CMTHsCcApiClient::Teardown()

   150 // -----------------------------------------------------------------------

   151 //

   152 void CMTHsCcApiClient::Teardown()

   153     {

   154     }

   155 

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

   157 // CMTHsCcApiClient::NotifyWidgetListChanged()

   158 // -----------------------------------------------------------------------

   159 //

   160 void CMTHsCcApiClient::NotifyWidgetListChanged()

   161     {

   162     if ( iWidgetListNtfExpected )

   163         {

   164         iWidgetListNtfReceived = ETrue;

   165         iWait.AsyncStop();

   166         }

   167     }

   168 

   169 // -----------------------------------------------------------------------

   170 // CMTHsCcApiClient::NotifyViewListChanged()

   171 // -----------------------------------------------------------------------

   172 //

   173 void CMTHsCcApiClient::NotifyViewListChanged()

   174     {

   175     if ( iViewListNtfExpected )

   176         {

   177         iViewListNtfReceived = ETrue;

   178         iWait.AsyncStop();

   179         }

   180     }

   181 

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

   183 // CMTHsCcApiClient::NotifyAppListChanged()

   184 // -----------------------------------------------------------------------

   185 //

   186 void CMTHsCcApiClient::NotifyAppListChanged()

   187     {

   188     if ( iAppListNtfExpected )

   189         {

   190         iAppListNtfReceived = ETrue;

   191         iWait.AsyncStop();

   192         }

   193     }

   194 

   195 // -----------------------------------------------------------------------

   196 // CMTHsCcApiClient::ConnectHsCcApiClientL()

   197 // -----------------------------------------------------------------------

   198 //

   199 void CMTHsCcApiClient::ConnectHsCcApiClientL( MHsContentControl* aObserver )

   200     {

   201     iApiClient = CHsCcApiClient::NewL( aObserver );

   202     }

   203 

   204 // -----------------------------------------------------------------------

   205 // CMTHsCcApiClient::DisconnectHsCcApiClient()

   206 // -----------------------------------------------------------------------

   207 //

   208 void CMTHsCcApiClient::DisconnectHsCcApiClient()

   209     {

   210     delete iApiClient;

   211     iApiClient = NULL;

   212     }

   213 

   214 // -----------------------------------------------------------------------

   215 // CMTHsCcApiClient::AddViewL()

   216 // -----------------------------------------------------------------------

   217 //

   218 CHsContentInfo* CMTHsCcApiClient::AddViewL(

   219     const TDesC8& aUid )

   220     {

   221     CHsContentInfo* info = GetViewL( NULL, aUid );

   222     CleanupStack::PushL( info );

   223 

   224     TInt err = iApiClient->AddViewL( *info );

   225     User::LeaveIfError( err );

   226     CleanupStack::PopAndDestroy( info );

   227     info = NULL;

   228 

   229     CHsContentInfo* app = CHsContentInfo::NewL();

   230     CleanupStack::PushL( app );

   231 

   232     err = iApiClient->ActiveAppL( *app );

   233     User::LeaveIfError( err );

   234 

   235     info = GetViewL( app, aUid );

   236 

   237     CleanupStack::PopAndDestroy( app );

   238 

   239     User::LeaveIfNull( info );

   240     return info;

   241     }

   242 

   243 // -----------------------------------------------------------------------

   244 // CMTHsCcApiClient::AddWidgetL()

   245 // -----------------------------------------------------------------------

   246 //

   247 CHsContentInfo* CMTHsCcApiClient::AddWidgetL(

   248     const TDesC8& aUid )

   249     {

   250 

   251     CHsContentInfo* info = GetWidgetL( NULL, aUid );

   252     CleanupStack::PushL( info );

   253 

   254     TInt err = iApiClient->AddWidgetL( *info );

   255     User::LeaveIfError( err );

   256     CleanupStack::PopAndDestroy( info );

   257     info = NULL;

   258 

   259     CHsContentInfo* view = CHsContentInfo::NewL();

   260     CleanupStack::PushL( view );

   261 

   262     err = iApiClient->ActiveViewL( *view );

   263     User::LeaveIfError( err );

   264 

   265     info = GetWidgetL( view, aUid );

   266     

   267     CleanupStack::PopAndDestroy( view );

   268 

   269     User::LeaveIfNull( info );

   270     return info;

   271     }

   272 

   273 // -----------------------------------------------------------------------

   274 // CMTHsCcApiClient::GetViewL()

   275 // -----------------------------------------------------------------------

   276 //

   277 CHsContentInfo* CMTHsCcApiClient::GetViewL(

   278     CHsContentInfo* aApp,

   279     const TDesC8& aUid )

   280     {

   281     CHsContentInfoArray* views = CHsContentInfoArray::NewL();

   282     CleanupStack::PushL( views );

   283     TInt err( KErrNone );

   284     if ( aApp )

   285         {

   286         err = iApiClient->ViewListL( *aApp, *views );

   287         }

   288     else

   289         {

   290         err = iApiClient->ViewListL( *views );

   291         }

   292     User::LeaveIfError( err );

   293 

   294     CHsContentInfo* info = NULL;

   295     for ( TInt i = 0; i < views->Array().Count() && !info; i++ )

   296         {

   297         if ( views->Array()[ i ]->Uid().CompareF( aUid ) == 0 )

   298             {

   299             info = views->Array()[ i ];

   300             views->Array().Remove( i );

   301             break;

   302             }

   303         }

   304     CleanupStack::PopAndDestroy( views );

   305 

   306     User::LeaveIfNull( info );

   307     return info;

   308     }

   309 

   310 // -----------------------------------------------------------------------

   311 // CMTHsCcApiClient::GetWidgetL()

   312 // -----------------------------------------------------------------------

   313 //

   314 CHsContentInfo* CMTHsCcApiClient::GetWidgetL(

   315     CHsContentInfo* aView,

   316     const TDesC8& aUid )

   317     {

   318     CHsContentInfoArray* widgets = CHsContentInfoArray::NewL();

   319     CleanupStack::PushL( widgets );

   320     TInt err( KErrNone );

   321     if ( aView )

   322         {

   323         err = iApiClient->WidgetListL( *aView, *widgets );

   324         }

   325     else

   326         {

   327         err = iApiClient->WidgetListL( *widgets );

   328         }

   329     User::LeaveIfError( err );

   330 

   331     CHsContentInfo* info = NULL;

   332     for ( TInt i = 0; i < widgets->Array().Count() && !info; i++ )

   333         {

   334         if ( widgets->Array()[ i ]->Uid().CompareF( aUid ) == 0 )

   335             {

   336             info = widgets->Array()[ i ];

   337             widgets->Array().Remove( i );

   338             break;

   339             }

   340         }

   341     CleanupStack::PopAndDestroy( widgets );

   342 

   343     User::LeaveIfNull( info );

   344     return info;

   345     }

   346 

   347 // -----------------------------------------------------------------------

   348 // CMTHsCcApiClient::ConnectDisconnectHsCcApiClientL()

   349 // 

   350 // Test purpose:

   351 // The purpose of this test case is to verify that a connection to the

   352 // Home screen Content Control server is successfully established and 

   353 // closed via Home screen Content Control API client when the api observer

   354 // is not defined

   355 //

   356 // Pre conditions (SetupL()):

   357 // Empty homescreen

   358 //

   359 // Test step 1:

   360 // Create CHsCcApiClient

   361 //

   362 // Expected result:

   363 // Connection is successfully established

   364 //

   365 // Test step 2:

   366 // Delete CHsCcApiClient

   367 //

   368 // Expected result:

   369 // Connection is successfully closed

   370 //

   371 // Post conditions (Teardown()):

   372 // -

   373 //

   374 // -----------------------------------------------------------------------

   375 //

   376 void CMTHsCcApiClient::ConnectDisconnectHsCcApiClientL()

   377     {

   378     // Test step 1

   379     ConnectHsCcApiClientL( NULL );

   380 

   381     // Test step 2

   382     DisconnectHsCcApiClient();

   383     }

   384 

   385 // -----------------------------------------------------------------------

   386 // CMTHsCcApiClient::RegisterUnregisterHsCcApiObserverL()

   387 // 

   388 // Test purpose:

   389 // The purpose of this test case is to verify that a connection to the

   390 // Home screen Content Control server is successfully established and 

   391 // closed via Home screen Content Control API client when the api observer

   392 // is defined

   393 //

   394 // Pre conditions (SetupL()):

   395 // Empty homescreen

   396 //

   397 // Test step 1:

   398 // Create CHsCcApiClient

   399 //

   400 // Expected result:

   401 // Connection is successfully established and 

   402 // observation is successfully started

   403 //

   404 // Test step 2:

   405 // Delete CHsCcApiClient

   406 //

   407 // Expected result:

   408 // Connection is successfully closed

   409 //

   410 // Post conditions (Teardown()):

   411 // -

   412 //

   413 // -----------------------------------------------------------------------

   414 //

   415 void CMTHsCcApiClient::RegisterUnregisterHsCcApiObserverL()

   416     {

   417     // Test step 1

   418     ConnectHsCcApiClientL( this );

   419 

   420     // Test step 2

   421     DisconnectHsCcApiClient();

   422     }

   423 

   424 // -----------------------------------------------------------------------

   425 // CMTHsCcApiClient::RegisterUnregisterMultipleObserversL()

   426 // 

   427 // Test purpose:

   428 // The purpose of this test case is to verify that multiple connections to 

   429 // the Home screen Content Control server are successfully established and 

   430 // closed via Home screen Content Control API client when the api observer

   431 // is defined

   432 //

   433 // Pre conditions (SetupL()):

   434 // Empty homescreen

   435 //

   436 // Test step 1:

   437 // Create CHsCcApiClient

   438 //

   439 // Expected result:

   440 // Connection is successfully established and 

   441 // observation is successfully started

   442 //

   443 // Test step 2

   444 // Create additional connection 1

   445 //

   446 // Expected result:

   447 // Connection is successfully established and 

   448 // observation is successfully started

   449 //

   450 // Test step 3

   451 // Create additional connection 2

   452 //

   453 // Expected result:

   454 // Connection is successfully established and 

   455 // observation is successfully started

   456 //

   457 // Test step 4:

   458 // Delete additional connection 1

   459 //

   460 // Expected result:

   461 // Connection is successfully closed

   462 //

   463 // Test step 5:

   464 // Delete additional connection 2

   465 //

   466 // Expected result:

   467 // Connection is successfully closed

   468 //

   469 // Test step 6:

   470 // Delete CHsCcApiClient

   471 //

   472 // Expected result:

   473 // Connection is successfully closed

   474 //

   475 // Post conditions (Teardown()):

   476 // -

   477 //

   478 // -----------------------------------------------------------------------

   479 //

   480 void CMTHsCcApiClient::RegisterUnregisterMultipleObserversL()

   481     {

   482     // Test step 1

   483     ConnectHsCcApiClientL( this );

   484 

   485     // Test step 2

   486     CHsCcApiClient* addClient1 = CHsCcApiClient::NewL( this );

   487     CleanupStack::PushL( addClient1 );

   488 

   489     // Test step 3

   490     CHsCcApiClient* addClient2 = CHsCcApiClient::NewL( this );

   491 

   492     // Test step 4

   493     CleanupStack::PopAndDestroy( addClient1 );

   494     

   495     // Test step 5

   496     delete addClient2;

   497 

   498     // Test step 6

   499     DisconnectHsCcApiClient();

   500     }

   501 

   502 // -----------------------------------------------------------------------

   503 // CMTHsCcApiClient::WidgetListL()

   504 // 

   505 // Test purpose:

   506 // The purpose of this test case is to verify that a correct list of

   507 // widgets is returned

   508 //

   509 // Pre conditions (SetupL()):

   510 // Empty homescreen

   511 //

   512 // Test step 1:

   513 // Create CHsCcApiClient

   514 //

   515 // Expected result:

   516 // Connection is successfully established

   517 //

   518 // Test step 2:

   519 // Get widget list

   520 //

   521 // Expected result:

   522 // Content info list with widget or template type content info

   523 //

   524 // Test step 3:

   525 // Delete CHsCcApiClient

   526 //

   527 // Expected result:

   528 // Connection is successfully closed

   529 //

   530 // Post conditions (Teardown()):

   531 // -

   532 //

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

   534 //

   535 void CMTHsCcApiClient::WidgetListL()

   536     {

   537     // Test step 1

   538     ConnectHsCcApiClientL( NULL );

   539 

   540     // Test step 2

   541     CHsContentInfoArray* widgets = CHsContentInfoArray::NewL();

   542     CleanupStack::PushL( widgets );

   543     TInt err = iApiClient->WidgetListL( *widgets );

   544     // Check widget list

   545     for ( TInt i = 0; i < widgets->Array().Count() && !err ; i++ )

   546         {

   547         CHsContentInfo* info = widgets->Array()[ i ];

   548         if ( info->Type().Compare( KInfoTypeWidget ) != 0 &&

   549              info->Type().Compare( KInfoTypeTemplate ) != 0 )

   550             {

   551             // Invalid widget type

   552             err = KErrArgument;

   553             }

   554         }

   555     CleanupStack::PopAndDestroy( widgets );

   556     User::LeaveIfError( err );

   557 

   558     // Test step 3

   559     DisconnectHsCcApiClient();

   560     }

   561 

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

   563 // CMTHsCcApiClient::AddRemoveWidgetL()

   564 // 

   565 // Test purpose:

   566 // The purpose of this test case is to verify that a widget which can be

   567 // added to the Home scree is successfully added

   568 //

   569 // Pre conditions (SetupL()):

   570 // Empty homescreen

   571 //

   572 // Test step 1:

   573 // Create CHsCcApiClient

   574 //

   575 // Expected result:

   576 // Connection is successfully established

   577 //

   578 // Test step 2:

   579 // Add test view

   580 //

   581 // Expected result:

   582 // View successfully aded

   583 //

   584 // Test step 3:

   585 // Activate test view

   586 //

   587 // Expected result:

   588 // View successfully activated

   589 //

   590 // Test step 4:

   591 // Add desktop widget

   592 //

   593 // Expected result:

   594 // Widget is successfully added

   595 //

   596 // Test step 5:

   597 // Remove desktop widget

   598 //

   599 // Expected result

   600 // Widget is removed succesfully

   601 //

   602 // Test step 6:

   603 // Delete CHsCcApiClient

   604 //

   605 // Expected result:

   606 // Connection is successfully closed

   607 //

   608 // Post conditions (Teardown()):

   609 // -

   610 //

   611 // -----------------------------------------------------------------------

   612 //

   613 void CMTHsCcApiClient::AddRemoveWidgetL()

   614     {

   615     // Test step 1

   616     ConnectHsCcApiClientL( NULL );

   617 

   618     // Test step 2

   619     CHsContentInfo* view = AddViewL( KTemplateViewUid );

   620     User::LeaveIfNull( view );

   621     CleanupStack::PushL( view );

   622 

   623     // Test step 3

   624     TInt err = iApiClient->ActivateViewL( *view );

   625     User::LeaveIfError( err );

   626     CleanupStack::PopAndDestroy( view );

   627 

   628     // Test step 4

   629     CHsContentInfo* widget = AddWidgetL( KDesktopWidgetUid );

   630     User::LeaveIfNull( widget );

   631     CleanupStack::PushL( widget );

   632 

   633     // Test step 5

   634     err = iApiClient->RemoveWidgetL( *widget );

   635     User::LeaveIfError( err );

   636     CleanupStack::PopAndDestroy( widget );

   637 

   638     // Test step 6

   639     DisconnectHsCcApiClient();

   640     }

   641 

   642 // -----------------------------------------------------------------------

   643 // CMTHsCcApiClient::AddWidgetFails1L()

   644 // 

   645 // Test purpose:

   646 // The purpose of this test case is to verify that adding of widget fails

   647 // if a widget which cannot be found is request to be added

   648 //

   649 // Pre conditions (SetupL()):

   650 // Empty homescreen

   651 //

   652 // Test step 1:

   653 // Create CHsCcApiClient

   654 //

   655 // Expected result:

   656 // Connection is successfully established

   657 //

   658 // Test step 2:

   659 // Add test view

   660 //

   661 // Expected result:

   662 // View successfully added

   663 //

   664 // Test step 3:

   665 // Activate test view

   666 //

   667 // Expected result:

   668 // View successfully activated

   669 //

   670 // Test step 4:

   671 // Add invalid widget

   672 //

   673 // Expected result:

   674 // Widget adding fails

   675 //

   676 // Test step 5:

   677 // Delete CHsCcApiClient

   678 //

   679 // Expected result:

   680 // Connection is successfully closed

   681 //

   682 // Post conditions (Teardown()):

   683 // -

   684 //

   685 // -----------------------------------------------------------------------

   686 //

   687 void CMTHsCcApiClient::AddWidgetFails1L()

   688     {

   689     // Test step 1

   690     ConnectHsCcApiClientL( NULL );

   691 

   692     // Test step 2

   693     CHsContentInfo* view = AddViewL( KTemplateViewUid );

   694     User::LeaveIfNull( view );

   695     CleanupStack::PushL( view );

   696 

   697     // Test step 3

   698     TInt err = iApiClient->ActivateViewL( *view );

   699     User::LeaveIfError( err );

   700     CleanupStack::PopAndDestroy( view );

   701 

   702     // Test step 4

   703     CHsContentInfo* widget = GetWidgetL( NULL, KDesktopWidgetUid );

   704     User::LeaveIfNull( widget );

   705     CleanupStack::PushL( widget );

   706     widget->SetUidL( KNotFoundWidgetUid );

   707     err = iApiClient->AddWidgetL( *widget );

   708     if ( err != KErrArgument )

   709         {

   710         User::Leave( KErrGeneral );

   711         }

   712     CleanupStack::PopAndDestroy( widget );

   713 

   714     // Test step 5

   715     DisconnectHsCcApiClient();

   716     }

   717 

   718 // -----------------------------------------------------------------------

   719 // CMTHsCcApiClient::RemoveWidgetFails1L()

   720 // 

   721 // Test purpose:

   722 // The purpose of this test case is to verify that removing of widget fails

   723 // if a widget request to be removed cannot be found

   724 //

   725 // Pre conditions (SetupL()):

   726 // Empty homescreen

   727 //

   728 // Test step 1:

   729 // Create CHsCcApiClient

   730 //

   731 // Expected result:

   732 // Connection is successfully established

   733 //

   734 // Test step 2:

   735 // Add test view

   736 //

   737 // Expected result:

   738 // View successfully added

   739 //

   740 // Test step 3:

   741 // Activate test view

   742 //

   743 // Expected result:

   744 // View successfully activated

   745 //

   746 // Test step 4:

   747 // Remove invalid widget

   748 //

   749 // Expected result:

   750 // Widget removing fails

   751 //

   752 // Test step 5:

   753 // Delete CHsCcApiClient

   754 //

   755 // Expected result:

   756 // Connection is successfully closed

   757 //

   758 // Post conditions (Teardown()):

   759 // -

   760 //

   761 // -----------------------------------------------------------------------

   762 //

   763 void CMTHsCcApiClient::RemoveWidgetFails1L()

   764     {

   765     // Test step 1

   766     ConnectHsCcApiClientL( NULL );

   767 

   768     // Test step 2

   769     CHsContentInfo* view = AddViewL( KTemplateViewUid );

   770     User::LeaveIfNull( view );

   771     CleanupStack::PushL( view );

   772 

   773     // Test step 3

   774     TInt err = iApiClient->ActivateViewL( *view );

   775     User::LeaveIfError( err );

   776     CleanupStack::PopAndDestroy( view );

   777 

   778     // Test step 4

   779     CHsContentInfo* widget = GetWidgetL( NULL, KDesktopWidgetUid );

   780     User::LeaveIfNull( widget );

   781     CleanupStack::PushL( widget );

   782     widget->SetUidL( KNotFoundWidgetUid );

   783     err = iApiClient->RemoveWidgetL( *widget );

   784     if ( err != KErrArgument )

   785         {

   786         User::Leave( KErrGeneral );

   787         }

   788     CleanupStack::PopAndDestroy( widget );

   789 

   790     // Test step 5

   791     DisconnectHsCcApiClient();

   792     }

   793 

   794 // -----------------------------------------------------------------------

   795 // CMTHsCcApiClient::WidgetListChangeNtfL()

   796 // 

   797 // Test purpose:

   798 // The purpose of this test case is to verify that a notification is

   799 // received after a widget is successfully addded to Home screen

   800 //

   801 // Pre conditions (SetupL()):

   802 // Empty homescreen

   803 //

   804 // Test step 1:

   805 // Create CHsCcApiClient

   806 //

   807 // Expected result:

   808 // Connection is successfully established

   809 //

   810 // Test step 2:

   811 // Add test view

   812 //

   813 // Expected result:

   814 // View successfully added

   815 //

   816 // Test step 3:

   817 // Activate test view

   818 //

   819 // Expected result:

   820 // View successfully activated

   821 //

   822 // Test step 4:

   823 // Delete CHsCcApiClient

   824 //

   825 // Expected result:

   826 // Connection is successfully closed

   827 //

   828 // Test step 5:

   829 // Create CHsCcApiClient and register it as Content Control server api 

   830 // observer

   831 //

   832 // Expected result:

   833 // Connection is successfully established observation registration 

   834 // succeeded

   835 //

   836 // Test step 6:

   837 // Add desktop widget

   838 //

   839 // Expected result:

   840 // 1) Widget added successfully

   841 // 2) Widget list change notification received

   842 //

   843 // Test step 7:

   844 // Delete CHsCcApiClient

   845 //

   846 // Expected result:

   847 // Connection is successfully closed

   848 //

   849 // Post conditions (Teardown()):

   850 // -

   851 //

   852 // -----------------------------------------------------------------------

   853 //

   854 void CMTHsCcApiClient::WidgetListChangeNtfL()

   855     {

   856     // Test step 1

   857     ConnectHsCcApiClientL( NULL );

   858 

   859     // Test step 2

   860     CHsContentInfo* view = AddViewL( KTemplateViewUid );

   861     User::LeaveIfNull( view );

   862     CleanupStack::PushL( view );

   863 

   864     // Test step 3

   865     TInt err = iApiClient->ActivateViewL( *view );

   866     User::LeaveIfError( err );

   867     CleanupStack::PopAndDestroy( view );

   868 

   869     // Test step 4

   870     DisconnectHsCcApiClient();

   871 

   872     // Test step 5

   873     ConnectHsCcApiClientL( this );

   874 

   875     // Test step 6

   876     iWidgetListNtfExpected = ETrue;

   877     CHsContentInfo* widget = GetWidgetL( NULL, KDesktopWidgetUid );

   878     User::LeaveIfNull( widget );

   879     CleanupStack::PushL( widget );

   880     err = iApiClient->AddWidgetL( *widget );

   881     User::LeaveIfError( err );

   882 

   883     // Wait for notification

   884     iWait.Start();

   885     if ( !iWidgetListNtfReceived )

   886         {

   887         User::Leave( KErrGeneral );

   888         }

   889     CleanupStack::PopAndDestroy( widget );

   890 

   891     // Test step 7

   892     DisconnectHsCcApiClient();

   893     }

   894 

   895 // -----------------------------------------------------------------------

   896 // CMTHsCcApiClient::ViewListL()

   897 // 

   898 // Test purpose:

   899 // The purpose of this test case is to verify that a correct list of

   900 // views is returned

   901 //

   902 // Pre conditions (SetupL()):

   903 // Empty homescreen

   904 //

   905 // Test step 1:

   906 // Create CHsCcApiClient

   907 //

   908 // Expected result:

   909 // Connection is successfully established

   910 //

   911 // Test step 2:

   912 // Get view list

   913 //

   914 // Expected result:

   915 // Content info list with view type content info

   916 //

   917 // Test step 3:

   918 // Delete CHsCcApiClient

   919 //

   920 // Expected result:

   921 // Connection is successfully closed

   922 //

   923 // Post conditions (Teardown()):

   924 // -

   925 //

   926 // -----------------------------------------------------------------------

   927 //

   928 void CMTHsCcApiClient::ViewListL()

   929     {

   930     // Test step 1

   931     ConnectHsCcApiClientL( NULL );

   932 

   933     // Test step 2

   934     CHsContentInfoArray* views = CHsContentInfoArray::NewL();

   935     CleanupStack::PushL( views );

   936     TInt err = iApiClient->ViewListL( *views );

   937     // Check widget list

   938     for ( TInt i = 0; i < views->Array().Count() && !err ; i++ )

   939         {

   940         CHsContentInfo* info = views->Array()[ i ];

   941         if ( info->Type().Compare( KInfoTypeView ) != 0 )

   942             {

   943             // Invalid widget type

   944             err = KErrArgument;

   945             }

   946         }

   947     CleanupStack::PopAndDestroy( views );

   948     User::LeaveIfError( err );

   949 

   950     // Test step 3

   951     DisconnectHsCcApiClient();

   952     }

   953 

   954 // -----------------------------------------------------------------------

   955 // CMTHsCcApiClient::AddRemoveViewL()

   956 // 

   957 // Test purpose:

   958 // The purpose of this test case is to verify that a widget which can be

   959 // added to the Home scree is successfully added

   960 //

   961 // Pre conditions (SetupL()):

   962 // Empty homescreen

   963 //

   964 // Test step 1:

   965 // Create CHsCcApiClient

   966 //

   967 // Expected result:

   968 // Connection is successfully established

   969 //

   970 // Test step 2:

   971 // Add test view

   972 //

   973 // Expected result:

   974 // View added successfully

   975 //

   976 // Test step 3:

   977 // Remove test view

   978 //

   979 // Expected result:

   980 // View is successfully removed

   981 //

   982 // Test step 4:

   983 // Delete CHsCcApiClient

   984 //

   985 // Expected result:

   986 // Connection is successfully closed

   987 //

   988 // Post conditions (Teardown()):

   989 // -

   990 //

   991 // -----------------------------------------------------------------------

   992 //

   993 void CMTHsCcApiClient::AddRemoveViewL()

   994     {

   995     // Test step 1

   996     ConnectHsCcApiClientL( NULL );

   997 

   998     // Test step 2

   999     CHsContentInfo* view = AddViewL( KTemplateViewUid );

  1000     User::LeaveIfNull( view );

  1001     CleanupStack::PushL( view );

  1002 

  1003     // Test step 3

  1004     TInt err = iApiClient->RemoveViewL( *view );

  1005     User::LeaveIfError( err );

  1006     CleanupStack::PopAndDestroy( view );

  1007 

  1008     // Test step 4

  1009     DisconnectHsCcApiClient();

  1010     }

  1011 

  1012 // -----------------------------------------------------------------------

  1013 // CMTHsCcApiClient::ActivateViewL()

  1014 // 

  1015 // Test purpose:

  1016 // The purpose of this test case is to verify that a view can be

  1017 // successfully activated

  1018 //

  1019 // Pre conditions (SetupL()):

  1020 // Empty homescreen

  1021 //

  1022 // Test step 1:

  1023 // Create CHsCcApiClient

  1024 //

  1025 // Expected result:

  1026 // Connection is successfully established

  1027 //

  1028 // Test step 2:

  1029 // Add test view

  1030 //

  1031 // Expected result:

  1032 // View successfully added

  1033 //

  1034 // Test step 3:

  1035 // Activate test view

  1036 //

  1037 // Expected result:

  1038 // View successfully activated

  1039 //

  1040 // Test step 4:

  1041 // Delete CHsCcApiClient

  1042 //

  1043 // Expected result:

  1044 // Connection is successfully closed

  1045 //

  1046 // Post conditions (Teardown()):

  1047 // -

  1048 //

  1049 // -----------------------------------------------------------------------

  1050 //

  1051 void CMTHsCcApiClient::ActivateViewL()

  1052     {

  1053     // Test step 1

  1054     ConnectHsCcApiClientL( NULL );

  1055 

  1056     // Test step 2

  1057     CHsContentInfo* view = AddViewL( KTemplateViewUid );

  1058     User::LeaveIfNull( view );

  1059     CleanupStack::PushL( view );

  1060 

  1061     // Test step 3

  1062     TInt err = iApiClient->ActivateViewL( *view );

  1063     User::LeaveIfError( err );

  1064     CleanupStack::PopAndDestroy( view );

  1065 

  1066     // Test step 4

  1067     DisconnectHsCcApiClient();

  1068     }

  1069 

  1070 // -----------------------------------------------------------------------

  1071 // CMTHsCcApiClient::AddViewFails1L()

  1072 // 

  1073 // Test purpose:

  1074 // The purpose of this test case is to verify that adding of view fails

  1075 // if an unknown view (invalid UID) is tried to add to Home screen

  1076 //

  1077 // Pre conditions (SetupL()):

  1078 // Empty homescreen

  1079 //

  1080 // Test step 1:

  1081 // Create CHsCcApiClient

  1082 //

  1083 // Expected result:

  1084 // Connection is successfully established

  1085 //

  1086 // Test step 2:

  1087 // Add view which cannot be found to the Home screen

  1088 //

  1089 // Expected result:

  1090 // View adding fails

  1091 //

  1092 // Test step 3:

  1093 // Delete CHsCcApiClient

  1094 //

  1095 // Expected result:

  1096 // Connection is successfully closed

  1097 //

  1098 // Post conditions (Teardown()):

  1099 // -

  1100 //

  1101 // -----------------------------------------------------------------------

  1102 //

  1103 void CMTHsCcApiClient::AddViewFails1L()

  1104     {

  1105     // Test step 1

  1106     ConnectHsCcApiClientL( NULL );

  1107 

  1108     // Test step 2

  1109     CHsContentInfo* view = GetViewL( NULL, KTemplateViewUid );

  1110     User::LeaveIfNull( view );

  1111     CleanupStack::PushL( view );

  1112     view->SetUidL( KNotFoundViewUid );

  1113     TInt err = iApiClient->AddViewL( *view );

  1114     if ( err != KErrArgument )

  1115         {

  1116         User::Leave( KErrGeneral );

  1117         }

  1118     CleanupStack::PopAndDestroy( view );

  1119 

  1120     // Test step 3

  1121     DisconnectHsCcApiClient();

  1122     }

  1123 

  1124 // -----------------------------------------------------------------------

  1125 // CMTHsCcApiClient::RemoveViewFails1L()

  1126 // 

  1127 // Test purpose:

  1128 // The purpose of this test case is to verify that removing of view fails

  1129 // if a view which cannot be removed (last view) is request to be removed

  1130 //

  1131 // Pre conditions (SetupL()):

  1132 // Empty homescreen

  1133 //

  1134 // Test step 1:

  1135 // Create CHsCcApiClient