1 // Copyright (c) 2003-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 <logeng.h>

    18 #include <tz.h>

    19 #include "TEST.H"

    20 #include <logview.h>

    21 

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

    23 

    24 RTest test(_L("Log View Test Harness Number 2"));

    25 

    26 const TInt KTestEventNum = 20;

    27 const TInt KTestErrorEventNum = 3;

    28 const TLogContactItemId KTestContact1 = 0x123;

    29 const TLogContactItemId KTestContact2 = 0x456;

    30 const TLogContactItemId KTestContact3 = 0x789;

    31 _LIT(KTestDirection1, "Direction Test 1");

    32 _LIT(KTestDirection2, "Direction Test 2");

    33 _LIT(KTestDirection3, "Direction Test 3");

    34 _LIT(KTestNumber1, "Number Test 1");

    35 _LIT(KTestNumber2, "Number Test 2");

    36 _LIT(KTestNumber3, "Number Test 3");

    37 _LIT(KTestRemote1, "Remote Test 1");

    38 _LIT(KTestRemote2, "Remote Test 2");

    39 _LIT(KTestRemote3, "Remote Test 3");

    40 _LIT(KTestStatus1, "Status Test 1");

    41 _LIT(KTestStatus2, "Status Test 2");

    42 _LIT(KTestStatus3, "Status Test 3");

    43 _LIT(KTestSubject, "Test Subject");

    44 const TLogLink KTestLink = 0x123456;

    45 _LIT8(KTestData, "Test data");

    46 

    47 /**

    48 @SYMTestCaseID          SYSLIB-LOGENG-CT-0930

    49 @SYMTestCaseDesc	    Tests for the functionality of CLogViewEvent,CLogFilter classes

    50 @SYMTestPriority 	    High

    51 @SYMTestActions  	    Tests for event view after setting filter on the views.

    52                         Change the filter list configuration and test for the view

    53 @SYMTestExpectedResults Test must not fail

    54 @SYMREQ                 REQ0000

    55 */

    56 LOCAL_C void TestEventViewWithFilterListL(CLogClient& aClient)

    57 	{

    58 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0930 "));

    59 	CTestActive* active = new(ELeave)CTestActive;

    60 	CleanupStack::PushL(active);

    61 

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

    63 	CleanupStack::PushL(event);

    64 

    65 	event->SetEventType(KLogCallEventTypeUid);

    66 	event->SetContact(KTestContact1);

    67 	event->SetDirection(KTestDirection1);

    68 	event->SetDurationType(KLogDurationNone);

    69 	event->SetNumber(KTestNumber1);

    70 	event->SetRemoteParty(KTestRemote1);

    71 	event->SetStatus(KTestStatus1);

    72 

    73 	// Add event

    74 	active->StartL();

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

    76 	CActiveScheduler::Start();

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

    78 

    79 	event->SetEventType(KLogDataEventTypeUid);

    80 	event->SetContact(KTestContact2);

    81 	event->SetDirection(KTestDirection2);

    82 	event->SetDurationType(KLogDurationValid);

    83 	event->SetNumber(KTestNumber2);

    84 	event->SetRemoteParty(KTestRemote2);

    85 	event->SetStatus(KTestStatus2);

    86 

    87 	// Add event

    88 	active->StartL();

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

    90 	CActiveScheduler::Start();

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

    92 

    93 	event->SetEventType(KLogFaxEventTypeUid);

    94 	event->SetContact(KTestContact3);

    95 	event->SetDirection(KTestDirection3);

    96 	event->SetDurationType(KLogDurationData);

    97 	event->SetNumber(KTestNumber3);

    98 	event->SetRemoteParty(KTestRemote3);

    99 	event->SetStatus(KTestStatus3);

   100 

   101 	// Add event

   102 	active->StartL();

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

   104 	CActiveScheduler::Start();

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

   106 

   107 	CLogFilterList* list = new(ELeave)CLogFilterList;

   108 	CleanupStack::PushL(list);

   109 

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

   111 	CleanupStack::PushL(view);

   112 

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

   114 	CleanupStack::PushL(filter);

   115 	

   116 	// Set filter

   117 	filter->SetContact(KTestContact1);

   118 

   119 	list->AppendL(filter);

   120 	CleanupStack::Pop(); // filter

   121 

   122 	// Test View

   123 	active->StartL();

   124 	TEST(view->SetFilterL(*list, active->iStatus));

   125 	CActiveScheduler::Start();

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

   127 

   128 	filter = CLogFilter::NewL();

   129 	CleanupStack::PushL(filter);

   130 	

   131 	// Set filter

   132 	filter->SetContact(KTestContact2);

   133 

   134 	list->AppendL(filter);

   135 	CleanupStack::Pop(); // filter

   136 

   137 	// Test View

   138 	active->StartL();

   139 	TEST(view->SetFilterL(*list, active->iStatus));

   140 	CActiveScheduler::Start();

   141 	TEST2(view->CountL(), 2);

   142 

   143 	filter = CLogFilter::NewL();

   144 	CleanupStack::PushL(filter);

   145 	

   146 	// Set filter

   147 	filter->SetContact(KTestContact3);

   148 

   149 	list->AppendL(filter);

   150 	CleanupStack::Pop(); // filter

   151 

   152 	// Test View

   153 	active->StartL();

   154 	TEST(view->SetFilterL(*list, active->iStatus));

   155 	CActiveScheduler::Start();

   156 	TEST2(view->CountL(), 3);

   157 

   158 	list->ResetAndDestroy();

   159 

   160 	/////////////////////////////////////////

   161 

   162 	filter = CLogFilter::NewL();

   163 	CleanupStack::PushL(filter);

   164 	

   165 	// Set filter

   166 	filter->SetContact(KTestContact1);

   167 	filter->SetDirection(KTestDirection1);

   168 

   169 	list->AppendL(filter);

   170 	CleanupStack::Pop(); // filter

   171 

   172 	// Test View

   173 	active->StartL();

   174 	TEST(view->SetFilterL(*list, active->iStatus));

   175 	CActiveScheduler::Start();

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

   177 

   178 	filter = CLogFilter::NewL();

   179 	CleanupStack::PushL(filter);

   180 	

   181 	// Set filter

   182 	filter->SetContact(KTestContact2);

   183 	filter->SetDirection(KTestDirection2);

   184 

   185 	list->AppendL(filter);

   186 	CleanupStack::Pop(); // filter

   187 

   188 	// Test View

   189 	active->StartL();

   190 	TEST(view->SetFilterL(*list, active->iStatus));

   191 	CActiveScheduler::Start();

   192 	TEST2(view->CountL(), 2);

   193 

   194 	filter = CLogFilter::NewL();

   195 	CleanupStack::PushL(filter);

   196 	

   197 	// Set filter

   198 	filter->SetContact(KTestContact3);

   199 	filter->SetDirection(KTestDirection3);

   200 

   201 	list->AppendL(filter);

   202 	CleanupStack::Pop(); // filter

   203 

   204 	// Test View

   205 	active->StartL();

   206 	TEST(view->SetFilterL(*list, active->iStatus));

   207 	CActiveScheduler::Start();

   208 	TEST2(view->CountL(), 3);

   209 

   210 	list->ResetAndDestroy();

   211 

   212 	/////////////////////////////////////////

   213 

   214 	filter = CLogFilter::NewL();

   215 	CleanupStack::PushL(filter);

   216 	

   217 	// Set filter

   218 	filter->SetContact(KTestContact1);

   219 	filter->SetDirection(KTestDirection1);

   220 	filter->SetDurationType(KLogDurationNone);

   221 

   222 	list->AppendL(filter);

   223 	CleanupStack::Pop(); // filter

   224 

   225 	// Test View

   226 	active->StartL();

   227 	TEST(view->SetFilterL(*list, active->iStatus));

   228 	CActiveScheduler::Start();

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

   230 

   231 	filter = CLogFilter::NewL();

   232 	CleanupStack::PushL(filter);

   233 	

   234 	// Set filter

   235 	filter->SetContact(KTestContact2);

   236 	filter->SetDirection(KTestDirection2);

   237 	filter->SetDurationType(KLogDurationValid);

   238 

   239 	list->AppendL(filter);

   240 	CleanupStack::Pop(); // filter

   241 

   242 	// Test View

   243 	active->StartL();

   244 	TEST(view->SetFilterL(*list, active->iStatus));

   245 	CActiveScheduler::Start();

   246 	TEST2(view->CountL(), 2);

   247 

   248 	filter = CLogFilter::NewL();

   249 	CleanupStack::PushL(filter);

   250 	

   251 	// Set filter

   252 	filter->SetContact(KTestContact3);

   253 	filter->SetDirection(KTestDirection3);

   254 	filter->SetDurationType(KLogDurationData);

   255 

   256 	list->AppendL(filter);

   257 	CleanupStack::Pop(); // filter

   258 

   259 	// Test View

   260 	active->StartL();

   261 	TEST(view->SetFilterL(*list, active->iStatus));

   262 	CActiveScheduler::Start();

   263 	TEST2(view->CountL(), 3);

   264 

   265 	list->ResetAndDestroy();

   266 

   267 	/////////////////////////////////////////

   268 

   269 	filter = CLogFilter::NewL();

   270 	CleanupStack::PushL(filter);

   271 	

   272 	// Set filter

   273 	filter->SetContact(KTestContact1);

   274 	filter->SetDirection(KTestDirection1);

   275 	filter->SetDurationType(KLogDurationNone);

   276 	filter->SetEventType(KLogCallEventTypeUid);

   277 

   278 	list->AppendL(filter);

   279 	CleanupStack::Pop(); // filter

   280 

   281 	// Test View

   282 	active->StartL();

   283 	TEST(view->SetFilterL(*list, active->iStatus));

   284 	CActiveScheduler::Start();

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

   286 

   287 	filter = CLogFilter::NewL();

   288 	CleanupStack::PushL(filter);

   289 	

   290 	// Set filter

   291 	filter->SetContact(KTestContact2);

   292 	filter->SetDirection(KTestDirection2);

   293 	filter->SetDurationType(KLogDurationValid);

   294 	filter->SetEventType(KLogDataEventTypeUid);

   295 

   296 	list->AppendL(filter);

   297 	CleanupStack::Pop(); // filter

   298 

   299 	// Test View

   300 	active->StartL();

   301 	TEST(view->SetFilterL(*list, active->iStatus));

   302 	CActiveScheduler::Start();

   303 	TEST2(view->CountL(), 2);

   304 

   305 	filter = CLogFilter::NewL();

   306 	CleanupStack::PushL(filter);

   307 	

   308 	// Set filter

   309 	filter->SetContact(KTestContact3);

   310 	filter->SetDirection(KTestDirection3);

   311 	filter->SetDurationType(KLogDurationData);

   312 	filter->SetEventType(KLogFaxEventTypeUid);

   313 

   314 	list->AppendL(filter);

   315 	CleanupStack::Pop(); // filter

   316 

   317 	// Test View

   318 	active->StartL();

   319 	TEST(view->SetFilterL(*list, active->iStatus));

   320 	CActiveScheduler::Start();

   321 	TEST2(view->CountL(), 3);

   322 

   323 	list->ResetAndDestroy();

   324 

   325 	/////////////////////////////////////////

   326 

   327 	filter = CLogFilter::NewL();

   328 	CleanupStack::PushL(filter);

   329 	

   330 	// Set filter

   331 	filter->SetContact(KTestContact1);

   332 	filter->SetDirection(KTestDirection1);

   333 	filter->SetDurationType(KLogDurationNone);

   334 	filter->SetEventType(KLogCallEventTypeUid);

   335 	filter->SetNumber(KTestNumber1);

   336 

   337 	list->AppendL(filter);

   338 	CleanupStack::Pop(); // filter

   339 

   340 	// Test View

   341 	active->StartL();

   342 	TEST(view->SetFilterL(*list, active->iStatus));

   343 	CActiveScheduler::Start();

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

   345 

   346 	filter = CLogFilter::NewL();

   347 	CleanupStack::PushL(filter);

   348 	

   349 	// Set filter

   350 	filter->SetContact(KTestContact2);

   351 	filter->SetDirection(KTestDirection2);

   352 	filter->SetDurationType(KLogDurationValid);

   353 	filter->SetEventType(KLogDataEventTypeUid);

   354 	filter->SetNumber(KTestNumber2);

   355 

   356 	list->AppendL(filter);

   357 	CleanupStack::Pop(); // filter

   358 

   359 	// Test View

   360 	active->StartL();

   361 	TEST(view->SetFilterL(*list, active->iStatus));

   362 	CActiveScheduler::Start();

   363 	TEST2(view->CountL(), 2);

   364 

   365 	filter = CLogFilter::NewL();

   366 	CleanupStack::PushL(filter);

   367 	

   368 	// Set filter

   369 	filter->SetContact(KTestContact3);

   370 	filter->SetDirection(KTestDirection3);

   371 	filter->SetDurationType(KLogDurationData);

   372 	filter->SetEventType(KLogFaxEventTypeUid);

   373 	filter->SetNumber(KTestNumber3);

   374 

   375 	list->AppendL(filter);

   376 	CleanupStack::Pop(); // filter

   377 

   378 	// Test View

   379 	active->StartL();

   380 	TEST(view->SetFilterL(*list, active->iStatus));

   381 	CActiveScheduler::Start();

   382 	TEST2(view->CountL(), 3);

   383 

   384 	list->ResetAndDestroy();

   385 

   386 	/////////////////////////////////////////

   387 

   388 	filter = CLogFilter::NewL();

   389 	CleanupStack::PushL(filter);

   390 	

   391 	// Set filter

   392 	filter->SetContact(KTestContact1);

   393 	filter->SetDirection(KTestDirection1);

   394 	filter->SetDurationType(KLogDurationNone);

   395 	filter->SetEventType(KLogCallEventTypeUid);

   396 	filter->SetNumber(KTestNumber1);

   397 	filter->SetRemoteParty(KTestRemote1);

   398 

   399 	list->AppendL(filter);

   400 	CleanupStack::Pop(); // filter

   401 

   402 	// Test View

   403 	active->StartL();

   404 	TEST(view->SetFilterL(*list, active->iStatus));

   405 	CActiveScheduler::Start();

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

   407 

   408 	filter = CLogFilter::NewL();

   409 	CleanupStack::PushL(filter);

   410 	

   411 	// Set filter

   412 	filter->SetContact(KTestContact2);

   413 	filter->SetDirection(KTestDirection2);

   414 	filter->SetDurationType(KLogDurationValid);

   415 	filter->SetEventType(KLogDataEventTypeUid);

   416 	filter->SetNumber(KTestNumber2);

   417 	filter->SetRemoteParty(KTestRemote2);

   418 

   419 	list->AppendL(filter);

   420 	CleanupStack::Pop(); // filter

   421 

   422 	// Test View

   423 	active->StartL();

   424 	TEST(view->SetFilterL(*list, active->iStatus));

   425 	CActiveScheduler::Start();

   426 	TEST2(view->CountL(), 2);

   427 

   428 	filter = CLogFilter::NewL();

   429 	CleanupStack::PushL(filter);

   430 	

   431 	// Set filter

   432 	filter->SetContact(KTestContact3);

   433 	filter->SetDirection(KTestDirection3);

   434 	filter->SetDurationType(KLogDurationData);

   435 	filter->SetEventType(KLogFaxEventTypeUid);

   436 	filter->SetNumber(KTestNumber3);

   437 	filter->SetRemoteParty(KTestRemote3);

   438 

   439 	list->AppendL(filter);

   440 	CleanupStack::Pop(); // filter

   441 

   442 	// Test View

   443 	active->StartL();

   444 	TEST(view->SetFilterL(*list, active->iStatus));

   445 	CActiveScheduler::Start();

   446 	TEST2(view->CountL(), 3);

   447 

   448 	list->ResetAndDestroy();

   449 

   450 	/////////////////////////////////////////

   451 

   452 	filter = CLogFilter::NewL();

   453 	CleanupStack::PushL(filter);

   454 	

   455 	// Set filter

   456 	filter->SetContact(KTestContact1);

   457 	filter->SetDirection(KTestDirection1);

   458 	filter->SetDurationType(KLogDurationNone);

   459 	filter->SetEventType(KLogCallEventTypeUid);

   460 	filter->SetNumber(KTestNumber1);

   461 	filter->SetRemoteParty(KTestRemote1);

   462 	filter->SetStatus(KTestStatus1);

   463 

   464 	list->AppendL(filter);

   465 	CleanupStack::Pop(); // filter

   466 

   467 	// Test View

   468 	active->StartL();

   469 	TEST(view->SetFilterL(*list, active->iStatus));

   470 	CActiveScheduler::Start();

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

   472 

   473 	filter = CLogFilter::NewL();

   474 	CleanupStack::PushL(filter);

   475 	

   476 	// Set filter

   477 	filter->SetContact(KTestContact2);

   478 	filter->SetDirection(KTestDirection2);

   479 	filter->SetDurationType(KLogDurationValid);

   480 	filter->SetEventType(KLogDataEventTypeUid);

   481 	filter->SetNumber(KTestNumber2);

   482 	filter->SetRemoteParty(KTestRemote2);

   483 	filter->SetStatus(KTestStatus2);

   484 

   485 	list->AppendL(filter);

   486 	CleanupStack::Pop(); // filter

   487 

   488 	// Test View

   489 	active->StartL();

   490 	TEST(view->SetFilterL(*list, active->iStatus));

   491 	CActiveScheduler::Start();

   492 	TEST2(view->CountL(), 2);

   493 

   494 	filter = CLogFilter::NewL();

   495 	CleanupStack::PushL(filter);

   496 	

   497 	// Set filter

   498 	filter->SetContact(KTestContact3);

   499 	filter->SetDirection(KTestDirection3);

   500 	filter->SetDurationType(KLogDurationData);

   501 	filter->SetEventType(KLogFaxEventTypeUid);

   502 	filter->SetNumber(KTestNumber3);

   503 	filter->SetRemoteParty(KTestRemote3);

   504 	filter->SetStatus(KTestStatus3);

   505 

   506 	list->AppendL(filter);

   507 	CleanupStack::Pop(); // filter

   508 

   509 	// Test View

   510 	active->StartL();

   511 	TEST(view->SetFilterL(*list, active->iStatus));

   512 	CActiveScheduler::Start();

   513 	TEST2(view->CountL(), 3);

   514 

   515 	list->ResetAndDestroy();

   516 

   517 	CleanupStack::PopAndDestroy(4); // list, view, event, active

   518 	}

   519 

   520 /**

   521 @SYMTestCaseID          SYSLIB-LOGENG-CT-3432

   522 @SYMTestCaseDesc	    Test the functionality of CLogViewEvent::SetFilterL with the CLogFilterList parameter containing multiple filters with start time and end time.

   523 @SYMTestPriority 	    High

   524 @SYMTestActions  	    1. Add 2 events.

   525 						2. Setup a CLogFilterList with two filters targeting the first event. Both filters have start and end time. Call SetFilterL.

   526 						3. Verify view has 1 event and no LogServ panic.

   527 						4. Clear the filter list.

   528 						5. Setup filter for first event with start and end time. Call SetFilterL.

   529 						6. Verify view has one event.

   530                         7. Setup second filter for second event with start and end time. Append this filter to filter list and call SetFilterL.

   531 						8. Verify view has 2 events and no LogServ panic.

   532 @SYMTestExpectedResults Log view has expected number of events and no LogServ panic.

   533 @SYMDEF                 INC102412

   534 */

   535 LOCAL_C void TestEventViewWithTimestampsInFilterListL(CLogClient& aClient)

   536 	{

   537 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-3432 "));

   538 	TTime testStartTime;

   539 	testStartTime.UniversalTime();

   540 	TTime tomorrow = testStartTime + (TTimeIntervalDays)1;

   541 	TTime twoDaysFromNow = tomorrow + (TTimeIntervalDays)1;

   542 

   543 	CTestActive* active = new(ELeave)CTestActive;

   544 	CleanupStack::PushL(active);

   545 

   546 	// Get rid of all the events in the log

   547 	active->StartL();

   548 	aClient.ClearLog(tomorrow, active->iStatus);

   549 	CActiveScheduler::Start();

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

   551 	

   552 	// Wait a second before adding events to log.

   553 	User::After(1100000);

   554 

   555 	// Add two events to log

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

   557 	CleanupStack::PushL(event);

   558 

   559 	// Add event 1

   560 	event->SetEventType(KLogCallEventTypeUid);

   561 	event->SetContact(KTestContact1);

   562 	event->SetDirection(KTestDirection1);

   563 	event->SetDurationType(KLogDurationNone);

   564 	event->SetNumber(KTestNumber1);

   565 	event->SetRemoteParty(KTestRemote1);

   566 	event->SetStatus(KTestStatus1);

   567 

   568 	active->StartL();

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

   570 	CActiveScheduler::Start();

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

   572 

   573 	// Add event 2

   574 	event->SetEventType(KLogDataEventTypeUid);

   575 	event->SetContact(KTestContact2);

   576 	event->SetDirection(KTestDirection2);

   577 	event->SetDurationType(KLogDurationValid);

   578 	event->SetNumber(KTestNumber2);

   579 	event->SetRemoteParty(KTestRemote2);

   580 	event->SetStatus(KTestStatus2);

   581 

   582 	active->StartL();

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

   584 	CActiveScheduler::Start();

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

   586 

   587 	// Setup filter

   588 	CLogFilterList* list = new(ELeave)CLogFilterList;

   589 	CleanupStack::PushL(list);

   590 

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

   592 	CleanupStack::PushL(view);

   593 

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

   595 	CleanupStack::PushL(filter);

   596 	

   597 	// Set half a filter

   598 	filter->SetContact(KTestContact1);

   599 	filter->SetDirection(KTestDirection1);

   600 	filter->SetDurationType(KLogDurationNone);

   601 	filter->SetStartTime(testStartTime);

   602 	TTime t1 = filter->StartTime();

   603 	TEST(t1 == testStartTime);

   604 	filter->SetEndTime(tomorrow);

   605 	TTime t2 = filter->EndTime();

   606 	TEST(t2 == tomorrow);

   607 

   608 	list->AppendL(filter);

   609 	CleanupStack::Pop(); // filter

   610 

   611 	// set the other half of filter for event 1

   612 	filter = CLogFilter::NewL();

   613 	CleanupStack::PushL(filter);

   614 

   615 	filter->SetEventType(KLogCallEventTypeUid);

   616 	filter->SetNumber(KTestNumber1);

   617 	filter->SetRemoteParty(KTestRemote1);

   618 	filter->SetStatus(KTestStatus1);

   619 

   620 	// start time is duplicate of previous filter, 

   621 	// end time is not duplicate

   622 	filter->SetStartTime(testStartTime);

   623 	filter->SetEndTime(twoDaysFromNow);

   624 

   625 	list->AppendL(filter);

   626 	CleanupStack::Pop(); // filter

   627 

   628 	// Test View

   629 	active->StartL();

   630 	TEST(view->SetFilterL(*list, active->iStatus));

   631 	CActiveScheduler::Start();

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

   633 

   634 	list->ResetAndDestroy();

   635 

   636 	// check contents of the event.

   637 	TBool res = view->FirstL(active->iStatus);

   638 	TEST(res);

   639 	active->StartL();

   640 	CActiveScheduler::Start();

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

   642 	

   643 	TEST2(view->Event().Contact(), KTestContact1);

   644 	TEST( view->Event().Number() == KTestNumber1);

   645 	TEST( view->Event().Status() == KTestStatus1);

   646 	TEST( view->Event().RemoteParty() == KTestRemote1);

   647 

   648 	/////////////////////////////////////////

   649 

   650 	filter = CLogFilter::NewL();

   651 	CleanupStack::PushL(filter);

   652 	

   653 	// Set filter

   654 	filter->SetContact(KTestContact1);

   655 	filter->SetDirection(KTestDirection1);

   656 	filter->SetDurationType(KLogDurationNone);

   657 	filter->SetEventType(KLogCallEventTypeUid);

   658 	filter->SetNumber(KTestNumber1);

   659 	filter->SetRemoteParty(KTestRemote1);

   660 	filter->SetStatus(KTestStatus1);

   661 	filter->SetStartTime(testStartTime);

   662 	filter->SetEndTime(tomorrow);

   663 

   664 	list->AppendL(filter);

   665 	CleanupStack::Pop(); // filter

   666 

   667 	// Test View

   668 	active->StartL();

   669 	TEST(view->SetFilterL(*list, active->iStatus));

   670 	CActiveScheduler::Start();

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

   672 

   673 	filter = CLogFilter::NewL();

   674 	CleanupStack::PushL(filter);

   675 	

   676 	// Set filter

   677 	filter->SetContact(KTestContact2);

   678 	filter->SetDirection(KTestDirection2);

   679 	filter->SetDurationType(KLogDurationValid);

   680 	filter->SetEventType(KLogDataEventTypeUid);

   681 	filter->SetNumber(KTestNumber2);

   682 	filter->SetRemoteParty(KTestRemote2);

   683 	filter->SetStatus(KTestStatus2);

   684 

   685 	// start time is duplicate,

   686 	// end time is not duplicate

   687 	filter->SetStartTime(testStartTime);

   688 	filter->SetEndTime(twoDaysFromNow);

   689 

   690 	list->AppendL(filter);

   691 	CleanupStack::Pop(); // filter

   692 

   693 	// Test View

   694 	active->StartL();

   695 	TEST(view->SetFilterL(*list, active->iStatus));

   696 	CActiveScheduler::Start();

   697 	TEST2(view->CountL(), 2);

   698 

   699 	list->ResetAndDestroy();

   700 

   701 	// check contents of event 2 (most recent)

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

   703 	TEST(res);

   704 	active->StartL();

   705 	CActiveScheduler::Start();

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

   707 	

   708 	TEST2(view->Event().Contact(), KTestContact2);

   709 	TEST( view->Event().Number() == KTestNumber2);

   710 	TEST( view->Event().Status() == KTestStatus2);

   711 	TEST( view->Event().RemoteParty() == KTestRemote2);

   712 

   713 	// check contents of event 1 (older)

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

   715 	TEST(res);

   716 	active->StartL();

   717 	CActiveScheduler::Start();

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

   719 	

   720 	TEST2(view->Event().Contact(), KTestContact1);

   721 	TEST( view->Event().Number() == KTestNumber1);

   722 	TEST( view->Event().Status() == KTestStatus1);

   723 	TEST( view->Event().RemoteParty() == KTestRemote1);

   724 

   725 	CleanupStack::PopAndDestroy(4); // list, view, event, active

   726 	}

   727 

   728 /**

   729 @SYMTestCaseID          SYSLIB-LOGENG-CT-0931

   730 @SYMTestCaseDesc	    Tests for recent view list with filters 

   731 @SYMTestPriority 	    High

   732 @SYMTestActions  	    Tests for recent view list,with different settings of the filter. 

   733 @SYMTestExpectedResults Test must not fail

   734 @SYMREQ                 REQ0000

   735 */

   736 LOCAL_C void TestRecentViewWithFilterL(CLogClient& aClient)

   737 	{

   738 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0931 "));

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

   740 	CleanupStack::PushL(event);

   741 

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

   743 	CleanupStack::PushL(active);

   744 

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

   746 	CleanupStack::PushL(view);

   747 

   748 	// Incoming

   749 	TLogString buf;

   750 	aClient.GetString(buf, R_LOG_DIR_IN);

   751 

   752 	event->SetEventType(KLogCallEventTypeUid);

   753 	event->SetDirection(buf);

   754 	event->SetNumber(_L("1"));

   755 

   756 	// Add event

   757 	active->StartL();

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

   759 	CActiveScheduler::Start();

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

   761 

   762 	event->SetDurationType(KLogDurationData);

   763 	event->SetNumber(_L("2"));

   764 

   765 	// Add event

   766 	active->StartL();

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

   768 	CActiveScheduler::Start();

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

   770 

   771 	event->SetStatus(KTestStatus1);

   772 	event->SetNumber(_L("3"));

   773 

   774 	// Add event

   775 	active->StartL();

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

   777 	CActiveScheduler::Start();

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

   779 

   780 	event->SetContact(KTestContact1);

   781 	event->SetNumber(_L("4"));

   782 

   783 	// Add event

   784 	active->StartL();

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

   786 	CActiveScheduler::Start();

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

   788 

   789 	active->StartL();

   790 	TEST(view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));

   791 	CActiveScheduler::Start();

   792 	TEST2(view->CountL(), 4);

   793 

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

   795 	CleanupStack::PushL(filter);

   796 

   797 	// This should make no difference

   798 	filter->SetEventType(KLogCallEventTypeUid);

   799 

   800 	active->StartL();

   801 	TEST(view->SetRecentListL(KLogRecentIncomingCalls, *filter, active->iStatus));

   802 	CActiveScheduler::Start();

   803 	TEST2(view->CountL(), 4);

   804 

   805 	// This should make no difference

   806 	filter->SetDirection(buf);

   807 

   808 	active->StartL();

   809 	TEST(view->SetRecentListL(KLogRecentIncomingCalls, *filter, active->iStatus));

   810 	CActiveScheduler::Start();

   811 	TEST2(view->CountL(), 4);

   812 

   813 	filter->SetDurationType(KLogDurationData);

   814 

   815 	active->StartL();

   816 	TEST(view->SetRecentListL(KLogRecentIncomingCalls, *filter, active->iStatus));

   817 	CActiveScheduler::Start();

   818 	TEST2(view->CountL(), 3);

   819 

   820 	filter->SetStatus(KTestStatus1);

   821 

   822 	active->StartL();

   823 	TEST(view->SetRecentListL(KLogRecentIncomingCalls, *filter, active->iStatus));

   824 	CActiveScheduler::Start();

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

   826 

   827 	filter->SetContact(KTestContact1);

   828 

   829 	active->StartL();

   830 	TEST(view->SetRecentListL(KLogRecentIncomingCalls, *filter, active->iStatus));

   831 	CActiveScheduler::Start();

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

   833 

   834 	filter->SetStatus(_L("Dummy"));

   835 	TEST(!view->SetRecentListL(KLogRecentIncomingCalls, *filter, active->iStatus));

   836 

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

   838 	}

   839 

   840 /**

   841 @SYMTestCaseID          SYSLIB-LOGENG-CT-0932

   842 @SYMTestCaseDesc	    Tests for recent view list with filter set for the view

   843 @SYMTestPriority 	    High

   844 @SYMTestActions  	    Tests for recent view list set by the specified set of filters.

   845 @SYMTestExpectedResults Test must not fail

   846 @SYMREQ                 REQ0000

   847 */

   848 LOCAL_C void TestRecentViewWithFilterListL(CLogClient& aClient)

   849 	{

   850 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0932 "));

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

   852 	CleanupStack::PushL(event);

   853 

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

   855 	CleanupStack::PushL(active);

   856 

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

   858 	CleanupStack::PushL(view);

   859 

   860 	// Make sure there are no entries in any recent lists

   861 	active->StartL();

   862 	aClient.ClearLog(KLogNullRecentList, active->iStatus);

   863 	CActiveScheduler::Start();

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

   865 

   866 	// Incoming

   867 	TLogString buf;

   868 	aClient.GetString(buf, R_LOG_DIR_IN);

   869 

   870 	event->SetEventType(KLogCallEventTypeUid);

   871 	event->SetDirection(buf);

   872 	event->SetDurationType(KLogDurationNone);

   873 	event->SetContact(KTestContact1);

   874 	event->SetStatus(KTestStatus1);

   875 

   876 	// Add event

   877 	active->StartL();

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

   879 	CActiveScheduler::Start();

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

   881 

   882 	event->SetDurationType(KLogDurationValid);

   883 	event->SetContact(KTestContact2);

   884 	event->SetStatus(KTestStatus2);

   885 

   886 	// Add event

   887 	active->StartL();

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

   889 	CActiveScheduler::Start();

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

   891 

   892 	event->SetDurationType(KLogDurationData);

   893 	event->SetContact(KTestContact3);

   894 	event->SetStatus(KTestStatus3);

   895 

   896 	// Add event

   897 	active->StartL();

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

   899 	CActiveScheduler::Start();

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

   901 

   902 	active->StartL();

   903 	TEST(view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));

   904 	CActiveScheduler::Start();

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

   906 	TEST2(view->CountL(), 3);

   907 

   908 	CLogFilterList* list = new(ELeave)CLogFilterList;

   909 	CleanupStack::PushL(list);

   910 

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

   912 	CleanupStack::PushL(filter);

   913 	list->AppendL(filter);

   914 	CleanupStack::Pop(); // filter

   915 

   916 	filter->SetDurationType(KLogDurationNone);

   917 	filter->SetStatus(KTestStatus1);

   918 	filter->SetContact(KTestContact1);

   919 

   920 	active->StartL();

   921 	TEST(view->SetRecentListL(KLogRecentIncomingCalls, *list, active->iStatus));

   922 	CActiveScheduler::Start();

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

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

   925 

   926 	filter = CLogFilter::NewL();

   927 	CleanupStack::PushL(filter);

   928 	list->AppendL(filter);

   929 	CleanupStack::Pop(); // filter

   930 

   931 	filter->SetDurationType(KLogDurationValid);

   932 	filter->SetStatus(KTestStatus2);

   933 	filter->SetContact(KTestContact2);

   934 

   935 	active->StartL();

   936 	TEST(view->SetRecentListL(KLogRecentIncomingCalls, *list, active->iStatus));

   937 	CActiveScheduler::Start();

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

   939 	TEST2(view->CountL(), 2);

   940 

   941 	filter = CLogFilter::NewL();

   942 	CleanupStack::PushL(filter);

   943 	list->AppendL(filter);

   944 	CleanupStack::Pop(); // filter

   945 

   946 	filter->SetDurationType(KLogDurationData);

   947 	filter->SetStatus(KTestStatus3);

   948 	filter->SetContact(KTestContact3);

   949 

   950 	active->StartL();

   951 	TEST(view->SetRecentListL(KLogRecentIncomingCalls, *list, active->iStatus));

   952 	CActiveScheduler::Start();

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

   954 	TEST2(view->CountL(), 3);

   955 

   956 	list->ResetAndDestroy();

   957 	CleanupStack::PopAndDestroy(4); // list, view, active, event

   958 	}

   959 

   960 /**

   961 @SYMTestCaseID          SYSLIB-LOGENG-CT-0933

   962 @SYMTestCaseDesc	    Tests for duplicate event view with filter 

   963 @SYMTestPriority 	    High

   964 @SYMTestActions  	    Tests for duplicate event view count. 

   965 @SYMTestExpectedResults Test must not fail

   966 @SYMREQ                 REQ0000

   967 */

   968 LOCAL_C void TestDuplicateViewWithFilterL(CLogClient& aClient)

   969 	{

   970 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0933 "));

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

   972 	CleanupStack::PushL(event);

   973 

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

   975 	CleanupStack::PushL(active);

   976 

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

   978 	CleanupStack::PushL(view);

   979 

   980 	CLogViewDuplicate* duplicate = CLogViewDuplicate::NewL(aClient);

   981 	CleanupStack::PushL(duplicate);

   982 

   983 	// Make sure there are no entries in any recent lists

   984 	active->StartL();

   985 	aClient.ClearLog(KLogNullRecentList, active->iStatus);

   986 	CActiveScheduler::Start();

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

   988 

   989 	// Incoming

   990 	TLogString buf;

   991 	aClient.GetString(buf, R_LOG_DIR_IN);

   992 

   993 	event->SetEventType(KLogCallEventTypeUid);

   994 	event->SetDirection(buf);

   995 	event->SetContact(KTestContact1);

   996 

   997 	// Add event

   998 	active->StartL();

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

  1000 	CActiveScheduler::Start();

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

  1002 

  1003 	event->SetDurationType(KLogDurationValid);

  1004 

  1005 	// Add event

  1006 	active->StartL();

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

  1008 	CActiveScheduler::Start();

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

  1010 

  1011 	event->SetStatus(KTestStatus1);

  1012 

  1013 	// Add event

  1014 	active->StartL();

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

  1016 	CActiveScheduler::Start();

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

  1018 

  1019 	event->SetDurationType(KLogDurationNone);

  1020 	event->SetStatus(KNullDesC);

  1021 

  1022 	// Add event - This will be the entry in recent list

  1023 	active->StartL();

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

  1025 	CActiveScheduler::Start();

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

  1027 	TLogId logId1 = event->Id();

  1028 

  1029 	// Should only be one event in recent list - the rest are duplicates

  1030 	active->StartL();

  1031 	TEST(view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));

  1032 	CActiveScheduler::Start();

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

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

  1035 	

  1036 	TLogRecentList recentList = view->RecentList();

  1037 	TEST(recentList == KLogRecentIncomingCalls);

  1038 

  1039 	// Check duplicate count

  1040 	active->StartL();

  1041 	TEST(view->DuplicatesL(*duplicate, active->iStatus));

  1042 	CActiveScheduler::Start();

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

  1044 	TEST2(duplicate->CountL(), 3);

  1045 	

  1046 	TLogId logId2 = duplicate->Source();

  1047 	TEST(logId1 == logId2);

  1048 

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

  1050 	CleanupStack::PushL(filter);

  1051 

  1052 	active->StartL();

  1053 	TEST(view->DuplicatesL(*duplicate, *filter, active->iStatus));

  1054 	CActiveScheduler::Start();

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

  1056 	TEST2(duplicate->CountL(), 3);

  1057 

  1058 	filter->SetDurationType(KLogDurationValid);

  1059 

  1060 	active->StartL();

  1061 	TEST(view->DuplicatesL(*duplicate, *filter, active->iStatus));

  1062 	CActiveScheduler::Start();

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

  1064 	TEST2(duplicate->CountL(), 2);

  1065 

  1066 	filter->SetStatus(KTestStatus1);

  1067 

  1068 	active->StartL();

  1069 	TEST(view->DuplicatesL(*duplicate, *filter, active->iStatus));

  1070 	CActiveScheduler::Start();

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

  1072 	TEST2(duplicate->CountL(), 1);

  1073 

  1074 	filter->SetStatus(KTestStatus2);

  1075 	TEST(!view->DuplicatesL(*duplicate, *filter, active->iStatus));

  1076 

  1077 	CleanupStack::PopAndDestroy(5); // filter, duplicate, view, active, event

  1078 	}

  1079 

  1080 /**

  1081 @SYMTestCaseID          SYSLIB-LOGENG-CT-0934

  1082 @SYMTestCaseDesc	    Tests for duplicate event view with filter list

  1083 @SYMTestPriority 	    High

  1084 @SYMTestActions  	    Tests for duplicate event view count,set by the specified set of filters.

  1085 @SYMTestExpectedResults Test must not fail

  1086 @SYMREQ                 REQ0000

  1087 */

  1088 LOCAL_C void TestDuplicateViewWithFilterListL(CLogClient& aClient)

  1089 	{

  1090 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0934 "));

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

  1092 	CleanupStack::PushL(event);

  1093 

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

  1095 	CleanupStack::PushL(active);

  1096 

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

  1098 	CleanupStack::PushL(view);

  1099 

  1100 	CLogViewDuplicate* duplicate = CLogViewDuplicate::NewL(aClient);

  1101 	CleanupStack::PushL(duplicate);

  1102 

  1103 	// Make sure there are no entries in any recent lists

  1104 	active->StartL();

  1105 	aClient.ClearLog(KLogNullRecentList, active->iStatus);

  1106 	CActiveScheduler::Start();

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

  1108 

  1109 	// Incoming

  1110 	TLogString buf;

  1111 	aClient.GetString(buf, R_LOG_DIR_IN);

  1112 

  1113 	event->SetEventType(KLogCallEventTypeUid);

  1114 	event->SetDirection(buf);

  1115 	event->SetContact(KTestContact1);

  1116 

  1117 	event->SetDurationType(KLogDurationNone);

  1118 	event->SetStatus(KNullDesC);

  1119 

  1120 	// Add event

  1121 	active->StartL();

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

  1123 	CActiveScheduler::Start();

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

  1125 

  1126 	event->SetDurationType(KLogDurationValid);

  1127 

  1128 	active->StartL();

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

  1130 	CActiveScheduler::Start();

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

  1132 

  1133 	event->SetDurationType(KLogDurationData);

  1134