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 <s32mem.h>

    18 #include <e32math.h>

    19 

    20 #include "TEST.H"

    21 #include <logview.h>

    22 

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

    24 

    25 #define UNUSED_VAR(a) a = a

    26 

    27 RTest test(_L("Log View Test Harness Number 1"));

    28 

    29 const TInt KTestLogNumberCharsToMatch = 9; // should be the same as KLogNumberCharsToMatch defined in LogServ\src\LOGFILTQ.CPP

    30 const TInt KTestEventNum = 10;

    31 const TUid KTestEventUid = {0x10005393};

    32 const TLogDurationType KTestDurationType = 0x12;

    33 const TLogContactItemId KTestContact = 0x1234;

    34 _LIT(KTestEventDesc, "Test Event");

    35 _LIT(KTestRemoteParty, "Test Remote Party");

    36 _LIT(KTestDirection, "Test Direction");

    37 _LIT(KTestStatus, "Test Status");

    38 _LIT(KTestNumber, "Test Number");

    39 _LIT(KThreadSemaphoreName, "T_VIEW1_TEST_CODE");

    40 

    41 

    42 TBool TheMatchingIsEnabled = EFalse;

    43 

    44 #define TEST_LOG_UID KTestEventUid

    45 

    46 //View's DoCancel() test

    47 void DoViewCancelTestL(CTestActive& aActive, CLogViewEvent& aView)

    48 	{

    49 	//Call FirstL() and cancel the operation

    50 	aActive.StartL();

    51 	(void)aView.FirstL(aActive.iStatus);

    52 	aView.Cancel();

    53 	TEST(!aView.IsActive());

    54 	CActiveScheduler::Start();

    55 	TEST2(aActive.iStatus.Int(), KErrCancel);

    56 	

    57 	//Call FirstL(). View cursor positioned on the first record.

    58 	aActive.StartL();

    59 	(void)aView.FirstL(aActive.iStatus);

    60 	CActiveScheduler::Start();

    61 	TEST2(aActive.iStatus.Int(), KErrNone);

    62 

    63 	//Call NextL() and cancel the operation

    64 	aActive.StartL();

    65 	(void)aView.NextL(aActive.iStatus);

    66 	aView.Cancel();

    67 	TEST(!aView.IsActive());

    68 	CActiveScheduler::Start();

    69 	TEST2(aActive.iStatus.Int(), KErrCancel);

    70 

    71 	//Call LastL() and cancel the operation

    72 	aActive.StartL();

    73 	(void)aView.LastL(aActive.iStatus);

    74 	aView.Cancel();

    75 	TEST(!aView.IsActive());

    76 	CActiveScheduler::Start();

    77 	TEST2(aActive.iStatus.Int(), KErrCancel);

    78 

    79 	//Call LastL(). View cursor positioned on the last record.

    80 	aActive.StartL();

    81 	(void)aView.LastL(aActive.iStatus);

    82 	CActiveScheduler::Start();

    83 	TEST2(aActive.iStatus.Int(), KErrNone);

    84 

    85 	//Call PreviousL() and cancel the operation

    86 	aActive.StartL();

    87 	(void)aView.PreviousL(aActive.iStatus);

    88 	aView.Cancel();

    89 	TEST(!aView.IsActive());

    90 	CActiveScheduler::Start();

    91 	TEST2(aActive.iStatus.Int(), KErrCancel);

    92 	}

    93 

    94 /**

    95 @SYMTestCaseID          SYSLIB-LOGENG-CT-0851

    96 @SYMTestCaseDesc	    Tests for adding event types to the log 

    97 @SYMTestPriority 	    High

    98 @SYMTestActions  	    Tests for adding events,check event count,clearing all the events

    99 @SYMTestExpectedResults Test must not fail

   100 @SYMREQ                 REQ0000

   101 */

   102 LOCAL_C void TestEventViewL(CLogClient& aClient)

   103 	{

   104 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0851 "));

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

   106 	CleanupStack::PushL(event);

   107 	event->SetEventType(KLogCallEventTypeUid);

   108 

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

   110 	CleanupStack::PushL(active);

   111 

   112 	TInt count;

   113 	for(count = 0; count < KTestEventNum; count++)

   114 		{

   115 		active->StartL();

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

   117 		CActiveScheduler::Start();

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

   119 		}

   120 

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

   122 	changeObs->SetActive();

   123 

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

   125 	CleanupStack::PushL(view);

   126 

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

   128 	CleanupStack::PushL(filter);

   129 

   130 	count = view->CountL();

   131 	TEST2(count, 0);

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

   133 	TEST(res);

   134 

   135 	// Move forward

   136 	count = KTestEventNum;

   137 	do	{

   138 		active->StartL();

   139 		CActiveScheduler::Start();

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

   141 

   142 		const TInt viewCount = view->CountL();

   143 		TEST2(viewCount, KTestEventNum);

   144 		const TLogId eventId = view->Event().Id();

   145 		TLogId id = --count;

   146 		TEST2(eventId, id);

   147 		}

   148 	while(view->NextL(active->iStatus));

   149 	TEST2(count, 0);

   150 

   151 	// Move back

   152 	while(view->PreviousL(active->iStatus))

   153 		{

   154 		active->StartL();

   155 		CActiveScheduler::Start();

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

   157 

   158 		TEST2(view->CountL(), KTestEventNum);

   159 		TLogId id = ++count;

   160 		TEST2(view->Event().Id(), id);

   161 		}

   162 	TEST(count == KTestEventNum - 1);

   163 

   164 	active->StartL();

   165 	res = view->FirstL(active->iStatus);

   166 	TEST(res);

   167 	CActiveScheduler::Start();

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

   169 

   170 	active->StartL();

   171 	res = view->LastL(active->iStatus);

   172 	TEST(res);

   173 	CActiveScheduler::Start();

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

   175 

   176 	// Nothing has changed in the view yet

   177 	TEST(!changeObs->HaveChanges());

   178 

   179 	DoViewCancelTestL(*active, *view);

   180 	

   181 	TTime now;

   182 	now.UniversalTime();

   183 	now+=(TTimeIntervalDays) 1;

   184 

   185 	// Clear all the events

   186 	active->StartL();

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

   188 	CActiveScheduler::Start();

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

   190 

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

   192 	TEST(!res);

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

   194 	res = view->FirstL(active->iStatus);

   195 	TEST(!res);

   196 	res = view->LastL(active->iStatus);

   197 	TEST(!res);

   198 	res = view->NextL(active->iStatus);

   199 	TEST(!res);

   200 	res = view->PreviousL(active->iStatus);

   201 	TEST(!res);

   202 	

   203 	CleanupStack::PopAndDestroy(5, event); // filter, view, changeObs, active, event

   204 

   205 	CLogSchedulerTimer* timer = CLogSchedulerTimer::NewLC();

   206 	timer->Wait(10 * 1000000);

   207 	CleanupStack::PopAndDestroy(timer);

   208 	}

   209 

   210 /**

   211 @SYMTestCaseID          SYSLIB-LOGENG-CT-0852

   212 @SYMTestCaseDesc	    Tests for adding event types to the filter list

   213 @SYMTestPriority 	    High

   214 @SYMTestActions  	    Set the configuration data of event type.Add the event type to the filter and 

   215                         compare the configuration data of event type and from filter view.

   216 @SYMTestExpectedResults Test must not fail

   217 @SYMREQ                 REQ0000

   218 */

   219 LOCAL_C void TestViewFilterL(CLogClient& aClient, CLogFilter& aFilter)

   220 	{

   221 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0852 "));

   222 	CLogViewEvent* view = CLogViewEvent::NewL(aClient);

   223 	CleanupStack::PushL(view);

   224 

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

   226 	CleanupStack::PushL(event);

   227 

   228 	event->SetEventType(KTestEventUid);

   229 	event->SetRemoteParty(aFilter.RemoteParty());

   230 	event->SetDirection(aFilter.Direction());

   231 	event->SetDurationType(aFilter.DurationType());

   232 	event->SetStatus(aFilter.Status());

   233 	event->SetContact(aFilter.Contact());

   234 	event->SetNumber(aFilter.Number());

   235 

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

   237 	CleanupStack::PushL(active);

   238 

   239 	if (view->SetFilterL(aFilter, active->iStatus))

   240 		{

   241 		active->StartL();

   242 		CActiveScheduler::Start();

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

   244 		}

   245 

   246 	TInt total = view->CountL();

   247 

   248 	active->StartL();

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

   250 	CActiveScheduler::Start();

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

   252 

   253 	TBool res = view->SetFilterL(aFilter, active->iStatus);

   254 	TEST(res);

   255 	active->StartL();

   256 	CActiveScheduler::Start();

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

   258 

   259 	TEST(view->CountL() == total + 1);

   260 

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

   262 	TEST(event->RemoteParty() == aFilter.RemoteParty());

   263 	TEST(event->Direction() == aFilter.Direction());

   264 	TEST(event->DurationType() == aFilter.DurationType());

   265 	TEST(event->Status() == aFilter.Status());

   266 	TEST(event->Contact() == aFilter.Contact());

   267 	TEST(event->Number() == aFilter.Number());

   268 

   269 	TTime now;

   270 	now.UniversalTime();

   271 

   272 	TInt count = 1;

   273 

   274 	while(view->NextL(active->iStatus))

   275 		{

   276 		count++;

   277 		TEST(count <= total + 1);

   278 

   279 		active->StartL();

   280 		CActiveScheduler::Start();

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

   282 

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

   284 

   285 		if (aFilter.EventType() != KNullUid)

   286 			TEST(event->EventType() == aFilter.EventType());

   287 

   288 		if (aFilter.RemoteParty().Length() > 0)

   289 			TEST(event->RemoteParty() == aFilter.RemoteParty());

   290 

   291 		if (aFilter.Direction().Length() > 0)

   292 			TEST(event->Direction() == aFilter.Direction());

   293 

   294 		if (aFilter.DurationType() != KLogNullDurationType)

   295 			TEST(event->DurationType() == aFilter.DurationType());

   296 

   297 		if (aFilter.Status().Length() > 0)

   298 			TEST(event->Status() == aFilter.Status());

   299 

   300 		if (aFilter.Contact() > KLogNullContactId)

   301 			TEST(event->Contact() == aFilter.Contact());

   302 

   303 		if (aFilter.Number().Length() > 0)

   304 			TEST(event->Number() == aFilter.Number());

   305 		}

   306 

   307 	TEST(count == total + 1);

   308 

   309 	CleanupStack::PopAndDestroy(3); // active, event, view;

   310 	}

   311 

   312 /**

   313 @SYMTestCaseID          SYSLIB-LOGENG-CT-0853

   314 @SYMTestCaseDesc	    Tests for filtering the log view

   315 @SYMTestPriority 	    High

   316 @SYMTestActions  	    Tests for the log view filter,which is set with different configuration data

   317 @SYMTestExpectedResults Test must not fail

   318 @SYMREQ                 REQ0000

   319 */

   320 LOCAL_C void TestEventViewFilter1L(CLogClient& aClient)

   321 	{

   322 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0853 "));

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

   324 	CleanupStack::PushL(active);

   325 

   326 	// Create a test event type

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

   328 	CleanupStack::PushL(type);

   329 

   330 	type->SetUid(KTestEventUid);

   331 	type->SetDescription(KTestEventDesc);

   332 	type->SetLoggingEnabled(ETrue);

   333 

   334 	// Register the event type

   335 	active->StartL();

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

   337 	CActiveScheduler::Start();

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

   339 

   340 	CleanupStack::PopAndDestroy(); // type

   341 

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

   343 	CleanupStack::PushL(filter);

   344 

   345 	filter->SetEventType(KTestEventUid);

   346 	TestViewFilterL(aClient, *filter);

   347 

   348 	filter->SetEventType(KTestEventUid);

   349 	filter->SetRemoteParty(KTestRemoteParty);

   350 	TestViewFilterL(aClient, *filter);

   351 

   352 	filter->SetEventType(KTestEventUid);

   353 	filter->SetRemoteParty(KTestRemoteParty);

   354 	filter->SetDirection(KTestDirection);

   355 	TestViewFilterL(aClient, *filter);

   356 

   357 	filter->SetEventType(KTestEventUid);

   358 	filter->SetRemoteParty(KTestRemoteParty);

   359 	filter->SetDirection(KTestDirection);

   360 	filter->SetDurationType(KTestDurationType);

   361 	TestViewFilterL(aClient, *filter);

   362 

   363 	filter->SetEventType(KTestEventUid);

   364 	filter->SetRemoteParty(KTestRemoteParty);

   365 	filter->SetDirection(KTestDirection);

   366 	filter->SetDurationType(KTestDurationType);

   367 	filter->SetStatus(KTestStatus);

   368 	TestViewFilterL(aClient, *filter);

   369 

   370 	filter->SetEventType(KTestEventUid);

   371 	filter->SetRemoteParty(KTestRemoteParty);

   372 	filter->SetDirection(KTestDirection);

   373 	filter->SetDurationType(KTestDurationType);

   374 	filter->SetStatus(KTestStatus);

   375 	filter->SetContact(KTestContact);

   376 	TestViewFilterL(aClient, *filter);

   377 

   378 	filter->SetEventType(KTestEventUid);

   379 	filter->SetRemoteParty(KTestRemoteParty);

   380 	filter->SetDirection(KTestDirection);

   381 	filter->SetDurationType(KTestDurationType);

   382 	filter->SetStatus(KTestStatus);

   383 	filter->SetContact(KTestContact);

   384 	filter->SetNumber(KTestNumber);

   385 	TestViewFilterL(aClient, *filter);

   386 

   387 	CleanupStack::PopAndDestroy(); // filter

   388 

   389 	filter = CLogFilter::NewL();

   390 	CleanupStack::PushL(filter);

   391 

   392 	filter->SetRemoteParty(KTestRemoteParty);

   393 	TestViewFilterL(aClient, *filter);

   394 

   395 	filter->SetRemoteParty(KTestRemoteParty);

   396 	filter->SetDirection(KTestDirection);

   397 	TestViewFilterL(aClient, *filter);

   398 

   399 	filter->SetRemoteParty(KTestRemoteParty);

   400 	filter->SetDirection(KTestDirection);

   401 	filter->SetDurationType(KTestDurationType);

   402 	TestViewFilterL(aClient, *filter);

   403 

   404 	filter->SetRemoteParty(KTestRemoteParty);

   405 	filter->SetDirection(KTestDirection);

   406 	filter->SetDurationType(KTestDurationType);

   407 	filter->SetStatus(KTestStatus);

   408 	TestViewFilterL(aClient, *filter);

   409 

   410 	filter->SetRemoteParty(KTestRemoteParty);

   411 	filter->SetDirection(KTestDirection);

   412 	filter->SetDurationType(KTestDurationType);

   413 	filter->SetStatus(KTestStatus);

   414 	filter->SetContact(KTestContact);

   415 	TestViewFilterL(aClient, *filter);

   416 

   417 	filter->SetRemoteParty(KTestRemoteParty);

   418 	filter->SetDirection(KTestDirection);

   419 	filter->SetDurationType(KTestDurationType);

   420 	filter->SetStatus(KTestStatus);

   421 	filter->SetContact(KTestContact);

   422 	filter->SetNumber(KTestNumber);

   423 	TestViewFilterL(aClient, *filter);

   424 

   425 	CleanupStack::PopAndDestroy(); // filter

   426 

   427 	filter = CLogFilter::NewL();

   428 	CleanupStack::PushL(filter);

   429 

   430 	filter->SetDirection(KTestDirection);

   431 	TestViewFilterL(aClient, *filter);

   432 

   433 	filter->SetDirection(KTestDirection);

   434 	filter->SetDurationType(KTestDurationType);

   435 	TestViewFilterL(aClient, *filter);

   436 

   437 	filter->SetDirection(KTestDirection);

   438 	filter->SetDurationType(KTestDurationType);

   439 	filter->SetStatus(KTestStatus);

   440 	TestViewFilterL(aClient, *filter);

   441 

   442 	filter->SetDirection(KTestDirection);

   443 	filter->SetDurationType(KTestDurationType);

   444 	filter->SetStatus(KTestStatus);

   445 	filter->SetContact(KTestContact);

   446 	TestViewFilterL(aClient, *filter);

   447 

   448 	filter->SetDirection(KTestDirection);

   449 	filter->SetDurationType(KTestDurationType);

   450 	filter->SetStatus(KTestStatus);

   451 	filter->SetContact(KTestContact);

   452 	filter->SetNumber(KTestNumber);

   453 	TestViewFilterL(aClient, *filter);

   454 

   455 	CleanupStack::PopAndDestroy(); // filter

   456 

   457 	filter = CLogFilter::NewL();

   458 	CleanupStack::PushL(filter);

   459 

   460 	filter->SetDurationType(KTestDurationType);

   461 	TestViewFilterL(aClient, *filter);

   462 

   463 	filter->SetDurationType(KTestDurationType);

   464 	filter->SetStatus(KTestStatus);

   465 	TestViewFilterL(aClient, *filter);

   466 

   467 	filter->SetDurationType(KTestDurationType);

   468 	filter->SetStatus(KTestStatus);

   469 	filter->SetContact(KTestContact);

   470 	TestViewFilterL(aClient, *filter);

   471 

   472 	filter->SetDurationType(KTestDurationType);

   473 	filter->SetStatus(KTestStatus);

   474 	filter->SetContact(KTestContact);

   475 	filter->SetNumber(KTestNumber);

   476 	TestViewFilterL(aClient, *filter);

   477 

   478 	CleanupStack::PopAndDestroy(); // filter

   479 

   480 	filter = CLogFilter::NewL();

   481 	CleanupStack::PushL(filter);

   482 

   483 	filter->SetStatus(KTestStatus);

   484 	TestViewFilterL(aClient, *filter);

   485 

   486 	filter->SetStatus(KTestStatus);

   487 	filter->SetContact(KTestContact);

   488 	TestViewFilterL(aClient, *filter);

   489 

   490 	filter->SetStatus(KTestStatus);

   491 	filter->SetContact(KTestContact);

   492 	filter->SetNumber(KTestNumber);

   493 	TestViewFilterL(aClient, *filter);

   494 

   495 	CleanupStack::PopAndDestroy(); // filter

   496 

   497 	filter = CLogFilter::NewL();

   498 	CleanupStack::PushL(filter);

   499 

   500 	filter->SetContact(KTestContact);

   501 	TestViewFilterL(aClient, *filter);

   502 

   503 	filter->SetContact(KTestContact);

   504 	filter->SetNumber(KTestNumber);

   505 	TestViewFilterL(aClient, *filter);

   506 

   507 	CleanupStack::PopAndDestroy(); // filter

   508 

   509 	filter = CLogFilter::NewL();

   510 	CleanupStack::PushL(filter);

   511 

   512 	filter->SetNumber(KTestNumber);

   513 	TestViewFilterL(aClient, *filter);

   514 

   515 	CleanupStack::PopAndDestroy(2); // filter, active

   516 	}

   517 

   518 /**

   519 @SYMTestCaseID          SYSLIB-LOGENG-CT-0854

   520 @SYMTestCaseDesc	    Tests for filtering list event types

   521 @SYMTestPriority 	    High

   522 @SYMTestActions  	    Get the count of all event types,call,data,fax events.

   523                         Add some event types to the filter,test for the new count

   524 						Check for non existing event type.

   525 @SYMTestExpectedResults Test must not fail

   526 @SYMREQ                 REQ0000

   527 */

   528 LOCAL_C void TestEventViewFilter2L(CLogClient& aClient)

   529 	{

   530 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0854 "));

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

   532 	CleanupStack::PushL(active);

   533 

   534 	CLogViewEvent* view = CLogViewEvent::NewL(aClient);

   535 	CleanupStack::PushL(view);

   536 

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

   538 	CleanupStack::PushL(filter);

   539 

   540 	// Get total count of all events

   541 	if (view->SetFilterL(*filter, active->iStatus))

   542 		{

   543 		active->StartL();

   544 		CActiveScheduler::Start();

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

   546 		}

   547 	TInt total = view->CountL();

   548 

   549 	filter->SetEventType(KLogCallEventTypeUid);

   550 

   551 	// Get number of call events

   552 	if (view->SetFilterL(*filter, active->iStatus))

   553 		{

   554 		active->StartL();

   555 		CActiveScheduler::Start();

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

   557 		}

   558 	TInt calls = view->CountL();

   559 

   560 	filter->SetEventType(KLogDataEventTypeUid);

   561 

   562 	// Get number of data events

   563 	if (view->SetFilterL(*filter, active->iStatus))

   564 		{

   565 		active->StartL();

   566 		CActiveScheduler::Start();

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

   568 		}

   569 	TInt data = view->CountL();

   570 

   571 	filter->SetEventType(KLogFaxEventTypeUid);

   572 

   573 	// Get number of fax events

   574 	if (view->SetFilterL(*filter, active->iStatus))

   575 		{

   576 		active->StartL();

   577 		CActiveScheduler::Start();

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

   579 		}

   580 	TInt fax = view->CountL();

   581 

   582 	filter->SetEventType(KLogLbsSelfLocateEventTypeUid);

   583 

   584 	// Get number of Lbs self locate events

   585 	if (view->SetFilterL(*filter, active->iStatus))

   586 		{

   587 		active->StartL();

   588 		CActiveScheduler::Start();

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

   590 		}

   591 	TInt lbsSelf = view->CountL();

   592 

   593 	filter->SetEventType(KLogLbsExternalLocateEventTypeUid);

   594 

   595 	// Get number of Lbs self locate events

   596 	if (view->SetFilterL(*filter, active->iStatus))

   597 		{

   598 		active->StartL();

   599 		CActiveScheduler::Start();

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

   601 		}

   602 	TInt lbsExternal = view->CountL();

   603 

   604 	filter->SetEventType(KLogLbsTransmitLocationEventTypeUid);

   605 

   606 	// Get number of Lbs transmit location events

   607 	if (view->SetFilterL(*filter, active->iStatus))

   608 		{

   609 		active->StartL();

   610 		CActiveScheduler::Start();

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

   612 		}

   613 	TInt lbsXmitLoc = view->CountL();

   614 

   615 	filter->SetEventType(KLogLbsNetworkLocateEventTypeUid);

   616 

   617 	// Get number of Lbs network locate events

   618 	if (view->SetFilterL(*filter, active->iStatus))

   619 		{

   620 		active->StartL();

   621 		CActiveScheduler::Start();

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

   623 		}

   624 	TInt lbsNetwork = view->CountL();

   625 

   626 	filter->SetEventType(KLogLbsAssistanceDataEventTypeUid);

   627 

   628 	// Get number of Lbs assistance data events

   629 	if (view->SetFilterL(*filter, active->iStatus))

   630 		{

   631 		active->StartL();

   632 		CActiveScheduler::Start();

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

   634 		}

   635 	TInt lbsAssistance = view->CountL();

   636 

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

   638 	CleanupStack::PushL(event);

   639 

   640 	event->SetEventType(KLogCallEventTypeUid);

   641 

   642 	// Add two call events

   643 	active->StartL();

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

   645 	CActiveScheduler::Start();

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

   647 

   648 	active->StartL();

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

   650 	CActiveScheduler::Start();

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

   652 

   653 	event->SetEventType(KLogDataEventTypeUid);

   654 

   655 	// Add two data events

   656 	active->StartL();

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

   658 	CActiveScheduler::Start();

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

   660 

   661 	active->StartL();

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

   663 	CActiveScheduler::Start();

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

   665 

   666 	// Filter all event types

   667 	filter->SetEventType(KNullUid);

   668 

   669 	// Get view of all events

   670 	active->StartL();

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

   672 	TEST(res);

   673 	CActiveScheduler::Start();

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

   675 

   676 	// Check the count is correct

   677 	TEST(view->CountL() == total + 4);

   678 

   679 	filter->SetEventType(KLogCallEventTypeUid);

   680 

   681 	// Get view of call events

   682 	active->StartL();

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

   684 	TEST(res);

   685 	CActiveScheduler::Start();

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

   687 

   688 	TEST(view->CountL() == calls + 2);

   689 

   690 	filter->SetEventType(KLogDataEventTypeUid);

   691 

   692 	// Get view of data events

   693 	active->StartL();

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

   695 	TEST(res);

   696 	CActiveScheduler::Start();

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

   698 

   699 	TEST(view->CountL() == data + 2);

   700 

   701 	filter->SetEventType(KLogFaxEventTypeUid);

   702 

   703 	// Get view of fax events

   704 	if (view->SetFilterL(*filter, active->iStatus))

   705 		{

   706 		active->StartL();

   707 		CActiveScheduler::Start();

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

   709 		}

   710 	TEST2(view->CountL(), fax);

   711 

   712 	filter->SetEventType(KLogLbsSelfLocateEventTypeUid);

   713 

   714 	// Get number of Lbs self locate events

   715 	if (view->SetFilterL(*filter, active->iStatus))

   716 		{

   717 		active->StartL();

   718 		CActiveScheduler::Start();

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

   720 		}

   721 	TEST2(view->CountL(), lbsSelf);

   722 

   723 	filter->SetEventType(KLogLbsExternalLocateEventTypeUid);

   724 

   725 	// Get number of Lbs self locate events	

   726 	if (view->SetFilterL(*filter, active->iStatus))

   727 		{

   728 		active->StartL();

   729 		CActiveScheduler::Start();

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

   731 		}

   732 	TEST2(view->CountL(), lbsExternal);

   733 

   734 	filter->SetEventType(KLogLbsTransmitLocationEventTypeUid);

   735 

   736 	// Get number of Lbs transmit location events

   737 	if (view->SetFilterL(*filter, active->iStatus))

   738 		{

   739 		active->StartL();

   740 		CActiveScheduler::Start();

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

   742 		}

   743 	TEST2(view->CountL(), lbsXmitLoc);

   744 

   745 	filter->SetEventType(KLogLbsNetworkLocateEventTypeUid);

   746 

   747 	// Get number of Lbs network locate events

   748 	if (view->SetFilterL(*filter, active->iStatus))

   749 		{

   750 		active->StartL();

   751 		CActiveScheduler::Start();

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

   753 		}

   754 	TEST2(view->CountL(), lbsNetwork);

   755 

   756 	filter->SetEventType(KLogLbsAssistanceDataEventTypeUid);

   757 

   758 	// Get number of Lbs assistance data events

   759 	if (view->SetFilterL(*filter, active->iStatus))

   760 		{

   761 		active->StartL();

   762 		CActiveScheduler::Start();

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

   764 		}

   765 	TEST2(view->CountL(), lbsAssistance);

   766 

   767 	// Test a non existing event type

   768 	filter->SetEventType(TUid::Uid(0x12345678));

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

   770 	TEST(!res);

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

   772 

   773 	CleanupStack::PopAndDestroy(4); // view, filter, event, active

   774 	}

   775 

   776 /**

   777 @SYMTestCaseID          SYSLIB-LOGENG-CT-0855

   778 @SYMTestCaseDesc	    Tests for CLogViewRecent::SetRecentListL() function 

   779 @SYMTestPriority 	    High

   780 @SYMTestActions  	    Tests for the count of events,outgoing calls.

   781 @SYMTestExpectedResults Test must not fail

   782 @SYMREQ                 REQ0000

   783 */

   784 LOCAL_C void TestRecentView1L(CLogClient& aClient)

   785 	{

   786 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0855 "));

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

   788 	CleanupStack::PushL(event);

   789 

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

   791 	CleanupStack::PushL(active);

   792 

   793 	CLogViewRecent* view = CLogViewRecent::NewL(aClient);

   794 	CleanupStack::PushL(view);

   795 

   796 	// Incoming

   797 	TBuf<KLogMaxDirectionLength> buf;

   798 	aClient.GetString(buf, R_LOG_DIR_IN);

   799 

   800 	event->SetEventType(KLogCallEventTypeUid);

   801 	event->SetDirection(buf);

   802 

   803 	TInt count;

   804 	for(count = 0; count < KTestEventNum; count++)

   805 		{

   806 		event->SetContact(count);

   807 

   808 		active->StartL();

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

   810 		CActiveScheduler::Start();

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

   812 		}

   813 

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

   815 	TBool res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus);

   816 	TEST(res);

   817 

   818 	// Move forward

   819 	count = KTestEventNum;

   820 	do	{

   821 		active->StartL();

   822 		CActiveScheduler::Start();

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

   824 

   825 		TEST2(view->CountL(), KTestEventNum);

   826 		TEST2(view->RecentList(), KLogRecentIncomingCalls);

   827 		count--;

   828 		}

   829 	while(view->NextL(active->iStatus));

   830 	TEST2(count, 0);

   831 	TEST2(view->CountL(), KTestEventNum);

   832 

   833 	// Move back

   834 	while(view->PreviousL(active->iStatus))

   835 		{

   836 		active->StartL();

   837 		CActiveScheduler::Start();

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

   839 

   840 		TEST2(view->CountL(), KTestEventNum);

   841 		TEST2(view->RecentList(), KLogRecentIncomingCalls);

   842 		count++;

   843 		}

   844 	TEST(count == KTestEventNum - 1);

   845 

   846 	active->StartL();

   847 	res = view->FirstL(active->iStatus);

   848 	TEST(res);

   849 	CActiveScheduler::Start();

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

   851 

   852 	active->StartL();

   853 	res = view->LastL(active->iStatus);

   854 	TEST(res);

   855 	CActiveScheduler::Start();

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

   857 

   858 	TEST2(view->CountL(), KTestEventNum);

   859 

   860 	// Outgoing

   861 	res = view->SetRecentListL(KLogRecentOutgoingCalls, active->iStatus);

   862 	TEST(!res);

   863 	count = view->CountL();

   864 	TEST2(count, 0);

   865 	CleanupStack::PopAndDestroy(view);

   866 	//

   867 	view = CLogViewRecent::NewL(aClient);

   868 	CleanupStack::PushL(view);

   869 	res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus);

   870 	TEST(res);

   871 	TEST2(view->CountL(), KTestEventNum);

   872 	active->StartL();

   873 	CActiveScheduler::Start();

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

   875 

   876 	aClient.GetString(buf, R_LOG_DIR_OUT);

   877 

   878 	event->SetEventType(KLogCallEventTypeUid);

   879 	event->SetDirection(buf);

   880 

   881 	for(count = 0; count < KTestEventNum; count++)

   882 		{

   883 		event->SetContact(count);

   884 

   885 		active->StartL();

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

   887 		CActiveScheduler::Start();

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

   889 		}

   890 

   891 	count = view->CountL();

   892 	TEST2(count, KTestEventNum);

   893 	res = view->SetRecentListL(KLogRecentOutgoingCalls, active->iStatus);

   894 	TEST(res);

   895 

   896 	// Move forward

   897 	count = KTestEventNum;

   898 	do	{

   899 		active->StartL();

   900 		CActiveScheduler::Start();

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

   902 

   903 		TEST2(view->CountL(), KTestEventNum);

   904 		TEST2(view->RecentList(), KLogRecentOutgoingCalls);

   905 		count--;

   906 		}

   907 	while(view->NextL(active->iStatus));

   908 	TEST2(count, 0);

   909 	TEST2(view->CountL(), KTestEventNum);

   910 

   911 	// Move back

   912 	while(view->PreviousL(active->iStatus))

   913 		{

   914 		active->StartL();

   915 		CActiveScheduler::Start();

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

   917 

   918 		TEST2(view->CountL(), KTestEventNum);

   919 		TEST2(view->RecentList(), KLogRecentOutgoingCalls);

   920 		count++;

   921 		}

   922 	TEST(count == KTestEventNum - 1);

   923 

   924 	active->StartL();

   925 	res = view->FirstL(active->iStatus);

   926 	TEST(res);

   927 	CActiveScheduler::Start();

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

   929 

   930 	active->StartL();

   931 	res = view->LastL(active->iStatus);

   932 	TEST(res);

   933 	CActiveScheduler::Start();

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

   935 

   936 	// Missed

   937 	aClient.GetString(buf, R_LOG_DIR_MISSED);

   938 

   939 	event->SetEventType(KLogCallEventTypeUid);

   940 	event->SetDirection(buf);

   941 

   942 	TEST2(view->CountL(), KTestEventNum);

   943 	res = view->SetRecentListL(KLogRecentMissedCalls, active->iStatus);

   944 	TEST(!res);

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

   946 

   947 	for(count = 0; count < KTestEventNum; count++)

   948 		{

   949 		event->SetContact(count);

   950 

   951 		active->StartL();

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

   953 		CActiveScheduler::Start();

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

   955 

   956 		// Test INC123066 - LogView not updated if log count is zero at

   957 		// time of SetFilterL.

   958 		TEST2(view->CountL(), count+1);

   959 		}

   960 

   961 

   962 	// Move forward

   963 	count = KTestEventNum;

   964 	while(view->NextL(active->iStatus))

   965 		{

   966 		active->StartL();

   967 		CActiveScheduler::Start();

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

   969 

   970 		TEST2(view->CountL(), KTestEventNum);

   971 		TEST2(view->RecentList(), KLogRecentMissedCalls);

   972 		count--;

   973 		}

   974 	TEST2(count, 0);

   975 

   976 	// Move back

   977 	while(view->PreviousL(active->iStatus))

   978 		{

   979 		active->StartL();

   980 		CActiveScheduler::Start();

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

   982 

   983 		TEST2(view->CountL(), KTestEventNum);

   984 		TEST2(view->RecentList(), KLogRecentMissedCalls);

   985 		count++;

   986 		}

   987 	TEST(count == KTestEventNum - 1);

   988 

   989 	active->StartL();

   990 	res = view->FirstL(active->iStatus);

   991 	TEST(res);

   992 	CActiveScheduler::Start();

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

   994 

   995 	active->StartL();

   996 	res = view->LastL(active->iStatus);

   997 	TEST(res);

   998 	CActiveScheduler::Start();

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

  1000 

  1001 	// All

  1002 	TEST2(view->CountL(), KTestEventNum);

  1003 	res = view->SetRecentListL(KLogNullRecentList, active->iStatus);

  1004 	TEST(res);

  1005 

  1006 	// Move forward

  1007 	count = KTestEventNum * 3;

  1008 	TEST2(view->CountL(), count);

  1009 	do	{

  1010 		active->StartL();

  1011 		CActiveScheduler::Start();

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

  1013 

  1014 		TEST(view->CountL() == KTestEventNum * 3);

  1015 		count--;

  1016 		}

  1017 	while(view->NextL(active->iStatus));

  1018 	TEST2(count, 0);

  1019 

  1020 	// Move back

  1021 	while(view->PreviousL(active->iStatus))

  1022 		{

  1023 		active->StartL();

  1024 		CActiveScheduler::Start();

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

  1026 

  1027 		TEST(view->CountL() == KTestEventNum * 3);

  1028 		count++;

  1029 		}

  1030 	TEST(count == KTestEventNum * 3 - 1);

  1031 

  1032 	active->StartL();

  1033 	res = view->FirstL(active->iStatus);

  1034 	TEST(res);

  1035 	CActiveScheduler::Start();

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

  1037 

  1038 	active->StartL();

  1039 	res = view->LastL(active->iStatus);

  1040 	TEST(res);

  1041 	CActiveScheduler::Start();

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

  1043 

  1044 	CleanupStack::PopAndDestroy(3); // view, active, event

  1045 	theLog.Write(_L8("Test 3.1 OK\n"));

  1046 	}

  1047 

  1048 /**

  1049 @SYMTestCaseID          SYSLIB-LOGENG-CT-0856

  1050 @SYMTestCaseDesc	    Tests for CLogViewRecent::SetRecentListL(),DuplicatesL() functions

  1051 @SYMTestPriority 	    High

  1052 @SYMTestActions  	    Tests for the count of events in the log

  1053 @SYMTestExpectedResults Test must not fail

  1054 @SYMREQ                 REQ0000

  1055 */

  1056 LOCAL_C void TestRecentView2L(CLogClient& aClient)

  1057 	{

  1058 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0856 "));

  1059 	TInt count;

  1060 

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

  1062 	CleanupStack::PushL(event);

  1063 

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

  1065 	CleanupStack::PushL(active);

  1066 

  1067 	CLogViewRecent* view = CLogViewRecent::NewL(aClient);

  1068 	CleanupStack::PushL(view);

  1069 

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

  1071 	TBool res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus);

  1072 	TEST(res);

  1073 	active->StartL();

  1074 	CActiveScheduler::Start();

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

  1076 	count = view->CountL();

  1077 	TEST2(count, KTestEventNum);

  1078 

  1079 	aClient.ClearLog(KLogRecentIncomingCalls, active->iStatus);

  1080 	active->StartL();

  1081 	CActiveScheduler::Start();

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

  1083 

  1084 	count = view->CountL();

  1085 	TEST2(count, 0);

  1086 

  1087 	CleanupStack::PopAndDestroy(view);

  1088 	view = CLogViewRecent::NewL(aClient);

  1089 	CleanupStack::PushL(view);

  1090 

  1091 

  1092 	// Incoming

  1093 	TBuf<KLogMaxDirectionLength> buf;

  1094 	aClient.GetString(buf, R_LOG_DIR_IN);

  1095 

  1096 	event->SetEventType(KLogCallEventTypeUid);

  1097 	event->SetDirection(buf);

  1098 

  1099 	// All fields are null, they should all be duplicates

  1100 	for(count = 0; count < KTestEventNum; count++)

  1101 		{

  1102 		active->StartL();

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

  1104 		CActiveScheduler::Start();

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

  1106 		}

  1107 

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

  1109 

  1110 	// Move forward

  1111 	res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus);

  1112 	TEST(res);

  1113 	active->StartL();

  1114 	CActiveScheduler::Start();

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

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

  1117 

  1118 	CLogViewDuplicate* dView = CLogViewDuplicate::NewL(aClient);

  1119 	CleanupStack::PushL(dView);

  1120 

  1121 	res = view->DuplicatesL(*dView, active->iStatus);

  1122 	TEST(res);

  1123 	active->StartL();

  1124 	CActiveScheduler::Start();

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

  1126 	TEST(dView->CountL() == KTestEventNum - 1);

  1127 

  1128 	CleanupStack::PopAndDestroy(4); // view, active, event, dView

  1129 	}

  1130 

  1131 /**

  1132 @SYMTestCaseID          SYSLIB-LOGENG-CT-0857

  1133 @SYMTestCaseDesc	    Tests for CLogViewRecent::RemoveL() functions

  1134 @SYMTestPriority 	    High