1 /*

     2 * Copyright (c) 2002-2005 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 the License "Symbian Foundation License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: The class handles the test case running.

    15 *

    16 *

    17 */

    18 

    19 

    20 

    21 // INCLUDE FILES

    22 #include    <e32std.h>

    23 #include    <flogger.h>

    24 #include 	"imerrors.h"

    25 #include    <CNTDEF.H>

    26 #include    "IMApiMTHandlers.h"

    27 #include    "TestRunner.h"

    28 #include 	"IMApiTest.h"

    29 #include 	"ParserUtils.h"

    30 

    31 _LIT( KImpsIMApiMTIniFile, "c:\\smoketest\\imapitest.ini" );

    32 _LIT8( KImpsSAP, "SAP" );

    33 _LIT8( KImpsUserID, "Userid" );

    34 _LIT8( KImpsPassword, "password" );

    35 _LIT8( KImpsClientid, "clientid" );

    36 _LIT8( KImpsIAP, "IAP" );

    37 _LIT8( KImpsUserid1, "userid1" );

    38 _LIT8( KImpsUserid2, "userid2" );

    39 

    40 void SetupSchedulerL()

    41     {

    42     // Create a scheduler

    43     CTestScheduler* scheduler = new( ELeave )CTestScheduler;

    44     CleanupStack::PushL( scheduler );

    45     CActiveScheduler::Install( scheduler );

    46     CleanupStack::Pop(); // scheduler

    47     }

    48 

    49 void CTestRunner::ReadIniFileL()

    50     {

    51     RFs myFs;

    52     TInt err = 0;

    53     TUint32 myTime = 0;

    54     TLex lex;

    55     err = myFs.Connect();

    56     //CleanupClosePushL( myFs );

    57     CImpsSettingFile* configFile = CImpsSettingFile::NewL( myFs );

    58     CleanupStack::PushL( configFile );

    59     TFileName fileN( KImpsIMApiMTIniFile );

    60     // Open config file

    61     TRAP( err, configFile->OpenL( fileN ) );

    62     User::LeaveIfError( err );

    63 

    64     TBuf<KImpsMaxSapLen> myPtr;

    65     TRAP( err, myPtr.Copy( configFile->KeyValueL( KImpsSAP ) ) );

    66     if ( !err )

    67         {

    68         iSapValue.Copy( myPtr );

    69         }

    70     TRAP( err, myPtr.Copy( configFile->KeyValueL( KImpsUserID ) ) );

    71     if ( !err )

    72         {

    73         iUserIdValue.Copy( myPtr );

    74         }

    75     TRAP( err, myPtr.Copy( configFile->KeyValueL( KImpsPassword ) ) );

    76     if ( !err )

    77         {

    78         iPassword.Copy( myPtr );

    79         }

    80     TRAP( err, myPtr.Copy( configFile->KeyValueL( KImpsClientid ) ) );

    81     if ( !err )

    82         {

    83         iClientId.Copy( myPtr );

    84         }

    85     TRAP( err, myPtr.Copy( configFile->KeyValueL( KImpsIAP ) ) );

    86     if ( !err )

    87         {

    88         lex.Assign( myPtr );

    89         lex.Val( myTime, EDecimal );

    90         iIAP = ( TInt ) myTime;

    91         }

    92     TRAP( err, myPtr.Copy( configFile->KeyValueL( KImpsUserid1 ) ) );

    93     if ( !err )

    94         {

    95         iUserId1.Copy( myPtr );

    96         }

    97     TRAP( err, myPtr.Copy( configFile->KeyValueL( KImpsUserid2 ) ) );

    98     if ( !err )

    99         {

   100         iUserId2.Copy( myPtr );

   101         }

   102     CleanupStack::PopAndDestroy( 1 );  // configFile

   103     }

   104 

   105 

   106 

   107 CTestRunner* CTestRunner::NewL()

   108     {

   109     CTestRunner* self = new ( ELeave ) CTestRunner();

   110     CleanupStack::PushL( self );

   111     self->ConstructL();

   112     CleanupStack::Pop(); //self

   113     return self;

   114     }

   115 

   116 void CTestRunner::ConstructL()

   117     {

   118     SetupSchedulerL();

   119     iCase = Login;

   120     iDatabase = CContactDatabase::OpenL();

   121     iImObserver = CIMApiClientHandler::NewL( iStatus );

   122     iConnObserver = CConnectionObserver::NewL( iStatus );

   123     ReadIniFileL();

   124 

   125     CActiveScheduler::Add( this );

   126     }

   127 

   128 CTestRunner::~CTestRunner()

   129     {

   130 

   131     if ( iOpenApi != NULL )

   132         {

   133         iOpenApi->UnregisterObserver();

   134         }

   135     CTestLogger1::Log( _L( "Test Case Number #16" ) );

   136     CTestLogger1::Log( _L( "CImConnection::UnregisterObserver" ) );

   137     if ( iOpenApi != NULL )

   138         {

   139         delete iOpenApi;

   140         iOpenApi = NULL;

   141         }

   142     if ( iImClient != NULL )

   143         {

   144         delete iImClient;

   145         iImClient = NULL;

   146         }

   147     if ( iConnObserver != NULL )

   148         {

   149         delete iConnObserver;

   150         iConnObserver = NULL;

   151         }

   152     if ( iImObserver != NULL )

   153         {

   154         delete iImObserver;

   155         iImObserver = NULL;

   156         }

   157     if ( iDatabase != NULL )

   158         {

   159         delete iDatabase;

   160         iDatabase = NULL;

   161         }

   162 

   163     }

   164 

   165 

   166 

   167 void CTestRunner::DoCancel()

   168     {

   169     // Complete the request with error

   170     TRequestStatus* s = &iStatus;

   171     User::RequestComplete( s, KErrCancel );

   172     }

   173 

   174 

   175 CTestRunner::CTestRunner()

   176         : CActive( 0 )

   177     {

   178     }

   179 

   180 

   181 void CTestRunner::StartRunL( TWhichCase aCase )

   182     {

   183     iCase = aCase;

   184     SetActive();

   185     TRequestStatus *s = &iStatus;

   186     User::RequestComplete( s, KErrNone );

   187     CActiveScheduler::Start();

   188     }

   189 

   190 void CTestRunner::RunL()

   191     {

   192     TInt errxx = 0;

   193     TRAP( errxx, DoRunL() );

   194     if ( errxx < 0 )

   195         {

   196         CActiveScheduler::Stop();

   197         }

   198     }

   199 

   200 

   201 void CTestRunner::DoRunL()

   202     {

   203     if ( iCase >= Finish )

   204         {

   205         Cancel();

   206         CActiveScheduler::Stop();

   207         return;

   208         }

   209 

   210     if ( iStatus != KErrNone )

   211         {

   212         Cancel();

   213         CActiveScheduler::Stop();

   214         return;

   215         }

   216     switch ( iCase )

   217         {

   218         case CreateImClient:

   219             {

   220             CreateInstanceL();			//NewL - instantiate the object

   221             RegisterConnObserverL();	//RegisterObserverL - register the observer methods

   222             LoadIMInterfaceL();			//CreateImClientL - get the IM interface

   223             }

   224         break;

   225         case InvalidLogin:

   226             {

   227             CreateInstanceL();

   228             RegisterConnObserverL();

   229             LoadIMInterfaceL();

   230             IMRegisterL();

   231             LoginL( _L( "InvalidUser" ) );

   232             }

   233         break;

   234         case Login:

   235             {

   236             CreateInstanceL();

   237             RegisterConnObserverL();

   238             LoadIMInterfaceL();

   239             IMRegisterL();

   240             LoginL( iUserIdValue );

   241             }

   242         break;

   243         case SendMessageValidUserId:

   244             {

   245             SendPToPValidUserIDL();

   246             }

   247         break;

   248         case SendMessageValidTwoUserId:

   249             {

   250             SendPToPValidTwoUserIDL();

   251             }

   252         break;

   253         case SendMessageValidContact:

   254             {

   255             SendPToPValidContactL();

   256             }

   257         break;

   258         case SendMessageValidTwoContact:

   259             {

   260             SendPToPValidTwoContactL();

   261             }

   262         break;

   263         case SendPToPContactContentType:

   264             {

   265             SendPToPContactContentTypeL();

   266             }

   267         break;

   268         case SendPToPUserIDContentType:

   269             {

   270             SendPToPUserIDContentTypeL();

   271             }

   272         break;

   273 

   274         case Logout:

   275             {

   276             QueryIMConnectionStatusL();

   277             }

   278         break;

   279         case CancelLogin:

   280             {

   281             CancelLoginL();

   282             }

   283         break;

   284         }

   285 

   286     iCase = Finish;

   287 

   288     return;

   289     }

   290 

   291 

   292 CContactIdArray* CTestRunner::GetWVContactIdsLC( )

   293     {

   294     _LIT( KWVStart, "" );

   295     // Specify in which fields search should be performed

   296     CContactItemFieldDef* fieldToSearchIn = new ( ELeave ) CContactItemFieldDef();

   297     CleanupStack::PushL( fieldToSearchIn );

   298     fieldToSearchIn->AppendL( KUidContactFieldVCardMapWV );

   299 

   300     // search in contact database

   301     CContactIdArray *array = iDatabase->FindLC( KWVStart, fieldToSearchIn );

   302     CleanupStack::Pop(); //>> array

   303     CleanupStack::PopAndDestroy(); //>> fieldToSearchIn

   304     CleanupStack::PushL( array );

   305 

   306     return array;

   307     }

   308 

   309 

   310 

   311 TInt CTestRunner::RegisterConnObserverL()

   312     {

   313     CTestLogger1::Log( _L( "Test Case Number #2" ) );

   314     TRAPD( err, iOpenApi->RegisterObserverL( iConnObserver ) );

   315     // Catch errors

   316     if ( err == KImApiGeneralError ) // -30133

   317         {

   318         iStatus = err; // Failed

   319         CTestLogger1::Log( _L( "CImConnection::RegisterObserverL - err=%d" ), err );

   320         }

   321     else

   322         {

   323         iStatus = KErrNone; //OK

   324         CTestLogger1::Log( _L( "CImConnection::RegisterObserverL - err=%d" ), err );

   325         }

   326     }

   327 

   328 

   329 TInt CTestRunner::CreateInstanceL()

   330     {

   331     CTestLogger1::Log( _L( "Test Case Number #1" ) );

   332     iOpenApi = CImConnection::NewL( iClientId );

   333     CTestLogger1::Log( _L( "CImConnection::NewL" ) );

   334     return KErrNone; //OK

   335     }

   336 

   337 

   338 TInt CTestRunner::LoadIMInterfaceL()

   339     {

   340     CTestLogger1::Log( _L( "Test Case Number #3" ) );

   341     TRAPD( err, iImClient = iOpenApi->CreateImClientL() );

   342     // Catch errrors

   343     if ( err == 0 )

   344         {

   345         iStatus = KErrNone; // OK

   346         CTestLogger1::Log( _L( "CreateImClientL - err=%d" ), err );

   347         }

   348     else

   349         {

   350         iStatus = err; // Failed

   351         CTestLogger1::Log( _L( "CreateImClientL - err=%d" ), err );

   352         }

   353     }

   354 

   355 

   356 TInt CTestRunner::IMRegisterL()

   357     {

   358     CTestLogger1::Log( _L( "Test Case Number #4" ) );

   359     TRAPD( err, iImClient -> RegisterObserverL( iImObserver ) );

   360     // Catch errors

   361     if ( err == KImApiGeneralError ) //- 30133

   362         {

   363         iStatus = err; // Failes

   364         CTestLogger1::Log( _L( "MImClient::RegisterObserverL - err=%d" ), err );

   365         }

   366     else

   367         {

   368         iStatus = KErrNone; //OK

   369         CTestLogger1::Log( _L( "MImClient::RegisterObserverL - err=%d" ), err );

   370         }

   371     }

   372 

   373 TInt CTestRunner::LoginL( const TDesC& aUserID )

   374     {

   375     if ( aUserID.Compare( _L( "InvalidUser" ) ) )

   376         CTestLogger1::Log( _L( "Test Case Number #6" ) );

   377     else

   378         {

   379         CTestLogger1::Log( _L( "Invalid Login" ) );

   380         CTestLogger1::Log( _L( "Test Case Number #5" ) );

   381         }

   382 

   383     if ( iSapValue.Size() == 0 || iPassword.Size() == 0 || aUserID.Size() == 0 )

   384         {

   385         iStatus = KErrNone;

   386         CTestLogger1::Log( _L( "Invalid login parametres" ) );

   387         Cancel();

   388         CActiveScheduler::Stop();

   389         return KErrNone;

   390         }

   391 

   392     TRAPD( err, iOpenApi->LoginL( iSapValue, aUserID, iPassword, iIAP ) );

   393     // Catch errors

   394     if ( err )

   395         {

   396         iStatus = err; // Failes

   397         CTestLogger1::Log( _L( "LoginL - err=%d" ), err );

   398         return err;

   399         }

   400     else

   401         {

   402         iStatus = KRequestPending;

   403         CTestLogger1::Log( _L( "LoginL - err=%d" ), err );

   404         SetActive();

   405         return KErrNone;

   406         }

   407     }

   408 

   409 TInt CTestRunner::SendPToPValidUserIDL()

   410     {

   411     CTestLogger1::Log( _L( "Test Case Number #7" ) );

   412     if ( iUserId1.Length() == 0 )

   413         {

   414         CTestLogger1::Log( _L( "SendPToPMessageL(ValidUserId) UserID1 is NULL " ) );

   415         iStatus = KErrNone;

   416         Cancel();

   417         CActiveScheduler::Stop();

   418         return KErrNone;

   419         }

   420     CDesCArray* userIds = new( ELeave ) CDesCArrayFlat( 1 ); // Create user list

   421     CleanupStack::PushL( userIds );

   422     userIds->AppendL( iUserId1 ); // Add one user

   423 

   424     _LIT( KContentType, "text/plain" ); // Message type

   425     _LIT( KMessage, "5. Hello In One Time Valid UserId" ); // Message

   426     TInt OpId = 0;

   427     // Send message

   428     TRAPD ( err, OpId = iImClient->SendPToPMessageL( iUserId1, KMessage ) );

   429     // Catch errors

   430     if ( err == KImApiErrInvalidUserId && OpId == 0 ) // KImApiErrInvalidUserId

   431         {

   432         CTestLogger1::Log( _L( "SendPToPMessageL(ValidUserId) - err=%d" ), err );

   433         CleanupStack::PopAndDestroy(); // userIds

   434         iStatus = err;

   435         return err;

   436         }

   437     else if ( err == KImApiGeneralError && OpId == 0 ) // General ImApi errror

   438         {

   439         CTestLogger1::Log( _L( "SendPToPMessageL(ValidUserId) - err=%d" ), err );

   440         CleanupStack::PopAndDestroy(); // userIds

   441         iStatus = err;

   442         return err;

   443         }

   444     else

   445         {

   446         CTestLogger1::Log( _L( "SendPToPMessageL(ValidUserId) - err=%d" ), err );

   447         CleanupStack::PopAndDestroy(); // userIds

   448         iStatus = KRequestPending;

   449         SetActive();

   450         return KErrNone;

   451         }

   452     }

   453 

   454 

   455 TInt CTestRunner::SendPToPValidTwoUserIDL()

   456     {

   457     CTestLogger1::Log( _L( "Test Case Number #8" ) );

   458     CDesCArray* userIds = new( ELeave ) CDesCArrayFlat( 2 ); // Create new user list

   459     CleanupStack::PushL( userIds );

   460     userIds->AppendL( iUserId1 ); // Add user 0 nok3

   461     userIds->AppendL( iUserId2 ); // Add user 1 nok5

   462 

   463     _LIT( KContentType, "text/plain" );

   464     _LIT( KMessage, "6. Hello In Two Times Valid UserId" );

   465     TInt OpId = 0;

   466     // Send Message

   467     TRAPD ( err, OpId = iImClient->SendPToPMessageL( *userIds, KMessage ) );

   468     // Catch errors

   469     if ( err == KImApiErrInvalidUserId && OpId == 0 ) // KImApiErrInvalidUserId

   470         {

   471         CTestLogger1::Log( _L( "SendPToPMessageL(ValidTwoUserIds) - err=%d" ), err );

   472         CleanupStack::PopAndDestroy(); // userIds

   473         iStatus = err;

   474         return err;

   475         }

   476     else if ( err == KImApiGeneralError && OpId == 0 ) // General ImApi errror

   477         {

   478         CTestLogger1::Log( _L( "SendPToPMessageL(ValidTwoUserIds) - err=%d" ), err );

   479         CleanupStack::PopAndDestroy(); // userIds

   480         iStatus = err;

   481         return err;

   482         }

   483     else

   484         {

   485         CTestLogger1::Log( _L( "SendPToPMessageL(ValidTwoUserIds) - err=%d" ), err );

   486         CleanupStack::PopAndDestroy(); // userIds

   487         iStatus = KRequestPending;

   488         SetActive();

   489         return KErrNone;

   490         }

   491     }

   492 

   493 

   494 TInt CTestRunner::SendPToPValidContactL()

   495     {

   496     CTestLogger1::Log( _L( "Test Case Number #9" ) );

   497     CContactIdArray* contactIDArray = GetWVContactIdsLC();

   498     if ( contactIDArray->Count() == 0 )

   499         {

   500         CTestLogger1::Log( _L( "Can not find WvContact ID" ) );

   501         CleanupStack::PopAndDestroy();

   502         iStatus = KErrNone;

   503         Cancel();

   504         CActiveScheduler::Stop();

   505         return KErrNone;

   506         }

   507     TInt OpId = 0;

   508     // Be sure that two contact is real WV contact

   509     // Select first contact

   510     TContactItemId& OmaContact = ( *contactIDArray )[0];

   511 

   512     //Add first contact

   513     CContactIdArray* myContactIds = CContactIdArray::NewL();

   514     myContactIds->AddL( OmaContact );

   515 

   516     // Check that we have only one contact

   517     TInt nuberofcontacts = myContactIds->Count();

   518     //CTestLogger1::Log( _L("nuberofcontacts =%d"), nuberofcontacts );

   519     //Send message to myContacts

   520     TRAPD( err, OpId = iImClient->SendPToPMessageL( OmaContact/*myContactIds*/, _L( "12. Hello One Valid Contact" ) ) );

   521     // Just checking return value

   522     if ( err == KImApiErrInvalidContactId && OpId == 0 ) // KImApiErrInvalidContactId and OperationId is 0

   523         {

   524         CTestLogger1::Log( _L( "SendPToPMessageL(ValidContact) - err=%d" ), err );

   525         CleanupStack::PopAndDestroy();

   526         iStatus = KErrNone;

   527         Cancel();

   528         CActiveScheduler::Stop();

   529         return err;

   530         }

   531     else if ( err == KImApiGeneralError && OpId == 0 ) // General ImApi error

   532         {

   533         CTestLogger1::Log( _L( "SendPToPMessageL(ValidContact) - err=%d" ), err );

   534         CleanupStack::PopAndDestroy(); // userIds

   535         iStatus = err;

   536         return err;

   537         }

   538     else

   539         {

   540         CTestLogger1::Log( _L( "SendPToPMessageL(ValidContact) - err=%d" ), err );

   541         CleanupStack::PopAndDestroy();

   542         iStatus = KRequestPending;

   543         SetActive();

   544         return KErrNone; //OpId;

   545         }

   546     }

   547 

   548 

   549 TInt CTestRunner::SendPToPValidTwoContactL()

   550     {

   551     CTestLogger1::Log( _L( "Test Case Number #10" ) );

   552     CContactIdArray* contactIDArray = GetWVContactIdsLC();

   553     TInt OpId = 0;

   554     // Be sure that two contact is real WV contact

   555     //Is there three contacts

   556     TInt nuberofcontacts = contactIDArray->Count();

   557     if ( contactIDArray->Count() == 0 )

   558         {

   559         CTestLogger1::Log( _L( "Can not find WvContact ID" ) );

   560         CleanupStack::PopAndDestroy();

   561         iStatus = KErrNone;

   562         Cancel();

   563         CActiveScheduler::Stop();

   564         return KErrNone;

   565         }

   566     // Remove third contact

   567     // Never commit the reset

   568     if ( contactIDArray->Count() >= 3 )

   569         {

   570         contactIDArray->Remove( 2 );

   571         }

   572 

   573 

   574     // Check if Remove is OK

   575     TRAPD( err1, OpId = iImClient->SendPToPMessageL( *contactIDArray, _L( "text/plain" ), _L8( "Hello All" ) ) );

   576 

   577     //Send message

   578     TRAPD( err, OpId = iImClient->SendPToPMessageL( *contactIDArray, _L( "13. Hello In Two Times Valid Contact" ) ) );

   579 

   580     // Just checking return value

   581     if ( err == KImApiErrInvalidContactId && OpId == 0 ) // KImApiErrInvalidContactId and OperationId is 0

   582         {

   583         CTestLogger1::Log( _L( "SendPToPMessageL(ValidTwoContact) - err=%d" ), err );

   584         CleanupStack::PopAndDestroy();

   585         iStatus = KErrNone;

   586         Cancel();

   587         CActiveScheduler::Stop();

   588         return err;

   589         }

   590     else if ( err == KImApiGeneralError && OpId == 0 ) // General ImApi error

   591         {

   592         CTestLogger1::Log( _L( "SendPToPMessageL(ValidTwoContact) - err=%d" ), err );

   593         CleanupStack::PopAndDestroy(); // userIds

   594         iStatus = err;

   595         return err;

   596         }

   597     else

   598         {

   599         CTestLogger1::Log( _L( "SendPToPMessageL(ValidTwoContact) - err=%d" ), err );

   600         CleanupStack::PopAndDestroy();

   601         iStatus = KRequestPending;

   602         SetActive();

   603         return KErrNone; // OpId;

   604         }

   605     }

   606 

   607 TInt CTestRunner::SendPToPContactContentTypeL()

   608     {

   609     //This SDK API is not supported. Test case is added to increase the code coverage

   610     CTestLogger1::Log( _L( "Test Case Number #11" ) );

   611     CTestLogger1::Log( _L( "SendPToPContactContentTypeL" ) );

   612     TInt OpId = 0;

   613     CContactIdArray* contactIDArray = GetWVContactIdsLC();

   614     if ( contactIDArray->Count() == 0 )

   615         {

   616         CTestLogger1::Log( _L( "Can not find WvContact ID" ) );

   617         CleanupStack::PopAndDestroy();

   618         iStatus = KErrNone;

   619         Cancel();

   620         CActiveScheduler::Stop();

   621         return KErrNone;

   622         }

   623     TRAPD( err, OpId = iImClient->SendPToPMessageL( *contactIDArray, _L( "text/plain" ), _L8( "Hello All" ) ) );

   624     CleanupStack::PopAndDestroy(); // userIds

   625     iStatus = err;

   626     Cancel();

   627     CActiveScheduler::Stop();

   628     return err;

   629     }

   630 

   631 TInt CTestRunner::SendPToPUserIDContentTypeL()

   632     {

   633     //This SDK API is not supported. Test case is added to increase the code coverage

   634     CTestLogger1::Log( _L( "Test Case Number #12" ) );

   635     CTestLogger1::Log( _L( "SendPToPUserIDContentTypeL" ) );

   636     TInt OpId = 0;

   637     CDesCArray* userIds = new( ELeave ) CDesCArrayFlat( 2 );

   638     CleanupStack::PushL( userIds );

   639 

   640     TRAPD( err, OpId = iImClient->SendPToPMessageL( *userIds, _L( "text/plain" ), _L8( "Hello All" ) ) );

   641     CleanupStack::PopAndDestroy(); // userIds

   642     iStatus = err;

   643     Cancel();

   644     CActiveScheduler::Stop();

   645     return err;

   646     }

   647 

   648 

   649 TInt CTestRunner::QueryIMConnectionStatusL()

   650     {

   651     CTestLogger1::Log( _L( "Test Case Number #13" ) );

   652     TInt ret = iOpenApi->ImConnectionStatus();

   653     // Check returnvalue

   654     if ( ret == 0 ) // iLoggedIn

   655         {

   656         CTestLogger1::Log( _L( "LogoutL" ) );

   657         iOpenApi->LogoutL();

   658         iStatus = KErrNone;

   659         return 0;

   660         }

   661     else // 1

   662         {

   663         iStatus = KErrNone;

   664         Cancel();

   665         CActiveScheduler::Stop();

   666         return ret;

   667         }

   668     }

   669 

   670 

   671 TInt CTestRunner::CancelLoginL()

   672     {

   673     CTestLogger1::Log( _L( "Test Case Number #14" ) );

   674     LoginL( iUserIdValue );

   675     TRAPD ( err, iOpenApi->CancelLoginL() );

   676     CTestLogger1::Log( _L( "CancelLoginL - err=%d" ), err );

   677     iImClient->UnregisterObserver();

   678     CTestLogger1::Log( _L( "Test Case Number #15" ) );

   679     CTestLogger1::Log( _L( "CImClient::UnregisterObserver" ) );

   680     }

   681 

   682 //**********************************

   683 // Logger

   684 //**********************************

   685 const TInt KLogBufferLength = 256;

   686 _LIT( KLogDir, "impsc" );

   687 _LIT( KLogFile, "IMAPITestCaseLog.txt" );

   688 

   689 EXPORT_C void CTestLogger1::Log( TRefByValue<const TDesC> aFmt, ... )

   690     {

   691     VA_LIST list;

   692     VA_START( list, aFmt );

   693 

   694     // Print to log file

   695     TBuf<KLogBufferLength> buf;

   696     buf.FormatList( aFmt, list );

   697 

   698     // Write to log file

   699     RFileLogger::Write( KLogDir, KLogFile, EFileLoggingModeAppend, buf );

   700     }

   701