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

     2 // All rights reserved.

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

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include <s32file.h>

    17 #include "TEST.H"

    18 #include <logview.h>

    19 

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

    21 

    22 RTest test(_L("File Failure Test Harness"));

    23 

    24 const TLogContactItemId KTestContact = 0x123;

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

    26 

    27 /**

    28 @SYMTestCaseID          SYSLIB-LOGENG-CT-0971

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

    30 @SYMTestPriority 	    High

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

    32 						added.Check for file failure error

    33 @SYMTestExpectedResults Test must not fail

    34 @SYMREQ                 REQ0000

    35 */

    36 LOCAL_C void TestEventViewSetupWithFileFailL(CLogClient& aClient)

    37 	{

    38 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0971 "));

    39 	CTestActive* active = new(ELeave)CTestActive;

    40 	CleanupStack::PushL(active);

    41 

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

    43 	CleanupStack::PushL(event);

    44 	event->SetEventType(KLogCallEventTypeUid);

    45 	event->SetStatus(KTestStatus);

    46 

    47 	// Add an event

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

    49 	active->StartL();

    50 	CActiveScheduler::Start();

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

    52 

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

    54 	CleanupStack::PushL(view);

    55 

    56 	CLogFilterList* list = new(ELeave)CLogFilterList;

    57 	CleanupStack::PushL(list);

    58 

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

    60 	CleanupStack::PushL(filter);

    61 	filter->SetStatus(KTestStatus);

    62 

    63 	TInt failCount = 0;

    64 

    65 	TBool finished = EFalse;

    66 	TInt error;

    67 

    68 	while(!finished)

    69 		{

    70 		__FILE_FAILNEXT(++failCount);

    71 

    72 		TBool result = EFalse;

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

    74 		

    75 		if (error == KErrNone)

    76 			{

    77 			TEST(result);

    78 

    79 			active->StartL();

    80 			CActiveScheduler::Start();

    81 

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

    83 				{

    84 				finished = ETrue;		

    85 				

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

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

    88 				}

    89 			else

    90 				{

    91 				if(active->iStatus.Int() != KErrGeneral)

    92 					{

    93 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());

    94 					}

    95 				TEST2(active->iStatus.Int(), KErrGeneral);

    96 				}

    97 			}

    98 		else

    99 			{

   100 			if(error != KErrGeneral)

   101 				{

   102 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);

   103 				}

   104 			TEST2(error, KErrGeneral);

   105 			}

   106 

   107 		__FILE_RESET;

   108 		}

   109     RDebug::Print(_L("Test-1 has succeeded at iteration %d\n"), failCount);

   110 

   111 	list->AppendL(filter);

   112 	CleanupStack::Pop(); // filter

   113 	

   114 	filter = CLogFilter::NewL();

   115 	CleanupStack::PushL(filter);

   116 	filter->SetEventType(KLogCallEventTypeUid);

   117 	list->AppendL(filter);

   118 	CleanupStack::Pop(); // filter

   119 

   120 	failCount = 0;

   121 	finished = EFalse;

   122 

   123 	while(!finished)

   124 		{

   125 		__FILE_FAILNEXT(++failCount);

   126 

   127 		TBool result = EFalse;

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

   129 		

   130 		if (error == KErrNone)

   131 			{

   132 			TEST(result);

   133 

   134 			active->StartL();

   135 			CActiveScheduler::Start();

   136 

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

   138 				{

   139 				finished = ETrue;		

   140 				

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

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

   143 				}

   144 			else

   145 				{

   146 				if(active->iStatus.Int() != KErrGeneral)

   147 					{

   148 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());

   149 					}

   150 				TEST2(active->iStatus.Int(), KErrGeneral);

   151 				}

   152 			}

   153 		else

   154 			{

   155 			if(error != KErrGeneral)

   156 				{

   157 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);

   158 				}

   159 			TEST2(error, KErrGeneral);

   160 			}

   161 

   162 		__FILE_RESET;

   163 		}

   164 

   165 	list->ResetAndDestroy();

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

   167 

   168     RDebug::Print(_L("Test-2 has succeeded at iteration %d\n"), failCount);

   169 	}

   170 

   171 /**

   172 @SYMTestCaseID          SYSLIB-LOGENG-CT-0972

   173 @SYMTestCaseDesc	    Tests CLogViewRecent::SetRecentListL() function

   174 @SYMTestPriority 	    High

   175 @SYMTestActions  	    Set recent view list first without a filter and later with log filter,check for file failure error

   176 @SYMTestExpectedResults Test must not fail

   177 @SYMREQ                 REQ0000

   178 */

   179 LOCAL_C void TestRecentViewSetupWithFileFailL(CLogClient& aClient)

   180 	{

   181 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0972 "));

   182 	CTestActive* active = new(ELeave)CTestActive;

   183 	CleanupStack::PushL(active);

   184 

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

   186 	CleanupStack::PushL(event);

   187 

   188 	// Incoming

   189 	TLogString buf;

   190 	aClient.GetString(buf, R_LOG_DIR_IN);

   191 

   192 	event->SetEventType(KLogCallEventTypeUid);

   193 	event->SetDirection(buf);

   194 	event->SetStatus(KTestStatus);

   195 

   196 	// Add an event

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

   198 	active->StartL();

   199 	CActiveScheduler::Start();

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

   201 

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

   203 	CleanupStack::PushL(view);

   204 

   205 	TInt failCount = 0;

   206 	TBool finished = EFalse;

   207 	TInt error;

   208 

   209 	while(!finished)

   210 		{

   211 		__FILE_FAILNEXT(++failCount);

   212 

   213 		TBool result = EFalse;

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

   215 		

   216 		if (error == KErrNone)

   217 			{

   218 			TEST(result);

   219 

   220 			active->StartL();

   221 			CActiveScheduler::Start();

   222 

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

   224 				{

   225 				finished = ETrue;		

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

   227 				}

   228 			else

   229 				{

   230 				if(active->iStatus.Int() != KErrGeneral)

   231 					{

   232 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());

   233 					}

   234 				TEST2(active->iStatus.Int(), KErrGeneral);

   235 				}

   236 			}

   237 		else

   238 			{

   239 			if(error != KErrGeneral)

   240 				{

   241 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);

   242 				}

   243 			TEST2(error, KErrGeneral);

   244 			}

   245 

   246 		__FILE_RESET;

   247 		}

   248     RDebug::Print(_L("Test-1 has succeeded at iteration %d\n"), failCount);

   249 

   250 	CLogFilterList* list = new(ELeave)CLogFilterList;

   251 	CleanupStack::PushL(list);

   252 

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

   254 	CleanupStack::PushL(filter);

   255 	filter->SetStatus(KTestStatus);

   256 

   257 	failCount = 0;

   258 	finished = EFalse;

   259 

   260 	while(!finished)

   261 		{

   262 		__FILE_FAILNEXT(++failCount);

   263 

   264 		TBool result = EFalse;

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

   266 		

   267 		if (error == KErrNone)

   268 			{

   269 			TEST(result);

   270 

   271 			active->StartL();

   272 			CActiveScheduler::Start();

   273 

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

   275 				{

   276 				finished = ETrue;		

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

   278 				}

   279 			else

   280 				{

   281 				if(active->iStatus.Int() != KErrGeneral)

   282 					{

   283 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());

   284 					}

   285 				TEST2(active->iStatus.Int(), KErrGeneral);

   286 				}

   287 			}

   288 		else

   289 			{

   290 			if(error != KErrGeneral)

   291 				{

   292 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);

   293 				}

   294 			TEST2(error, KErrGeneral);

   295 			}

   296 

   297 		__FILE_RESET;

   298 		}

   299     RDebug::Print(_L("Test-2 has succeeded at iteration %d\n"), failCount);

   300 

   301 	list->AppendL(filter);

   302 	CleanupStack::Pop(); // filter

   303 

   304 	filter = CLogFilter::NewL();

   305 	CleanupStack::PushL(filter);

   306 	filter->SetEventType(KLogCallEventTypeUid);

   307 	list->AppendL(filter);

   308 	CleanupStack::Pop(); // filter

   309 

   310 	failCount = 0;

   311 	finished = EFalse;

   312 

   313 	while(!finished)

   314 		{

   315 		__FILE_FAILNEXT(++failCount);

   316 

   317 		TBool result = EFalse;

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

   319 		

   320 		if (error == KErrNone)

   321 			{

   322 			TEST(result);

   323 

   324 			active->StartL();

   325 			CActiveScheduler::Start();

   326 

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

   328 				{

   329 				finished = ETrue;		

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

   331 				}

   332 			else

   333 				{

   334 				if(active->iStatus.Int() != KErrGeneral)

   335 					{

   336 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());

   337 					}

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

   339 				}

   340 			}

   341 		else

   342 			{

   343 			if(error != KErrGeneral)

   344 				{

   345 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);

   346 				}

   347 			TEST2(error, KErrGeneral);

   348 			}

   349 

   350 		__FILE_RESET;

   351 		}

   352 

   353 	list->ResetAndDestroy();

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

   355 

   356     RDebug::Print(_L("Test-3 has succeeded at iteration %d\n"), failCount);

   357 	}

   358 

   359 /**

   360 @SYMTestCaseID          SYSLIB-LOGENG-CT-0973

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

   362 @SYMTestPriority 	    High

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

   364                         Check for file failure errors 

   365 @SYMTestExpectedResults Test must not fail

   366 @SYMREQ                 REQ0000

   367 */

   368 LOCAL_C void TestDuplicateViewSetupWithFileFailL(CLogClient& aClient)

   369 	{

   370 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0973 "));

   371 	CTestActive* active = new(ELeave)CTestActive;

   372 	CleanupStack::PushL(active);

   373 

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

   375 	CleanupStack::PushL(event);

   376 

   377 	// Incoming

   378 	TLogString buf;

   379 	aClient.GetString(buf, R_LOG_DIR_IN);

   380 

   381 	event->SetEventType(KLogCallEventTypeUid);

   382 	event->SetDirection(buf);

   383 	event->SetContact(KTestContact);

   384 	event->SetStatus(KTestStatus);

   385 

   386 	// Add events

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

   388 	active->StartL();

   389 	CActiveScheduler::Start();

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

   391 

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

   393 	active->StartL();

   394 	CActiveScheduler::Start();

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

   396 

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

   398 	CleanupStack::PushL(view);

   399 

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

   401 	active->StartL();

   402 	CActiveScheduler::Start();

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

   404 	

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

   406 	CleanupStack::PushL(duplicate);

   407 

   408 	TInt failCount = 0;

   409 	TBool finished = EFalse;

   410 	TInt error;

   411 

   412 	while(!finished)

   413 		{

   414 		__FILE_FAILNEXT(++failCount);

   415 

   416 		TBool result = EFalse;

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

   418 		

   419 		if (error == KErrNone)

   420 			{

   421 			TEST(result);

   422 

   423 			active->StartL();

   424 			CActiveScheduler::Start();

   425 

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

   427 				{

   428 				finished = ETrue;		

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

   430 				}

   431 			else

   432 				{

   433 				if(active->iStatus.Int() != KErrGeneral)

   434 					{

   435 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());

   436 					}

   437 				TEST2(active->iStatus.Int(), KErrGeneral);

   438 				}

   439 			}

   440 		else

   441 			{

   442 			if(error != KErrGeneral)

   443 				{

   444 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);

   445 				}

   446 			TEST2(error, KErrGeneral);

   447 			}

   448 

   449 		__FILE_RESET;

   450 		}

   451     RDebug::Print(_L("Test-1 has succeeded at iteration %d\n"), failCount);

   452 

   453 	CLogFilterList* list = new(ELeave)CLogFilterList;

   454 	CleanupStack::PushL(list);

   455 

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

   457 	CleanupStack::PushL(filter);

   458 	filter->SetStatus(KTestStatus);

   459 

   460 	failCount = 0;

   461 	finished = EFalse;

   462 

   463 	while(!finished)

   464 		{

   465 		__FILE_FAILNEXT(++failCount);

   466 

   467 		TBool result = EFalse;

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

   469 		

   470 		if (error == KErrNone)

   471 			{

   472 			TEST(result);

   473 

   474 			active->StartL();

   475 			CActiveScheduler::Start();

   476 

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

   478 				{

   479 				finished = ETrue;		

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

   481 				}

   482 			else

   483 				{

   484 				if(active->iStatus.Int() != KErrGeneral)

   485 					{

   486 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());

   487 					}

   488 				TEST2(active->iStatus.Int(), KErrGeneral);

   489 				}

   490 			}

   491 		else

   492 			{

   493 			if(error != KErrGeneral)

   494 				{

   495 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);

   496 				}

   497 			TEST2(error, KErrGeneral);

   498 			}

   499 

   500 		__FILE_RESET;

   501 		}

   502     RDebug::Print(_L("Test-2 has succeeded at iteration %d\n"), failCount);

   503 

   504 	list->AppendL(filter);

   505 	CleanupStack::Pop(); // filter

   506 

   507 	filter = CLogFilter::NewL();

   508 	CleanupStack::PushL(filter);

   509 	filter->SetEventType(KLogCallEventTypeUid);

   510 	list->AppendL(filter);

   511 	CleanupStack::Pop(); // filter

   512 

   513 	failCount = 0;

   514 	finished = EFalse;

   515 

   516 	while(!finished)

   517 		{

   518 		__FILE_FAILNEXT(++failCount);

   519 

   520 		TBool result = EFalse;

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

   522 		

   523 		if (error == KErrNone)

   524 			{

   525 			TEST(result);

   526 

   527 			active->StartL();

   528 			CActiveScheduler::Start();

   529 

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

   531 				{

   532 				finished = ETrue;		

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

   534 				}

   535 			else

   536 				{

   537 				if(active->iStatus.Int() != KErrGeneral)

   538 					{

   539 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());

   540 					}

   541 				TEST2(active->iStatus.Int(), KErrGeneral);

   542 				}

   543 			}

   544 		else

   545 			{

   546 			if(error != KErrGeneral)

   547 				{

   548 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);

   549 				}

   550 			TEST2(error, KErrGeneral);

   551 			}

   552 

   553 		__FILE_RESET;

   554 		}

   555 

   556 	list->ResetAndDestroy();

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

   558 

   559     RDebug::Print(_L("Test-3 has succeeded at iteration %d\n"), failCount);

   560 	}

   561 

   562 /**

   563 @SYMTestCaseID          SYSLIB-LOGENG-CT-0974

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

   565                         CLogViewEvent::FirstL() functions

   566 @SYMTestPriority 	    High

   567 @SYMTestActions  	    Tests for all the navigation functions in the view.Check for file failure error 

   568 @SYMTestExpectedResults Test must not fail

   569 @SYMREQ                 REQ0000

   570 */

   571 LOCAL_C void TestNavigationWithFileFailL(CLogClient& aClient)

   572 	{

   573 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0974 "));

   574 	CTestActive* active = new(ELeave)CTestActive;

   575 	CleanupStack::PushL(active);

   576 

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

   578 	CleanupStack::PushL(event);

   579 	event->SetEventType(KLogCallEventTypeUid);

   580 

   581 	// Add an event

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

   583 	active->StartL();

   584 	CActiveScheduler::Start();

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

   586 

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

   588 	CleanupStack::PushL(view);

   589 

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

   591 	CleanupStack::PushL(filter);

   592 

   593 	TInt failCount = 0;

   594 	TBool finished = EFalse;

   595 	TInt error;

   596 

   597 	while(!finished)

   598 		{

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

   600 		active->StartL();

   601 		CActiveScheduler::Start();

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

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

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

   605 

   606 		__FILE_FAILNEXT(++failCount);

   607 

   608 		TBool result = EFalse;

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

   610 		

   611 		if (error == KErrNone)

   612 			{

   613 			TEST(result);

   614 

   615 			active->StartL();

   616 			CActiveScheduler::Start();

   617 

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

   619 				{

   620 				finished = ETrue;

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

   622 				}

   623 			else

   624 				{

   625 				if(active->iStatus.Int() != KErrGeneral)

   626 					{

   627 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());

   628 					}

   629 				TEST2(active->iStatus.Int(), KErrGeneral);

   630 				}

   631 			}

   632 		else

   633 			{

   634 			if(error != KErrGeneral)

   635 				{

   636 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);

   637 				}

   638 			TEST2(error, KErrGeneral);

   639 			}

   640 

   641 		__FILE_RESET;

   642 		}

   643     RDebug::Print(_L("Test-1 (\"View Next\") has succeeded at iteration %d\n"), failCount);

   644 

   645 	failCount = 0;

   646 	finished = EFalse;

   647 

   648 	while(!finished)

   649 		{

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

   651 		active->StartL();

   652 		CActiveScheduler::Start();

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

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

   655 

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

   657 		active->StartL();

   658 		CActiveScheduler::Start();

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

   660 

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

   662 

   663 		__FILE_FAILNEXT(++failCount);

   664 

   665 		TBool result = EFalse;

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

   667 		

   668 		if (error == KErrNone)

   669 			{

   670 			TEST(result);

   671 

   672 			active->StartL();

   673 			CActiveScheduler::Start();

   674 

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

   676 				{

   677 				finished = ETrue;

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

   679 				}

   680 			else

   681 				{

   682 				if(active->iStatus.Int() != KErrGeneral)

   683 					{

   684 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());

   685 					}

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

   687 				}

   688 			}

   689 		else

   690 			{

   691 			if(error != KErrGeneral)

   692 				{

   693 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);

   694 				}

   695 			TEST2(error, KErrGeneral);

   696 			}

   697 

   698 		__FILE_RESET;

   699 		}

   700     RDebug::Print(_L("Test-2 (\"View Previous\") has succeeded at iteration %d\n"), failCount);

   701 

   702 	failCount = 0;

   703 	finished = EFalse;

   704 

   705 	while(!finished)

   706 		{

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

   708 		active->StartL();

   709 		CActiveScheduler::Start();

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

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

   712 

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

   714 		active->StartL();

   715 		CActiveScheduler::Start();

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

   717 

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

   719 

   720 		__FILE_FAILNEXT(++failCount);

   721 

   722 		TBool result = EFalse;

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

   724 		

   725 		if (error == KErrNone)

   726 			{

   727 			TEST(result);

   728 

   729 			active->StartL();

   730 			CActiveScheduler::Start();

   731 

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

   733 				{

   734 				finished = ETrue;

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

   736 				}

   737 			else

   738 				{

   739 				if(active->iStatus.Int() != KErrGeneral)

   740 					{

   741 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());

   742 					}

   743 				TEST2(active->iStatus.Int(), KErrGeneral);

   744 				}

   745 			}

   746 		else

   747 			{

   748 			if(error != KErrGeneral)

   749 				{

   750 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);

   751 				}

   752 			TEST2(error, KErrGeneral);

   753 			}

   754 

   755 		__FILE_RESET;

   756 		}

   757     RDebug::Print(_L("Test-3 (\"View First\") has succeeded at iteration %d\n"), failCount);

   758 

   759 	failCount = 0;

   760 	finished = EFalse;

   761 

   762 	while(!finished)

   763 		{

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

   765 		active->StartL();

   766 		CActiveScheduler::Start();

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

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

   769 

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

   771 		active->StartL();

   772 		CActiveScheduler::Start();

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

   774 

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

   776 

   777 		__FILE_FAILNEXT(++failCount);

   778 

   779 		TBool result = EFalse;

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

   781 		

   782 		if (error == KErrNone)

   783 			{

   784 			TEST(result);

   785 

   786 			active->StartL();

   787 			CActiveScheduler::Start();

   788 

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

   790 				{

   791 				finished = ETrue;

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

   793 				}

   794 			else

   795 				{

   796 				if(active->iStatus.Int() != KErrGeneral)

   797 					{

   798 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());

   799 					}

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

   801 				}

   802 			}

   803 		else

   804 			{

   805 			if(error != KErrGeneral)

   806 				{

   807 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);

   808 				}

   809 			TEST2(error, KErrGeneral);

   810 			}

   811 

   812 		__FILE_RESET;

   813 		}

   814 

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

   816 

   817     RDebug::Print(_L("Test-4 (\"View Last\") has succeeded at iteration %d\n"), failCount);

   818 	}

   819 

   820 /**

   821 @SYMTestCaseID          SYSLIB-LOGENG-CT-0975

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

   823 @SYMTestPriority 	    High

   824 @SYMTestActions  	    Test for getting the number of events in the view.Check for file failure error

   825 @SYMTestExpectedResults Test must not fail

   826 @SYMREQ                 REQ0000

   827 */

   828 LOCAL_C void TestViewCountWithFileFailL(CLogClient& aClient)

   829 	{

   830 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0975 "));

   831 	CTestActive* active = new(ELeave)CTestActive;

   832 	CleanupStack::PushL(active);

   833 

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

   835 	CleanupStack::PushL(event);

   836 	event->SetEventType(KLogCallEventTypeUid);

   837 

   838 	// Add an event

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

   840 	active->StartL();

   841 	CActiveScheduler::Start();

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

   843 

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

   845 	CleanupStack::PushL(view);

   846 

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

   848 	CleanupStack::PushL(filter);

   849 

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

   851 	active->StartL();

   852 	CActiveScheduler::Start();

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

   854 

   855 	TInt failCount = 0;

   856 	TBool finished = EFalse;

   857 	TInt error;

   858 

   859 	while(!finished)

   860 		{

   861 		__FILE_FAILNEXT(++failCount);

   862 

   863 		TInt result = 0;

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

   865 		

   866 		if (error == KErrNone)

   867 			{

   868 			finished = ETrue;

   869 			TEST(result > 0);

   870 			}

   871 		else

   872 			{

   873 			if(error != KErrGeneral)

   874 				{

   875 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);

   876 				}

   877 			TEST2(error, KErrGeneral);

   878 			}

   879 

   880 		__FILE_RESET;

   881 		}

   882 

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

   884 

   885     RDebug::Print(_L("The test (\"View Count\") has succeeded at iteration %d\n"), failCount);

   886 	}

   887 

   888 /**

   889 @SYMTestCaseID          SYSLIB-LOGENG-CT-0976

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

   891 @SYMTestPriority 	    High

   892 @SYMTestActions  	    Test for removing the event with the specified unique event ID from the view.Check for file failure error

   893 @SYMTestExpectedResults Test must not fail

   894 @SYMREQ                 REQ0000

   895 */

   896 LOCAL_C void TestRecentViewRemoveWithFileFailL(CLogClient& aClient)

   897 	{

   898 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0976 "));

   899 	CTestActive* active = new(ELeave)CTestActive;

   900 	CleanupStack::PushL(active);

   901 

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

   903 	CleanupStack::PushL(event);

   904 

   905 	// Incoming

   906 	TLogString buf;

   907 	aClient.GetString(buf, R_LOG_DIR_IN);

   908 

   909 	event->SetEventType(KLogCallEventTypeUid);

   910 	event->SetDirection(buf);

   911 

   912 	// Add events

   913 	event->SetContact(1);

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

   915 	active->StartL();

   916 	CActiveScheduler::Start();

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

   918 

   919 	event->SetContact(2);

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

   921 	active->StartL();

   922 	CActiveScheduler::Start();

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

   924 

   925 	event->SetContact(3);

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

   927 	active->StartL();

   928 	CActiveScheduler::Start();

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

   930 

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

   932 	CleanupStack::PushL(view);

   933 

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

   935 	active->StartL();

   936 	CActiveScheduler::Start();

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

   938 

   939 	TInt count = view->CountL();

   940 	TEST(count > 1);

   941 

   942 	TInt failCount = 0;

   943 	TBool finished = EFalse;

   944 	TInt error;

   945 

   946 	while(!finished)

   947 		{

   948 		// This failCount value causes DBMS to return KErrCorrupt. Apparently this

   949 		// can't actually occur in real life, so we skip this value.

   950 		if (failCount == 9)

   951 		    {

   952 		    failCount++;

   953 		    }

   954 		__FILE_FAILNEXT(++failCount);

   955 

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

   957 

   958 		__FILE_RESET;

   959 

   960 		if (error == KErrNone)

   961 			{

   962 			finished = ETrue;

   963 

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

   965 			active->StartL();

   966 			CActiveScheduler::Start();

   967 			if(active->iStatus.Int() != KErrNone)

   968 				{

   969 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());

   970 				}

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

   972 

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

   974 			}

   975 		else

   976 			{

   977 			if(error != KErrGeneral)

   978 				{

   979 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);

   980 				}

   981 			TEST2(error, KErrGeneral);

   982 			}

   983 		}

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

   985 	

   986     RDebug::Print(_L("The test (\"View Remove\") has succeeded at iteration %d\n"), failCount);

   987 	}

   988 

   989 /**

   990 @SYMTestCaseID          SYSLIB-LOGENG-CT-0977

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

   992 @SYMTestPriority 	    High

   993 @SYMTestActions  	    Test for removing the event with the specified unique event ID from the view.Check for file failure error

   994 @SYMTestExpectedResults Test must not fail

   995 @SYMREQ                 REQ0000

   996 */

   997 LOCAL_C void TestDuplicateViewRemoveWithFileFailL(CLogClient& aClient)

   998 	{

   999 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0977 "));

  1000 	CTestActive* active = new(ELeave)CTestActive;

  1001 	CleanupStack::PushL(active);

  1002 

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

  1004 	CleanupStack::PushL(event);

  1005 

  1006 	// Incoming

  1007 	TLogString buf;

  1008 	aClient.GetString(buf, R_LOG_DIR_IN);

  1009 

  1010 	event->SetEventType(KLogCallEventTypeUid);

  1011 	event->SetDirection(buf);

  1012 	event->SetContact(KTestContact);

  1013 

  1014 	// Add events

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

  1016 	active->StartL();

  1017 	CActiveScheduler::Start();

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

  1019 

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

  1021 	active->StartL();

  1022 	CActiveScheduler::Start();

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

  1024 

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

  1026 	active->StartL();

  1027 	CActiveScheduler::Start();

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

  1029 

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

  1031 	active->StartL();

  1032 	CActiveScheduler::Start();

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

  1034 

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

  1036 	CleanupStack::PushL(view);

  1037 

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

  1039 	active->StartL();

  1040 	CActiveScheduler::Start();

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

  1042 

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

  1044 	CleanupStack::PushL(duplicate);

  1045 

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

  1047 	active->StartL();

  1048 	CActiveScheduler::Start();

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

  1050 	

  1051 	TInt count = duplicate->CountL();

  1052 	TEST(count > 0);

  1053 

  1054 	TInt failCount = 0;

  1055 	TBool finished = EFalse;

  1056 	TInt error;

  1057 

  1058 	while(!finished)

  1059 		{

  1060 		__FILE_FAILNEXT(++failCount);

  1061 		

  1062 		if(failCount == 7)

  1063 			{

  1064 			__FILE_RESET;

  1065 			break;

  1066 			}

  1067 

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

  1069 

  1070 		__FILE_RESET;

  1071 

  1072 		if (error == KErrNone)

  1073 			{

  1074 			finished = ETrue;

  1075 

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

  1077 			active->StartL();

  1078 			CActiveScheduler::Start();

  1079 			if(active->iStatus.Int() != KErrNone)

  1080 				{

  1081 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());

  1082 				}

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

  1084 

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

  1086 			}

  1087 		else

  1088 			{

  1089 			if(error != KErrGeneral)

  1090 				{

  1091 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);

  1092 				}

  1093 			TEST2(error, KErrGeneral);

  1094 			}

  1095 		}

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

  1097     

  1098     RDebug::Print(_L("The test (\"View Remove Duplicates\") has succeeded at iteration %d\n"), failCount);

  1099 	}

  1100 

  1101 void doTestsL()

  1102 	{

  1103 	TestUtils::Initialize(_L("T_LOGVIEWFAIL2"));

  1104 	TestUtils::DeleteDatabaseL();

  1105 

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

  1107 	CleanupStack::PushL(client);

  1108 

  1109 	test.Start(_L("Event View Setup"));

  1110 	TestEventViewSetupWithFileFailL(*client);

  1111     test.Next(_L("Recent View Setup"));

  1112 	TestRecentViewSetupWithFileFailL(*client);

  1113     test.Next(_L("Duplicated View Setup"));

  1114 	TestDuplicateViewSetupWithFileFailL(*client);

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

  1116 

  1117 	test.Next(_L("View Navigation"));

  1118 	TestNavigationWithFileFailL(*client);

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

  1120 

  1121 	test.Next(_L("View Count"));

  1122 	TestViewCountWithFileFailL(*client);

  1123     test.Next(_L("View Remove"));

  1124 	TestRecentViewRemoveWithFileFailL(*client);

  1125     test.Next(_L("View Remove Duplicates"));

  1126 	TestDuplicateViewRemoveWithFileFailL(*client);

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

  1128 

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

  1130 	}