// Copyright (c) 2002-2010 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 "t_logutil2.h"

#include <logview.h>

RTest TheTest(_L("t_logviewfail2"));

const TLogContactItemId KTestContact = 0x123;

_LIT(KTestStatus, "Test Status Text");

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-0971

@SYMTestCaseDesc	    Tests for CLogViewEvent::SetFilterL() function

@SYMTestPriority 	    High

@SYMTestActions  	    Create a log filter and set the filter on logview.Check for equality of events on the view and events

						added.Check for file failure error

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestEventViewSetupWithFileFailL(CLogClient& aClient)

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0971 "));

	CTestActive* active = new(ELeave)CTestActive;

	CleanupStack::PushL(active);

	CLogEvent* event = CLogEvent::NewL();

	CleanupStack::PushL(event);

	event->SetEventType(KLogCallEventTypeUid);

	event->SetStatus(KTestStatus);

	// Add an event

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

	active->StartL();

	CActiveScheduler::Start();

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

	CLogViewEvent* view = CLogViewEvent::NewL(aClient);

	CleanupStack::PushL(view);

	CLogFilterList* list = new(ELeave)CLogFilterList;

	CleanupStack::PushL(list);

	CLogFilter* filter = CLogFilter::NewL();

	CleanupStack::PushL(filter);

	filter->SetStatus(KTestStatus);

	TInt failCount = 0;

	TBool finished = EFalse;

	TInt error;

	while(!finished)

		{

		TheTest.Printf(_L("%d  \r"), failCount);

		__FILE_FAILNEXT(KErrNoMemory, failCount++);

		TBool result = EFalse;

		TRAP(error, result = view->SetFilterL(*filter, active->iStatus));

		if (error == KErrNone)

			{

			TEST(result);

			active->StartL();

			CActiveScheduler::Start();

			if (active->iStatus.Int() == KErrNone)

				{

				finished = ETrue;		

				TEST(view->CountL() >= 1);

				TEST(TestUtils::EventsEqual(*event, view->Event()));

				}

			else

				{

				if(active->iStatus.Int() != KErrNoMemory)

					{

					TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int());

					}

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

				}

			}

		else

			{

			if(error != KErrNoMemory)

				{

				TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error);

				}

			TEST2(error, KErrNoMemory);

			}

		__FILE_RESET;

		}

    TheTest.Printf(_L("\r\nTest-1 has succeeded at iteration %d\n"), failCount);

	list->AppendL(filter);

	CleanupStack::Pop(); // filter

	filter = CLogFilter::NewL();

	CleanupStack::PushL(filter);

	filter->SetEventType(KLogCallEventTypeUid);

	list->AppendL(filter);

	CleanupStack::Pop(); // filter

	failCount = 0;

	finished = EFalse;

	while(!finished)

		{

		TheTest.Printf(_L("%d  \r"), failCount);

		__FILE_FAILNEXT(KErrNoMemory, failCount++);

		TBool result = EFalse;

		TRAP(error, result = view->SetFilterL(*list, active->iStatus));

		if (error == KErrNone)

			{

			TEST(result);

			active->StartL();

			CActiveScheduler::Start();

			if (active->iStatus.Int() == KErrNone)

				{

				finished = ETrue;		

				TEST(view->CountL() >= 1);

				TEST(TestUtils::EventsEqual(*event, view->Event()));

				}

			else

				{

				if(active->iStatus.Int() != KErrNoMemory)

					{

					TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int());

					}

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

				}

			}

		else

			{

			if(error != KErrNoMemory)

				{

				TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error);

				}

			TEST2(error, KErrNoMemory);

			}

		__FILE_RESET;

		}

	list->ResetAndDestroy();

	CleanupStack::PopAndDestroy(4); // list, view, event, active

    TheTest.Printf(_L("\r\nTest-2 has succeeded at iteration %d\n"), failCount);

	}

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-0972

@SYMTestCaseDesc	    Tests CLogViewRecent::SetRecentListL() function

@SYMTestPriority 	    High

@SYMTestActions  	    Set recent view list first without a filter and later with log filter,check for file failure error

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestRecentViewSetupWithFileFailL(CLogClient& aClient)

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0972 "));

	CTestActive* active = new(ELeave)CTestActive;

	CleanupStack::PushL(active);

	CLogEvent* event = CLogEvent::NewL();

	CleanupStack::PushL(event);

	// Incoming

	TLogString buf;

	aClient.GetString(buf, R_LOG_DIR_IN);

	event->SetEventType(KLogCallEventTypeUid);

	event->SetDirection(buf);

	event->SetStatus(KTestStatus);

	// Add an event

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

	active->StartL();

	CActiveScheduler::Start();

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

	CLogViewRecent* view = CLogViewRecent::NewL(aClient);

	CleanupStack::PushL(view);

	TInt failCount = 0;

	TBool finished = EFalse;

	TInt error;

	while(!finished)

		{

		TheTest.Printf(_L("%d  \r"), failCount);

		__FILE_FAILNEXT(KErrNoMemory, failCount++);

		TBool result = EFalse;

		TRAP(error, result = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));

		if (error == KErrNone)

			{

			TEST(result);

			active->StartL();

			CActiveScheduler::Start();

			if (active->iStatus.Int() == KErrNone)

				{

				finished = ETrue;		

				TEST(view->CountL() >= 1);

				}

			else

				{

				if(active->iStatus.Int() != KErrNoMemory)

					{

					TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int());

					}

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

				}

			}

		else

			{

			if(error != KErrNoMemory)

				{

				TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error);

				}

			TEST2(error, KErrNoMemory);

			}

		__FILE_RESET;

		}

    TheTest.Printf(_L("\r\nTest-1 has succeeded at iteration %d\n"), failCount);

	CLogFilterList* list = new(ELeave)CLogFilterList;

	CleanupStack::PushL(list);

	CLogFilter* filter = CLogFilter::NewL();

	CleanupStack::PushL(filter);

	filter->SetStatus(KTestStatus);

	failCount = 0;

	finished = EFalse;

	while(!finished)

		{

		TheTest.Printf(_L("%d  \r"), failCount);

		__FILE_FAILNEXT(KErrNoMemory, failCount++);

		TBool result = EFalse;

		TRAP(error, result = view->SetRecentListL(KLogRecentIncomingCalls, *filter, active->iStatus));

		if (error == KErrNone)

			{

			TEST(result);

			active->StartL();

			CActiveScheduler::Start();

			if (active->iStatus.Int() == KErrNone)

				{

				finished = ETrue;		

				TEST(view->CountL() >= 1);

				}

			else

				{

				if(active->iStatus.Int() != KErrNoMemory)

					{

					TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int());

					}

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

				}

			}

		else

			{

			if(error != KErrNoMemory)

				{

				TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error);

				}

			TEST2(error, KErrNoMemory);

			}

		__FILE_RESET;

		}

    TheTest.Printf(_L("\r\nTest-2 has succeeded at iteration %d\n"), failCount);

	list->AppendL(filter);

	CleanupStack::Pop(); // filter

	filter = CLogFilter::NewL();

	CleanupStack::PushL(filter);

	filter->SetEventType(KLogCallEventTypeUid);

	list->AppendL(filter);

	CleanupStack::Pop(); // filter

	failCount = 0;

	finished = EFalse;

	while(!finished)

		{

		TheTest.Printf(_L("%d  \r"), failCount);

		__FILE_FAILNEXT(KErrNoMemory, failCount++);

		TBool result = EFalse;

		TRAP(error, result = view->SetRecentListL(KLogRecentIncomingCalls, *list, active->iStatus));

		if (error == KErrNone)

			{

			TEST(result);

			active->StartL();

			CActiveScheduler::Start();

			if (active->iStatus.Int() == KErrNone)

				{

				finished = ETrue;		

				TEST(view->CountL() >= 1);

				}

			else

				{

				if(active->iStatus.Int() != KErrNoMemory)

					{

					TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int());

					}

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

				}

			}

		else

			{

			if(error != KErrNoMemory)

				{

				TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error);

				}

			TEST2(error, KErrNoMemory);

			}

		__FILE_RESET;

		}

	list->ResetAndDestroy();

	CleanupStack::PopAndDestroy(4); // list, view, event, active

    TheTest.Printf(_L("\r\nTest-3 has succeeded at iteration %d\n"), failCount);

	}

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-0973

@SYMTestCaseDesc	    Tests for CLogViewRecent::DuplicatesL() function

@SYMTestPriority 	    High

@SYMTestActions  	    Set the specified duplicate event view with logview duplicates.

                        Check for file failure errors 

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestDuplicateViewSetupWithFileFailL(CLogClient& aClient)

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0973 "));

	CTestActive* active = new(ELeave)CTestActive;

	CleanupStack::PushL(active);

	CLogEvent* event = CLogEvent::NewL();

	CleanupStack::PushL(event);

	// Incoming

	TLogString buf;

	aClient.GetString(buf, R_LOG_DIR_IN);

	event->SetEventType(KLogCallEventTypeUid);

	event->SetDirection(buf);

	event->SetContact(KTestContact);

	event->SetStatus(KTestStatus);

	// Add events

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

	active->StartL();

	CActiveScheduler::Start();

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

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

	active->StartL();

	CActiveScheduler::Start();

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

	CLogViewRecent* view = CLogViewRecent::NewL(aClient);

	CleanupStack::PushL(view);

	TEST(view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus));

	active->StartL();

	CActiveScheduler::Start();

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

	CLogViewDuplicate* duplicate = CLogViewDuplicate::NewL(aClient);

	CleanupStack::PushL(duplicate);

	TInt failCount = 0;

	TBool finished = EFalse;

	TInt error;

	while(!finished)

		{

		TheTest.Printf(_L("%d  \r"), failCount);

		__FILE_FAILNEXT(KErrNoMemory, failCount++);

		TBool result = EFalse;

		TRAP(error, result = view->DuplicatesL(*duplicate, active->iStatus));

		if (error == KErrNone)

			{

			TEST(result);

			active->StartL();

			CActiveScheduler::Start();

			if (active->iStatus.Int() == KErrNone)

				{

				finished = ETrue;		

				TEST(duplicate->CountL() >= 1);

				}

			else

				{

				if(active->iStatus.Int() != KErrNoMemory)

					{

					TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int());

					}

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

				}

			}

		else

			{

			if(error != KErrNoMemory)

				{

				TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error);

				}

			TEST2(error, KErrNoMemory);

			}

		__FILE_RESET;

		}

    TheTest.Printf(_L("\r\nTest-1 has succeeded at iteration %d\n"), failCount);

	CLogFilterList* list = new(ELeave)CLogFilterList;

	CleanupStack::PushL(list);

	CLogFilter* filter = CLogFilter::NewL();

	CleanupStack::PushL(filter);

	filter->SetStatus(KTestStatus);

	failCount = 0;

	finished = EFalse;

	while(!finished)

		{

		TheTest.Printf(_L("%d  \r"), failCount);

		__FILE_FAILNEXT(KErrNoMemory, failCount++);

		TBool result = EFalse;

		TRAP(error, result = view->DuplicatesL(*duplicate, *filter, active->iStatus));

		if (error == KErrNone)

			{

			TEST(result);

			active->StartL();

			CActiveScheduler::Start();

			if (active->iStatus.Int() == KErrNone)

				{

				finished = ETrue;		

				TEST(duplicate->CountL() >= 1);

				}

			else

				{

				if(active->iStatus.Int() != KErrNoMemory)

					{

					TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int());

					}

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

				}

			}

		else

			{

			if(error != KErrNoMemory)

				{

				TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error);

				}

			TEST2(error, KErrNoMemory);

			}

		__FILE_RESET;

		}

    TheTest.Printf(_L("\r\nTest-2 has succeeded at iteration %d\n"), failCount);

	list->AppendL(filter);

	CleanupStack::Pop(); // filter

	filter = CLogFilter::NewL();

	CleanupStack::PushL(filter);

	filter->SetEventType(KLogCallEventTypeUid);

	list->AppendL(filter);

	CleanupStack::Pop(); // filter