1 /*

     2 * t_vimpstengine.cpp  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_vimpstengine.cpp

    15 *

    16 */

    17 #include <EUnitMacros.h>

    18 #include <TEUnitAssertionInfo.h>

    19 #include <CEUnitAllocTestCaseDecorator.h>

    20 #include "t_vimpstengine.h"

    21 

    22 #include <spentry.h>

    23 #include <spsettings.h>

    24 #include <spproperty.h>

    25 

    26 #include "cvimpstengine.h"

    27 #include "cvimpstengineservicetablefetcher.h"

    28 #include "mvimpstenginecontactmgmtextention.h"

    29 #include "mvimpstenginesearchmgrextention.h"

    30 #include "mvimpstengineextentionfeatures.h"

    31 #include "cvimpstenginesessioncntxtobserver.h"

    32 //#include "cvimpstenginesearchmgrextention.h"

    33 #include "cvimpstenginecontactmgmtextention.h"

    34 #include "mvimpstenginesubservice.h"

    35 

    36 #include "s_cch.h"

    37 

    38 extern MyCchService* myService;

    39 extern TBool createService ;

    40 extern CSPSettings* myCSPSettings;

    41 

    42 extern TBool getUserName;

    43 extern TBool getPassword;

    44 

    45 const TInt KTestServiceId = 4;

    46 _LIT( KTestServiceName, "TEST_SERVICE" );

    47 //_LIT8( KTestBrandId, "TEST_BRAND_ID" );

    48 

    49 _LIT( KTestInternetTelephoneField, "Internet telephone" );

    50 

    51 T_VimpstEngine* T_VimpstEngine::NewLC()

    52     {

    53     T_VimpstEngine* self = new( ELeave ) T_VimpstEngine;

    54     CleanupStack::PushL( self );

    55     self->ConstructL();

    56     return self;

    57     }

    58 

    59 T_VimpstEngine::~T_VimpstEngine()

    60     {

    61     }

    62 

    63 void T_VimpstEngine::ConstructL()

    64     {

    65     CEUnitTestSuiteClass::ConstructL();

    66     }

    67 

    68 void T_VimpstEngine::SetupL()

    69     {

    70     iServiceTableFetcher = CVIMPSTEngineServiceTableFetcher::NewL();

    71     

    72     createService = ETrue;

    73     myCSPSettings = CSPSettings::NewL();

    74     iTestServiceId = CreateSpEntryL( KTestServiceId );

    75     

    76     iEngine = CVIMPSTEngine::NewL( 

    77         iTestServiceId, *iServiceTableFetcher );

    78     }    

    79 

    80 void T_VimpstEngine::Teardown()

    81     {    

    82     if ( iServiceTableFetcher )

    83         {

    84         delete iServiceTableFetcher;

    85         iServiceTableFetcher = NULL;

    86         }   

    87     if ( iEngine )

    88         {

    89         delete iEngine;

    90         iEngine = NULL;

    91         }

    92     

    93     if ( myService )

    94         {

    95         delete myService;

    96         myService = NULL;  

    97         }

    98   

    99     if ( myCSPSettings )

   100         {

   101         delete myCSPSettings;

   102         myCSPSettings = NULL;

   103         }

   104     

   105     createService = EFalse;

   106     getUserName = EFalse;

   107     getPassword = EFalse;

   108     }

   109 

   110 

   111 // FROM OBSERVERS

   112 

   113 void T_VimpstEngine::HandleServiceEventL( 

   114     TVIMPSTEnums::TVIMPSTRegistrationState /*aState*/, 

   115     TInt /*aServiceError*/ )

   116     {

   117     

   118     }

   119 

   120 

   121 

   122 // HELP METHODS

   123 

   124 TInt T_VimpstEngine::CreateSpEntryL( TInt aServiceId )

   125     {    

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

   127     entry->SetServiceId( aServiceId );

   128     User::LeaveIfError( entry->SetServiceName( KTestServiceName ) );

   129     

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

   131     TInt result = myCSPSettings->FindEntryL( entry->GetServiceId(), *testEntry );

   132     

   133     if( result == KErrNone )

   134         {

   135         myCSPSettings->UpdateEntryL( *entry );

   136         }

   137     else

   138         {

   139         myCSPSettings->AddEntryL( *entry );

   140         }

   141     

   142     CSPProperty* property = NULL;

   143    

   144     // set voip enabled property

   145     property = CSPProperty::NewLC();

   146     property->SetName( ESubPropertyVoIPEnabled );

   147     property->SetValue( EOn );

   148     entry->AddPropertyL( *property );

   149     CleanupStack::PopAndDestroy( property );

   150     

   151     // set presence settings id property

   152     property = CSPProperty::NewLC();

   153     property->SetName( ESubPropertyPresenceSettingsId );

   154     property->SetValue( 1 );

   155     entry->AddPropertyL( *property );

   156     CleanupStack::PopAndDestroy( property );

   157     

   158     // set im settings id property

   159     property = CSPProperty::NewLC();

   160     property->SetName( ESubPropertyIMSettingsId );

   161     property->SetValue( 1 );

   162     entry->AddPropertyL( *property );

   163     CleanupStack::PopAndDestroy( property );

   164     

   165     // set Presence FW PSC plugin UID

   166     property = CSPProperty::NewLC();

   167     property->SetName( EPropertyPCSPluginId );

   168     property->SetValue( 1 );

   169     entry->AddPropertyL( *property );

   170     CleanupStack::PopAndDestroy( property );

   171     

   172     myCSPSettings->UpdateEntryL( *entry ); 

   173     TInt createdServiceId = entry->GetServiceId();

   174     

   175     CleanupStack::PopAndDestroy( testEntry );

   176     CleanupStack::PopAndDestroy( entry );

   177     

   178     return createdServiceId;

   179     } 

   180 

   181 

   182 

   183 // TEST CASES

   184 

   185 void T_VimpstEngine::T_NewLL()

   186     {  

   187     EUNIT_ASSERT( iEngine != NULL );

   188     }

   189 

   190 void T_VimpstEngine::T_LoginL()

   191     {  

   192    // iEngine->iCchHandler = mycch_stub::N

   193     TInt err = iEngine->Login();   

   194     EUNIT_ASSERT( KErrNone == err );

   195     }

   196 

   197 void T_VimpstEngine::T_LogoutL()

   198     {  

   199     iEngine->LogoutL();   

   200     }

   201 

   202 void T_VimpstEngine::T_ServiceIdL()

   203     {  

   204     TUint32 serviceId( KErrNone );

   205     serviceId = iEngine->ServiceId();

   206     EUNIT_ASSERT( iTestServiceId == serviceId );

   207     }

   208 

   209 void T_VimpstEngine::T_ServiceNameL()

   210     {  

   211     RBuf serviceName;

   212     CleanupClosePushL( serviceName );

   213     serviceName.CreateL( 15 );

   214     serviceName.Copy( iEngine->ServiceName() );   

   215     EUNIT_ASSERT( serviceName.Compare( KTestServiceName ) == 0 );

   216     CleanupStack::PopAndDestroy( &serviceName );

   217     }

   218 

   219 void T_VimpstEngine::T_ServiceStateL()

   220     {  

   221     RArray<TVIMPSTEnums::TVIMPSTRegistrationState> states;

   222     CleanupClosePushL( states );

   223     

   224     states.AppendL( TVIMPSTEnums::ESVCENotRegistered );

   225     states.AppendL( TVIMPSTEnums::ESVCERegistered );

   226     states.AppendL( TVIMPSTEnums::ESVCENetworkConnecting );

   227     states.AppendL( TVIMPSTEnums::ESVCEWaitingForNetwork );

   228     states.AppendL( TVIMPSTEnums::ESVCENetworkDisConnecting );

   229     states.AppendL( TVIMPSTEnums::ESVCEUpdatingContacts );

   230     

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

   232         {

   233         iEngine->iState = states[ i ];

   234         TVIMPSTEnums::TVIMPSTRegistrationState state = 

   235             iEngine->ServiceState();

   236         EUNIT_ASSERT( state == states[ i ] );

   237         }

   238     

   239     CleanupStack::PopAndDestroy( &states );

   240     }

   241 

   242 void T_VimpstEngine::T_GetBrandInfoLL()

   243     {  

   244     TLanguage language;

   245     TInt version( KErrNone );

   246     RBuf8 brandId;

   247     CleanupClosePushL( brandId );

   248     brandId.CreateL( 20 );

   249     

   250     TRAPD( err, iEngine->GetBrandInfoL( 

   251         language, version, brandId ) );

   252     

   253     if ( KErrNoMemory == err )

   254         {

   255         User::Leave( err );

   256         }

   257     

   258     EUNIT_ASSERT( KErrNone == err );

   259     

   260     CleanupStack::PopAndDestroy( &brandId );

   261     }

   262 

   263 void T_VimpstEngine::T_IsSubServiceSupportedLL()

   264     {  

   265     RArray<TVIMPSTEnums::SubServiceType> types;

   266     CleanupClosePushL( types );

   267     

   268     types.AppendL( TVIMPSTEnums::EVoip );

   269     types.AppendL( TVIMPSTEnums::EPresence );

   270     types.AppendL( TVIMPSTEnums::EIM );

   271     types.AppendL( TVIMPSTEnums::ELast );

   272 

   273     for ( TInt i( 0 ) ; i < types.Count() ; i++ )

   274         {

   275         TBool supported( EFalse );

   276         TRAPD( err, supported =  

   277             iEngine->IsSubServiceSupportedL( types[ i ] ) );

   278         

   279         if ( KErrNoMemory == err )

   280             {

   281             User::Leave( err );

   282             }

   283         

   284         EUNIT_ASSERT( KErrNone == err );

   285         EUNIT_ASSERT( ETrue == supported || EFalse == supported );

   286         }

   287     

   288     CleanupStack::PopAndDestroy( &types );

   289     }

   290 

   291 void T_VimpstEngine::T_IsSubServiceEnabledL()

   292     {  

   293     RArray<TVIMPSTEnums::SubServiceType> types;

   294     CleanupClosePushL( types );

   295        

   296     types.AppendL( TVIMPSTEnums::EVoip );

   297     types.AppendL( TVIMPSTEnums::EPresence );

   298     types.AppendL( TVIMPSTEnums::EIM );

   299     types.AppendL( TVIMPSTEnums::ELast );

   300 

   301     for ( TInt i( 0 ) ; i < types.Count() ; i++ )

   302         {

   303         TBool enabled( EFalse );

   304         TRAPD( err, enabled =  

   305             iEngine->IsSubServiceEnabled( types[ i ] ) );

   306            

   307         if ( KErrNoMemory == err )

   308             {

   309             User::Leave( err );

   310             }

   311            

   312         EUNIT_ASSERT( KErrNone == err );

   313         EUNIT_ASSERT( ETrue == enabled || EFalse == enabled );

   314         }

   315        

   316     CleanupStack::PopAndDestroy( &types );

   317     }

   318 

   319 void T_VimpstEngine::T_ContactStoreIdLL()

   320     {  

   321     RBuf contactStoreId;

   322     CleanupClosePushL( contactStoreId );

   323     contactStoreId.CreateL( 50 );

   324     

   325     TRAPD( err, iEngine->ContactStoreIdL( contactStoreId ) );

   326     

   327     if ( KErrNoMemory == err )

   328         {

   329         User::Leave( err );

   330         }

   331     

   332     EUNIT_ASSERT( KErrNone == err );

   333     

   334     CleanupStack::PopAndDestroy( &contactStoreId );

   335     }

   336 

   337 void T_VimpstEngine::T_RegisterServiceSessionObserverLL()

   338     {  

   339     TInt err( KErrNone );

   340     

   341     // Register observer

   342     TRAP( err, iEngine->RegisterServiceSessionObserverL( this ) );

   343     

   344     if ( KErrNoMemory == err )

   345         {

   346         User::Leave( err );

   347         }

   348         

   349     EUNIT_ASSERT( KErrNone == err );

   350     

   351     // Try to register same observer again

   352     TRAP( err, iEngine->RegisterServiceSessionObserverL( this ) );

   353        

   354     if ( KErrNoMemory == err )

   355         {

   356         User::Leave( err );

   357         }

   358            

   359     EUNIT_ASSERT( KErrNone == err );

   360     }

   361 

   362 void T_VimpstEngine::T_UnRegisterServiceSessionObserverLL()

   363     {

   364     TInt err( KErrNone );

   365     

   366     // Register observer to be unregistered

   367     TRAP( err, iEngine->RegisterServiceSessionObserverL( this ) );

   368        

   369     if ( KErrNoMemory == err )

   370         {

   371         User::Leave( err );

   372         }

   373            

   374     EUNIT_ASSERT( KErrNone == err );

   375     

   376     // Unregister observer

   377     TRAP( err, iEngine->UnRegisterServiceSessionObserver( this ) );

   378         

   379     if ( KErrNoMemory == err )

   380         {

   381         User::Leave( err );

   382         }

   383             

   384     EUNIT_ASSERT( KErrNone == err );

   385     

   386     // Try to unregister observer again

   387     TRAP( err, iEngine->UnRegisterServiceSessionObserver( this ) );

   388         

   389     if ( KErrNoMemory == err )

   390         {

   391         User::Leave( err );

   392         }

   393             

   394     EUNIT_ASSERT( KErrNone == err )

   395     }

   396 

   397 void T_VimpstEngine::T_IntializeStorageLL()

   398     {  

   399     TRAPD( err, iEngine->IntializeStorageL() );

   400     

   401     if ( KErrNoMemory == err )

   402         {

   403         User::Leave( err );

   404         }

   405             

   406     EUNIT_ASSERT( KErrNone == err );

   407     }

   408 

   409 void T_VimpstEngine::T_UnIntializeStorageLL()

   410     {  

   411     iEngine->UnIntializeStorage();

   412     }

   413 

   414 /*void T_VimpstEngine::T_SetUserNameL()

   415     {  

   416     TInt err( KErrNone );

   417     //err = iEngine->SetUserName( KTestUserName );

   418     

   419     if ( KErrNoMemory == err )

   420         {

   421         User::Leave( err );

   422         }

   423     EUNIT_ASSERT( KErrNone == err );

   424     }

   425 

   426 void T_VimpstEngine::T_SetPasswordL()

   427     {  

   428     TInt err( KErrNone );

   429     //rr = iEngine->SetPassword( KTestPassword );

   430     

   431     if ( KErrNoMemory == err )

   432         {

   433         User::Leave( err );

   434         }

   435     EUNIT_ASSERT( KErrNone == err );

   436     }

   437 */

   438 /*

   439 void T_VimpstEngine::T_UserNameLL()

   440     {  

   441     getUserName = ETrue;

   442     

   443     HBufC* userName = NULL;

   444     TRAPD( err, userName = iEngine->UserNameL() );

   445     CleanupStack::PushL( userName );

   446     

   447     if ( KErrNoMemory == err )

   448         {

   449         User::Leave( err );

   450         }

   451     EUNIT_ASSERT( KErrNone == err );

   452     EUNIT_ASSERT( userName->Des().Compare( KTestUserName ) == 0 );

   453     

   454     CleanupStack::PopAndDestroy( userName );

   455     }*/

   456 /*

   457 void T_VimpstEngine::T_PasswordLL()

   458     {  

   459     getPassword = ETrue;

   460     

   461     HBufC* passWord = NULL;      

   462     TRAPD( err, passWord = iEngine->PasswordL() );

   463     CleanupStack::PushL( passWord );

   464        

   465     if ( KErrNoMemory == err )

   466         {

   467         User::Leave( err );

   468         }

   469     EUNIT_ASSERT( KErrNone == err );

   470     EUNIT_ASSERT( passWord->Des().Compare( KTestPassword ) == 0 );

   471        

   472     CleanupStack::PopAndDestroy( passWord );

   473     }*/

   474 

   475 void T_VimpstEngine::T_SubServiceL()

   476     {  

   477     RArray<TVIMPSTEnums::SubServiceType> types;

   478     CleanupClosePushL( types );

   479           

   480     types.AppendL( TVIMPSTEnums::EVoip );

   481     types.AppendL( TVIMPSTEnums::EPresence );

   482     types.AppendL( TVIMPSTEnums::EIM );

   483     types.AppendL( TVIMPSTEnums::ELast );

   484     

   485     for ( TInt i( 0 ) ; i < types.Count() ; i++ )

   486         {

   487         MVIMPSTEngineSubService* subservice = 

   488             iEngine->SubService( types[ i ] );

   489         }

   490     

   491     CleanupStack::PopAndDestroy( &types );

   492     }

   493 

   494 void T_VimpstEngine::T_ExtentionFeaturesL()

   495     { 

   496     // Try when no extension features exist

   497     MVIMPSTEngineSearchMgrExtention* searchMgr = 

   498         dynamic_cast<MVIMPSTEngineSearchMgrExtention*> 

   499         (iEngine->ExtentionFeatures(TVIMPSTEnums::ESearch));

   500         

   501     MVIMPSTEngineContactMgmtExtention* contactMgr = 

   502         dynamic_cast<MVIMPSTEngineContactMgmtExtention*> 

   503         (iEngine->ExtentionFeatures(

   504             TVIMPSTEnums::EContactManagement));

   505         

   506     iEngine->ExtentionFeatures(

   507         TVIMPSTEnums::EBlocking);

   508     

   509     iEngine->ExtentionFeatures(

   510         TVIMPSTEnums::EExtentionLast);

   511     

   512     // Test again after creating extension features

   513     TRAPD( err, iEngine->CreateExtentionFeaturesL() );

   514        

   515     if ( KErrNoMemory == err )

   516         {

   517         User::Leave( err );

   518         }

   519               

   520     EUNIT_ASSERT( KErrNone == err );

   521     

   522     searchMgr = NULL;

   523     contactMgr = NULL;

   524     

   525     searchMgr = 

   526         dynamic_cast<MVIMPSTEngineSearchMgrExtention*> 

   527         (iEngine->ExtentionFeatures(TVIMPSTEnums::ESearch));

   528             

   529     contactMgr = 

   530         dynamic_cast<MVIMPSTEngineContactMgmtExtention*> 

   531         (iEngine->ExtentionFeatures(

   532             TVIMPSTEnums::EContactManagement));

   533             

   534     iEngine->ExtentionFeatures(

   535         TVIMPSTEnums::EBlocking);

   536         

   537     iEngine->ExtentionFeatures(

   538         TVIMPSTEnums::EExtentionLast);

   539     }

   540 

   541 void T_VimpstEngine::T_AddExtentionFeaturesLL()

   542     {  

   543     /*CVIMPSTEngineSessionCntxtObserver* observer = 

   544         CVIMPSTEngineSessionCntxtObserver::NewLC( 

   545             iTestServiceId );

   546     

   547     CVIMPSTEngineSearchMgrExtention* searchitem = 

   548         CVIMPSTEngineSearchMgrExtention::NewLC(

   549              observer->XimpPresenceContextL(),

   550             *observer->GetRequestMapper());

   551     

   552     TRAPD( err, iEngine->AddExtentionFeaturesL( searchitem ) );    

   553     

   554     if ( KErrNoMemory == err )

   555         {

   556         User::Leave( err );

   557         }

   558     

   559     EUNIT_ASSERT( KErrNone == err );

   560     

   561     CleanupStack::PopAndDestroy( searchitem );

   562     CleanupStack::PopAndDestroy( observer );*/

   563     }

   564 

   565 void T_VimpstEngine::T_RemoveExtentionFeaturesL()

   566     {  

   567     RArray<TVIMPSTEnums::ExtentionType> types;

   568     CleanupClosePushL( types );

   569                 

   570     // Add feature that can be removed

   571     CVIMPSTEngineSessionCntxtObserver* observer = 

   572        CVIMPSTEngineSessionCntxtObserver::NewLC( 

   573            iTestServiceId );

   574        

   575    /* CVIMPSTEngineSearchMgrExtention* searchitem = 

   576        CVIMPSTEngineSearchMgrExtention::NewLC(

   577             observer->XimpPresenceContextL(),

   578             *observer->GetRequestMapper());

   579        

   580     TRAPD( err, iEngine->AddExtentionFeaturesL( searchitem ) );    

   581        

   582     if ( KErrNoMemory == err )

   583         {

   584         User::Leave( err );

   585         }

   586        

   587     EUNIT_ASSERT( KErrNone == err );

   588     EUNIT_ASSERT( iEngine->iExtentionFeatures.Count() == 1 );   

   589    */  

   590     

   591     // Test with all types

   592    // types.AppendL( TVIMPSTEnums::ESearch );

   593     //types.AppendL( TVIMPSTEnums::EBlocking );

   594     types.AppendL( TVIMPSTEnums::EContactManagement );

   595     types.AppendL( TVIMPSTEnums::EExtentionLast );

   596     

   597     for ( TInt i( 0 ) ; i < types.Count() ; i++ )

   598         {

   599         iEngine->RemoveExtentionFeatures( types[ i ] );

   600         }

   601     

   602     // Created feature should be removed --> count = 0

   603     EUNIT_ASSERT( iEngine->iExtentionFeatures.Count() == 0 ); 

   604     

   605     //CleanupStack::PopAndDestroy( searchitem );

   606     CleanupStack::PopAndDestroy( observer );

   607     CleanupStack::PopAndDestroy( &types );

   608     }

   609 

   610 void T_VimpstEngine::T_HandleServceConnectionEventLL()

   611     {  

   612     TRAPD( err, iEngine->HandleServceConnectionEventL() );

   613     

   614     if ( KErrNoMemory == err )

   615         {

   616         User::Leave( err );

   617         }

   618     

   619     EUNIT_ASSERT( KErrNone == err );

   620     }

   621 

   622 void T_VimpstEngine::T_ParseGetServiceStateL()

   623     {  

   624     RArray<TVIMPSTEnums::TVIMPSTRegistrationState> states;

   625     CleanupClosePushL( states ); 

   626     

   627     states.AppendL( TVIMPSTEnums::ESVCENotRegistered );

   628     states.AppendL( TVIMPSTEnums::ESVCERegistered );

   629     states.AppendL( TVIMPSTEnums::ESVCENetworkConnecting );

   630     states.AppendL( TVIMPSTEnums::ESVCEWaitingForNetwork );

   631     states.AppendL( TVIMPSTEnums::ESVCENetworkDisConnecting );

   632     states.AppendL( TVIMPSTEnums::ESVCEUpdatingContacts );

   633     

   634     TVIMPSTEnums::TVIMPSTRegistrationState state;

   635     state = iEngine->ParseGetServiceState();   

   636     EUNIT_ASSERT( state == TVIMPSTEnums::ESVCENotRegistered );

   637     

   638     // TBD: test with different states

   639     

   640     CleanupStack::PopAndDestroy( &states );

   641     }

   642 

   643 void T_VimpstEngine::T_HandleContactFetchedLL()

   644     {  

   645     TRAPD( err, iEngine->HandleContactFetchedL() );

   646     

   647     if ( KErrNoMemory == err )

   648         {

   649         User::Leave( err );

   650         }

   651     

   652     EUNIT_ASSERT( KErrNone == err );

   653     }

   654 /*

   655 void T_VimpstEngine::T_HandleContactAddedLL()

   656     {  

   657     RPointerArray<HBufC> serviceDetails;    

   658     CDesCArray* array = new (ELeave) CDesCArrayFlat( 1 );

   659     CleanupStack::PushL( array );

   660     

   661     array->AppendL( KTestInternetTelephoneField );    

   662     const CDesCArray& constArray = *array;

   663     

   664     for ( TInt i( 0 ) ; i < constArray.MdcaCount() ; i++ )

   665         {

   666         serviceDetails.InsertInOrder( constArray[ i ].Alloc(),0);

   667         }

   668     

   669     TRAPD( err, iEngine->HandleContactAddedL( serviceDetails ) );

   670     

   671     if ( KErrNoMemory == err )

   672         {

   673         User::Leave( err );

   674         }

   675     

   676     EUNIT_ASSERT( KErrNone == err );

   677     

   678     CleanupStack::PopAndDestroy( array );

   679     serviceDetails.ResetAndDestroy();

   680     }*/

   681 /*

   682 void T_VimpstEngine::T_HandleContactDeletedLL()

   683     {  

   684   //  RPointerArray<HBufC> serviceDetails;

   685     MVIMPSTStorageContact* aStorageContact;

   686     

   687     //TRAPD( err, iEngine->HandleContactDeletedL( serviceDetails ) );

   688     

   689     TRAPD( err, iEngine->HandleContactDeletedL( *aStorageContact ) );

   690     

   691     if ( KErrNoMemory == err )

   692         {

   693         User::Leave( err );

   694         }

   695         

   696     EUNIT_ASSERT( KErrNone == err );

   697     

   698     //serviceDetails.ResetAndDestroy();

   699     

   700     }

   701 */

   702 void T_VimpstEngine::T_CreateExtentionFeaturesLL()

   703     {  

   704     TRAPD( err, iEngine->CreateExtentionFeaturesL() );

   705     

   706     if ( KErrNoMemory == err )

   707         {

   708         User::Leave( err );

   709         }

   710            

   711     EUNIT_ASSERT( KErrNone == err );

   712     }

   713 /*

   714 void T_VimpstEngine::T_EmptySetUserNameL()

   715     {  

   716     TRAPD( err, iEngine->SetUserNameL(KNullDesC()) );

   717     

   718     if ( KErrNone != err )

   719         {

   720         User::Leave( err );

   721         }

   722            

   723     EUNIT_ASSERT( KErrNone == err );

   724     }

   725 */

   726 /*

   727 void T_VimpstEngine::T_SetUserNameL()

   728     {  

   729     TRAPD( err, iEngine->SetUserNameL(_L("testui")) );

   730     

   731     if ( KErrNone != err )

   732         {

   733         User::Leave( err );

   734         }

   735            

   736     EUNIT_ASSERT( KErrNone == err );

   737     }

   738 */

   739 /*

   740 void T_VimpstEngine::T_WithDomainNameSetUserNameL()

   741     {  

   742     TRAPD( err, iEngine->SetUserNameL(_L("testui123@gmail.com")) );

   743     

   744     if ( KErrNone != err )

   745         {

   746         User::Leave( err );

   747         }

   748            

   749     EUNIT_ASSERT( KErrNone == err );

   750     }

   751 */

   752 /*

   753 void T_VimpstEngine::T_EmptySetPassword()

   754     {  

   755     TRAPD( err, iEngine->SetPassword(KNullDesC()) );

   756     

   757     if (KErrNone != err )

   758         {

   759         User::Leave( err );

   760         }

   761            

   762     EUNIT_ASSERT( KErrNone == err );

   763     }

   764 */

   765 /*

   766 void T_VimpstEngine::T_SetPassword()

   767     {  

   768     TRAPD( err, iEngine->SetPassword(_L("test_ui123")) );

   769     

   770     if (KErrNone != err )

   771             {

   772             User::Leave( err );

   773             }

   774                

   775     EUNIT_ASSERT( KErrNone == err );

   776     }

   777 */

   778 void T_VimpstEngine::T_BlockNotSupported()

   779     {

   780     TBool isBlockSupported = iEngine->IsBlockSupportedL();

   781     EUNIT_ASSERT( EFalse == isBlockSupported );

   782     }

   783     

   784 void T_VimpstEngine::T_FetchBlockedListL()

   785     {

   786     TInt err = KErrNone;

   787     TRAP(err,iEngine->FetchBlockedListL())

   788     EUNIT_ASSERT( KErrNone == err);

   789     }

   790 

   791 void T_VimpstEngine::T_RegisterBlockedListObserver()

   792     {

   793     TInt err = KErrNone;

   794     iEngine->RegisterBlockedListObserver(NULL);

   795     EUNIT_ASSERT( NULL == iEngine->iBlockListObs );

   796     }

   797     

   798 

   799 void T_VimpstEngine::T_BlockSupported()

   800     {

   801     

   802     iEngine->iSessionCntxtObserver =  CVIMPSTEngineSessionCntxtObserver::NewL(3);

   803     TBool isBlockSupported = iEngine->IsBlockSupportedL();

   804     EUNIT_ASSERT( EFalse == isBlockSupported );

   805     }

   806 

   807 EUNIT_BEGIN_TEST_TABLE( T_VimpstEngine, "T_VimpstEngine", "" )

   808 

   809 EUNIT_TEST(

   810     "NewL - test ",

   811     "T_VimpstEngine",

   812     "NewL",

   813     "FUNCTIONALITY",

   814     SetupL, T_NewLL, Teardown)

   815     

   816 EUNIT_TEST(

   817     "Login - test ",

   818     "T_VimpstEngine",

   819     "Login",

   820     "FUNCTIONALITY",

   821     SetupL, T_LoginL, Teardown)

   822     

   823 EUNIT_TEST(

   824     "Logout - test ",

   825     "T_VimpstEngine",

   826     "Logout",

   827     "FUNCTIONALITY",

   828     SetupL, T_LogoutL, Teardown)

   829     

   830 EUNIT_TEST(

   831     "ServiceId - test ",

   832     "T_VimpstEngine",

   833     "ServiceId",

   834     "FUNCTIONALITY",

   835     SetupL, T_ServiceIdL, Teardown)

   836         

   837 EUNIT_TEST(

   838     "ServiceName - test ",

   839     "T_VimpstEngine",

   840     "ServiceName",

   841     "FUNCTIONALITY",

   842     SetupL, T_ServiceNameL, Teardown)

   843     

   844 EUNIT_TEST(

   845     "ServiceState - test ",

   846     "T_VimpstEngine",

   847     "ServiceState",

   848     "FUNCTIONALITY",

   849     SetupL, T_ServiceStateL, Teardown)

   850     

   851 EUNIT_TEST(

   852     "GetBrandInfoL - test ",

   853     "T_VimpstEngine",

   854     "GetBrandInfoL",

   855     "FUNCTIONALITY",

   856     SetupL, T_GetBrandInfoLL, Teardown)

   857     

   858 EUNIT_TEST(

   859     "IsSubServiceSupportedL - test ",

   860     "T_VimpstEngine",

   861     "IsSubServiceSupportedL",

   862     "FUNCTIONALITY",

   863     SetupL, T_IsSubServiceSupportedLL, Teardown)

   864     

   865 EUNIT_TEST(

   866     "IsSubServiceEnabled - test ",

   867     "T_VimpstEngine",

   868     "IsSubServiceEnabled",

   869     "FUNCTIONALITY",

   870     SetupL, T_IsSubServiceEnabledL, Teardown)

   871     

   872 EUNIT_TEST(

   873     "ContactStoreIdL - test ",

   874     "T_VimpstEngine",

   875     "ContactStoreIdL",

   876     "FUNCTIONALITY",

   877     SetupL, T_ContactStoreIdLL, Teardown)

   878     

   879 EUNIT_TEST(

   880     "RegisterServiceSessionObserverL",

   881     "T_VimpstEngine",

   882     "RegisterServiceSessionObserverL",

   883     "FUNCTIONALITY",

   884     SetupL, T_RegisterServiceSessionObserverLL, Teardown)

   885     

   886 EUNIT_TEST(

   887     "UnRegisterServiceSessionObserverL - test ",

   888     "T_VimpstEngine",

   889     "UnRegisterServiceSessionObserverL",

   890     "FUNCTIONALITY",

   891     SetupL, T_UnRegisterServiceSessionObserverLL, Teardown)

   892     

   893 EUNIT_TEST(

   894     "IntializeStorageL - test ",

   895     "T_VimpstEngine",

   896     "IntializeStorageL",

   897     "FUNCTIONALITY",

   898     SetupL, T_IntializeStorageLL, Teardown)

   899     

   900 EUNIT_TEST(

   901     "UnIntializeStorageL - test ",

   902     "T_VimpstEngine",

   903     "UnIntializeStorageL",

   904     "FUNCTIONALITY",

   905     SetupL, T_UnIntializeStorageLL, Teardown)

   906     

   907 /*EUNIT_TEST(

   908     "SetUserName - test ",

   909     "T_VimpstEngine",

   910     "SetUserName",

   911     "FUNCTIONALITY",

   912     SetupL, T_SetUserNameL, Teardown)

   913     

   914 EUNIT_TEST(

   915     "SetPassword - test ",

   916     "T_VimpstEngine",

   917     "SetPassword",

   918     "FUNCTIONALITY",

   919     SetupL, T_SetPasswordL, Teardown)

   920   */ 

   921  /*   

   922 EUNIT_TEST(

   923     "UserNameL - test ",

   924     "T_VimpstEngine",

   925     "UserNameL",

   926     "FUNCTIONALITY",

   927     SetupL, T_UserNameLL, Teardown)

   928     

   929 EUNIT_TEST(

   930     "PasswordL - test ",

   931     "T_VimpstEngine",

   932     "PasswordL",

   933     "FUNCTIONALITY",

   934     SetupL, T_PasswordLL, Teardown)

   935   */  

   936 EUNIT_TEST(

   937     "SubService - test ",

   938     "T_VimpstEngine",

   939     "SubService",

   940     "FUNCTIONALITY",

   941     SetupL, T_SubServiceL, Teardown)

   942     

   943 EUNIT_TEST(

   944     "ExtentionFeatures - test ",

   945     "T_VimpstEngine",

   946     "ExtentionFeatures",

   947     "FUNCTIONALITY",

   948     SetupL, T_ExtentionFeaturesL, Teardown)

   949     

   950 EUNIT_TEST(

   951     "AddExtentionFeaturesL - test ",

   952     "T_VimpstEngine",

   953     "AddExtentionFeaturesL",

   954     "FUNCTIONALITY",

   955     SetupL, T_AddExtentionFeaturesLL, Teardown)

   956     

   957 EUNIT_TEST(

   958     "RemoveExtentionFeatures - test ",

   959     "T_VimpstEngine",

   960     "RemoveExtentionFeatures",

   961     "FUNCTIONALITY",

   962     SetupL, T_RemoveExtentionFeaturesL, Teardown)

   963     

   964 EUNIT_TEST(

   965     "HandleServceConnectionEventL - test ",

   966     "T_VimpstEngine",

   967     "HandleServceConnectionEventL",

   968     "FUNCTIONALITY",

   969     SetupL, T_HandleServceConnectionEventLL, Teardown)

   970     

   971 EUNIT_TEST(

   972     "ParseGetServiceState - test ",

   973     "T_VimpstEngine",

   974     "ParseGetServiceState",

   975     "FUNCTIONALITY",

   976     SetupL, T_ParseGetServiceStateL, Teardown)

   977     

   978 EUNIT_TEST(

   979     "HandleContactFetchedL - test ",

   980     "T_VimpstEngine",

   981     "HandleContactFetchedL",

   982     "FUNCTIONALITY",

   983     SetupL, T_HandleContactFetchedLL, Teardown)

   984 /*    

   985 EUNIT_TEST(

   986     "HandleContactAddedL - test ",

   987     "T_VimpstEngine",

   988     "HandleContactAddedL",

   989     "FUNCTIONALITY",

   990     SetupL, T_HandleContactAddedLL, Teardown)

   991     

   992 EUNIT_TEST(

   993     "HandleContactDeletedL - test ",

   994     "T_VimpstEngine",

   995     "HandleContactDeletedL",

   996     "FUNCTIONALITY",

   997     SetupL, T_HandleContactDeletedLL, Teardown)

   998  */   

   999 EUNIT_TEST(

  1000     "CreateExtentionFeaturesL - test ",

  1001     "T_VimpstEngine",

  1002     "CreateExtentionFeaturesL",

  1003     "FUNCTIONALITY",

  1004     SetupL, T_CreateExtentionFeaturesLL, Teardown)

  1005 

  1006 /*

  1007 EUNIT_TEST(

  1008     "EmptySetPassword - test ",

  1009     "T_VimpstEngine",

  1010     "CreateExtentionFeaturesL",

  1011     "FUNCTIONALITY",

  1012     SetupL, T_EmptySetPassword, Teardown)*/

  1013 /*

  1014 EUNIT_TEST(

  1015     "EmptySetUserNameL - test ",

  1016     "T_VimpstEngine",

  1017     "CreateExtentionFeaturesL",

  1018     "FUNCTIONALITY",

  1019     SetupL, T_EmptySetUserNameL, Teardown)

  1020 

  1021 EUNIT_TEST(

  1022     "SetUserNameL - test ",

  1023     "T_VimpstEngine",

  1024     "CreateExtentionFeaturesL",

  1025     "FUNCTIONALITY",

  1026     SetupL, T_SetUserNameL, Teardown)

  1027 

  1028 EUNIT_TEST(

  1029     "WithDomainNameSetUserNameL - test ",

  1030     "T_VimpstEngine",

  1031     "CreateExtentionFeaturesL",

  1032     "FUNCTIONALITY",

  1033     SetupL, T_WithDomainNameSetUserNameL, Teardown)

  1034   */  

  1035 EUNIT_TEST(

  1036     "BlockSupported - test ",

  1037     "T_VimpstEngine",

  1038     "BlockSupported",

  1039     "FUNCTIONALITY",

  1040     SetupL, T_BlockSupported, Teardown)

  1041 

  1042 EUNIT_TEST(

  1043     "BlockNotSupported - test ",

  1044     "T_VimpstEngine",

  1045     "BlockNotSupported",

  1046     "FUNCTIONALITY",

  1047     SetupL, T_BlockNotSupported, Teardown)

  1048 

  1049 EUNIT_TEST(

  1050     "FetchBlockedList - test ",

  1051     "T_FetchBlockedListL",

  1052     "FetchBlockedList",

  1053     "FUNCTIONALITY",

  1054     SetupL, T_FetchBlockedListL, Teardown)

  1055 

  1056 EUNIT_TEST(

  1057     "RegisterBlockedListObserver - test ",

  1058     "T_RegisterBlockedListObserver",

  1059     "RegisterBlockedListObserver",

  1060     "FUNCTIONALITY",

  1061     SetupL, T_RegisterBlockedListObserver , Teardown)

  1062    

  1063 EUNIT_END_TESTCASE_TABLE

  1064 

  1065 //  END OF FILE