Symaptic: os/persistentdata/loggingservices/eventlogger/test/src/t

     1 // Copyright (c) 2002-2010 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 //

    16 #include <s32file.h>

    17 #include <e32math.h>

    18 #include <logview.h>

    19 #include <s32mem.h>

    20 #include "t_logutil2.h"

    21 #include "t_logutil3.h"

    23 #define UNUSED_VAR(a) a = a

    25 const TLogContactItemId KTestContact = 0x1234;

    26 const TInt KTestEventNum = 10;

    28 RTest TheTest(_L("t_logapi"));

    30 const TUid KTestEventUid = {0x10005393};

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

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

    33 _LIT(KTestRemoteParty1, "Remote Party");

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

    35 _LIT(KTestDirection1, "Direction");

    36 _LIT(KTestDirection2, "Changed Direction");

    37 const TLogDurationType KTestDurationType1 = 1;

    38 const TLogDurationType KTestDurationType2 = 2;

    39 const TLogDuration KTestDuration1 = 0x1234;

    40 const TLogDuration KTestDuration2 = 0x1234567;

    41 _LIT(KTestStatus1, "Status");

    42 _LIT(KTestStatus2, "Changed Status");

    43 _LIT(KTestSubject1, "Subject");

    44 _LIT(KTestSubject2, "Changed Subject");

    45 _LIT(KTestNumber1, "TheNumber");

    46 _LIT(KTestNumber2, "Changed Number");

    47 const TLogContactItemId KTestContact1 = 0x1234;

    48 const TLogContactItemId KTestContact2 = 0x1234567;

    49 const TLogLink KTestLink1 = 0x1234;

    50 const TLogLink KTestLink2 = 0x1234567;

    51 _LIT8(KTestData1, "ABCDEFGH");

    52 _LIT8(KTestData2, "IJKLMNOPQRSTUVWXYZ");

    53 const TLogFlags KTestFlags1 = 0x5;

    54 const TLogFlags KTestFlags2 = 0xA;

    55 const TLogSize KTestMaxLogSize = 0xFFF;

    56 const TLogRecentSize KTestMaxRecentLogSize = 0xF;

    57 const TLogAge KTestMaxEventAge = 0xFFFFFFF;

    59 TInt gTheId;

    61 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    63 class TClientObserverTestReceiver : public MLogClientChangeObserver

    64 	{

    65 public:

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

    68 public:

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

    70 		{

    71 		++iCallCount;

    72 		iFlag = (aChangeType == KLogClientChangeEventLogCleared);

    73 		}

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

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

    77 private:

    78 	TInt iCallCount;

    79 	TBool& iFlag;

    80 	};

    82 /**

    83 @SYMTestCaseID          SYSLIB-LOGENG-CT-0833

    84 @SYMTestCaseDesc	    Client observer mechanism test

    85 @SYMTestPriority 	    High

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

    87 @SYMTestExpectedResults Test must not fail

    88 @SYMREQ                 REQ0000

    89 */

    90 LOCAL_C void TestClientObserverMechanismL(CLogClient& aClient)

    91 	{

    92 	//

    93 	TBool logClearedFlag = EFalse;

    94 	TClientObserverTestReceiver testReceiver(logClearedFlag);

    95 	//

    96 	aClient.SetGlobalChangeObserverL(&testReceiver);

    98 	TTime now;

    99 	now.UniversalTime();

   100 	TTime clearLogThreshold(now);

   101 	clearLogThreshold -= TTimeIntervalDays(1);

   102 	TTime past(now);

   103 	past -= TTimeIntervalDays(2);

   105 	// Make some events

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

   107 	CleanupStack::PushL(event);

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

   109 	CleanupStack::PushL(active);

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

   111 		{

   112 		event->SetEventType(KLogCallEventTypeUid);

   113 		event->SetRemoteParty(KTestRemoteParty1);

   114 		event->SetDirection(KTestDirection1);

   115 		event->SetDurationType(KTestDurationType1);

   116 		event->SetDuration(KTestDuration1);

   117 		event->SetStatus(KTestStatus1);

   118 		event->SetSubject(KTestSubject1);

   119 		event->SetNumber(KTestNumber1);

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

   121 		event->SetLink(KTestLink1);

   122 		event->SetDataL(KTestData1);

   123 		event->SetFlags(KTestFlags1);

   125 		// Add event

   126 		active->StartL();

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

   128 		CActiveScheduler::Start();

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

   131 		// Make it in the past

   132 		event->SetTime(past);

   133 		active->StartL();

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

   135 		CActiveScheduler::Start();

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

   137 		}

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

   140 	// Clear the log

   141 	active->StartL();

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

   143 	CActiveScheduler::Start();

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

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

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

   148 	// request status.

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

   150 	CleanupStack::PushL(timer);

   151 	timer->After(5 * 1000000);

   152 	CActiveScheduler::Start();

   153 	CleanupStack::PopAndDestroy(timer);

   154 	//

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

   156 	TEST(logClearedFlag);

   158 	// Start again

   159 	testReceiver.Reset();

   161 	// Test removing observer

   162 	aClient.SetGlobalChangeObserverL(NULL);

   164 	// Add an event again

   165 	active->StartL();

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

   167 	CActiveScheduler::Start();

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

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

   171 	// Make it in the past

   172 	event->SetTime(past);

   173 	active->StartL();

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

   175 	CActiveScheduler::Start();

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

   178 	// Clear the log again

   179 	active->StartL();

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

   181 	CActiveScheduler::Start();

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

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

   184 	TEST(logClearedFlag == EFalse);

   186 	aClient.SetGlobalChangeObserverL(&testReceiver);

   188 	// Tidy up

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

   190 	}

   192 /**

   193 @SYMTestCaseID          SYSLIB-LOGENG-CT-0834

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

   195 @SYMTestPriority 	    High

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

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

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

   199 @SYMTestExpectedResults Test must not fail

   200 @SYMREQ                 REQ0000

   201 */

   202 LOCAL_C void TestAddEventTypeL(CLogClient& aClient)

   203 //

   204 //

   205 //

   206 	{

   207 	LOGTEXT("TestAddEventTypeL()");

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

   209 	CleanupStack::PushL(type);

   211 	type->SetUid(KTestEventUid);

   212 	type->SetDescription(KTestEventDesc1);

   213 	type->SetLoggingEnabled(ETrue);

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

   216 	CleanupStack::PushL(active);

   218 	active->StartL();

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

   220 	aClient.Cancel();

   221 	CActiveScheduler::Start();

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

   224 	active->StartL();

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

   226 	CActiveScheduler::Start();

   227 	aClient.Cancel();

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

   230 	active->StartL();

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

   232 	CActiveScheduler::Start();

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

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

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

   237 	}

   238 /**

   239 @SYMTestCaseID          SYSLIB-LOGENG-CT-0835

   240 @SYMTestCaseDesc	    Retrieving the event type information test.

   241                         Tests for CLogClient::GetEventType() function.

   242 @SYMTestPriority 	    High

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

   244 @SYMTestExpectedResults Test must not fail

   245 @SYMREQ                 REQ0000

   246 */

   247 LOCAL_C void TestGetEventTypeL(CLogClient& aClient)

   248 //

   249 //

   250 //

   251 	{

   252 	LOGTEXT("TestGetEventTypeL()");

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

   254 	CleanupStack::PushL(type);

   256 	type->SetUid(KTestEventUid);

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

   259 	CleanupStack::PushL(active);

   261 	active->StartL();

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

   263 	aClient.Cancel();

   264 	CActiveScheduler::Start();

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

   267 	active->StartL();

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

   269 	CActiveScheduler::Start();

   270 	aClient.Cancel();

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

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

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

   275 	TEST(type->LoggingEnabled());

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

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

   279 	}

   281 /**

   282 @SYMTestCaseID          SYSLIB-LOGENG-CT-0836

   283 @SYMTestCaseDesc	    Changing the event type test.

   284                         Tests for CLogClient::ChangeEventType test

   285 @SYMTestPriority 	    High

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

   287 @SYMTestExpectedResults Test must not fail

   288 @SYMREQ                 REQ0000

   289 */

   290 LOCAL_C void TestChangeEventTypeL(CLogClient& aClient)

   291 //

   292 //

   293 //

   294 	{

   295 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0836 "));

   296 	LOGTEXT("TestChangeEventTypeL()");

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

   298 	CleanupStack::PushL(active);

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

   301 	CleanupStack::PushL(type);

   303 	type->SetUid(KTestEventUid);

   304 	type->SetDescription(KTestEventDesc2);

   305 	type->SetLoggingEnabled(EFalse);

   307 	active->StartL();

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

   309 	aClient.Cancel();

   310 	CActiveScheduler::Start();

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

   313 	active->StartL();

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

   315 	CActiveScheduler::Start();

   316 	aClient.Cancel();

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

   319 	CleanupStack::PopAndDestroy(); // type

   321 	type = CLogEventType::NewL();

   322 	CleanupStack::PushL(type);

   324 	type->SetUid(KTestEventUid);

   326 	active->StartL();

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

   328 	CActiveScheduler::Start();

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

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

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

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

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

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

   337 	}

   339 /**

   340 @SYMTestCaseID          SYSLIB-LOGENG-CT-0837

   341 @SYMTestCaseDesc	    Deleting an event type test.

   342                         Tests for CLogClient::DeleteEventType() test

   343 @SYMTestPriority 	    High

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

   345 @SYMTestExpectedResults Test must not fail

   346 @SYMREQ                 REQ0000

   347 */

   348 LOCAL_C void TestDeleteEventTypeL(CLogClient& aClient)

   349 //

   350 //

   351 //

   352 	{

   353 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0837 "));

   354 	LOGTEXT("TestChangeEventTypeL()");

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

   356 	CleanupStack::PushL(active);

   358 	active->StartL();

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

   360 	aClient.Cancel();

   361 	CActiveScheduler::Start();

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

   364 	active->StartL();

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

   366 	CActiveScheduler::Start();

   367 	aClient.Cancel();

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

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

   371 	CleanupStack::PushL(type);

   373 	type->SetUid(KTestEventUid);

   375 	active->StartL();

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

   377 	CActiveScheduler::Start();

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

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

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

   382 	}

   384 /**

   385 @SYMTestCaseID          SYSLIB-LOGENG-CT-1329

   386 @SYMTestCaseDesc	    Adding an event type test.

   387                         Tests for CLogClient::AddEventType() function

   388 @SYMTestPriority 	    High

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

   390 @SYMTestExpectedResults Test must not fail

   391 @SYMREQ                 REQ0000

   392 */

   393 LOCAL_C void TestAddEventL(CLogClient& aClient)

   394 //

   395 //

   396 //

   397 	{

   398 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1329 "));

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

   400 	CleanupStack::PushL(type);

   402 	type->SetUid(KTestEventUid);

   403 	type->SetDescription(KTestEventDesc1);

   404 	type->SetLoggingEnabled(ETrue);

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

   407 	CleanupStack::PushL(active);

   409 	active->StartL();

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

   411 	CActiveScheduler::Start();

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

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

   415 	CleanupStack::PushL(event);

   417 	// Reset

   418 	gTheId = KLogNullId;

   419 	//

   420 	TTime now;

   421 	now.UniversalTime();

   423 	event->SetEventType(KTestEventUid);

   424 	event->SetRemoteParty(KTestRemoteParty1);

   425 	event->SetDirection(KTestDirection1);

   426 	event->SetDurationType(KTestDurationType1);

   427 	event->SetDuration(KTestDuration1);

   428 	event->SetStatus(KTestStatus1);

   429 	event->SetSubject(KTestSubject1);

   430 	event->SetNumber(KTestNumber1);

   431 	event->SetContact(KTestContact1);

   432 	event->SetLink(KTestLink1);

   433 	event->SetDataL(KTestData1);

   434 	event->SetFlags(KTestFlags1);

   435 	//

   436 	active->StartL();

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

   438 	aClient.Cancel();

   439 	CActiveScheduler::Start();

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

   441 	//

   442 	active->StartL();

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

   444 	CActiveScheduler::Start();

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

   446 	aClient.Cancel();

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

   448 	//

   449 	gTheId=event->Id();

   450 	//

   451 	TEST(gTheId != KLogNullId);

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

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

   454 	//

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

   456 	}

   458 /**

   459 @SYMTestCaseID          SYSLIB-LOGENG-CT-0838

   460 @SYMTestCaseDesc	    Client failure test

   461 @SYMTestPriority 	    High

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

   463 @SYMTestExpectedResults Test must not fail

   464 @SYMREQ                 REQ0000

   465 */

   466 LOCAL_C void TestClientFailL()

   467 	{

   468 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0838 "));

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

   470 	CleanupStack::PushL(event);

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

   473 	CleanupStack::PushL(active);

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

   476 	CleanupStack::PushL(client);

   478 	event->SetId(gTheId);

   480 	active->StartL();

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

   482 	CleanupStack::Pop(); // client

   483 	delete client;

   485 	CActiveScheduler::Start();

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

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

   489 	}

   491 /**

   492 @SYMTestCaseID          SYSLIB-LOGENG-CT-0839

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

   494 @SYMTestPriority 	    High

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

   496                         Check for no errors

   497 @SYMTestExpectedResults Test must not fail

   498 @SYMREQ                 REQ0000

   499 */

   501 LOCAL_C void TestGetEventL(CLogClient& aClient)

   502 //

   503 //

   504 //

   505 	{

   506 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0839 "));

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

   508 	CleanupStack::PushL(active);

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

   511 	CleanupStack::PushL(event);

   513 	event->SetId(gTheId);

   515 	active->StartL();

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

   517 	aClient.Cancel();

   518 	CActiveScheduler::Start();

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

   521 	active->StartL();

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

   523 	CActiveScheduler::Start();

   524 	aClient.Cancel();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   543 	TBuf<500> subject;

   544 	TInt i=450;

   545 	while(i--)

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

   547 	event->SetSubject(subject);

   549 	active->StartL();

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

   551 	CActiveScheduler::Start();

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

   553 		{

   554 		aClient.Cancel();

   555 		CActiveScheduler::Start();

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

   557 		}

   558 	else

   559 		{

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

   561 		}

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

   564 	// to be cancelled.

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

   567 	i=450;

   568 	while(i--)

   569 		subject[i]='b';

   570 	event->SetSubject(subject);

   572 	active->StartL();

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

   574 	CActiveScheduler::Start();

   575 	aClient.Cancel();

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

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

   580 	}

   582 /**

   583 @SYMTestCaseID          SYSLIB-LOGENG-CT-0840

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

   585 @SYMTestPriority 	    High

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

   587                         Check for any errors.

   588 @SYMTestExpectedResults Test must not fail

   589 @SYMREQ                 REQ0000

   590 */

   591 LOCAL_C void TestChangeEventL(CLogClient& aClient)

   592 //

   593 //

   594 //

   595 	{

   596 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0840 "));

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

   598 	CleanupStack::PushL(active);

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

   601 	CleanupStack::PushL(event);

   603 	TTime now;

   604 	now.UniversalTime();

   606 	event->SetId(gTheId);

   607 	event->SetTime(now);

   608 	event->SetRemoteParty(KTestRemoteParty2);

   609 	event->SetDirection(KTestDirection2);

   610 	event->SetDurationType(KTestDurationType2);

   611 	event->SetDuration(KTestDuration2);

   612 	event->SetStatus(KTestStatus2);

   613 	event->SetSubject(KTestSubject2);

   614 	event->SetNumber(KTestNumber2);

   615 	event->SetContact(KTestContact2);

   616 	event->SetLink(KTestLink2);

   617 	event->SetDataL(KTestData2);

   618 	event->SetFlags(KTestFlags2);

   620 	active->StartL();

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

   622 	aClient.Cancel();

   623 	CActiveScheduler::Start();

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

   626 	active->StartL();

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

   628 	CActiveScheduler::Start();

   629 	aClient.Cancel();

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

   632 	CleanupStack::PopAndDestroy(); // event

   634 	event = CLogEvent::NewL();

   635 	CleanupStack::PushL(event);

   637 	event->SetId(gTheId);

   639 	active->StartL();

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

   641 	CActiveScheduler::Start();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   661 	}

   663 /**

   664 @SYMTestCaseID          SYSLIB-LOGENG-CT-0841

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

   666 @SYMTestPriority 	    High

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

   668 @SYMTestExpectedResults Test must not fail

   669 @SYMREQ                 REQ0000

   670 */

   671 LOCAL_C void TestDeleteEventL(CLogClient& aClient)

   672 //

   673 //

   674 //

   675 	{

   676 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0841 "));

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

   678 	CleanupStack::PushL(active);

   680 	active->StartL();

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

   682 	aClient.Cancel();

   683 	CActiveScheduler::Start();

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

   686 	active->StartL();

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

   688 	CActiveScheduler::Start();

   689 	aClient.Cancel();

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

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

   693 	CleanupStack::PushL(event);

   695 	event->SetId(0);

   697 	active->StartL();

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

   699 	CActiveScheduler::Start();

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

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

   703 	}

   706 #ifdef SYSLIBS_TEST

   708 /**

   709 @SYMTestCaseID          SYSLIB-LOGENG-UT-4015

   710 @SYMTestCaseDesc	    Test the behaviour implemented by PREQ2103

   711 @SYMTestPriority 	    Medium

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

   713 @SYMTestExpectedResults Test must not fail

   714 @SYMREQ                 REQ11125

   715                         REQ11126

   716                         REQ11127

   717                         REQ11128

   718 */

   719 LOCAL_C void TestGetConfigSettingsFromRepositoryFileL(CLogClient& aClient)

   720 	{

   721 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-UT-4015 "));

   723 	TInt contactMatchCount1;

   724 	TLogContactNameFormat contactNameFormat1;

   725 	LogGetContactmatchCountAndNameFormatL(contactMatchCount1, contactNameFormat1);

   726 	TheTest.Printf(_L("Contact match count = %d, contact name format = %d\r\n"), contactMatchCount1, (TInt)contactNameFormat1);

   727 	//contactMatchCount1 and contactNameFormat1 are loaded directly from the repository, if exists.

   728 	//Otherwise they are initialzied with their default values.

   729 	//The LogEng server should load these resource values in a similar way.

   730 	//They will be stored in contactMatchCount2 and contactNameFormat2.

   731 	TInt16 contactMatchCount2;

   732 	TInt16 contactNameFormat2;

   733 	RFs fs;

   735 	LEAVE_IF_ERROR(fs.Connect());

   736 	CleanupClosePushL(fs);

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

   739 	//As the database is deleted it gets them from the LogEng repository.

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

   741 	CleanupStack::PushL(client2);

   742 	CleanupStack::PopAndDestroy(client2);

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

   745 	RFileReadStream resFileCount_reader;

   746 	CleanupClosePushL(resFileCount_reader);

   747 	RFileReadStream resFileFormat_reader;

   748 	CleanupClosePushL(resFileFormat_reader);

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

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

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

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

   753 	contactMatchCount2 = resFileCount_reader.ReadInt32L();

   754 	contactNameFormat2 = resFileFormat_reader.ReadInt32L();

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

   757 	TEST2(contactMatchCount1, contactMatchCount2);

   758 	TEST2(contactNameFormat1, contactNameFormat2);

   760 	CleanupStack::PopAndDestroy(&resFileFormat_reader);

   761 	CleanupStack::PopAndDestroy(&resFileCount_reader);

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

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

   766 	CleanupStack::PushL(active);

   768 	TLogConfig config;

   769 	TEST(config.iMaxEventAge == 0);

   770 	TEST(config.iMaxLogSize == 0);

   771 	TEST(config.iMaxRecentLogSize == 0);

   772 	active->StartL();

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

   774 	CActiveScheduler::Start();

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

   777 	//The config settings should match the ones from the repository.

   778 	TEST(config.iMaxEventAge == 2592000);

   779 	TEST(config.iMaxLogSize == 1000);

   780 	TEST(config.iMaxRecentLogSize == 20);

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

   784 	//from it.

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

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

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

   789 	RProcess process;

   790 	TRequestStatus processWaitStatus;

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

   792 	TEST(r == KErrNone);

   793 	process.Logon(processWaitStatus);

   794 	process.Resume();

   795 	User::WaitForRequest(processWaitStatus);

   796 	TEST(processWaitStatus.Int() == KErrNone);

   797 	process.Close();

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

   800 	_LIT(KCommandParameters1,		"z:\\test\\101f401d_TEST.txt;c:\\private\\10202be9\\101f401d.txt;0");

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

   802 	TEST(r == KErrNone);

   803 	process.Logon(processWaitStatus);

   804 	process.Resume();

   805 	User::WaitForRequest(processWaitStatus);

   806 	TEST(processWaitStatus.Int() == KErrNone);

   807 	process.Close();

   809 	TestUtils::DeleteDatabaseL();

   811 	//Get the config settings.

   812 	config.iMaxEventAge = 0;

   813 	config.iMaxLogSize = 0;

   814 	config.iMaxRecentLogSize = 0;

   815 	active->StartL();

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

   817 	CActiveScheduler::Start();

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

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

   821 	TEST(config.iMaxEventAge == 2592001);

   822 	TEST(config.iMaxLogSize == 1001);

   823 	TEST(config.iMaxRecentLogSize == 21);

   825 	CleanupStack::PopAndDestroy(active);

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

   828 	RFileReadStream repFileCount_reader;

   829 	CleanupClosePushL(repFileCount_reader);

   830 	RFileReadStream repFileFormat_reader;

   831 	CleanupClosePushL(repFileFormat_reader);

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

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

   834 	contactMatchCount2 = repFileCount_reader.ReadInt32L();

   835 	contactNameFormat2 = repFileFormat_reader.ReadInt32L();

   836 	CleanupStack::PopAndDestroy(&repFileFormat_reader);

   837 	CleanupStack::PopAndDestroy(&repFileCount_reader);

   838 	CleanupStack::PopAndDestroy(&fs);

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

   841 	TEST(contactMatchCount2 == 6);

   842 	TEST(contactNameFormat2 == 1);

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

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

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

   847 	TEST(r == KErrNone);

   848 	process.Logon(processWaitStatus);

   849 	process.Resume();

   850 	User::WaitForRequest(processWaitStatus);

   851 	TEST(processWaitStatus.Int() == KErrNone);

   852 	process.Close();

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

   855 	TestUtils::DeleteDatabaseL();

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

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

   858 	}

   859 #endif

   862 /**

   863 @SYMTestCaseID          SYSLIB-LOGENG-CT-0842

   864 @SYMTestCaseDesc	    Tests for retrieving the log engine configuration data

   865 @SYMTestPriority 	    High

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

   867 @SYMTestExpectedResults Test must not fail

   868 @SYMREQ                 REQ0000

   869 */

   870 LOCAL_C void TestGetConfigL(CLogClient& aClient)

   871 //

   872 //

   873 //

   874 	{

   875 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0842 "));

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

   877 	CleanupStack::PushL(active);

   879 	TLogConfig config;

   881 	TEST(config.iMaxEventAge == 0);

   882 	TEST(config.iMaxLogSize == 0);

   883 	TEST(config.iMaxRecentLogSize == 0);

   885 	active->StartL();

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

   887 	aClient.Cancel();

   888 	CActiveScheduler::Start();

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

   891 	active->StartL();

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

   893 	CActiveScheduler::Start();

   894 	aClient.Cancel();

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

   897 	TEST(config.iMaxEventAge > 0);

   898 	TEST(config.iMaxLogSize > 0);

   899 	TEST(config.iMaxRecentLogSize > 0);

   901 	CleanupStack::PopAndDestroy(); // active

   902 	}

   904 /**

   905 @SYMTestCaseID          SYSLIB-LOGENG-CT-0843

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

   907 @SYMTestPriority 	    High

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

   909 @SYMTestExpectedResults Test must not fail

   910 @SYMREQ                 REQ0000

   911 */

   912 LOCAL_C void TestChangeConfigL(CLogClient& aClient)

   913 //

   914 //

   915 //

   916 	{

   917 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0843 "));

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

   919 	CleanupStack::PushL(active);

   921 	TLogConfig config;

   923 	config.iMaxLogSize = KTestMaxLogSize;

   924 	config.iMaxRecentLogSize = KTestMaxRecentLogSize;

   925 	config.iMaxEventAge = KTestMaxEventAge;

   927 	active->StartL();

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

   929 	aClient.Cancel();

   930 	CActiveScheduler::Start();

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

   933 	active->StartL();

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

   935 	CActiveScheduler::Start();

   936 	aClient.Cancel();

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

   939 	TEST(config.iMaxLogSize == KTestMaxLogSize);

   940 	TEST(config.iMaxRecentLogSize == KTestMaxRecentLogSize);

   941 	TEST(config.iMaxEventAge == KTestMaxEventAge);

   943 	CleanupStack::PopAndDestroy(); // active

   944 	}

   946 /**

   947 @SYMTestCaseID          SYSLIB-LOGENG-CT-0844

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

   949 @SYMTestPriority 	    High

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

   951 @SYMTestExpectedResults Test must not fail

   952 @SYMREQ                 REQ0000

   953 */

   954 LOCAL_C void TestGetStringL(CLogClient& aClient)

   955 //

   956 //

   957 //

   958 	{

   959 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0844 "));

   960 	TBuf<KLogMaxSharedStringLength> str;

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

   963 	TEST2(err, KErrNone);

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

   965 	str.Zero();

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

   968 	TEST2(err, KErrNone);

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

   970 	str.Zero();

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

   973 	TEST2(err, KErrNone);

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

   975 	str.Zero();

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

   978 	TEST2(err, KErrNone);

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

   980 	str.Zero();

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

   983 	TEST2(err, KErrNone);

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

   985 	str.Zero();

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

   988 	TEST2(err, KErrNone);

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

   990 	str.Zero();

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

   993 	TEST2(err, KErrNone);

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

   995 	str.Zero();

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

   998 	TEST2(err, KErrNone);

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

  1000 	str.Zero();

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

  1003 	TEST2(err, KErrNone);

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

  1005 	str.Zero();

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

  1008 	TEST2(err, KErrNone);

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

  1010 	str.Zero();

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

  1013 	TEST2(err, KErrNone);

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

  1015 	str.Zero();

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

  1018 	TEST2(err, KErrNone);

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

  1020 	str.Zero();

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

  1023 	TEST2(err, KErrNone);

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

  1025 	str.Zero();

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

  1028 	TEST2(err, KErrNone);

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

  1030 	str.Zero();

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

  1033 	TEST2(err, KErrNone);

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

  1035 	str.Zero();

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

  1038 	TEST2(err, KErrNone);

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

  1040 	str.Zero();

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

  1043 	TEST2(err, KErrNone);

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

  1045 	str.Zero();

  1046 	}

  1048 /**

  1049 @SYMTestCaseID          SYSLIB-LOGENG-CT-0845

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

  1051 @SYMTestPriority 	    High

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

  1053 @SYMTestExpectedResults Test must not fail

  1054 @SYMREQ                 REQ0000

  1055 */

  1056 LOCAL_C void TestClearEventLogL(CLogClient& aClient)

  1057 	{

  1058 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0845 "));

  1059 	TTime now;

  1060 	now.UniversalTime();

  1061 	TDateTime d = now.DateTime();

  1062 	TheTest.Printf(_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());

  1064 	TTime date1(now);

  1065 	date1 -= TTimeIntervalDays(1);

  1067 	TTime date2(date1);

  1068 	date2 -= TTimeIntervalDays(1);

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

  1071 	CleanupStack::PushL(active);

  1073 	//////////////////////////////////////////////////////////////////////////////

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

  1075 	active->StartL();

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

  1077 	CActiveScheduler::Start();

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

  1080 	//////////////////////////////////////////////////////////////////////////////

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

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

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

  1084 	//The test is:

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

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

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

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

  1089 	//

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

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

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

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

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

  1096 	//////////////////////////////////////////////////////////////////////////////

  1097 	//Create and add new event - event1.

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

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

  1100 	CleanupStack::PushL(event1);

  1102 	event1->SetEventType(KTestEventUid);

  1103 	active->StartL();

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

  1105 	CActiveScheduler::Start();

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

  1108 	TTimeIntervalSeconds tenSeconds(10);

  1109 	event1->SetTime(date1 + tenSeconds);

  1110 	active->StartL();

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

  1112 	CActiveScheduler::Start();

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

  1115 	//////////////////////////////////////////////////////////////////////////////

  1116 	//Create and add new event - event2.

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

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

  1119 	CleanupStack::PushL(event2);

  1121 	event2->SetEventType(KTestEventUid);

  1122 	active->StartL();

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

  1124 	CActiveScheduler::Start();

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

  1127 	event2->SetTime(date1 + tenSeconds);

  1128 	active->StartL();

  1129 	aClient.ChangeEvent(*event2, active->iStatus);

  1130 	CActiveScheduler::Start();

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

  1133 	//////////////////////////////////////////////////////////////////////////////

  1134 	//Create and add new event - event3.

  1135 	//Set event3 date to be (current date - 2 days).

  1136 	CLogEvent* event3 = CLogEvent::NewL();

  1137 	CleanupStack::PushL(event3);

  1138 	event3->SetEventType(KTestEventUid);

  1140 	active->StartL();

  1141 	aClient.AddEvent(*event3, active->iStatus);

  1142 	CActiveScheduler::Start();

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

  1145 	event3->SetTime(date2);

  1146 	active->StartL();

  1147 	aClient.ChangeEvent(*event3, active->iStatus);

  1148 	CActiveScheduler::Start();

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

  1151 	//////////////////////////////////////////////////////////////////////////////

  1152 	//Create and add new event - event4.

  1153 	//Set event4 date to be (current date - 2 days).

  1154 	CLogEvent* event4 = CLogEvent::NewL();

  1155 	CleanupStack::PushL(event4);

  1156 	event4->SetEventType(KTestEventUid);

  1158 	active->StartL();

  1159 	aClient.AddEvent(*event4, active->iStatus);

  1160 	CActiveScheduler::Start();

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

  1163 	event4->SetTime(date2);

  1164 	active->StartL();

  1165 	aClient.ChangeEvent(*event4, active->iStatus);

  1166 	CActiveScheduler::Start();

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

  1169 	//////////////////////////////////////////////////////////////////////////////

  1170 	//Clear all events before (current date - 1 day).

  1171 	//Then cancel the operation.

  1172 	TheTest.Printf(_L("=.= ClearLog 1\n"));

  1173 	active->StartL();

  1174 	aClient.ClearLog(date1, active->iStatus);

  1175 	aClient.Cancel();

  1176 	CActiveScheduler::Start();

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

  1179 	//////////////////////////////////////////////////////////////////////////////

  1180 	//Clear all events before (current date - 1 day).

  1181 	//event3 and event4 should be removed.

  1182 	TheTest.Printf(_L("=.= ClearLog 2\n"));

  1183 	active->StartL();

  1184 	aClient.ClearLog(date1, active->iStatus);

  1185 	CActiveScheduler::Start();

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

  1188 	//////////////////////////////////////////////////////////////////////////////

  1189 	//Get event1. It should be there - its time is (current date - 1 day + 10 seconds).

  1190 	TheTest.Printf(_L("=.= GetEvent 1\n"));

  1191 	active->StartL();

  1192 	aClient.GetEvent(*event1, active->iStatus);

  1193 	CActiveScheduler::Start();

  1194 	if(active->iStatus != KErrNone)

  1195 		{

  1196 		TheTest.Printf(_L("=1= error code:%d\n"),active->iStatus.Int());

  1197 		}

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

  1200 	//////////////////////////////////////////////////////////////////////////////

  1201 	//Get event2. It should be there - its time is (current date - 1 day + 10 seconds).

  1202 	TheTest.Printf(_L("=.= GetEvent 2\n"));

  1203 	active->StartL();

  1204 	aClient.GetEvent(*event2, active->iStatus);

  1205 	CActiveScheduler::Start();

  1206 	if(active->iStatus != KErrNone)

  1207 		{

  1208 		TheTest.Printf(_L("=2= error code:%d\n"),active->iStatus.Int());

  1209 		}

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

  1212 	//////////////////////////////////////////////////////////////////////////////

  1213 	//Get event3. It should not be there - its time is (current date - 2 days).

  1214 	TheTest.Printf(_L("=.= GetEvent 3\n"));

  1215 	active->StartL();

  1216 	aClient.GetEvent(*event3, active->iStatus);

  1217 	CActiveScheduler::Start();

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

  1220 	//////////////////////////////////////////////////////////////////////////////

  1221 	//Get event4. It should not be there - its time is (current date - 2 days).

  1222 	TheTest.Printf(_L("=.= GetEvent 4\n"));

  1223 	active->StartL();

  1224 	aClient.GetEvent(*event4, active->iStatus);

  1225 	CActiveScheduler::Start();

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

  1228 	//////////////////////////////////////////////////////////////////////////////

  1229 	//Clear all events happened before (current date).

  1230 	//event1 and event2 should be removed.

  1231 	TheTest.Printf(_L("=#= ClearLog 1\n"));

  1232 	active->StartL();

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

  1234 	CActiveScheduler::Start();

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

  1237 	//////////////////////////////////////////////////////////////////////////////

  1238 	//Get event1. It should not be there - its time is (current date - 1 day + 10 seconds).

  1239 	TheTest.Printf(_L("=#= GetEvent 1\n"));

  1240 	active->StartL();

  1241 	aClient.GetEvent(*event1, active->iStatus);

  1242 	CActiveScheduler::Start();

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

  1245 	//////////////////////////////////////////////////////////////////////////////

  1246 	//Get event2. It should not be there - its time is (current date - 1 day + 10 seconds).

  1247 	TheTest.Printf(_L("=#= GetEvent 2\n"));

  1248 	active->StartL();

  1249 	aClient.GetEvent(*event2, active->iStatus);

  1250 	CActiveScheduler::Start();

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

  1253 	CleanupStack::PopAndDestroy(5); // event4, event3, event2, event1, active

  1254 	}

  1256 LOCAL_C void DoTestLogL(CLogBase& aClient)

  1257 	{

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

  1259 	CleanupStack::PushL(active);

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

  1262 	CleanupStack::PushL(event);

  1264 	TTime now;

  1265 	now.UniversalTime();

  1267 	event->SetEventType(KLogCallEventTypeUid);

  1269 	User::After((Math::Random() % 4) * 100000);

  1270 	active->StartL();

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

  1272 	CActiveScheduler::Start();

  1273 	TTEST2(active->iStatus.Int(), KErrNone);

  1275 	TTEST(event->EventType() == KLogCallEventTypeUid);

  1276 	TTEST(event->Description().Length() > 0);

  1277 	TTEST(event->Time() >= now);

  1278 	now = event->Time();

  1280 	TLogId id = event->Id();

  1282 	event->SetRemoteParty(KTestRemoteParty1);

  1283 	event->SetDirection(KTestDirection1);

  1284 	event->SetDurationType(KTestDurationType1);

  1285 	event->SetDuration(KTestDuration1);

  1286 	event->SetStatus(KTestStatus1);

  1287 	event->SetSubject(KTestSubject1);

  1288 	event->SetNumber(KTestNumber1);

  1289 	event->SetContact(KTestContact1);

  1290 	event->SetLink(KTestLink1);

  1291 	event->SetDataL(KTestData1);

  1293 	User::After((Math::Random() % 4) * 100000);

  1294 	active->StartL();

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

  1296 	CActiveScheduler::Start();

  1297 	TTEST2(active->iStatus.Int(), KErrNone);

  1299 	TTEST(event->Id() == id);

  1300 	TTEST(event->EventType() == KLogCallEventTypeUid);

  1301 	TTEST(event->Description().Length() > 0);

  1302 	TTEST(event->Time() == now);

  1303 	TTEST(event->RemoteParty() == KTestRemoteParty1);

  1304 	TTEST(event->Direction() == KTestDirection1);

  1305 	TTEST(event->DurationType() == KTestDurationType1);

  1306 	TTEST(event->Duration() == KTestDuration1);

  1307 	TTEST(event->Status() == KTestStatus1);

  1308 	TTEST(event->Subject() == KTestSubject1);

  1309 	TTEST(event->Number() == KTestNumber1);

  1310 	TTEST(event->Contact() == KTestContact1);

  1311 	TTEST(event->Link() == KTestLink1);

  1312 	TTEST(event->Data() == KTestData1);

  1314 	CleanupStack::PopAndDestroy(); // event;

  1316 	event = CLogEvent::NewL();

  1317 	CleanupStack::PushL(event);

  1319 	event->SetId(id);

  1321 	active->StartL();

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

  1323 	CActiveScheduler::Start();

  1324 	TTEST2(active->iStatus.Int(), KErrNone);

  1326 	TTEST(event->Id() == id);

  1327 	TTEST(event->EventType() == KLogCallEventTypeUid);

  1328 	TTEST(event->Description().Length() > 0);

  1329 	TTEST(event->Time() == now);

  1330 	TTEST(event->RemoteParty() == KTestRemoteParty1);

  1331 	TTEST(event->Direction() == KTestDirection1);

  1332 	TTEST(event->DurationType() == KTestDurationType1);

  1333 	TTEST(event->Duration() == KTestDuration1);

  1334 	TTEST(event->Status() == KTestStatus1);

  1335 	TTEST(event->Subject() == KTestSubject1);

  1336 	TTEST(event->Number() == KTestNumber1);

  1337 	TTEST(event->Contact() == KTestContact1);

  1338 	TTEST(event->Link() == KTestLink1);

  1339 	TTEST(event->Data() == KTestData1);

  1341 	User::After((Math::Random() % 4) * 100000);

  1342 	active->StartL();

  1343 	aClient.DeleteEvent(id, active->iStatus);

  1344 	CActiveScheduler::Start();

  1345 	TTEST2(active->iStatus.Int(), KErrNone);

  1347 	active->StartL();

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

  1349 	CActiveScheduler::Start();

  1350 	TTEST2(active->iStatus.Int(), KErrNotFound);

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

  1353 	}

  1355 void DoTestMultipleClientAccessL()

  1356 	{

  1357 	CActiveScheduler::Install(new(ELeave)CActiveScheduler);

  1358 	CleanupStack::PushL(CActiveScheduler::Current());

  1360 	RFs fs;

  1361 	TTEST2(fs.Connect(), KErrNone);

  1362 	CleanupClosePushL(fs);

  1364 	CLogClient* client = CLogClient::NewL(fs);

  1365 	CleanupStack::PushL(client);

  1367 	TBuf8<500> buf;

  1369 	TInt count = 10;

  1370 	while(count--)

  1371 		{

  1372 		DoTestLogL(*client);

  1373 		}

  1375 	CleanupStack::PopAndDestroy(3); // fs, client, CActiveScheduler

  1376 	}

  1378 void DoThreadDieL()

  1379 	{

  1380 	CActiveScheduler::Install(new(ELeave)CActiveScheduler);

  1381 	CleanupStack::PushL(CActiveScheduler::Current());

  1383 	RFs fs;

  1384 	TTEST2(fs.Connect(), KErrNone);

  1385 	CleanupClosePushL(fs);

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

  1388 	CleanupStack::PushL(event);

  1390 	const TInt KLogClientCnt = 10;

  1391 	for(TInt i=0;i<KLogClientCnt;i++)

  1392 		{

  1393 		CLogClient* client = CLogClient::NewL(fs);

  1394 		event->SetId(i);

  1395 		TRequestStatus status;

  1396 		client->GetEvent(*event, status);

  1397 		}

  1399 	User::After(100000);

  1401 	RThread thread;

  1402 	thread.Kill(KErrGeneral);

  1403 	}

  1405 static TInt DoDyingThreadStart(TAny*)

  1406 	{

  1407 	CTrapCleanup* cleanup = CTrapCleanup::New();

  1408 	TTEST(cleanup != NULL);

  1409 	TRAPD(err, DoThreadDieL());

  1410 	delete cleanup;

  1411 	if(err != KErrNone)

  1412 		{

  1413 		RDebug::Print(_L("*** DoThreadDieL() failed with err %d\r\n"), err);

  1414 		User::Panic(_L("ThrChk4"), 4);

  1415 		}

  1416 	return err;

  1417 	}

  1419 static TInt DoThreadStart(TAny* aThreadNumber)

  1420 	{

  1421 	TInt thrNum = (TInt)aThreadNumber;

  1422 	CTrapCleanup* cleanup = CTrapCleanup::New();

  1423 	TTEST(cleanup != NULL);

  1424 	TRAPD(err, DoTestMultipleClientAccessL());

  1425 	delete cleanup;

  1426 	if(err != KErrNone)

  1427 		{

  1428 		RDebug::Print(_L("*** Thread %d failed with err %d\r\n"), thrNum, err);

  1429 		User::Panic(_L("ThrChk3"), 3);

  1430 		}

  1431 	return err;

  1432 	}

  1434 const TInt KTestThreadCount = 20;

  1435 const TInt KMinTestHeapSize = 0x10000;

  1436 const TInt KMaxTestHeapSize = 0x100000;

  1438 /**

  1439 @SYMTestCaseID          SYSLIB-LOGENG-CT-0846

  1440 @SYMTestCaseDesc	    Thread invoking test

  1441 @SYMTestPriority 	    High

  1442 @SYMTestActions  	    Create a new thread,check for no errors,register for notification of status when the thread dies

  1443 @SYMTestExpectedResults Test must not fail

  1444 @SYMREQ                 REQ0000

  1445 */

  1446 LOCAL_C void TestThreadDieL()

  1447 	{

  1448 	RThread thread;

  1449 	TRequestStatus status;

  1451 	TName name;

  1452 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0846 "));

  1453 	_LIT(KThreadName, "Test thread");

  1454 	name.Format(KThreadName);

  1456 	TInt err = thread.Create(name, DoDyingThreadStart, KDefaultStackSize, KMinTestHeapSize, KMaxTestHeapSize, NULL, EOwnerThread);

  1457 	// Create the thread

  1458 	TEST2(err, KErrNone);

  1459 	thread.Logon(status);

  1461 	// Let the thread run

  1462 	thread.Resume();

  1464 	User::WaitForRequest(status);

  1465 	TEST2(thread.ExitType(), EExitKill);

  1466 	thread.Close();

  1467 	TEST2(status.Int(), KErrGeneral);

  1468 	}

  1470 /**

  1471 @SYMTestCaseID          SYSLIB-LOGENG-CT-0847

  1472 @SYMTestCaseDesc	    Multiple client access test

  1473 @SYMTestPriority 	    High

  1474 @SYMTestActions  	    Create threads,request for notification of thread death.

  1475                         Resume and stop all the threads executions.Check for no errors.

  1476 @SYMTestExpectedResults Test must not fail

  1477 @SYMREQ                 REQ0000

  1478 */

  1479 LOCAL_C void TestMultipleClientAccessL()

  1480 	{

  1481 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0847 "));

  1482 	RThread threadArray[KTestThreadCount];

  1483 	TRequestStatus statusArray[KTestThreadCount];

  1485 	// Create the threads

  1486 	TInt count = KTestThreadCount;

  1487 	while(count--)

  1488 		{

  1489 		TName name;

  1490 		_LIT(KThreadName, "TmcaTh%d");

  1491 		name.Format(KThreadName, count);

  1493 		// Create the thread

  1494 		TInt err = threadArray[count].Create(name, DoThreadStart, KDefaultStackSize, KMinTestHeapSize, KMaxTestHeapSize, (TAny*) count, EOwnerThread);

  1495 		TEST2(err, KErrNone);

  1496 		threadArray[count].Logon(statusArray[count]);

  1497 		}

  1499 	// Let the thread run

  1500 	count = KTestThreadCount;

  1501 	while(count--)

  1502 		{

  1503 		TheTest.Printf(_L("   ** Resume thread %d\r\n"), count);

  1504 		threadArray[count].Resume();

  1505 		}

  1507 	TheTest.Printf(_L("   ** Waiting threads to complete....\r\n"));

  1509 	// Wait for all the threads to complete

  1510 	count = KTestThreadCount;

  1511 	while(count--)

  1512 		{

  1513 		User::WaitForRequest(statusArray[count]);

  1514 		TheTest.Printf(_L("   ** Thread %d completed\r\n"), count);

  1515 		TEST(threadArray[count].ExitType() != EExitPanic);

  1516 		threadArray[count].Close();

  1517 		}

  1518 	}

  1520 /**

  1521 @SYMTestCaseID          SYSLIB-LOGENG-CT-0848

  1522 @SYMTestCaseDesc	    Test for checking notification of status

  1523 @SYMTestPriority 	    High

  1524 @SYMTestActions  	    Call up add - get - change - delete event type.

  1525 @SYMTestExpectedResults Test must not fail

  1526 @SYMREQ                 REQ0000

  1527 */

  1528 LOCAL_C void TestNoNotifierL()

  1529 	{

  1530 	TestUtils::DeleteDatabaseL();

  1531 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0848 "));

  1532 	TheTest.Printf(_L("TestNoNotifierL - begin\n"));

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

  1535 	CleanupStack::PushL(client);

  1537 	CTestActive* active = new(ELeave)CTestActive;

  1538 	CleanupStack::PushL(active);

  1540 	TheTest.Printf(_L("TestAddEventTypeL\n"));

  1541 	TestAddEventTypeL(*client);

  1543 	TheTest.Printf(_L("TestGetEventTypeL\n"));

  1544 	TestGetEventTypeL(*client);

  1546 	TheTest.Printf(_L("TestChangeEventTypeL\n"));

  1547 	TestChangeEventTypeL(*client);

  1549 	TheTest.Printf(_L("TestDeleteEventTypeL\n"));

  1550 	TestDeleteEventTypeL(*client);

  1552 	TheTest.Printf(_L("TestAddEventL\n"));

  1553 	TestAddEventL(*client);

  1555 	TheTest.Printf(_L("TestGetEventL\n"));

  1556 	TestGetEventL(*client);

  1558 	TheTest.Printf(_L("TestChangeEventL\n"));

  1559 	TestChangeEventL(*client);

  1561 	TheTest.Printf(_L("TestDeleteEventL\n"));

  1562 	TestDeleteEventL(*client);

  1564 	TheTest.Printf(_L("TestGetConfigL\n"));

  1565 	TestGetConfigL(*client);

  1567 	TheTest.Printf(_L("TestChangeConfigL\n"));

  1568 	TestChangeConfigL(*client);

  1570 	TheTest.Printf(_L("TestGetStringL\n"));

  1571 	TestGetStringL(*client);

  1573 	TheTest.Printf(_L("TestClearEventLogL\n"));

  1574 	TestClearEventLogL(*client);

  1576 	CleanupStack::PopAndDestroy(2); // active, client

  1577 	TheTest.Printf(_L("TestNoNotifierL - end\n"));

  1578 	}

  1580 /**

  1581 @SYMTestCaseID          PDS-LOGENG-CT-4016

  1582 @SYMTestCaseDesc	    Tests for CLogChangeDefinition public APIs

  1583 @SYMTestPriority 	    High

  1584 @SYMTestActions  	    Tests for CLogChangeDefinition::Find() functions, and different NewL() functions.

  1585 @SYMTestExpectedResults CLogChangeDefinition object need to be created propertly. Find() functions

  1586 						need to return proper items from list.

  1587 @SYMDEF                 DEF135499

  1588 */

  1589 LOCAL_C void TestLogChangeDefinitionL(CLogClient& aClient)

  1590 	{

  1591 	TheTest.Next(_L(" @SYMTestCaseID:PDS-LOGENG-CT-4016"));

  1592 	TestUtils::DeleteDatabaseL();

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

  1595 	CleanupStack::PushL(event);

  1597 	CLogFilter* filter = CLogFilter::NewL();

  1598 	CleanupStack::PushL(filter);

  1599 	filter->SetContact(KTestContact);

  1600 	filter->SetEventType(KLogPacketDataEventTypeUid);

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

  1603 	CleanupStack::PushL(active);

  1605 	CLogViewChangeObserver* changeObs = CLogViewChangeObserver::NewLC();

  1606 	changeObs->SetActive();

  1608 	CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs);

  1609 	CleanupStack::PushL(view);

  1611 	// Incoming

  1612 	TBuf<KLogMaxDirectionLength> buf;

  1613 	aClient.GetString(buf, R_LOG_DIR_IN);

  1615 	event->SetEventType(KLogPacketDataEventTypeUid);

  1616 	event->SetDirection(buf);

  1617 	event->SetContact(KTestContact);

  1619 	active->StartL();

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

  1621 	CActiveScheduler::Start();

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

  1623 	User::After(1 * 1000000);

  1625 	TEST2(view->CountL(), 0);

  1626 	active->StartL();

  1627 	TBool res = view->SetFilterL(*filter, active->iStatus);

  1628 	TEST(res);

  1629 	CActiveScheduler::Start();

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

  1631 	TEST2(view->CountL(), 1);

  1633 	// Transients

  1634 	TInt changeCount;

  1635 	TLogId logId;

  1636 	TInt viewIndex;

  1637 	TLogDatabaseChangeType type;

  1639 	for(TInt count = 0; count < KTestEventNum; count++)

  1640 		{

  1641 		active->StartL();

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

  1643 		CActiveScheduler::Start();

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

  1645 		User::After(1 * 1000000);

  1646 		}

  1648 	const CLogChangeDefinition& changes = changeObs->Changes();

  1650 	changeCount = changes.Count();

  1651 	TheTest.Printf(_L("Change Count: %d\n"), changeCount);

  1652 	TEST2(changeCount, KTestEventNum);

  1653 	for(TInt i=0; i<changeCount; i++)

  1654 		{

  1655 		type = changes.At(i, logId, viewIndex);

  1656 		TheTest.Printf(_L("Change Type: %d, logId: %d, viewIndex: %d\n"), type, logId, viewIndex);

  1657 		TEST(changes.Find(logId)==i);

  1658 		TEST(changes.Find(logId, ELogChangeTypeEventAdded)>=0);

  1659 		TEST(changes.Find(TLogId(100000000), ELogChangeTypeEventAdded)==KErrNotFound);

  1660 		TEST(changes.Find(logId, ELogChangeTypeLogCleared)==KErrNotFound);

  1661 		TEST(changes.FindByViewIndex(viewIndex)>=0);

  1662 		TEST(changes.Find(TLogId(100000000))==KErrNotFound);

  1663 		}

  1665 	CBufFlat* buffer = CBufFlat::NewL(10*1024);

  1666 	CleanupStack::PushL(buffer);

  1667 	RBufWriteStream wstr(*buffer,0);

  1668 	wstr << changes;

  1669 	wstr.CommitL();

  1670 	wstr.Close();

  1671 	RBufReadStream rstr(*buffer,0);

  1672 	CLogChangeDefinition* changes2 = CLogChangeDefinition::NewL(rstr);

  1673 	CleanupStack::PushL(changes2);

  1674 	rstr.Close();

  1676 	TEST(changes.Count()==changes2->Count());

  1678 	CleanupStack::PopAndDestroy(3); // changes2, buffer, view

  1680 	// Check the change was as expected

  1681 	TEST2(changes.Count(), 10);

  1682 	type = changes.At(0, logId, viewIndex);

  1684 	CleanupStack::PopAndDestroy(4, event); // changeObs, active, filter, event

  1686 	TEST2(type, ELogChangeTypeEventAdded);

  1687 	TEST2(viewIndex, 0); // first (newest) events in the view

  1689 	const TLogId expectedLogId = ((TLogId) 1);

  1690 	TEST2(logId, expectedLogId);

  1691 	}

  1693 void DoStartL()

  1694 	{

  1695 	CActiveScheduler::Install(new(ELeave)CActiveScheduler);

  1696 	RFs fs;

  1697 	LEAVE_IF_ERROR(fs.Connect());

  1698 	CleanupClosePushL(fs);

  1699 	CLogClient* client = CLogClient::NewL(fs);

  1700 	delete client;

  1701 	CleanupStack::PopAndDestroy(&fs);

  1702 	delete CActiveScheduler::Current();

  1703 	}

  1705 static TInt LaunchThread(TAny* /*aAny*/)

  1706 	{

  1707 	__UHEAP_MARK;

  1708 	CTrapCleanup* cleanup = CTrapCleanup::New();

  1709 	TRAPD(err, DoStartL());

  1710 	delete cleanup;

  1711 	__UHEAP_MARKEND;

  1712 	if(err != KErrNone)

  1713 		{

  1714 		RDebug::Print(_L("*** DoStartL() failed with err %d\r\n"), err);

  1715 		User::Panic(_L("ThrChk5"), 5);

  1716 		}

  1717 	return KErrNone;

  1718 	}

  1720 /**

  1721 @SYMTestCaseID          SYSLIB-LOGENG-CT-0849

  1722 @SYMTestCaseDesc	    Tests for creation of two simultaneous threads

  1723 @SYMTestPriority 	    High

  1724 @SYMTestActions  	    Create two threads,start and close the threads

  1725 @SYMTestExpectedResults Test must not fail

  1726 @SYMREQ                 REQ0000

  1727 */

  1728 LOCAL_C void TestStartupL()

  1729 	{

  1730 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0849 "));

  1731 	RThread thread1;

  1732 	RThread thread2;

  1734 	// Create the threads

  1735 	LEAVE_IF_ERROR(thread1.Create(_L("Thread1"), LaunchThread, KDefaultStackSize, KMinHeapSize , KMinHeapSize , NULL));

  1736 	LEAVE_IF_ERROR(thread2.Create(_L("Thread2"), LaunchThread, KDefaultStackSize, KMinHeapSize , KMinHeapSize, NULL));

  1738 	// Let them run

  1739 	TRequestStatus s1;

  1740 	thread1.Logon(s1);

  1741 	thread1.Resume();

  1743 	TRequestStatus s2;

  1744 	thread2.Logon(s2);

  1745 	thread2.Resume();

  1747 	User::WaitForRequest(s1);

  1748 	TEST(thread1.ExitType() != EExitPanic);

  1749 	thread1.Close();

  1751 	User::WaitForRequest(s2);

  1752 	TEST(thread2.ExitType() != EExitPanic);

  1753 	thread2.Close();

  1755 	TEST2(s1.Int(), KErrNone);

  1756 	TEST2(s2.Int(), KErrNone);

  1757 	}

  1759 /**

  1760 @SYMTestCaseID          SYSLIB-LOGENG-CT-0850

  1761 @SYMTestCaseDesc	    Tests for invalid database scheme

  1762 @SYMTestPriority 	    High

  1763 @SYMTestActions  	    Create a log event implementation,should leave if there is a problem

  1764 @SYMTestExpectedResults Test must not fail

  1765 @SYMREQ                 REQ0000

  1766 */

  1767 LOCAL_C void TestInvalidSchemaL()

  1768 	{

  1769 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0850 "));

  1770 	TestUtils::TestInvalidSchemaL();

  1771 	}

  1773 void doTestsL()

  1774 	{

  1775 	TestUtils::Initialize(_L("t_logapi"));

  1777 	// This test should be first to ensure no clients kicking around

  1778 	TheTest.Next(_L("Invalid database scheme"));

  1779 	TestInvalidSchemaL();

  1780 	theLog.Write(_L8("Test 0 OK\n"));

  1782 	TheTest.Start(_L("Simultaneous Startup"));

  1783 	TestStartupL();

  1784 	theLog.Write(_L8("Test 1 OK\n"));

  1786 	CLogChangeNotifier* notifier = CLogChangeNotifier::NewL();

  1787 	CleanupStack::PushL(notifier);

  1789 	TheTest.Next(_L("Dying thread test"));

  1790 	TestThreadDieL();

  1791 	theLog.Write(_L8("Test 2 OK\n"));

  1793 	TestUtils::DeleteDatabaseL();

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

  1796 	CleanupStack::PushL(client);

  1798 	CTestActive* active = new(ELeave) CTestActive(CActive::EPriorityIdle - 500);

  1799 	CleanupStack::PushL(active);

  1801 	TheTest.Next(_L("Additional tests on CLogChangeDefinition."));

  1802 	TestLogChangeDefinitionL(*client);

  1803 	theLog.Write(_L8("Test 2.1 OK\n"));

  1804 	TestUtils::DeleteDatabaseL();

  1806 	TheTest.Next(_L("Client death"));

  1807 	TestClientFailL();

  1808 	theLog.Write(_L8("Test 3 OK\n"));

  1810 	TheTest.Next(_L("Testing client API"));

  1811 	TestNoNotifierL();

  1812 	theLog.Write(_L8("Test 4 OK\n"));

  1814 	// Delay for testing change notification

  1815 	TInt delay = 5000000;

  1816 	User::After(delay);

  1819 	active->StartL();

  1820 	client->NotifyChange(delay, active->iStatus);

  1822 	TheTest.Next(_L("Delete Event Type"));

  1823 	TestDeleteEventTypeL(*client);

  1824 	theLog.Write(_L8("Test 5 OK\n"));

  1826 	CActiveScheduler::Start();

  1827 	TEST(active->iStatus.Int() >= 0);

  1829 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0834 Add Event Type "));

  1830 	TestAddEventTypeL(*client);

  1831 	theLog.Write(_L8("Test 6 OK\n"));

  1833 	// Must delete the database before testing

  1834 	// the notification API, since we just created the

  1835 	// entry in the previous test (6) and therefore

  1836 	// attempting to add the entry again just results in

  1837 	// KErrAlreadyExists and does not cause a change to the

  1838 	// database.

  1839 	TestUtils::DeleteDatabaseL();

  1841 	active->StartL();

  1842 	client->NotifyChange(delay, active->iStatus);

  1844 	TestAddEventTypeL(*client);

  1846 	CActiveScheduler::Start();

  1847 	TEST(active->iStatus.Int() >= 0);

  1848 	active->StartL();

  1849 	client->NotifyChange(delay, active->iStatus);

  1851 	// The following doesn't make any changes

  1852 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0835 Get Event Type "));

  1853 	TestGetEventTypeL(*client);

  1854 	theLog.Write(_L8("Test 7 OK\n"));

  1856 	TheTest.Next(_L("Change Event Type"));

  1857 	TestChangeEventTypeL(*client);

  1858 	theLog.Write(_L8("Test 8 OK\n"));

  1860 	CActiveScheduler::Start();

  1861 	TEST(active->iStatus.Int() >= 0);

  1862 	active->StartL();

  1863 	client->NotifyChange(delay, active->iStatus);

  1865 	TheTest.Next(_L("Delete Event Type"));

  1866 	TestDeleteEventTypeL(*client);

  1867 	theLog.Write(_L8("Test 9 OK\n"));

  1869 	CActiveScheduler::Start();

  1870 	TEST(active->iStatus.Int() >= 0);

  1871 	active->StartL();

  1872 	client->NotifyChange(delay, active->iStatus);

  1874 	TheTest.Next(_L("Add Event"));

  1875 	TestAddEventL(*client);

  1876 	theLog.Write(_L8("Test 10 OK\n"));

  1878 	CActiveScheduler::Start();

  1879 	TEST(active->iStatus.Int() >= 0);

  1880 	active->StartL();

  1881 	client->NotifyChange(delay, active->iStatus);

  1883 	// The following doesn't make any changes

  1884 	TheTest.Next(_L("Get Event"));

  1885 	TestGetEventL(*client);

  1886 	theLog.Write(_L8("Test 11 OK\n"));

  1888 	TheTest.Next(_L("Change Event"));

  1889 	TestChangeEventL(*client);

  1890 	theLog.Write(_L8("Test 12 OK\n"));

  1892 	CActiveScheduler::Start();

  1893 	TEST(active->iStatus.Int() >= 0);

  1894 	active->StartL();

  1895 	client->NotifyChange(delay, active->iStatus);

  1897 	TheTest.Next(_L("Delete Event"));

  1898 	TestDeleteEventL(*client);

  1899 	theLog.Write(_L8("Test 13 OK\n"));

  1901 	CActiveScheduler::Start();

  1902 	TEST(active->iStatus.Int() >= 0);

  1903 	active->StartL();

  1904 	client->NotifyChange(delay, active->iStatus);

  1906 	// The following doesn't make any changes

  1907 	TheTest.Next(_L("Get Config"));

  1908 	TestGetConfigL(*client);

  1909 	theLog.Write(_L8("Test 14 OK\n"));

  1911 	TheTest.Next(_L("Change Config"));

  1912 	TestChangeConfigL(*client);

  1913 	theLog.Write(_L8("Test 15 OK\n"));

  1915 	CActiveScheduler::Start();

  1916 	TEST(active->iStatus.Int() >= 0);

  1917 	active->StartL();

  1918 	client->NotifyChange(delay*3, active->iStatus);

  1920 	// The following doesn't make any changes

  1921 	TheTest.Next(_L("Get String"));

  1922 	TestGetStringL(*client);

  1923 	theLog.Write(_L8("Test 16 OK\n"));

  1925 	TheTest.Next(_L("Clear Event Log"));

  1926 	TestClearEventLogL(*client);

  1927 	theLog.Write(_L8("Test 17 OK\n"));

  1929 	CActiveScheduler::Start();

  1930 	TEST(active->iStatus.Int() >= 0);

  1931 	active->StartL();

  1932 	client->NotifyChange(delay, active->iStatus);

  1934 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0833 Test global change API "));

  1935 	TestClientObserverMechanismL(*client);

  1936 	theLog.Write(_L8("Test 18 OK\n"));

  1938 	TheTest.Next(_L("Multiple client access"));

  1939 	TestMultipleClientAccessL();

  1940 	theLog.Write(_L8("Test 19 OK\n"));

  1942 	theLog.Write(_L8("Destroying: active\n"));

  1943 	CleanupStack::PopAndDestroy(active);

  1944 	theLog.Write(_L8("Destroyed ok\n"));

  1945 	theLog.Write(_L8("Destroying: client\n"));

  1946 	CleanupStack::PopAndDestroy(client);

  1947 	theLog.Write(_L8("Destroyed ok\n"));

  1948 	theLog.Write(_L8("Destroying: notifier\n"));

  1949 	CleanupStack::PopAndDestroy(notifier);

  1950 	theLog.Write(_L8("Destroyed ok\n"));

  1953 #ifdef SYSLIBS_TEST

  1954 	theLog.Write(_L8("Preparing the context for the test : @SYMTestCaseID:SYSLIB-LOGENG-UT-4015... \n"));

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

  1956 	TestUtils::DeleteDatabaseL();

  1957 	theLog.Write(_L8("Allocating a new CLogClient object... \n"));

  1958 	CLogClient* theClient = CLogClient::NewL(theFs);

  1959 	CleanupStack::PushL(theClient);

  1960 	TheTest.Next(_L("TestGetConfigSettingsFromRepositoryFileL () "));

  1961 	TestGetConfigSettingsFromRepositoryFileL(*theClient);

  1962 	theLog.Write(_L8("TestGetConfigSettingsFromRepositoryFileL () OK\n"));

  1963 	theLog.Write(_L8("Destroying the CLogClient object... \n"));

  1964 	CleanupStack::PopAndDestroy(theClient);

  1965 	theLog.Write(_L8("Destroyed ok\n"));

  1966 #else

  1967 	theLog.Write(_L8("The Test PREQ2103 works only when SYSLIBS_TEST macro is defined"));

  1968 #endif

  1969 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--