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 <logview.h>

    18 #include "TEST.H"

    19 

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

    21 

    22 RTest test(_L("Log Client API Heap Failure Test Harness"));

    23 

    24 const TUid KTestEventUid = {0x10005393};

    25 _LIT(KTestEventDesc1, "Event Type Description");

    26 _LIT(KTestEventDesc2, "Changed Event Description");

    27 _LIT(KTestRemoteParty1, "Remote Party");

    28 _LIT(KTestRemoteParty2, "Changed Remote Party");

    29 _LIT(KTestDirection1, "Direction");

    30 _LIT(KTestDirection2, "Changed Direction");

    31 const TLogDurationType KTestDurationType1 = 1;

    32 const TLogDurationType KTestDurationType2 = 2;

    33 const TLogDuration KTestDuration1 = 0x1234;

    34 const TLogDuration KTestDuration2 = 0x1234567;

    35 _LIT(KTestStatus1, "Status");

    36 _LIT(KTestStatus2, "Changed Status");

    37 _LIT(KTestSubject1, "Subject");

    38 _LIT(KTestSubject2, "Changed Subject");

    39 _LIT(KTestNumber1, "Number");

    40 _LIT(KTestNumber2, "Changed Number");

    41 const TLogContactItemId KTestContact1 = 0x1234;

    42 const TLogContactItemId KTestContact2 = 0x1234567;

    43 const TLogLink KTestLink1 = 0x1234;

    44 const TLogLink KTestLink2 = 0x1234567;

    45 _LIT8(KTestData1, "ABCDEFGH");

    46 _LIT8(KTestData2, "IJKLMNOPQRSTUVWXYZ");

    47 const TLogSize KTestMaxLogSize = 0xFFF;

    48 const TLogRecentSize KTestMaxRecentLogSize = 0xF;

    49 const TLogAge KTestMaxEventAge = 0xFFFFFFF;

    50 

    51 _LIT(KCreateDb, "Create Db");

    52 _LIT(KOpenDb,   "Open Db");

    53 

    54 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	

    55 _LIT(KServerSide, "server side");

    56 _LIT(KClientSide, "client side");

    57 #endif

    58 

    59 /**

    60 @SYMTestCaseID          SYSLIB-LOGENG-CT-0884

    61 @SYMTestCaseDesc	    Tests for functionality of CLogEvent,CTestActive classes

    62 @SYMTestPriority 	    High

    63 @SYMTestActions  	    Tests for no memory errors.

    64 @SYMTestExpectedResults Test must not fail

    65 @SYMREQ                 REQ0000

    66 */

    67 LOCAL_C void TestStartup1L()

    68 	{

    69 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0884 "));

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

    71 	CleanupStack::PushL(client);

    72 

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

    74 	CleanupStack::PushL(active);

    75 

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

    77 	CleanupStack::PushL(event);

    78 

    79 	TTime now;

    80 	now.UniversalTime();

    81 

    82 	event->SetEventType(KLogCallEventTypeUid);

    83 

    84 	active->StartL();

    85 	client->AddEvent(*event, active->iStatus);

    86 	CActiveScheduler::Start();

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

    88 	

    89 	TBool finished = EFalse;

    90 	TInt failCount = 0;

    91 

    92 	while(!finished)

    93 		{

    94 		__UHEAP_FAILNEXT(++failCount);

    95 		client->ChangeEvent(*event, active->iStatus);

    96 		__UHEAP_RESET;

    97 		active->StartL();

    98 		CActiveScheduler::Start();

    99 

   100 		if (active->iStatus == KErrNone)

   101 			{

   102 			finished = ETrue;

   103 			}

   104 		else

   105 			{

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

   107 			}

   108 		}

   109 

   110 	CleanupStack::PopAndDestroy(3); // client, active, event

   111     test.Printf(_L("===CLogClient::ChangeEvent() client side OOM test succeeded at iteration %d\n"), failCount);

   112 	}

   113 

   114 /**

   115 @SYMTestCaseID          SYSLIB-LOGENG-CT-0885

   116 @SYMTestCaseDesc	    Tests for CLogEvent,CTestActive classes

   117 @SYMTestPriority 	    High

   118 @SYMTestActions  	    Tests for all basic functions of CLogEvent,CTestActive classes.Check for ErrNone flag.

   119 @SYMTestExpectedResults Test must not fail

   120 @SYMREQ                 REQ0000

   121 */

   122 LOCAL_C void TestBasicL(CLogClient& aClient)

   123 	{

   124 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0885 "));

   125 	

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

   127 	CleanupStack::PushL(active);

   128 

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

   130 	CleanupStack::PushL(event);

   131 

   132 	TTime now;

   133 	now.UniversalTime();

   134 

   135 	event->SetEventType(KLogCallEventTypeUid);

   136 

   137 	active->StartL();

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

   139 	CActiveScheduler::Start();

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

   141 

   142 	TEST(event->EventType() == KLogCallEventTypeUid);

   143 	TEST(event->Description().Length() > 0);

   144 	TEST(event->Time() >= now);

   145 	now = event->Time();

   146 

   147 	TLogId id = event->Id();

   148 

   149 	event->SetRemoteParty(KTestRemoteParty1);

   150 	event->SetDirection(KTestDirection1);

   151 	event->SetDurationType(KTestDurationType1);

   152 	event->SetDuration(KTestDuration1);

   153 	event->SetStatus(KTestStatus1);

   154 	event->SetSubject(KTestSubject1);

   155 	event->SetNumber(KTestNumber1);

   156 	event->SetContact(KTestContact1);

   157 	event->SetLink(KTestLink1);

   158 	event->SetDataL(KTestData1);

   159 

   160 	active->StartL();

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

   162 	CActiveScheduler::Start();

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

   164 

   165 	TEST(event->Id() == id);

   166 	TEST(event->EventType() == KLogCallEventTypeUid);

   167 	TEST(event->Description().Length() > 0);

   168 	TEST(event->Time() == now);

   169 	TEST(event->RemoteParty() == KTestRemoteParty1);

   170 	TEST(event->Direction() == KTestDirection1);

   171 	TEST(event->DurationType() == KTestDurationType1);

   172 	TEST(event->Duration() == KTestDuration1);

   173 	TEST(event->Status() == KTestStatus1);

   174 	TEST(event->Subject() == KTestSubject1);

   175 	TEST(event->Number() == KTestNumber1);

   176 	TEST(event->Contact() == KTestContact1);

   177 	TEST(event->Link() == KTestLink1);

   178 	TEST(event->Data() == KTestData1);

   179 

   180 	CleanupStack::PopAndDestroy(); // event;

   181 

   182 	event = CLogEvent::NewL();

   183 	CleanupStack::PushL(event);

   184 

   185 	event->SetId(id);

   186 

   187 	active->StartL();

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

   189 	CActiveScheduler::Start();

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

   191 

   192 	TEST(event->Id() == id);

   193 	TEST(event->EventType() == KLogCallEventTypeUid);

   194 	TEST(event->Description().Length() > 0);

   195 	TEST(event->Time() == now);

   196 	TEST(event->RemoteParty() == KTestRemoteParty1);

   197 	TEST(event->Direction() == KTestDirection1);

   198 	TEST(event->DurationType() == KTestDurationType1);

   199 	TEST(event->Duration() == KTestDuration1);

   200 	TEST(event->Status() == KTestStatus1);

   201 	TEST(event->Subject() == KTestSubject1);

   202 	TEST(event->Number() == KTestNumber1);

   203 	TEST(event->Contact() == KTestContact1);

   204 	TEST(event->Link() == KTestLink1);

   205 	TEST(event->Data() == KTestData1);

   206 

   207 	active->StartL();

   208 	aClient.DeleteEvent(id, active->iStatus);

   209 	CActiveScheduler::Start();

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

   211 

   212 	active->StartL();

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

   214 	CActiveScheduler::Start();

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

   216 

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

   218 	}

   219 

   220 /**

   221 @SYMTestCaseID          SYSLIB-LOGENG-CT-0886

   222 @SYMTestCaseDesc	    Tests for new CLogClient object creation

   223 @SYMTestPriority 	    High

   224 @SYMTestActions  	    Create a CLogClient object on heap.Check for memory errors

   225 @SYMTestExpectedResults Test must not fail

   226 @SYMREQ                 REQ0000

   227 */

   228 LOCAL_C void TestConstruction1L(TBool aCreateDb)

   229 	{

   230 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0886 "));

   231 

   232 	if(aCreateDb)

   233 	    {

   234 	    TestUtils::DeleteDatabaseL();

   235 	    }

   236 		

   237 	CLogClient* client = NULL;

   238 	TInt failCount = 0;

   239 

   240 	TBool finished = EFalse;

   241 	TInt error;

   242 

   243 	while(!finished)

   244 		{

   245 		__UHEAP_FAILNEXT(++failCount);

   246 

   247 		TRAP(error, client = CLogClient::NewL(theFs));

   248 

   249 		__UHEAP_RESET;

   250 

   251 		if (error == KErrNone)

   252 			{

   253 			finished = ETrue;

   254 			TestBasicL(*client);

   255 			}

   256 		else

   257 			TEST2(error, KErrNoMemory);

   258 		}

   259 

   260 	delete client;

   261     test.Printf(_L("==CLogClient::NewL()+\"%S\" client side OOM test succeeded at iteration %d\n"), aCreateDb ? &KCreateDb : &KOpenDb, failCount);

   262 	}

   263 

   264 /**s

   265 @SYMTestCaseID          SYSLIB-LOGENG-CT-0887

   266 @SYMTestCaseDesc	    Tests for creation of new CLogClient object 

   267 @SYMTestPriority 	    High

   268 @SYMTestActions  	    Check for memory errors and error in the environment 

   269 @SYMTestExpectedResults Test must not fail

   270 @SYMREQ                 REQ0000

   271 */

   272 LOCAL_C void TestConstruction3L(TBool aCreateDb)

   273 	{

   274 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0887 "));

   275 

   276     if(aCreateDb)

   277         {

   278         TestUtils::DeleteDatabaseL();

   279         }

   280 

   281 	CLogClient* client = NULL;

   282 

   283 	TInt failCount = 0;

   284 

   285 	TBool finished = EFalse;

   286 	TInt error;

   287 

   288 	while(!finished)

   289 		{

   290 		__LOGSERV_UHEAP_FAILNEXT(++failCount);

   291 

   292 		TRAP(error, client = CLogClient::NewL(theFs));

   293 

   294 		__LOGSERV_UHEAP_RESET;

   295 

   296 		if (error == KErrNone)

   297 			{

   298 			finished = ETrue;

   299 			TestBasicL(*client);

   300 			}

   301 		else

   302 			TEST2(error, KErrNoMemory);

   303 		}

   304 

   305 	delete client;

   306     test.Printf(_L("==CLogClient::NewL()+\"%S\" server side OOM test succeeded at iteration %d\n"), aCreateDb ? &KCreateDb : &KOpenDb, failCount);

   307 	}

   308 

   309 /**

   310 @SYMTestCaseID          SYSLIB-LOGENG-CT-0888

   311 @SYMTestCaseDesc	    Tests for CLogClient::AddEventType() function

   312 @SYMTestPriority 	    High

   313 @SYMTestActions  	    Tests for adding events to the log

   314                         Check for memory errors and error in the environment 

   315 @SYMTestExpectedResults Test must not fail

   316 @SYMREQ                 REQ0000

   317 */

   318 LOCAL_C void TestAddEventType1L()

   319 	{

   320 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0888 "));

   321 	

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

   323 	CleanupStack::PushL(client);

   324 	

   325 	CLogEventType* type = CLogEventType::NewL();

   326 	CleanupStack::PushL(type);

   327 

   328 	type->SetUid(KTestEventUid);

   329 	type->SetDescription(KTestEventDesc1);

   330 	type->SetLoggingEnabled(ETrue);

   331 

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

   333 	CleanupStack::PushL(active);

   334 

   335 	TInt failCount = 0;

   336 	TBool finished = EFalse;

   337 	TInt error;

   338 

   339 	while(!finished)

   340 		{

   341 		error = KErrNone;

   342 

   343 		__UHEAP_FAILNEXT(++failCount);

   344 		client->AddEventType(*type, active->iStatus);

   345 	

   346 		active->StartL();

   347 		CActiveScheduler::Start();

   348 		

   349 		if (active->iStatus == KErrNone)

   350 			finished = ETrue;

   351 		else

   352 			error = active->iStatus.Int();

   353 

   354 		__UHEAP_RESET;

   355 

   356 		if (error == KErrNoMemory)

   357 			{

   358 			active->StartL();

   359 			client->GetEventType(*type, active->iStatus);

   360 			CActiveScheduler::Start();

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

   362 			}

   363 		else

   364 			TEST2(error, KErrNone);

   365 

   366 		}

   367 

   368 	active->StartL();

   369 	client->AddEventType(*type, active->iStatus);

   370 	CActiveScheduler::Start();

   371 	TEST2(active->iStatus.Int(), KErrAlreadyExists);

   372 

   373 	CleanupStack::PopAndDestroy(3, client); // active, type, client

   374    test.Printf(_L("===CLogClient::AddEventType() client side OOM test succeeded at iteration %d\n"), failCount);

   375 	}

   376 

   377 /**

   378 @SYMTestCaseID          SYSLIB-LOGENG-CT-0889

   379 @SYMTestCaseDesc	    Tests for CLogClient::AddEventType() function

   380 @SYMTestPriority 	    High

   381 @SYMTestActions  	    Tests for adding events to the log

   382                         Check for memory errors and error in the environment 

   383 						Test for adding the same event and check for already exits error.

   384 @SYMTestExpectedResults Test must not fail

   385 @SYMREQ                 REQ0000

   386 */

   387 LOCAL_C void TestAddEventType3L()

   388 	{

   389 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0889 "));

   390 	

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

   392 	CleanupStack::PushL(client);

   393 	

   394 	CLogEventType* type = CLogEventType::NewL();

   395 	CleanupStack::PushL(type);

   396 

   397 	type->SetUid(KTestEventUid);

   398 	type->SetDescription(KTestEventDesc1);

   399 	type->SetLoggingEnabled(ETrue);

   400 

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

   402 	CleanupStack::PushL(active);

   403 

   404 	TInt failCount = 0;

   405 

   406 	TBool finished = EFalse;

   407 	TInt error;

   408 

   409 	while(!finished)

   410 		{

   411 		error = KErrNone;

   412 

   413 		__LOGSERV_UHEAP_FAILNEXT(++failCount);

   414 		client->AddEventType(*type, active->iStatus);

   415 	

   416 		active->StartL();

   417 		CActiveScheduler::Start();

   418 		

   419 		if (active->iStatus == KErrNone)

   420 			finished = ETrue;

   421 		else

   422 			error = active->iStatus.Int();

   423 

   424 		__LOGSERV_UHEAP_RESET;

   425 

   426 		if (error == KErrNoMemory)

   427 			{

   428 			active->StartL();

   429 			client->GetEventType(*type, active->iStatus);

   430 			CActiveScheduler::Start();

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

   432 			}

   433 		else

   434 			TEST2(error, KErrNone);

   435 

   436 		}

   437 

   438 	active->StartL();

   439 	client->AddEventType(*type, active->iStatus);

   440 	CActiveScheduler::Start();

   441 	TEST2(active->iStatus.Int(), KErrAlreadyExists);

   442 

   443 	CleanupStack::PopAndDestroy(3, client); // active, type, client

   444 	test.Printf(_L("===CLogClient::AddEventType() server side OOM test succeeded at iteration %d\n"), failCount);

   445 	}

   446 

   447 /**

   448 @SYMTestCaseID          SYSLIB-LOGENG-CT-0890

   449 @SYMTestCaseDesc	    Tests for CLogClient::GetEventType() function 

   450 @SYMTestPriority 	    High

   451 @SYMTestActions  	    Tests for getting event type for the specific UID  from the log

   452                         Check for memory errors and error in the environment

   453 @SYMTestExpectedResults Test must not fail

   454 @SYMREQ                 REQ0000

   455 */

   456 LOCAL_C void TestGetEventType1L()

   457 	{

   458 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0890 "));

   459 	

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

   461 	CleanupStack::PushL(client);

   462 	

   463 	CLogEventType* type = CLogEventType::NewL();

   464 	CleanupStack::PushL(type);

   465 

   466 	type->SetUid(KTestEventUid);

   467 

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

   469 	CleanupStack::PushL(active);

   470 

   471 	TInt failCount = 0;

   472 	TBool finished = EFalse;

   473 

   474 	while(!finished)

   475 		{

   476 		__UHEAP_FAILNEXT(++failCount);

   477 

   478 		client->GetEventType(*type, active->iStatus);

   479 

   480 		active->StartL();

   481 		CActiveScheduler::Start();

   482 		

   483 		if (active->iStatus == KErrNone)

   484 			finished = ETrue;

   485 		else

   486 			{

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

   488 			TEST(type->Description() == KNullDesC);

   489 			}

   490 

   491 		__UHEAP_RESET;

   492 		}

   493 

   494 	TEST(type->Uid() == KTestEventUid);

   495 	TEST(type->Description() == KTestEventDesc1);

   496 	TEST(type->LoggingEnabled());

   497 

   498 	CleanupStack::PopAndDestroy(3, client); // active, type, client

   499     test.Printf(_L("===CLogClient::GetEventType() client side OOM test succeeded at iteration %d\n"), failCount);

   500 	}

   501 

   502 /**

   503 @SYMTestCaseID          SYSLIB-LOGENG-CT-0891

   504 @SYMTestCaseDesc	    Tests for CLogClient::GetEventType() function 

   505 @SYMTestPriority 	    High

   506 @SYMTestActions  	    Tests for getting event type for the specific UID  from the log

   507                         Check for memory errors and error in the environment

   508 @SYMTestExpectedResults Test must not fail

   509 @SYMREQ                 REQ0000

   510 */

   511 LOCAL_C void TestGetEventType3L()

   512 	{

   513 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0891 "));

   514 	

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

   516 	CleanupStack::PushL(client);

   517 	

   518 	CLogEventType* type = CLogEventType::NewL();

   519 	CleanupStack::PushL(type);

   520 

   521 	type->SetUid(KTestEventUid);

   522 

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

   524 	CleanupStack::PushL(active);

   525 

   526 	TInt failCount = 0;

   527 	TBool finished = EFalse;

   528 

   529 	while(!finished)

   530 		{

   531 		__LOGSERV_UHEAP_FAILNEXT(++failCount);

   532 

   533 		client->GetEventType(*type, active->iStatus);

   534 

   535 		active->StartL();

   536 		CActiveScheduler::Start();

   537 		

   538 		if (active->iStatus == KErrNone)

   539 			finished = ETrue;

   540 		else

   541 			{

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

   543 			TEST(type->Description() == KNullDesC);

   544 			}

   545 

   546 		__LOGSERV_UHEAP_RESET;

   547 		}

   548 

   549 	TEST(type->Uid() == KTestEventUid);

   550 	TEST(type->Description() == KTestEventDesc1);

   551 	TEST(type->LoggingEnabled());

   552 

   553 	CleanupStack::PopAndDestroy(3, client); // active, type, client

   554     test.Printf(_L("===CLogClient::GetEventType() server side OOM test succeeded at iteration %d\n"), failCount);

   555 	}

   556 

   557 /**

   558 @SYMTestCaseID          SYSLIB-LOGENG-CT-0892

   559 @SYMTestCaseDesc	    Tests for CLogClient::ChangeEventType() function 

   560 @SYMTestPriority 	    High

   561 @SYMTestActions  	    Tests for changing the event type 

   562                         Check for memory errors and error in the environment 

   563 @SYMTestExpectedResults Test must not fail

   564 @SYMREQ                 REQ0000

   565 */

   566 LOCAL_C void TestChangeEventType1L()

   567 	{

   568 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0892 "));

   569 	

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

   571 	CleanupStack::PushL(client);

   572 	

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

   574 	CleanupStack::PushL(active);

   575 

   576 	CLogEventType* type = CLogEventType::NewL();

   577 	CleanupStack::PushL(type);

   578 

   579 	type->SetUid(KTestEventUid);

   580 

   581 	type->SetDescription(KTestEventDesc1);

   582 	type->SetDescription(KTestEventDesc2);

   583 

   584 	TInt failCount = 0;

   585 	TBool finished = EFalse;

   586 	TInt error;

   587 

   588 	while(!finished)

   589 		{

   590 		error = KErrNone;

   591 

   592 		type->SetDescription(KTestEventDesc2);

   593 		type->SetLoggingEnabled(EFalse);

   594 

   595 		__UHEAP_FAILNEXT(++failCount);

   596 		

   597 		client->ChangeEventType(*type, active->iStatus);

   598 

   599 		active->StartL();

   600 		CActiveScheduler::Start();

   601 

   602 		if (active->iStatus == KErrNone)

   603 			finished = ETrue;

   604 		else

   605 			error = active->iStatus.Int();

   606 

   607 		__UHEAP_RESET;

   608 

   609 		if (error == KErrNoMemory)

   610 			{

   611 			active->StartL();

   612 			client->GetEventType(*type, active->iStatus);

   613 			CActiveScheduler::Start();

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

   615 

   616 			TEST(type->Description() == KTestEventDesc1);

   617 			TEST(type->LoggingEnabled());

   618 			}

   619 		else

   620 			TEST2(error, KErrNone);

   621 		}

   622 

   623 	type->SetUid(KTestEventUid);

   624 

   625 	active->StartL();

   626 	client->GetEventType(*type, active->iStatus);

   627 	CActiveScheduler::Start();

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

   629 

   630 	TEST(type->Uid() == KTestEventUid);

   631 	TEST(type->Description() == KTestEventDesc2);

   632 	TEST(type->LoggingEnabled() == EFalse);

   633 

   634 	CleanupStack::PopAndDestroy(3, client); // type, active, client

   635     test.Printf(_L("===CLogClient::ChangeEventType() client side OOM test succeeded at iteration %d\n"), failCount);

   636 	}

   637 

   638 /**

   639 @SYMTestCaseID          SYSLIB-LOGENG-CT-0893

   640 @SYMTestCaseDesc	    Tests for CLogClient::ChangeEventType() function 

   641 @SYMTestPriority 	    High

   642 @SYMTestActions  	    Tests for changing the event type. 

   643                         Check for memory errors and error in the environment 

   644 @SYMTestExpectedResults Test must not fail

   645 @SYMREQ                 REQ0000

   646 */

   647 LOCAL_C void TestChangeEventType3L()

   648 	{

   649 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0893 "));

   650 	

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

   652 	CleanupStack::PushL(client);

   653 	

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

   655 	CleanupStack::PushL(active);

   656 

   657 	CLogEventType* type = CLogEventType::NewL();

   658 	CleanupStack::PushL(type);

   659 

   660 	type->SetUid(KTestEventUid);

   661 

   662 	type->SetDescription(KTestEventDesc1);

   663 	type->SetDescription(KTestEventDesc2);

   664 

   665 	TInt failCount = 0;

   666 	TBool finished = EFalse;

   667 	TInt error;

   668 

   669 	while(!finished)

   670 		{

   671 		error = KErrNone;

   672 

   673 		type->SetDescription(KTestEventDesc2);

   674 		type->SetLoggingEnabled(EFalse);

   675 

   676 		__LOGSERV_UHEAP_FAILNEXT(++failCount);

   677 		

   678 		client->ChangeEventType(*type, active->iStatus);

   679 

   680 		active->StartL();

   681 		CActiveScheduler::Start();

   682 

   683 		if (active->iStatus == KErrNone)

   684 			finished = ETrue;

   685 		else

   686 			error = active->iStatus.Int();

   687 

   688 		__LOGSERV_UHEAP_RESET;

   689 

   690 		if (error == KErrNoMemory)

   691 			{

   692 			active->StartL();

   693 			client->GetEventType(*type, active->iStatus);

   694 			CActiveScheduler::Start();

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

   696 

   697 			TEST(type->Description() == KTestEventDesc1);

   698 			TEST(type->LoggingEnabled());

   699 			}

   700 		else

   701 			TEST2(error, KErrNone);

   702 		}

   703 

   704 	type->SetUid(KTestEventUid);

   705 

   706 	active->StartL();

   707 	client->GetEventType(*type, active->iStatus);

   708 	CActiveScheduler::Start();

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

   710 

   711 	TEST(type->Uid() == KTestEventUid);

   712 	TEST(type->Description() == KTestEventDesc2);

   713 	TEST(type->LoggingEnabled() == EFalse);

   714 

   715 	CleanupStack::PopAndDestroy(3, client); // type, active, client

   716     test.Printf(_L("===CLogClient::ChangeEventType() server side OOM test succeeded at iteration %d\n"), failCount);

   717 	}

   718 

   719 /**

   720 @SYMTestCaseID          SYSLIB-LOGENG-CT-0894

   721 @SYMTestCaseDesc	    Tests for CLogClient::DeleteEventType() function 

   722 @SYMTestPriority 	    High

   723 @SYMTestActions  	    Tests for deleting of event type.

   724                         After deletion check by trying to retrieve the event.

   725 						Check for ErrNotFound,error flag

   726 @SYMTestExpectedResults Test must not fail

   727 @SYMREQ                 REQ0000

   728 */

   729 LOCAL_C void TestDeleteEventType1L()

   730 	{

   731 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0894 "));

   732 

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

   734 	CleanupStack::PushL(client);

   735 	

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

   737 	CleanupStack::PushL(active);

   738 

   739 	CLogEventType* type = CLogEventType::NewL();

   740 	CleanupStack::PushL(type);

   741 

   742 	type->SetUid(KTestEventUid);

   743 

   744 	TInt failCount = 0;

   745 	TBool finished = EFalse;

   746 	TInt error;

   747 

   748 	while(!finished)

   749 		{

   750 		error = KErrNone;

   751 

   752 		__UHEAP_FAILNEXT(++failCount);

   753 		client->DeleteEventType(KTestEventUid, active->iStatus);

   754 

   755 		active->StartL();

   756 		CActiveScheduler::Start();

   757 

   758 		if (active->iStatus == KErrNone)

   759 			finished = ETrue;

   760 		else

   761 			error = active->iStatus.Int();

   762 

   763 		__UHEAP_RESET;

   764 

   765 		if (error == KErrNoMemory)

   766 			{

   767 			active->StartL();

   768 			client->GetEventType(*type, active->iStatus);

   769 			CActiveScheduler::Start();

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

   771 			}

   772 		else

   773 			TEST2(error, KErrNone);

   774 		}

   775 

   776 	active->StartL();

   777 	client->GetEventType(*type, active->iStatus);

   778 	CActiveScheduler::Start();

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

   780 

   781 	CleanupStack::PopAndDestroy(3, client); // type, active, client

   782     test.Printf(_L("===CLogClient::DeleteEventType() client side OOM test succeeded at iteration %d\n"), failCount);

   783 	}

   784 

   785 /**

   786 @SYMTestCaseID          SYSLIB-LOGENG-CT-0895

   787 @SYMTestCaseDesc	    Tests for CLogClient::DeleteEventType() function 

   788 @SYMTestPriority 	    High

   789 @SYMTestActions  	    Tests for deleting of event type.

   790                         After deletion check by trying to retrieve the event.

   791 						Check for ErrNotFound,error flag.

   792 @SYMTestExpectedResults Test must not fail

   793 @SYMREQ                 REQ0000

   794 */

   795 LOCAL_C void TestDeleteEventType3L()

   796 	{

   797 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0895 "));

   798 	

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

   800 	CleanupStack::PushL(client);

   801 	

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

   803 	CleanupStack::PushL(active);

   804 

   805 	CLogEventType* type = CLogEventType::NewL();

   806 	CleanupStack::PushL(type);

   807 

   808 	type->SetUid(KTestEventUid);

   809 

   810 	TInt failCount = 0;

   811 

   812 	TBool finished = EFalse;

   813 	TInt error;

   814 

   815 	while(!finished)

   816 		{

   817 		error = KErrNone;

   818 

   819 		__LOGSERV_UHEAP_FAILNEXT(++failCount);

   820 		client->DeleteEventType(KTestEventUid, active->iStatus);

   821 

   822 		active->StartL();

   823 		CActiveScheduler::Start();

   824 

   825 		if (active->iStatus == KErrNone)

   826 			finished = ETrue;

   827 		else

   828 			error = active->iStatus.Int();

   829 

   830 		__LOGSERV_UHEAP_RESET;

   831 

   832 		if (error == KErrNoMemory)

   833 			{

   834 			active->StartL();

   835 			client->GetEventType(*type, active->iStatus);

   836 			CActiveScheduler::Start();

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

   838 			}

   839 		else

   840 			TEST2(error, KErrNone);

   841 		}

   842 

   843 	active->StartL();

   844 	client->GetEventType(*type, active->iStatus);

   845 	CActiveScheduler::Start();

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

   847 

   848 	CleanupStack::PopAndDestroy(3, client); // type, active, client

   849     test.Printf(_L("===CLogClient::DeleteEventType() server side OOM test succeeded at iteration %d\n"), failCount);

   850 	}

   851 

   852 /**

   853 @SYMTestCaseID          SYSLIB-LOGENG-CT-0896

   854 @SYMTestCaseDesc	    Tests for adding event CLogClient::AddEvent() function  

   855 @SYMTestPriority 	    High

   856 @SYMTestActions  	    Add logeventtype and logevent to the log

   857                         Tests for memory errors and environment errors.

   858 @SYMTestExpectedResults Test must not fail 

   859 @SYMREQ                 REQ0000

   860 */

   861 LOCAL_C void TestAddEvent1L()

   862 	{

   863 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0896 "));

   864 

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

   866 	CleanupStack::PushL(client);

   867 	

   868 	CLogEventType* type = CLogEventType::NewL();

   869 	CleanupStack::PushL(type);

   870 

   871 	type->SetUid(KTestEventUid);

   872 	type->SetDescription(KTestEventDesc1);

   873 	type->SetLoggingEnabled(ETrue);

   874 

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

   876 	CleanupStack::PushL(active);

   877 

   878 	active->StartL();

   879 	client->AddEventType(*type, active->iStatus);

   880 	CActiveScheduler::Start();

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

   882 

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

   884 	CleanupStack::PushL(event);

   885 

   886 	TTime now;

   887 	now.UniversalTime();

   888 

   889 	event->SetEventType(KTestEventUid);

   890 	event->SetRemoteParty(KTestRemoteParty1);

   891 	event->SetDirection(KTestDirection1);

   892 	event->SetDurationType(KTestDurationType1);

   893 	event->SetDuration(KTestDuration1);

   894 	event->SetStatus(KTestStatus1);

   895 	event->SetSubject(KTestSubject1);

   896 	event->SetNumber(KTestNumber1);

   897 	event->SetContact(KTestContact1);

   898 	event->SetLink(KTestLink1);

   899 	event->SetDataL(KTestData1);

   900 

   901 	TInt failCount = 0;

   902 	TBool finished = EFalse;

   903 	TInt error;

   904 

   905 	while(!finished)

   906 		{

   907 		error = KErrNone;

   908 

   909 		__UHEAP_FAILNEXT(++failCount);

   910 		client->AddEvent(*event, active->iStatus);

   911 		active->StartL();

   912 		CActiveScheduler::Start();

   913 

   914 		if (active->iStatus == KErrNone)

   915 			finished = ETrue;

   916 		else

   917 			error = active->iStatus.Int();

   918 

   919 		__UHEAP_RESET;

   920 

   921 		if(error != KErrNoMemory)

   922 			{

   923 			TEST2(error, KErrNone);

   924 			}

   925 		}

   926 

   927 	TEST(event->Time() >= now);

   928 	TEST(event->Description() == KTestEventDesc1);

   929 

   930 	active->StartL();

   931 	client->GetEvent(*event, active->iStatus);

   932 	CActiveScheduler::Start();

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

   934 

   935 	CleanupStack::PopAndDestroy(4, client); // event, active, type, client

   936     test.Printf(_L("===CLogClient::AddEvent() client side OOM test succeeded at iteration %d\n"), failCount);

   937 	}

   938 

   939 /**

   940 @SYMTestCaseID          SYSLIB-LOGENG-CT-0897

   941 @SYMTestCaseDesc	    Tests for adding event CLogClient::AddEvent() function 

   942 @SYMTestPriority 	    High

   943 @SYMTestActions  	    Add logeventtype and logevent to the log

   944                         Tests for memory errors and environment errors.

   945 @SYMTestExpectedResults Test must not fail 

   946 @SYMREQ                 REQ0000

   947 */

   948 LOCAL_C void TestAddEvent3L()

   949 	{

   950 	

   951 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0897 "));

   952 	

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

   954 	CleanupStack::PushL(client);

   955 

   956 	CLogEventType* type = CLogEventType::NewL();

   957 	CleanupStack::PushL(type);

   958 

   959 	type->SetUid(KTestEventUid);

   960 	type->SetDescription(KTestEventDesc1);

   961 	type->SetLoggingEnabled(ETrue);

   962 

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

   964 	CleanupStack::PushL(active);

   965 

   966 	active->StartL();

   967 	client->AddEventType(*type, active->iStatus);

   968 	CActiveScheduler::Start();

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

   970 

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

   972 	CleanupStack::PushL(event);

   973 

   974 	TTime now;

   975 	now.UniversalTime();

   976 

   977 	event->SetEventType(KTestEventUid);

   978 	event->SetRemoteParty(KTestRemoteParty1);

   979 	event->SetDirection(KTestDirection1);

   980 	event->SetDurationType(KTestDurationType1);

   981 	event->SetDuration(KTestDuration1);

   982 	event->SetStatus(KTestStatus1);

   983 	event->SetSubject(KTestSubject1);

   984 	event->SetNumber(KTestNumber1);

   985 	event->SetContact(KTestContact1);

   986 	event->SetLink(KTestLink1);

   987 	event->SetDataL(KTestData1);

   988 

   989 	TInt failCount = 0;

   990 	TBool finished = EFalse;

   991 	TInt error;

   992 

   993 	while(!finished)

   994 		{

   995 		error = KErrNone;

   996 

   997 		__LOGSERV_UHEAP_FAILNEXT(++failCount);

   998 		client->AddEvent(*event, active->iStatus);

   999 		active->StartL();

  1000 		CActiveScheduler::Start();

  1001 

  1002 		if (active->iStatus == KErrNone)

  1003 			finished = ETrue;

  1004 		else

  1005 			error = active->iStatus.Int();

  1006 

  1007 		__LOGSERV_UHEAP_RESET;

  1008 

  1009 		if(error != KErrNoMemory)

  1010 			{

  1011 			TEST2(error, KErrNone);

  1012 			}

  1013 		}

  1014 

  1015 	TEST(event->Time() >= now);

  1016 	TEST(event->Description() == KTestEventDesc1);

  1017 

  1018 	active->StartL();

  1019 	client->GetEvent(*event, active->iStatus);

  1020 	CActiveScheduler::Start();

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

  1022 

  1023 	CleanupStack::PopAndDestroy(4, client); // event, active, type, client

  1024     test.Printf(_L("===CLogClient::AddEvent() server side OOM test succeeded at iteration %d\n"), failCount);

  1025 	}

  1026 

  1027 /**

  1028 @SYMTestCaseID          SYSLIB-LOGENG-CT-0898

  1029 @SYMTestCaseDesc	    Tests for retrieving details of an event 

  1030                         Tests for CLogClient::GetEvent() function.

  1031 @SYMTestPriority 	    High

  1032 @SYMTestActions  	    Tests for getting event details.Check for memory errors and error in the environment

  1033                         Tests for the integrity of the information

  1034 @SYMTestExpectedResults Test must not fail

  1035 @SYMREQ                 REQ0000

  1036 */

  1037 LOCAL_C void TestGetEvent1L()

  1038 	{

  1039 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0898 "));

  1040 	

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

  1042 	CleanupStack::PushL(client);

  1043 	

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

  1045 	CleanupStack::PushL(active);

  1046 

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

  1048 	CleanupStack::PushL(event);

  1049 

  1050 	event->SetId(0);

  1051 

  1052 	TInt failCount = 0;

  1053 	TBool finished = EFalse;

  1054 

  1055 	while(!finished)

  1056 		{

  1057 		__UHEAP_FAILNEXT(++failCount);

  1058 		client->GetEvent(*event, active->iStatus);

  1059 

  1060 		active->StartL();

  1061 		CActiveScheduler::Start();

  1062 

  1063 		if (active->iStatus == KErrNone)

  1064 			finished = ETrue;

  1065 		else

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

  1067 

  1068 		__UHEAP_RESET;

  1069 		}

  1070 

  1071 	TEST(event->Id() == 0);

  1072 	TEST(event->Time() > TTime(0));

  1073 	TEST(event->Description() == KTestEventDesc1);

  1074 	TEST(event->EventType() == KTestEventUid);

  1075 	TEST(event->RemoteParty() == KTestRemoteParty1);

  1076 	TEST(event->Direction() == KTestDirection1);

  1077 	TEST(event->DurationType() == KTestDurationType1);

  1078 	TEST(event->Duration() == KTestDuration1);

  1079 	TEST(event->Status() == KTestStatus1);

  1080 	TEST(event->Subject() == KTestSubject1);

  1081 	TEST(event->Number() == KTestNumber1);

  1082 	TEST(event->Contact() == KTestContact1);

  1083 	TEST(event->Link() == KTestLink1);

  1084 	TEST(event->Data() == KTestData1);

  1085 

  1086 	CleanupStack::PopAndDestroy(3, client); // event, active, client

  1087     test.Printf(_L("===CLogClient::AddEvent() client side OOM test succeeded at iteration %d\n"), failCount);

  1088 	}

  1089 

  1090 /**

  1091 @SYMTestCaseID          SYSLIB-LOGENG-CT-0899

  1092 @SYMTestCaseDesc	    Tests for retrieving details of an event.Tests for CLogClient::GetEventL() function 

  1093 @SYMTestPriority 	    High

  1094 @SYMTestActions  	    Tests for getting event details of UID 0.Check for memory errors and error in the environment

  1095                         Tests for the integrity of the information

  1096 @SYMTestExpectedResults Test must not fail

  1097 @SYMREQ                 REQ0000

  1098 */

  1099 LOCAL_C void TestGetEvent3L()

  1100 	{

  1101 	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0899 "));

  1102 	

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

  1104 	CleanupStack::PushL(client);

  1105 	

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

  1107 	CleanupStack::PushL(active);

  1108 

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

  1110 	CleanupStack::PushL(event);

  1111 

  1112 	event->SetId(0);

  1113 

  1114 	TInt failCount = 0;

  1115 	TBool finished = EFalse;

  1116 

  1117 	while(!finished)

  1118 		{

  1119 		__LOGSERV_UHEAP_FAILNEXT(++failCount);

  1120 		client->GetEvent(*event, active->iStatus);

  1121 

  1122 		active->StartL();

  1123 		CActiveScheduler::Start();

  1124 

  1125 		if (active->iStatus == KErrNone)

  1126 			finished = ETrue;

  1127 		else

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

  1129 

  1130 		__LOGSERV_UHEAP_RESET;

  1131 		}

  1132 

  1133 	TEST(event->Id() == 0);

  1134 	TEST(event->Time() > TTime(0));