mmshplugins/mmshsipcrplugin/tsrc/ut_sipcrplugin/src/mussipcrplugintest.cpp
changeset 0 f0cf47e981f9
child 32 73a1feb507fb
equal deleted inserted replaced
-1:000000000000 0:f0cf47e981f9
       
     1 /*
       
     2 * Copyright (c) 2005-2006 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:  Main plugin class
       
    15 *
       
    16 */
       
    17 
       
    18 #include <sipstrings.h>
       
    19 #include "musunittesting.h"
       
    20 #include "musmanagerstub.h"
       
    21 #include "mussipcrplugin.h"
       
    22 #include "mussipcrplugintest.h"
       
    23 #include "muslogger.h" 
       
    24 #include "musmanager.h"
       
    25 
       
    26 #include <alwaysonlinemanagercommon.h>
       
    27 #include <alwaysonlinemanagerclient.h>
       
    28 #include <digia/eunit/eunitmacros.h>
       
    29 #include <SipResolvedClient.h>    
       
    30 #include <sipstrconsts.h>
       
    31 #include "FeatMgr.h"
       
    32 
       
    33 
       
    34 // Next row is to disable warning emerging from EUnit code.
       
    35 #pragma warn_illtokenpasting off
       
    36 
       
    37 
       
    38 // --------------------------------------------------------------------------
       
    39 // C++ constructor.
       
    40 // --------------------------------------------------------------------------
       
    41 // 
       
    42 CMusSipCrPluginTest::CMusSipCrPluginTest()
       
    43     : CEUnitTestSuiteClass()
       
    44     {
       
    45     }
       
    46 
       
    47 
       
    48 // --------------------------------------------------------------------------
       
    49 // Symbian two-phase constructor.
       
    50 // --------------------------------------------------------------------------
       
    51 // 
       
    52 CMusSipCrPluginTest* CMusSipCrPluginTest::NewL()
       
    53     {
       
    54     CMusSipCrPluginTest* self = new (ELeave) CMusSipCrPluginTest();
       
    55     CleanupStack::PushL( self );
       
    56     self->ConstructL();
       
    57     CleanupStack::Pop( self );
       
    58     return self;
       
    59     }
       
    60 
       
    61 
       
    62 // --------------------------------------------------------------------------
       
    63 // Symbian second-phase constructor.
       
    64 // --------------------------------------------------------------------------
       
    65 // 
       
    66 void CMusSipCrPluginTest::ConstructL()
       
    67     {
       
    68     CEUnitTestSuiteClass::ConstructL();
       
    69     }
       
    70 
       
    71 
       
    72 // --------------------------------------------------------------------------
       
    73 // C++ destructor.
       
    74 // --------------------------------------------------------------------------
       
    75 // 
       
    76 CMusSipCrPluginTest::~CMusSipCrPluginTest()
       
    77     {
       
    78     }
       
    79 
       
    80 
       
    81 
       
    82 // ------------------------ Test case setup begin ---------------------------
       
    83 
       
    84 
       
    85 // --------------------------------------------------------------------------
       
    86 // 
       
    87 // --------------------------------------------------------------------------
       
    88 //     
       
    89 void CMusSipCrPluginTest::SetupL(  )
       
    90     {
       
    91     iPlugin = CMusSipCrPlugin::NewL();
       
    92     }
       
    93 
       
    94 
       
    95 // --------------------------------------------------------------------------
       
    96 // 
       
    97 // --------------------------------------------------------------------------
       
    98 // 
       
    99 void CMusSipCrPluginTest::Teardown(  )
       
   100     {
       
   101     delete iPlugin;
       
   102     }
       
   103 
       
   104 
       
   105 
       
   106 // ------------------------- Test functions begin ---------------------------
       
   107 
       
   108 
       
   109 // --------------------------------------------------------------------------
       
   110 // 
       
   111 // --------------------------------------------------------------------------
       
   112 // 
       
   113 void CMusSipCrPluginTest::UT_ChannelL()
       
   114     {
       
   115     SIPStrings::OpenL();
       
   116     
       
   117     RPointerArray<CSIPHeaderBase> array;
       
   118     
       
   119     TUid response;
       
   120     
       
   121     // Options
       
   122     response = iPlugin->ChannelL( 
       
   123                        SIPStrings::StringF( SipStrConsts::EOptions ),
       
   124                        KNullDesC8(),
       
   125                        array,
       
   126                        KNullDesC8(),
       
   127                        NULL );
       
   128 
       
   129     EUNIT_ASSERT( response.iUid == CMusManager::ESipOptions )
       
   130 
       
   131     // Everything is OK
       
   132     CMusManager::SetAvailability( 
       
   133                  ( MultimediaSharing::TMusAvailabilityStatus ) KErrNone );
       
   134     
       
   135     response = iPlugin->ChannelL( SIPStrings::StringF( SipStrConsts::EMessage ),
       
   136                        KNullDesC8(),
       
   137                        array,
       
   138                        KNullDesC8(),
       
   139                        NULL );
       
   140     
       
   141     EUNIT_ASSERT( response.iUid == CMusManager::ESipInviteDesired )
       
   142     
       
   143     // Server is shut down                     
       
   144     CMusManager::SetAvailability( MultimediaSharing::EErrServerShutDown );
       
   145     
       
   146     response = iPlugin->ChannelL( SIPStrings::StringF( SipStrConsts::EMessage ),
       
   147                        KNullDesC8(),
       
   148                        array,
       
   149                        KNullDesC8(),
       
   150                        NULL );
       
   151 
       
   152     EUNIT_ASSERT( response.iUid == CMusManager::ESipInviteNotDesired )
       
   153 
       
   154     // Mus is not supported
       
   155     CMusManager::SetAvailability(
       
   156             ( MultimediaSharing::TMusAvailabilityStatus ) KErrNotSupported );
       
   157     
       
   158     response = iPlugin->ChannelL( SIPStrings::StringF( SipStrConsts::EMessage ),
       
   159                        KNullDesC8(),
       
   160                        array,
       
   161                        KNullDesC8(),
       
   162                        NULL );
       
   163     
       
   164     EUNIT_ASSERT( response.iUid == CMusManager::ESipInviteNotDesired )
       
   165     //Feature Manager testing
       
   166     FeatureManager::MultimediaSharingNotSupported();
       
   167     response = iPlugin->ChannelL( 
       
   168     		           SIPStrings::StringF( SipStrConsts::EOptions ),
       
   169                        KNullDesC8(),
       
   170                        array,
       
   171                        KNullDesC8(),
       
   172                        NULL );
       
   173 
       
   174     EUNIT_ASSERT( response.iUid == CMusManager::ESipInviteNotDesired )
       
   175     // Everything is OK
       
   176     CMusManager::SetAvailability( 
       
   177                  ( MultimediaSharing::TMusAvailabilityStatus ) KErrNone );
       
   178     
       
   179     response = iPlugin->ChannelL( SIPStrings::StringF( SipStrConsts::EMessage ),
       
   180                        KNullDesC8(),
       
   181                        array,
       
   182                        KNullDesC8(),
       
   183                        NULL );
       
   184     
       
   185     EUNIT_ASSERT( response.iUid == CMusManager::ESipInviteNotDesired )
       
   186     
       
   187     // Server is shut down                     
       
   188     CMusManager::SetAvailability( MultimediaSharing::EErrServerShutDown );
       
   189     
       
   190     response = iPlugin->ChannelL( SIPStrings::StringF( SipStrConsts::EMessage ),
       
   191                        KNullDesC8(),
       
   192                        array,
       
   193                        KNullDesC8(),
       
   194                        NULL );
       
   195 
       
   196     EUNIT_ASSERT( response.iUid == CMusManager::ESipInviteNotDesired )
       
   197 
       
   198     // Mus is not supported
       
   199     CMusManager::SetAvailability(
       
   200             ( MultimediaSharing::TMusAvailabilityStatus ) KErrNotSupported );
       
   201     
       
   202     response = iPlugin->ChannelL( SIPStrings::StringF( SipStrConsts::EMessage ),
       
   203                        KNullDesC8(),
       
   204                        array,
       
   205                        KNullDesC8(),
       
   206                        NULL );
       
   207     
       
   208     EUNIT_ASSERT( response.iUid == CMusManager::ESipInviteNotDesired )
       
   209     FeatureManager::MultimediaSharingSupported();  
       
   210     SIPStrings::Close();                       
       
   211                         
       
   212     }
       
   213 
       
   214 
       
   215 // --------------------------------------------------------------------------
       
   216 // 
       
   217 // --------------------------------------------------------------------------
       
   218 // 
       
   219 void CMusSipCrPluginTest::UT_ConnectL()
       
   220     {
       
   221     // Options
       
   222     TUid uid;
       
   223     uid.iUid = CMusManager::ESipOptions;
       
   224     iPlugin->ConnectL( uid );
       
   225     EUNIT_ASSERT_EQUALS( iPlugin->iManager->iHandleSipRequestLCalledWithParam,
       
   226                          CMusManager::ESipOptions )
       
   227     
       
   228     // Desired invite
       
   229     uid.iUid = CMusManager::ESipInviteDesired;
       
   230     iPlugin->ConnectL( uid );
       
   231     EUNIT_ASSERT_EQUALS( iPlugin->iManager->iHandleSipRequestLCalledWithParam,
       
   232                          CMusManager::ESipInviteDesired )
       
   233     
       
   234     // Not desired invite
       
   235     uid.iUid = CMusManager::ESipInviteNotDesired;
       
   236     iPlugin->ConnectL( uid );
       
   237     EUNIT_ASSERT_EQUALS( iPlugin->iManager->iHandleSipRequestLCalledWithParam,
       
   238                          CMusManager::ESipInviteNotDesired )
       
   239       
       
   240     // Unknown case, manager is not called and value does not change    
       
   241     uid.iUid = KErrNone;
       
   242     EUNIT_ASSERT_SPECIFIC_LEAVE( iPlugin->ConnectL( uid ), KErrNotSupported )
       
   243     EUNIT_ASSERT_EQUALS( iPlugin->iManager->iHandleSipRequestLCalledWithParam,
       
   244                          CMusManager::ESipInviteNotDesired )
       
   245     }
       
   246 
       
   247 
       
   248 // --------------------------------------------------------------------------
       
   249 // 
       
   250 // --------------------------------------------------------------------------
       
   251 // 
       
   252 void CMusSipCrPluginTest::UT_Capabilities()
       
   253     {
       
   254     // Dummy test is enough
       
   255     iPlugin->Capabilities();
       
   256     }
       
   257 
       
   258 
       
   259 // --------------------------------------------------------------------------
       
   260 // 
       
   261 // --------------------------------------------------------------------------
       
   262 // 
       
   263 void CMusSipCrPluginTest::UT_ImplementationGroupProxy()
       
   264     {
       
   265     // Dummy test
       
   266     TInt tableCount;
       
   267     
       
   268     ImplementationGroupProxy( tableCount );
       
   269     }
       
   270 
       
   271 
       
   272 
       
   273 
       
   274 //  TEST TABLE
       
   275 
       
   276 EUNIT_BEGIN_TEST_TABLE(
       
   277     CMusSipCrPluginTest,
       
   278     "CMusSipCrPluginTest",
       
   279     "CMusSipCrPluginTest" )
       
   280 
       
   281 EUNIT_TEST(
       
   282     "CMusSipCrPluginTest",
       
   283     "CMusSipCrPluginTest",
       
   284     "ConnectL",
       
   285     "FUNCTIONALITY",
       
   286     SetupL, UT_ConnectL, Teardown)
       
   287 
       
   288 EUNIT_TEST(
       
   289     "CMusSipCrPluginTest",
       
   290     "CMusSipCrPluginTest",
       
   291     "ChannelL",
       
   292     "FUNCTIONALITY",
       
   293     SetupL, UT_ChannelL, Teardown)
       
   294 
       
   295 EUNIT_TEST(
       
   296     "CMusSipCrPluginTest",
       
   297     "CMusSipCrPluginTest",
       
   298     "Capabilities",
       
   299     "FUNCTIONALITY",
       
   300     SetupL, UT_Capabilities, Teardown)
       
   301 
       
   302 EUNIT_TEST(
       
   303     "CMusSipCrPluginTest",
       
   304     "CMusSipCrPluginTest",
       
   305     "ImplementationGroupProxyTest",
       
   306     "FUNCTIONALITY",
       
   307     SetupL, UT_ImplementationGroupProxy, Teardown)
       
   308     
       
   309 EUNIT_END_TEST_TABLE
       
   310