diff -r 000000000000 -r 08ec8eefde2f loggingservices/eventlogger/test/src/t_logheap.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/loggingservices/eventlogger/test/src/t_logheap.cpp	Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,2560 @@
+// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include <s32file.h>
+#include <logview.h>
+#include "TEST.H"
+
+#undef test  //there is a "test" macro which hides "RTest test" declaration.
+
+RTest test(_L("Log Client API Heap Failure Test Harness"));
+
+const TUid KTestEventUid = {0x10005393};
+_LIT(KTestEventDesc1, "Event Type Description");
+_LIT(KTestEventDesc2, "Changed Event Description");
+_LIT(KTestRemoteParty1, "Remote Party");
+_LIT(KTestRemoteParty2, "Changed Remote Party");
+_LIT(KTestDirection1, "Direction");
+_LIT(KTestDirection2, "Changed Direction");
+const TLogDurationType KTestDurationType1 = 1;
+const TLogDurationType KTestDurationType2 = 2;
+const TLogDuration KTestDuration1 = 0x1234;
+const TLogDuration KTestDuration2 = 0x1234567;
+_LIT(KTestStatus1, "Status");
+_LIT(KTestStatus2, "Changed Status");
+_LIT(KTestSubject1, "Subject");
+_LIT(KTestSubject2, "Changed Subject");
+_LIT(KTestNumber1, "Number");
+_LIT(KTestNumber2, "Changed Number");
+const TLogContactItemId KTestContact1 = 0x1234;
+const TLogContactItemId KTestContact2 = 0x1234567;
+const TLogLink KTestLink1 = 0x1234;
+const TLogLink KTestLink2 = 0x1234567;
+_LIT8(KTestData1, "ABCDEFGH");
+_LIT8(KTestData2, "IJKLMNOPQRSTUVWXYZ");
+const TLogSize KTestMaxLogSize = 0xFFF;
+const TLogRecentSize KTestMaxRecentLogSize = 0xF;
+const TLogAge KTestMaxEventAge = 0xFFFFFFF;
+
+_LIT(KCreateDb, "Create Db");
+_LIT(KOpenDb,   "Open Db");
+
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
+_LIT(KServerSide, "server side");
+_LIT(KClientSide, "client side");
+#endif
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0884
+@SYMTestCaseDesc	    Tests for functionality of CLogEvent,CTestActive classes
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for no memory errors.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestStartup1L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0884 "));
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	TTime now;
+	now.UniversalTime();
+
+	event->SetEventType(KLogCallEventTypeUid);
+
+	active->StartL();
+	client->AddEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	
+	TBool finished = EFalse;
+	TInt failCount = 0;
+
+	while(!finished)
+		{
+		__UHEAP_FAILNEXT(++failCount);
+		client->ChangeEvent(*event, active->iStatus);
+		__UHEAP_RESET;
+		active->StartL();
+		CActiveScheduler::Start();
+
+		if (active->iStatus == KErrNone)
+			{
+			finished = ETrue;
+			}
+		else
+			{
+			TEST2(active->iStatus.Int(), KErrNoMemory);
+			}
+		}
+
+	CleanupStack::PopAndDestroy(3); // client, active, event
+    test.Printf(_L("===CLogClient::ChangeEvent() client side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0885
+@SYMTestCaseDesc	    Tests for CLogEvent,CTestActive classes
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for all basic functions of CLogEvent,CTestActive classes.Check for ErrNone flag.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestBasicL(CLogClient& aClient)
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0885 "));
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	TTime now;
+	now.UniversalTime();
+
+	event->SetEventType(KLogCallEventTypeUid);
+
+	active->StartL();
+	aClient.AddEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(event->EventType() == KLogCallEventTypeUid);
+	TEST(event->Description().Length() > 0);
+	TEST(event->Time() >= now);
+	now = event->Time();
+
+	TLogId id = event->Id();
+
+	event->SetRemoteParty(KTestRemoteParty1);
+	event->SetDirection(KTestDirection1);
+	event->SetDurationType(KTestDurationType1);
+	event->SetDuration(KTestDuration1);
+	event->SetStatus(KTestStatus1);
+	event->SetSubject(KTestSubject1);
+	event->SetNumber(KTestNumber1);
+	event->SetContact(KTestContact1);
+	event->SetLink(KTestLink1);
+	event->SetDataL(KTestData1);
+
+	active->StartL();
+	aClient.ChangeEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(event->Id() == id);
+	TEST(event->EventType() == KLogCallEventTypeUid);
+	TEST(event->Description().Length() > 0);
+	TEST(event->Time() == now);
+	TEST(event->RemoteParty() == KTestRemoteParty1);
+	TEST(event->Direction() == KTestDirection1);
+	TEST(event->DurationType() == KTestDurationType1);
+	TEST(event->Duration() == KTestDuration1);
+	TEST(event->Status() == KTestStatus1);
+	TEST(event->Subject() == KTestSubject1);
+	TEST(event->Number() == KTestNumber1);
+	TEST(event->Contact() == KTestContact1);
+	TEST(event->Link() == KTestLink1);
+	TEST(event->Data() == KTestData1);
+
+	CleanupStack::PopAndDestroy(); // event;
+
+	event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	event->SetId(id);
+
+	active->StartL();
+	aClient.GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(event->Id() == id);
+	TEST(event->EventType() == KLogCallEventTypeUid);
+	TEST(event->Description().Length() > 0);
+	TEST(event->Time() == now);
+	TEST(event->RemoteParty() == KTestRemoteParty1);
+	TEST(event->Direction() == KTestDirection1);
+	TEST(event->DurationType() == KTestDurationType1);
+	TEST(event->Duration() == KTestDuration1);
+	TEST(event->Status() == KTestStatus1);
+	TEST(event->Subject() == KTestSubject1);
+	TEST(event->Number() == KTestNumber1);
+	TEST(event->Contact() == KTestContact1);
+	TEST(event->Link() == KTestLink1);
+	TEST(event->Data() == KTestData1);
+
+	active->StartL();
+	aClient.DeleteEvent(id, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	active->StartL();
+	aClient.GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	CleanupStack::PopAndDestroy(2, active); // event, active
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0886
+@SYMTestCaseDesc	    Tests for new CLogClient object creation
+@SYMTestPriority 	    High
+@SYMTestActions  	    Create a CLogClient object on heap.Check for memory errors
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestConstruction1L(TBool aCreateDb)
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0886 "));
+
+	if(aCreateDb)
+	    {
+	    TestUtils::DeleteDatabaseL();
+	    }
+		
+	CLogClient* client = NULL;
+	TInt failCount = 0;
+
+	TBool finished = EFalse;
+	TInt error;
+
+	while(!finished)
+		{
+		__UHEAP_FAILNEXT(++failCount);
+
+		TRAP(error, client = CLogClient::NewL(theFs));
+
+		__UHEAP_RESET;
+
+		if (error == KErrNone)
+			{
+			finished = ETrue;
+			TestBasicL(*client);
+			}
+		else
+			TEST2(error, KErrNoMemory);
+		}
+
+	delete client;
+    test.Printf(_L("==CLogClient::NewL()+\"%S\" client side OOM test succeeded at iteration %d\n"), aCreateDb ? &KCreateDb : &KOpenDb, failCount);
+	}
+
+/**s
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0887
+@SYMTestCaseDesc	    Tests for creation of new CLogClient object 
+@SYMTestPriority 	    High
+@SYMTestActions  	    Check for memory errors and error in the environment 
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestConstruction3L(TBool aCreateDb)
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0887 "));
+
+    if(aCreateDb)
+        {
+        TestUtils::DeleteDatabaseL();
+        }
+
+	CLogClient* client = NULL;
+
+	TInt failCount = 0;
+
+	TBool finished = EFalse;
+	TInt error;
+
+	while(!finished)
+		{
+		__LOGSERV_UHEAP_FAILNEXT(++failCount);
+
+		TRAP(error, client = CLogClient::NewL(theFs));
+
+		__LOGSERV_UHEAP_RESET;
+
+		if (error == KErrNone)
+			{
+			finished = ETrue;
+			TestBasicL(*client);
+			}
+		else
+			TEST2(error, KErrNoMemory);
+		}
+
+	delete client;
+    test.Printf(_L("==CLogClient::NewL()+\"%S\" server side OOM test succeeded at iteration %d\n"), aCreateDb ? &KCreateDb : &KOpenDb, failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0888
+@SYMTestCaseDesc	    Tests for CLogClient::AddEventType() function
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for adding events to the log
+                        Check for memory errors and error in the environment 
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestAddEventType1L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0888 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	CLogEventType* type = CLogEventType::NewL();
+	CleanupStack::PushL(type);
+
+	type->SetUid(KTestEventUid);
+	type->SetDescription(KTestEventDesc1);
+	type->SetLoggingEnabled(ETrue);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+	TInt error;
+
+	while(!finished)
+		{
+		error = KErrNone;
+
+		__UHEAP_FAILNEXT(++failCount);
+		client->AddEventType(*type, active->iStatus);
+	
+		active->StartL();
+		CActiveScheduler::Start();
+		
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			error = active->iStatus.Int();
+
+		__UHEAP_RESET;
+
+		if (error == KErrNoMemory)
+			{
+			active->StartL();
+			client->GetEventType(*type, active->iStatus);
+			CActiveScheduler::Start();
+			TEST2(active->iStatus.Int(), KErrNotFound);
+			}
+		else
+			TEST2(error, KErrNone);
+
+		}
+
+	active->StartL();
+	client->AddEventType(*type, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrAlreadyExists);
+
+	CleanupStack::PopAndDestroy(3, client); // active, type, client
+   test.Printf(_L("===CLogClient::AddEventType() client side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0889
+@SYMTestCaseDesc	    Tests for CLogClient::AddEventType() function
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for adding events to the log
+                        Check for memory errors and error in the environment 
+						Test for adding the same event and check for already exits error.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestAddEventType3L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0889 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	CLogEventType* type = CLogEventType::NewL();
+	CleanupStack::PushL(type);
+
+	type->SetUid(KTestEventUid);
+	type->SetDescription(KTestEventDesc1);
+	type->SetLoggingEnabled(ETrue);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	TInt failCount = 0;
+
+	TBool finished = EFalse;
+	TInt error;
+
+	while(!finished)
+		{
+		error = KErrNone;
+
+		__LOGSERV_UHEAP_FAILNEXT(++failCount);
+		client->AddEventType(*type, active->iStatus);
+	
+		active->StartL();
+		CActiveScheduler::Start();
+		
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			error = active->iStatus.Int();
+
+		__LOGSERV_UHEAP_RESET;
+
+		if (error == KErrNoMemory)
+			{
+			active->StartL();
+			client->GetEventType(*type, active->iStatus);
+			CActiveScheduler::Start();
+			TEST2(active->iStatus.Int(), KErrNotFound);
+			}
+		else
+			TEST2(error, KErrNone);
+
+		}
+
+	active->StartL();
+	client->AddEventType(*type, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrAlreadyExists);
+
+	CleanupStack::PopAndDestroy(3, client); // active, type, client
+	test.Printf(_L("===CLogClient::AddEventType() server side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0890
+@SYMTestCaseDesc	    Tests for CLogClient::GetEventType() function 
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for getting event type for the specific UID  from the log
+                        Check for memory errors and error in the environment
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestGetEventType1L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0890 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	CLogEventType* type = CLogEventType::NewL();
+	CleanupStack::PushL(type);
+
+	type->SetUid(KTestEventUid);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+
+	while(!finished)
+		{
+		__UHEAP_FAILNEXT(++failCount);
+
+		client->GetEventType(*type, active->iStatus);
+
+		active->StartL();
+		CActiveScheduler::Start();
+		
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			{
+			TEST2(active->iStatus.Int(), KErrNoMemory);
+			TEST(type->Description() == KNullDesC);
+			}
+
+		__UHEAP_RESET;
+		}
+
+	TEST(type->Uid() == KTestEventUid);
+	TEST(type->Description() == KTestEventDesc1);
+	TEST(type->LoggingEnabled());
+
+	CleanupStack::PopAndDestroy(3, client); // active, type, client
+    test.Printf(_L("===CLogClient::GetEventType() client side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0891
+@SYMTestCaseDesc	    Tests for CLogClient::GetEventType() function 
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for getting event type for the specific UID  from the log
+                        Check for memory errors and error in the environment
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestGetEventType3L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0891 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	CLogEventType* type = CLogEventType::NewL();
+	CleanupStack::PushL(type);
+
+	type->SetUid(KTestEventUid);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+
+	while(!finished)
+		{
+		__LOGSERV_UHEAP_FAILNEXT(++failCount);
+
+		client->GetEventType(*type, active->iStatus);
+
+		active->StartL();
+		CActiveScheduler::Start();
+		
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			{
+			TEST2(active->iStatus.Int(), KErrNoMemory);
+			TEST(type->Description() == KNullDesC);
+			}
+
+		__LOGSERV_UHEAP_RESET;
+		}
+
+	TEST(type->Uid() == KTestEventUid);
+	TEST(type->Description() == KTestEventDesc1);
+	TEST(type->LoggingEnabled());
+
+	CleanupStack::PopAndDestroy(3, client); // active, type, client
+    test.Printf(_L("===CLogClient::GetEventType() server side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0892
+@SYMTestCaseDesc	    Tests for CLogClient::ChangeEventType() function 
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for changing the event type 
+                        Check for memory errors and error in the environment 
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestChangeEventType1L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0892 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogEventType* type = CLogEventType::NewL();
+	CleanupStack::PushL(type);
+
+	type->SetUid(KTestEventUid);
+
+	type->SetDescription(KTestEventDesc1);
+	type->SetDescription(KTestEventDesc2);
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+	TInt error;
+
+	while(!finished)
+		{
+		error = KErrNone;
+
+		type->SetDescription(KTestEventDesc2);
+		type->SetLoggingEnabled(EFalse);
+
+		__UHEAP_FAILNEXT(++failCount);
+		
+		client->ChangeEventType(*type, active->iStatus);
+
+		active->StartL();
+		CActiveScheduler::Start();
+
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			error = active->iStatus.Int();
+
+		__UHEAP_RESET;
+
+		if (error == KErrNoMemory)
+			{
+			active->StartL();
+			client->GetEventType(*type, active->iStatus);
+			CActiveScheduler::Start();
+			TEST2(active->iStatus.Int(), KErrNone);
+
+			TEST(type->Description() == KTestEventDesc1);
+			TEST(type->LoggingEnabled());
+			}
+		else
+			TEST2(error, KErrNone);
+		}
+
+	type->SetUid(KTestEventUid);
+
+	active->StartL();
+	client->GetEventType(*type, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(type->Uid() == KTestEventUid);
+	TEST(type->Description() == KTestEventDesc2);
+	TEST(type->LoggingEnabled() == EFalse);
+
+	CleanupStack::PopAndDestroy(3, client); // type, active, client
+    test.Printf(_L("===CLogClient::ChangeEventType() client side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0893
+@SYMTestCaseDesc	    Tests for CLogClient::ChangeEventType() function 
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for changing the event type. 
+                        Check for memory errors and error in the environment 
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestChangeEventType3L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0893 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogEventType* type = CLogEventType::NewL();
+	CleanupStack::PushL(type);
+
+	type->SetUid(KTestEventUid);
+
+	type->SetDescription(KTestEventDesc1);
+	type->SetDescription(KTestEventDesc2);
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+	TInt error;
+
+	while(!finished)
+		{
+		error = KErrNone;
+
+		type->SetDescription(KTestEventDesc2);
+		type->SetLoggingEnabled(EFalse);
+
+		__LOGSERV_UHEAP_FAILNEXT(++failCount);
+		
+		client->ChangeEventType(*type, active->iStatus);
+
+		active->StartL();
+		CActiveScheduler::Start();
+
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			error = active->iStatus.Int();
+
+		__LOGSERV_UHEAP_RESET;
+
+		if (error == KErrNoMemory)
+			{
+			active->StartL();
+			client->GetEventType(*type, active->iStatus);
+			CActiveScheduler::Start();
+			TEST2(active->iStatus.Int(), KErrNone);
+
+			TEST(type->Description() == KTestEventDesc1);
+			TEST(type->LoggingEnabled());
+			}
+		else
+			TEST2(error, KErrNone);
+		}
+
+	type->SetUid(KTestEventUid);
+
+	active->StartL();
+	client->GetEventType(*type, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(type->Uid() == KTestEventUid);
+	TEST(type->Description() == KTestEventDesc2);
+	TEST(type->LoggingEnabled() == EFalse);
+
+	CleanupStack::PopAndDestroy(3, client); // type, active, client
+    test.Printf(_L("===CLogClient::ChangeEventType() server side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0894
+@SYMTestCaseDesc	    Tests for CLogClient::DeleteEventType() function 
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for deleting of event type.
+                        After deletion check by trying to retrieve the event.
+						Check for ErrNotFound,error flag
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestDeleteEventType1L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0894 "));
+
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogEventType* type = CLogEventType::NewL();
+	CleanupStack::PushL(type);
+
+	type->SetUid(KTestEventUid);
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+	TInt error;
+
+	while(!finished)
+		{
+		error = KErrNone;
+
+		__UHEAP_FAILNEXT(++failCount);
+		client->DeleteEventType(KTestEventUid, active->iStatus);
+
+		active->StartL();
+		CActiveScheduler::Start();
+
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			error = active->iStatus.Int();
+
+		__UHEAP_RESET;
+
+		if (error == KErrNoMemory)
+			{
+			active->StartL();
+			client->GetEventType(*type, active->iStatus);
+			CActiveScheduler::Start();
+			TEST2(active->iStatus.Int(), KErrNone);
+			}
+		else
+			TEST2(error, KErrNone);
+		}
+
+	active->StartL();
+	client->GetEventType(*type, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	CleanupStack::PopAndDestroy(3, client); // type, active, client
+    test.Printf(_L("===CLogClient::DeleteEventType() client side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0895
+@SYMTestCaseDesc	    Tests for CLogClient::DeleteEventType() function 
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for deleting of event type.
+                        After deletion check by trying to retrieve the event.
+						Check for ErrNotFound,error flag.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestDeleteEventType3L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0895 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogEventType* type = CLogEventType::NewL();
+	CleanupStack::PushL(type);
+
+	type->SetUid(KTestEventUid);
+
+	TInt failCount = 0;
+
+	TBool finished = EFalse;
+	TInt error;
+
+	while(!finished)
+		{
+		error = KErrNone;
+
+		__LOGSERV_UHEAP_FAILNEXT(++failCount);
+		client->DeleteEventType(KTestEventUid, active->iStatus);
+
+		active->StartL();
+		CActiveScheduler::Start();
+
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			error = active->iStatus.Int();
+
+		__LOGSERV_UHEAP_RESET;
+
+		if (error == KErrNoMemory)
+			{
+			active->StartL();
+			client->GetEventType(*type, active->iStatus);
+			CActiveScheduler::Start();
+			TEST2(active->iStatus.Int(), KErrNone);
+			}
+		else
+			TEST2(error, KErrNone);
+		}
+
+	active->StartL();
+	client->GetEventType(*type, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	CleanupStack::PopAndDestroy(3, client); // type, active, client
+    test.Printf(_L("===CLogClient::DeleteEventType() server side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0896
+@SYMTestCaseDesc	    Tests for adding event CLogClient::AddEvent() function  
+@SYMTestPriority 	    High
+@SYMTestActions  	    Add logeventtype and logevent to the log
+                        Tests for memory errors and environment errors.
+@SYMTestExpectedResults Test must not fail 
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestAddEvent1L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0896 "));
+
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	CLogEventType* type = CLogEventType::NewL();
+	CleanupStack::PushL(type);
+
+	type->SetUid(KTestEventUid);
+	type->SetDescription(KTestEventDesc1);
+	type->SetLoggingEnabled(ETrue);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	active->StartL();
+	client->AddEventType(*type, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	TTime now;
+	now.UniversalTime();
+
+	event->SetEventType(KTestEventUid);
+	event->SetRemoteParty(KTestRemoteParty1);
+	event->SetDirection(KTestDirection1);
+	event->SetDurationType(KTestDurationType1);
+	event->SetDuration(KTestDuration1);
+	event->SetStatus(KTestStatus1);
+	event->SetSubject(KTestSubject1);
+	event->SetNumber(KTestNumber1);
+	event->SetContact(KTestContact1);
+	event->SetLink(KTestLink1);
+	event->SetDataL(KTestData1);
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+	TInt error;
+
+	while(!finished)
+		{
+		error = KErrNone;
+
+		__UHEAP_FAILNEXT(++failCount);
+		client->AddEvent(*event, active->iStatus);
+		active->StartL();
+		CActiveScheduler::Start();
+
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			error = active->iStatus.Int();
+
+		__UHEAP_RESET;
+
+		if(error != KErrNoMemory)
+			{
+			TEST2(error, KErrNone);
+			}
+		}
+
+	TEST(event->Time() >= now);
+	TEST(event->Description() == KTestEventDesc1);
+
+	active->StartL();
+	client->GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	CleanupStack::PopAndDestroy(4, client); // event, active, type, client
+    test.Printf(_L("===CLogClient::AddEvent() client side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0897
+@SYMTestCaseDesc	    Tests for adding event CLogClient::AddEvent() function 
+@SYMTestPriority 	    High
+@SYMTestActions  	    Add logeventtype and logevent to the log
+                        Tests for memory errors and environment errors.
+@SYMTestExpectedResults Test must not fail 
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestAddEvent3L()
+	{
+	
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0897 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+
+	CLogEventType* type = CLogEventType::NewL();
+	CleanupStack::PushL(type);
+
+	type->SetUid(KTestEventUid);
+	type->SetDescription(KTestEventDesc1);
+	type->SetLoggingEnabled(ETrue);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	active->StartL();
+	client->AddEventType(*type, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	TTime now;
+	now.UniversalTime();
+
+	event->SetEventType(KTestEventUid);
+	event->SetRemoteParty(KTestRemoteParty1);
+	event->SetDirection(KTestDirection1);
+	event->SetDurationType(KTestDurationType1);
+	event->SetDuration(KTestDuration1);
+	event->SetStatus(KTestStatus1);
+	event->SetSubject(KTestSubject1);
+	event->SetNumber(KTestNumber1);
+	event->SetContact(KTestContact1);
+	event->SetLink(KTestLink1);
+	event->SetDataL(KTestData1);
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+	TInt error;
+
+	while(!finished)
+		{
+		error = KErrNone;
+
+		__LOGSERV_UHEAP_FAILNEXT(++failCount);
+		client->AddEvent(*event, active->iStatus);
+		active->StartL();
+		CActiveScheduler::Start();
+
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			error = active->iStatus.Int();
+
+		__LOGSERV_UHEAP_RESET;
+
+		if(error != KErrNoMemory)
+			{
+			TEST2(error, KErrNone);
+			}
+		}
+
+	TEST(event->Time() >= now);
+	TEST(event->Description() == KTestEventDesc1);
+
+	active->StartL();
+	client->GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	CleanupStack::PopAndDestroy(4, client); // event, active, type, client
+    test.Printf(_L("===CLogClient::AddEvent() server side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0898
+@SYMTestCaseDesc	    Tests for retrieving details of an event 
+                        Tests for CLogClient::GetEvent() function.
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for getting event details.Check for memory errors and error in the environment
+                        Tests for the integrity of the information
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestGetEvent1L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0898 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	event->SetId(0);
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+
+	while(!finished)
+		{
+		__UHEAP_FAILNEXT(++failCount);
+		client->GetEvent(*event, active->iStatus);
+
+		active->StartL();
+		CActiveScheduler::Start();
+
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			TEST2(active->iStatus.Int(), KErrNoMemory);
+
+		__UHEAP_RESET;
+		}
+
+	TEST(event->Id() == 0);
+	TEST(event->Time() > TTime(0));
+	TEST(event->Description() == KTestEventDesc1);
+	TEST(event->EventType() == KTestEventUid);
+	TEST(event->RemoteParty() == KTestRemoteParty1);
+	TEST(event->Direction() == KTestDirection1);
+	TEST(event->DurationType() == KTestDurationType1);
+	TEST(event->Duration() == KTestDuration1);
+	TEST(event->Status() == KTestStatus1);
+	TEST(event->Subject() == KTestSubject1);
+	TEST(event->Number() == KTestNumber1);
+	TEST(event->Contact() == KTestContact1);
+	TEST(event->Link() == KTestLink1);
+	TEST(event->Data() == KTestData1);
+
+	CleanupStack::PopAndDestroy(3, client); // event, active, client
+    test.Printf(_L("===CLogClient::AddEvent() client side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0899
+@SYMTestCaseDesc	    Tests for retrieving details of an event.Tests for CLogClient::GetEventL() function 
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for getting event details of UID 0.Check for memory errors and error in the environment
+                        Tests for the integrity of the information
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestGetEvent3L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0899 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	event->SetId(0);
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+
+	while(!finished)
+		{
+		__LOGSERV_UHEAP_FAILNEXT(++failCount);
+		client->GetEvent(*event, active->iStatus);
+
+		active->StartL();
+		CActiveScheduler::Start();
+
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			TEST2(active->iStatus.Int(), KErrNoMemory);
+
+		__LOGSERV_UHEAP_RESET;
+		}
+
+	TEST(event->Id() == 0);
+	TEST(event->Time() > TTime(0));
+	TEST(event->Description() == KTestEventDesc1);
+	TEST(event->EventType() == KTestEventUid);
+	TEST(event->RemoteParty() == KTestRemoteParty1);
+	TEST(event->Direction() == KTestDirection1);
+	TEST(event->DurationType() == KTestDurationType1);
+	TEST(event->Duration() == KTestDuration1);
+	TEST(event->Status() == KTestStatus1);
+	TEST(event->Subject() == KTestSubject1);
+	TEST(event->Number() == KTestNumber1);
+	TEST(event->Contact() == KTestContact1);
+	TEST(event->Link() == KTestLink1);
+	TEST(event->Data() == KTestData1);
+
+	CleanupStack::PopAndDestroy(3, client); // event, active, client
+    test.Printf(_L("===CLogClient::GetEvent() server side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0900
+@SYMTestCaseDesc	    Tests for changing the log event details.
+                        Tests for CLogClient::ChangeEvent() function
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for changing the event details.Check for memory errors and error in the environment
+                        If no memory error,get the event details and check for the integrity.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestChangeEvent3L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0900 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	TTime now;
+	now.UniversalTime();
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+	TInt error;
+
+	while(!finished)
+		{
+		error = KErrNone;
+
+		event->SetId(0);
+		event->SetTime(now);
+		event->SetRemoteParty(KTestRemoteParty2);
+		event->SetDirection(KTestDirection2);
+		event->SetDurationType(KTestDurationType2);
+		event->SetDuration(KTestDuration2);
+		event->SetStatus(KTestStatus2);
+		event->SetSubject(KTestSubject2);
+		event->SetNumber(KTestNumber2);
+		event->SetContact(KTestContact2);
+		event->SetLink(KTestLink2);
+		event->SetDataL(KTestData2);
+
+		__LOGSERV_UHEAP_FAILNEXT(++failCount);
+		client->ChangeEvent(*event, active->iStatus);
+
+		active->StartL();
+		CActiveScheduler::Start();
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			error = active->iStatus.Int();
+
+		__LOGSERV_UHEAP_RESET;
+
+		if (error == KErrNoMemory)
+			{
+			active->StartL();
+			client->GetEvent(*event, active->iStatus);
+			CActiveScheduler::Start();
+			TEST2(active->iStatus.Int(), KErrNone);
+
+			TEST(event->Id() == 0);
+			TEST(event->Time() > TTime(0));
+			TEST(event->Description() == KTestEventDesc1);
+			TEST(event->EventType() == KTestEventUid);
+			TEST(event->RemoteParty() == KTestRemoteParty1);
+			TEST(event->Direction() == KTestDirection1);
+			TEST(event->DurationType() == KTestDurationType1);
+			TEST(event->Duration() == KTestDuration1);
+			TEST(event->Status() == KTestStatus1);
+			TEST(event->Subject() == KTestSubject1);
+			TEST(event->Number() == KTestNumber1);
+			TEST(event->Contact() == KTestContact1);
+			TEST(event->Link() == KTestLink1);
+			TEST(event->Data() == KTestData1);
+			}
+		else
+			TEST2(error, KErrNone);
+		}
+
+	active->StartL();
+	client->GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(event->Id() == 0);
+	TEST(event->Time() == now);
+	TEST(event->Description() == KTestEventDesc1);
+	TEST(event->EventType() == KTestEventUid);
+	TEST(event->RemoteParty() == KTestRemoteParty2);
+	TEST(event->Direction() == KTestDirection2);
+	TEST(event->DurationType() == KTestDurationType2);
+	TEST(event->Duration() == KTestDuration2);
+	TEST(event->Status() == KTestStatus2);
+	TEST(event->Subject() == KTestSubject2);
+	TEST(event->Number() == KTestNumber2);
+	TEST(event->Contact() == KTestContact2);
+	TEST(event->Link() == KTestLink2);
+	TEST(event->Data() == KTestData2);
+
+	CleanupStack::PopAndDestroy(3, client); // event, active, client
+    test.Printf(_L("===CLogClient::ChangeEvent() server side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0901
+@SYMTestCaseDesc	    Tests for changing the log event details.Tests for CLogClient::ChangeEvent() function
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for changing the event details.Check for memory errors and error in the environment
+                        If no memory error,get the event details and check for the integrity.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestChangeEvent1L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0901 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	TTime now;
+	now.UniversalTime();
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+	TInt error;
+
+	while(!finished)
+		{
+		error = KErrNone;
+
+		event->SetId(0);
+		event->SetTime(now);
+		event->SetRemoteParty(KTestRemoteParty2);
+		event->SetDirection(KTestDirection2);
+		event->SetDurationType(KTestDurationType2);
+		event->SetDuration(KTestDuration2);
+		event->SetStatus(KTestStatus2);
+		event->SetSubject(KTestSubject2);
+		event->SetNumber(KTestNumber2);
+		event->SetContact(KTestContact2);
+		event->SetLink(KTestLink2);
+		event->SetDataL(KTestData2);
+
+		__UHEAP_FAILNEXT(++failCount);
+		client->ChangeEvent(*event, active->iStatus);
+
+		active->StartL();
+		CActiveScheduler::Start();
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			error = active->iStatus.Int();
+
+		__UHEAP_RESET;
+
+		if (error == KErrNoMemory)
+			{
+			active->StartL();
+			client->GetEvent(*event, active->iStatus);
+			CActiveScheduler::Start();
+			TEST2(active->iStatus.Int(), KErrNone);
+
+			TEST(event->Id() == 0);
+			TEST(event->Time() > TTime(0));
+			TEST(event->Description() == KTestEventDesc1);
+			TEST(event->EventType() == KTestEventUid);
+			TEST(event->RemoteParty() == KTestRemoteParty1);
+			TEST(event->Direction() == KTestDirection1);
+			TEST(event->DurationType() == KTestDurationType1);
+			TEST(event->Duration() == KTestDuration1);
+			TEST(event->Status() == KTestStatus1);
+			TEST(event->Subject() == KTestSubject1);
+			TEST(event->Number() == KTestNumber1);
+			TEST(event->Contact() == KTestContact1);
+			TEST(event->Link() == KTestLink1);
+			TEST(event->Data() == KTestData1);
+			}
+		else
+			TEST2(error, KErrNone);
+		}
+
+	active->StartL();
+	client->GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(event->Id() == 0);
+	TEST(event->Time() == now);
+	TEST(event->Description() == KTestEventDesc1);
+	TEST(event->EventType() == KTestEventUid);
+	TEST(event->RemoteParty() == KTestRemoteParty2);
+	TEST(event->Direction() == KTestDirection2);
+	TEST(event->DurationType() == KTestDurationType2);
+	TEST(event->Duration() == KTestDuration2);
+	TEST(event->Status() == KTestStatus2);
+	TEST(event->Subject() == KTestSubject2);
+	TEST(event->Number() == KTestNumber2);
+	TEST(event->Contact() == KTestContact2);
+	TEST(event->Link() == KTestLink2);
+	TEST(event->Data() == KTestData2);
+
+	CleanupStack::PopAndDestroy(3, client); // event, active, client
+    test.Printf(_L("===CLogClient::ChangeEvent() client side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0902
+@SYMTestCaseDesc	    Tests for deleting an event from the main event log.Tests for CLogClient::DeleteEvent() function
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for deleting an event with unique ID of 0,check for any memory errors
+                        Try to get the deleted event and test for not found error.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestDeleteEvent1L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0902 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	event->SetId(0);
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+	TInt error;
+
+	while(!finished)
+		{
+		error = KErrNone;
+
+		__UHEAP_FAILNEXT(++failCount);
+		client->DeleteEvent(0, active->iStatus);
+
+		if (error == KErrNone)
+			{
+			active->StartL();
+			CActiveScheduler::Start();
+
+			if (active->iStatus == KErrNone)
+				finished = ETrue;
+			else
+				error = active->iStatus.Int();
+			}
+
+		__UHEAP_RESET;
+
+		if (error == KErrNoMemory)
+			{
+			active->StartL();
+			client->GetEvent(*event, active->iStatus);
+			CActiveScheduler::Start();
+			TEST2(active->iStatus.Int(), KErrNone);
+			}
+		else
+			TEST2(error, KErrNone);
+		}
+
+	active->StartL();
+	client->GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	CleanupStack::PopAndDestroy(3); // event, active, client
+    test.Printf(_L("===CLogClient::DeleteEvent() client side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0903
+@SYMTestCaseDesc	    Tests for deleting an event from the main event log
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for deleting an event with unique ID of 0,check for any memory errors
+                        Try to get the deleted event and test for not found error.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestDeleteEvent3L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0903 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	event->SetId(0);
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+	TInt error;
+
+	while(!finished)
+		{
+		error = KErrNone;
+
+		__LOGSERV_UHEAP_FAILNEXT(++failCount);
+		client->DeleteEvent(0, active->iStatus);
+
+		if (error == KErrNone)
+			{
+			active->StartL();
+			CActiveScheduler::Start();
+
+			if (active->iStatus == KErrNone)
+				finished = ETrue;
+			else
+				error = active->iStatus.Int();
+			}
+
+		__LOGSERV_UHEAP_RESET;
+
+		if (error == KErrNoMemory)
+			{
+			active->StartL();
+			client->GetEvent(*event, active->iStatus);
+			CActiveScheduler::Start();
+			TEST2(active->iStatus.Int(), KErrNone);
+			}
+		else
+			TEST2(error, KErrNone);
+		}
+
+	active->StartL();
+	client->GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	CleanupStack::PopAndDestroy(3, client); // event, active, client
+    test.Printf(_L("===CLogClient::DeleteEvent() server side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0904
+@SYMTestCaseDesc	    Tests for CLogClient::GetConfig() function
+@SYMTestPriority 	    High
+@SYMTestActions  	    Set the configuration data with zero values.
+                        Get the log engine configuration data,check for any memory errors.
+						Tests for the integrity of the data
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestGetConfig1L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0904 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	TLogConfig config;
+
+	TEST(config.iMaxEventAge == 0);
+	TEST(config.iMaxLogSize == 0);
+	TEST(config.iMaxRecentLogSize == 0);
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+
+	while(!finished)
+		{
+		__UHEAP_FAILNEXT(++failCount);
+		client->GetConfig(config, active->iStatus);
+
+		active->StartL();
+		CActiveScheduler::Start();
+
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			TEST2(active->iStatus.Int(), KErrNoMemory);
+
+		__UHEAP_RESET;
+		}
+
+	TEST(config.iMaxEventAge > 0);
+	TEST(config.iMaxLogSize > 0);
+	TEST(config.iMaxRecentLogSize > 0);
+
+	CleanupStack::PopAndDestroy(2, client); // active, client
+    test.Printf(_L("===CLogClient::GetConfig() client side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0905
+@SYMTestCaseDesc	    Tests for CLogClient::GetConfig() function
+@SYMTestPriority 	    High
+@SYMTestActions  	    Set the configuration data with zero values.
+                        Get the log engine configuration data,check for any memory errors.
+						Tests for the integrity of the data
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestGetConfig3L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0905 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	TLogConfig config;
+
+	TEST(config.iMaxEventAge == 0);
+	TEST(config.iMaxLogSize == 0);
+	TEST(config.iMaxRecentLogSize == 0);
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+
+	while(!finished)
+		{
+		__LOGSERV_UHEAP_FAILNEXT(++failCount);
+		client->GetConfig(config, active->iStatus);
+
+		active->StartL();
+		CActiveScheduler::Start();
+
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			TEST2(active->iStatus.Int(), KErrNoMemory);
+
+		__LOGSERV_UHEAP_RESET;
+		}
+
+	TEST(config.iMaxEventAge > 0);
+	TEST(config.iMaxLogSize > 0);
+	TEST(config.iMaxRecentLogSize > 0);
+
+	CleanupStack::PopAndDestroy(2, client); // active, client
+    test.Printf(_L("===CLogClient::GetConfig() server side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0906
+@SYMTestCaseDesc	    Tests for CLogClient::ChangeConfig() function
+@SYMTestPriority 	    High
+@SYMTestActions  	    Get the configuration data and store in temporary object.
+                        Set the new configuration data and change the log engine configuration,check for no memory error
+                        If no memory error,get the configuration data and test for the new changes of the data with the old data.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestChangeConfig1L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0906 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	TLogConfig configOld;
+
+	active->StartL();
+	client->GetConfig(configOld, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TLogConfig config;
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+	TInt error;
+
+	while(!finished)
+		{
+		error = KErrNone;
+
+		config.iMaxLogSize = KTestMaxLogSize;
+		config.iMaxRecentLogSize = KTestMaxRecentLogSize;
+		config.iMaxEventAge = KTestMaxEventAge;
+
+		__UHEAP_FAILNEXT(++failCount);
+		client->ChangeConfig(config, active->iStatus);
+
+		active->StartL();
+		CActiveScheduler::Start();
+
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			error = active->iStatus.Int();
+		
+		__UHEAP_RESET;
+
+		if (error == KErrNoMemory)
+			{
+			active->StartL();
+			client->GetConfig(config, active->iStatus);
+			CActiveScheduler::Start();
+			TEST2(active->iStatus.Int(), KErrNone);
+
+			TEST(config.iMaxLogSize == configOld.iMaxLogSize);
+			TEST(config.iMaxRecentLogSize == configOld.iMaxRecentLogSize);
+			TEST(config.iMaxEventAge == configOld.iMaxEventAge);
+			}
+		else
+			TEST2(error, KErrNone);		
+		}
+
+	TEST(config.iMaxLogSize == KTestMaxLogSize);
+	TEST(config.iMaxRecentLogSize == KTestMaxRecentLogSize);
+	TEST(config.iMaxEventAge == KTestMaxEventAge);
+
+	CleanupStack::PopAndDestroy(2, client); // active, client
+    test.Printf(_L("===CLogClient::ChangeConfig() client side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0907
+@SYMTestCaseDesc	    Tests for CLogClient::ChangeConfig() function
+@SYMTestPriority 	    High
+@SYMTestActions  	    Get the configuration data and store in temporary object.
+                        Set the new configuration data and change the log engine configuration,check for no memory error
+                        If no memory error,get the configuration data and test for the new changes of the data with the old data.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestChangeConfig3L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0907 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	TLogConfig configOld;
+
+	active->StartL();
+	client->GetConfig(configOld, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TLogConfig config;
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+	TInt error;
+
+	while(!finished)
+		{
+		error = KErrNone;
+
+		config.iMaxLogSize = KTestMaxLogSize;
+		config.iMaxRecentLogSize = KTestMaxRecentLogSize;
+		config.iMaxEventAge = KTestMaxEventAge;
+
+		__LOGSERV_UHEAP_FAILNEXT(++failCount);
+		client->ChangeConfig(config, active->iStatus);
+
+		active->StartL();
+		CActiveScheduler::Start();
+
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			error = active->iStatus.Int();
+		
+		__LOGSERV_UHEAP_RESET;
+
+		if (error == KErrNoMemory)
+			{
+			active->StartL();
+			client->GetConfig(config, active->iStatus);
+			CActiveScheduler::Start();
+			TEST2(active->iStatus.Int(), KErrNone);
+
+			TEST(config.iMaxLogSize == configOld.iMaxLogSize);
+			TEST(config.iMaxRecentLogSize == configOld.iMaxRecentLogSize);
+			TEST(config.iMaxEventAge == configOld.iMaxEventAge);
+			}
+		else
+			TEST2(error, KErrNone);		
+		}
+
+	TEST(config.iMaxLogSize == KTestMaxLogSize);
+	TEST(config.iMaxRecentLogSize == KTestMaxRecentLogSize);
+	TEST(config.iMaxEventAge == KTestMaxEventAge);
+
+	CleanupStack::PopAndDestroy(2, client); // active, client
+    test.Printf(_L("===CLogClient::ChangeConfig() server side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0908
+@SYMTestCaseDesc	    Tests for CLogClient::GetString() function
+@SYMTestPriority 	    High
+@SYMTestActions  	    Get the standard string name from the resource.
+                        Tests for no memory error and null string.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestGetString1L()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0908 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	TBuf<KLogMaxSharedStringLength> str;
+	
+	TInt failCount = 0;
+	TBool finished = EFalse;
+	TInt error;
+
+	while(!finished)
+		{
+		__UHEAP_FAILNEXT(++failCount);
+
+		error = client->GetString(str, R_LOG_DIR_IN);
+
+		__UHEAP_RESET;
+
+		if (error == KErrNone)
+			{
+			finished = ETrue;
+			TEST(str.Length() > 0);
+			}
+		else
+			{
+			TEST2(error, KErrNoMemory);
+			TEST(str.Length() == 0);
+			}
+		}
+	CleanupStack::PopAndDestroy(client);
+    test.Printf(_L("===CLogClient::GetString() client side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0909
+@SYMTestCaseDesc	    Tests for CLogClient::ClearLog() function
+@SYMTestPriority 	    High
+@SYMTestActions  	    Add 4 events to the event log,check for no errors
+                        Clear the log by calling ClearLog function.
+						Try for getting the before added 4 events and check for not found error.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestClearEventLog1L(TBool aMicroSeconds)
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0909 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	TTime now;
+	now.UniversalTime();
+	
+	TDateTime dt(now.DateTime());
+	if(!aMicroSeconds)
+		dt.SetMicroSecond(0);
+	dt.SetYear(dt.Year() - 1);
+	TTime date1(dt);
+
+	dt.SetYear(dt.Year() - 1);
+	TTime date2(dt);
+
+	TTime ClearThreshold(date1);
+	ClearThreshold -= TTimeIntervalSeconds(1);
+	/*need to use set the clear threshold (at least 1 sec) before the date of event 1,2.
+	Otherwise the test will fail if now happens to occur at 0 microseconds (e.g the  
+	last 6 digit of now is 0) */
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogEvent* event1 = CLogEvent::NewL();
+	CleanupStack::PushL(event1);
+	event1->SetEventType(KTestEventUid);
+
+	active->StartL();
+	client->AddEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	event1->SetTime(date1);
+
+	active->StartL();
+	client->ChangeEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	CLogEvent* event2 = CLogEvent::NewL();
+	CleanupStack::PushL(event2);
+	event2->SetEventType(KTestEventUid);
+
+	active->StartL();
+	client->AddEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	event2->SetTime(date1);
+
+	active->StartL();
+	client->ChangeEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	CLogEvent* event3 = CLogEvent::NewL();
+	CleanupStack::PushL(event3);
+	event3->SetEventType(KTestEventUid);
+
+	active->StartL();
+	client->AddEvent(*event3, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	event3->SetTime(date2);
+
+	active->StartL();
+	client->ChangeEvent(*event3, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	CLogEvent* event4 = CLogEvent::NewL();
+	CleanupStack::PushL(event4);
+	event4->SetEventType(KTestEventUid);
+
+	active->StartL();
+	client->AddEvent(*event4, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	event4->SetTime(date2);
+
+	active->StartL();
+	client->ChangeEvent(*event4, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+
+	while(!finished)
+		{
+		__UHEAP_FAILNEXT(++failCount);
+
+		client->ClearLog(ClearThreshold, active->iStatus);
+
+		__UHEAP_RESET;
+
+		active->StartL();	
+		CActiveScheduler::Start();
+
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			TEST2(active->iStatus.Int(), KErrNoMemory);
+		}
+
+	active->StartL();
+	client->GetEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	if (active->iStatus != KErrNone) 
+		RDebug::Print(_L("error code:%d failcoount:%d\n"),active->iStatus.Int(),failCount);
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	active->StartL();
+	client->GetEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	active->StartL();
+	client->GetEvent(*event3, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	active->StartL();
+	client->GetEvent(*event4, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	active->StartL();
+	client->ClearLog(now, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	active->StartL();
+	client->GetEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	active->StartL();
+	client->GetEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	CleanupStack::PopAndDestroy(6, client); // event4, event3, event2, event1, active, client
+    test.Printf(_L("===CLogClient::ClearLog() client side OOM test succeeded at iteration %d\n"), failCount);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0910
+@SYMTestCaseDesc	    Tests for CLogClient::ClearLog() function
+@SYMTestPriority 	    High
+@SYMTestActions  	    Add 4 events to the event log,check for no errors
+                        Clear the log by calling ClearLog function.
+						Try for getting the before added 4 events and check for not found error.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestClearEventLog3L(TBool aMicroSeconds)
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0910 "));
+	
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	TTime now;
+	now.UniversalTime();
+	
+	TDateTime dt(now.DateTime());
+	if(!aMicroSeconds)
+		dt.SetMicroSecond(0);
+	dt.SetYear(dt.Year() - 1);
+	TTime date1(dt);
+
+	dt.SetYear(dt.Year() - 1);
+	TTime date2(dt);
+	
+	TTime ClearThreshold(date1);
+	ClearThreshold -= TTimeIntervalSeconds(1);
+	/*need to use set the clear threshold (at least 1 sec) before the date of event 1,2.
+	Otherwise the test will fail if now happens to occur at 0 microseconds (e.g the  
+	last 6 digit of now is 0) */
+	
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogEvent* event1 = CLogEvent::NewL();
+	CleanupStack::PushL(event1);
+	event1->SetEventType(KTestEventUid);
+
+	active->StartL();
+	client->AddEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	event1->SetTime(date1);
+
+	active->StartL();
+	client->ChangeEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	CLogEvent* event2 = CLogEvent::NewL();
+	CleanupStack::PushL(event2);
+	event2->SetEventType(KTestEventUid);
+
+	active->StartL();
+	client->AddEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	event2->SetTime(date1);
+
+	active->StartL();
+	client->ChangeEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	CLogEvent* event3 = CLogEvent::NewL();
+	CleanupStack::PushL(event3);
+	event3->SetEventType(KTestEventUid);
+
+	active->StartL();
+	client->AddEvent(*event3, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	event3->SetTime(date2);
+
+	active->StartL();
+	client->ChangeEvent(*event3, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	CLogEvent* event4 = CLogEvent::NewL();
+	CleanupStack::PushL(event4);
+	event4->SetEventType(KTestEventUid);
+
+	active->StartL();
+	client->AddEvent(*event4, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	event4->SetTime(date2);
+
+	active->StartL();
+	client->ChangeEvent(*event4, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+
+	while(!finished)
+		{
+		__LOGSERV_UHEAP_FAILNEXT(++failCount);
+
+		client->ClearLog(ClearThreshold, active->iStatus);
+
+		__LOGSERV_UHEAP_RESET;
+
+		active->StartL();	
+		CActiveScheduler::Start();
+
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			TEST2(active->iStatus.Int(), KErrNoMemory);
+		}
+
+	active->StartL();
+	client->GetEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	active->StartL();
+	client->GetEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	active->StartL();
+	client->GetEvent(*event3, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	active->StartL();
+	client->GetEvent(*event4, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	active->StartL();
+	client->ClearLog(now, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	active->StartL();
+	client->GetEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	active->StartL();
+	client->GetEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	CleanupStack::PopAndDestroy(6, client); // event4, event3, event2, event1, active, client
+    test.Printf(_L("===CLogClient::ClearLog() server side OOM test succeeded at iteration %d\n"), failCount);
+	}
+	
+	/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-1910
+@SYMTestCaseDesc	    Tests for CLogClient::ClearLog() under boundary conditions
+@SYMTestPriority 	    High
+@SYMTestActions  	    Add 4 events to the event log,check for no errors
+                        Clear the log by calling ClearLog function. 
+                        However using the date for 2 events the same as the clear date threshold.
+						Try for getting the before added 4 events and check for not found error.
+@SYMTestExpectedResults Test must not fail
+@SYMDEF                 DEF093601
+*/
+LOCAL_C void TestDEF093601L(TBool aClientTest)
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1910 "));
+	if(aClientTest)
+		TestClearEventLog3L(EFalse);
+	else
+		TestClearEventLog1L(EFalse);
+	}
+
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
+
+/**
+@SYMTestCaseID			PDS-LOGENG-UT-4038
+@SYMTestCaseDesc		Clear log events with specific SimId - client/server side OOM test.
+						The test adds 2 events, one of them with a SimId. Then the test
+						executes CLogClient::ClearLog() in an OOM loop.
+@SYMTestActions			Clear log events with specific SimId - client/server side OOM test.
+@SYMTestExpectedResults Test must not fail
+@SYMTestPriority		Medium
+@SYMREQ					REQ12748
+*/
+void ClearLogSimIdOomTestL(TBool aServerSideOomTest)
+	{//This test case is compiled only when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM macro is defined
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	const TSimId KSimId = 4100000000U;
+	TTime now;
+	now.UniversalTime();
+	
+	TDateTime dt(now.DateTime());
+	dt.SetYear(dt.Year() - 1);
+	TTime date(dt);
+	
+	TTime threshold(date);
+	threshold += TTimeIntervalSeconds(10);
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+	
+	//////// Event1 ///////////////////////////
+	CLogEvent* event1 = CLogEvent::NewL();
+	CleanupStack::PushL(event1);
+	event1->SetEventType(KTestEventUid);
+
+	active->StartL();
+	client->AddEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	event1->SetTime(date);
+
+	active->StartL();
+	client->ChangeEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	//////// Event2 ///////////////////////////
+	CLogEvent* event2 = CLogEvent::NewL();
+	CleanupStack::PushL(event2);
+	event2->SetEventType(KTestEventUid);
+
+	active->StartL();
+	client->AddEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	event2->SetTime(date);
+	event2->SetSimId(KSimId);
+
+	active->StartL();
+	client->ChangeEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	////////////////////////////////////////////
+	
+	TInt failCount = 0;
+	TBool finished = EFalse;
+
+	while(!finished)
+		{
+		if(aServerSideOomTest)
+			{
+			__LOGSERV_UHEAP_FAILNEXT(++failCount);
+			}
+		else
+			{
+			__UHEAP_FAILNEXT(++failCount);
+			}
+
+		client->ClearLog(threshold, KSimId, active->iStatus);
+
+		if(aServerSideOomTest)
+			{
+			__LOGSERV_UHEAP_RESET;
+			}
+		else
+			{
+			__UHEAP_RESET;
+			}
+
+		active->StartL();	
+		CActiveScheduler::Start();
+
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			TEST2(active->iStatus.Int(), KErrNoMemory);
+		}
+
+	//Check: event1 is without SimId and must not be deleted. event2 is with SimId and should be deleted. 
+	active->StartL();
+	client->GetEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	active->StartL();
+	client->GetEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	//Delete all events
+	active->StartL();
+	client->ClearLog(now, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	
+	active->StartL();
+	client->GetEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	active->StartL();
+	client->GetEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);	
+	
+	CleanupStack::PopAndDestroy(4, client); //event2, event1, active, client
+    test.Printf(_L("===CLogClient::ClearLog() + SimId %S OOM test succeeded at iteration %d\n"), aServerSideOomTest ? &KServerSide : &KClientSide, failCount);
+	}
+
+/**
+@SYMTestCaseID			PDS-LOGENG-UT-4039
+@SYMTestCaseDesc		Clear log events with specific SimId and recent list- client/server side OOM test.
+						The test adds 2 events to a recent list, one of them with a SimId. Then the test
+						executes CLogClient::ClearLog() in an OOM loop.
+@SYMTestActions			Clear log events with specific SimId and recent list- client/server side OOM test.
+@SYMTestExpectedResults Test must not fail
+@SYMTestPriority		Medium
+@SYMREQ					REQ12748
+*/
+void ClearLogRecentSimIdOomTestL(TBool aServerSideOomTest)
+	{//This test case is compiled only when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM macro is defined
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+	
+	const TSimId KSimId = 4200000000U;
+	const TUid KEvTypeUid = {KLogCallEventType};
+	_LIT(KEvDirection, "Missed call");
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+	
+	//////// Event1 ///////////////////////////
+	CLogEvent* event1 = CLogEvent::NewL();
+	CleanupStack::PushL(event1);
+	event1->SetEventType(KEvTypeUid);
+	event1->SetDirection(KEvDirection);
+	event1->SetNumber(_L("12345678"));
+
+	active->StartL();
+	client->AddEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	//////// Event2 ///////////////////////////
+	CLogEvent* event2 = CLogEvent::NewL();
+	CleanupStack::PushL(event2);
+	event2->SetEventType(KEvTypeUid);
+	event2->SetDirection(KEvDirection);
+	event2->SetNumber(_L("87654321"));
+	event2->SetSimId(KSimId);
+
+	active->StartL();
+	client->AddEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	////////////////////////////////////////////
+	
+	TInt failCount = 0;
+	TBool finished = EFalse;
+
+	while(!finished)
+		{
+		if(aServerSideOomTest)
+			{
+			__LOGSERV_UHEAP_FAILNEXT(++failCount);
+			}
+		else
+			{
+			__UHEAP_FAILNEXT(++failCount);
+			}
+
+		client->ClearLog(KLogRecentMissedCalls, KSimId, active->iStatus);
+
+		if(aServerSideOomTest)
+			{
+			__LOGSERV_UHEAP_RESET;
+			}
+		else
+			{
+			__UHEAP_RESET;
+			}
+
+		active->StartL();	
+		CActiveScheduler::Start();
+
+		if (active->iStatus == KErrNone)
+			finished = ETrue;
+		else
+			TEST2(active->iStatus.Int(), KErrNoMemory);
+		}
+
+	//Check: event1 is without SimId and must be presented in the view. Event2 is with SimId and should not be in the view.
+	CLogViewRecent* view = CLogViewRecent::NewL(*client);
+	CleanupStack::PushL(view);
+	TBool rc = view->SetRecentListL(KLogRecentMissedCalls, active->iStatus);
+	TEST(rc);
+	active->StartL();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	
+	TInt count = view->CountL();
+	TEST2(count, 1);
+	rc = view->FirstL(active->iStatus);
+	TEST(rc);
+	active->StartL();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	const CLogEvent& e = view->Event();
+	TEST2(e.SimId(), KLogNullSimId);
+	
+	CleanupStack::PopAndDestroy(view);
+
+	//Delete all events
+	active->StartL();
+	client->ClearLog(KLogRecentMissedCalls, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	
+	//Check: no events in the recent view list 
+	view = CLogViewRecent::NewL(*client);
+	CleanupStack::PushL(view);
+	rc = view->SetRecentListL(KLogRecentMissedCalls, active->iStatus);
+	TEST(!rc);
+	
+	CleanupStack::PopAndDestroy(5, client); //view, event2, event1, active, client
+    test.Printf(_L("===CLogClient::ClearLog()/Recent + SimId %S OOM test succeeded at iteration %d\n"), aServerSideOomTest ? &KServerSide : &KClientSide, failCount);
+	}
+
+#endif//SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
+
+LOCAL_C void doClientFailureL()
+	{
+	test.Next(_L("Server startup"));
+	TestStartup1L();
+	User::After(100000);
+
+	test.Next(_L("Construction + create logeng database"));
+	TestConstruction1L(ETrue); // Creates database
+    test.Next(_L("Construction + open logeng database"));
+	TestConstruction1L(EFalse); // Opens existing database
+	TestUtils::DeleteDatabaseL();
+	theLog.Write(_L8("Test 1.1 OK\n"));
+
+	test.Next(_L("Add Event Type"));
+	TestAddEventType1L();
+	theLog.Write(_L8("Test 1.2 OK\n"));
+
+	test.Next(_L("Get Event Type"));
+	TestGetEventType1L();
+	theLog.Write(_L8("Test 1.3 OK\n"));
+
+	test.Next(_L("Change Event Type"));
+	TestChangeEventType1L();
+	theLog.Write(_L8("Test 1.4 OK\n"));
+
+	test.Next(_L("Delete Event Type"));
+	TestDeleteEventType1L();
+	theLog.Write(_L8("Test 1.5 OK\n"));
+
+	test.Next(_L("Add Event"));
+	TestAddEvent1L();
+	theLog.Write(_L8("Test 1.6 OK\n"));
+
+	test.Next(_L("Get Event"));
+	TestGetEvent1L();
+	theLog.Write(_L8("Test 1.7 OK\n"));
+
+	test.Next(_L("Change Event"));
+	TestChangeEvent1L();
+	theLog.Write(_L8("Test 1.8 OK\n"));
+
+	test.Next(_L("Delete Event"));
+	TestDeleteEvent1L();
+	theLog.Write(_L8("Test 1.9 OK\n"));
+
+	test.Next(_L("Get Config"));
+	TestGetConfig1L();
+	theLog.Write(_L8("Test 1.10 OK\n"));
+
+	test.Next(_L("Change Config"));
+	TestChangeConfig1L();
+	theLog.Write(_L8("Test 1.11 OK\n"));
+
+	test.Next(_L("Get String"));
+	TestGetString1L();
+	theLog.Write(_L8("Test 1.12 OK\n"));
+	
+	test.Next(_L("Clear Event Log"));
+	TestClearEventLog1L(ETrue);
+	theLog.Write(_L8("Test 1.13 OK\n"));
+	
+	test.Next(_L("DEF093601"));
+	TestDEF093601L(EFalse);
+	theLog.Write(_L8("Test 1.14 OK\n"));
+
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
+	test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4038 Clear Event Log + SimId"));
+	ClearLogSimIdOomTestL(EFalse);
+	theLog.Write(_L8("Test 1.15 OK\n"));
+	
+	test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4039 Clear Event Log/Recent + SimId"));
+	ClearLogRecentSimIdOomTestL(EFalse);
+	theLog.Write(_L8("Test 1.16 OK\n"));
+#endif	
+	}
+
+LOCAL_C void doLogServFailureL()
+	{
+	test.Next(_L("Construction + create logeng database"));
+	TestConstruction3L(ETrue); // Creates database
+    test.Next(_L("Construction + open logeng database"));
+	TestConstruction3L(EFalse); // Opens existing database
+	TestUtils::DeleteDatabaseL();
+	theLog.Write(_L8("Test 2.1 OK\n"));
+
+	test.Next(_L("Add Event Type"));
+	TestAddEventType3L();
+	theLog.Write(_L8("Test 2.2 OK\n"));
+
+	test.Next(_L("Get Event Type"));
+	TestGetEventType3L();
+	theLog.Write(_L8("Test 2.3 OK\n"));
+
+	test.Next(_L("Change Event Type"));
+	TestChangeEventType3L();
+	theLog.Write(_L8("Test 2.4 OK\n"));
+
+	test.Next(_L("Delete Event Type"));
+	TestDeleteEventType3L();
+	theLog.Write(_L8("Test 2.5 OK\n"));
+
+	test.Next(_L("Add Event"));
+	TestAddEvent3L();
+	theLog.Write(_L8("Test 2.6 OK\n"));
+
+	test.Next(_L("Get Event"));
+	TestGetEvent3L(); 
+	theLog.Write(_L8("Test 2.7 OK\n"));
+
+	test.Next(_L("Change Event"));
+	TestChangeEvent3L();
+	theLog.Write(_L8("Test 2.8 OK\n"));
+
+	test.Next(_L("Delete Event"));
+	TestDeleteEvent3L();
+	theLog.Write(_L8("Test 2.9 OK\n"));
+
+	test.Next(_L("Get Config"));
+	TestGetConfig3L();
+	theLog.Write(_L8("Test 2.10 OK\n"));
+
+	test.Next(_L("Change Config"));
+	TestChangeConfig3L();
+	theLog.Write(_L8("Test 2.11 OK\n"));
+
+	test.Next(_L("Clear Event Log"));
+	TestClearEventLog3L(ETrue);
+	theLog.Write(_L8("Test 2.12 OK\n"));
+	
+	test.Next(_L("DEF093601"));
+	TestDEF093601L(ETrue);
+	theLog.Write(_L8("Test 2.13 OK\n"));
+	
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
+	test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4038 Clear Event Log + SimId"));
+	ClearLogSimIdOomTestL(ETrue);
+	theLog.Write(_L8("Test 2.14 OK\n"));
+
+	test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4039 Clear Event Log/Recent + SimId"));
+	ClearLogRecentSimIdOomTestL(ETrue);
+	theLog.Write(_L8("Test 2.15 OK\n"));
+#endif	
+	}
+
+void doTestsL()
+	{
+	TestUtils::Initialize(_L("T_LOGHEAP"));
+
+	test.Start(_L("Log Client"));
+	doClientFailureL();
+
+	test.Next(_L("Log Server"));
+	doLogServFailureL();
+	}