// 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);