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

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

    18 #include <logview.h>

    20 RTest TheTest(_L("t_logpurge"));

    22 const TInt KTestEventNum = 10;

    23 const TInt KTestEventAge = 5;

    24 const TInt KTestRecentNum = 10;

    25 const TInt KTestDuplicateNum = 10;

    27 _LIT(KTestRemoteParty, "Test Remote Party %d");

    29 /**

    30 @SYMTestCaseID          SYSLIB-LOGENG-CT-0875

    31 @SYMTestCaseDesc	    Tests for maximum logging of configuration data

    32 @SYMTestPriority 	    High

    33 @SYMTestActions  	    Get the event type configuration data.Set the log size to maximum.

    34                         Change the log engine configuration data with the new one.Add events to the log

    35                         Set the filter on the view and check for KErrNone flag.

    36 						Add a new event and disable logging by setting the maximum logging size to zero

    37 						Clear all the events and test for KErrNone and the total count of events.

    38 @SYMTestExpectedResults Test must not fail

    39 @SYMREQ                 REQ0000

    40 */

    41 LOCAL_C void TestMaxLogSizeL(CLogClient& aClient)

    42 	{

    43 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0875 "));

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

    45 	CleanupStack::PushL(event);

    46 	event->SetEventType(KLogCallEventTypeUid);

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

    49 	CleanupStack::PushL(active);

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

    52 	CleanupStack::PushL(view);

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

    55 	CleanupStack::PushL(filter);

    57 	TLogConfig config;

    59 	// Get log configuration

    60 	active->StartL();

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

    62 	CActiveScheduler::Start();

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

    65 	// Set the maximum log size

    66 	config.iMaxLogSize = KTestEventNum;

    68 	// Change the log engine config

    69 	active->StartL();

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

    71 	CActiveScheduler::Start();

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

    74 	// Initialise the view - There should be no events

    75 	TEST(!view->SetFilterL(*filter, active->iStatus));

    77 	// Add the number of allowed events

    78 	TInt count;

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

    80 		{

    81 		active->StartL();

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

    83 		CActiveScheduler::Start();

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

    85 		}

    87 	TEST(view->SetFilterL(*filter, active->iStatus));

    88 	active->StartL();

    89 	CActiveScheduler::Start();

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

    92 	// The view should now have the correct number of events

    93 	TEST(view->CountL() == KTestEventNum);

    95 	// Add the same number of events again - the old ones should be deleted

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

    97 		{

    98 		TEST(view->SetFilterL(*filter, active->iStatus));

    99 		active->StartL();

   100 		CActiveScheduler::Start();

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

   103 		// Get the last (oldest) event

   104 		active->StartL();

   105 		view->LastL(active->iStatus);

   106 		CActiveScheduler::Start();

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

   109 		// Remember the Id

   110 		TLogId id = view->Event().Id();

   112 		// Add another event - the oldest should be removed

   113 		active->StartL();

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

   115 		CActiveScheduler::Start();

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

   118 		// There should be the same number of events in view

   119 		TEST(view->CountL() == KTestEventNum);

   121 		event->SetId(id);

   123 		// Try and get the old event

   124 		active->StartL();

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

   126 		CActiveScheduler::Start();

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

   128 		}

   130 	// Add an event

   131 	active->StartL();

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

   133 	CActiveScheduler::Start();

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

   136 	// Check it's there

   137 	active->StartL();

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

   139 	CActiveScheduler::Start();

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

   142 	// Set the maximum log size to zero, i.e. disable logging

   143 	config.iMaxLogSize = 0;

   145 	// Change the log engine config

   146 	active->StartL();

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

   148 	CActiveScheduler::Start();

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

   151 	// Check the event has gone

   152 	active->StartL();

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

   154 	CActiveScheduler::Start();

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

   157 	// Add an event

   158 	active->StartL();

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

   160 	CActiveScheduler::Start();

   161 	TEST2(active->iStatus.Int(), KErrNotSupported);

   163 	// Check that event doesn't exist

   164 	active->StartL();

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

   166 	CActiveScheduler::Start();

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

   169 	User::After(1000000);

   171 	TTime now;

   172 	now.UniversalTime();

   173 	now+=(TTimeIntervalDays) 1;

   174 	// Clear all the events

   175 	active->StartL();

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

   177 	CActiveScheduler::Start();

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

   180 	TEST(!view->SetFilterL(*filter, active->iStatus));

   181 	TEST(view->CountL() == 0);

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

   184 	}

   186 /**

   187 @SYMTestCaseID          SYSLIB-LOGENG-CT-0876

   188 @SYMTestCaseDesc	    Tests for maximum logging of configuration data

   189 @SYMTestPriority 	    High

   190 @SYMTestActions  	    Get the event type configuration data.Set the log size to maximum.

   191                         Change the log engine configuration data and add the number of allowed events

   192                         Reduce the number of allowed events.The old ones should be purged

   193 						Change the log engine config and check for the event count.

   194 @SYMTestExpectedResults Test must not fail

   195 @SYMREQ                 REQ0000

   196 */

   197 LOCAL_C void TestMaxLogSizeConfigL(CLogClient& aClient)

   198 	{

   199 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0876 "));

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

   201 	CleanupStack::PushL(event);

   202 	event->SetEventType(KLogCallEventTypeUid);

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

   205 	CleanupStack::PushL(active);

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

   208 	CleanupStack::PushL(view);

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

   211 	CleanupStack::PushL(filter);

   213 	TLogConfig config;

   215 	// Get log configuration

   216 	active->StartL();

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

   218 	CActiveScheduler::Start();

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

   221 	// Set the maximum log size

   222 	config.iMaxLogSize = KTestEventNum;

   224 	// Change the log engine config

   225 	active->StartL();

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

   227 	CActiveScheduler::Start();

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

   230 	// Initialise the view - There should be no events

   231 	TEST(!view->SetFilterL(*filter, active->iStatus));

   233 	// Add the number of allowed events

   234 	TInt count;

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

   236 		{

   237 		active->StartL();

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

   239 		CActiveScheduler::Start();

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

   241 		}

   243 	TEST(view->SetFilterL(*filter, active->iStatus));

   244 	active->StartL();

   245 	CActiveScheduler::Start();

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

   248 	// The view should now have the correct number of events

   249 	TEST(view->CountL() == KTestEventNum);

   251 	// Reduce the number of allowed events

   252 	// The old ones should be purged

   253 	config.iMaxLogSize = KTestEventNum / 2;

   255 	// Change the log engine config

   256 	active->StartL();

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

   258 	CActiveScheduler::Start();

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

   261 	// Check the event count

   262 	TEST(view->SetFilterL(*filter, active->iStatus));

   263 	active->StartL();

   264 	CActiveScheduler::Start();

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

   266 	TEST(view->CountL() == KTestEventNum / 2);

   268 	User::After(0x1000000);

   270 	TTime now;

   271 	now.UniversalTime();

   272 	now+=(TTimeIntervalDays )1;

   273 	// Clear all the events

   274 	active->StartL();

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

   276 	CActiveScheduler::Start();

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

   279 	TEST(!view->SetFilterL(*filter, active->iStatus));

   280 	TEST(view->CountL() == 0);

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

   283 	}

   285 /**

   286 @SYMTestCaseID          SYSLIB-LOGENG-CT-0877

   287 @SYMTestCaseDesc	    Tests for maximum time for which events can be retained in the log

   288 @SYMTestPriority 	    High

   289 @SYMTestActions  	    Get the event type configuration data.Set maximum log age.

   290                         Change the log engine configuration data with the new one.Add events to the log

   291                         Set the date and time of events clear the log and check for errors

   292 @SYMTestExpectedResults Test must not fail

   293 @SYMREQ                 REQ0000

   294 */

   295 LOCAL_C void TestMaxLogAgeL(CLogClient& aClient, TLogAge aMaxLogAge)

   296 	{

   297 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0877 "));

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

   299 	CleanupStack::PushL(event);

   300 	event->SetEventType(KLogCallEventTypeUid);

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

   303 	CleanupStack::PushL(active);

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

   306 	CleanupStack::PushL(view);

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

   309 	CleanupStack::PushL(filter);

   311 	TLogConfig config;

   313 	// Get log configuration

   314 	active->StartL();

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

   316 	CActiveScheduler::Start();

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

   319 	// Set the maximum log age

   320 	config.iMaxLogSize = KTestEventAge * 2;

   321 	config.iMaxEventAge = aMaxLogAge;

   323 	// Change the log engine config

   324 	active->StartL();

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

   326 	CActiveScheduler::Start();

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

   329 	// Initialise the view - There should be no events

   330 	TEST(!view->SetFilterL(*filter, active->iStatus));

   332 	TTime date;

   333 	date.UniversalTime();

   335 	// Wait a second

   336 	User::After(0x1000000);

   338 	// Add events

   339 	TInt count;

   340 	for(count = 0; count < KTestEventAge * 2; count++)

   341 		{

   342 		active->StartL();

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

   344 		CActiveScheduler::Start();

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

   347 		// Set the time and date of the event

   348 		event->SetTime(date);

   349 		date -= TTimeIntervalDays(1);

   351 		active->StartL();

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

   353 		CActiveScheduler::Start();

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

   355 		User::After(1000000);

   357 		TEST(view->SetFilterL(*filter, active->iStatus));

   358 		active->StartL();

   359 		CActiveScheduler::Start();

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

   362 		// Check the old events have been removed

   363 		if ((count < KTestEventAge) || !aMaxLogAge)

   364 			TEST(view->CountL() == count + 1);

   365 		else

   366 			TEST(view->CountL() == KTestEventAge);

   367 		}

   369 	User::After(0x1000000);

   370 	date.UniversalTime();

   372 	date+=(TTimeIntervalYears )1;

   374 	// Clear all the events

   375 	active->StartL();

   376 	aClient.ClearLog(date, active->iStatus);

   377 	CActiveScheduler::Start();

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

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

   381 	TEST(view->CountL() == 0);

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

   384 	}

   386 /**

   387 @SYMTestCaseID          SYSLIB-LOGENG-CT-0878

   388 @SYMTestCaseDesc	    Tests for maximum number of events that a recent event list holds

   389 @SYMTestPriority 	    High

   390 @SYMTestActions  	    Set the event configuration data of recent log size(10) to maximum and

   391 						Add events to the log.Set the filter on the view and check for NO error.

   392 						Add a new event and disable logging by setting the maximum logging size to zero

   393 						Clear all the events and test for no errors and the total count of events and the logviewrecent should be zero.

   394 @SYMTestExpectedResults Test must not fail

   395 @SYMREQ                 REQ0000

   396 */

   397 LOCAL_C void TestMaxRecentSize1L(CLogClient& aClient)

   398 	{

   399 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0878 "));

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

   401 	CleanupStack::PushL(event);

   403 	// Incoming

   404 	TBuf<KLogMaxDirectionLength> buf;

   405 	aClient.GetString(buf, R_LOG_DIR_IN);

   407 	event->SetEventType(KLogCallEventTypeUid);

   408 	event->SetDirection(buf);

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

   411 	CleanupStack::PushL(active);

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

   414 	CleanupStack::PushL(view);

   416 	CLogViewRecent* recent = CLogViewRecent::NewL(aClient);

   417 	CleanupStack::PushL(recent);

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

   420 	CleanupStack::PushL(filter);

   422 	TLogConfig config;

   424 	// Get log configuration

   425 	active->StartL();

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

   427 	CActiveScheduler::Start();

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

   430 	// Set the maximum log size

   431 	config.iMaxLogSize = KTestRecentNum * 2;

   432 	config.iMaxRecentLogSize = KTestRecentNum;

   434 	// Change the log engine config

   435 	active->StartL();

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

   437 	CActiveScheduler::Start();

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

   440 	// Initialise the views - There should be no events

   441 	TEST(!view->SetFilterL(*filter, active->iStatus));

   442 	TEST(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));

   444 	// Add a number of events

   445 	TInt count;

   446 	for(count = 0; count < KTestRecentNum; count++)

   447 		{

   448 		event->SetContact(count);

   450 		active->StartL();

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

   452 		CActiveScheduler::Start();

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

   454 		}

   456 	TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));

   457 	active->StartL();

   458 	CActiveScheduler::Start();

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

   461 	TEST(recent->CountL() == KTestRecentNum);

   463 	// Add the same number of events again - the old ones should be removed

   464 	for(count = 0; count < KTestRecentNum; count++)

   465 		{

   466 		// Add another event - the oldest should be removed from recent list

   467 		active->StartL();

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

   469 		CActiveScheduler::Start();

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

   472 		TEST(view->SetFilterL(*filter, active->iStatus));

   473 		active->StartL();

   474 		CActiveScheduler::Start();

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

   477 		TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));

   478 		active->StartL();

   479 		CActiveScheduler::Start();

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

   482 		// Check an event has been removed from recent view

   483 		TEST(recent->CountL() == KTestRecentNum);

   484 		TEST(view->CountL() == count + KTestRecentNum + 1);

   485 		}

   487 	User::After(0x1000000);

   489 	TTime now;

   490 	now.UniversalTime();

   491 	now+=(TTimeIntervalDays )1;

   493 	// Clear all the events

   494 	active->StartL();

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

   496 	CActiveScheduler::Start();

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

   499 	TEST(!view->SetFilterL(*filter, active->iStatus));

   500 	TEST(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));

   501 	TEST(view->CountL() == 0 && recent->CountL() == 0);

   503 	CleanupStack::PopAndDestroy(5); // filter, recent, view, active, event

   504 	}

   506 /**

   507 @SYMTestCaseID          SYSLIB-LOGENG-CT-0879

   508 @SYMTestCaseDesc	    Tests for maximum number of events that a recent event list holds

   509 @SYMTestPriority 	    High

   510 @SYMTestActions  	    Set the event configuration data of recent log size(10) to maximum and

   511 						Add events to the log.Set the filter on the view and check for NO error.

   512 	                    Reduce the recent log size(5)  and set the new configuration.

   513 						Clear all the events and test for no errors and the total count of events and the logviewrecent should be zero.

   514 						Tests for CLogViewRecent::SetRecentListL

   515 @SYMTestExpectedResults Test must not fail

   516 @SYMREQ                 REQ0000

   517 */

   518 LOCAL_C void TestMaxRecentSizeConfigL(CLogClient& aClient)

   519 	{

   520 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0879 "));

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

   522 	CleanupStack::PushL(event);

   524 	// Incoming

   525 	TBuf<KLogMaxDirectionLength> buf;

   526 	aClient.GetString(buf, R_LOG_DIR_IN);

   528 	event->SetEventType(KLogCallEventTypeUid);

   529 	event->SetDirection(buf);

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

   532 	CleanupStack::PushL(active);

   534 	CLogViewRecent* recent = CLogViewRecent::NewL(aClient);

   535 	CleanupStack::PushL(recent);

   537 	TLogConfig config;

   539 	// Get log configuration

   540 	active->StartL();

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

   542 	CActiveScheduler::Start();

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

   545 	// Set the maximum log size

   546 	config.iMaxLogSize = KTestRecentNum * 2;

   547 	config.iMaxRecentLogSize = KTestRecentNum;

   549 	// Change the log engine config

   550 	active->StartL();

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

   552 	CActiveScheduler::Start();

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

   555 	// Initialise the views - There should be no events

   556 	TEST(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));

   558 	// Add a number of events

   559 	TInt count;

   560 	for(count = 0; count < KTestRecentNum; count++)

   561 		{

   562 		event->SetContact(count);

   564 		active->StartL();

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

   566 		CActiveScheduler::Start();

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

   568 		}

   570 	TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));

   571 	active->StartL();

   572 	CActiveScheduler::Start();

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

   575 	TEST(recent->CountL() == KTestRecentNum);

   577 	// Reduce the maximum allowed recent list size

   578 	// The oldest ones should be removed

   579 	config.iMaxRecentLogSize = KTestRecentNum / 2;

   581 	active->StartL();

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

   583 	CActiveScheduler::Start();

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

   586 	TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));

   587 	active->StartL();

   588 	CActiveScheduler::Start();

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

   591 	TEST(recent->CountL() == KTestRecentNum / 2);

   592 	User::After(0x1000000);

   594 	TTime now;

   595 	now.UniversalTime();

   596 	now+=(TTimeIntervalDays )1;

   598 	// Clear all the events

   599 	active->StartL();

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

   601 	CActiveScheduler::Start();

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

   604 	TEST(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));

   605 	TEST(recent->CountL() == 0);

   607 	CleanupStack::PopAndDestroy(3); // recent, active, event

   608 	}

   610 /**

   611 @SYMTestCaseID          SYSLIB-LOGENG-CT-0880

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

   613 @SYMTestPriority 	    High

   614 @SYMTestActions  	    Set the event configuration data of recent log size(10) to maximum and

   615 						Add events to the log.Set the filter on the view and check for NO error.

   616 	                    Reduce the recent log size(5)  and set the new configuration.

   617 						Clear all the events and test for no errors and the total count of events and the logviewrecent should be zero.

   618 						Tests for CLogViewRecent::SetRecentListL()

   619 @SYMTestExpectedResults Test must not fail

   620 @SYMREQ                 REQ0000

   621 */

   622 LOCAL_C void TestMaxRecentSize2L(CLogClient& aClient)

   623 	{

   624 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0880 "));

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

   626 	CleanupStack::PushL(event);

   628 	// Incoming

   629 	TBuf<KLogMaxDirectionLength> buf;

   630 	aClient.GetString(buf, R_LOG_DIR_IN);

   632 	event->SetEventType(KLogCallEventTypeUid);

   633 	event->SetDirection(buf);

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

   636 	CleanupStack::PushL(active);

   638 	CLogViewRecent* recent = CLogViewRecent::NewL(aClient);

   639 	CleanupStack::PushL(recent);

   641 	CLogViewDuplicate* dup = CLogViewDuplicate::NewL(aClient);

   642 	CleanupStack::PushL(dup);

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

   645 	CleanupStack::PushL(filter);

   647 	TLogConfig config;

   649 	// Get log configuration

   650 	active->StartL();

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

   652 	CActiveScheduler::Start();

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

   655 	// Set the maximum log size

   656 	config.iMaxLogSize = (KTestRecentNum * KTestDuplicateNum) * 2;

   657 	config.iMaxRecentLogSize = KTestRecentNum;

   659 	// Change the log engine config

   660 	active->StartL();

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

   662 	CActiveScheduler::Start();

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

   665 	// Initialise the view - There should be no events

   666 	TEST(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));

   668 	// Add a number of events

   669 	TInt count;

   670 	for(count = 0; count < KTestRecentNum; count++)

   671 		{

   672 		TBuf<KLogMaxRemotePartyLength> buf;

   673 		buf.Format(KTestRemoteParty, count);

   674 		event->SetRemoteParty(buf);

   676 		active->StartL();

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

   678 		CActiveScheduler::Start();

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

   681 		// Add some duplicates

   682 		TInt duplicate;

   683 		for(duplicate = 0; duplicate < KTestDuplicateNum; duplicate++)

   684 			{

   685 			active->StartL();

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

   687 			CActiveScheduler::Start();

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

   689 			}

   691 		// The views should now have the correct number of events

   692 		TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));

   693 		active->StartL();

   694 		CActiveScheduler::Start();

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

   697 		TEST(recent->CountL() == count + 1);

   699 		TEST(recent->DuplicatesL(*dup, active->iStatus));

   700 		active->StartL();

   701 		CActiveScheduler::Start();

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

   704 		TEST(dup->CountL() == KTestDuplicateNum);

   705 		}

   707 	event->SetRemoteParty(KNullDesC);

   709 	// Add the more events - the old ones should be removed

   710 	for(count = 0; count < KTestRecentNum; count++)

   711 		{

   712 		// Add another event - the oldest should be removed from recent list

   713 		active->StartL();

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

   715 		CActiveScheduler::Start();

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

   718 		TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));

   719 		active->StartL();

   720 		CActiveScheduler::Start();

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

   723 		// Check an event has been removed from recent view

   724 		TEST(recent->CountL() == KTestRecentNum);

   725 		}

   727 	User::After(0x1000000);

   729 	TTime now;

   730 	now.UniversalTime();

   731 	now+=(TTimeIntervalDays )1;

   733 	// Clear all the events

   734 	active->StartL();

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

   736 	CActiveScheduler::Start();

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

   739 	TEST(!recent->DuplicatesL(*dup, active->iStatus));

   741 	CleanupStack::PopAndDestroy(5); // filter, dup, recent, active, event

   742 	}

   744 /**

   745 @SYMTestCaseID          SYSLIB-LOGENG-CT-0881

   746 @SYMTestCaseDesc	    Tests for purge

   747 @SYMTestPriority 	    High

   748 @SYMTestActions  	    Get the event type data

   749 @SYMTestExpectedResults Test must not fail

   750 @SYMREQ                 REQ0000

   751 */

   752 LOCAL_C void TestNoPurgeWithGetL(CLogClient& aClient)

   753 	{

   754 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0881 "));

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

   756 	CleanupStack::PushL(event);

   757 	event->SetEventType(KLogCallEventTypeUid);

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

   760 	CleanupStack::PushL(active);

   762 	TLogConfig config;

   764 	// Get log configuration

   765 	active->StartL();

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

   767 	CActiveScheduler::Start();

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

   770 	// Set the maximum log age

   771 	TInt oldAge = config.iMaxEventAge;

   772 	config.iMaxEventAge = 24 * 60 * 60;

   774 	// Change the log engine config

   775 	active->StartL();

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

   777 	CActiveScheduler::Start();

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

   780 	active->StartL();

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

   782 	CActiveScheduler::Start();

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

   785 	// Check that the event can be retrieved

   786 	active->StartL();

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

   788 	CActiveScheduler::Start();

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

   791 	// Wait for 15 seconds (just to be safe)

   792 	User::After(15000000);

   794 	// Check that the event can still be retrieved

   795 	active->StartL();

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

   797 	CActiveScheduler::Start();

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

   800 	// Perform a dummy change

   801 	event->SetTime(event->Time() - TTimeIntervalDays(2));

   802 	active->StartL();

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

   804 	CActiveScheduler::Start();

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

   807 	// Check the event has been removed

   808 	active->StartL();

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

   810 	CActiveScheduler::Start();

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

   813 	// Reset the config

   814 	config.iMaxEventAge = oldAge;

   816 	// Change the log engine config

   817 	active->StartL();

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

   819 	CActiveScheduler::Start();

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

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

   823 	}

   825 /**

   826 @SYMTestCaseID          SYSLIB-LOGENG-CT-0882

   827 @SYMTestCaseDesc	    Tests for CLogClient::ClearLog() function

   828 @SYMTestPriority 	    High

   829 @SYMTestActions  	    Change locale settings and log duration to 1 day and test for number of event types in log

   830 @SYMTestExpectedResults Test must not fail

   831 @SYMREQ                 REQ0000

   832 */

   833 LOCAL_C void TestClearLog1L(CLogClient& aClient)

   834 	{

   835 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0882 "));

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

   837 	CleanupStack::PushL(event);

   838 	event->SetEventType(KLogCallEventTypeUid);

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

   841 	CleanupStack::PushL(active);

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

   844 	CleanupStack::PushL(view);

   846 	// change Locale

   847 	TLocale locale;

   848 	locale.SetCountryCode(47);//Norway

   849 	locale.SetDateFormat(EDateEuropean);

   850 	locale.SetTimeFormat(ETime12);

   851 	for (int i=0; i<4; i++)

   852          {

   853          locale.SetTimeSeparator(TChar('.'),i);

   854          locale.SetDateSeparator(TChar(':'),i);

   855          }

   856 	locale.Set();

   858 	// change the log duration settings to 1 day

   859 	TLogConfig config;

   860 	active->StartL();

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

   862 	CActiveScheduler::Start();

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

   865 	config.iMaxLogSize = KTestEventAge * 2;

   866 	config.iMaxEventAge = 86400;

   867 	active->StartL();

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

   869 	CActiveScheduler::Start();

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

   872 	// add a call event

   873 	active->StartL();

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

   875 	CActiveScheduler::Start();

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

   877 	User::After(1000000);

   878 	TTime now;

   879 	now.HomeTime();

   880 	event->SetTime(now);

   881 	active->StartL();

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

   883 	CActiveScheduler::Start();

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

   886 	// forward two days

   887 	now+=(TTimeIntervalDays )2;

   888 	User::SetHomeTime(now);

   890 	// dummy call ensures ClearLog() is called

   891 	active->StartL();

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

   893 	CActiveScheduler::Start();

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

   896 	// try to retrieve event

   897 	active->StartL();

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

   899 	CActiveScheduler::Start();

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

   902 	TEST(view->CountL() == 0);

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

   905 	}

   907 /**

   908 @SYMTestCaseID          SYSLIB-LOGENG-CT-0883

   909 @SYMTestCaseDesc	    Tests for CLogClient::ClearLog() function

   910 @SYMTestPriority 	    High

   911 @SYMTestActions  	    Change locale settings,call up ClearLog and try to retrieve event,test for count of number of events in the view.

   912 @SYMTestExpectedResults Test must not fail

   913 @SYMREQ                 REQ0000

   914 */

   915 LOCAL_C void TestClearLog2L(CLogClient& aClient)

   916 	{

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

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

   919 	CleanupStack::PushL(event);

   920 	event->SetEventType(KLogCallEventTypeUid);

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

   923 	CleanupStack::PushL(active);

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

   926 	CleanupStack::PushL(view);

   928 	// change Locale

   929 	TLocale locale;

   930 	locale.SetCountryCode(47);//Norway

   931 	locale.SetDateFormat(EDateEuropean);

   932 	locale.SetTimeFormat(ETime12);

   933 	for (int i=0; i<4; i++)

   934          {

   935          locale.SetTimeSeparator(TChar('.'),i);

   936          locale.SetDateSeparator(TChar(':'),i);

   937          }

   938 	locale.Set();

   940 	// change the log duration settings to 1 day

   941 	TLogConfig config;

   942 	active->StartL();

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

   944 	CActiveScheduler::Start();

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

   947 	config.iMaxLogSize = KTestEventAge * 2;

   948 	config.iMaxEventAge = 86400;

   949 	active->StartL();

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

   951 	CActiveScheduler::Start();

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

   954 	// add a call event

   955 	active->StartL();

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

   957 	CActiveScheduler::Start();

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

   959 	User::After(1000000);

   960 	TTime now;

   961 	now.HomeTime();

   962 	event->SetTime(now);

   963 	active->StartL();

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

   965 	CActiveScheduler::Start();

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

   968 	// forward two days

   969 	now+=(TTimeIntervalDays )2;

   970 	User::SetHomeTime(now);

   972 	active->StartL();

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

   974 	CActiveScheduler::Start();

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

   977 	// try to retrieve event

   978 	active->StartL();

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

   980 	CActiveScheduler::Start();

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

   983 	TEST(view->CountL() == 0);

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

   986 	}

   988 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM

   990 /**

   991 @SYMTestCaseID			PDS-LOGENG-UT-4036

   992 @SYMTestCaseDesc		Clear log events with specific SimId test.

   993 						The test adds 3 events with different SimIds and then checks that

   994 						CLogEvent::ClearLog() deletes only the event with the specified id.

   995 @SYMTestActions			Clear log events with specific SimId test.

   996 @SYMTestExpectedResults Test must not fail

   997 @SYMTestPriority		High

   998 @SYMREQ					REQ12748

   999 */

  1000 void ClearLogSimIdL(CLogClient& aClient)

  1001 	{//This test case is compiled only when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM macro is defined.

  1002 	const TSimId KSimId1 = 4100000000U;

  1003 	const TSimId KSimId2 = 100;

  1004 	const TSimId KSimId3 = 1678;

  1006 	TTime now;

  1007 	now.UniversalTime();

  1009 	TDateTime dt(now.DateTime());

  1010 	dt.SetHour(dt.Hour() - 1);

  1011 	TTime date(dt);

  1013 	TTime threshold(date);

  1014 	threshold += TTimeIntervalSeconds(10);

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

  1017 	CleanupStack::PushL(active);

  1019 	//////// Event1 ///////////////////////////

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

  1021 	CleanupStack::PushL(event1);

  1022 	event1->SetEventType(KLogCallEventTypeUid);

  1023 	event1->SetSimId(KSimId1);

  1025 	active->StartL();

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

  1027 	CActiveScheduler::Start();

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

  1030 	event1->SetTime(date);

  1032 	active->StartL();

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

  1034 	CActiveScheduler::Start();

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

  1037 	//////// Event2 ///////////////////////////

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

  1039 	CleanupStack::PushL(event2);

  1040 	event2->SetEventType(KLogCallEventTypeUid);

  1041 	event2->SetSimId(KSimId2);

  1043 	active->StartL();

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

  1045 	CActiveScheduler::Start();

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

  1048 	event2->SetTime(date);

  1050 	active->StartL();

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

  1052 	CActiveScheduler::Start();

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

  1055 	//////// Event3 ///////////////////////////

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

  1057 	CleanupStack::PushL(event3);

  1058 	event3->SetEventType(KLogCallEventTypeUid);

  1059 	event3->SetSimId(KSimId3);

  1061 	active->StartL();

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

  1063 	CActiveScheduler::Start();

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

  1066 	event3->SetTime(date);

  1068 	active->StartL();

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

  1070 	CActiveScheduler::Start();

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

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

  1075 	//Delete event3 /////////////////////////

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

  1077 	active->StartL();

  1078 	CActiveScheduler::Start();

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

  1080 	//Event1 and event2 should be there

  1081 	active->StartL();

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

  1083 	CActiveScheduler::Start();

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

  1085 	active->StartL();

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

  1087 	CActiveScheduler::Start();

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

  1089 	active->StartL();

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

  1091 	CActiveScheduler::Start();

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

  1094 	//Delete event2 /////////////////////////

  1095 	aClient.ClearLog(threshold, KSimId2, active->iStatus);

  1096 	active->StartL();

  1097 	CActiveScheduler::Start();

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

  1099 	//Event1 should be there

  1100 	active->StartL();

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

  1102 	CActiveScheduler::Start();

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

  1104 	active->StartL();

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

  1106 	CActiveScheduler::Start();

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

  1108 	active->StartL();

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

  1110 	CActiveScheduler::Start();

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

  1113 	//Delete event1 /////////////////////////

  1114 	aClient.ClearLog(threshold, KSimId1, active->iStatus);

  1115 	active->StartL();

  1116 	CActiveScheduler::Start();

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

  1118 	//All events deleted

  1119 	active->StartL();

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

  1121 	CActiveScheduler::Start();

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

  1123 	active->StartL();

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

  1125 	CActiveScheduler::Start();

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

  1127 	active->StartL();

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

  1129 	CActiveScheduler::Start();

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

  1132 	CleanupStack::PopAndDestroy(4); //event3, event2, event1, active

  1133 	}

  1135 /**

  1136 @SYMTestCaseID			PDS-LOGENG-UT-4037

  1137 @SYMTestCaseDesc		Clear log events from a recent list with specific SimId test.

  1138 						The test adds 3 events to a recent list with different SimIds and then checks that

  1139 						CLogEvent::ClearLog() deletes only the event with the specified id.

  1140 @SYMTestActions			Clear log events from a recent list with specific SimId test.

  1141 @SYMTestExpectedResults Test must not fail

  1142 @SYMTestPriority 	    High

  1143 @SYMREQ					REQ12748

  1144 */

  1145 void ClearLogRecentSimIdL(CLogClient& aClient)

  1146 	{//This test case is compiled only when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM macro is defined.

  1147 	const TSimId KSimId1 = 4200110000U;

  1148 	const TSimId KSimId2 = 38223;

  1149 	const TSimId KSimId3 = 239816;

  1151 	const TUid KEvTypeUid = {KLogCallEventType};

  1152 	_LIT(KEvDirection, "Missed call");

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

  1155 	CleanupStack::PushL(active);

  1157 	//////// Event1 ///////////////////////////

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

  1159 	CleanupStack::PushL(event1);

  1160 	event1->SetEventType(KEvTypeUid);

  1161 	event1->SetDirection(KEvDirection);

  1162 	event1->SetNumber(_L("12345678"));

  1163 	event1->SetSimId(KSimId1);

  1164 	active->StartL();

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

  1166 	CActiveScheduler::Start();

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

  1168 	//////// Event2 ///////////////////////////

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

  1170 	CleanupStack::PushL(event2);

  1171 	event2->SetEventType(KEvTypeUid);

  1172 	event2->SetDirection(KEvDirection);

  1173 	event2->SetNumber(_L("87654321"));

  1174 	event2->SetSimId(KSimId2);

  1175 	active->StartL();

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

  1177 	CActiveScheduler::Start();

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

  1179 	//////// Event3 ///////////////////////////

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

  1181 	CleanupStack::PushL(event3);

  1182 	event3->SetEventType(KEvTypeUid);

  1183 	event3->SetDirection(KEvDirection);

  1184 	event3->SetNumber(_L("99229922"));

  1185 	event3->SetSimId(KSimId3);

  1186 	active->StartL();

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

  1188 	CActiveScheduler::Start();

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

  1190 	//////////////////////////////////////////////////////////////////////////////////////////////////

  1192 	//Delete event3 /////////////////////////

  1193 	aClient.ClearLog(KLogRecentMissedCalls, KSimId3, active->iStatus);

  1194 	active->StartL();

  1195 	CActiveScheduler::Start();

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

  1197 	//Event1 and event2 should be there

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

  1199 	CleanupStack::PushL(view);

  1200 	TBool rc = view->SetRecentListL(KLogRecentMissedCalls, active->iStatus);

  1201 	TEST(rc);

  1202 	active->StartL();

  1203 	CActiveScheduler::Start();

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

  1206 	TInt count = view->CountL();

  1207 	TEST2(count, 2);

  1208 	rc = view->FirstL(active->iStatus);

  1209 	TEST(rc);

  1210 	active->StartL();

  1211 	CActiveScheduler::Start();

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

  1213 	const CLogEvent& e1 = view->Event();

  1214 	TEST(e1.SimId() == KSimId2 || e1.SimId() == KSimId1);

  1215 	rc = view->NextL(active->iStatus);

  1216 	TEST(rc);

  1217 	active->StartL();

  1218 	CActiveScheduler::Start();

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

  1220 	const CLogEvent& e2 = view->Event();

  1221 	TEST(e2.SimId() == KSimId2 || e2.SimId() == KSimId1);

  1222 	TEST(e1.Id() != e2.Id());

  1224 	CleanupStack::PopAndDestroy(view);

  1226 	//Delete event1 /////////////////////////

  1227 	aClient.ClearLog(KLogRecentMissedCalls, KSimId1, active->iStatus);

  1228 	active->StartL();

  1229 	CActiveScheduler::Start();

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

  1231 	//Only event2 should be there

  1232 	view = CLogViewRecent::NewL(aClient);

  1233 	CleanupStack::PushL(view);

  1234 	rc = view->SetRecentListL(KLogRecentMissedCalls, active->iStatus);

  1235 	TEST(rc);

  1236 	active->StartL();

  1237 	CActiveScheduler::Start();

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

  1239 	count = view->CountL();

  1240 	TEST2(count, 1);

  1241 	rc = view->FirstL(active->iStatus);

  1242 	TEST(rc);

  1243 	active->StartL();

  1244 	CActiveScheduler::Start();

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

  1246 	const CLogEvent& e3 = view->Event();

  1247 	TEST(e3.SimId() == KSimId2);

  1249 	CleanupStack::PopAndDestroy(5); //view, event3, event2, event1, active

  1250 	}

  1252 #endif//SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM

  1254 void doTestsL()

  1255 	{

  1256 	TestUtils::Initialize(_L("t_logpurge"));

  1257 	TestUtils::DeleteDatabaseL();

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

  1260 	CleanupStack::PushL(client);

  1262 	TheTest.Start(_L("Maximum Log Size"));

  1263 	TestMaxLogSizeL(*client);

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

  1266 	TheTest.Next(_L("Purge Log When Config Changed"));

  1267 	TestMaxLogSizeConfigL(*client);

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

  1270 	TheTest.Next(_L("Test purge by Maximum Log Age enabled/disabled"));

  1271 	TestMaxLogAgeL(*client, 0);	// disable purging by age

  1272 	TestMaxLogAgeL(*client, KTestEventAge * 60 * 60 * 24);

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

  1275 	TheTest.Next(_L("Maximum Recent List Size"));

  1276 	TestMaxRecentSize1L(*client);

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

  1279 	TheTest.Next(_L("Purge Recent Lists When Config Changed"));

  1280 	TestMaxRecentSizeConfigL(*client);

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

  1283 	TheTest.Next(_L("Maximum Recent List Size With Duplicates"));

  1284 	TestMaxRecentSize2L(*client);

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

  1287 	TheTest.Next(_L("Check no purge when retrieving event"));

  1288 	TestNoPurgeWithGetL(*client);

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

  1291 	TheTest.Next(_L("Check ClearLog works for different locales"));

  1292 	TestClearLog1L(*client);

  1293 	TestClearLog2L(*client);

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

  1296 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM

  1297 	TheTest.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4036 CLogClient::ClearLog() + SimId test"));

  1298  	ClearLogSimIdL(*client);

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

  1301 	TheTest.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4037 CLogClient::ClearLog()/recent + SimId test"));

  1302  	ClearLogRecentSimIdL(*client);

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

  1304 #endif

  1306 	CleanupStack::PopAndDestroy(); // client;

  1307 	}

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