1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "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:t_vimpstenginevoipsubservice.cpp

    15 *

    16 */

    17 #include <EUnitMacros.h>

    18 #include <TEUnitAssertionInfo.h>

    19 #include <CEUnitAllocTestCaseDecorator.h>

    20 #include "t_vimpstenginevoipsubservice.h"

    21 

    22 #include <spentry.h>

    23 #include <spsettings.h>

    24 #include <spproperty.h>

    25 

    26 #include "cvimpstenginevoipsubservice.h"

    27 #include "cvimpstenginecchhandler.h"

    28 #include "cvimpstengineservicetablefetcher.h"

    29 

    30 const TInt KTestServiceId = 5;

    31 

    32 T_VimpstEngineVoipSubService* T_VimpstEngineVoipSubService::NewLC()

    33     {

    34     T_VimpstEngineVoipSubService* self = new( ELeave ) T_VimpstEngineVoipSubService;

    35     CleanupStack::PushL( self );

    36     self->ConstructL();

    37     return self;

    38     }

    39 

    40 T_VimpstEngineVoipSubService::~T_VimpstEngineVoipSubService()

    41     {

    42     }

    43 

    44 void T_VimpstEngineVoipSubService::ConstructL()

    45     {

    46     CEUnitTestSuiteClass::ConstructL();

    47     }

    48 

    49 

    50 //  FROM OBSERVER INTERFACES

    51 void T_VimpstEngineVoipSubService::HandleServceConnectionEventL()

    52     {

    53     }

    54 

    55 

    56 void T_VimpstEngineVoipSubService::SetupL()

    57     {

    58     iTestServiceId = CreateSpEntryL( KTestServiceId );

    59    // MVIMPSTEngineCchUiEventObserver *aCchUiEventObserver;

    60     

    61     iCchHandler = CVIMPSTEngineCchHandler::NewL( iTestServiceId, *iCchUiEventObserver);

    62     iServiceTableFetcher = CVIMPSTEngineServiceTableFetcher::NewL(); 

    63     

    64     iVoIPSubService = CVIMPSTEngineVOIPSubService::NewL( 

    65         iTestServiceId,

    66         *iCchHandler,

    67         *iServiceTableFetcher,

    68         *this );

    69     }

    70 

    71 void T_VimpstEngineVoipSubService::Teardown()

    72     {

    73     if ( iCchHandler )

    74         {

    75         delete iCchHandler;

    76         iCchHandler = NULL;

    77         }

    78     if ( iServiceTableFetcher )

    79         {

    80         delete iServiceTableFetcher;

    81         iServiceTableFetcher = NULL;

    82         }

    83    

    84     if ( iVoIPSubService )

    85         {

    86         delete iVoIPSubService;

    87         iVoIPSubService = NULL;

    88         }

    89     }

    90 

    91 TInt T_VimpstEngineVoipSubService::CreateSpEntryL( TInt aServiceId )

    92     {

    93     CSPSettings* settings = CSPSettings::NewLC();

    94     

    95     CSPEntry* entry = CSPEntry::NewLC();

    96     entry->SetServiceId( aServiceId );

    97     

    98     CSPEntry* testEntry = CSPEntry::NewLC();

    99     TInt result = settings->FindEntryL( entry->GetServiceId(), *testEntry );

   100     

   101     if( result == KErrNone )

   102         {

   103         settings->UpdateEntryL( *entry );

   104         }

   105     else

   106         {

   107         settings->AddEntryL( *entry );

   108         }

   109     

   110     TInt createdServiceId = entry->GetServiceId();

   111     

   112     CleanupStack::PopAndDestroy( testEntry );

   113     CleanupStack::PopAndDestroy( entry );

   114     CleanupStack::PopAndDestroy( settings );

   115     

   116     return createdServiceId;

   117     }   

   118 

   119 void T_VimpstEngineVoipSubService::T_NewLL()

   120     {

   121     CVIMPSTEngineVOIPSubService* voipSubService = NULL;

   122     voipSubService = CVIMPSTEngineVOIPSubService::NewL(

   123         iTestServiceId,

   124         *iCchHandler,

   125         *iServiceTableFetcher,

   126         *this);

   127        

   128     EUNIT_ASSERT( voipSubService != NULL );

   129        

   130     delete voipSubService;

   131     voipSubService = NULL;

   132     }

   133 

   134 void T_VimpstEngineVoipSubService::T_CchEventOccuredLL()

   135     {

   136     TInt error( KErrNone );

   137         

   138     RArray<TCCHSubserviceState> subServiceStates;   

   139     CleanupClosePushL( subServiceStates );

   140     subServiceStates.AppendL( ECCHUninitialized );

   141     subServiceStates.AppendL( ECCHDisabled );

   142     subServiceStates.AppendL( ECCHConnecting );

   143     subServiceStates.AppendL( ECCHEnabled );

   144     subServiceStates.AppendL( ECCHDisconnecting );

   145 

   146     // Test with service error: KErrNone and all subservice states.

   147     TInt serviceError( KErrNone );

   148         

   149     for ( TInt i( 0 ) ; i < subServiceStates.Count() ; i++ )

   150         {

   151         TRAP( error, iVoIPSubService->CchEventOccuredL( 

   152             iTestServiceId, subServiceStates[ i ], serviceError ) );

   153             

   154         if ( KErrNoMemory == error )

   155             {

   156             User::Leave( error );

   157             }

   158             

   159         EUNIT_ASSERT( KErrNone == error );

   160         }

   161           

   162     // Test with service error: KErrNotFound and all subservice states.

   163     serviceError = KErrNotFound;

   164     for ( TInt j( 0 ) ; j < subServiceStates.Count() ; j++ )

   165         {

   166         TRAP( error, iVoIPSubService->CchEventOccuredL( 

   167             iTestServiceId, subServiceStates[ j ], serviceError ) );

   168             

   169         if ( KErrNoMemory == error )

   170             {

   171             User::Leave( error );

   172             }

   173                    

   174         EUNIT_ASSERT( KErrNone == error );

   175         }

   176         

   177     CleanupStack::PopAndDestroy( &subServiceStates );

   178     }

   179 

   180 void T_VimpstEngineVoipSubService::T_DoHandleCchErrorLL()

   181     {

   182     RArray<TInt> serviceErrors;

   183     CleanupClosePushL( serviceErrors );

   184     

   185     serviceErrors.AppendL( KErrGeneral ); // Tests default case

   186     serviceErrors.AppendL( KCCHErrorBandwidthInsufficient );

   187     serviceErrors.AppendL( KCCHErrorInvalidIap );

   188     serviceErrors.AppendL( KCCHErrorAuthenticationFailed );

   189     serviceErrors.AppendL( KCCHErrorNetworkLost );

   190     serviceErrors.AppendL( KCCHErrorLoginFailed );

   191     serviceErrors.AppendL( KCCHErrorServiceNotResponding );

   192     serviceErrors.AppendL( KCCHErrorInvalidSettings );

   193     serviceErrors.AppendL( KCCHErrorAccessPointNotDefined );

   194     

   195     for ( TInt i( 0 ) ; i < serviceErrors.Count() ; i++ )

   196         {

   197         TRAPD( err, iVoIPSubService->DoHandleCchErrorL( 

   198             serviceErrors[ i ] ) );

   199         

   200         if ( KErrNoMemory == err )

   201             {

   202             User::Leave( err );

   203             }

   204                       

   205         EUNIT_ASSERT( KErrNone == err );

   206         }

   207     

   208     CleanupStack::PopAndDestroy( &serviceErrors );

   209     }

   210 

   211 void T_VimpstEngineVoipSubService::T_ResolveServiceStateL()

   212     {

   213     TInt error( KErrNone );

   214         

   215     RArray<TCCHSubserviceState> subServiceStates;   

   216     CleanupClosePushL( subServiceStates );

   217     subServiceStates.AppendL( ECCHUninitialized );

   218     subServiceStates.AppendL( ECCHDisabled );

   219     subServiceStates.AppendL( ECCHConnecting );

   220     subServiceStates.AppendL( ECCHEnabled );

   221     subServiceStates.AppendL( ECCHDisconnecting );

   222     

   223     // Test with service error: KErrNone and all subservice states.

   224     TInt serviceError( KErrNone );

   225             

   226     for ( TInt i( 0 ) ; i < subServiceStates.Count() ; i++ )

   227         {

   228         TRAP( error, iVoIPSubService->ResolveServiceState( 

   229             subServiceStates[ i ], serviceError ) );

   230                 

   231         if ( KErrNoMemory == error )

   232             {

   233             User::Leave( error );

   234             }

   235                 

   236         EUNIT_ASSERT( KErrNone == error );

   237         }

   238               

   239     // Test with service error: KErrNotFound and all subservice states.

   240     serviceError = KErrNotFound;

   241     for ( TInt j( 0 ) ; j < subServiceStates.Count() ; j++ )

   242         {

   243         TRAP( error, iVoIPSubService->ResolveServiceState( 

   244             subServiceStates[ j ], serviceError ) );

   245                 

   246         if ( KErrNoMemory == error )

   247             {

   248             User::Leave( error );

   249             }

   250                        

   251         EUNIT_ASSERT( KErrNone == error );

   252         }

   253         

   254     CleanupStack::PopAndDestroy( &subServiceStates );

   255     }

   256 

   257 void T_VimpstEngineVoipSubService::T_SubServiceStateL()

   258     {

   259     RArray<TVIMPSTEnums::TVIMPSTRegistrationState> states;

   260     CleanupClosePushL( states );

   261     states.AppendL( TVIMPSTEnums::ESVCENotRegistered );

   262     states.AppendL( TVIMPSTEnums::ESVCERegistered );

   263     states.AppendL( TVIMPSTEnums::ESVCENetworkConnecting );

   264     states.AppendL( TVIMPSTEnums::ESVCEWaitingForNetwork );

   265     states.AppendL( TVIMPSTEnums::ESVCENetworkDisConnecting );

   266     states.AppendL( TVIMPSTEnums::ESVCEUpdatingContacts );

   267        

   268     for ( TInt i( 0 ) ; i < states.Count() ; i++ )

   269         {

   270         iVoIPSubService->iServiceState = states[ i ];

   271         EUNIT_ASSERT( states[ i ] == iVoIPSubService->SubServiceState() );

   272         }

   273        

   274     CleanupStack::PopAndDestroy( &states );

   275     }

   276 

   277 void T_VimpstEngineVoipSubService::T_TypeL()

   278     {    

   279     EUNIT_ASSERT( TVIMPSTEnums::EVoip == iVoIPSubService->Type() );

   280     }

   281 

   282 EUNIT_BEGIN_TEST_TABLE( T_VimpstEngineVoipSubService, "T_VimpstEngineVoipSubService", "" )

   283 

   284 EUNIT_TEST(

   285     "NewL - test ",

   286     "T_VimpstEngineVoipSubService",

   287     "NewL",

   288     "FUNCTIONALITY",

   289     SetupL, T_NewLL, Teardown)

   290     

   291 EUNIT_TEST(

   292     "CchEventOccuredL - test ",

   293     "T_VimpstEngineVoipSubService",

   294     "CchEventOccuredL",

   295     "FUNCTIONALITY",

   296     SetupL, T_CchEventOccuredLL, Teardown)

   297     

   298 EUNIT_TEST(

   299     "DoHandleCchErrorL - test ",

   300     "T_VimpstEngineVoipSubService",

   301     "DoHandleCchErrorL",

   302     "FUNCTIONALITY",

   303     SetupL, T_DoHandleCchErrorLL, Teardown)

   304     

   305 EUNIT_TEST(

   306     "ResolveServiceState - test ",

   307     "T_VimpstEngineVoipSubService",

   308     "ResolveServiceState",

   309     "FUNCTIONALITY",

   310     SetupL, T_ResolveServiceStateL, Teardown)

   311     

   312 EUNIT_TEST(

   313     "SubServiceState - test ",

   314     "T_VimpstEngineVoipSubService",

   315     "SubServiceState",

   316     "FUNCTIONALITY",

   317     SetupL, T_SubServiceStateL, Teardown)

   318     

   319 EUNIT_TEST(

   320     "Type - test ",

   321     "T_VimpstEngineVoipSubService",

   322     "Type",

   323     "FUNCTIONALITY",

   324     SetupL, T_TypeL, Teardown)

   325 

   326 EUNIT_END_TESTCASE_TABLE

   327 

   328 //  END OF FILE