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_logviewfail"));

    22 const TLogContactItemId KTestContact = 0x123;

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

    26 /**

    27 @SYMTestCaseID          SYSLIB-LOGENG-CT-0961-0001

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

    29 @SYMTestPriority 	    High

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

    31                         Check for memory errors

    32 @SYMTestExpectedResults Test must not fail

    33 @SYMREQ                 REQ0000

    34 */

    35 LOCAL_C void TestEventViewConstructWithHeapFailL(CLogClient& aClient)

    36 	{

    37 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0961-0001 "));

    38 	CTestActive* active = new(ELeave)CTestActive;

    39 	CleanupStack::PushL(active);

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

    42 	CleanupStack::PushL(event);

    43 	event->SetEventType(KLogCallEventTypeUid);

    45 	// Add an event

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

    47 	active->StartL();

    48 	CActiveScheduler::Start();

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

    51 	CLogViewEvent* view = NULL;

    53 #ifdef _DEBUG

    54 	TInt failCount = 0;

    55 #endif

    56 	TBool finished = EFalse;

    57 	TInt error;

    59 	while(!finished)

    60 		{

    61 		__UHEAP_FAILNEXT(failCount++);

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

    65 		__UHEAP_RESET;

    67 		if (!error)

    68 			{

    69 			finished = ETrue;

    70 			CleanupStack::PushL(view);

    72 			// Check the view works

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

    74 			CleanupStack::PushL(filter);

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

    77 			active->StartL();

    78 			CActiveScheduler::Start();

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

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

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

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

    84 			}

    85 		else

    86 			TEST2(error, KErrNoMemory);

    87 		}

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

    90 	}

    92 /**

    93 @SYMTestCaseID          SYSLIB-LOGENG-CT-0962-0001

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

    95 @SYMTestPriority 	    High

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

    97                         Check for no memory errors.

    98 @SYMTestExpectedResults Test must not fail

    99 @SYMREQ                 REQ0000

   100 */

   101 LOCAL_C void TestRecentViewConstructWithHeapFailL(CLogClient& aClient)

   102 	{

   103 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0962-0001 "));

   104 	CTestActive* active = new(ELeave)CTestActive;

   105 	CleanupStack::PushL(active);

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

   108 	CleanupStack::PushL(event);

   110 	// Incoming

   111 	TLogString buf;

   112 	aClient.GetString(buf, R_LOG_DIR_IN);

   114 	event->SetEventType(KLogCallEventTypeUid);

   115 	event->SetDirection(buf);

   117 	// Add an event

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

   119 	active->StartL();

   120 	CActiveScheduler::Start();

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

   123 	CLogViewRecent* view = NULL;

   125 #ifdef _DEBUG

   126 	TInt failCount = 0;

   127 #endif

   129 	TBool finished = EFalse;

   130 	TInt error;

   132 	while(!finished)

   133 		{

   134 		__UHEAP_FAILNEXT(failCount++);

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

   138 		__UHEAP_RESET;

   140 		if (!error)

   141 			{

   142 			finished = ETrue;

   143 			CleanupStack::PushL(view);

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

   146 			active->StartL();

   147 			CActiveScheduler::Start();

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

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

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

   152 			CleanupStack::PopAndDestroy(); // view

   153 			}

   154 		else

   155 			TEST2(error, KErrNoMemory);

   156 		}

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

   159 	}

   161 /**

   162 @SYMTestCaseID          SYSLIB-LOGENG-CT-0963-0001

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

   164 @SYMTestPriority 	    High

   165 @SYMTestActions  	    Create a new logviewrecent object,set the recent log view,

   166                         List out the duplicates of the current event in the recent event list view,

   167                         Check for no memory errors.

   168 @SYMTestExpectedResults Test must not fail

   169 @SYMREQ                 REQ0000

   170 */

   171 LOCAL_C void TestDuplicateViewConstructWithHeapFailL(CLogClient& aClient)

   172 	{

   173 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0963-0001 "));

   174 	CTestActive* active = new(ELeave)CTestActive;

   175 	CleanupStack::PushL(active);

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

   178 	CleanupStack::PushL(event);

   180 	// Incoming

   181 	TLogString buf;

   182 	aClient.GetString(buf, R_LOG_DIR_IN);

   184 	event->SetEventType(KLogCallEventTypeUid);

   185 	event->SetDirection(buf);

   186 	event->SetContact(KTestContact);

   188 	// Add events

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

   190 	active->StartL();

   191 	CActiveScheduler::Start();

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

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

   195 	active->StartL();

   196 	CActiveScheduler::Start();

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

   199 	CLogViewDuplicate* view = NULL;

   201 #ifdef _DEBUG

   202 	TInt failCount = 0;

   203 #endif

   205 	TBool finished = EFalse;

   206 	TInt error;

   208 	while(!finished)

   209 		{

   210 		__UHEAP_FAILNEXT(failCount++);

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

   214 		__UHEAP_RESET;

   216 		if (!error)

   217 			{

   218 			finished = ETrue;

   219 			CleanupStack::PushL(view);

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

   222 			CleanupStack::PushL(recent);

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

   224 			active->StartL();

   225 			CActiveScheduler::Start();

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

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

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

   230 			active->StartL();

   231 			CActiveScheduler::Start();

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

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

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

   236 			}

   237 		else

   238 			TEST2(error, KErrNoMemory);

   239 		}

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

   242 	}

   244 /**

   245 @SYMTestCaseID          SYSLIB-LOGENG-CT-0964-0001

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

   247 @SYMTestPriority 	    High

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

   249 						added.Check for memory errors.

   250 @SYMTestExpectedResults Test must not fail

   251 @SYMREQ                 REQ0000

   252 */

   253 LOCAL_C void TestEventViewSetupWithHeapFailL(CLogClient& aClient)

   254 	{

   255 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0964-0001 "));

   256 	CTestActive* active = new(ELeave)CTestActive;

   257 	CleanupStack::PushL(active);

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

   260 	CleanupStack::PushL(event);

   261 	event->SetEventType(KLogCallEventTypeUid);

   262 	event->SetStatus(KTestStatus);

   264 	// Add an event

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

   266 	active->StartL();

   267 	CActiveScheduler::Start();

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

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

   271 	CleanupStack::PushL(view);

   273 	CLogFilterList* list = new(ELeave)CLogFilterList;

   274 	CleanupStack::PushL(list);

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

   277 	CleanupStack::PushL(filter);

   278 	filter->SetStatus(KTestStatus);

   280 #ifdef _DEBUG

   281 	TInt failCount = 0;

   282 #endif

   284 	TBool finished = EFalse;

   285 	TInt error;

   287 	while(!finished)

   288 		{

   289 		__UHEAP_FAILNEXT(failCount++);

   291 		TBool result = EFalse;

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

   294 		if (!error)

   295 			{

   296 			TEST(result);

   298 			active->StartL();

   299 			CActiveScheduler::Start();

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

   302 				{

   303 				finished = ETrue;

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

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

   307 				}

   308 			else

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

   310 			}

   311 		else

   312 			TEST2(error, KErrNoMemory);

   314 		__UHEAP_RESET;

   315 		}

   317 	list->AppendL(filter);

   318 	CleanupStack::Pop(); // filter

   320 	filter = CLogFilter::NewL();

   321 	CleanupStack::PushL(filter);

   322 	filter->SetEventType(KLogCallEventTypeUid);

   323 	list->AppendL(filter);

   324 	CleanupStack::Pop(); // filter

   326 #ifdef _DEBUG

   327 	failCount = 0;

   328 #endif

   330 	while(!finished)

   331 		{

   332 		__UHEAP_FAILNEXT(failCount++);

   334 		TBool result = EFalse;

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

   337 		if (!error)

   338 			{

   339 			TEST(result);

   341 			active->StartL();

   342 			CActiveScheduler::Start();

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

   345 				{

   346 				finished = ETrue;

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

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

   350 				}

   351 			else

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

   353 			}

   354 		else

   355 			TEST2(error, KErrNoMemory);

   357 		__UHEAP_RESET;

   358 		}

   360 	list->ResetAndDestroy();

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

   362 	}

   364 /**

   365 @SYMTestCaseID          SYSLIB-LOGENG-CT-0965-0001

   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 memory errors

   369 @SYMTestExpectedResults Test must not fail

   370 @SYMREQ                 REQ0000

   371 */

   372 LOCAL_C void TestRecentViewSetupWithHeapFailL(CLogClient& aClient)

   373 	{

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

   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 #ifdef _DEBUG

   399 	TInt failCount = 0;

   400 #endif

   402 	TBool finished = EFalse;

   403 	TInt error;

   405 	while(!finished)

   406 		{

   407 		__UHEAP_FAILNEXT(failCount++);

   409 		TBool result = EFalse;

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

   412 		if (!error)

   413 			{

   414 			TEST(result);

   416 			active->StartL();

   417 			CActiveScheduler::Start();

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

   420 				{

   421 				finished = ETrue;

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

   423 				}

   424 			else

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

   426 			}

   427 		else

   428 			TEST2(error, KErrNoMemory);

   430 		__UHEAP_RESET;

   431 		}

   433 	CLogFilterList* list = new(ELeave)CLogFilterList;

   434 	CleanupStack::PushL(list);

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

   437 	CleanupStack::PushL(filter);

   438 	filter->SetStatus(KTestStatus);

   440 #ifdef _DEBUG

   441 	failCount = 0;

   442 #endif

   443 	finished = EFalse;

   445 	while(!finished)

   446 		{

   447 		__UHEAP_FAILNEXT(failCount++);

   449 		TBool result = EFalse;

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

   452 		if (!error)

   453 			{

   454 			TEST(result);

   456 			active->StartL();

   457 			CActiveScheduler::Start();

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

   460 				{

   461 				finished = ETrue;

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

   463 				}

   464 			else

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

   466 			}

   467 		else

   468 			TEST2(error, KErrNoMemory);

   470 		__UHEAP_RESET;

   471 		}

   473 	list->AppendL(filter);

   474 	CleanupStack::Pop(); // filter

   476 	filter = CLogFilter::NewL();

   477 	CleanupStack::PushL(filter);

   478 	filter->SetEventType(KLogCallEventTypeUid);

   479 	list->AppendL(filter);

   480 	CleanupStack::Pop(); // filter

   482 #ifdef _DEBUG

   483 	failCount = 0;

   484 #endif

   485 	finished = EFalse;

   487 	while(!finished)

   488 		{

   489 		__UHEAP_FAILNEXT(failCount++);

   491 		TBool result = EFalse;

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

   494 		if (!error)

   495 			{

   496 			TEST(result);

   498 			active->StartL();

   499 			CActiveScheduler::Start();

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

   502 				{

   503 				finished = ETrue;

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

   505 				}

   506 			else

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

   508 			}

   509 		else

   510 			TEST2(error, KErrNoMemory);

   512 		__UHEAP_RESET;

   513 		}

   515 	list->ResetAndDestroy();

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

   517 	}

   519 /**

   520 @SYMTestCaseID          SYSLIB-LOGENG-CT-0966

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

   522 @SYMTestPriority 	    High

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

   524                         Check for memory errors

   525 @SYMTestExpectedResults Test must not fail

   526 @SYMREQ                 REQ0000

   527 */

   528 LOCAL_C void TestDuplicateViewSetupWithHeapFailL(CLogClient& aClient)

   529 	{

   530 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0966 "));

   531 	CTestActive* active = new(ELeave)CTestActive;

   532 	CleanupStack::PushL(active);

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

   535 	CleanupStack::PushL(event);

   537 	// Incoming

   538 	TLogString buf;

   539 	aClient.GetString(buf, R_LOG_DIR_IN);

   541 	event->SetEventType(KLogCallEventTypeUid);

   542 	event->SetDirection(buf);

   543 	event->SetContact(KTestContact);

   544 	event->SetStatus(KTestStatus);

   546 	// Add events

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

   548 	active->StartL();

   549 	CActiveScheduler::Start();

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

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

   553 	active->StartL();

   554 	CActiveScheduler::Start();

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

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

   558 	CleanupStack::PushL(view);

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

   561 	active->StartL();

   562 	CActiveScheduler::Start();

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

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

   566 	CleanupStack::PushL(duplicate);

   568 #ifdef _DEBUG

   569 	TInt failCount = 0;

   570 #endif

   572 	TBool finished = EFalse;

   573 	TInt error;

   575 	while(!finished)

   576 		{

   577 		__UHEAP_FAILNEXT(failCount++);

   579 		TBool result = EFalse;

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

   582 		if (!error)

   583 			{

   584 			TEST(result);

   586 			active->StartL();

   587 			CActiveScheduler::Start();

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

   590 				{

   591 				finished = ETrue;

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

   593 				}

   594 			else

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

   596 			}

   597 		else

   598 			TEST2(error, KErrNoMemory);

   600 		__UHEAP_RESET;

   601 		}

   603 	CLogFilterList* list = new(ELeave)CLogFilterList;

   604 	CleanupStack::PushL(list);

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

   607 	CleanupStack::PushL(filter);

   608 	filter->SetStatus(KTestStatus);

   610 #ifdef _DEBUG

   611 	failCount = 0;

   612 #endif

   613 	finished = EFalse;

   615 	while(!finished)

   616 		{

   617 		__UHEAP_FAILNEXT(failCount++);

   619 		TBool result = EFalse;

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

   622 		if (!error)

   623 			{

   624 			TEST(result);

   626 			active->StartL();

   627 			CActiveScheduler::Start();

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

   630 				{

   631 				finished = ETrue;

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

   633 				}

   634 			else

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

   636 			}

   637 		else

   638 			TEST2(error, KErrNoMemory);

   640 		__UHEAP_RESET;

   641 		}

   643 	list->AppendL(filter);

   644 	CleanupStack::Pop(); // filter

   646 	filter = CLogFilter::NewL();

   647 	CleanupStack::PushL(filter);

   648 	filter->SetEventType(KLogCallEventTypeUid);

   649 	list->AppendL(filter);

   650 	CleanupStack::Pop(); // filter

   652 #ifdef _DEBUG

   653 	failCount = 0;

   654 #endif

   655 	finished = EFalse;

   657 	while(!finished)

   658 		{

   659 		__UHEAP_FAILNEXT(failCount++);

   661 		TBool result = EFalse;

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

   664 		if (!error)

   665 			{

   666 			TEST(result);

   668 			active->StartL();

   669 			CActiveScheduler::Start();

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

   672 				{

   673 				finished = ETrue;

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

   675 				}

   676 			else

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

   678 			}

   679 		else

   680 			TEST2(error, KErrNoMemory);

   682 		__UHEAP_RESET;

   683 		}

   685 	list->ResetAndDestroy();

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

   687 	}

   689 /**

   690 @SYMTestCaseID          SYSLIB-LOGENG-CT-0967

   691 @SYMTestCaseDesc	    Tests for CLogViewEvent::NextL(),CLogViewEvent::LastL(),CLogViewEvent::PreviousL(),

   692                         CLogViewEvent::FirstL() functions

   693 @SYMTestPriority 	    High

   694 @SYMTestActions  	    Tests for all the navigation functions in the view.

   695 @SYMTestExpectedResults Test must not fail

   696 @SYMREQ                 REQ0000

   697 */

   698 LOCAL_C void TestNavigationWithHeapFailL(CLogClient& aClient)

   699 	{

   700 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0967 "));

   701 	CTestActive* active = new(ELeave)CTestActive;

   702 	CleanupStack::PushL(active);

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

   705 	CleanupStack::PushL(event);

   706 	event->SetEventType(KLogCallEventTypeUid);

   708 	// Add an event

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

   710 	active->StartL();

   711 	CActiveScheduler::Start();

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

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

   715 	CleanupStack::PushL(view);

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

   718 	CleanupStack::PushL(filter);

   720 #ifdef _DEBUG

   721 	TInt failCount = 0;

   722 #endif

   724 	TBool finished = EFalse;

   725 	TInt error;

   727 	while(!finished)

   728 		{

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

   730 		active->StartL();

   731 		CActiveScheduler::Start();

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

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

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

   736 		__UHEAP_FAILNEXT(failCount++);

   738 		TBool result = EFalse;

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

   741 		if (!error)

   742 			{

   743 			TEST(result);

   745 			active->StartL();

   746 			CActiveScheduler::Start();

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

   749 				{

   750 				finished = ETrue;

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

   752 				}

   753 			else

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

   755 			}

   756 		else

   757 			TEST2(error, KErrNoMemory);

   759 		__UHEAP_RESET;

   760 		}

   762 #ifdef _DEBUG

   763 	failCount = 0;

   764 #endif

   765 	finished = EFalse;

   767 	while(!finished)

   768 		{

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

   770 		active->StartL();

   771 		CActiveScheduler::Start();

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

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

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

   776 		active->StartL();

   777 		CActiveScheduler::Start();

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

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

   782 		__UHEAP_FAILNEXT(failCount++);

   784 		TBool result = EFalse;

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

   787 		if (!error)

   788 			{

   789 			TEST(result);

   791 			active->StartL();

   792 			CActiveScheduler::Start();

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

   795 				{

   796 				finished = ETrue;

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

   798 				}

   799 			else

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

   801 			}

   802 		else

   803 			TEST2(error, KErrNoMemory);

   805 		__UHEAP_RESET;

   806 		}

   808 #ifdef _DEBUG

   809 	failCount = 0;

   810 #endif

   811 	finished = EFalse;

   813 	while(!finished)

   814 		{

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

   816 		active->StartL();

   817 		CActiveScheduler::Start();

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

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

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

   822 		active->StartL();

   823 		CActiveScheduler::Start();

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

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

   828 		__UHEAP_FAILNEXT(failCount++);

   830 		TBool result = EFalse;

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

   833 		if (!error)

   834 			{

   835 			TEST(result);

   837 			active->StartL();

   838 			CActiveScheduler::Start();

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

   841 				{

   842 				finished = ETrue;

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

   844 				}

   845 			else

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

   847 			}

   848 		else

   849 			TEST2(error, KErrNoMemory);

   851 		__UHEAP_RESET;

   852 		}

   854 #ifdef _DEBUG

   855 	failCount = 0;

   856 #endif

   857 	finished = EFalse;

   859 	while(!finished)

   860 		{

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

   862 		active->StartL();

   863 		CActiveScheduler::Start();

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

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

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

   868 		active->StartL();

   869 		CActiveScheduler::Start();

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

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

   874 		__UHEAP_FAILNEXT(failCount++);

   876 		TBool result = EFalse;

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

   879 		if (!error)

   880 			{

   881 			TEST(result);

   883 			active->StartL();

   884 			CActiveScheduler::Start();

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

   887 				{

   888 				finished = ETrue;

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

   890 				}

   891 			else

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

   893 			}

   894 		else

   895 			TEST2(error, KErrNoMemory);

   897 		__UHEAP_RESET;

   898 		}

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

   901 	}

   903 /**

   904 @SYMTestCaseID          SYSLIB-LOGENG-CT-0968

   905 @SYMTestCaseDesc	    Tests for CLogViewEvent::CountL() function

   906 @SYMTestPriority 	    High

   907 @SYMTestActions  	    Test for getting the number of events in the view.Check for memory errors

   908 @SYMTestExpectedResults Test must not fail

   909 @SYMREQ                 REQ0000

   910 */

   911 LOCAL_C void TestViewCountWithHeapFailL(CLogClient& aClient)

   912 	{

   913 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0968 "));

   914 	CTestActive* active = new(ELeave)CTestActive;

   915 	CleanupStack::PushL(active);

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

   918 	CleanupStack::PushL(event);

   919 	event->SetEventType(KLogCallEventTypeUid);

   921 	// Add an event

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

   923 	active->StartL();

   924 	CActiveScheduler::Start();

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

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

   928 	CleanupStack::PushL(view);

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

   931 	CleanupStack::PushL(filter);

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

   934 	active->StartL();

   935 	CActiveScheduler::Start();

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

   938 #ifdef _DEBUG

   939 	TInt failCount = 0;

   940 #endif

   942 	TBool finished = EFalse;

   943 	TInt error;

   945 	while(!finished)

   946 		{

   947 		__UHEAP_FAILNEXT(failCount++);

   949 		TInt result = 0;

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

   952 		if (!error)

   953 			{

   954 			finished = ETrue;

   955 			TEST(result > 0);

   956 			}

   957 		else

   958 			TEST2(error, KErrNoMemory);

   960 		__UHEAP_RESET;

   961 		}

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

   964 	}

   966 /**

   967 @SYMTestCaseID          SYSLIB-LOGENG-CT-0969

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

   969 @SYMTestPriority 	    High

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

   971 @SYMTestExpectedResults Test must not fail

   972 @SYMREQ                 REQ0000

   973 */

   974 LOCAL_C void TestRecentViewRemoveWithHeapFailL(CLogClient& aClient)

   975 	{

   976 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0969 "));

   977 	CTestActive* active = new(ELeave)CTestActive;

   978 	CleanupStack::PushL(active);

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

   981 	CleanupStack::PushL(event);

   983 	// Incoming

   984 	TLogString buf;

   985 	aClient.GetString(buf, R_LOG_DIR_IN);

   987 	event->SetEventType(KLogCallEventTypeUid);

   988 	event->SetDirection(buf);

   989 	event->SetContact(1);

   991 	// Add events

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

   993 	active->StartL();

   994 	CActiveScheduler::Start();

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

   997 	event->SetContact(2);

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

  1000 	active->StartL();

  1001 	CActiveScheduler::Start();

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

  1004 	event->SetContact(3);

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

  1007 	active->StartL();

  1008 	CActiveScheduler::Start();

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

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

  1012 	CleanupStack::PushL(view);

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

  1015 	active->StartL();

  1016 	CActiveScheduler::Start();

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

  1019 	TInt count = view->CountL();

  1020 	TEST(count > 1);

  1022 #ifdef _DEBUG

  1023 	TInt failCount = 0;

  1024 #endif

  1026 	TBool finished = EFalse;

  1027 	TInt error;

  1029 	while(!finished)

  1030 		{

  1031 		__UHEAP_FAILNEXT(failCount++);

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

  1035 		__UHEAP_RESET;

  1037 		if (!error)

  1038 			{

  1039 			finished = ETrue;

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

  1042 			active->StartL();

  1043 			CActiveScheduler::Start();

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

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

  1047 			}

  1048 		else

  1049 			TEST2(error, KErrNoMemory);

  1050 		}

  1052 #ifdef _DEBUG

  1053 	failCount = 0;

  1054 #endif

  1055 	finished = EFalse;

  1057 	while(!finished)

  1058 		{

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

  1060 		active->StartL();

  1061 		CActiveScheduler::Start();

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

  1064 		count = view->CountL();

  1065 		TEST(count > 1);

  1067 		__UHEAP_FAILNEXT(failCount++);

  1069 		TBool ret = EFalse;

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

  1072 		__UHEAP_RESET;

  1074 		if (!error)

  1075 			{

  1076 			TEST(ret);

  1078 			active->StartL();

  1079 			CActiveScheduler::Start();

  1081 			if (active->iStatus == KErrNone)

  1082 				{

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

  1084 				finished = ETrue;

  1085 				}

  1086 			else

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

  1088 			}

  1089 		else

  1090 			TEST2(error, KErrNoMemory);

  1091 		}

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

  1094 	}

  1096 /**

  1097 @SYMTestCaseID          SYSLIB-LOGENG-CT-0970

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

  1099 @SYMTestPriority 	    High

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

  1101 @SYMTestExpectedResults Test must not fail

  1102 @SYMREQ                 REQ0000

  1103 */

  1104 LOCAL_C void TestDuplicateViewRemoveWithHeapFailL(CLogClient& aClient)

  1105 	{

  1106 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0970 "));

  1107 	CTestActive* active = new(ELeave)CTestActive;

  1108 	CleanupStack::PushL(active);

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

  1111 	CleanupStack::PushL(event);

  1113 	// Incoming

  1114 	TLogString buf;

  1115 	aClient.GetString(buf, R_LOG_DIR_IN);

  1117 	event->SetEventType(KLogCallEventTypeUid);

  1118 	event->SetDirection(buf);

  1119 	event->SetContact(KTestContact);

  1121 	// Add events

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

  1123 	active->StartL();

  1124 	CActiveScheduler::Start();

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

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

  1128 	active->StartL();

  1129 	CActiveScheduler::Start();

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

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

  1133 	active->StartL();

  1134 	CActiveScheduler::Start();

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

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

  1138 	active->StartL();

  1139 	CActiveScheduler::Start();

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

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

  1143 	CleanupStack::PushL(view);

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

  1146 	active->StartL();

  1147 	CActiveScheduler::Start();

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

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

  1151 	CleanupStack::PushL(duplicate);

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

  1154 	active->StartL();

  1155 	CActiveScheduler::Start();

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

  1158 	TInt count = duplicate->CountL();

  1159 	TEST(count > 0);

  1161 #ifdef _DEBUG

  1162 	TInt failCount = 0;

  1163 #endif

  1165 	TBool finished = EFalse;

  1166 	TInt error;

  1168 	while(!finished)

  1169 		{

  1170 		__UHEAP_FAILNEXT(failCount++);

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

  1174 		__UHEAP_RESET;

  1176 		if (!error)

  1177 			{

  1178 			finished = ETrue;

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

  1181 			active->StartL();

  1182 			CActiveScheduler::Start();

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

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

  1186 			}

  1187 		else

  1188 			TEST2(error, KErrNoMemory);

  1189 		}

  1191 #ifdef _DEBUG

  1192 	failCount = 0;

  1193 #endif

  1194 	finished = EFalse;

  1196 	while(!finished)

  1197 		{

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

  1199 		active->StartL();

  1200 		CActiveScheduler::Start();

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

  1203 		count = duplicate->CountL();

  1204 		TEST(count > 1);

  1206 		__UHEAP_FAILNEXT(failCount++);

  1208 		TBool ret = EFalse;

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

  1211 		__UHEAP_RESET;

  1213 		if (!error)

  1214 			{

  1215 			TEST(ret);

  1217 			active->StartL();

  1218 			CActiveScheduler::Start();

  1220 			if (active->iStatus == KErrNone)

  1221 				{

  1222 				finished = ETrue;

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

  1224 				}

  1225 			else

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

  1227 			}

  1228 		else

  1229 			TEST2(error, KErrNoMemory);

  1230 		}

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

  1233 	}

  1235 void doTestsL()

  1236 	{

  1237 	TestUtils::Initialize(_L("t_logviewfail"));

  1238 	TestUtils::DeleteDatabaseL();

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

  1241 	CleanupStack::PushL(client);

  1243 	TheTest.Start(_L("Heap Failure in Client"));

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

  1246 	TestEventViewConstructWithHeapFailL(*client);

  1247 	TestRecentViewConstructWithHeapFailL(*client);

  1248 	TestDuplicateViewConstructWithHeapFailL(*client);

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

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

  1252 	TestEventViewSetupWithHeapFailL(*client);

  1253 	TestRecentViewSetupWithHeapFailL(*client);

  1254 	TestDuplicateViewSetupWithHeapFailL(*client);

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

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

  1258 	TestNavigationWithHeapFailL(*client);

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

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

  1262 	TestViewCountWithHeapFailL(*client);

  1263 	TestRecentViewRemoveWithHeapFailL(*client);

  1264 	TestDuplicateViewRemoveWithHeapFailL(*client);

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

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

  1268 	}

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