Mercurial Mercurial > oss > MCL > sf > os > persistentdata / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
loggingservices/eventlogger/test/src/t_logviewfail2.cpp
branchRCL_3
changeset 9 667e88a979d7
parent 0 08ec8eefde2f
child 23 26645d81f48d
equal deleted inserted replaced
8:fa9941cf3867 9:667e88a979d7 
     1 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
 
     1 // Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).
 
     2 // All rights reserved.
 
     2 // All rights reserved.
 
     3 // This component and the accompanying materials are made available
 
     3 // This component and the accompanying materials are made available
 
     4 // under the terms of "Eclipse Public License v1.0"
 
     4 // under the terms of "Eclipse Public License v1.0"
 
     5 // which accompanies this distribution, and is available
 
     5 // which accompanies this distribution, and is available
 
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
    12 //
 
    12 //
 
    13 // Description:
 
    13 // Description:
 
    14 //
 
    14 //
 
    15 
    15 
    16 #include <s32file.h>
 
    16 #include <s32file.h>
 
    17 #include "TEST.H"
 
    17 #include "t_logutil2.h"
 
    18 #include <logview.h>
 
    18 #include <logview.h>
 
    19 
    19 
    20 #undef test  //there is a "test" macro which hides "RTest test" declaration.
 
    20 RTest TheTest(_L("t_logviewfail2"));
 
    21 
       
    22 RTest test(_L("File Failure Test Harness"));
 
       
    23 
    21 
    24 const TLogContactItemId KTestContact = 0x123;
 
    22 const TLogContactItemId KTestContact = 0x123;
 
    25 _LIT(KTestStatus, "Test Status Text");
 
    23 _LIT(KTestStatus, "Test Status Text");
 
    26 
    24 
    27 /**
 
    25 /**
 
    33 @SYMTestExpectedResults Test must not fail
 
    31 @SYMTestExpectedResults Test must not fail
 
    34 @SYMREQ                 REQ0000
 
    32 @SYMREQ                 REQ0000
 
    35 */
 
    33 */
 
    36 LOCAL_C void TestEventViewSetupWithFileFailL(CLogClient& aClient)
 
    34 LOCAL_C void TestEventViewSetupWithFileFailL(CLogClient& aClient)
 
    37 	{
 
    35 	{
 
    38 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0971 "));
 
    36 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0971 "));
 
    39 	CTestActive* active = new(ELeave)CTestActive;
 
    37 	CTestActive* active = new(ELeave)CTestActive;
 
    40 	CleanupStack::PushL(active);
 
    38 	CleanupStack::PushL(active);
 
    41 
    39 
    42 	CLogEvent* event = CLogEvent::NewL();
 
    40 	CLogEvent* event = CLogEvent::NewL();
 
    43 	CleanupStack::PushL(event);
 
    41 	CleanupStack::PushL(event);
 
    88 				}
 
    86 				}
 
    89 			else
 
    87 			else
 
    90 				{
 
    88 				{
 
    91 				if(active->iStatus.Int() != KErrGeneral)
 
    89 				if(active->iStatus.Int() != KErrGeneral)
 
    92 					{
 
    90 					{
 
    93 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
    91 					TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
    94 					}
 
    92 					}
 
    95 				TEST2(active->iStatus.Int(), KErrGeneral);
 
    93 				TEST2(active->iStatus.Int(), KErrGeneral);
 
    96 				}
 
    94 				}
 
    97 			}
 
    95 			}
 
    98 		else
 
    96 		else
 
    99 			{
 
    97 			{
 
   100 			if(error != KErrGeneral)
 
    98 			if(error != KErrGeneral)
 
   101 				{
 
    99 				{
 
   102 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   100 				TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   103 				}
 
   101 				}
 
   104 			TEST2(error, KErrGeneral);
 
   102 			TEST2(error, KErrGeneral);
 
   105 			}
 
   103 			}
 
   106 
   104 
   107 		__FILE_RESET;
 
   105 		__FILE_RESET;
 
   108 		}
 
   106 		}
 
   109     RDebug::Print(_L("Test-1 has succeeded at iteration %d\n"), failCount);
 
   107     TheTest.Printf(_L("Test-1 has succeeded at iteration %d\n"), failCount);
 
   110 
   108 
   111 	list->AppendL(filter);
 
   109 	list->AppendL(filter);
 
   112 	CleanupStack::Pop(); // filter
 
   110 	CleanupStack::Pop(); // filter
 
   113 	
   111 	
   114 	filter = CLogFilter::NewL();
 
   112 	filter = CLogFilter::NewL();
 
   143 				}
 
   141 				}
 
   144 			else
 
   142 			else
 
   145 				{
 
   143 				{
 
   146 				if(active->iStatus.Int() != KErrGeneral)
 
   144 				if(active->iStatus.Int() != KErrGeneral)
 
   147 					{
 
   145 					{
 
   148 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   146 					TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   149 					}
 
   147 					}
 
   150 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   148 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   151 				}
 
   149 				}
 
   152 			}
 
   150 			}
 
   153 		else
 
   151 		else
 
   154 			{
 
   152 			{
 
   155 			if(error != KErrGeneral)
 
   153 			if(error != KErrGeneral)
 
   156 				{
 
   154 				{
 
   157 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   155 				TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   158 				}
 
   156 				}
 
   159 			TEST2(error, KErrGeneral);
 
   157 			TEST2(error, KErrGeneral);
 
   160 			}
 
   158 			}
 
   161 
   159 
   162 		__FILE_RESET;
 
   160 		__FILE_RESET;
 
   163 		}
 
   161 		}
 
   164 
   162 
   165 	list->ResetAndDestroy();
 
   163 	list->ResetAndDestroy();
 
   166 	CleanupStack::PopAndDestroy(4); // list, view, event, active
 
   164 	CleanupStack::PopAndDestroy(4); // list, view, event, active
 
   167 
   165 
   168     RDebug::Print(_L("Test-2 has succeeded at iteration %d\n"), failCount);
 
   166     TheTest.Printf(_L("Test-2 has succeeded at iteration %d\n"), failCount);
 
   169 	}
 
   167 	}
 
   170 
   168 
   171 /**
 
   169 /**
 
   172 @SYMTestCaseID          SYSLIB-LOGENG-CT-0972
 
   170 @SYMTestCaseID          SYSLIB-LOGENG-CT-0972
 
   173 @SYMTestCaseDesc	    Tests CLogViewRecent::SetRecentListL() function
 
   171 @SYMTestCaseDesc	    Tests CLogViewRecent::SetRecentListL() function
 
   176 @SYMTestExpectedResults Test must not fail
 
   174 @SYMTestExpectedResults Test must not fail
 
   177 @SYMREQ                 REQ0000
 
   175 @SYMREQ                 REQ0000
 
   178 */
 
   176 */
 
   179 LOCAL_C void TestRecentViewSetupWithFileFailL(CLogClient& aClient)
 
   177 LOCAL_C void TestRecentViewSetupWithFileFailL(CLogClient& aClient)
 
   180 	{
 
   178 	{
 
   181 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0972 "));
 
   179 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0972 "));
 
   182 	CTestActive* active = new(ELeave)CTestActive;
 
   180 	CTestActive* active = new(ELeave)CTestActive;
 
   183 	CleanupStack::PushL(active);
 
   181 	CleanupStack::PushL(active);
 
   184 
   182 
   185 	CLogEvent* event = CLogEvent::NewL();
 
   183 	CLogEvent* event = CLogEvent::NewL();
 
   186 	CleanupStack::PushL(event);
 
   184 	CleanupStack::PushL(event);
 
   227 				}
 
   225 				}
 
   228 			else
 
   226 			else
 
   229 				{
 
   227 				{
 
   230 				if(active->iStatus.Int() != KErrGeneral)
 
   228 				if(active->iStatus.Int() != KErrGeneral)
 
   231 					{
 
   229 					{
 
   232 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   230 					TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   233 					}
 
   231 					}
 
   234 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   232 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   235 				}
 
   233 				}
 
   236 			}
 
   234 			}
 
   237 		else
 
   235 		else
 
   238 			{
 
   236 			{
 
   239 			if(error != KErrGeneral)
 
   237 			if(error != KErrGeneral)
 
   240 				{
 
   238 				{
 
   241 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   239 				TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   242 				}
 
   240 				}
 
   243 			TEST2(error, KErrGeneral);
 
   241 			TEST2(error, KErrGeneral);
 
   244 			}
 
   242 			}
 
   245 
   243 
   246 		__FILE_RESET;
 
   244 		__FILE_RESET;
 
   247 		}
 
   245 		}
 
   248     RDebug::Print(_L("Test-1 has succeeded at iteration %d\n"), failCount);
 
   246     TheTest.Printf(_L("Test-1 has succeeded at iteration %d\n"), failCount);
 
   249 
   247 
   250 	CLogFilterList* list = new(ELeave)CLogFilterList;
 
   248 	CLogFilterList* list = new(ELeave)CLogFilterList;
 
   251 	CleanupStack::PushL(list);
 
   249 	CleanupStack::PushL(list);
 
   252 
   250 
   253 	CLogFilter* filter = CLogFilter::NewL();
 
   251 	CLogFilter* filter = CLogFilter::NewL();
 
   278 				}
 
   276 				}
 
   279 			else
 
   277 			else
 
   280 				{
 
   278 				{
 
   281 				if(active->iStatus.Int() != KErrGeneral)
 
   279 				if(active->iStatus.Int() != KErrGeneral)
 
   282 					{
 
   280 					{
 
   283 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   281 					TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   284 					}
 
   282 					}
 
   285 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   283 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   286 				}
 
   284 				}
 
   287 			}
 
   285 			}
 
   288 		else
 
   286 		else
 
   289 			{
 
   287 			{
 
   290 			if(error != KErrGeneral)
 
   288 			if(error != KErrGeneral)
 
   291 				{
 
   289 				{
 
   292 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   290 				TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   293 				}
 
   291 				}
 
   294 			TEST2(error, KErrGeneral);
 
   292 			TEST2(error, KErrGeneral);
 
   295 			}
 
   293 			}
 
   296 
   294 
   297 		__FILE_RESET;
 
   295 		__FILE_RESET;
 
   298 		}
 
   296 		}
 
   299     RDebug::Print(_L("Test-2 has succeeded at iteration %d\n"), failCount);
 
   297     TheTest.Printf(_L("Test-2 has succeeded at iteration %d\n"), failCount);
 
   300 
   298 
   301 	list->AppendL(filter);
 
   299 	list->AppendL(filter);
 
   302 	CleanupStack::Pop(); // filter
 
   300 	CleanupStack::Pop(); // filter
 
   303 
   301 
   304 	filter = CLogFilter::NewL();
 
   302 	filter = CLogFilter::NewL();
 
   331 				}
 
   329 				}
 
   332 			else
 
   330 			else
 
   333 				{
 
   331 				{
 
   334 				if(active->iStatus.Int() != KErrGeneral)
 
   332 				if(active->iStatus.Int() != KErrGeneral)
 
   335 					{
 
   333 					{
 
   336 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   334 					TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   337 					}
 
   335 					}
 
   338 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   336 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   339 				}
 
   337 				}
 
   340 			}
 
   338 			}
 
   341 		else
 
   339 		else
 
   342 			{
 
   340 			{
 
   343 			if(error != KErrGeneral)
 
   341 			if(error != KErrGeneral)
 
   344 				{
 
   342 				{
 
   345 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   343 				TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   346 				}
 
   344 				}
 
   347 			TEST2(error, KErrGeneral);
 
   345 			TEST2(error, KErrGeneral);
 
   348 			}
 
   346 			}
 
   349 
   347 
   350 		__FILE_RESET;
 
   348 		__FILE_RESET;
 
   351 		}
 
   349 		}
 
   352 
   350 
   353 	list->ResetAndDestroy();
 
   351 	list->ResetAndDestroy();
 
   354 	CleanupStack::PopAndDestroy(4); // list, view, event, active
 
   352 	CleanupStack::PopAndDestroy(4); // list, view, event, active
 
   355 
   353 
   356     RDebug::Print(_L("Test-3 has succeeded at iteration %d\n"), failCount);
 
   354     TheTest.Printf(_L("Test-3 has succeeded at iteration %d\n"), failCount);
 
   357 	}
 
   355 	}
 
   358 
   356 
   359 /**
 
   357 /**
 
   360 @SYMTestCaseID          SYSLIB-LOGENG-CT-0973
 
   358 @SYMTestCaseID          SYSLIB-LOGENG-CT-0973
 
   361 @SYMTestCaseDesc	    Tests for CLogViewRecent::DuplicatesL() function
 
   359 @SYMTestCaseDesc	    Tests for CLogViewRecent::DuplicatesL() function
 
   365 @SYMTestExpectedResults Test must not fail
 
   363 @SYMTestExpectedResults Test must not fail
 
   366 @SYMREQ                 REQ0000
 
   364 @SYMREQ                 REQ0000
 
   367 */
 
   365 */
 
   368 LOCAL_C void TestDuplicateViewSetupWithFileFailL(CLogClient& aClient)
 
   366 LOCAL_C void TestDuplicateViewSetupWithFileFailL(CLogClient& aClient)
 
   369 	{
 
   367 	{
 
   370 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0973 "));
 
   368 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0973 "));
 
   371 	CTestActive* active = new(ELeave)CTestActive;
 
   369 	CTestActive* active = new(ELeave)CTestActive;
 
   372 	CleanupStack::PushL(active);
 
   370 	CleanupStack::PushL(active);
 
   373 
   371 
   374 	CLogEvent* event = CLogEvent::NewL();
 
   372 	CLogEvent* event = CLogEvent::NewL();
 
   375 	CleanupStack::PushL(event);
 
   373 	CleanupStack::PushL(event);
 
   430 				}
 
   428 				}
 
   431 			else
 
   429 			else
 
   432 				{
 
   430 				{
 
   433 				if(active->iStatus.Int() != KErrGeneral)
 
   431 				if(active->iStatus.Int() != KErrGeneral)
 
   434 					{
 
   432 					{
 
   435 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   433 					TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   436 					}
 
   434 					}
 
   437 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   435 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   438 				}
 
   436 				}
 
   439 			}
 
   437 			}
 
   440 		else
 
   438 		else
 
   441 			{
 
   439 			{
 
   442 			if(error != KErrGeneral)
 
   440 			if(error != KErrGeneral)
 
   443 				{
 
   441 				{
 
   444 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   442 				TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   445 				}
 
   443 				}
 
   446 			TEST2(error, KErrGeneral);
 
   444 			TEST2(error, KErrGeneral);
 
   447 			}
 
   445 			}
 
   448 
   446 
   449 		__FILE_RESET;
 
   447 		__FILE_RESET;
 
   450 		}
 
   448 		}
 
   451     RDebug::Print(_L("Test-1 has succeeded at iteration %d\n"), failCount);
 
   449     TheTest.Printf(_L("Test-1 has succeeded at iteration %d\n"), failCount);
 
   452 
   450 
   453 	CLogFilterList* list = new(ELeave)CLogFilterList;
 
   451 	CLogFilterList* list = new(ELeave)CLogFilterList;
 
   454 	CleanupStack::PushL(list);
 
   452 	CleanupStack::PushL(list);
 
   455 
   453 
   456 	CLogFilter* filter = CLogFilter::NewL();
 
   454 	CLogFilter* filter = CLogFilter::NewL();
 
   481 				}
 
   479 				}
 
   482 			else
 
   480 			else
 
   483 				{
 
   481 				{
 
   484 				if(active->iStatus.Int() != KErrGeneral)
 
   482 				if(active->iStatus.Int() != KErrGeneral)
 
   485 					{
 
   483 					{
 
   486 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   484 					TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   487 					}
 
   485 					}
 
   488 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   486 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   489 				}
 
   487 				}
 
   490 			}
 
   488 			}
 
   491 		else
 
   489 		else
 
   492 			{
 
   490 			{
 
   493 			if(error != KErrGeneral)
 
   491 			if(error != KErrGeneral)
 
   494 				{
 
   492 				{
 
   495 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   493 				TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   496 				}
 
   494 				}
 
   497 			TEST2(error, KErrGeneral);
 
   495 			TEST2(error, KErrGeneral);
 
   498 			}
 
   496 			}
 
   499 
   497 
   500 		__FILE_RESET;
 
   498 		__FILE_RESET;
 
   501 		}
 
   499 		}
 
   502     RDebug::Print(_L("Test-2 has succeeded at iteration %d\n"), failCount);
 
   500     TheTest.Printf(_L("Test-2 has succeeded at iteration %d\n"), failCount);
 
   503 
   501 
   504 	list->AppendL(filter);
 
   502 	list->AppendL(filter);
 
   505 	CleanupStack::Pop(); // filter
 
   503 	CleanupStack::Pop(); // filter
 
   506 
   504 
   507 	filter = CLogFilter::NewL();
 
   505 	filter = CLogFilter::NewL();
 
   534 				}
 
   532 				}
 
   535 			else
 
   533 			else
 
   536 				{
 
   534 				{
 
   537 				if(active->iStatus.Int() != KErrGeneral)
 
   535 				if(active->iStatus.Int() != KErrGeneral)
 
   538 					{
 
   536 					{
 
   539 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   537 					TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   540 					}
 
   538 					}
 
   541 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   539 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   542 				}
 
   540 				}
 
   543 			}
 
   541 			}
 
   544 		else
 
   542 		else
 
   545 			{
 
   543 			{
 
   546 			if(error != KErrGeneral)
 
   544 			if(error != KErrGeneral)
 
   547 				{
 
   545 				{
 
   548 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   546 				TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   549 				}
 
   547 				}
 
   550 			TEST2(error, KErrGeneral);
 
   548 			TEST2(error, KErrGeneral);
 
   551 			}
 
   549 			}
 
   552 
   550 
   553 		__FILE_RESET;
 
   551 		__FILE_RESET;
 
   554 		}
 
   552 		}
 
   555 
   553 
   556 	list->ResetAndDestroy();
 
   554 	list->ResetAndDestroy();
 
   557 	CleanupStack::PopAndDestroy(5); // list, duplicate, view, event, active
 
   555 	CleanupStack::PopAndDestroy(5); // list, duplicate, view, event, active
 
   558 
   556 
   559     RDebug::Print(_L("Test-3 has succeeded at iteration %d\n"), failCount);
 
   557     TheTest.Printf(_L("Test-3 has succeeded at iteration %d\n"), failCount);
 
   560 	}
 
   558 	}
 
   561 
   559 
   562 /**
 
   560 /**
 
   563 @SYMTestCaseID          SYSLIB-LOGENG-CT-0974
 
   561 @SYMTestCaseID          SYSLIB-LOGENG-CT-0974
 
   564 @SYMTestCaseDesc	    Tests for CLogViewEvent::NextL(),CLogViewEvent::LastL(),CLogViewEvent::PreviousL(),
 
   562 @SYMTestCaseDesc	    Tests for CLogViewEvent::NextL(),CLogViewEvent::LastL(),CLogViewEvent::PreviousL(),
 
   568 @SYMTestExpectedResults Test must not fail
 
   566 @SYMTestExpectedResults Test must not fail
 
   569 @SYMREQ                 REQ0000
 
   567 @SYMREQ                 REQ0000
 
   570 */
 
   568 */
 
   571 LOCAL_C void TestNavigationWithFileFailL(CLogClient& aClient)
 
   569 LOCAL_C void TestNavigationWithFileFailL(CLogClient& aClient)
 
   572 	{
 
   570 	{
 
   573 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0974 "));
 
   571 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0974 "));
 
   574 	CTestActive* active = new(ELeave)CTestActive;
 
   572 	CTestActive* active = new(ELeave)CTestActive;
 
   575 	CleanupStack::PushL(active);
 
   573 	CleanupStack::PushL(active);
 
   576 
   574 
   577 	CLogEvent* event = CLogEvent::NewL();
 
   575 	CLogEvent* event = CLogEvent::NewL();
 
   578 	CleanupStack::PushL(event);
 
   576 	CleanupStack::PushL(event);
 
   622 				}
 
   620 				}
 
   623 			else
 
   621 			else
 
   624 				{
 
   622 				{
 
   625 				if(active->iStatus.Int() != KErrGeneral)
 
   623 				if(active->iStatus.Int() != KErrGeneral)
 
   626 					{
 
   624 					{
 
   627 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   625 					TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   628 					}
 
   626 					}
 
   629 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   627 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   630 				}
 
   628 				}
 
   631 			}
 
   629 			}
 
   632 		else
 
   630 		else
 
   633 			{
 
   631 			{
 
   634 			if(error != KErrGeneral)
 
   632 			if(error != KErrGeneral)
 
   635 				{
 
   633 				{
 
   636 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   634 				TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   637 				}
 
   635 				}
 
   638 			TEST2(error, KErrGeneral);
 
   636 			TEST2(error, KErrGeneral);
 
   639 			}
 
   637 			}
 
   640 
   638 
   641 		__FILE_RESET;
 
   639 		__FILE_RESET;
 
   642 		}
 
   640 		}
 
   643     RDebug::Print(_L("Test-1 (\"View Next\") has succeeded at iteration %d\n"), failCount);
 
   641     TheTest.Printf(_L("Test-1 (\"View Next\") has succeeded at iteration %d\n"), failCount);
 
   644 
   642 
   645 	failCount = 0;
 
   643 	failCount = 0;
 
   646 	finished = EFalse;
 
   644 	finished = EFalse;
 
   647 
   645 
   648 	while(!finished)
 
   646 	while(!finished)
 
   679 				}
 
   677 				}
 
   680 			else
 
   678 			else
 
   681 				{
 
   679 				{
 
   682 				if(active->iStatus.Int() != KErrGeneral)
 
   680 				if(active->iStatus.Int() != KErrGeneral)
 
   683 					{
 
   681 					{
 
   684 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   682 					TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   685 					}
 
   683 					}
 
   686 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   684 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   687 				}
 
   685 				}
 
   688 			}
 
   686 			}
 
   689 		else
 
   687 		else
 
   690 			{
 
   688 			{
 
   691 			if(error != KErrGeneral)
 
   689 			if(error != KErrGeneral)
 
   692 				{
 
   690 				{
 
   693 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   691 				TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   694 				}
 
   692 				}
 
   695 			TEST2(error, KErrGeneral);
 
   693 			TEST2(error, KErrGeneral);
 
   696 			}
 
   694 			}
 
   697 
   695 
   698 		__FILE_RESET;
 
   696 		__FILE_RESET;
 
   699 		}
 
   697 		}
 
   700     RDebug::Print(_L("Test-2 (\"View Previous\") has succeeded at iteration %d\n"), failCount);
 
   698     TheTest.Printf(_L("Test-2 (\"View Previous\") has succeeded at iteration %d\n"), failCount);
 
   701 
   699 
   702 	failCount = 0;
 
   700 	failCount = 0;
 
   703 	finished = EFalse;
 
   701 	finished = EFalse;
 
   704 
   702 
   705 	while(!finished)
 
   703 	while(!finished)
 
   736 				}
 
   734 				}
 
   737 			else
 
   735 			else
 
   738 				{
 
   736 				{
 
   739 				if(active->iStatus.Int() != KErrGeneral)
 
   737 				if(active->iStatus.Int() != KErrGeneral)
 
   740 					{
 
   738 					{
 
   741 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   739 					TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   742 					}
 
   740 					}
 
   743 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   741 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   744 				}
 
   742 				}
 
   745 			}
 
   743 			}
 
   746 		else
 
   744 		else
 
   747 			{
 
   745 			{
 
   748 			if(error != KErrGeneral)
 
   746 			if(error != KErrGeneral)
 
   749 				{
 
   747 				{
 
   750 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   748 				TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   751 				}
 
   749 				}
 
   752 			TEST2(error, KErrGeneral);
 
   750 			TEST2(error, KErrGeneral);
 
   753 			}
 
   751 			}
 
   754 
   752 
   755 		__FILE_RESET;
 
   753 		__FILE_RESET;
 
   756 		}
 
   754 		}
 
   757     RDebug::Print(_L("Test-3 (\"View First\") has succeeded at iteration %d\n"), failCount);
 
   755     TheTest.Printf(_L("Test-3 (\"View First\") has succeeded at iteration %d\n"), failCount);
 
   758 
   756 
   759 	failCount = 0;
 
   757 	failCount = 0;
 
   760 	finished = EFalse;
 
   758 	finished = EFalse;
 
   761 
   759 
   762 	while(!finished)
 
   760 	while(!finished)
 
   793 				}
 
   791 				}
 
   794 			else
 
   792 			else
 
   795 				{
 
   793 				{
 
   796 				if(active->iStatus.Int() != KErrGeneral)
 
   794 				if(active->iStatus.Int() != KErrGeneral)
 
   797 					{
 
   795 					{
 
   798 					RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   796 					TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   799 					}
 
   797 					}
 
   800 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   798 				TEST2(active->iStatus.Int(), KErrGeneral);
 
   801 				}
 
   799 				}
 
   802 			}
 
   800 			}
 
   803 		else
 
   801 		else
 
   804 			{
 
   802 			{
 
   805 			if(error != KErrGeneral)
 
   803 			if(error != KErrGeneral)
 
   806 				{
 
   804 				{
 
   807 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   805 				TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   808 				}
 
   806 				}
 
   809 			TEST2(error, KErrGeneral);
 
   807 			TEST2(error, KErrGeneral);
 
   810 			}
 
   808 			}
 
   811 
   809 
   812 		__FILE_RESET;
 
   810 		__FILE_RESET;
 
   813 		}
 
   811 		}
 
   814 
   812 
   815 	CleanupStack::PopAndDestroy(4); // filter, view, event, active
 
   813 	CleanupStack::PopAndDestroy(4); // filter, view, event, active
 
   816 
   814 
   817     RDebug::Print(_L("Test-4 (\"View Last\") has succeeded at iteration %d\n"), failCount);
 
   815     TheTest.Printf(_L("Test-4 (\"View Last\") has succeeded at iteration %d\n"), failCount);
 
   818 	}
 
   816 	}
 
   819 
   817 
   820 /**
 
   818 /**
 
   821 @SYMTestCaseID          SYSLIB-LOGENG-CT-0975
 
   819 @SYMTestCaseID          SYSLIB-LOGENG-CT-0975
 
   822 @SYMTestCaseDesc	    Tests for CLogViewEvent::CountL() functions
 
   820 @SYMTestCaseDesc	    Tests for CLogViewEvent::CountL() functions
 
   825 @SYMTestExpectedResults Test must not fail
 
   823 @SYMTestExpectedResults Test must not fail
 
   826 @SYMREQ                 REQ0000
 
   824 @SYMREQ                 REQ0000
 
   827 */
 
   825 */
 
   828 LOCAL_C void TestViewCountWithFileFailL(CLogClient& aClient)
 
   826 LOCAL_C void TestViewCountWithFileFailL(CLogClient& aClient)
 
   829 	{
 
   827 	{
 
   830 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0975 "));
 
   828 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0975 "));
 
   831 	CTestActive* active = new(ELeave)CTestActive;
 
   829 	CTestActive* active = new(ELeave)CTestActive;
 
   832 	CleanupStack::PushL(active);
 
   830 	CleanupStack::PushL(active);
 
   833 
   831 
   834 	CLogEvent* event = CLogEvent::NewL();
 
   832 	CLogEvent* event = CLogEvent::NewL();
 
   835 	CleanupStack::PushL(event);
 
   833 	CleanupStack::PushL(event);
 
   870 			}
 
   868 			}
 
   871 		else
 
   869 		else
 
   872 			{
 
   870 			{
 
   873 			if(error != KErrGeneral)
 
   871 			if(error != KErrGeneral)
 
   874 				{
 
   872 				{
 
   875 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   873 				TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   876 				}
 
   874 				}
 
   877 			TEST2(error, KErrGeneral);
 
   875 			TEST2(error, KErrGeneral);
 
   878 			}
 
   876 			}
 
   879 
   877 
   880 		__FILE_RESET;
 
   878 		__FILE_RESET;
 
   881 		}
 
   879 		}
 
   882 
   880 
   883 	CleanupStack::PopAndDestroy(4); // filter, view, event, active
 
   881 	CleanupStack::PopAndDestroy(4); // filter, view, event, active
 
   884 
   882 
   885     RDebug::Print(_L("The test (\"View Count\") has succeeded at iteration %d\n"), failCount);
 
   883     TheTest.Printf(_L("The test (\"View Count\") has succeeded at iteration %d\n"), failCount);
 
   886 	}
 
   884 	}
 
   887 
   885 
   888 /**
 
   886 /**
 
   889 @SYMTestCaseID          SYSLIB-LOGENG-CT-0976
 
   887 @SYMTestCaseID          SYSLIB-LOGENG-CT-0976
 
   890 @SYMTestCaseDesc	    Tests for CLogViewRecent::RemoveL() function
 
   888 @SYMTestCaseDesc	    Tests for CLogViewRecent::RemoveL() function
 
   893 @SYMTestExpectedResults Test must not fail
 
   891 @SYMTestExpectedResults Test must not fail
 
   894 @SYMREQ                 REQ0000
 
   892 @SYMREQ                 REQ0000
 
   895 */
 
   893 */
 
   896 LOCAL_C void TestRecentViewRemoveWithFileFailL(CLogClient& aClient)
 
   894 LOCAL_C void TestRecentViewRemoveWithFileFailL(CLogClient& aClient)
 
   897 	{
 
   895 	{
 
   898 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0976 "));
 
   896 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0976 "));
 
   899 	CTestActive* active = new(ELeave)CTestActive;
 
   897 	CTestActive* active = new(ELeave)CTestActive;
 
   900 	CleanupStack::PushL(active);
 
   898 	CleanupStack::PushL(active);
 
   901 
   899 
   902 	CLogEvent* event = CLogEvent::NewL();
 
   900 	CLogEvent* event = CLogEvent::NewL();
 
   903 	CleanupStack::PushL(event);
 
   901 	CleanupStack::PushL(event);
 
   964 			TEST(view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
 
   962 			TEST(view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
 
   965 			active->StartL();
 
   963 			active->StartL();
 
   966 			CActiveScheduler::Start();
 
   964 			CActiveScheduler::Start();
 
   967 			if(active->iStatus.Int() != KErrNone)
 
   965 			if(active->iStatus.Int() != KErrNone)
 
   968 				{
 
   966 				{
 
   969 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   967 				TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
   970 				}
 
   968 				}
 
   971 			TEST2(active->iStatus.Int(), KErrNone);
 
   969 			TEST2(active->iStatus.Int(), KErrNone);
 
   972 
   970 
   973 			TEST(count == view->CountL() + 1);
 
   971 			TEST(count == view->CountL() + 1);
 
   974 			}
 
   972 			}
 
   975 		else
 
   973 		else
 
   976 			{
 
   974 			{
 
   977 			if(error != KErrGeneral)
 
   975 			if(error != KErrGeneral)
 
   978 				{
 
   976 				{
 
   979 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   977 				TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error);
 
   980 				}
 
   978 				}
 
   981 			TEST2(error, KErrGeneral);
 
   979 			TEST2(error, KErrGeneral);
 
   982 			}
 
   980 			}
 
   983 		}
 
   981 		}
 
   984 	CleanupStack::PopAndDestroy(3); // view, event, active
 
   982 	CleanupStack::PopAndDestroy(3); // view, event, active
 
   985 	
   983 	
   986     RDebug::Print(_L("The test (\"View Remove\") has succeeded at iteration %d\n"), failCount);
 
   984     TheTest.Printf(_L("The test (\"View Remove\") has succeeded at iteration %d\n"), failCount);
 
   987 	}
 
   985 	}
 
   988 
   986 
   989 /**
 
   987 /**
 
   990 @SYMTestCaseID          SYSLIB-LOGENG-CT-0977
 
   988 @SYMTestCaseID          SYSLIB-LOGENG-CT-0977
 
   991 @SYMTestCaseDesc	    Tests for CLogViewDuplicate::RemoveL() function
 
   989 @SYMTestCaseDesc	    Tests for CLogViewDuplicate::RemoveL() function
 
   994 @SYMTestExpectedResults Test must not fail
 
   992 @SYMTestExpectedResults Test must not fail
 
   995 @SYMREQ                 REQ0000
 
   993 @SYMREQ                 REQ0000
 
   996 */
 
   994 */
 
   997 LOCAL_C void TestDuplicateViewRemoveWithFileFailL(CLogClient& aClient)
 
   995 LOCAL_C void TestDuplicateViewRemoveWithFileFailL(CLogClient& aClient)
 
   998 	{
 
   996 	{
 
   999 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0977 "));
 
   997 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0977 "));
 
  1000 	CTestActive* active = new(ELeave)CTestActive;
 
   998 	CTestActive* active = new(ELeave)CTestActive;
 
  1001 	CleanupStack::PushL(active);
 
   999 	CleanupStack::PushL(active);
 
  1002 
  1000 
  1003 	CLogEvent* event = CLogEvent::NewL();
 
  1001 	CLogEvent* event = CLogEvent::NewL();
 
  1004 	CleanupStack::PushL(event);
 
  1002 	CleanupStack::PushL(event);
 
  1076 			TEST(view->DuplicatesL(*duplicate, active->iStatus));
 
  1074 			TEST(view->DuplicatesL(*duplicate, active->iStatus));
 
  1077 			active->StartL();
 
  1075 			active->StartL();
 
  1078 			CActiveScheduler::Start();
 
  1076 			CActiveScheduler::Start();
 
  1079 			if(active->iStatus.Int() != KErrNone)
 
  1077 			if(active->iStatus.Int() != KErrNone)
 
  1080 				{
 
  1078 				{
 
  1081 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
  1079 				TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int());
 
  1082 				}
 
  1080 				}
 
  1083 			TEST2(active->iStatus.Int(), KErrNone);
 
  1081 			TEST2(active->iStatus.Int(), KErrNone);
 
  1084 
  1082 
  1085 			TEST(count == duplicate->CountL() + 1);
 
  1083 			TEST(count == duplicate->CountL() + 1);
 
  1086 			}
 
  1084 			}
 
  1087 		else
 
  1085 		else
 
  1088 			{
 
  1086 			{
 
  1089 			if(error != KErrGeneral)
 
  1087 			if(error != KErrGeneral)
 
  1090 				{
 
  1088 				{
 
  1091 				RDebug::Print(_L("Iter.step: %d, error %d\n"), failCount, error);
 
  1089 				TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error);
 
  1092 				}
 
  1090 				}
 
  1093 			TEST2(error, KErrGeneral);
 
  1091 			TEST2(error, KErrGeneral);
 
  1094 			}
 
  1092 			}
 
  1095 		}
 
  1093 		}
 
  1096 	CleanupStack::PopAndDestroy(4); // duplicate, view, event, active
 
  1094 	CleanupStack::PopAndDestroy(4); // duplicate, view, event, active
 
  1097     
  1095     
  1098     RDebug::Print(_L("The test (\"View Remove Duplicates\") has succeeded at iteration %d\n"), failCount);
 
  1096     TheTest.Printf(_L("The test (\"View Remove Duplicates\") has succeeded at iteration %d\n"), failCount);
 
  1099 	}
 
  1097 	}
 
  1100 
  1098 
  1101 void doTestsL()
 
  1099 void doTestsL()
 
  1102 	{
 
  1100 	{
 
  1103 	TestUtils::Initialize(_L("T_LOGVIEWFAIL2"));
 
  1101 	TestUtils::Initialize(_L("t_logviewfail2"));
 
  1104 	TestUtils::DeleteDatabaseL();
 
  1102 	TestUtils::DeleteDatabaseL();
 
  1105 
  1103 
  1106 	CLogClient* client = CLogClient::NewL(theFs);
 
  1104 	CLogClient* client = CLogClient::NewL(theFs);
 
  1107 	CleanupStack::PushL(client);
 
  1105 	CleanupStack::PushL(client);
 
  1108 
  1106 
  1109 	test.Start(_L("Event View Setup"));
 
  1107 	TheTest.Start(_L("Event View Setup"));
 
  1110 	TestEventViewSetupWithFileFailL(*client);
 
  1108 	TestEventViewSetupWithFileFailL(*client);
 
  1111     test.Next(_L("Recent View Setup"));
 
  1109     TheTest.Next(_L("Recent View Setup"));
 
  1112 	TestRecentViewSetupWithFileFailL(*client);
 
  1110 	TestRecentViewSetupWithFileFailL(*client);
 
  1113     test.Next(_L("Duplicated View Setup"));
 
  1111     TheTest.Next(_L("Duplicated View Setup"));
 
  1114 	TestDuplicateViewSetupWithFileFailL(*client);
 
  1112 	TestDuplicateViewSetupWithFileFailL(*client);
 
  1115 	theLog.Write(_L8("Test 1 OK\n"));
 
  1113 	theLog.Write(_L8("Test 1 OK\n"));
 
  1116 
  1114 
  1117 	test.Next(_L("View Navigation"));
 
  1115 	TheTest.Next(_L("View Navigation"));
 
  1118 	TestNavigationWithFileFailL(*client);
 
  1116 	TestNavigationWithFileFailL(*client);
 
  1119 	theLog.Write(_L8("Test 2 OK\n"));
 
  1117 	theLog.Write(_L8("Test 2 OK\n"));
 
  1120 
  1118 
  1121 	test.Next(_L("View Count"));
 
  1119 	TheTest.Next(_L("View Count"));
 
  1122 	TestViewCountWithFileFailL(*client);
 
  1120 	TestViewCountWithFileFailL(*client);
 
  1123     test.Next(_L("View Remove"));
 
  1121     TheTest.Next(_L("View Remove"));
 
  1124 	TestRecentViewRemoveWithFileFailL(*client);
 
  1122 	TestRecentViewRemoveWithFileFailL(*client);
 
  1125     test.Next(_L("View Remove Duplicates"));
 
  1123     TheTest.Next(_L("View Remove Duplicates"));
 
  1126 	TestDuplicateViewRemoveWithFileFailL(*client);
 
  1124 	TestDuplicateViewRemoveWithFileFailL(*client);
 
  1127 	theLog.Write(_L8("Test 3 OK\n"));
 
  1125 	theLog.Write(_L8("Test 3 OK\n"));
 
  1128 
  1126 
  1129 	CleanupStack::PopAndDestroy(); // client;
 
  1127 	CleanupStack::PopAndDestroy(); // client;
 
  1130 	}
 
  1128 	}
MCL/sf/os/persistentdata