diff -r 000000000000 -r 08ec8eefde2f loggingservices/eventlogger/test/src/t_logpurge.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/loggingservices/eventlogger/test/src/t_logpurge.cpp	Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,1309 @@
+// Copyright (c) 2003-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 "TEST.H"
+#include <logview.h>
+
+#undef test  //there is a "test" macro which hides "RTest test" declaration.
+
+RTest test(_L("Log Purge Test Harness"));
+
+const TInt KTestEventNum = 10;
+const TInt KTestEventAge = 5;
+const TInt KTestRecentNum = 10;
+const TInt KTestDuplicateNum = 10;
+
+_LIT(KTestRemoteParty, "Test Remote Party %d");
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0875
+@SYMTestCaseDesc	    Tests for maximum logging of configuration data 
+@SYMTestPriority 	    High
+@SYMTestActions  	    Get the event type configuration data.Set the log size to maximum.
+                        Change the log engine configuration data with the new one.Add events to the log
+                        Set the filter on the view and check for KErrNone flag.
+						Add a new event and disable logging by setting the maximum logging size to zero
+						Clear all the events and test for KErrNone and the total count of events.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestMaxLogSizeL(CLogClient& aClient)
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0875 "));
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+	event->SetEventType(KLogCallEventTypeUid);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogViewEvent* view = CLogViewEvent::NewL(aClient);
+	CleanupStack::PushL(view);
+
+	CLogFilter* filter = CLogFilter::NewL();
+	CleanupStack::PushL(filter);
+
+	TLogConfig config;
+
+	// Get log configuration
+	active->StartL();
+	aClient.GetConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Set the maximum log size
+	config.iMaxLogSize = KTestEventNum;
+
+	// Change the log engine config
+	active->StartL();
+	aClient.ChangeConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Initialise the view - There should be no events
+	TEST(!view->SetFilterL(*filter, active->iStatus));
+
+	// Add the number of allowed events
+	TInt count;
+	for(count = 0; count < KTestEventNum; count++)
+		{
+		active->StartL();
+		aClient.AddEvent(*event, active->iStatus);
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+		}
+
+	TEST(view->SetFilterL(*filter, active->iStatus));
+	active->StartL();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// The view should now have the correct number of events
+	TEST(view->CountL() == KTestEventNum);
+
+	// Add the same number of events again - the old ones should be deleted
+	for(count = 0; count < KTestEventNum; count++)
+		{
+		TEST(view->SetFilterL(*filter, active->iStatus));
+		active->StartL();
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+
+		// Get the last (oldest) event
+		active->StartL();
+		view->LastL(active->iStatus);
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+
+		// Remember the Id
+		TLogId id = view->Event().Id();
+
+		// Add another event - the oldest should be removed
+		active->StartL();
+		aClient.AddEvent(*event, active->iStatus);
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+
+		// There should be the same number of events in view
+		TEST(view->CountL() == KTestEventNum);
+		
+		event->SetId(id);
+
+		// Try and get the old event
+		active->StartL();
+		aClient.GetEvent(*event, active->iStatus);
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNotFound);
+		}
+
+	// Add an event
+	active->StartL();
+	aClient.AddEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Check it's there
+	active->StartL();
+	aClient.GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Set the maximum log size to zero, i.e. disable logging
+	config.iMaxLogSize = 0;
+
+	// Change the log engine config
+	active->StartL();
+	aClient.ChangeConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Check the event has gone
+	active->StartL();
+	aClient.GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);;
+
+	// Add an event
+	active->StartL();
+	aClient.AddEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotSupported);
+
+	// Check that event doesn't exist
+	active->StartL();
+	aClient.GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);;
+
+	User::After(1000000);
+
+	TTime now;
+	now.UniversalTime();
+	now+=(TTimeIntervalDays) 1;
+	// Clear all the events
+	active->StartL();
+	aClient.ClearLog(now, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(!view->SetFilterL(*filter, active->iStatus));
+	TEST(view->CountL() == 0);
+
+	CleanupStack::PopAndDestroy(4); // filter, view, active, event
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0876
+@SYMTestCaseDesc	    Tests for maximum logging of configuration data 
+@SYMTestPriority 	    High
+@SYMTestActions  	    Get the event type configuration data.Set the log size to maximum.
+                        Change the log engine configuration data and add the number of allowed events
+                        Reduce the number of allowed events.The old ones should be purged
+						Change the log engine config and check for the event count.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestMaxLogSizeConfigL(CLogClient& aClient)
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0876 "));
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+	event->SetEventType(KLogCallEventTypeUid);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogViewEvent* view = CLogViewEvent::NewL(aClient);
+	CleanupStack::PushL(view);
+
+	CLogFilter* filter = CLogFilter::NewL();
+	CleanupStack::PushL(filter);
+
+	TLogConfig config;
+
+	// Get log configuration
+	active->StartL();
+	aClient.GetConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Set the maximum log size
+	config.iMaxLogSize = KTestEventNum;
+
+	// Change the log engine config
+	active->StartL();
+	aClient.ChangeConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Initialise the view - There should be no events
+	TEST(!view->SetFilterL(*filter, active->iStatus));
+
+	// Add the number of allowed events
+	TInt count;
+	for(count = 0; count < KTestEventNum; count++)
+		{
+		active->StartL();
+		aClient.AddEvent(*event, active->iStatus);
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+		}
+
+	TEST(view->SetFilterL(*filter, active->iStatus));
+	active->StartL();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// The view should now have the correct number of events
+	TEST(view->CountL() == KTestEventNum);
+
+	// Reduce the number of allowed events
+	// The old ones should be purged
+	config.iMaxLogSize = KTestEventNum / 2;
+
+	// Change the log engine config
+	active->StartL();
+	aClient.ChangeConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Check the event count
+	TEST(view->SetFilterL(*filter, active->iStatus));
+	active->StartL();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	TEST(view->CountL() == KTestEventNum / 2);
+		
+	User::After(0x1000000);
+
+	TTime now;
+	now.UniversalTime();
+	now+=(TTimeIntervalDays )1;
+	// Clear all the events
+	active->StartL();
+	aClient.ClearLog(now, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(!view->SetFilterL(*filter, active->iStatus));
+	TEST(view->CountL() == 0);
+
+	CleanupStack::PopAndDestroy(4); // filter, view, active, event
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0877
+@SYMTestCaseDesc	    Tests for maximum time for which events can be retained in the log
+@SYMTestPriority 	    High
+@SYMTestActions  	    Get the event type configuration data.Set maximum log age.
+                        Change the log engine configuration data with the new one.Add events to the log
+                        Set the date and time of events clear the log and check for errors
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestMaxLogAgeL(CLogClient& aClient, TLogAge aMaxLogAge)
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0877 "));
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+	event->SetEventType(KLogCallEventTypeUid);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogViewEvent* view = CLogViewEvent::NewL(aClient);
+	CleanupStack::PushL(view);
+
+	CLogFilter* filter = CLogFilter::NewL();
+	CleanupStack::PushL(filter);
+
+	TLogConfig config;
+
+	// Get log configuration
+	active->StartL();
+	aClient.GetConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Set the maximum log age
+	config.iMaxLogSize = KTestEventAge * 2;
+	config.iMaxEventAge = aMaxLogAge;
+
+	// Change the log engine config
+	active->StartL();
+	aClient.ChangeConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Initialise the view - There should be no events
+	TEST(!view->SetFilterL(*filter, active->iStatus));
+
+	TTime date;
+	date.UniversalTime();
+
+	// Wait a second
+	User::After(0x1000000);
+
+	// Add events
+	TInt count;
+	for(count = 0; count < KTestEventAge * 2; count++)
+		{
+		active->StartL();
+		aClient.AddEvent(*event, active->iStatus);
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+
+		// Set the time and date of the event
+		event->SetTime(date);
+		date -= TTimeIntervalDays(1);
+
+		active->StartL();
+		aClient.ChangeEvent(*event, active->iStatus);
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+		User::After(1000000);
+
+		TEST(view->SetFilterL(*filter, active->iStatus));
+		active->StartL();
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+
+		// Check the old events have been removed
+		if ((count < KTestEventAge) || !aMaxLogAge)
+			TEST(view->CountL() == count + 1);
+		else
+			TEST(view->CountL() == KTestEventAge);
+		}
+
+	User::After(0x1000000);
+	date.UniversalTime();
+
+	date+=(TTimeIntervalYears )1;
+
+	// Clear all the events
+	active->StartL();
+	aClient.ClearLog(date, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(!view->SetFilterL(*filter, active->iStatus));
+	TEST(view->CountL() == 0);
+
+	CleanupStack::PopAndDestroy(4); // filter, view, active, event
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0878
+@SYMTestCaseDesc	    Tests for maximum number of events that a recent event list holds
+@SYMTestPriority 	    High
+@SYMTestActions  	    Set the event configuration data of recent log size(10) to maximum and 
+						Add events to the log.Set the filter on the view and check for NO error.
+						Add a new event and disable logging by setting the maximum logging size to zero
+						Clear all the events and test for no errors and the total count of events and the logviewrecent should be zero.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestMaxRecentSize1L(CLogClient& aClient)
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0878 "));
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	// Incoming
+	TBuf<KLogMaxDirectionLength> buf;
+	aClient.GetString(buf, R_LOG_DIR_IN);
+
+	event->SetEventType(KLogCallEventTypeUid);
+	event->SetDirection(buf);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogViewEvent* view = CLogViewEvent::NewL(aClient);
+	CleanupStack::PushL(view);
+
+	CLogViewRecent* recent = CLogViewRecent::NewL(aClient);
+	CleanupStack::PushL(recent);
+
+	CLogFilter* filter = CLogFilter::NewL();
+	CleanupStack::PushL(filter);
+
+	TLogConfig config;
+
+	// Get log configuration
+	active->StartL();
+	aClient.GetConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Set the maximum log size
+	config.iMaxLogSize = KTestRecentNum * 2;
+	config.iMaxRecentLogSize = KTestRecentNum;
+
+	// Change the log engine config
+	active->StartL();
+	aClient.ChangeConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Initialise the views - There should be no events
+	TEST(!view->SetFilterL(*filter, active->iStatus));
+	TEST(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
+
+	// Add a number of events
+	TInt count;
+	for(count = 0; count < KTestRecentNum; count++)
+		{
+		event->SetContact(count);
+
+		active->StartL();
+		aClient.AddEvent(*event, active->iStatus);
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+		}
+
+	TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
+	active->StartL();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(recent->CountL() == KTestRecentNum);
+
+	// Add the same number of events again - the old ones should be removed
+	for(count = 0; count < KTestRecentNum; count++)
+		{
+		// Add another event - the oldest should be removed from recent list
+		active->StartL();
+		aClient.AddEvent(*event, active->iStatus);
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+
+		TEST(view->SetFilterL(*filter, active->iStatus));
+		active->StartL();
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+
+		TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
+		active->StartL();
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+
+		// Check an event has been removed from recent view
+		TEST(recent->CountL() == KTestRecentNum);
+		TEST(view->CountL() == count + KTestRecentNum + 1);
+		}
+
+	User::After(0x1000000);
+
+	TTime now;
+	now.UniversalTime();
+	now+=(TTimeIntervalDays )1;
+
+	// Clear all the events
+	active->StartL();
+	aClient.ClearLog(now, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(!view->SetFilterL(*filter, active->iStatus));
+	TEST(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
+	TEST(view->CountL() == 0 && recent->CountL() == 0);
+
+	CleanupStack::PopAndDestroy(5); // filter, recent, view, active, event
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0879
+@SYMTestCaseDesc	    Tests for maximum number of events that a recent event list holds
+@SYMTestPriority 	    High
+@SYMTestActions  	    Set the event configuration data of recent log size(10) to maximum and 
+						Add events to the log.Set the filter on the view and check for NO error.
+	                    Reduce the recent log size(5)  and set the new configuration.
+						Clear all the events and test for no errors and the total count of events and the logviewrecent should be zero.
+						Tests for CLogViewRecent::SetRecentListL
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestMaxRecentSizeConfigL(CLogClient& aClient)
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0879 "));
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	// Incoming
+	TBuf<KLogMaxDirectionLength> buf;
+	aClient.GetString(buf, R_LOG_DIR_IN);
+
+	event->SetEventType(KLogCallEventTypeUid);
+	event->SetDirection(buf);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogViewRecent* recent = CLogViewRecent::NewL(aClient);
+	CleanupStack::PushL(recent);
+
+	TLogConfig config;
+
+	// Get log configuration
+	active->StartL();
+	aClient.GetConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Set the maximum log size
+	config.iMaxLogSize = KTestRecentNum * 2;
+	config.iMaxRecentLogSize = KTestRecentNum;
+
+	// Change the log engine config
+	active->StartL();
+	aClient.ChangeConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Initialise the views - There should be no events
+	TEST(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
+
+	// Add a number of events
+	TInt count;
+	for(count = 0; count < KTestRecentNum; count++)
+		{
+		event->SetContact(count);
+
+		active->StartL();
+		aClient.AddEvent(*event, active->iStatus);
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+		}
+
+	TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
+	active->StartL();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(recent->CountL() == KTestRecentNum);
+
+	// Reduce the maximum allowed recent list size
+	// The oldest ones should be removed
+	config.iMaxRecentLogSize = KTestRecentNum / 2;
+
+	active->StartL();
+	aClient.ChangeConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
+	active->StartL();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(recent->CountL() == KTestRecentNum / 2);
+	User::After(0x1000000);
+
+	TTime now;
+	now.UniversalTime();
+	now+=(TTimeIntervalDays )1;
+
+	// Clear all the events
+	active->StartL();
+	aClient.ClearLog(now, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
+	TEST(recent->CountL() == 0);
+
+	CleanupStack::PopAndDestroy(3); // recent, active, event
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0880
+@SYMTestCaseDesc	    Tests for CLogViewRecent::SetRecentListL(),CLogViewRecent::DuplicatesL() functions
+@SYMTestPriority 	    High
+@SYMTestActions  	    Set the event configuration data of recent log size(10) to maximum and 
+						Add events to the log.Set the filter on the view and check for NO error.
+	                    Reduce the recent log size(5)  and set the new configuration.
+						Clear all the events and test for no errors and the total count of events and the logviewrecent should be zero.
+						Tests for CLogViewRecent::SetRecentListL()
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestMaxRecentSize2L(CLogClient& aClient)
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0880 "));
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	// Incoming
+	TBuf<KLogMaxDirectionLength> buf;
+	aClient.GetString(buf, R_LOG_DIR_IN);
+
+	event->SetEventType(KLogCallEventTypeUid);
+	event->SetDirection(buf);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogViewRecent* recent = CLogViewRecent::NewL(aClient);
+	CleanupStack::PushL(recent);
+
+	CLogViewDuplicate* dup = CLogViewDuplicate::NewL(aClient);
+	CleanupStack::PushL(dup);
+
+	CLogFilter* filter = CLogFilter::NewL();
+	CleanupStack::PushL(filter);
+
+	TLogConfig config;
+
+	// Get log configuration
+	active->StartL();
+	aClient.GetConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Set the maximum log size
+	config.iMaxLogSize = (KTestRecentNum * KTestDuplicateNum) * 2;
+	config.iMaxRecentLogSize = KTestRecentNum;
+
+	// Change the log engine config
+	active->StartL();
+	aClient.ChangeConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Initialise the view - There should be no events
+	TEST(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
+
+	// Add a number of events
+	TInt count;
+	for(count = 0; count < KTestRecentNum; count++)
+		{
+		TBuf<KLogMaxRemotePartyLength> buf;
+		buf.Format(KTestRemoteParty, count);
+		event->SetRemoteParty(buf);
+
+		active->StartL();
+		aClient.AddEvent(*event, active->iStatus);
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+
+		// Add some duplicates
+		TInt duplicate;
+		for(duplicate = 0; duplicate < KTestDuplicateNum; duplicate++)
+			{
+			active->StartL();
+			aClient.AddEvent(*event, active->iStatus);
+			CActiveScheduler::Start();
+			TEST2(active->iStatus.Int(), KErrNone);
+			}
+
+		// The views should now have the correct number of events
+		TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
+		active->StartL();
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+
+		TEST(recent->CountL() == count + 1);
+
+		TEST(recent->DuplicatesL(*dup, active->iStatus));
+		active->StartL();
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+
+		TEST(dup->CountL() == KTestDuplicateNum);
+		}
+
+	event->SetRemoteParty(KNullDesC);
+
+	// Add the more events - the old ones should be removed
+	for(count = 0; count < KTestRecentNum; count++)
+		{
+		// Add another event - the oldest should be removed from recent list
+		active->StartL();
+		aClient.AddEvent(*event, active->iStatus);
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+
+		TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));
+		active->StartL();
+		CActiveScheduler::Start();
+		TEST2(active->iStatus.Int(), KErrNone);
+
+		// Check an event has been removed from recent view
+		TEST(recent->CountL() == KTestRecentNum);
+		}
+
+	User::After(0x1000000);
+
+	TTime now;
+	now.UniversalTime();
+	now+=(TTimeIntervalDays )1;
+
+	// Clear all the events
+	active->StartL();
+	aClient.ClearLog(now, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	TEST(!recent->DuplicatesL(*dup, active->iStatus));
+
+	CleanupStack::PopAndDestroy(5); // filter, dup, recent, active, event
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0881
+@SYMTestCaseDesc	    Tests for purge
+@SYMTestPriority 	    High
+@SYMTestActions  	    Get the event type data 
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestNoPurgeWithGetL(CLogClient& aClient)
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0881 "));
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+	event->SetEventType(KLogCallEventTypeUid);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	TLogConfig config;
+
+	// Get log configuration
+	active->StartL();
+	aClient.GetConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Set the maximum log age
+	TInt oldAge = config.iMaxEventAge;
+	config.iMaxEventAge = 24 * 60 * 60;
+
+	// Change the log engine config
+	active->StartL();
+	aClient.ChangeConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	active->StartL();
+	aClient.AddEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Check that the event can be retrieved
+	active->StartL();
+	aClient.GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Wait for 15 seconds (just to be safe)
+	User::After(15000000);
+
+	// Check that the event can still be retrieved
+	active->StartL();
+	aClient.GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Perform a dummy change
+	event->SetTime(event->Time() - TTimeIntervalDays(2));
+	active->StartL();
+	aClient.ChangeEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// Check the event has been removed
+	active->StartL();
+	aClient.GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);;
+
+	// Reset the config
+	config.iMaxEventAge = oldAge;
+
+	// Change the log engine config
+	active->StartL();
+	aClient.ChangeConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	CleanupStack::PopAndDestroy(2); // active, event	
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0882
+@SYMTestCaseDesc	    Tests for CLogClient::ClearLog() function
+@SYMTestPriority 	    High
+@SYMTestActions  	    Change locale settings and log duration to 1 day and test for number of event types in log 
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestClearLog1L(CLogClient& aClient)
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0882 "));
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+	event->SetEventType(KLogCallEventTypeUid);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogViewEvent* view = CLogViewEvent::NewL(aClient);
+	CleanupStack::PushL(view);
+
+	// change Locale
+	TLocale locale;
+	locale.SetCountryCode(47);//Norway
+	locale.SetDateFormat(EDateEuropean);
+	locale.SetTimeFormat(ETime12);
+	for (int i=0; i<4; i++)
+         {
+         locale.SetTimeSeparator(TChar('.'),i);
+         locale.SetDateSeparator(TChar(':'),i);
+         }
+	locale.Set();
+
+	// change the log duration settings to 1 day  
+	TLogConfig config;
+	active->StartL();
+	aClient.GetConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	config.iMaxLogSize = KTestEventAge * 2;
+	config.iMaxEventAge = 86400;
+	active->StartL();
+	aClient.ChangeConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// add a call event
+	active->StartL();
+	aClient.AddEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	User::After(1000000);
+	TTime now;
+	now.HomeTime();	
+	event->SetTime(now);
+	active->StartL();
+	aClient.ChangeEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// forward two days
+	now+=(TTimeIntervalDays )2;
+	User::SetHomeTime(now);
+		
+	// dummy call ensures ClearLog() is called
+	active->StartL();
+	aClient.ChangeConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// try to retrieve event
+	active->StartL();
+	aClient.GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);;
+
+	TEST(view->CountL() == 0);
+
+	CleanupStack::PopAndDestroy(3); // view, active, event
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-0883
+@SYMTestCaseDesc	    Tests for CLogClient::ClearLog() function
+@SYMTestPriority 	    High
+@SYMTestActions  	    Change locale settings,call up ClearLog and try to retrieve event,test for count of number of events in the view.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestClearLog2L(CLogClient& aClient)
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0883 "));
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+	event->SetEventType(KLogCallEventTypeUid);
+
+	CTestActive* active = new(ELeave)CTestActive();
+	CleanupStack::PushL(active);
+
+	CLogViewEvent* view = CLogViewEvent::NewL(aClient);
+	CleanupStack::PushL(view);
+
+	// change Locale
+	TLocale locale;
+	locale.SetCountryCode(47);//Norway
+	locale.SetDateFormat(EDateEuropean);
+	locale.SetTimeFormat(ETime12);
+	for (int i=0; i<4; i++)
+         {
+         locale.SetTimeSeparator(TChar('.'),i);
+         locale.SetDateSeparator(TChar(':'),i);
+         }
+	locale.Set();
+
+	// change the log duration settings to 1 day  
+	TLogConfig config;
+	active->StartL();
+	aClient.GetConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	config.iMaxLogSize = KTestEventAge * 2;
+	config.iMaxEventAge = 86400;
+	active->StartL();
+	aClient.ChangeConfig(config, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// add a call event
+	active->StartL();
+	aClient.AddEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	User::After(1000000);
+	TTime now;
+	now.HomeTime();	
+	event->SetTime(now);
+	active->StartL();
+	aClient.ChangeEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// forward two days
+	now+=(TTimeIntervalDays )2;
+	User::SetHomeTime(now);
+		
+	active->StartL();
+	aClient.ClearLog(now, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	// try to retrieve event
+	active->StartL();
+	aClient.GetEvent(*event, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);;
+
+	TEST(view->CountL() == 0);
+
+	CleanupStack::PopAndDestroy(3); // view, active, event
+	}
+
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
+
+/**
+@SYMTestCaseID			PDS-LOGENG-UT-4036
+@SYMTestCaseDesc		Clear log events with specific SimId test.
+						The test adds 3 events with different SimIds and then checks that
+						CLogEvent::ClearLog() deletes only the event with the specified id.
+@SYMTestActions			Clear log events with specific SimId test.
+@SYMTestExpectedResults Test must not fail
+@SYMTestPriority		High
+@SYMREQ					REQ12748
+*/
+void ClearLogSimIdL(CLogClient& aClient)
+	{//This test case is compiled only when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM macro is defined.
+	const TSimId KSimId1 = 4100000000U;
+	const TSimId KSimId2 = 100;
+	const TSimId KSimId3 = 1678;
+	
+	TTime now;
+	now.UniversalTime();
+	
+	TDateTime dt(now.DateTime());
+	dt.SetHour(dt.Hour() - 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(KLogCallEventTypeUid);
+	event1->SetSimId(KSimId1);
+
+	active->StartL();
+	aClient.AddEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	event1->SetTime(date);
+
+	active->StartL();
+	aClient.ChangeEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	//////// Event2 ///////////////////////////
+	CLogEvent* event2 = CLogEvent::NewL();
+	CleanupStack::PushL(event2);
+	event2->SetEventType(KLogCallEventTypeUid);
+	event2->SetSimId(KSimId2);
+
+	active->StartL();
+	aClient.AddEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	event2->SetTime(date);
+
+	active->StartL();
+	aClient.ChangeEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	//////// Event3 ///////////////////////////
+	CLogEvent* event3 = CLogEvent::NewL();
+	CleanupStack::PushL(event3);
+	event3->SetEventType(KLogCallEventTypeUid);
+	event3->SetSimId(KSimId3);
+
+	active->StartL();
+	aClient.AddEvent(*event3, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+
+	event3->SetTime(date);
+
+	active->StartL();
+	aClient.ChangeEvent(*event3, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	
+	//////////////////////////////////////////////////////////////////////////////////////////////////
+	
+	//Delete event3 /////////////////////////
+	aClient.ClearLog(threshold, KSimId3, active->iStatus);
+	active->StartL();	
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	//Event1 and event2 should be there
+	active->StartL();
+	aClient.GetEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	active->StartL();
+	aClient.GetEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	active->StartL();
+	aClient.GetEvent(*event3, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+	
+	//Delete event2 /////////////////////////
+	aClient.ClearLog(threshold, KSimId2, active->iStatus);
+	active->StartL();	
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	//Event1 should be there
+	active->StartL();
+	aClient.GetEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	active->StartL();
+	aClient.GetEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+	active->StartL();
+	aClient.GetEvent(*event3, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+	
+	//Delete event1 /////////////////////////
+	aClient.ClearLog(threshold, KSimId1, active->iStatus);
+	active->StartL();	
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	//All events deleted
+	active->StartL();
+	aClient.GetEvent(*event1, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+	active->StartL();
+	aClient.GetEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+	active->StartL();
+	aClient.GetEvent(*event3, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNotFound);
+
+	CleanupStack::PopAndDestroy(4); //event3, event2, event1, active
+	}
+
+/**
+@SYMTestCaseID			PDS-LOGENG-UT-4037
+@SYMTestCaseDesc		Clear log events from a recent list with specific SimId test.
+						The test adds 3 events to a recent list with different SimIds and then checks that
+						CLogEvent::ClearLog() deletes only the event with the specified id.
+@SYMTestActions			Clear log events from a recent list with specific SimId test.
+@SYMTestExpectedResults Test must not fail
+@SYMTestPriority 	    High
+@SYMREQ					REQ12748
+*/
+void ClearLogRecentSimIdL(CLogClient& aClient)
+	{//This test case is compiled only when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM macro is defined.
+	const TSimId KSimId1 = 4200110000U;
+	const TSimId KSimId2 = 38223;
+	const TSimId KSimId3 = 239816;
+	
+	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"));
+	event1->SetSimId(KSimId1);
+	active->StartL();
+	aClient.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(KSimId2);
+	active->StartL();
+	aClient.AddEvent(*event2, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	//////// Event3 ///////////////////////////
+	CLogEvent* event3 = CLogEvent::NewL();
+	CleanupStack::PushL(event3);
+	event3->SetEventType(KEvTypeUid);
+	event3->SetDirection(KEvDirection);
+	event3->SetNumber(_L("99229922"));
+	event3->SetSimId(KSimId3);
+	active->StartL();
+	aClient.AddEvent(*event3, active->iStatus);
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	//////////////////////////////////////////////////////////////////////////////////////////////////
+	
+	//Delete event3 /////////////////////////
+	aClient.ClearLog(KLogRecentMissedCalls, KSimId3, active->iStatus);
+	active->StartL();	
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	//Event1 and event2 should be there
+	CLogViewRecent* view = CLogViewRecent::NewL(aClient);
+	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, 2);
+	rc = view->FirstL(active->iStatus);
+	TEST(rc);
+	active->StartL();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	const CLogEvent& e1 = view->Event();
+	TEST(e1.SimId() == KSimId2 || e1.SimId() == KSimId1);
+	rc = view->NextL(active->iStatus);
+	TEST(rc);
+	active->StartL();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	const CLogEvent& e2 = view->Event();
+	TEST(e2.SimId() == KSimId2 || e2.SimId() == KSimId1);
+	TEST(e1.Id() != e2.Id());
+
+	CleanupStack::PopAndDestroy(view);
+	
+	//Delete event1 /////////////////////////
+	aClient.ClearLog(KLogRecentMissedCalls, KSimId1, active->iStatus);
+	active->StartL();	
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	//Only event2 should be there
+	view = CLogViewRecent::NewL(aClient);
+	CleanupStack::PushL(view);
+	rc = view->SetRecentListL(KLogRecentMissedCalls, active->iStatus);
+	TEST(rc);
+	active->StartL();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	count = view->CountL();
+	TEST2(count, 1);
+	rc = view->FirstL(active->iStatus);
+	TEST(rc);
+	active->StartL();
+	CActiveScheduler::Start();
+	TEST2(active->iStatus.Int(), KErrNone);
+	const CLogEvent& e3 = view->Event();
+	TEST(e3.SimId() == KSimId2);
+
+	CleanupStack::PopAndDestroy(5); //view, event3, event2, event1, active
+	}
+
+#endif//SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
+
+void doTestsL()
+	{
+	TestUtils::Initialize(_L("T_LOGPURGE"));
+	TestUtils::DeleteDatabaseL();
+
+	CLogClient* client = CLogClient::NewL(theFs);
+	CleanupStack::PushL(client);
+
+	test.Start(_L("Maximum Log Size"));
+	TestMaxLogSizeL(*client);
+	theLog.Write(_L8("Test 1 OK\n"));
+
+	test.Next(_L("Purge Log When Config Changed"));
+	TestMaxLogSizeConfigL(*client);
+	theLog.Write(_L8("Test 2 OK\n"));
+
+	test.Next(_L("Test purge by Maximum Log Age enabled/disabled"));
+	TestMaxLogAgeL(*client, 0);	// disable purging by age
+	TestMaxLogAgeL(*client, KTestEventAge * 60 * 60 * 24);  
+	theLog.Write(_L8("Test 3 OK\n"));
+
+	test.Next(_L("Maximum Recent List Size"));
+	TestMaxRecentSize1L(*client);
+	theLog.Write(_L8("Test 4 OK\n"));
+
+	test.Next(_L("Purge Recent Lists When Config Changed"));
+	TestMaxRecentSizeConfigL(*client);
+	theLog.Write(_L8("Test 5 OK\n"));
+
+	test.Next(_L("Maximum Recent List Size With Duplicates"));
+	TestMaxRecentSize2L(*client);
+	theLog.Write(_L8("Test 6 OK\n"));
+
+	test.Next(_L("Check no purge when retrieving event"));
+	TestNoPurgeWithGetL(*client);
+	theLog.Write(_L8("Test 7 OK\n"));
+
+	test.Next(_L("Check ClearLog works for different locales"));
+	TestClearLog1L(*client);
+	TestClearLog2L(*client);
+ 	theLog.Write(_L8("Test 8 OK\n"));
+
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
+	test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4036 CLogClient::ClearLog() + SimId test"));
+ 	ClearLogSimIdL(*client);
+ 	theLog.Write(_L8("Test 9 OK\n"));
+
+	test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4037 CLogClient::ClearLog()/recent + SimId test"));
+ 	ClearLogRecentSimIdL(*client);
+ 	theLog.Write(_L8("Test 10 OK\n"));
+#endif 	
+ 	
+	CleanupStack::PopAndDestroy(); // client;
+	}