1 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include <s32file.h>

    17 #include <e32math.h>

    18 #include <logview.h>

    19 #include <s32mem.h> 

    20 #include "TEST.H"

    21 

    22 #define UNUSED_VAR(a) a = a

    23 

    24 #undef test  //there is a "test" macro which hides "RTest test" declaration.

    25 

    26 const TLogContactItemId KTestContact = 0x1234;

    27 const TInt KTestEventNum = 10;

    28 

    29 RTest test(_L("Log Client Basic API Test Harness"));

    30 

    31 const TUid KTestEventUid = {0x10005393};

    32 _LIT(KTestEventDesc1, "Event Type Description");

    33 _LIT(KTestEventDesc2, "Changed Event Description");

    34 _LIT(KTestRemoteParty1, "Remote Party");

    35 _LIT(KTestRemoteParty2, "Changed Remote Party");

    36 _LIT(KTestDirection1, "Direction");

    37 _LIT(KTestDirection2, "Changed Direction");

    38 const TLogDurationType KTestDurationType1 = 1;

    39 const TLogDurationType KTestDurationType2 = 2;

    40 const TLogDuration KTestDuration1 = 0x1234;

    41 const TLogDuration KTestDuration2 = 0x1234567;

    42 _LIT(KTestStatus1, "Status");

    43 _LIT(KTestStatus2, "Changed Status");

    44 _LIT(KTestSubject1, "Subject");

    45 _LIT(KTestSubject2, "Changed Subject");

    46 _LIT(KTestNumber1, "TheNumber");

    47 _LIT(KTestNumber2, "Changed Number");

    48 const TLogContactItemId KTestContact1 = 0x1234;

    49 const TLogContactItemId KTestContact2 = 0x1234567;

    50 const TLogLink KTestLink1 = 0x1234;

    51 const TLogLink KTestLink2 = 0x1234567;

    52 _LIT8(KTestData1, "ABCDEFGH");

    53 _LIT8(KTestData2, "IJKLMNOPQRSTUVWXYZ");

    54 const TLogFlags KTestFlags1 = 0x5;

    55 const TLogFlags KTestFlags2 = 0xA;

    56 const TLogSize KTestMaxLogSize = 0xFFF;

    57 const TLogRecentSize KTestMaxRecentLogSize = 0xF;

    58 const TLogAge KTestMaxEventAge = 0xFFFFFFF;

    59 

    60 TInt gTheId;

    61 

    62 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    63 ////////////////////  Thread panic macros   ////////////////////////////////////////////////////////////////////////

    64 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    65 

    66 static void ThrCheck1(TInt aValue, TInt aLine)

    67 	{

    68 	if(!aValue)

    69 		{

    70 		RDebug::Print(_L("*** Line %d. Boolean expression evaluated to false!\r\n"), aLine);

    71 		User::Panic(_L("ThrChk1"), 1);

    72 		}

    73 	}

    74 

    75 static void ThrCheck2(TInt aValue, TInt aExpected, TInt aLine)

    76 	{

    77 	if(aValue != aExpected)

    78 		{

    79 		RDebug::Print(_L("*** Line %d. Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue);

    80 		User::Panic(_L("ThrChk2"), 2);

    81 		}

    82 	}

    83 

    84 #define TTEST(arg) ThrCheck1((arg), __LINE__)

    85 #define TTEST2(aValue, aExpected) ThrCheck2(aValue, aExpected, __LINE__)

    86 

    87 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    88 

    89 class TClientObserverTestReceiver : public MLogClientChangeObserver

    90 	{

    91 public:

    92 	TClientObserverTestReceiver(TBool& aFlag) : iCallCount(0), iFlag(aFlag) { }

    93 

    94 public:

    95 	void HandleLogClientChangeEventL(TUid aChangeType, TInt /*aChangeParam1*/, TInt /*aChangeParam2*/, TInt /*aChangeParam3*/)

    96 		{

    97 		++iCallCount;

    98 		iFlag = (aChangeType == KLogClientChangeEventLogCleared);

    99 		}

   100 	inline TInt CallCount() const { return iCallCount; }

   101 	inline void Reset() { iCallCount = 0; iFlag = EFalse; }

   102 

   103 private:

   104 	TInt iCallCount;

   105 	TBool& iFlag;

   106 	};

   107 

   108 /**

   109 @SYMTestCaseID          SYSLIB-LOGENG-CT-0833

   110 @SYMTestCaseDesc	    Client observer mechanism test

   111 @SYMTestPriority 	    High

   112 @SYMTestActions  	    Set the change observer,add an event type,clear the log and test for the status.

   113 @SYMTestExpectedResults Test must not fail

   114 @SYMREQ                 REQ0000

   115 */

   116 LOCAL_C void TestClientObserverMechanismL(CLogClient& aClient)

   117 	{	

   118 	//

   119 	TBool logClearedFlag = EFalse;

   120 	TClientObserverTestReceiver testReceiver(logClearedFlag);

   121 	//

   122 	aClient.SetGlobalChangeObserverL(&testReceiver);

   123 

   124 	TTime now;

   125 	now.UniversalTime();

   126 	TTime clearLogThreshold(now);

   127 	clearLogThreshold -= TTimeIntervalDays(1);

   128 	TTime past(now);

   129 	past -= TTimeIntervalDays(2);

   130 

   131 	// Make some events

   132 	CLogEvent* event = CLogEvent::NewL();

   133 	CleanupStack::PushL(event);

   134 	CTestActive* active = new(ELeave)CTestActive();

   135 	CleanupStack::PushL(active);

   136 	for(TInt i=0; i<10; i++)

   137 		{

   138 		event->SetEventType(KLogCallEventTypeUid);

   139 		event->SetRemoteParty(KTestRemoteParty1);

   140 		event->SetDirection(KTestDirection1);

   141 		event->SetDurationType(KTestDurationType1);

   142 		event->SetDuration(KTestDuration1);

   143 		event->SetStatus(KTestStatus1);

   144 		event->SetSubject(KTestSubject1);

   145 		event->SetNumber(KTestNumber1);

   146 		event->SetContact((TLogContactItemId) i+1);

   147 		event->SetLink(KTestLink1);

   148 		event->SetDataL(KTestData1);

   149 		event->SetFlags(KTestFlags1);

   150 

   151 		// Add event

   152 		active->StartL();

   153 		aClient.AddEvent(*event, active->iStatus);

   154 		CActiveScheduler::Start();

   155 		TEST2(active->iStatus.Int(), KErrNone);

   156 

   157 		// Make it in the past

   158 		event->SetTime(past);

   159 		active->StartL();

   160 		aClient.ChangeEvent(*event, active->iStatus);

   161 		CActiveScheduler::Start();

   162 		TEST2(active->iStatus.Int(), KErrNone);

   163 		}

   164 	TEST2(testReceiver.CallCount(), 0);

   165 

   166 	// Clear the log

   167 	active->StartL();

   168 	aClient.ClearLog(clearLogThreshold, active->iStatus);

   169 	CActiveScheduler::Start();

   170 	TEST2(active->iStatus.Int(), KErrNone);

   171 

   172 	// Have to wait a while, since the change observer active object

   173 	// won't run until shortly after completing the 'clear log' operation

   174 	// request status.

   175 	CTestTimer* timer = CTestTimer::NewL();

   176 	CleanupStack::PushL(timer);

   177 	timer->After(5 * 1000000);

   178 	CActiveScheduler::Start();

   179 	CleanupStack::PopAndDestroy(timer);

   180 	//

   181 	TEST2(testReceiver.CallCount(), 1);

   182 	TEST(logClearedFlag);

   183 

   184 	// Start again

   185 	testReceiver.Reset();

   186 

   187 	// Test removing observer

   188 	aClient.SetGlobalChangeObserverL(NULL);

   189 

   190 	// Add an event again

   191 	active->StartL();

   192 	aClient.AddEvent(*event, active->iStatus);

   193 	CActiveScheduler::Start();

   194 	TEST2(active->iStatus.Int(), KErrNone);

   195 	TEST2(testReceiver.CallCount(), 0);

   196 

   197 	// Make it in the past

   198 	event->SetTime(past);

   199 	active->StartL(); 

   200 	aClient.ChangeEvent(*event, active->iStatus);

   201 	CActiveScheduler::Start();

   202 	TEST2(active->iStatus.Int(), KErrNone);

   203 

   204 	// Clear the log again

   205 	active->StartL();

   206 	aClient.ClearLog(clearLogThreshold, active->iStatus);

   207 	CActiveScheduler::Start();

   208 	TEST2(active->iStatus.Int(), KErrNone);

   209 	TEST2(testReceiver.CallCount(), 0);

   210 	TEST(logClearedFlag == EFalse);

   211 

   212 	aClient.SetGlobalChangeObserverL(&testReceiver);

   213 

   214 	// Tidy up

   215 	CleanupStack::PopAndDestroy(2, event); // active, event

   216 	}

   217 

   218 /**

   219 @SYMTestCaseID          SYSLIB-LOGENG-CT-0834

   220 @SYMTestCaseDesc	    Adding an event to the log engine test.

   221 @SYMTestPriority 	    High

   222 @SYMTestActions  	    Create a new event type and add that to the log engine.

   223                         Start an active scheduler and check for the  error status.

   224                         Add the event once again and check for the already exits condition.

   225 @SYMTestExpectedResults Test must not fail

   226 @SYMREQ                 REQ0000

   227 */

   228 LOCAL_C void TestAddEventTypeL(CLogClient& aClient)

   229 //

   230 //

   231 //

   232 	{

   233 	LOGTEXT("TestAddEventTypeL()");	

   234 	CLogEventType* type = CLogEventType::NewL();

   235 	CleanupStack::PushL(type);

   236 

   237 	type->SetUid(KTestEventUid);

   238 	type->SetDescription(KTestEventDesc1);

   239 	type->SetLoggingEnabled(ETrue);

   240 

   241 	CTestActive* active = new(ELeave) CTestActive();

   242 	CleanupStack::PushL(active);

   243 

   244 	active->StartL();

   245 	aClient.AddEventType(*type, active->iStatus);

   246 	aClient.Cancel();

   247 	CActiveScheduler::Start();

   248 	TEST2(active->iStatus.Int(), KErrCancel);

   249 

   250 	active->StartL();

   251 	aClient.AddEventType(*type, active->iStatus);

   252 	CActiveScheduler::Start();

   253 	aClient.Cancel();

   254 	TEST((active->iStatus == KErrNone)||(active->iStatus == KErrAlreadyExists));

   255 

   256 	active->StartL();

   257 	aClient.AddEventType(*type, active->iStatus);

   258 	CActiveScheduler::Start();

   259 	TEST2(active->iStatus.Int(), KErrAlreadyExists);

   260 

   261 	CleanupStack::PopAndDestroy(2); // active, type

   262 	LOGTEXT("TestAddEventTypeL() - end");

   263 	}

   264 /**

   265 @SYMTestCaseID          SYSLIB-LOGENG-CT-0835

   266 @SYMTestCaseDesc	    Retrieving the event type information test.

   267                         Tests for CLogClient::GetEventType() function.

   268 @SYMTestPriority 	    High

   269 @SYMTestActions  	    Tests for the retrieved information of event type. 

   270 @SYMTestExpectedResults Test must not fail

   271 @SYMREQ                 REQ0000

   272 */

   273 LOCAL_C void TestGetEventTypeL(CLogClient& aClient)

   274 //

   275 //

   276 //

   277 	{

   278 	LOGTEXT("TestGetEventTypeL()");	

   279 	CLogEventType* type = CLogEventType::NewL();

   280 	CleanupStack::PushL(type);

   281 

   282 	type->SetUid(KTestEventUid);

   283 

   284 	CTestActive* active = new(ELeave)CTestActive();

   285 	CleanupStack::PushL(active);

   286 

   287 	active->StartL();

   288 	aClient.GetEventType(*type, active->iStatus);

   289 	aClient.Cancel();

   290 	CActiveScheduler::Start();

   291 	TEST2(active->iStatus.Int(), KErrCancel);

   292 

   293 	active->StartL();

   294 	aClient.GetEventType(*type, active->iStatus);

   295 	CActiveScheduler::Start();

   296 	aClient.Cancel();

   297 	TEST2(active->iStatus.Int(), KErrNone);

   298 

   299 	TEST(type->Uid() == KTestEventUid);

   300 	TEST(type->Description() == KTestEventDesc1);

   301 	TEST(type->LoggingEnabled());

   302 

   303 	CleanupStack::PopAndDestroy(2); // active, type

   304 	LOGTEXT("TestGetEventTypeL() - end");

   305 	}

   306 

   307 /**

   308 @SYMTestCaseID          SYSLIB-LOGENG-CT-0836

   309 @SYMTestCaseDesc	    Changing the event type test.

   310                         Tests for CLogClient::ChangeEventType test

   311 @SYMTestPriority 	    High

   312 @SYMTestActions  	    Create a new event type,change the event type and check for any errors

   313 @SYMTestExpectedResults Test must not fail

   314 @SYMREQ                 REQ0000

   315 */

   316 LOCAL_C void TestChangeEventTypeL(CLogClient& aClient)

   317 //

   318 //

   319 //

   320 	{

   321 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0836 "));

   322 	LOGTEXT("TestChangeEventTypeL()");	

   323 	CTestActive* active = new(ELeave)CTestActive();

   324 	CleanupStack::PushL(active);

   325 

   326 	CLogEventType* type = CLogEventType::NewL();

   327 	CleanupStack::PushL(type);

   328 

   329 	type->SetUid(KTestEventUid);

   330 	type->SetDescription(KTestEventDesc2);

   331 	type->SetLoggingEnabled(EFalse);

   332 

   333 	active->StartL();

   334 	aClient.ChangeEventType(*type, active->iStatus);

   335 	aClient.Cancel();

   336 	CActiveScheduler::Start();

   337 	TEST2(active->iStatus.Int(), KErrCancel);

   338 

   339 	active->StartL();

   340 	aClient.ChangeEventType(*type, active->iStatus);

   341 	CActiveScheduler::Start();

   342 	aClient.Cancel();

   343 	TEST2(active->iStatus.Int(), KErrNone);

   344 

   345 	CleanupStack::PopAndDestroy(); // type

   346 

   347 	type = CLogEventType::NewL();

   348 	CleanupStack::PushL(type);

   349 

   350 	type->SetUid(KTestEventUid);

   351 

   352 	active->StartL();

   353 	aClient.GetEventType(*type, active->iStatus);

   354 	CActiveScheduler::Start();

   355 	TEST2(active->iStatus.Int(), KErrNone);

   356 

   357 	TEST(type->Uid() == KTestEventUid);

   358 	TEST(type->Description() == KTestEventDesc2);

   359 	TEST(type->LoggingEnabled() == EFalse);

   360 

   361 	CleanupStack::PopAndDestroy(2); // type, active

   362 	LOGTEXT("TestChangeEventTypeL() - end");

   363 	}

   364 

   365 /**

   366 @SYMTestCaseID          SYSLIB-LOGENG-CT-0837

   367 @SYMTestCaseDesc	    Deleting an event type test.

   368                         Tests for CLogClient::DeleteEventType() test

   369 @SYMTestPriority 	    High

   370 @SYMTestActions  	    Delete an event type from log database and test for no errors found

   371 @SYMTestExpectedResults Test must not fail

   372 @SYMREQ                 REQ0000

   373 */

   374 LOCAL_C void TestDeleteEventTypeL(CLogClient& aClient)

   375 //

   376 //

   377 //

   378 	{

   379     test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0837 "));

   380 	LOGTEXT("TestChangeEventTypeL()");	

   381 	CTestActive* active = new(ELeave)CTestActive();

   382 	CleanupStack::PushL(active);

   383 

   384 	active->StartL();

   385 	aClient.DeleteEventType(KTestEventUid, active->iStatus);

   386 	aClient.Cancel();

   387 	CActiveScheduler::Start();

   388 	TEST2(active->iStatus.Int(), KErrCancel);

   389 

   390 	active->StartL();

   391 	aClient.DeleteEventType(KTestEventUid, active->iStatus);

   392 	CActiveScheduler::Start();

   393 	aClient.Cancel();

   394 	TEST2(active->iStatus.Int(), KErrNone);

   395 

   396 	CLogEventType* type = CLogEventType::NewL();

   397 	CleanupStack::PushL(type);

   398 

   399 	type->SetUid(KTestEventUid);

   400 

   401 	active->StartL();

   402 	aClient.GetEventType(*type, active->iStatus);

   403 	CActiveScheduler::Start();

   404 	TEST2(active->iStatus.Int(), KErrNotFound);

   405 

   406 	CleanupStack::PopAndDestroy(2); // type, active

   407 	LOGTEXT("TestChangeEventTypeL() - end");

   408 	}

   409 

   410 /**

   411 @SYMTestCaseID          SYSLIB-LOGENG-CT-1329

   412 @SYMTestCaseDesc	    Adding an event type test.

   413                         Tests for CLogClient::AddEventType() function

   414 @SYMTestPriority 	    High

   415 @SYMTestActions  	    Add an event type to the log database and test for no errors found

   416 @SYMTestExpectedResults Test must not fail

   417 @SYMREQ                 REQ0000

   418 */

   419 LOCAL_C void TestAddEventL(CLogClient& aClient)

   420 //

   421 //

   422 //

   423 	{

   424 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1329 "));	

   425 	CLogEventType* type = CLogEventType::NewL();

   426 	CleanupStack::PushL(type);

   427 

   428 	type->SetUid(KTestEventUid);

   429 	type->SetDescription(KTestEventDesc1);

   430 	type->SetLoggingEnabled(ETrue);

   431 

   432 	CTestActive* active = new(ELeave)CTestActive();

   433 	CleanupStack::PushL(active);

   434 

   435 	active->StartL();

   436 	aClient.AddEventType(*type, active->iStatus);

   437 	CActiveScheduler::Start();

   438 	TEST2(active->iStatus.Int(), KErrNone);

   439 

   440 	CLogEvent* event = CLogEvent::NewL();

   441 	CleanupStack::PushL(event);

   442 

   443 	// Reset

   444 	gTheId = KLogNullId;

   445 	//

   446 	TTime now;

   447 	now.UniversalTime();

   448 

   449 	event->SetEventType(KTestEventUid);

   450 	event->SetRemoteParty(KTestRemoteParty1);

   451 	event->SetDirection(KTestDirection1);

   452 	event->SetDurationType(KTestDurationType1);

   453 	event->SetDuration(KTestDuration1);

   454 	event->SetStatus(KTestStatus1);

   455 	event->SetSubject(KTestSubject1);

   456 	event->SetNumber(KTestNumber1);

   457 	event->SetContact(KTestContact1);

   458 	event->SetLink(KTestLink1);

   459 	event->SetDataL(KTestData1);

   460 	event->SetFlags(KTestFlags1);

   461 	//

   462 	active->StartL();

   463 	aClient.AddEvent(*event, active->iStatus);

   464 	aClient.Cancel();

   465 	CActiveScheduler::Start();

   466 	TEST2(active->iStatus.Int(), KErrCancel);

   467 	//

   468 	active->StartL();

   469 	aClient.AddEvent(*event, active->iStatus);

   470 	CActiveScheduler::Start();

   471 	TEST(!active->IsActive());

   472 	aClient.Cancel();

   473 	TEST2(active->iStatus.Int(), KErrNone);

   474 	//

   475 	gTheId=event->Id();

   476 	//

   477 	TEST(gTheId != KLogNullId);

   478 	TEST(event->Time() >= now);

   479 	TEST(event->Description() == KTestEventDesc1);

   480 	//

   481 	CleanupStack::PopAndDestroy(3); // event, active, type

   482 	}

   483 

   484 /**

   485 @SYMTestCaseID          SYSLIB-LOGENG-CT-0838

   486 @SYMTestCaseDesc	    Client failure test

   487 @SYMTestPriority 	    High

   488 @SYMTestActions  	    Checks for status after client is deleted,checks for Cancel error flag

   489 @SYMTestExpectedResults Test must not fail

   490 @SYMREQ                 REQ0000

   491 */

   492 LOCAL_C void TestClientFailL()

   493 	{

   494 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0838 "));	

   495 	CLogEvent* event = CLogEvent::NewL();

   496 	CleanupStack::PushL(event);

   497 

   498 	CTestActive* active = new(ELeave)CTestActive();

   499 	CleanupStack::PushL(active);

   500 

   501 	CLogClient* client = CLogClient::NewL(theFs);

   502 	CleanupStack::PushL(client);

   503 

   504 	event->SetId(gTheId);

   505 

   506 	active->StartL();

   507 	client->GetEvent(*event, active->iStatus);

   508 	CleanupStack::Pop(); // client

   509 	delete client;	

   510 	

   511 	CActiveScheduler::Start();

   512 	TEST2(active->iStatus.Int(), KErrCancel);

   513 

   514 	CleanupStack::PopAndDestroy(2); // event, active

   515 	}

   516 

   517 /**

   518 @SYMTestCaseID          SYSLIB-LOGENG-CT-0839

   519 @SYMTestCaseDesc	    Tests for CLogClient::GetEvent() function

   520 @SYMTestPriority 	    High

   521 @SYMTestActions  	    Retrieve the event type and test for the integrity of the event type information

   522                         Check for no errors

   523 @SYMTestExpectedResults Test must not fail

   524 @SYMREQ                 REQ0000

   525 */

   526 

   527 LOCAL_C void TestGetEventL(CLogClient& aClient)

   528 //

   529 //

   530 //

   531 	{

   532 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0839 "));

   533 	CTestActive* active = new(ELeave)CTestActive();

   534 	CleanupStack::PushL(active);

   535 

   536 	CLogEvent* event = CLogEvent::NewL();

   537 	CleanupStack::PushL(event);

   538 

   539 	event->SetId(gTheId);

   540 

   541 	active->StartL();

   542 	aClient.GetEvent(*event, active->iStatus);

   543 	aClient.Cancel();

   544 	CActiveScheduler::Start();

   545 	TEST2(active->iStatus.Int(), KErrCancel);

   546 

   547 	active->StartL();

   548 	aClient.GetEvent(*event, active->iStatus);

   549 	CActiveScheduler::Start();

   550 	aClient.Cancel();

   551 	TEST2(active->iStatus.Int(), KErrNone);

   552 

   553 	TEST(event->Id() == gTheId);

   554 	TEST(event->Time() > TTime(0));

   555 	TEST(event->Description() == KTestEventDesc1);

   556 	TEST(event->EventType() == KTestEventUid);

   557 	TEST(event->RemoteParty() == KTestRemoteParty1);

   558 	TEST(event->Direction() == KTestDirection1);

   559 	TEST(event->DurationType() == KTestDurationType1);

   560 	TEST(event->Duration() == KTestDuration1);

   561 	TEST(event->Status() == KTestStatus1);

   562 	TEST(event->Subject() == KTestSubject1);

   563 	TEST(event->Number() == KTestNumber1);

   564 	TEST(event->Contact() == KTestContact1);

   565 	TEST(event->Link() == KTestLink1);

   566 	TEST(event->Data() == KTestData1);

   567 	TEST(event->Flags() == KTestFlags1);

   568 

   569 	TBuf<500> subject;

   570 	TInt i=450;

   571 	while(i--)

   572 		subject.Append(_L("a"));

   573 	event->SetSubject(subject);

   574 

   575 	active->StartL();

   576 	aClient.AddEvent(*event, active->iStatus);

   577 	CActiveScheduler::Start();

   578 	if	(aClient.IsActive() && active->iStatus == KRequestPending)

   579 		{

   580 		aClient.Cancel();

   581 		CActiveScheduler::Start();

   582 		TEST2(active->iStatus.Int(), KErrCancel);

   583 		}

   584 	else

   585 		{

   586 		TEST2(active->iStatus.Int(), KErrNone);

   587 		}

   588 

   589 	// See TestAddEventL on why this might still allow the active object

   590 	// to be cancelled.

   591 //	TEST(active->iStatus == KErrNone || active->iStatus == KErrCancel);

   592 

   593 	i=450;

   594 	while(i--)

   595 		subject[i]='b';

   596 	event->SetSubject(subject);

   597 

   598 	active->StartL();

   599 	aClient.GetEvent(*event, active->iStatus);

   600 	CActiveScheduler::Start();

   601 	aClient.Cancel();

   602  	TEST2(active->iStatus.Int(), KErrNone);

   603 

   604 

   605 	CleanupStack::PopAndDestroy(2); // event, active

   606 	}

   607 

   608 /**

   609 @SYMTestCaseID          SYSLIB-LOGENG-CT-0840

   610 @SYMTestCaseDesc	    Tests for CLogClient::ChangeEvent() function 

   611 @SYMTestPriority 	    High

   612 @SYMTestActions  	    Change the event,get the event information and test for the integrity.

   613                         Check for any errors.

   614 @SYMTestExpectedResults Test must not fail

   615 @SYMREQ                 REQ0000

   616 */

   617 LOCAL_C void TestChangeEventL(CLogClient& aClient)

   618 //

   619 //

   620 //

   621 	{

   622 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0840 "));

   623 	CTestActive* active = new(ELeave)CTestActive();

   624 	CleanupStack::PushL(active);

   625 

   626 	CLogEvent* event = CLogEvent::NewL();

   627 	CleanupStack::PushL(event);

   628 

   629 	TTime now;

   630 	now.UniversalTime();

   631 

   632 	event->SetId(gTheId);

   633 	event->SetTime(now);

   634 	event->SetRemoteParty(KTestRemoteParty2);

   635 	event->SetDirection(KTestDirection2);

   636 	event->SetDurationType(KTestDurationType2);

   637 	event->SetDuration(KTestDuration2);

   638 	event->SetStatus(KTestStatus2);

   639 	event->SetSubject(KTestSubject2);

   640 	event->SetNumber(KTestNumber2);

   641 	event->SetContact(KTestContact2);

   642 	event->SetLink(KTestLink2);

   643 	event->SetDataL(KTestData2);

   644 	event->SetFlags(KTestFlags2);

   645 

   646 	active->StartL();

   647 	aClient.ChangeEvent(*event, active->iStatus);

   648 	aClient.Cancel();

   649 	CActiveScheduler::Start();

   650 	TEST2(active->iStatus.Int(), KErrCancel);

   651 

   652 	active->StartL();

   653 	aClient.ChangeEvent(*event, active->iStatus);

   654 	CActiveScheduler::Start();

   655 	aClient.Cancel();

   656 	TEST2(active->iStatus.Int(), KErrNone);

   657 

   658 	CleanupStack::PopAndDestroy(); // event

   659 

   660 	event = CLogEvent::NewL();

   661 	CleanupStack::PushL(event);

   662 

   663 	event->SetId(gTheId);

   664 

   665 	active->StartL();

   666 	aClient.GetEvent(*event, active->iStatus);

   667 	CActiveScheduler::Start();

   668 	TEST2(active->iStatus.Int(), KErrNone);

   669 

   670 	TEST(event->Id() == gTheId);

   671 	TEST(event->Time() == now);

   672 	TEST(event->Description() == KTestEventDesc1);

   673 	TEST(event->EventType() == KTestEventUid);

   674 	TEST(event->RemoteParty() == KTestRemoteParty2);

   675 	TEST(event->Direction() == KTestDirection2);

   676 	TEST(event->DurationType() == KTestDurationType2);

   677 	TEST(event->Duration() == KTestDuration2);

   678 	TEST(event->Status() == KTestStatus2);

   679 	TEST(event->Subject() == KTestSubject2);

   680 	TEST(event->Number() == KTestNumber2);

   681 	TEST(event->Contact() == KTestContact2);

   682 	TEST(event->Link() == KTestLink2);

   683 	TEST(event->Data() == KTestData2);

   684 	TEST(event->Flags() == KTestFlags2);

   685 

   686 	CleanupStack::PopAndDestroy(2); // event, active

   687 	}

   688 

   689 /**

   690 @SYMTestCaseID          SYSLIB-LOGENG-CT-0841

   691 @SYMTestCaseDesc	    Tests for CLogClient::DeleteEvent() function 

   692 @SYMTestPriority 	    High

   693 @SYMTestActions  	    Delete the event and test for no errors found.

   694 @SYMTestExpectedResults Test must not fail

   695 @SYMREQ                 REQ0000

   696 */

   697 LOCAL_C void TestDeleteEventL(CLogClient& aClient)

   698 //

   699 //

   700 //

   701 	{

   702 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0841 "));

   703 	CTestActive* active = new(ELeave)CTestActive();

   704 	CleanupStack::PushL(active);

   705 

   706 	active->StartL();

   707 	aClient.DeleteEvent(0, active->iStatus);

   708 	aClient.Cancel();

   709 	CActiveScheduler::Start();

   710 	TEST2(active->iStatus.Int(), KErrCancel);

   711 

   712 	active->StartL();

   713 	aClient.DeleteEvent(0, active->iStatus);

   714 	CActiveScheduler::Start();

   715 	aClient.Cancel();

   716 	TEST2(active->iStatus.Int(), KErrNone);

   717 

   718 	CLogEvent* event = CLogEvent::NewL();

   719 	CleanupStack::PushL(event);

   720 

   721 	event->SetId(0);

   722 

   723 	active->StartL();

   724 	aClient.GetEvent(*event, active->iStatus);

   725 	CActiveScheduler::Start();

   726 	TEST2(active->iStatus.Int(), KErrNotFound);

   727 

   728 	CleanupStack::PopAndDestroy(2); // event, active

   729 	}

   730 

   731 

   732 #ifdef SYSLIBS_TEST

   733 /**

   734 @SYMTestCaseID          SYSLIB-LOGENG-UT-4015

   735 @SYMTestCaseDesc	    Test the behaviour implemented by PREQ2103

   736 @SYMTestPriority 	    Medium

   737 @SYMTestActions  	    Get the settings from logeng repository file / resource file.

   738 @SYMTestExpectedResults Test must not fail

   739 @SYMREQ                 REQ11125

   740                         REQ11126

   741                         REQ11127

   742                         REQ11128

   743 */

   744 LOCAL_C void TestGetConfigSettingsFromRepositoryFileL(CLogClient& aClient)

   745 	{

   746 	//Note: if this tests starts failing, then go and check the CentralRepository private data cage (c:\\private\\10202be9) , if this file - 101f401d.txt, is there.

   747 	//If it is - delete it and try the test again.

   748 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-UT-4015 "));

   749 	//Get the contact match count and contact name format.This should be from resource file.

   750 	TInt16 contactMatchCount;

   751 	TInt16 contactNameFormat;

   752 	RFs fs;

   753 	

   754 	LEAVE_IF_ERROR(fs.Connect());

   755 	CleanupClosePushL(fs);

   756 	

   757 	//Creating a new CLogClient Object make the server getting the contact match settings. 

   758 	//As the database is deleted it get them from the resource file.

   759 	CLogClient* client2 = CLogClient::NewL(fs);

   760 	CleanupStack::PushL(client2);

   761 	CleanupStack::PopAndDestroy(client2);

   762 		

   763 	//Read these settings via "reader" object.

   764 	RFileReadStream resFileCount_reader;

   765 	CleanupClosePushL(resFileCount_reader);

   766 	RFileReadStream resFileFormat_reader;

   767 	CleanupClosePushL(resFileFormat_reader);

   768 	_LIT(KLogengTestFileNameCount, "c:\\test\\test_logengconfig_count.ini");

   769 	_LIT(KLogengTestFileNameFormat, "c:\\test\\test_logengconfig_format.ini");

   770 	LEAVE_IF_ERROR(resFileCount_reader.Open(fs, KLogengTestFileNameCount, EFileRead));

   771 	LEAVE_IF_ERROR(resFileFormat_reader.Open(fs, KLogengTestFileNameFormat, EFileRead));		

   772 	contactMatchCount = resFileCount_reader.ReadInt32L();

   773 	contactNameFormat = resFileFormat_reader.ReadInt32L();

   774 		

   775 	//The settings should match the ones from resource file.

   776 	TEST(contactMatchCount == 8);

   777 	TEST(contactNameFormat == 0);

   778 		

   779 	CleanupStack::PopAndDestroy(&resFileFormat_reader);

   780 	CleanupStack::PopAndDestroy(&resFileCount_reader);

   781 	

   782 	//Get the config settings (Three config settings). 

   783 	

   784 	CTestActive* active = new(ELeave)CTestActive();

   785 	CleanupStack::PushL(active);

   786 		

   787 	TLogConfig config;

   788 	TEST(config.iMaxEventAge == 0);

   789 	TEST(config.iMaxLogSize == 0);

   790 	TEST(config.iMaxRecentLogSize == 0);

   791 	active->StartL();

   792 	aClient.GetConfig(config, active->iStatus);	

   793 	CActiveScheduler::Start();

   794 	TEST2(active->iStatus.Int(), KErrNone);

   795 	

   796 	//The config settings should match the ones from the resource file.

   797 	TEST(config.iMaxEventAge == 2592000);

   798 	TEST(config.iMaxLogSize == 1000);

   799 	TEST(config.iMaxRecentLogSize == 20);

   800 	

   801 	

   802 	//Now let's provide the repository file, so the server will find it and will get the settings

   803 	//from it.

   804 	

   805 	//Create the directory c:\private\10202be9\ if it does not exist.

   806 	_LIT(KExecutableFileName,		"t_logapi_helper.exe");

   807 	_LIT(KCommandParameters,		"c:\\private\\10202be9\\;c:\\private\\10202be9\\101f401d.txt;3");

   808 	RProcess process;

   809 	TInt r = process.Create(KExecutableFileName, KCommandParameters); 

   810 	process.Resume();

   811 	process.Close();	 

   812 	User::After(1000);

   813 	

   814 	 //copy the repository file to the folder 10202be9

   815 	_LIT(KCommandParameters1,		"z:\\system\\data\\101f401d.txt;c:\\private\\10202be9\\101f401d.txt;0");

   816 	r = process.Create(KExecutableFileName, KCommandParameters1); 

   817 	process.Resume();

   818 	process.Close();	 

   819 	User::After(1000);

   820 	

   821 	TestUtils::DeleteDatabaseL();

   822 	

   823 	//Get the config settings.

   824 	config.iMaxEventAge = 0;

   825 	config.iMaxLogSize = 0;

   826 	config.iMaxRecentLogSize = 0;	

   827 	active->StartL();

   828 	aClient.GetConfig(config, active->iStatus);

   829 	CActiveScheduler::Start();

   830 	TEST2(active->iStatus.Int(), KErrNone);

   831 

   832 	//They should match the ones from the repository file.

   833 	TEST(config.iMaxEventAge == 2592001);

   834 	TEST(config.iMaxLogSize == 1001);

   835 	TEST(config.iMaxRecentLogSize == 21);

   836 	

   837 	CleanupStack::PopAndDestroy(active);

   838 	

   839 	//Get the contact match count and the contact name format.

   840 	RFileReadStream repFileCount_reader;

   841 	CleanupClosePushL(repFileCount_reader);

   842 	RFileReadStream repFileFormat_reader;

   843 	CleanupClosePushL(repFileFormat_reader);

   844 	LEAVE_IF_ERROR(repFileCount_reader.Open(fs, KLogengTestFileNameCount, EFileRead));

   845 	LEAVE_IF_ERROR(repFileFormat_reader.Open(fs, KLogengTestFileNameFormat, EFileRead));		

   846 	contactMatchCount = repFileCount_reader.ReadInt32L();

   847 	contactNameFormat = repFileFormat_reader.ReadInt32L();

   848 	CleanupStack::PopAndDestroy(&repFileFormat_reader);

   849 	CleanupStack::PopAndDestroy(&repFileCount_reader);

   850 	CleanupStack::PopAndDestroy(&fs);

   851 	

   852 	//The values should match the ones from the repository file.

   853 	TEST(contactMatchCount == 6);

   854 	TEST(contactNameFormat == 1);

   855 	

   856 	//delete the repository file c:\\private\\10202be9\\101f401d.txt.

   857 	_LIT(KCommandParameters2,		"c:\\private\\10202be9\\101f401d.txt;private\\10202be9\101f401d.txt;2");

   858 	r = process.Create(KExecutableFileName, KCommandParameters2); 

   859 	process.Resume();

   860 	process.Close();	 

   861 	User::After(1000);

   862 	theLog.Write(_L8("Deleting the Log engine database... \n"));	

   863 	TestUtils::DeleteDatabaseL();

   864 	test.Next(_L("Delay of 2 min, the necessary time to central repository to unload its cache... "));	

   865 	User::After(125000000); // Delay to time to cenrep to unload its cache.

   866 	}

   867 #endif

   868 

   869 

   870 /**

   871 @SYMTestCaseID          SYSLIB-LOGENG-CT-0842

   872 @SYMTestCaseDesc	    Tests for retrieving the log engine configuration data

   873 @SYMTestPriority 	    High

   874 @SYMTestActions  	    Tests for CLogClient::GetConfig() function,check for the integrity of the data

   875 @SYMTestExpectedResults Test must not fail

   876 @SYMREQ                 REQ0000

   877 */

   878 LOCAL_C void TestGetConfigL(CLogClient& aClient)

   879 //

   880 //

   881 //

   882 	{

   883 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0842 "));

   884 	CTestActive* active = new(ELeave)CTestActive();

   885 	CleanupStack::PushL(active);

   886 

   887 	TLogConfig config;

   888 

   889 	TEST(config.iMaxEventAge == 0);

   890 	TEST(config.iMaxLogSize == 0);

   891 	TEST(config.iMaxRecentLogSize == 0);

   892 

   893 	active->StartL();

   894 	aClient.GetConfig(config, active->iStatus);

   895 	aClient.Cancel();

   896 	CActiveScheduler::Start();

   897 	TEST2(active->iStatus.Int(), KErrCancel);

   898 

   899 	active->StartL();

   900 	aClient.GetConfig(config, active->iStatus);

   901 	CActiveScheduler::Start();

   902 	aClient.Cancel();

   903 	TEST2(active->iStatus.Int(), KErrNone);

   904 

   905 	TEST(config.iMaxEventAge > 0);

   906 	TEST(config.iMaxLogSize > 0);

   907 	TEST(config.iMaxRecentLogSize > 0);

   908 

   909 	CleanupStack::PopAndDestroy(); // active

   910 	}

   911 

   912 /**

   913 @SYMTestCaseID          SYSLIB-LOGENG-CT-0843

   914 @SYMTestCaseDesc	    Tests for CLogClient::ChangeConfig() function 

   915 @SYMTestPriority 	    High

   916 @SYMTestActions  	    Change the configuration data and test for the integrity.

   917 @SYMTestExpectedResults Test must not fail

   918 @SYMREQ                 REQ0000

   919 */

   920 LOCAL_C void TestChangeConfigL(CLogClient& aClient)

   921 //

   922 //

   923 //

   924 	{

   925 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0843 "));

   926 	CTestActive* active = new(ELeave)CTestActive();

   927 	CleanupStack::PushL(active);

   928 

   929 	TLogConfig config;

   930 

   931 	config.iMaxLogSize = KTestMaxLogSize;

   932 	config.iMaxRecentLogSize = KTestMaxRecentLogSize;

   933 	config.iMaxEventAge = KTestMaxEventAge;

   934 

   935 	active->StartL();

   936 	aClient.ChangeConfig(config, active->iStatus);

   937 	aClient.Cancel();

   938 	CActiveScheduler::Start();

   939 	TEST2(active->iStatus.Int(), KErrCancel);

   940 

   941 	active->StartL();

   942 	aClient.ChangeConfig(config, active->iStatus);

   943 	CActiveScheduler::Start();

   944 	aClient.Cancel();

   945 	TEST2(active->iStatus.Int(), KErrNone);

   946 

   947 	TEST(config.iMaxLogSize == KTestMaxLogSize);

   948 	TEST(config.iMaxRecentLogSize == KTestMaxRecentLogSize);

   949 	TEST(config.iMaxEventAge == KTestMaxEventAge);

   950 

   951 	CleanupStack::PopAndDestroy(); // active

   952 	}

   953 

   954 /**

   955 @SYMTestCaseID          SYSLIB-LOGENG-CT-0844

   956 @SYMTestCaseDesc	    Tests for CLogClient::GetString() function

   957 @SYMTestPriority 	    High

   958 @SYMTestActions  	    Get the string from the resource file and check for no errors and the zero string length

   959 @SYMTestExpectedResults Test must not fail

   960 @SYMREQ                 REQ0000

   961 */

   962 LOCAL_C void TestGetStringL(CLogClient& aClient)

   963 //

   964 //

   965 //

   966 	{

   967 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0844 "));

   968 	TBuf<KLogMaxSharedStringLength> str;

   969 	

   970 	TInt err = aClient.GetString(str, R_LOG_DIR_IN);

   971 	TEST2(err, KErrNone);

   972 	TEST(str.Length() > 0);

   973 	str.Zero();

   974 

   975 	err = aClient.GetString(str, R_LOG_DIR_OUT);

   976 	TEST2(err, KErrNone);

   977 	TEST(str.Length() > 0);

   978 	str.Zero();

   979 

   980 	err = aClient.GetString(str, R_LOG_DIR_IN_ALT);

   981 	TEST2(err, KErrNone);

   982 	TEST(str.Length() > 0);

   983 	str.Zero();

   984 

   985 	err = aClient.GetString(str, R_LOG_DIR_OUT_ALT);

   986 	TEST2(err, KErrNone);

   987 	TEST(str.Length() > 0);

   988 	str.Zero();

   989 

   990 	err = aClient.GetString(str, R_LOG_DIR_FETCHED);

   991 	TEST2(err, KErrNone);

   992 	TEST(str.Length() > 0);

   993 	str.Zero();

   994 

   995 	err = aClient.GetString(str, R_LOG_DIR_MISSED);

   996 	TEST2(err, KErrNone);

   997 	TEST(str.Length() > 0);

   998 	str.Zero();

   999 

  1000 	err = aClient.GetString(str, R_LOG_DEL_PENDING);

  1001 	TEST2(err, KErrNone);

  1002 	TEST(str.Length() > 0);

  1003 	str.Zero();

  1004 

  1005 	err = aClient.GetString(str, R_LOG_DEL_SENT);

  1006 	TEST2(err, KErrNone);

  1007 	TEST(str.Length() > 0);

  1008 	str.Zero();

  1009 

  1010 	err = aClient.GetString(str, R_LOG_DEL_FAILED);

  1011 	TEST2(err, KErrNone);

  1012 	TEST(str.Length() > 0);

  1013 	str.Zero();

  1014 

  1015 	err = aClient.GetString(str, R_LOG_DEL_NONE);

  1016 	TEST2(err, KErrNone);

  1017 	TEST(str.Length() > 0);

  1018 	str.Zero();

  1019 

  1020 	err = aClient.GetString(str, R_LOG_DEL_DONE);

  1021 	TEST2(err, KErrNone);

  1022 	TEST(str.Length() > 0);

  1023 	str.Zero();

  1024 

  1025 	err = aClient.GetString(str, R_LOG_DEL_NOT_SENT);

  1026 	TEST2(err, KErrNone);

  1027 	TEST(str.Length() > 0);

  1028 	str.Zero();

  1029 

  1030 	err = aClient.GetString(str, R_LOG_DEL_NOTIFIED);

  1031 	TEST2(err, KErrNone);

  1032 	TEST(str.Length() > 0);

  1033 	str.Zero();

  1034 

  1035 	err = aClient.GetString(str, R_LOG_DEL_EXPIRED);

  1036 	TEST2(err, KErrNone);

  1037 	TEST(str.Length() > 0);

  1038 	str.Zero();

  1039 

  1040 	err = aClient.GetString(str, R_LOG_REMOTE_UNKNOWN);

  1041 	TEST2(err, KErrNone);

  1042 	TEST(str.Length() > 0);

  1043 	str.Zero();

  1044 

  1045 	err = aClient.GetString(str, R_LOG_REMOTE_MULTIPLE);

  1046 	TEST2(err, KErrNone);

  1047 	TEST(str.Length() > 0);

  1048 	str.Zero();

  1049 

  1050 	err = aClient.GetString(str, R_LOG_SUBJECT_NONE);

  1051 	TEST2(err, KErrNone);

  1052 	TEST(str.Length() > 0);

  1053 	str.Zero();

  1054 	}

  1055 

  1056 /**

  1057 @SYMTestCaseID          SYSLIB-LOGENG-CT-0845

  1058 @SYMTestCaseDesc	    Tests for clearing the event types from the log

  1059 @SYMTestPriority 	    High

  1060 @SYMTestActions  	    Clear the event types from the log and check for event not found error.

  1061 @SYMTestExpectedResults Test must not fail

  1062 @SYMREQ                 REQ0000

  1063 */

  1064 LOCAL_C void TestClearEventLogL(CLogClient& aClient)

  1065 	{

  1066 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0845 "));

  1067 	TTime now;

  1068 	now.UniversalTime();

  1069 	TDateTime d = now.DateTime();

  1070 	RDebug::Print(_L("TimeNow: Y=%d, M=%d, D=%d, H=%d, M=%d, S=%d\n"), d.Year(), d.Month() + 1, d.Day() + 1, d.Hour(), d.Minute(), d.Second());

  1071 

  1072 	TTime date1(now);

  1073 	date1 -= TTimeIntervalDays(1);

  1074 

  1075 	TTime date2(date1);

  1076 	date2 -= TTimeIntervalDays(1);

  1077 

  1078 	CTestActive* active = new(ELeave)CTestActive();

  1079 	CleanupStack::PushL(active);

  1080 

  1081 	//////////////////////////////////////////////////////////////////////////////	

  1082 	//Clear all events before (current date). Actually - all events!

  1083 	active->StartL();

  1084 	aClient.ClearLog(now, active->iStatus);

  1085 	CActiveScheduler::Start();

  1086 	TEST2(active->iStatus.Int(), KErrNone);

  1087 

  1088 	//////////////////////////////////////////////////////////////////////////////	

  1089 	//The next part of the test will create 4 events:

  1090 	//-event1 and event2 will have time = current date - 1 day + 10 seconds;

  1091 	//-event3 and event4 will have time = current date - 2 days;

  1092 	//The test is:

  1093 	//ClearLog - Delete all events, which time is less or equal to current date - 1 day.

  1094 	//Check - event3 and event4 should disappear, event1 and event2 should stay.

  1095 	//ClearLog - Delete all events, which time is less or equal to current date.

  1096 	//Check - event1 and event2 should disappear too.

  1097 	//

  1098 	//The "10 seconds" addition is very important. The creation of the 4 events is 

  1099 	//an operation, which is performed very quickly. It is possible that the 

  1100 	//first ClearLog operation will be executed at the same second at which the events

  1101 	//were created. Which means, that all events will be deleted and the next check 

  1102 	//for the presence of event1 and event2 will fail.

  1103 

  1104 	//////////////////////////////////////////////////////////////////////////////	

  1105 	//Create and add new event - event1. 

  1106 	//Set event1 date to be (current date - 1 day + 10 seconds).

  1107 	CLogEvent* event1 = CLogEvent::NewL();

  1108 	CleanupStack::PushL(event1);

  1109 	

  1110 	event1->SetEventType(KTestEventUid);

  1111 	active->StartL();

  1112 	aClient.AddEvent(*event1, active->iStatus);

  1113 	CActiveScheduler::Start();

  1114 	TEST2(active->iStatus.Int(), KErrNone);

  1115 

  1116 	TTimeIntervalSeconds tenSeconds(10);

  1117 	event1->SetTime(date1 + tenSeconds);

  1118 	active->StartL();

  1119 	aClient.ChangeEvent(*event1, active->iStatus);

  1120 	CActiveScheduler::Start();

  1121 	TEST2(active->iStatus.Int(), KErrNone);

  1122 

  1123 	//////////////////////////////////////////////////////////////////////////////	

  1124 	//Create and add new event - event2. 

  1125 	//Set event2 date to be (current date - 1 day + 10 seconds).

  1126 	CLogEvent* event2 = CLogEvent::NewL();

  1127 	CleanupStack::PushL(event2);

  1128 	

  1129 	event2->SetEventType(KTestEventUid);

  1130 	active->StartL();

  1131 	aClient.AddEvent(*event2, active->iStatus);

  1132 	CActiveScheduler::Start();

  1133 	TEST2(active->iStatus.Int(), KErrNone);

  1134