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 "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: 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:\\TestFramework\\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 InvalidLogin:

   219             {

   220             CreateInstanceL();

   221             RegisterConnObserverL();

   222             LoadIMInterfaceL();

   223             IMRegisterL();

   224             LoginL( _L( "InvalidUser" ) );

   225             }

   226         break;

   227         case Login:

   228             {

   229             LoginL( iUserIdValue );

   230             }

   231         break;

   232         case SendMessageValidUserId:

   233             {

   234             SendPToPValidUserIDL();

   235             }

   236         break;

   237         case SendMessageValidTwoUserId:

   238             {

   239             SendPToPValidTwoUserIDL();

   240             }

   241         break;

   242         case SendMessageValidContact:

   243             {

   244             SendPToPValidContactL();

   245             }

   246         break;

   247         case SendMessageValidTwoContact:

   248             {

   249             SendPToPValidTwoContactL();

   250             }

   251         break;

   252         case SendPToPContactContentType:

   253             {

   254             SendPToPContactContentTypeL();

   255             }

   256         break;

   257         case SendPToPUserIDContentType:

   258             {

   259             SendPToPUserIDContentTypeL();

   260             }

   261         break;

   262 

   263         case Logout:

   264             {

   265             QueryIMConnectionStatusL();

   266             }

   267         break;

   268         case CancelLogin:

   269             {

   270             CancelLoginL();

   271             }

   272         break;

   273         }

   274 

   275     iCase = Finish;

   276 

   277     return;

   278     }

   279 

   280 

   281 CContactIdArray* CTestRunner::GetWVContactIdsLC( )

   282     {

   283     _LIT( KWVStart, "" );

   284     // Specify in which fields search should be performed

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

   286     CleanupStack::PushL( fieldToSearchIn );

   287     fieldToSearchIn->AppendL( KUidContactFieldVCardMapWV );

   288 

   289     // search in contact database

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

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

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

   293     CleanupStack::PushL( array );

   294 

   295     return array;

   296     }

   297 

   298 

   299 

   300 TInt CTestRunner::RegisterConnObserverL()

   301     {

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

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

   304     // Catch errors

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

   306         {

   307         iStatus = err; // Failed

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

   309         }

   310     else

   311         {

   312         iStatus = KErrNone; //OK

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

   314         }

   315     }

   316 

   317 

   318 TInt CTestRunner::CreateInstanceL()

   319     {

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

   321     iOpenApi = CImConnection::NewL( iClientId );

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

   323     return KErrNone; //OK

   324     }

   325 

   326 

   327 TInt CTestRunner::LoadIMInterfaceL()

   328     {

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

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

   331     // Catch errrors

   332     if ( err == 0 )

   333         {

   334         iStatus = KErrNone; // OK

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

   336         }

   337     else

   338         {

   339         iStatus = err; // Failed

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

   341         }

   342     }

   343 

   344 

   345 TInt CTestRunner::IMRegisterL()

   346     {

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

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

   349     // Catch errors

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

   351         {

   352         iStatus = err; // Failes

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

   354         }

   355     else

   356         {

   357         iStatus = KErrNone; //OK

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

   359         }

   360     }

   361 

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

   363     {

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

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

   366     else

   367         {

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

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

   370         }

   371 

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

   373         {

   374         iStatus = KErrNone;

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

   376         Cancel();

   377         CActiveScheduler::Stop();

   378         return KErrNone;

   379         }

   380 

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

   382     // Catch errors

   383     if ( err )

   384         {

   385         iStatus = err; // Failes

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

   387         return err;

   388         }

   389     else

   390         {

   391         iStatus = KRequestPending;

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

   393         SetActive();

   394         return KErrNone;

   395         }

   396     }

   397 

   398 TInt CTestRunner::SendPToPValidUserIDL()

   399     {

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

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

   402         {

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

   404         iStatus = KErrNone;

   405         Cancel();

   406         CActiveScheduler::Stop();

   407         return KErrNone;

   408         }

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

   410     CleanupStack::PushL( userIds );

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

   412 

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

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

   415     TInt OpId = 0;

   416     // Send message

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

   418     // Catch errors

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

   420         {

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

   422         CleanupStack::PopAndDestroy(); // userIds

   423         iStatus = err;

   424         return err;

   425         }

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

   427         {

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

   429         CleanupStack::PopAndDestroy(); // userIds

   430         iStatus = err;

   431         return err;

   432         }

   433     else

   434         {

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

   436         CleanupStack::PopAndDestroy(); // userIds

   437         iStatus = KRequestPending;

   438         SetActive();

   439         return KErrNone;

   440         }

   441     }

   442 

   443 

   444 TInt CTestRunner::SendPToPValidTwoUserIDL()

   445     {

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

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

   448     CleanupStack::PushL( userIds );

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

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

   451 

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

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

   454     TInt OpId = 0;

   455     // Send Message

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

   457     // Catch errors

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

   459         {

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

   461         CleanupStack::PopAndDestroy(); // userIds

   462         iStatus = err;

   463         return err;

   464         }

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

   466         {

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

   468         CleanupStack::PopAndDestroy(); // userIds

   469         iStatus = err;

   470         return err;

   471         }

   472     else

   473         {

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

   475         CleanupStack::PopAndDestroy(); // userIds

   476         iStatus = KRequestPending;

   477         SetActive();

   478         return KErrNone;

   479         }

   480     }

   481 

   482 

   483 TInt CTestRunner::SendPToPValidContactL()

   484     {

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

   486     CContactIdArray* contactIDArray = GetWVContactIdsLC();

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

   488         {

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

   490         CleanupStack::PopAndDestroy();

   491         iStatus = KErrNone;

   492         Cancel();

   493         CActiveScheduler::Stop();

   494         return KErrNone;

   495         }

   496     TInt OpId = 0;

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

   498     // Select first contact

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

   500 

   501     //Add first contact

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

   503     myContactIds->AddL( OmaContact );

   504 

   505     // Check that we have only one contact

   506     TInt nuberofcontacts = myContactIds->Count();

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

   508     //Send message to myContacts

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

   510     // Just checking return value

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

   512         {

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

   514         CleanupStack::PopAndDestroy();

   515         iStatus = KErrNone;

   516         Cancel();

   517         CActiveScheduler::Stop();

   518         return err;

   519         }

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

   521         {

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

   523         CleanupStack::PopAndDestroy(); // userIds

   524         iStatus = err;

   525         return err;

   526         }

   527     else

   528         {

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

   530         CleanupStack::PopAndDestroy();

   531         iStatus = KRequestPending;

   532         SetActive();

   533         return KErrNone; //OpId;

   534         }

   535     }

   536 

   537 

   538 TInt CTestRunner::SendPToPValidTwoContactL()

   539     {

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

   541     CContactIdArray* contactIDArray = GetWVContactIdsLC();

   542     TInt OpId = 0;

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

   544     //Is there three contacts

   545     TInt nuberofcontacts = contactIDArray->Count();

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

   547         {

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

   549         CleanupStack::PopAndDestroy();

   550         iStatus = KErrNone;

   551         Cancel();

   552         CActiveScheduler::Stop();

   553         return KErrNone;

   554         }

   555     // Remove third contact

   556     // Never commit the reset

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

   558         {

   559         contactIDArray->Remove( 2 );

   560         }

   561 

   562 

   563     // Check if Remove is OK

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

   565 

   566     //Send message

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

   568 

   569     // Just checking return value

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

   571         {

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

   573         CleanupStack::PopAndDestroy();

   574         iStatus = KErrNone;

   575         Cancel();

   576         CActiveScheduler::Stop();

   577         return err;

   578         }

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

   580         {

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

   582         CleanupStack::PopAndDestroy(); // userIds

   583         iStatus = err;

   584         return err;

   585         }

   586     else

   587         {

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

   589         CleanupStack::PopAndDestroy();

   590         iStatus = KRequestPending;

   591         SetActive();

   592         return KErrNone; // OpId;

   593         }

   594     }

   595 

   596 TInt CTestRunner::SendPToPContactContentTypeL()

   597     {

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

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

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

   601     TInt OpId = 0;

   602     CContactIdArray* contactIDArray = GetWVContactIdsLC();

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

   604         {

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

   606         CleanupStack::PopAndDestroy();

   607         iStatus = KErrNone;

   608         Cancel();

   609         CActiveScheduler::Stop();

   610         return KErrNone;

   611         }

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

   613     CleanupStack::PopAndDestroy(); // userIds

   614     iStatus = err;

   615     Cancel();

   616     CActiveScheduler::Stop();

   617     return err;

   618     }

   619 

   620 TInt CTestRunner::SendPToPUserIDContentTypeL()

   621     {

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

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

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

   625     TInt OpId = 0;

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

   627     CleanupStack::PushL( userIds );

   628 

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

   630     CleanupStack::PopAndDestroy(); // userIds

   631     iStatus = err;

   632     Cancel();

   633     CActiveScheduler::Stop();

   634     return err;

   635     }

   636 

   637 

   638 TInt CTestRunner::QueryIMConnectionStatusL()

   639     {

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

   641     TInt ret = iOpenApi->ImConnectionStatus();

   642     // Check returnvalue

   643     if ( ret == 0 ) // iLoggedIn

   644         {

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

   646         iOpenApi->LogoutL();

   647         iStatus = KErrNone;

   648         return 0;

   649         }

   650     else // 1

   651         {

   652         iStatus = KErrNone;

   653         Cancel();

   654         CActiveScheduler::Stop();

   655         return ret;

   656         }

   657     }

   658 

   659 

   660 TInt CTestRunner::CancelLoginL()

   661     {

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

   663     LoginL( iUserIdValue );

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

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

   666     iImClient->UnregisterObserver();

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

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

   669     }

   670 

   671 //**********************************

   672 // Logger

   673 //**********************************

   674 const TInt KLogBufferLength = 256;

   675 _LIT( KLogDir, "impsc" );

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

   677 

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

   679     {

   680     VA_LIST list;

   681     VA_START( list, aFmt );

   682 

   683     // Print to log file

   684     TBuf<KLogBufferLength> buf;

   685     buf.FormatList( aFmt, list );

   686 

   687     // Write to log file

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

   689     }

   690