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             CreateInstanceL();

   230             RegisterConnObserverL();

   231             LoadIMInterfaceL();

   232             IMRegisterL();

   233             LoginL( iUserIdValue );

   234             }

   235         break;

   236         case SendMessageValidUserId:

   237             {

   238             SendPToPValidUserIDL();

   239             }

   240         break;

   241         case SendMessageValidTwoUserId:

   242             {

   243             SendPToPValidTwoUserIDL();

   244             }

   245         break;

   246         case SendMessageValidContact:

   247             {

   248             SendPToPValidContactL();

   249             }

   250         break;

   251         case SendMessageValidTwoContact:

   252             {

   253             SendPToPValidTwoContactL();

   254             }

   255         break;

   256         case SendPToPContactContentType:

   257             {

   258             SendPToPContactContentTypeL();

   259             }

   260         break;

   261         case SendPToPUserIDContentType:

   262             {

   263             SendPToPUserIDContentTypeL();

   264             }

   265         break;

   266 

   267         case Logout:

   268             {

   269             QueryIMConnectionStatusL();

   270             }

   271         break;

   272         case CancelLogin:

   273             {

   274             CancelLoginL();

   275             }

   276         break;

   277         }

   278 

   279     iCase = Finish;

   280 

   281     return;

   282     }

   283 

   284 

   285 CContactIdArray* CTestRunner::GetWVContactIdsLC( )

   286     {

   287     _LIT( KWVStart, "" );

   288     // Specify in which fields search should be performed

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

   290     CleanupStack::PushL( fieldToSearchIn );

   291     fieldToSearchIn->AppendL( KUidContactFieldVCardMapWV );

   292 

   293     // search in contact database

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

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

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

   297     CleanupStack::PushL( array );

   298 

   299     return array;

   300     }

   301 

   302 

   303 

   304 TInt CTestRunner::RegisterConnObserverL()

   305     {

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

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

   308     // Catch errors

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

   310         {

   311         iStatus = err; // Failed

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

   313         }

   314     else

   315         {

   316         iStatus = KErrNone; //OK

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

   318         }

   319     }

   320 

   321 

   322 TInt CTestRunner::CreateInstanceL()

   323     {

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

   325     iOpenApi = CImConnection::NewL( iClientId );

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

   327     return KErrNone; //OK

   328     }

   329 

   330 

   331 TInt CTestRunner::LoadIMInterfaceL()

   332     {

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

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

   335     // Catch errrors

   336     if ( err == 0 )

   337         {

   338         iStatus = KErrNone; // OK

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

   340         }

   341     else

   342         {

   343         iStatus = err; // Failed

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

   345         }

   346     }

   347 

   348 

   349 TInt CTestRunner::IMRegisterL()

   350     {

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

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

   353     // Catch errors

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

   355         {

   356         iStatus = err; // Failes

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

   358         }

   359     else

   360         {

   361         iStatus = KErrNone; //OK

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

   363         }

   364     }

   365 

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

   367     {

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

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

   370     else

   371         {

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

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

   374         }

   375 

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

   377         {

   378         iStatus = KErrNone;

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

   380         Cancel();

   381         CActiveScheduler::Stop();

   382         return KErrNone;

   383         }

   384 

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

   386     // Catch errors

   387     if ( err )

   388         {

   389         iStatus = err; // Failes

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

   391         return err;

   392         }

   393     else

   394         {

   395         iStatus = KRequestPending;

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

   397         SetActive();

   398         return KErrNone;

   399         }

   400     }

   401 

   402 TInt CTestRunner::SendPToPValidUserIDL()

   403     {

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

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

   406         {

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

   408         iStatus = KErrNone;

   409         Cancel();

   410         CActiveScheduler::Stop();

   411         return KErrNone;

   412         }

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

   414     CleanupStack::PushL( userIds );

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

   416 

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

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

   419     TInt OpId = 0;

   420     // Send message

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

   422     // Catch errors

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

   424         {

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

   426         CleanupStack::PopAndDestroy(); // userIds

   427         iStatus = err;

   428         return err;

   429         }

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

   431         {

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

   433         CleanupStack::PopAndDestroy(); // userIds

   434         iStatus = err;

   435         return err;

   436         }

   437     else

   438         {

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

   440         CleanupStack::PopAndDestroy(); // userIds

   441         iStatus = KRequestPending;

   442         SetActive();

   443         return KErrNone;

   444         }

   445     }

   446 

   447 

   448 TInt CTestRunner::SendPToPValidTwoUserIDL()

   449     {

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

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

   452     CleanupStack::PushL( userIds );

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

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

   455 

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

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

   458     TInt OpId = 0;

   459     // Send Message

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

   461     // Catch errors

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

   463         {

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

   465         CleanupStack::PopAndDestroy(); // userIds

   466         iStatus = err;

   467         return err;

   468         }

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

   470         {

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

   472         CleanupStack::PopAndDestroy(); // userIds

   473         iStatus = err;

   474         return err;

   475         }

   476     else

   477         {

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

   479         CleanupStack::PopAndDestroy(); // userIds

   480         iStatus = KRequestPending;

   481         SetActive();

   482         return KErrNone;

   483         }

   484     }

   485 

   486 

   487 TInt CTestRunner::SendPToPValidContactL()

   488     {

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

   490     CContactIdArray* contactIDArray = GetWVContactIdsLC();

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

   492         {

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

   494         CleanupStack::PopAndDestroy();

   495         iStatus = KErrNone;

   496         Cancel();

   497         CActiveScheduler::Stop();

   498         return KErrNone;

   499         }

   500     TInt OpId = 0;

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

   502     // Select first contact

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

   504 

   505     //Add first contact

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

   507     myContactIds->AddL( OmaContact );

   508 

   509     // Check that we have only one contact

   510     TInt nuberofcontacts = myContactIds->Count();

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

   512     //Send message to myContacts

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

   514     // Just checking return value

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

   516         {

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

   518         CleanupStack::PopAndDestroy();

   519         iStatus = KErrNone;

   520         Cancel();

   521         CActiveScheduler::Stop();

   522         return err;

   523         }

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

   525         {

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

   527         CleanupStack::PopAndDestroy(); // userIds

   528         iStatus = err;

   529         return err;

   530         }

   531     else

   532         {

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

   534         CleanupStack::PopAndDestroy();

   535         iStatus = KRequestPending;

   536         SetActive();

   537         return KErrNone; //OpId;

   538         }

   539     }

   540 

   541 

   542 TInt CTestRunner::SendPToPValidTwoContactL()

   543     {

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

   545     CContactIdArray* contactIDArray = GetWVContactIdsLC();

   546     TInt OpId = 0;

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

   548     //Is there three contacts

   549     TInt nuberofcontacts = contactIDArray->Count();

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

   551         {

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

   553         CleanupStack::PopAndDestroy();

   554         iStatus = KErrNone;

   555         Cancel();

   556         CActiveScheduler::Stop();

   557         return KErrNone;

   558         }

   559     // Remove third contact

   560     // Never commit the reset

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

   562         {

   563         contactIDArray->Remove( 2 );

   564         }

   565 

   566 

   567     // Check if Remove is OK

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

   569 

   570     //Send message

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

   572 

   573     // Just checking return value

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

   575         {

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

   577         CleanupStack::PopAndDestroy();

   578         iStatus = KErrNone;

   579         Cancel();

   580         CActiveScheduler::Stop();

   581         return err;

   582         }

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

   584         {

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

   586         CleanupStack::PopAndDestroy(); // userIds

   587         iStatus = err;

   588         return err;

   589         }

   590     else

   591         {

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

   593         CleanupStack::PopAndDestroy();

   594         iStatus = KRequestPending;

   595         SetActive();

   596         return KErrNone; // OpId;

   597         }

   598     }

   599 

   600 TInt CTestRunner::SendPToPContactContentTypeL()

   601     {

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

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

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

   605     TInt OpId = 0;

   606     CContactIdArray* contactIDArray = GetWVContactIdsLC();

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

   608         {

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

   610         CleanupStack::PopAndDestroy();

   611         iStatus = KErrNone;

   612         Cancel();

   613         CActiveScheduler::Stop();

   614         return KErrNone;

   615         }

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

   617     CleanupStack::PopAndDestroy(); // userIds

   618     iStatus = err;

   619     Cancel();

   620     CActiveScheduler::Stop();

   621     return err;

   622     }

   623 

   624 TInt CTestRunner::SendPToPUserIDContentTypeL()

   625     {

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

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

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

   629     TInt OpId = 0;

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

   631     CleanupStack::PushL( userIds );

   632 

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

   634     CleanupStack::PopAndDestroy(); // userIds

   635     iStatus = err;

   636     Cancel();

   637     CActiveScheduler::Stop();

   638     return err;

   639     }

   640 

   641 

   642 TInt CTestRunner::QueryIMConnectionStatusL()

   643     {

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

   645     TInt ret = iOpenApi->ImConnectionStatus();

   646     // Check returnvalue

   647     if ( ret == 0 ) // iLoggedIn

   648         {

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

   650         iOpenApi->LogoutL();

   651         iStatus = KErrNone;

   652         return 0;

   653         }

   654     else // 1

   655         {

   656         iStatus = KErrNone;

   657         Cancel();

   658         CActiveScheduler::Stop();

   659         return ret;

   660         }

   661     }

   662 

   663 

   664 TInt CTestRunner::CancelLoginL()

   665     {

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

   667     LoginL( iUserIdValue );

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

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

   670     iImClient->UnregisterObserver();

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

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

   673     }

   674 

   675 //**********************************

   676 // Logger

   677 //**********************************

   678 const TInt KLogBufferLength = 256;

   679 _LIT( KLogDir, "impsc" );

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

   681 

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

   683     {

   684     VA_LIST list;

   685     VA_START( list, aFmt );

   686 

   687     // Print to log file

   688     TBuf<KLogBufferLength> buf;

   689     buf.FormatList( aFmt, list );

   690 

   691     // Write to log file

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

   693     }

   694