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

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

     2 // All rights reserved.

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

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 #include <s32file.h>

    17 #include "t_logutil2.h"

    18 #include <logview.h>

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

    22 const TLogContactItemId KTestContact = 0x123;

    23 _LIT(KTestStatus, "Test Status Text");

    25 /**

    26 @SYMTestCaseID          SYSLIB-LOGENG-CT-0978

    27 @SYMTestCaseDesc	    Tests for CLogViewEvent::NewL() function

    28 @SYMTestPriority 	    High

    29 @SYMTestActions  	    Add an event to the client,Create a new CLogViewEvent on heap,if no error check if the view works

    30                         Check for log server failure error

    31 @SYMTestExpectedResults Test must not fail

    32 @SYMREQ                 REQ0000

    33 */

    34 LOCAL_C void TestEventViewConstructWithLogServFailL(CLogClient& aClient)

    35 	{

    36 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0978 "));

    37 	CTestActive* active = new(ELeave)CTestActive;

    38 	CleanupStack::PushL(active);

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

    41 	CleanupStack::PushL(event);

    42 	event->SetEventType(KLogCallEventTypeUid);

    44 	// Add an event

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

    46 	active->StartL();

    47 	CActiveScheduler::Start();

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

    50 	CLogViewEvent* view = NULL;

    52 	TInt failCount = 0;

    53 	TBool finished = EFalse;

    54 	TInt error;

    56 	while(!finished)

    57 		{

    58 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

    60 		TRAP(error, view = CLogViewEvent::NewL(aClient));

    62 		__LOGSERV_UHEAP_RESET;

    64 		if (!error)

    65 			{

    66 			finished = ETrue;

    67 			CleanupStack::PushL(view);

    69 			// Check the view works

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

    71 			CleanupStack::PushL(filter);

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

    74 			active->StartL();

    75 			CActiveScheduler::Start();

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

    77 			TEST(view->CountL() >= 1);

    78 			TEST(TestUtils::EventsEqual(*event, view->Event()));

    80 			CleanupStack::PopAndDestroy(2); // filter, view

    81 			}

    82 		else

    83 			{

    84 			TEST2(error, KErrNoMemory);

    85 			}

    86 		}

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

    89 	}

    91 /**

    92 @SYMTestCaseID          SYSLIB-LOGENG-CT-0979

    93 @SYMTestCaseDesc	    Tests for CLogViewRecent::NewL(),SetRecentListL() functions

    94 @SYMTestPriority 	    High

    95 @SYMTestActions  	    Create a new view object,if no errors and test of initialising of the view for the specified recent event list.

    96                         Check for log server failure error

    97 @SYMTestExpectedResults Test must not fail

    98 @SYMREQ                 REQ0000

    99 */

   100 LOCAL_C void TestRecentViewConstructWithLogServFailL(CLogClient& aClient)

   101 	{

   102 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0979 "));

   103 	CTestActive* active = new(ELeave)CTestActive;

   104 	CleanupStack::PushL(active);

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

   107 	CleanupStack::PushL(event);

   109 	// Incoming

   110 	TLogString buf;

   111 	aClient.GetString(buf, R_LOG_DIR_IN);

   113 	event->SetEventType(KLogCallEventTypeUid);

   114 	event->SetDirection(buf);

   116 	// Add an event

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

   118 	active->StartL();

   119 	CActiveScheduler::Start();

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

   122 	CLogViewRecent* view = NULL;

   124 	TInt failCount = 0;

   125 	TBool finished = EFalse;

   126 	TInt error;

   128 	while(!finished)

   129 		{

   130 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

   132 		TRAP(error, view = CLogViewRecent::NewL(aClient));

   134 		__LOGSERV_UHEAP_RESET;

   136 		if (!error)

   137 			{

   138 			finished = ETrue;

   139 			CleanupStack::PushL(view);

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

   142 			active->StartL();

   143 			CActiveScheduler::Start();

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

   145 			TEST(view->CountL() >= 1);

   146 			TEST(TestUtils::EventsEqual(*event, view->Event()));

   148 			CleanupStack::PopAndDestroy(); // view

   149 			}

   150 		else

   151 			{

   152 			TEST2(error, KErrNoMemory);

   153 			}

   154 		}

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

   157 	}

   159 /**

   160 @SYMTestCaseID          SYSLIB-LOGENG-CT-0980

   161 @SYMTestCaseDesc	    Tests for CLogViewDuplicate::NewL() functions

   162 @SYMTestPriority 	    High

   163 @SYMTestActions  	    Create a new logviewrecent object,set the recent log view,list out the duplicates of the current event in the recent event list view

   164                         Check for log server failure error

   165 @SYMTestExpectedResults Test must not fail

   166 @SYMREQ                 REQ0000

   167 */

   168 LOCAL_C void TestDuplicateViewConstructWithLogServFailL(CLogClient& aClient)

   169 	{

   170 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0980 "));

   171 	CTestActive* active = new(ELeave)CTestActive;

   172 	CleanupStack::PushL(active);

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

   175 	CleanupStack::PushL(event);

   177 	// Incoming

   178 	TLogString buf;

   179 	aClient.GetString(buf, R_LOG_DIR_IN);

   181 	event->SetEventType(KLogCallEventTypeUid);

   182 	event->SetDirection(buf);

   183 	event->SetContact(KTestContact);

   185 	// Add events

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

   187 	active->StartL();

   188 	CActiveScheduler::Start();

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

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

   192 	active->StartL();

   193 	CActiveScheduler::Start();

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

   196 	CLogViewDuplicate* view = NULL;

   198 	TInt failCount = 0;

   199 	TBool finished = EFalse;

   200 	TInt error;

   202 	while(!finished)

   203 		{

   204 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

   206 		TRAP(error, view = CLogViewDuplicate::NewL(aClient));

   208 		__LOGSERV_UHEAP_RESET;

   210 		if (!error)

   211 			{

   212 			finished = ETrue;

   213 			CleanupStack::PushL(view);

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

   216 			CleanupStack::PushL(recent);

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

   218 			active->StartL();

   219 			CActiveScheduler::Start();

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

   221 			TEST(recent->CountL() >= 1);

   223 			TEST(recent->DuplicatesL(*view, active->iStatus));

   224 			active->StartL();

   225 			CActiveScheduler::Start();

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

   227 			TEST(view->CountL() >= 1);

   229 			CleanupStack::PopAndDestroy(2); // recent, view

   230 			}

   231 		else

   232 			{

   233 			TEST2(error, KErrNoMemory);

   234 			}

   235 		}

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

   238 	}

   240 /**

   241 @SYMTestCaseID          SYSLIB-LOGENG-CT-0981

   242 @SYMTestCaseDesc	    Tests for CLogViewEvent::SetFilterL() function

   243 @SYMTestPriority 	    High

   244 @SYMTestActions  	    Create a log filter and set the filter on logview.Check for equality of events on the view and events

   245 						added.Check for log server failure error

   246 @SYMTestExpectedResults Test must not fail

   247 @SYMREQ                 REQ0000

   248 */

   249 LOCAL_C void TestEventViewSetupWithLogServFailL(CLogClient& aClient)

   250 	{

   251 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0981 "));

   252 	CTestActive* active = new(ELeave)CTestActive;

   253 	CleanupStack::PushL(active);

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

   256 	CleanupStack::PushL(event);

   257 	event->SetEventType(KLogCallEventTypeUid);

   258 	event->SetStatus(KTestStatus);

   260 	// Add an event

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

   262 	active->StartL();

   263 	CActiveScheduler::Start();

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

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

   267 	CleanupStack::PushL(view);

   269 	CLogFilterList* list = new(ELeave)CLogFilterList;

   270 	CleanupStack::PushL(list);

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

   273 	CleanupStack::PushL(filter);

   274 	filter->SetStatus(KTestStatus);

   276 	TInt failCount = 0;

   277 	TBool finished = EFalse;

   278 	TInt error;

   280 	while(!finished)

   281 		{

   282 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

   284 		TBool result = EFalse;

   285 		TRAP(error, result = view->SetFilterL(*filter, active->iStatus));

   287 		if (!error)

   288 			{

   289 			TEST(result);

   291 			active->StartL();

   292 			CActiveScheduler::Start();

   294 			if (active->iStatus.Int() == KErrNone)

   295 				{

   296 				finished = ETrue;

   298 				TEST(view->CountL() >= 1);

   299 				TEST(TestUtils::EventsEqual(*event, view->Event()));

   300 				}

   301 			else

   302 				{

   303 				TEST2(active->iStatus.Int(), KErrNoMemory);

   304 				}

   305 			}

   306 		else

   307 			{

   308 			TEST2(error, KErrNoMemory);

   309 			}

   311 		__LOGSERV_UHEAP_RESET;

   312 		}

   314 	list->AppendL(filter);

   315 	CleanupStack::Pop(); // filter

   317 	filter = CLogFilter::NewL();

   318 	CleanupStack::PushL(filter);

   319 	filter->SetEventType(KLogCallEventTypeUid);

   320 	list->AppendL(filter);

   321 	CleanupStack::Pop(); // filter

   323 	failCount = 0;

   324 	finished = EFalse;

   326 	while(!finished)

   327 		{

   328 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

   330 		TBool result = EFalse;

   331 		TRAP(error, result = view->SetFilterL(*list, active->iStatus));

   333 		if (!error)

   334 			{

   335 			TEST(result);

   337 			active->StartL();

   338 			CActiveScheduler::Start();

   340 			if (active->iStatus.Int() == KErrNone)

   341 				{

   342 				finished = ETrue;

   344 				TEST(view->CountL() >= 1);

   345 				TEST(TestUtils::EventsEqual(*event, view->Event()));

   346 				}

   347 			else

   348 				{

   349 				TEST2(active->iStatus.Int(), KErrNoMemory);

   350 				}

   351 			}

   352 		else

   353 			{

   354 			TEST2(error, KErrNoMemory);

   355 			}

   357 		__LOGSERV_UHEAP_RESET;

   358 		}

   360 	list->ResetAndDestroy();

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

   362 	}

   364 /**

   365 @SYMTestCaseID          SYSLIB-LOGENG-CT-0982

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

   367 @SYMTestPriority 	    High

   368 @SYMTestActions  	    Set recent view list first without a filter and later with log filter,Check for log server failure error

   369 @SYMTestExpectedResults Test must not fail

   370 @SYMREQ                 REQ0000

   371 */

   372 LOCAL_C void TestRecentViewSetupWithLogServFailL(CLogClient& aClient)

   373 	{

   374 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0982 "));

   375 	CTestActive* active = new(ELeave)CTestActive;

   376 	CleanupStack::PushL(active);

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

   379 	CleanupStack::PushL(event);

   381 	// Incoming

   382 	TLogString buf;

   383 	aClient.GetString(buf, R_LOG_DIR_IN);

   385 	event->SetEventType(KLogCallEventTypeUid);

   386 	event->SetDirection(buf);

   387 	event->SetStatus(KTestStatus);

   389 	// Add an event

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

   391 	active->StartL();

   392 	CActiveScheduler::Start();

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

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

   396 	CleanupStack::PushL(view);

   398 	TInt failCount = 0;

   399 	TBool finished = EFalse;

   400 	TInt error;

   402 	while(!finished)

   403 		{

   404 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

   406 		TBool result = EFalse;

   407 		TRAP(error, result = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));

   409 		if (!error)

   410 			{

   411 			TEST(result);

   413 			active->StartL();

   414 			CActiveScheduler::Start();

   416 			if (active->iStatus.Int() == KErrNone)

   417 				{

   418 				finished = ETrue;

   419 				TEST(view->CountL() >= 1);

   420 				}

   421 			else

   422 				{

   423 				TEST2(active->iStatus.Int(), KErrNoMemory);

   424 				}

   425 			}

   426 		else

   427 			{

   428 			TEST2(error, KErrNoMemory);

   429 			}

   431 		__LOGSERV_UHEAP_RESET;

   432 		}

   434 	CLogFilterList* list = new(ELeave)CLogFilterList;

   435 	CleanupStack::PushL(list);

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

   438 	CleanupStack::PushL(filter);

   439 	filter->SetStatus(KTestStatus);

   441 	failCount = 0;

   442 	finished = EFalse;

   444 	while(!finished)

   445 		{

   446 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

   448 		TBool result = EFalse;

   449 		TRAP(error, result = view->SetRecentListL(KLogRecentIncomingCalls, *filter, active->iStatus));

   451 		if (!error)

   452 			{

   453 			TEST(result);

   455 			active->StartL();

   456 			CActiveScheduler::Start();

   458 			if (active->iStatus.Int() == KErrNone)

   459 				{

   460 				finished = ETrue;

   461 				TEST(view->CountL() >= 1);

   462 				}

   463 			else

   464 				TEST2(active->iStatus.Int(), KErrNoMemory);

   465 			}

   466 		else

   467 			TEST2(error, KErrNoMemory);

   469 		__LOGSERV_UHEAP_RESET;

   470 		}

   472 	list->AppendL(filter);

   473 	CleanupStack::Pop(); // filter

   475 	filter = CLogFilter::NewL();

   476 	CleanupStack::PushL(filter);

   477 	filter->SetEventType(KLogCallEventTypeUid);

   478 	list->AppendL(filter);

   479 	CleanupStack::Pop(); // filter

   481 	failCount = 0;

   482 	finished = EFalse;

   484 	while(!finished)

   485 		{

   486 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

   488 		TBool result = EFalse;

   489 		TRAP(error, result = view->SetRecentListL(KLogRecentIncomingCalls, *list, active->iStatus));

   491 		if (!error)

   492 			{

   493 			TEST(result);

   495 			active->StartL();

   496 			CActiveScheduler::Start();

   498 			if (active->iStatus.Int() == KErrNone)

   499 				{

   500 				finished = ETrue;

   501 				TEST(view->CountL() >= 1);

   502 				}

   503 			else

   504 				TEST2(active->iStatus.Int(), KErrNoMemory);

   505 			}

   506 		else

   507 			TEST2(error, KErrNoMemory);

   509 		__LOGSERV_UHEAP_RESET;

   510 		}

   512 	list->ResetAndDestroy();

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

   514 	}

   516 /**

   517 @SYMTestCaseID          SYSLIB-LOGENG-CT-0983

   518 @SYMTestCaseDesc	    Tests for CLogViewRecent::DuplicatesL() function

   519 @SYMTestPriority 	    High

   520 @SYMTestActions  	    Set the specified duplicate event view with logview duplicates.

   521                         Check for log server failure error

   522 @SYMTestExpectedResults Test must not fail

   523 @SYMREQ                 REQ0000

   524 */

   525 LOCAL_C void TestDuplicateViewSetupWithLogServFailL(CLogClient& aClient)

   526 	{

   527 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0983 "));

   528 	CTestActive* active = new(ELeave)CTestActive;

   529 	CleanupStack::PushL(active);

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

   532 	CleanupStack::PushL(event);

   534 	// Incoming

   535 	TLogString buf;

   536 	aClient.GetString(buf, R_LOG_DIR_IN);

   538 	event->SetEventType(KLogCallEventTypeUid);

   539 	event->SetDirection(buf);

   540 	event->SetContact(KTestContact);

   541 	event->SetStatus(KTestStatus);

   543 	// Add events

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

   545 	active->StartL();

   546 	CActiveScheduler::Start();

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

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

   550 	active->StartL();

   551 	CActiveScheduler::Start();

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

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

   555 	CleanupStack::PushL(view);

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

   558 	active->StartL();

   559 	CActiveScheduler::Start();

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

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

   563 	CleanupStack::PushL(duplicate);

   565 	TInt failCount = 0;

   566 	TBool finished = EFalse;

   567 	TInt error;

   569 	while(!finished)

   570 		{

   571 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

   573 		TBool result = EFalse;

   574 		TRAP(error, result = view->DuplicatesL(*duplicate, active->iStatus));

   576 		if (!error)

   577 			{

   578 			TEST(result);

   580 			active->StartL();

   581 			CActiveScheduler::Start();

   583 			if (active->iStatus.Int() == KErrNone)

   584 				{

   585 				finished = ETrue;

   586 				TEST(duplicate->CountL() >= 1);

   587 				}

   588 			else

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

   590 			}

   591 		else

   592 			TEST2(error, KErrNoMemory);

   594 		__LOGSERV_UHEAP_RESET;

   595 		}

   597 	CLogFilterList* list = new(ELeave)CLogFilterList;

   598 	CleanupStack::PushL(list);

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

   601 	CleanupStack::PushL(filter);

   602 	filter->SetStatus(KTestStatus);

   604 	failCount = 0;

   605 	finished = EFalse;

   607 	while(!finished)

   608 		{

   609 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

   611 		TBool result = EFalse;

   612 		TRAP(error, result = view->DuplicatesL(*duplicate, *filter, active->iStatus));

   614 		if (!error)

   615 			{

   616 			TEST(result);

   618 			active->StartL();

   619 			CActiveScheduler::Start();

   621 			if (active->iStatus.Int() == KErrNone)

   622 				{

   623 				finished = ETrue;

   624 				TEST(duplicate->CountL() >= 1);

   625 				}

   626 			else

   627 				TEST2(active->iStatus.Int(), KErrNoMemory);

   628 			}

   629 		else

   630 			TEST2(error, KErrNoMemory);

   632 		__LOGSERV_UHEAP_RESET;

   633 		}

   635 	list->AppendL(filter);

   636 	CleanupStack::Pop(); // filter

   638 	filter = CLogFilter::NewL();

   639 	CleanupStack::PushL(filter);

   640 	filter->SetEventType(KLogCallEventTypeUid);

   641 	list->AppendL(filter);

   642 	CleanupStack::Pop(); // filter

   644 	failCount = 0;

   645 	finished = EFalse;

   647 	while(!finished)

   648 		{

   649 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

   651 		TBool result = EFalse;

   652 		TRAP(error, result = view->DuplicatesL(*duplicate, *list, active->iStatus));

   654 		if (!error)

   655 			{

   656 			TEST(result);

   658 			active->StartL();

   659 			CActiveScheduler::Start();

   661 			if (active->iStatus.Int() == KErrNone)

   662 				{

   663 				finished = ETrue;

   664 				TEST(duplicate->CountL() >= 1);

   665 				}

   666 			else

   667 				TEST2(active->iStatus.Int(), KErrNoMemory);

   668 			}

   669 		else

   670 			TEST2(error, KErrNoMemory);

   672 		__LOGSERV_UHEAP_RESET;

   673 		}

   675 	list->ResetAndDestroy();

   676 	CleanupStack::PopAndDestroy(5); // list, duplicate, view, event, active

   677 	}

   679 /**

   680 @SYMTestCaseID          SYSLIB-LOGENG-CT-0984

   681 @SYMTestCaseDesc	    Tests for CLogViewEvent::NextL(),LastL(),PreviousL(),FirstL() functions

   682 @SYMTestPriority 	    High

   683 @SYMTestActions  	    Tests for all the navigation functions in the view.Check for log server failure error

   684 @SYMTestExpectedResults Test must not fail

   685 @SYMREQ                 REQ0000

   686 */

   687 LOCAL_C void TestNavigationWithLogServFailL(CLogClient& aClient)

   688 	{

   689 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0984 "));

   690 	CTestActive* active = new(ELeave)CTestActive;

   691 	CleanupStack::PushL(active);

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

   694 	CleanupStack::PushL(event);

   695 	event->SetEventType(KLogCallEventTypeUid);

   697 	// Add an event

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

   699 	active->StartL();

   700 	CActiveScheduler::Start();

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

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

   704 	CleanupStack::PushL(view);

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

   707 	CleanupStack::PushL(filter);

   709 	TInt failCount = 0;

   710 	TBool finished = EFalse;

   711 	TInt error;

   713 	while(!finished)

   714 		{

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

   716 		active->StartL();

   717 		CActiveScheduler::Start();

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

   719 		TEST(view->CountL() > 1);

   720 		event->CopyL(view->Event());

   722 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

   724 		TBool result = EFalse;

   725 		TRAP(error, result = view->NextL(active->iStatus));

   727 		if (!error)

   728 			{

   729 			TEST(result);

   731 			active->StartL();

   732 			CActiveScheduler::Start();

   734 			if (active->iStatus.Int() == KErrNone)

   735 				{

   736 				finished = ETrue;

   737 				TEST(!TestUtils::EventsEqual(*event, view->Event()));

   738 				}

   739 			else

   740 				TEST2(active->iStatus.Int(), KErrNoMemory);

   741 			}

   742 		else

   743 			TEST2(error, KErrNoMemory);

   745 		__LOGSERV_UHEAP_RESET;

   746 		}

   748 	failCount = 0;

   749 	finished = EFalse;

   751 	while(!finished)

   752 		{

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

   754 		active->StartL();

   755 		CActiveScheduler::Start();

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

   757 		TEST(view->CountL() > 1);

   759 		TEST(view->LastL(active->iStatus));

   760 		active->StartL();

   761 		CActiveScheduler::Start();

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

   764 		event->CopyL(view->Event());

   766 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

   768 		TBool result = EFalse;

   769 		TRAP(error, result = view->PreviousL(active->iStatus));

   771 		if (!error)

   772 			{

   773 			TEST(result);

   775 			active->StartL();

   776 			CActiveScheduler::Start();

   778 			if (active->iStatus.Int() == KErrNone)

   779 				{

   780 				finished = ETrue;

   781 				TEST(!TestUtils::EventsEqual(*event, view->Event()));

   782 				}

   783 			else

   784 				TEST2(active->iStatus.Int(), KErrNoMemory);

   785 			}

   786 		else

   787 			TEST2(error, KErrNoMemory);

   789 		__LOGSERV_UHEAP_RESET;

   790 		}

   792 	failCount = 0;

   793 	finished = EFalse;

   795 	while(!finished)

   796 		{

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

   798 		active->StartL();

   799 		CActiveScheduler::Start();

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

   801 		TEST(view->CountL() > 1);

   803 		TEST(view->LastL(active->iStatus));

   804 		active->StartL();

   805 		CActiveScheduler::Start();

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

   808 		event->CopyL(view->Event());

   810 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

   812 		TBool result = EFalse;

   813 		TRAP(error, result = view->FirstL(active->iStatus));

   815 		if (!error)

   816 			{

   817 			TEST(result);

   819 			active->StartL();

   820 			CActiveScheduler::Start();

   822 			if (active->iStatus.Int() == KErrNone)

   823 				{

   824 				finished = ETrue;

   825 				TEST(!TestUtils::EventsEqual(*event, view->Event()));

   826 				}

   827 			else

   828 				TEST2(active->iStatus.Int(), KErrNoMemory);

   829 			}

   830 		else

   831 			TEST2(error, KErrNoMemory);

   833 		__LOGSERV_UHEAP_RESET;

   834 		}

   836 	failCount = 0;

   837 	finished = EFalse;

   839 	while(!finished)

   840 		{

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

   842 		active->StartL();

   843 		CActiveScheduler::Start();

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

   845 		TEST(view->CountL() > 1);

   847 		TEST(view->FirstL(active->iStatus));

   848 		active->StartL();

   849 		CActiveScheduler::Start();

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

   852 		event->CopyL(view->Event());

   854 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

   856 		TBool result = EFalse;

   857 		TRAP(error, result = view->LastL(active->iStatus));

   859 		if (!error)

   860 			{

   861 			TEST(result);

   863 			active->StartL();

   864 			CActiveScheduler::Start();

   866 			if (active->iStatus.Int() == KErrNone)

   867 				{

   868 				finished = ETrue;

   869 				TEST(!TestUtils::EventsEqual(*event, view->Event()));

   870 				}

   871 			else

   872 				TEST2(active->iStatus.Int(), KErrNoMemory);

   873 			}

   874 		else

   875 			TEST2(error, KErrNoMemory);

   877 		__LOGSERV_UHEAP_RESET;

   878 		}

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

   881 	}

   883 /**

   884 @SYMTestCaseID          SYSLIB-LOGENG-CT-0985

   885 @SYMTestCaseDesc	    Tests for CLogViewEvent::CountL() functions

   886 @SYMTestPriority 	    High

   887 @SYMTestActions  	    Test for getting the number of events in the view.Check for log server failure error

   888 @SYMTestExpectedResults Test must not fail

   889 @SYMREQ                 REQ0000

   890 */

   891 LOCAL_C void TestViewCountWithLogServFailL(CLogClient& aClient)

   892 	{

   893 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0985 "));

   894 	CTestActive* active = new(ELeave)CTestActive;

   895 	CleanupStack::PushL(active);

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

   898 	CleanupStack::PushL(event);

   899 	event->SetEventType(KLogCallEventTypeUid);

   901 	// Add an event

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

   903 	active->StartL();

   904 	CActiveScheduler::Start();

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

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

   908 	CleanupStack::PushL(view);

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

   911 	CleanupStack::PushL(filter);

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

   914 	active->StartL();

   915 	CActiveScheduler::Start();

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

   918 	TInt failCount = 0;

   919 	TBool finished = EFalse;

   920 	TInt error;

   922 	while(!finished)

   923 		{

   924 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

   926 		TInt result = 0;

   927 		TRAP(error, result = view->CountL());

   929 		if (!error)

   930 			{

   931 			finished = ETrue;

   932 			TEST(result > 0);

   933 			}

   934 		else

   935 			TEST2(error, KErrNoMemory);

   937 		__LOGSERV_UHEAP_RESET;

   938 		}

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

   941 	}

   943 /**

   944 @SYMTestCaseID          SYSLIB-LOGENG-CT-0986

   945 @SYMTestCaseDesc	    Tests for CLogViewRecent::RemoveL() function

   946 @SYMTestPriority 	    High

   947 @SYMTestActions  	    Test for removing the event with the specified unique event ID from the view

   948 						Check for log server failure error

   949 @SYMTestExpectedResults Test must not fail

   950 @SYMREQ                 REQ0000

   951 */

   952 LOCAL_C void TestRecentViewRemoveWithLogServFailL(CLogClient& aClient)

   953 	{

   954 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0986 "));

   955 	CTestActive* active = new(ELeave)CTestActive;

   956 	CleanupStack::PushL(active);

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

   959 	CleanupStack::PushL(event);

   961 	// Incoming

   962 	TLogString buf;

   963 	aClient.GetString(buf, R_LOG_DIR_IN);

   965 	event->SetEventType(KLogCallEventTypeUid);

   966 	event->SetDirection(buf);

   967 	event->SetContact(1);

   969 	// Add events

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

   971 	active->StartL();

   972 	CActiveScheduler::Start();

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

   975 	event->SetContact(2);

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

   978 	active->StartL();

   979 	CActiveScheduler::Start();

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

   982 	event->SetContact(3);

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

   985 	active->StartL();

   986 	CActiveScheduler::Start();

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

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

   990 	CleanupStack::PushL(view);

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

   993 	active->StartL();

   994 	CActiveScheduler::Start();

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

   997 	TInt count = view->CountL();

   998 	TEST(count > 1);

  1000 	TInt failCount = 0;

  1001 	TBool finished = EFalse;

  1002 	TInt error;

  1004 	while(!finished)

  1005 		{

  1006 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

  1008 		TRAP(error, view->RemoveL(view->Event().Id()));

  1010 		__LOGSERV_UHEAP_RESET;

  1012 		if (!error)

  1013 			{

  1014 			finished = ETrue;

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

  1017 			active->StartL();

  1018 			CActiveScheduler::Start();

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

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

  1022 			}

  1023 		else

  1024 			TEST2(error, KErrNoMemory);

  1025 		}

  1027 	failCount = 0;

  1028 	finished = EFalse;

  1030 	while(!finished)

  1031 		{

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

  1033 		active->StartL();

  1034 		CActiveScheduler::Start();

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

  1037 		count = view->CountL();

  1038 		TEST(count > 1);

  1040 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

  1042 		TBool ret = EFalse;

  1043 		TRAP(error, ret = view->RemoveL(active->iStatus));

  1045 		__LOGSERV_UHEAP_RESET;

  1047 		if (!error)

  1048 			{

  1049 			TEST(ret);

  1051 			active->StartL();

  1052 			CActiveScheduler::Start();

  1054 			if (active->iStatus == KErrNone)

  1055 				{

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

  1057 				finished = ETrue;

  1058 				}

  1059 			else

  1060 				TEST2(active->iStatus.Int(), KErrNoMemory);

  1061 			}

  1062 		else

  1063 			TEST2(error, KErrNoMemory);

  1064 		}

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

  1067 	}

  1069 /**

  1070 @SYMTestCaseID          SYSLIB-LOGENG-CT-0987

  1071 @SYMTestCaseDesc	    Tests for CLogViewDuplicate::RemoveL() function

  1072 @SYMTestPriority 	    High

  1073 @SYMTestActions  	    Test for removing the event with the specified unique event ID from the view.Check for memory error

  1074 @SYMTestExpectedResults Test must not fail

  1075 @SYMREQ                 REQ0000

  1076 */

  1077 LOCAL_C void TestDuplicateViewRemoveWithLogServFailL(CLogClient& aClient)

  1078 	{

  1079 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0987 "));

  1080 	CTestActive* active = new(ELeave)CTestActive;

  1081 	CleanupStack::PushL(active);

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

  1084 	CleanupStack::PushL(event);

  1086 	// Incoming

  1087 	TLogString buf;

  1088 	aClient.GetString(buf, R_LOG_DIR_IN);

  1090 	event->SetEventType(KLogCallEventTypeUid);

  1091 	event->SetDirection(buf);

  1092 	event->SetContact(KTestContact);

  1094 	// Add events

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

  1096 	active->StartL();

  1097 	CActiveScheduler::Start();

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

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

  1101 	active->StartL();

  1102 	CActiveScheduler::Start();

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

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

  1106 	active->StartL();

  1107 	CActiveScheduler::Start();

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

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

  1111 	active->StartL();

  1112 	CActiveScheduler::Start();

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

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

  1116 	CleanupStack::PushL(view);

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

  1119 	active->StartL();

  1120 	CActiveScheduler::Start();

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

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

  1124 	CleanupStack::PushL(duplicate);

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

  1127 	active->StartL();

  1128 	CActiveScheduler::Start();

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

  1131 	TInt count = duplicate->CountL();

  1132 	TEST(count > 0);

  1134 	TInt failCount = 0;

  1135 	TBool finished = EFalse;

  1136 	TInt error;

  1138 	while(!finished)

  1139 		{

  1140 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

  1142 		TRAP(error, duplicate->RemoveL(duplicate->Event().Id()));

  1144 		__LOGSERV_UHEAP_RESET;

  1146 		if (!error)

  1147 			{

  1148 			finished = ETrue;

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

  1151 			active->StartL();

  1152 			CActiveScheduler::Start();

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

  1155 			TEST(count == duplicate->CountL() + 1);

  1156 			}

  1157 		else

  1158 			TEST2(error, KErrNoMemory);

  1159 		}

  1161 	failCount = 0;

  1162 	finished = EFalse;

  1164 	while(!finished)

  1165 		{

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

  1167 		active->StartL();

  1168 		CActiveScheduler::Start();

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

  1171 		count = duplicate->CountL();

  1173 		__LOGSERV_UHEAP_FAILNEXT(failCount++);

  1175 		TBool ret = EFalse;

  1176 		TRAP(error, ret = duplicate->RemoveL(active->iStatus));

  1178 		__LOGSERV_UHEAP_RESET;

  1180 		if (!error)

  1181 			{

  1182 			if (ret)

  1183 				{

  1184 				active->StartL();

  1185 				CActiveScheduler::Start();

  1186 				}

  1188 			if (!ret || active->iStatus == KErrNone)

  1189 				{

  1190 				finished = ETrue;

  1191 				TEST(count == duplicate->CountL() + 1);

  1192 				}

  1193 			else

  1194 				TEST2(active->iStatus.Int(), KErrNoMemory);

  1195 			}

  1196 		else

  1197 			TEST2(error, KErrNoMemory);

  1198 		}

  1200 	CleanupStack::PopAndDestroy(4); // duplicate, view, event, active

  1201 	}

  1203 void doTestsL()

  1204 	{

  1205 	TestUtils::Initialize(_L("t_logviewfail3"));

  1206 	TestUtils::DeleteDatabaseL();

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

  1209 	CleanupStack::PushL(client);

  1211 	TheTest.Start(_L("Heap Failure in Log Server"));

  1213 	TheTest.Next(_L("View Construction"));

  1214 	TestEventViewConstructWithLogServFailL(*client);

  1215 	TestRecentViewConstructWithLogServFailL(*client);

  1216 	TestDuplicateViewConstructWithLogServFailL(*client);

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

  1219 	TheTest.Next(_L("View Setup"));

  1220 	TestEventViewSetupWithLogServFailL(*client);

  1221 	TestRecentViewSetupWithLogServFailL(*client);

  1222 	TestDuplicateViewSetupWithLogServFailL(*client);

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

  1225 	TheTest.Next(_L("View Navigation"));

  1226 	TestNavigationWithLogServFailL(*client);

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

  1229 	TheTest.Next(_L("Other"));

  1230 	TestViewCountWithLogServFailL(*client);

  1231 	TestRecentViewRemoveWithLogServFailL(*client);

  1232 	TestDuplicateViewRemoveWithLogServFailL(*client);

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

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

  1236 	}

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