diff -r 000000000000 -r 08ec8eefde2f loggingservices/eventlogger/test/src/t_logapi.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/loggingservices/eventlogger/test/src/t_logapi.cpp	Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,1977 @@
+// 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 <e32math.h>
+#include <logview.h>
+#include <s32mem.h> 
+#include "TEST.H"
+
+#define UNUSED_VAR(a) a = a
+
+#undef test  //there is a "test" macro which hides "RTest test" declaration.
+
+const TLogContactItemId KTestContact = 0x1234;
+const TInt KTestEventNum = 10;
+
+RTest test(_L("Log Client Basic API 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, "TheNumber");
+_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 TLogFlags KTestFlags1 = 0x5;
+const TLogFlags KTestFlags2 = 0xA;
+const TLogSize KTestMaxLogSize = 0xFFF;
+const TLogRecentSize KTestMaxRecentLogSize = 0xF;
+const TLogAge KTestMaxEventAge = 0xFFFFFFF;
+
+TInt gTheId;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////  Thread panic macros   ////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+static void ThrCheck1(TInt aValue, TInt aLine)
+	{
+	if(!aValue)
+		{
+		RDebug::Print(_L("*** Line %d. Boolean expression evaluated to false!\r\n"), aLine);
+		User::Panic(_L("ThrChk1"), 1);
+		}
+	}
+
+static void ThrCheck2(TInt aValue, TInt aExpected, TInt aLine)
+	{
+	if(aValue != aExpected)
+		{
+		RDebug::Print(_L("*** Line %d. Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue);
+		User::Panic(_L("ThrChk2"), 2);
+		}
+	}
+
+#define TTEST(arg) ThrCheck1((arg), __LINE__)
+#define TTEST2(aValue, aExpected) ThrCheck2(aValue, aExpected, __LINE__)
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+class TClientObserverTestReceiver : public MLogClientChangeObserver
+	{
+public:
+	TClientObserverTestReceiver(TBool& aFlag) : iCallCount(0), iFlag(aFlag) { }
+
+public:
+	void HandleLogClientChangeEventL(TUid aChangeType, TInt /*aChangeParam1*/, TInt /*aChangeParam2*/, TInt /*aChangeParam3*/)
+		{
+		++iCallCount;
+		iFlag = (aChangeType == KLogClientChangeEventLogCleared);
+		}
+	inline TInt CallCount() const { return iCallCount; }
+	inline void Reset() { iCallCount = 0; iFlag = EFalse; }
+
+private:
+	TInt iCallCount;
+	TBool& iFlag;
+	};
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0833
+@SYMTestCaseDesc	    Client observer mechanism test
+@SYMTestPriority 	    High
+@SYMTestActions  	    Set the change observer,add an event type,clear the log and test for the status.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestClientObserverMechanismL(CLogClient& aClient)
+	{	
+	//
+	TBool logClearedFlag = EFalse;
+	TClientObserverTestReceiver testReceiver(logClearedFlag);
+	//
+	aClient.SetGlobalChangeObserverL(&testReceiver);
+
+	TTime now;
+	now.UniversalTime();
+	TTime clearLogThreshold(now);
+	clearLogThreshold -= TTimeIntervalDays(1);
+	TTime past(now);
+	past -= TTimeIntervalDays(2);
+
+	// Make some events
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+	for(TInt i=0; i<10; i++)
+		{
+		event->SetEventType(KLogCallEventTypeUid);
+		event->SetRemoteParty(KTestRemoteParty1);
+		event->SetDirection(KTestDirection1);
+		event->SetDurationType(KTestDurationType1);
+		event->SetDuration(KTestDuration1);
+		event->SetStatus(KTestStatus1);
+		event->SetSubject(KTestSubject1);
+		event->SetNumber(KTestNumber1);
+		event->SetContact((TLogContactItemId) i+1);
+		event->SetLink(KTestLink1);
+		event->SetDataL(KTestData1);
+		event->SetFlags(KTestFlags1);
+
+		// Add event
+		active->StartL();
+		aClient.AddEvent(*event, active->iStatus);
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+
+		// Make it in the past
+		event->SetTime(past);
+		active->StartL();
+		aClient.ChangeEvent(*event, active->iStatus);
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+		}
+	TEST2(testReceiver.CallCount(), 0);
+
+	// Clear the log
+	active->StartL();
+	aClient.ClearLog(clearLogThreshold, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Have to wait a while, since the change observer active object
+	// won't run until shortly after completing the 'clear log' operation
+	// request status.
+	CTestTimer* timer = CTestTimer::NewL();
+	CleanupStack::PushL(timer);
+	timer->After(5 * 1000000);
+	CActiveScheduler::Start();
+	CleanupStack::PopAndDestroy(timer);
+	//
+	TEST2(testReceiver.CallCount(), 1);
+	TEST(logClearedFlag);
+
+	// Start again
+	testReceiver.Reset();
+
+	// Test removing observer
+	aClient.SetGlobalChangeObserverL(NULL);
+
+	// Add an event again
+	active->StartL();
+	aClient.AddEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	TEST2(testReceiver.CallCount(), 0);
+
+	// Make it in the past
+	event->SetTime(past);
+	active->StartL(); 
+	aClient.ChangeEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Clear the log again
+	active->StartL();
+	aClient.ClearLog(clearLogThreshold, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	TEST2(testReceiver.CallCount(), 0);
+	TEST(logClearedFlag == EFalse);
+
+	aClient.SetGlobalChangeObserverL(&testReceiver);
+
+	// Tidy up
+	CleanupStack::PopAndDestroy(2, event); // active, event
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0834
+@SYMTestCaseDesc	    Adding an event to the log engine test.
+@SYMTestPriority 	    High
+@SYMTestActions  	    Create a new event type and add that to the log engine.
+                        Start an active scheduler and check for the  error status.
+                        Add the event once again and check for the already exits condition.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestAddEventTypeL(CLogClient& aClient)
+//
+//
+//
+	{
+	LOGTEXT("TestAddEventTypeL()");	
+	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();
+	aClient.AddEventType(*type, active->iStatus);
+	aClient.Cancel();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrCancel);
+
+	active->StartL();
+	aClient.AddEventType(*type, active->iStatus);
+	CActiveScheduler::Start();
+	aClient.Cancel();
+	TEST((active->iStatus == KErrNone)||(active->iStatus == KErrAlreadyExists));
+
+	active->StartL();
+	aClient.AddEventType(*type, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrAlreadyExists);
+
+	CleanupStack::PopAndDestroy(2); // active, type
+	LOGTEXT("TestAddEventTypeL() - end");
+	}
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0835
+@SYMTestCaseDesc	    Retrieving the event type information test.
+                        Tests for CLogClient::GetEventType() function.
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for the retrieved information of event type. 
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestGetEventTypeL(CLogClient& aClient)
+//
+//
+//
+	{
+	LOGTEXT("TestGetEventTypeL()");	
+	CLogEventType* type = CLogEventType::NewL();
+	CleanupStack::PushL(type);
+
+	type->SetUid(KTestEventUid);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	active->StartL();
+	aClient.GetEventType(*type, active->iStatus);
+	aClient.Cancel();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrCancel);
+
+	active->StartL();
+	aClient.GetEventType(*type, active->iStatus);
+	CActiveScheduler::Start();
+	aClient.Cancel();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(type->Uid() == KTestEventUid);
+	TEST(type->Description() == KTestEventDesc1);
+	TEST(type->LoggingEnabled());
+
+	CleanupStack::PopAndDestroy(2); // active, type
+	LOGTEXT("TestGetEventTypeL() - end");
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0836
+@SYMTestCaseDesc	    Changing the event type test.
+                        Tests for CLogClient::ChangeEventType test
+@SYMTestPriority 	    High
+@SYMTestActions  	    Create a new event type,change the event type and check for any errors
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestChangeEventTypeL(CLogClient& aClient)
+//
+//
+//
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0836 "));
+	LOGTEXT("TestChangeEventTypeL()");	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogEventType* type = CLogEventType::NewL();
+	CleanupStack::PushL(type);
+
+	type->SetUid(KTestEventUid);
+	type->SetDescription(KTestEventDesc2);
+	type->SetLoggingEnabled(EFalse);
+
+	active->StartL();
+	aClient.ChangeEventType(*type, active->iStatus);
+	aClient.Cancel();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrCancel);
+
+	active->StartL();
+	aClient.ChangeEventType(*type, active->iStatus);
+	CActiveScheduler::Start();
+	aClient.Cancel();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	CleanupStack::PopAndDestroy(); // type
+
+	type = CLogEventType::NewL();
+	CleanupStack::PushL(type);
+
+	type->SetUid(KTestEventUid);
+
+	active->StartL();
+	aClient.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(2); // type, active
+	LOGTEXT("TestChangeEventTypeL() - end");
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0837
+@SYMTestCaseDesc	    Deleting an event type test.
+                        Tests for CLogClient::DeleteEventType() test
+@SYMTestPriority 	    High
+@SYMTestActions  	    Delete an event type from log database and test for no errors found
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestDeleteEventTypeL(CLogClient& aClient)
+//
+//
+//
+	{
+    test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0837 "));
+	LOGTEXT("TestChangeEventTypeL()");	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	active->StartL();
+	aClient.DeleteEventType(KTestEventUid, active->iStatus);
+	aClient.Cancel();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrCancel);
+
+	active->StartL();
+	aClient.DeleteEventType(KTestEventUid, active->iStatus);
+	CActiveScheduler::Start();
+	aClient.Cancel();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	CLogEventType* type = CLogEventType::NewL();
+	CleanupStack::PushL(type);
+
+	type->SetUid(KTestEventUid);
+
+	active->StartL();
+	aClient.GetEventType(*type, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	CleanupStack::PopAndDestroy(2); // type, active
+	LOGTEXT("TestChangeEventTypeL() - end");
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-1329
+@SYMTestCaseDesc	    Adding an event type test.
+                        Tests for CLogClient::AddEventType() function
+@SYMTestPriority 	    High
+@SYMTestActions  	    Add an event type to the log database and test for no errors found
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestAddEventL(CLogClient& aClient)
+//
+//
+//
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1329 "));	
+	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();
+	aClient.AddEventType(*type, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	// Reset
+	gTheId = KLogNullId;
+	//
+	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);
+	event->SetFlags(KTestFlags1);
+	//
+	active->StartL();
+	aClient.AddEvent(*event, active->iStatus);
+	aClient.Cancel();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrCancel);
+	//
+	active->StartL();
+	aClient.AddEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST(!active->IsActive());
+	aClient.Cancel();
+	TEST2(active->iStatus.Int(), KErrNone);
+	//
+	gTheId=event->Id();
+	//
+	TEST(gTheId != KLogNullId);
+	TEST(event->Time() >= now);
+	TEST(event->Description() == KTestEventDesc1);
+	//
+	CleanupStack::PopAndDestroy(3); // event, active, type
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0838
+@SYMTestCaseDesc	    Client failure test
+@SYMTestPriority 	    High
+@SYMTestActions  	    Checks for status after client is deleted,checks for Cancel error flag
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestClientFailL()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0838 "));	
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+
+	event->SetId(gTheId);
+
+	active->StartL();
+	client->GetEvent(*event, active->iStatus);
+	CleanupStack::Pop(); // client
+	delete client;	
+	
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrCancel);
+
+	CleanupStack::PopAndDestroy(2); // event, active
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0839
+@SYMTestCaseDesc	    Tests for CLogClient::GetEvent() function
+@SYMTestPriority 	    High
+@SYMTestActions  	    Retrieve the event type and test for the integrity of the event type information
+                        Check for no errors
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+
+LOCAL_C void TestGetEventL(CLogClient& aClient)
+//
+//
+//
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0839 "));
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	event->SetId(gTheId);
+
+	active->StartL();
+	aClient.GetEvent(*event, active->iStatus);
+	aClient.Cancel();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrCancel);
+
+	active->StartL();
+	aClient.GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	aClient.Cancel();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(event->Id() == gTheId);
+	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);
+	TEST(event->Flags() == KTestFlags1);
+
+	TBuf<500> subject;
+	TInt i=450;
+	while(i--)
+		subject.Append(_L("a"));
+	event->SetSubject(subject);
+
+	active->StartL();
+	aClient.AddEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	if	(aClient.IsActive() && active->iStatus == KRequestPending)
+		{
+		aClient.Cancel();
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrCancel);
+		}
+	else
+		{
+		TEST2(active->iStatus.Int(), KErrNone);
+		}
+
+	// See TestAddEventL on why this might still allow the active object
+	// to be cancelled.
+//	TEST(active->iStatus == KErrNone || active->iStatus == KErrCancel);
+
+	i=450;
+	while(i--)
+		subject[i]='b';
+	event->SetSubject(subject);
+
+	active->StartL();
+	aClient.GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	aClient.Cancel();
+ 	TEST2(active->iStatus.Int(), KErrNone);
+
+
+	CleanupStack::PopAndDestroy(2); // event, active
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0840
+@SYMTestCaseDesc	    Tests for CLogClient::ChangeEvent() function 
+@SYMTestPriority 	    High
+@SYMTestActions  	    Change the event,get the event information and test for the integrity.
+                        Check for any errors.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestChangeEventL(CLogClient& aClient)
+//
+//
+//
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0840 "));
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	TTime now;
+	now.UniversalTime();
+
+	event->SetId(gTheId);
+	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);
+	event->SetFlags(KTestFlags2);
+
+	active->StartL();
+	aClient.ChangeEvent(*event, active->iStatus);
+	aClient.Cancel();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrCancel);
+
+	active->StartL();
+	aClient.ChangeEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	aClient.Cancel();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	CleanupStack::PopAndDestroy(); // event
+
+	event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	event->SetId(gTheId);
+
+	active->StartL();
+	aClient.GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(event->Id() == gTheId);
+	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);
+	TEST(event->Flags() == KTestFlags2);
+
+	CleanupStack::PopAndDestroy(2); // event, active
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0841
+@SYMTestCaseDesc	    Tests for CLogClient::DeleteEvent() function 
+@SYMTestPriority 	    High
+@SYMTestActions  	    Delete the event and test for no errors found.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestDeleteEventL(CLogClient& aClient)
+//
+//
+//
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0841 "));
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	active->StartL();
+	aClient.DeleteEvent(0, active->iStatus);
+	aClient.Cancel();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrCancel);
+
+	active->StartL();
+	aClient.DeleteEvent(0, active->iStatus);
+	CActiveScheduler::Start();
+	aClient.Cancel();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	event->SetId(0);
+
+	active->StartL();
+	aClient.GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	CleanupStack::PopAndDestroy(2); // event, active
+	}
+
+
+#ifdef SYSLIBS_TEST
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-UT-4015
+@SYMTestCaseDesc	    Test the behaviour implemented by PREQ2103
+@SYMTestPriority 	    Medium
+@SYMTestActions  	    Get the settings from logeng repository file / resource file.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ11125
+                        REQ11126
+                        REQ11127
+                        REQ11128
+*/
+LOCAL_C void TestGetConfigSettingsFromRepositoryFileL(CLogClient& aClient)
+	{
+	//Note: if this tests starts failing, then go and check the CentralRepository private data cage (c:\\private\\10202be9) , if this file - 101f401d.txt, is there.
+	//If it is - delete it and try the test again.
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-UT-4015 "));
+	//Get the contact match count and contact name format.This should be from resource file.
+	TInt16 contactMatchCount;
+	TInt16 contactNameFormat;
+	RFs fs;
+	
+	LEAVE_IF_ERROR(fs.Connect());
+	CleanupClosePushL(fs);
+	
+	//Creating a new CLogClient Object make the server getting the contact match settings. 
+	//As the database is deleted it get them from the resource file.
+	CLogClient* client2 = CLogClient::NewL(fs);
+	CleanupStack::PushL(client2);
+	CleanupStack::PopAndDestroy(client2);
+		
+	//Read these settings via "reader" object.
+	RFileReadStream resFileCount_reader;
+	CleanupClosePushL(resFileCount_reader);
+	RFileReadStream resFileFormat_reader;
+	CleanupClosePushL(resFileFormat_reader);
+	_LIT(KLogengTestFileNameCount, "c:\\test\\test_logengconfig_count.ini");
+	_LIT(KLogengTestFileNameFormat, "c:\\test\\test_logengconfig_format.ini");
+	LEAVE_IF_ERROR(resFileCount_reader.Open(fs, KLogengTestFileNameCount, EFileRead));
+	LEAVE_IF_ERROR(resFileFormat_reader.Open(fs, KLogengTestFileNameFormat, EFileRead));		
+	contactMatchCount = resFileCount_reader.ReadInt32L();
+	contactNameFormat = resFileFormat_reader.ReadInt32L();
+		
+	//The settings should match the ones from resource file.
+	TEST(contactMatchCount == 8);
+	TEST(contactNameFormat == 0);
+		
+	CleanupStack::PopAndDestroy(&resFileFormat_reader);
+	CleanupStack::PopAndDestroy(&resFileCount_reader);
+	
+	//Get the config settings (Three config settings). 
+	
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+		
+	TLogConfig config;
+	TEST(config.iMaxEventAge == 0);
+	TEST(config.iMaxLogSize == 0);
+	TEST(config.iMaxRecentLogSize == 0);
+	active->StartL();
+	aClient.GetConfig(config, active->iStatus);	
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	
+	//The config settings should match the ones from the resource file.
+	TEST(config.iMaxEventAge == 2592000);
+	TEST(config.iMaxLogSize == 1000);
+	TEST(config.iMaxRecentLogSize == 20);
+	
+	
+	//Now let's provide the repository file, so the server will find it and will get the settings
+	//from it.
+	
+	//Create the directory c:\private\10202be9\ if it does not exist.
+	_LIT(KExecutableFileName,		"t_logapi_helper.exe");
+	_LIT(KCommandParameters,		"c:\\private\\10202be9\\;c:\\private\\10202be9\\101f401d.txt;3");
+	RProcess process;
+	TInt r = process.Create(KExecutableFileName, KCommandParameters); 
+	process.Resume();
+	process.Close();	 
+	User::After(1000);
+	
+	 //copy the repository file to the folder 10202be9
+	_LIT(KCommandParameters1,		"z:\\system\\data\\101f401d.txt;c:\\private\\10202be9\\101f401d.txt;0");
+	r = process.Create(KExecutableFileName, KCommandParameters1); 
+	process.Resume();
+	process.Close();	 
+	User::After(1000);
+	
+	TestUtils::DeleteDatabaseL();
+	
+	//Get the config settings.
+	config.iMaxEventAge = 0;
+	config.iMaxLogSize = 0;
+	config.iMaxRecentLogSize = 0;	
+	active->StartL();
+	aClient.GetConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	//They should match the ones from the repository file.
+	TEST(config.iMaxEventAge == 2592001);
+	TEST(config.iMaxLogSize == 1001);
+	TEST(config.iMaxRecentLogSize == 21);
+	
+	CleanupStack::PopAndDestroy(active);
+	
+	//Get the contact match count and the contact name format.
+	RFileReadStream repFileCount_reader;
+	CleanupClosePushL(repFileCount_reader);
+	RFileReadStream repFileFormat_reader;
+	CleanupClosePushL(repFileFormat_reader);
+	LEAVE_IF_ERROR(repFileCount_reader.Open(fs, KLogengTestFileNameCount, EFileRead));
+	LEAVE_IF_ERROR(repFileFormat_reader.Open(fs, KLogengTestFileNameFormat, EFileRead));		
+	contactMatchCount = repFileCount_reader.ReadInt32L();
+	contactNameFormat = repFileFormat_reader.ReadInt32L();
+	CleanupStack::PopAndDestroy(&repFileFormat_reader);
+	CleanupStack::PopAndDestroy(&repFileCount_reader);
+	CleanupStack::PopAndDestroy(&fs);
+	
+	//The values should match the ones from the repository file.
+	TEST(contactMatchCount == 6);
+	TEST(contactNameFormat == 1);
+	
+	//delete the repository file c:\\private\\10202be9\\101f401d.txt.
+	_LIT(KCommandParameters2,		"c:\\private\\10202be9\\101f401d.txt;private\\10202be9\101f401d.txt;2");
+	r = process.Create(KExecutableFileName, KCommandParameters2); 
+	process.Resume();
+	process.Close();	 
+	User::After(1000);
+	theLog.Write(_L8("Deleting the Log engine database... \n"));	
+	TestUtils::DeleteDatabaseL();
+	test.Next(_L("Delay of 2 min, the necessary time to central repository to unload its cache... "));	
+	User::After(125000000); // Delay to time to cenrep to unload its cache.
+	}
+#endif
+
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0842
+@SYMTestCaseDesc	    Tests for retrieving the log engine configuration data
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for CLogClient::GetConfig() function,check for the integrity of the data
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestGetConfigL(CLogClient& aClient)
+//
+//
+//
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0842 "));
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	TLogConfig config;
+
+	TEST(config.iMaxEventAge == 0);
+	TEST(config.iMaxLogSize == 0);
+	TEST(config.iMaxRecentLogSize == 0);
+
+	active->StartL();
+	aClient.GetConfig(config, active->iStatus);
+	aClient.Cancel();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrCancel);
+
+	active->StartL();
+	aClient.GetConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	aClient.Cancel();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(config.iMaxEventAge > 0);
+	TEST(config.iMaxLogSize > 0);
+	TEST(config.iMaxRecentLogSize > 0);
+
+	CleanupStack::PopAndDestroy(); // active
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0843
+@SYMTestCaseDesc	    Tests for CLogClient::ChangeConfig() function 
+@SYMTestPriority 	    High
+@SYMTestActions  	    Change the configuration data and test for the integrity.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestChangeConfigL(CLogClient& aClient)
+//
+//
+//
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0843 "));
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	TLogConfig config;
+
+	config.iMaxLogSize = KTestMaxLogSize;
+	config.iMaxRecentLogSize = KTestMaxRecentLogSize;
+	config.iMaxEventAge = KTestMaxEventAge;
+
+	active->StartL();
+	aClient.ChangeConfig(config, active->iStatus);
+	aClient.Cancel();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrCancel);
+
+	active->StartL();
+	aClient.ChangeConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	aClient.Cancel();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(config.iMaxLogSize == KTestMaxLogSize);
+	TEST(config.iMaxRecentLogSize == KTestMaxRecentLogSize);
+	TEST(config.iMaxEventAge == KTestMaxEventAge);
+
+	CleanupStack::PopAndDestroy(); // active
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0844
+@SYMTestCaseDesc	    Tests for CLogClient::GetString() function
+@SYMTestPriority 	    High
+@SYMTestActions  	    Get the string from the resource file and check for no errors and the zero string length
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestGetStringL(CLogClient& aClient)
+//
+//
+//
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0844 "));
+	TBuf<KLogMaxSharedStringLength> str;
+	
+	TInt err = aClient.GetString(str, R_LOG_DIR_IN);
+	TEST2(err, KErrNone);
+	TEST(str.Length() > 0);
+	str.Zero();
+
+	err = aClient.GetString(str, R_LOG_DIR_OUT);
+	TEST2(err, KErrNone);
+	TEST(str.Length() > 0);
+	str.Zero();
+
+	err = aClient.GetString(str, R_LOG_DIR_IN_ALT);
+	TEST2(err, KErrNone);
+	TEST(str.Length() > 0);
+	str.Zero();
+
+	err = aClient.GetString(str, R_LOG_DIR_OUT_ALT);
+	TEST2(err, KErrNone);
+	TEST(str.Length() > 0);
+	str.Zero();
+
+	err = aClient.GetString(str, R_LOG_DIR_FETCHED);
+	TEST2(err, KErrNone);
+	TEST(str.Length() > 0);
+	str.Zero();
+
+	err = aClient.GetString(str, R_LOG_DIR_MISSED);
+	TEST2(err, KErrNone);
+	TEST(str.Length() > 0);
+	str.Zero();
+
+	err = aClient.GetString(str, R_LOG_DEL_PENDING);
+	TEST2(err, KErrNone);
+	TEST(str.Length() > 0);
+	str.Zero();
+
+	err = aClient.GetString(str, R_LOG_DEL_SENT);
+	TEST2(err, KErrNone);
+	TEST(str.Length() > 0);
+	str.Zero();
+
+	err = aClient.GetString(str, R_LOG_DEL_FAILED);
+	TEST2(err, KErrNone);
+	TEST(str.Length() > 0);
+	str.Zero();
+
+	err = aClient.GetString(str, R_LOG_DEL_NONE);
+	TEST2(err, KErrNone);
+	TEST(str.Length() > 0);
+	str.Zero();
+
+	err = aClient.GetString(str, R_LOG_DEL_DONE);
+	TEST2(err, KErrNone);
+	TEST(str.Length() > 0);
+	str.Zero();
+
+	err = aClient.GetString(str, R_LOG_DEL_NOT_SENT);
+	TEST2(err, KErrNone);
+	TEST(str.Length() > 0);
+	str.Zero();
+
+	err = aClient.GetString(str, R_LOG_DEL_NOTIFIED);
+	TEST2(err, KErrNone);
+	TEST(str.Length() > 0);
+	str.Zero();
+
+	err = aClient.GetString(str, R_LOG_DEL_EXPIRED);
+	TEST2(err, KErrNone);
+	TEST(str.Length() > 0);
+	str.Zero();
+
+	err = aClient.GetString(str, R_LOG_REMOTE_UNKNOWN);
+	TEST2(err, KErrNone);
+	TEST(str.Length() > 0);
+	str.Zero();
+
+	err = aClient.GetString(str, R_LOG_REMOTE_MULTIPLE);
+	TEST2(err, KErrNone);
+	TEST(str.Length() > 0);
+	str.Zero();
+
+	err = aClient.GetString(str, R_LOG_SUBJECT_NONE);
+	TEST2(err, KErrNone);
+	TEST(str.Length() > 0);
+	str.Zero();
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0845
+@SYMTestCaseDesc	    Tests for clearing the event types from the log
+@SYMTestPriority 	    High
+@SYMTestActions  	    Clear the event types from the log and check for event not found error.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestClearEventLogL(CLogClient& aClient)
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0845 "));
+	TTime now;
+	now.UniversalTime();
+	TDateTime d = now.DateTime();
+	RDebug::Print(_L("TimeNow: Y=%d, M=%d, D=%d, H=%d, M=%d, S=%d\n"), d.Year(), d.Month() + 1, d.Day() + 1, d.Hour(), d.Minute(), d.Second());
+
+	TTime date1(now);
+	date1 -= TTimeIntervalDays(1);
+
+	TTime date2(date1);
+	date2 -= TTimeIntervalDays(1);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	//////////////////////////////////////////////////////////////////////////////	
+	//Clear all events before (current date). Actually - all events!
+	active->StartL();
+	aClient.ClearLog(now, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	//////////////////////////////////////////////////////////////////////////////	
+	//The next part of the test will create 4 events:
+	//-event1 and event2 will have time = current date - 1 day + 10 seconds;
+	//-event3 and event4 will have time = current date - 2 days;
+	//The test is:
+	//ClearLog - Delete all events, which time is less or equal to current date - 1 day.
+	//Check - event3 and event4 should disappear, event1 and event2 should stay.
+	//ClearLog - Delete all events, which time is less or equal to current date.
+	//Check - event1 and event2 should disappear too.
+	//
+	//The "10 seconds" addition is very important. The creation of the 4 events is 
+	//an operation, which is performed very quickly. It is possible that the 
+	//first ClearLog operation will be executed at the same second at which the events
+	//were created. Which means, that all events will be deleted and the next check 
+	//for the presence of event1 and event2 will fail.
+
+	//////////////////////////////////////////////////////////////////////////////	
+	//Create and add new event - event1. 
+	//Set event1 date to be (current date - 1 day + 10 seconds).
+	CLogEvent* event1 = CLogEvent::NewL();
+	CleanupStack::PushL(event1);
+	
+	event1->SetEventType(KTestEventUid);
+	active->StartL();
+	aClient.AddEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TTimeIntervalSeconds tenSeconds(10);
+	event1->SetTime(date1 + tenSeconds);
+	active->StartL();
+	aClient.ChangeEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	//////////////////////////////////////////////////////////////////////////////	
+	//Create and add new event - event2. 
+	//Set event2 date to be (current date - 1 day + 10 seconds).
+	CLogEvent* event2 = CLogEvent::NewL();
+	CleanupStack::PushL(event2);
+	
+	event2->SetEventType(KTestEventUid);
+	active->StartL();
+	aClient.AddEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	event2->SetTime(date1 + tenSeconds);
+	active->StartL();
+	aClient.ChangeEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	//////////////////////////////////////////////////////////////////////////////	
+	//Create and add new event - event3. 
+	//Set event3 date to be (current date - 2 days).
+	CLogEvent* event3 = CLogEvent::NewL();
+	CleanupStack::PushL(event3);
+	event3->SetEventType(KTestEventUid);
+
+	active->StartL();
+	aClient.AddEvent(*event3, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	event3->SetTime(date2);
+	active->StartL();
+	aClient.ChangeEvent(*event3, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	//////////////////////////////////////////////////////////////////////////////	
+	//Create and add new event - event4. 
+	//Set event4 date to be (current date - 2 days).
+	CLogEvent* event4 = CLogEvent::NewL();
+	CleanupStack::PushL(event4);
+	event4->SetEventType(KTestEventUid);
+
+	active->StartL();
+	aClient.AddEvent(*event4, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	event4->SetTime(date2);
+	active->StartL();
+	aClient.ChangeEvent(*event4, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	//////////////////////////////////////////////////////////////////////////////	
+	//Clear all events before (current date - 1 day).
+	//Then cancel the operation.
+	RDebug::Print(_L("=.= ClearLog 1\n"));
+	active->StartL();
+	aClient.ClearLog(date1, active->iStatus);
+	aClient.Cancel();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrCancel);
+
+	//////////////////////////////////////////////////////////////////////////////	
+	//Clear all events before (current date - 1 day).
+	//event3 and event4 should be removed.
+	RDebug::Print(_L("=.= ClearLog 2\n"));
+	active->StartL();
+	aClient.ClearLog(date1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	//////////////////////////////////////////////////////////////////////////////	
+	//Get event1. It should be there - its time is (current date - 1 day + 10 seconds).
+	RDebug::Print(_L("=.= GetEvent 1\n"));
+	active->StartL();
+	aClient.GetEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	if(active->iStatus != KErrNone) 
+		{
+		RDebug::Print(_L("=1= error code:%d\n"),active->iStatus.Int());
+		}
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	//////////////////////////////////////////////////////////////////////////////	
+	//Get event2. It should be there - its time is (current date - 1 day + 10 seconds).
+	RDebug::Print(_L("=.= GetEvent 2\n"));
+	active->StartL();
+	aClient.GetEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	if(active->iStatus != KErrNone) 
+		{
+		RDebug::Print(_L("=2= error code:%d\n"),active->iStatus.Int());
+		}
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	//////////////////////////////////////////////////////////////////////////////	
+	//Get event3. It should not be there - its time is (current date - 2 days).
+	RDebug::Print(_L("=.= GetEvent 3\n"));
+	active->StartL();
+	aClient.GetEvent(*event3, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	//////////////////////////////////////////////////////////////////////////////	
+	//Get event4. It should not be there - its time is (current date - 2 days).
+	RDebug::Print(_L("=.= GetEvent 4\n"));
+	active->StartL();
+	aClient.GetEvent(*event4, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	//////////////////////////////////////////////////////////////////////////////	
+	//Clear all events happened before (current date).
+	//event1 and event2 should be removed.
+	RDebug::Print(_L("=#= ClearLog 1\n"));
+	active->StartL();
+	aClient.ClearLog(now, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	//////////////////////////////////////////////////////////////////////////////	
+	//Get event1. It should not be there - its time is (current date - 1 day + 10 seconds).
+	RDebug::Print(_L("=#= GetEvent 1\n"));
+	active->StartL();
+	aClient.GetEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	//////////////////////////////////////////////////////////////////////////////	
+	//Get event2. It should not be there - its time is (current date - 1 day + 10 seconds).
+	RDebug::Print(_L("=#= GetEvent 2\n"));
+	active->StartL();
+	aClient.GetEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	CleanupStack::PopAndDestroy(5); // event4, event3, event2, event1, active
+	}
+
+LOCAL_C void DoTestLogL(CLogBase& aClient)
+	{
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	TTime now;
+	now.UniversalTime();
+
+	event->SetEventType(KLogCallEventTypeUid);
+
+	User::After((Math::Random() % 4) * 100000);
+	active->StartL();
+	aClient.AddEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TTEST2(active->iStatus.Int(), KErrNone);
+
+	TTEST(event->EventType() == KLogCallEventTypeUid);
+	TTEST(event->Description().Length() > 0);
+	TTEST(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);
+
+	User::After((Math::Random() % 4) * 100000);
+	active->StartL();
+	aClient.ChangeEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TTEST2(active->iStatus.Int(), KErrNone);
+
+	TTEST(event->Id() == id);
+	TTEST(event->EventType() == KLogCallEventTypeUid);
+	TTEST(event->Description().Length() > 0);
+	TTEST(event->Time() == now);
+	TTEST(event->RemoteParty() == KTestRemoteParty1);
+	TTEST(event->Direction() == KTestDirection1);
+	TTEST(event->DurationType() == KTestDurationType1);
+	TTEST(event->Duration() == KTestDuration1);
+	TTEST(event->Status() == KTestStatus1);
+	TTEST(event->Subject() == KTestSubject1);
+	TTEST(event->Number() == KTestNumber1);
+	TTEST(event->Contact() == KTestContact1);
+	TTEST(event->Link() == KTestLink1);
+	TTEST(event->Data() == KTestData1);
+
+	CleanupStack::PopAndDestroy(); // event;
+
+	event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	event->SetId(id);
+
+	active->StartL();
+	aClient.GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TTEST2(active->iStatus.Int(), KErrNone);
+
+	TTEST(event->Id() == id);
+	TTEST(event->EventType() == KLogCallEventTypeUid);
+	TTEST(event->Description().Length() > 0);
+	TTEST(event->Time() == now);
+	TTEST(event->RemoteParty() == KTestRemoteParty1);
+	TTEST(event->Direction() == KTestDirection1);
+	TTEST(event->DurationType() == KTestDurationType1);
+	TTEST(event->Duration() == KTestDuration1);
+	TTEST(event->Status() == KTestStatus1);
+	TTEST(event->Subject() == KTestSubject1);
+	TTEST(event->Number() == KTestNumber1);
+	TTEST(event->Contact() == KTestContact1);
+	TTEST(event->Link() == KTestLink1);
+	TTEST(event->Data() == KTestData1);
+
+	User::After((Math::Random() % 4) * 100000);
+	active->StartL();
+	aClient.DeleteEvent(id, active->iStatus);
+	CActiveScheduler::Start();
+	TTEST2(active->iStatus.Int(), KErrNone);
+
+	active->StartL();
+	aClient.GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TTEST2(active->iStatus.Int(), KErrNotFound);
+
+	CleanupStack::PopAndDestroy(2); // event, active
+	}
+
+void DoTestMultipleClientAccessL()
+	{
+	CActiveScheduler::Install(new(ELeave)CActiveScheduler);
+	CleanupStack::PushL(CActiveScheduler::Current());
+
+	RFs fs;
+	TTEST2(fs.Connect(), KErrNone);
+	CleanupClosePushL(fs);
+	
+	CLogClient* client = CLogClient::NewL(fs);
+	CleanupStack::PushL(client);
+
+	TBuf8<500> buf;
+
+	TInt count = 10;
+	while(count--)
+		{
+		DoTestLogL(*client);
+		}
+
+	CleanupStack::PopAndDestroy(3); // fs, client, CActiveScheduler
+	}
+
+void DoThreadDieL()
+	{
+	CActiveScheduler::Install(new(ELeave)CActiveScheduler);
+	CleanupStack::PushL(CActiveScheduler::Current());
+
+	RFs fs;
+	TTEST2(fs.Connect(), KErrNone);
+	CleanupClosePushL(fs);
+
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	const TInt KLogClientCnt = 10;
+	for(TInt i=0;i<KLogClientCnt;i++)
+		{
+		CLogClient* client = CLogClient::NewL(fs);
+		event->SetId(i);
+		TRequestStatus status;
+		client->GetEvent(*event, status);
+		}
+	
+	User::After(100000);
+
+	RThread thread;
+	thread.Kill(KErrGeneral);
+	}
+
+static TInt DoDyingThreadStart(TAny*)
+	{
+	CTrapCleanup* cleanup = CTrapCleanup::New();
+	TTEST(cleanup != NULL);
+	TRAPD(err, DoThreadDieL());		
+	delete cleanup;
+	if(err != KErrNone)
+		{
+		RDebug::Print(_L("*** DoThreadDieL() failed with err %d\r\n"), err);
+		User::Panic(_L("ThrChk4"), 4);
+		}
+	return err;
+	}
+
+static TInt DoThreadStart(TAny* aThreadNumber)
+	{
+	TInt thrNum = (TInt)aThreadNumber;
+	CTrapCleanup* cleanup = CTrapCleanup::New();
+	TTEST(cleanup != NULL);
+	TRAPD(err, DoTestMultipleClientAccessL());		
+	delete cleanup;
+	if(err != KErrNone)
+		{
+		RDebug::Print(_L("*** Thread %d failed with err %d\r\n"), thrNum, err);
+		User::Panic(_L("ThrChk3"), 3);
+		}
+	return err;
+	}
+
+const TInt KTestThreadCount = 20;
+const TInt KMinTestHeapSize = 0x10000;
+const TInt KMaxTestHeapSize = 0x100000;
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0846
+@SYMTestCaseDesc	    Thread invoking test
+@SYMTestPriority 	    High
+@SYMTestActions  	    Create a new thread,check for no errors,register for notification of status when the thread dies
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestThreadDieL()
+	{
+	RThread thread;
+	TRequestStatus status;
+
+	TName name;
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0846 "));
+	_LIT(KThreadName, "Test thread");
+	name.Format(KThreadName);
+
+	TInt err = thread.Create(name, DoDyingThreadStart, KDefaultStackSize, KMinTestHeapSize, KMaxTestHeapSize, NULL, EOwnerThread);
+	// Create the thread
+	TEST2(err, KErrNone);
+	thread.Logon(status);
+
+	// Let the thread run
+	thread.Resume();
+
+	User::WaitForRequest(status);
+	TEST2(thread.ExitType(), EExitKill);
+	thread.Close();
+	TEST2(status.Int(), KErrGeneral);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0847
+@SYMTestCaseDesc	    Multiple client access test
+@SYMTestPriority 	    High
+@SYMTestActions  	    Create threads,request for notification of thread death.
+                        Resume and stop all the threads executions.Check for no errors.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestMultipleClientAccessL()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0847 "));
+	RThread threadArray[KTestThreadCount];
+	TRequestStatus statusArray[KTestThreadCount];
+
+	// Create the threads
+	TInt count = KTestThreadCount;
+	while(count--)
+		{
+		TName name;
+		_LIT(KThreadName, "TmcaTh%d");
+		name.Format(KThreadName, count);
+
+		// Create the thread
+		TInt err = threadArray[count].Create(name, DoThreadStart, KDefaultStackSize, KMinTestHeapSize, KMaxTestHeapSize, (TAny*) count, EOwnerThread);
+		TEST2(err, KErrNone);
+		threadArray[count].Logon(statusArray[count]);
+		}
+
+	// Let the thread run
+	count = KTestThreadCount;
+	while(count--)
+		{
+		RDebug::Print(_L("   ** Resume thread %d\r\n"), count);
+		threadArray[count].Resume();
+		}
+
+	RDebug::Print(_L("   ** Waiting threads to complete....\r\n"));
+	
+	// Wait for all the threads to complete
+	count = KTestThreadCount;
+	while(count--)
+		{
+		User::WaitForRequest(statusArray[count]);
+		RDebug::Print(_L("   ** Thread %d completed\r\n"), count);
+		TEST(threadArray[count].ExitType() != EExitPanic);
+		threadArray[count].Close();
+		}
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0848
+@SYMTestCaseDesc	    Test for checking notification of status
+@SYMTestPriority 	    High
+@SYMTestActions  	    Call up add - get - change - delete event type.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestNoNotifierL()
+	{
+	TestUtils::DeleteDatabaseL();
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0848 "));
+	RDebug::Print(_L("TestNoNotifierL - begin\n"));
+
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+
+	CTestActive* active = new(ELeave)CTestActive;
+	CleanupStack::PushL(active);
+	
+	RDebug::Print(_L("TestAddEventTypeL\n"));
+	TestAddEventTypeL(*client);
+
+	RDebug::Print(_L("TestGetEventTypeL\n"));
+	TestGetEventTypeL(*client);
+
+	RDebug::Print(_L("TestChangeEventTypeL\n"));
+	TestChangeEventTypeL(*client);
+
+	RDebug::Print(_L("TestDeleteEventTypeL\n"));
+	TestDeleteEventTypeL(*client);
+
+	RDebug::Print(_L("TestAddEventL\n"));
+	TestAddEventL(*client);
+
+	RDebug::Print(_L("TestGetEventL\n"));
+	TestGetEventL(*client);
+
+	RDebug::Print(_L("TestChangeEventL\n"));
+	TestChangeEventL(*client);
+
+	RDebug::Print(_L("TestDeleteEventL\n"));
+	TestDeleteEventL(*client);
+
+	RDebug::Print(_L("TestGetConfigL\n"));
+	TestGetConfigL(*client);
+
+	RDebug::Print(_L("TestChangeConfigL\n"));
+	TestChangeConfigL(*client);
+
+	RDebug::Print(_L("TestGetStringL\n"));
+	TestGetStringL(*client);
+
+	RDebug::Print(_L("TestClearEventLogL\n"));
+	TestClearEventLogL(*client);
+
+	CleanupStack::PopAndDestroy(2); // active, client
+	RDebug::Print(_L("TestNoNotifierL - end\n"));
+	}
+
+/**
+@SYMTestCaseID          PDS-LOGENG-CT-4016
+@SYMTestCaseDesc	    Tests for CLogChangeDefinition public APIs
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for CLogChangeDefinition::Find() functions, and different NewL() functions.
+@SYMTestExpectedResults CLogChangeDefinition object need to be created propertly. Find() functions
+						need to return proper items from list.
+@SYMDEF                 DEF135499
+*/
+LOCAL_C void TestLogChangeDefinitionL(CLogClient& aClient)
+	{
+	test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-CT-4016"));
+	TestUtils::DeleteDatabaseL();
+
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	CLogFilter* filter = CLogFilter::NewL();
+	CleanupStack::PushL(filter);
+	filter->SetContact(KTestContact);
+	filter->SetEventType(KLogPacketDataEventTypeUid);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogViewChangeObserver* changeObs = CLogViewChangeObserver::NewLC();
+	changeObs->SetActive();
+
+	CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs);
+	CleanupStack::PushL(view);
+
+	// Incoming
+	TBuf<KLogMaxDirectionLength> buf;
+	aClient.GetString(buf, R_LOG_DIR_IN);
+
+	event->SetEventType(KLogPacketDataEventTypeUid);
+	event->SetDirection(buf);
+	event->SetContact(KTestContact);
+	
+	active->StartL();
+	aClient.AddEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	User::After(1 * 1000000);
+	
+	TEST2(view->CountL(), 0);
+	active->StartL();
+	TBool res = view->SetFilterL(*filter, active->iStatus);
+	TEST(res);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	TEST2(view->CountL(), 1);
+	
+	// Transients
+	TInt changeCount;
+	TLogId logId;
+	TInt viewIndex;
+	TLogDatabaseChangeType type;
+	
+	for(TInt count = 0; count < KTestEventNum; count++)
+		{
+		active->StartL();
+		aClient.AddEvent(*event, active->iStatus);
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+		User::After(1 * 1000000);
+		}
+
+	const CLogChangeDefinition& changes = changeObs->Changes();
+
+	changeCount = changes.Count();
+	RDebug::Print(_L("Change Count: %d\n"), changeCount);
+	TEST2(changeCount, KTestEventNum);
+	for(TInt i=0; i<changeCount; i++)
+		{
+		type = changes.At(i, logId, viewIndex);
+		RDebug::Print(_L("Change Type: %d, logId: %d, viewIndex: %d\n"), type, logId, viewIndex);
+		TEST(changes.Find(logId)==i);
+		TEST(changes.Find(logId, ELogChangeTypeEventAdded)>=0);
+		TEST(changes.Find(TLogId(100000000), ELogChangeTypeEventAdded)==KErrNotFound);
+		TEST(changes.Find(logId, ELogChangeTypeLogCleared)==KErrNotFound);
+		TEST(changes.FindByViewIndex(viewIndex)>=0);
+		TEST(changes.Find(TLogId(100000000))==KErrNotFound);
+		}
+	
+	CBufFlat* buffer = CBufFlat::NewL(10*1024);
+	CleanupStack::PushL(buffer);
+	RBufWriteStream wstr(*buffer,0);
+	wstr << changes;
+	wstr.CommitL();
+	wstr.Close();
+	RBufReadStream rstr(*buffer,0);
+	CLogChangeDefinition* changes2 = CLogChangeDefinition::NewL(rstr);
+	CleanupStack::PushL(changes2);
+	rstr.Close();
+	
+	TEST(changes.Count()==changes2->Count());
+
+	CleanupStack::PopAndDestroy(3); // changes2, buffer, view
+	
+	// Check the change was as expected
+	TEST2(changes.Count(), 10);
+	type = changes.At(0, logId, viewIndex);
+
+	CleanupStack::PopAndDestroy(4, event); // changeObs, active, filter, event
+	
+	TEST2(type, ELogChangeTypeEventAdded);
+	TEST2(viewIndex, 0); // first (newest) events in the view
+
+	const TLogId expectedLogId = ((TLogId) 1);
+	TEST2(logId, expectedLogId);
+	}
+
+void DoStartL()
+	{
+	CActiveScheduler::Install(new(ELeave)CActiveScheduler);
+	RFs fs;
+	LEAVE_IF_ERROR(fs.Connect());
+	CleanupClosePushL(fs);
+	CLogClient* client = CLogClient::NewL(fs);
+	delete client;
+	CleanupStack::PopAndDestroy(&fs);
+	delete CActiveScheduler::Current();
+	}
+
+static TInt LaunchThread(TAny* /*aAny*/)
+	{
+	__UHEAP_MARK;
+	CTrapCleanup* cleanup = CTrapCleanup::New();
+	TRAPD(err, DoStartL());		
+	delete cleanup;	
+	__UHEAP_MARKEND;
+	if(err != KErrNone)
+		{
+		RDebug::Print(_L("*** DoStartL() failed with err %d\r\n"), err);
+		User::Panic(_L("ThrChk5"), 5);
+		}
+	return KErrNone;
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0849
+@SYMTestCaseDesc	    Tests for creation of two simultaneous threads
+@SYMTestPriority 	    High
+@SYMTestActions  	    Create two threads,start and close the threads 
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestStartupL()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0849 "));
+	RThread thread1;
+	RThread thread2;
+
+	// Create the threads
+	LEAVE_IF_ERROR(thread1.Create(_L("Thread1"), LaunchThread, KDefaultStackSize, KMinHeapSize , KMinHeapSize , NULL));
+	LEAVE_IF_ERROR(thread2.Create(_L("Thread2"), LaunchThread, KDefaultStackSize, KMinHeapSize , KMinHeapSize, NULL));
+
+	// Let them run
+	TRequestStatus s1;
+	thread1.Logon(s1);
+	thread1.Resume();
+	
+	TRequestStatus s2;
+	thread2.Logon(s2);
+	thread2.Resume();
+
+	User::WaitForRequest(s1);
+	TEST(thread1.ExitType() != EExitPanic);
+	thread1.Close();
+	
+	User::WaitForRequest(s2);
+	TEST(thread2.ExitType() != EExitPanic);
+	thread2.Close();
+	
+	TEST2(s1.Int(), KErrNone);
+	TEST2(s2.Int(), KErrNone);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0850
+@SYMTestCaseDesc	    Tests for invalid database scheme 
+@SYMTestPriority 	    High
+@SYMTestActions  	    Create a log event implementation,should leave if there is a problem
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestInvalidSchemaL()
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0850 "));
+	TestUtils::TestInvalidSchemaL();
+	}
+
+void doTestsL()
+	{
+	TestUtils::Initialize(_L("T_LOGAPI"));
+	
+	// This test should be first to ensure no clients kicking around
+	test.Next(_L("Invalid database scheme"));
+	TestInvalidSchemaL();
+	theLog.Write(_L8("Test 0 OK\n"));
+
+	test.Start(_L("Simultaneous Startup"));
+	TestStartupL();
+	theLog.Write(_L8("Test 1 OK\n"));
+
+	CLogChangeNotifier* notifier = CLogChangeNotifier::NewL();
+	CleanupStack::PushL(notifier);
+
+	test.Next(_L("Dying thread test"));
+	TestThreadDieL();
+	theLog.Write(_L8("Test 2 OK\n"));
+	
+	TestUtils::DeleteDatabaseL();
+
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+
+	CTestActive* active = new(ELeave) CTestActive(CActive::EPriorityIdle - 500);
+	CleanupStack::PushL(active);
+	
+	test.Next(_L("Additional tests on CLogChangeDefinition."));
+	TestLogChangeDefinitionL(*client);
+	theLog.Write(_L8("Test 2.1 OK\n"));
+	TestUtils::DeleteDatabaseL();
+	
+	test.Next(_L("Client death"));
+	TestClientFailL();
+	theLog.Write(_L8("Test 3 OK\n"));
+
+	test.Next(_L("Testing client API"));
+	TestNoNotifierL();
+	theLog.Write(_L8("Test 4 OK\n"));
+
+	// Delay for testing change notification
+	TInt delay = 5000000;	
+	User::After(delay);	
+
+
+	active->StartL();
+	client->NotifyChange(delay, active->iStatus);
+
+	test.Next(_L("Delete Event Type"));
+	TestDeleteEventTypeL(*client);
+	theLog.Write(_L8("Test 5 OK\n"));
+
+	CActiveScheduler::Start();
+	TEST(active->iStatus.Int() >= 0);
+
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0834 Add Event Type "));
+	TestAddEventTypeL(*client);
+	theLog.Write(_L8("Test 6 OK\n"));
+
+	// Must delete the database before testing
+	// the notification API, since we just created the
+	// entry in the previous test (6) and therefore
+	// attempting to add the entry again just results in
+	// KErrAlreadyExists and does not cause a change to the
+	// database.
+	TestUtils::DeleteDatabaseL();
+
+	active->StartL();
+	client->NotifyChange(delay, active->iStatus);
+
+	TestAddEventTypeL(*client);
+
+	CActiveScheduler::Start();
+	TEST(active->iStatus.Int() >= 0);
+	active->StartL();
+	client->NotifyChange(delay, active->iStatus);
+
+	// The following doesn't make any changes
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0835 Get Event Type "));
+	TestGetEventTypeL(*client);
+	theLog.Write(_L8("Test 7 OK\n"));
+
+	test.Next(_L("Change Event Type"));
+	TestChangeEventTypeL(*client);
+	theLog.Write(_L8("Test 8 OK\n"));
+
+	CActiveScheduler::Start();
+	TEST(active->iStatus.Int() >= 0);
+	active->StartL();
+	client->NotifyChange(delay, active->iStatus);
+
+	test.Next(_L("Delete Event Type"));
+	TestDeleteEventTypeL(*client);
+	theLog.Write(_L8("Test 9 OK\n"));
+
+	CActiveScheduler::Start();
+	TEST(active->iStatus.Int() >= 0);
+	active->StartL();
+	client->NotifyChange(delay, active->iStatus);
+
+	test.Next(_L("Add Event"));
+	TestAddEventL(*client);
+	theLog.Write(_L8("Test 10 OK\n"));
+
+	CActiveScheduler::Start();
+	TEST(active->iStatus.Int() >= 0);
+	active->StartL();
+	client->NotifyChange(delay, active->iStatus);
+
+	// The following doesn't make any changes
+	test.Next(_L("Get Event"));
+	TestGetEventL(*client);
+	theLog.Write(_L8("Test 11 OK\n"));
+
+	test.Next(_L("Change Event"));
+	TestChangeEventL(*client);
+	theLog.Write(_L8("Test 12 OK\n"));
+
+	CActiveScheduler::Start();
+	TEST(active->iStatus.Int() >= 0);
+	active->StartL();
+	client->NotifyChange(delay, active->iStatus);
+
+	test.Next(_L("Delete Event"));
+	TestDeleteEventL(*client);
+	theLog.Write(_L8("Test 13 OK\n"));
+
+	CActiveScheduler::Start();
+	TEST(active->iStatus.Int() >= 0);
+	active->StartL();
+	client->NotifyChange(delay, active->iStatus);
+
+	// The following doesn't make any changes
+	test.Next(_L("Get Config"));
+	TestGetConfigL(*client);
+	theLog.Write(_L8("Test 14 OK\n"));
+
+	test.Next(_L("Change Config"));
+	TestChangeConfigL(*client);
+	theLog.Write(_L8("Test 15 OK\n"));
+
+	CActiveScheduler::Start();
+	TEST(active->iStatus.Int() >= 0);
+	active->StartL();
+	client->NotifyChange(delay*3, active->iStatus);
+
+	// The following doesn't make any changes
+	test.Next(_L("Get String"));
+	TestGetStringL(*client);
+	theLog.Write(_L8("Test 16 OK\n"));
+
+	test.Next(_L("Clear Event Log"));
+	TestClearEventLogL(*client);
+	theLog.Write(_L8("Test 17 OK\n"));
+
+	CActiveScheduler::Start();
+	TEST(active->iStatus.Int() >= 0);
+	active->StartL();
+	client->NotifyChange(delay, active->iStatus);
+
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0833 Test global change API "));
+	TestClientObserverMechanismL(*client);
+	theLog.Write(_L8("Test 18 OK\n"));
+
+	test.Next(_L("Multiple client access"));
+	TestMultipleClientAccessL();
+	theLog.Write(_L8("Test 19 OK\n"));
+	
+	theLog.Write(_L8("Destroying: active\n"));
+	CleanupStack::PopAndDestroy(active);
+	theLog.Write(_L8("Destroyed ok\n"));
+	theLog.Write(_L8("Destroying: client\n"));
+	CleanupStack::PopAndDestroy(client);
+	theLog.Write(_L8("Destroyed ok\n"));
+	theLog.Write(_L8("Destroying: notifier\n"));
+	CleanupStack::PopAndDestroy(notifier);
+	theLog.Write(_L8("Destroyed ok\n"));
+
+
+#ifdef SYSLIBS_TEST		
+	theLog.Write(_L8("Preparing the context for the test : @SYMTestCaseID:SYSLIB-LOGENG-UT-4015... \n"));
+	theLog.Write(_L8("Deleting the Log engine database... \n"));	
+	TestUtils::DeleteDatabaseL();
+	theLog.Write(_L8("Allocating a new CLogClient object... \n"));
+	CLogClient* theClient = CLogClient::NewL(theFs);
+	CleanupStack::PushL(theClient);	
+	test.Next(_L("TestGetConfigSettingsFromRepositoryFileL () "));
+	TestGetConfigSettingsFromRepositoryFileL(*theClient);
+	theLog.Write(_L8("TestGetConfigSettingsFromRepositoryFileL () OK\n"));
+	theLog.Write(_L8("Destroying the CLogClient object... \n"));	
+	CleanupStack::PopAndDestroy(theClient);
+	theLog.Write(_L8("Destroyed ok\n"));
+#else
+	theLog.Write(_L8("The Test PREQ2103 works only when SYSLIBS_TEST macro is defined"));
+#endif
+	}