// Copyright (c) 2000-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 "emailtestutils.h"

#include "miutlog.h"

#include "miutmsg.h"

#include <txtrich.h>

#include "T_mtmcmd.h"

_LIT(K_CHANGE_COMMAND, "Change");

_LIT(K_COPY_FROM_LOCAL_COMMAND, "Copy from local");

_LIT(K_COPY_TO_LOCAL_COMMAND, "Copy to local");

_LIT(K_COPY_WITHIN_SERVICE_COMMAND, "Copy within service");

_LIT(K_DELETE_ALL_COMMAND, "Delete all");

_LIT(K_MOVE_FROM_LOCAL_COMMAND, "Move from local");

_LIT(K_MOVE_TO_LOCAL_COMMAND, "Move to local");

_LIT(K_MOVE_WITHIN_SERVICE_COMMAND, "Move within service");

_LIT(K_START_COMMAND, "Start command");

_LIT(K_TEST_ON_ALL, " (run on all messages)");

_LIT(K_TEST_COMPLETED, "Completed - ");

_LIT(K_TEST_STARTED, "Started - ");

_LIT(K_TEST_FAILED, "Failed - ");

_LIT(K_TEST_COMPLETED_OKAY, "Test Completed OK");

_LIT(K_TEST_ON_SINGLE, " (run on single message)");

_LIT(K_TEST_ON_SECOND, " (run on second message)");

_LIT(K_TEST_ON_SECOND_CHILDREN, " (run on children of second message)");

_LIT(K_TOP_POPULATE_COMMAND, "Populate using TOP");

// Generic Server MTM Test Harness

//

CMtmTestHarness* CMtmTestHarness::NewL(CBaseServerMtm& aServerMtm, CTestUtils& aTestUtils)

	{

	CMtmTestHarness* self = new (ELeave) CMtmTestHarness(aServerMtm, aTestUtils);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

	}

// Test harness set up

void CMtmTestHarness::Reset()

	{

	Cancel();

	TInt index = iCommandList->Count();

	while (index != 0)

		{

		index--;

		delete (*iCommandList)[index];

		}

	iCommandList->Reset();

	iCurrentCommand = 0;

	iCommandIndex = 0;

	}

void CMtmTestHarness::AddCommandL(CMtmTestCommand* aCommand)

	{

	iCommandList->AppendL(aCommand);

	}

// Run the test harness

void CMtmTestHarness::StartL(const TDesC& aTestName, TRequestStatus& aStatus)

	{

	iFailed = EFalse;

	iCommandIndex = 0;

	iCurrentCommand = 0;

	iStatus = KRequestPending;

	iReportStatus = &aStatus;

	*iReportStatus = KRequestPending;

	iTestUtils.WriteComment(aTestName);

	if (iCommandIndex < iCommandList->Count())

		{

		RunCurrentCommandL();

		}

	else

		{

		SetActive();

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrNone);

		}

	}

TInt CMtmTestHarness::StartL(const TDesC& aTestName)

	{

	CTestActive* waiter = new (ELeave) CTestActive;

	CleanupStack::PushL(waiter);

	waiter->StartL();

	StartL(aTestName, waiter->iStatus);

	CActiveScheduler::Start();

	TInt status = waiter->iStatus.Int();

	CleanupStack::PopAndDestroy(); // waiter

	return status;

	}

// Status information

const TDesC8& CMtmTestHarness::Progress()

	{

	return iServerMtm.Progress();

	}

CBaseServerMtm&	CMtmTestHarness::ServerMtm()

	{

	return iServerMtm;

	}

// Constructor & destructor

CMtmTestHarness::CMtmTestHarness(CBaseServerMtm& aServerMtm, CTestUtils& aTestUtils) : CActive(EPriorityNormal), iServerMtm(aServerMtm), iTestUtils(aTestUtils)

	{}

CMtmTestHarness::~CMtmTestHarness()

	{

	Reset();

	delete iCommandList;

	}

void CMtmTestHarness::ConstructL()

	{

	CActiveScheduler::Add(this);

	iCommandList = new (ELeave) CArrayFixFlat<CMtmTestCommand*>(6);

	Reset();

	}

void CMtmTestHarness::DoCancel()

	{

	if (iCurrentCommand)

		{

		iCurrentCommand->Cancel();

		}

	}

TInt CMtmTestHarness::RunError(TInt aError)

	{

	if (iReportStatus)

		User::RequestComplete(iReportStatus,aError);

	return KErrNone;

	}

void CMtmTestHarness::RunL()

	{

	if (iCurrentCommand)

		{

		TBool failed = EFalse;

		MCommandTester* tester = iCurrentCommand->Tester();

		if (tester)

			{

			if (!(tester->EndL()))

				{

				HBufC* logString = HBufC::NewLC(((TDesC&)K_TEST_FAILED).Size() + iCurrentCommand->DetailsL().Size());

				*logString = (TDesC&)K_TEST_FAILED;

				logString->Des().Append(iCurrentCommand->DetailsL());

				iTestUtils.WriteComment(logString->Des());

				CleanupStack::PopAndDestroy(); // logString

				// log 'FAILED + the info string from the tester'

				HBufC* failureInfo = tester->TextInfoL();

				if (failureInfo)

					{

					CleanupStack::PushL(failureInfo);

					iTestUtils.WriteComment(failureInfo->Des());

					CleanupStack::PopAndDestroy(); // failureInfo

					}

				iFailed = ETrue;

				failed = ETrue;

				}

			}

		if (!failed)

			{

			HBufC* logString = HBufC::NewLC(((TDesC&)K_TEST_COMPLETED).Size() + iCurrentCommand->DetailsL().Size());

			*logString = (TDesC&)K_TEST_COMPLETED;

			logString->Des().Append(iCurrentCommand->DetailsL());

			iTestUtils.WriteComment(logString->Des());

			CleanupStack::PopAndDestroy(); // logString

			}

		}

	// Run the next command if there is one.

	iCommandError = KErrNone;

 	iCommandIndex++;

	if ((iCommandIndex < iCommandList->Count())

		&& (iStatus == KErrNone))

		{

		// Check for any Command Errors

		TRAPD(err, RunCurrentCommandL());

		if (err != KErrNone)

			{

			// Store the Command Error & Leave

			iCommandError = err;

			User::Leave(err);

			}

		}

	else

	// otherwise complete the report status.

		{

		iTestUtils.WriteComment(K_TEST_COMPLETED_OKAY);

		User::RequestComplete(iReportStatus, iStatus.Int());

		Reset();

		}

	}

void CMtmTestHarness::RunCurrentCommandL()

	{

	iStatus = KRequestPending;

	SetActive();

	iCurrentCommand = (*iCommandList)[iCommandIndex];

	MCommandTester* tester = iCurrentCommand->Tester();

	if (tester)

		tester->InitialiseL();

	iCurrentCommand->ExecuteCommandL(iStatus);

	if (tester)

		tester->StartL();

	HBufC* logString = HBufC::NewLC(((TDesC&)K_TEST_STARTED).Size() + iCurrentCommand->DetailsL().Size());

	*logString = (TDesC&)K_TEST_STARTED;

	logString->Des().Append(iCurrentCommand->DetailsL());

	iTestUtils.WriteComment(logString->Des());

	CleanupStack::PopAndDestroy(); // logString

	}

//

// Run this command

void CMtmTestCommand::DoCancel()

	{

	iServerMtm.Cancel();

	}

TInt CMtmTestCommand::RunError(TInt aError)

	{

	if (iReportStatus)

		User::RequestComplete(iReportStatus,aError);

	return KErrNone;

	}

void CMtmTestCommand::RunL()

	{

	TPop3Progress temp;	

	TPckgC<TPop3Progress> paramPack(temp);

	const TDesC8& progBuf = iServerMtm.Progress();	

	paramPack.Set(progBuf);

	TPop3Progress progress=paramPack();	

	TInt err=iStatus.Int();

	if (!err && progress.iErrorCode )

		err=progress.iErrorCode; //pass the error

	User::RequestComplete(iReportStatus, err);

	}

CMtmTestCommand::~CMtmTestCommand()

	{

	delete iSelection;

	delete iTester;

	delete iDetails;

	}

void CMtmTestCommand::CopySelectionL(const CMsvEntrySelection* aSelection)

	{

	delete iSelection;

	iSelection = 0;

	if (aSelection)

		iSelection = aSelection->CopyL();

	}

CMtmTestCommand::CMtmTestCommand(CBaseServerMtm& aServerMtm) : CActive(EPriorityNormal),iServerMtm(aServerMtm)

	{

	CActiveScheduler::Add(this);

	}

void CMtmTestCommand::Queue(TRequestStatus& aReportStatus)

	{

	iReportStatus = &aReportStatus;

	iStatus = KRequestPending;

	SetActive();

	}

void CMtmTestCommand::SetCommandTester(MCommandTester* aTester)

	{

	delete iTester;

	iTester = 0;

	iTester = aTester;

	}

MCommandTester* CMtmTestCommand::Tester()

	{

	return iTester;

	}

TPtrC CMtmTestCommand::DetailsL()

	{

	delete iDetails;

	iDetails = NULL;

	iDetails = CommandDetailsL();

	if (iDetails == NULL)

		{

		iDetails = HBufC::NewL(0);

		}

	return TPtrC(iDetails->Des());

	}

//

void CMtmTestChange::ExecuteCommandL(TRequestStatus& aStatus)

	{

	Queue(aStatus);

	iServerMtm.ChangeL(iNewEntry, iStatus);

	}

HBufC* CMtmTestChange::CommandDetailsL()

	{

	HBufC* details = HBufC::NewL(((TDesC&)K_CHANGE_COMMAND).Size());

	*details = (TDesC&)K_CHANGE_COMMAND;

	return details;

	}

CMtmTestChange* CMtmTestChange::NewL(CBaseServerMtm& aServerMtm, TMsvEntry aNewEntry)

	{

	CMtmTestChange* self = new (ELeave) CMtmTestChange(aServerMtm, aNewEntry);

	return self;

	}

CMtmTestChange::CMtmTestChange(CBaseServerMtm& aServerMtm, TMsvEntry aNewEntry) : CMtmTestCommand(aServerMtm),iNewEntry(aNewEntry)

	{}

//

void CMtmTestDeleteAll::ExecuteCommandL(TRequestStatus& aStatus)

	{

	Queue(aStatus);

	iServerMtm.DeleteAllL(*iSelection, iStatus);

	}

HBufC* CMtmTestDeleteAll::CommandDetailsL()

	{

	HBufC* details = HBufC::NewL(((TDesC&)K_DELETE_ALL_COMMAND).Size());

	*details = (TDesC&)K_DELETE_ALL_COMMAND;

	return details;

	}

CMtmTestDeleteAll* CMtmTestDeleteAll::NewL(CBaseServerMtm& aServerMtm, const CMsvEntrySelection* aSelection)

	{

	CMtmTestDeleteAll* self = new (ELeave) CMtmTestDeleteAll(aServerMtm, aSelection);

	CleanupStack::PushL(self);

	self->CopySelectionL(aSelection);

	CleanupStack::Pop(); // self

	return self;

	}

CMtmTestDeleteAll::CMtmTestDeleteAll(CBaseServerMtm& aServerMtm, const CMsvEntrySelection* /*aSelection*/) : CMtmTestCommand(aServerMtm)

	{}

//

void CMtmTestCopyToLocal::ExecuteCommandL(TRequestStatus& aStatus)

	{

	Queue(aStatus);

	iServerMtm.CopyToLocalL(*iSelection, iDest, iStatus);

	}

HBufC* CMtmTestCopyToLocal::CommandDetailsL()

	{

	HBufC* details = HBufC::NewL(((TDesC&)K_COPY_TO_LOCAL_COMMAND).Size());

	*details = (TDesC&)K_COPY_TO_LOCAL_COMMAND;

	return details;

	}

CMtmTestCopyToLocal* CMtmTestCopyToLocal::NewL(CBaseServerMtm& aServerMtm, const CMsvEntrySelection* aSelection, TMsvId aDest)

	{

	CMtmTestCopyToLocal* self = new (ELeave) CMtmTestCopyToLocal(aServerMtm, aSelection, aDest);

	CleanupStack::PushL(self);

	self->CopySelectionL(aSelection);

	CleanupStack::Pop(); // self

	return self;

	}

CMtmTestCopyToLocal::CMtmTestCopyToLocal(CBaseServerMtm& aServerMtm, const CMsvEntrySelection* /*aSelection*/, TMsvId aDest) : CMtmTestCommand(aServerMtm), iDest(aDest)

	{}

//

void CMtmTestCopyFromLocal::ExecuteCommandL(TRequestStatus& aStatus)

	{

	Queue(aStatus);

	iServerMtm.CopyFromLocalL(*iSelection, iDest, iStatus);

	}

HBufC* CMtmTestCopyFromLocal::CommandDetailsL()

	{

	HBufC* details = HBufC::NewL(((TDesC&)K_COPY_FROM_LOCAL_COMMAND).Size());

	*details = (TDesC&)K_COPY_FROM_LOCAL_COMMAND;

	return details;

	}

CMtmTestCopyFromLocal* CMtmTestCopyFromLocal::NewL(CBaseServerMtm& aServerMtm, const CMsvEntrySelection* aSelection, TMsvId aDest)

	{

	CMtmTestCopyFromLocal* self = new (ELeave) CMtmTestCopyFromLocal(aServerMtm, aSelection, aDest);

	CleanupStack::PushL(self);

	self->CopySelectionL(aSelection);

	CleanupStack::Pop(); // self

	return self;

	}

CMtmTestCopyFromLocal::CMtmTestCopyFromLocal(CBaseServerMtm& aServerMtm, const CMsvEntrySelection* /*aSelection*/, TMsvId aDest) : CMtmTestCommand(aServerMtm), iDest(aDest)

	{}

//

void CMtmTestTopPopulate::ExecuteCommandL(TRequestStatus& aStatus)

	{

	Queue(aStatus);

	TInt command = KPOP3MTMPopulate;

	TImPop3PopulateOptions pop3GetMailInfo;	

	pop3GetMailInfo.SetPopulationLimit(64);

	TPckgC<TImPop3PopulateOptions> paramPack(pop3GetMailInfo);

	iServerMtm.StartCommandL(*iSelection,command,paramPack,iStatus);

	}

HBufC* CMtmTestTopPopulate::CommandDetailsL()

	{

	HBufC* details = HBufC::NewL(((TDesC&)K_TOP_POPULATE_COMMAND).Size());

	*details = (TDesC&)K_TOP_POPULATE_COMMAND;

	return details;

	}

CMtmTestTopPopulate* CMtmTestTopPopulate::NewL(CBaseServerMtm& aServerMtm, const CMsvEntrySelection* aSelection, TMsvId aDest)

	{

	CMtmTestTopPopulate* self = new (ELeave) CMtmTestTopPopulate(aServerMtm, aSelection, aDest);

	CleanupStack::PushL(self);

	self->CopySelectionL(aSelection);

	CleanupStack::Pop(self); // self

	return self;

	}

CMtmTestTopPopulate::CMtmTestTopPopulate(CBaseServerMtm& aServerMtm, const CMsvEntrySelection* /*aSelection*/, TMsvId aDest) : CMtmTestCommand(aServerMtm), iDest(aDest)

	{}

//

void CMtmTestCopyWithinService::ExecuteCommandL(TRequestStatus& aStatus)

	{

	Queue(aStatus);

	iServerMtm.CopyWithinServiceL(*iSelection, iDest, iStatus);

	}

HBufC* CMtmTestCopyWithinService::CommandDetailsL()

	{

	HBufC* details = HBufC::NewL(((TDesC&)K_COPY_WITHIN_SERVICE_COMMAND).Size());

	*details = (TDesC&)K_COPY_WITHIN_SERVICE_COMMAND;

	return details;

	}

CMtmTestCopyWithinService* CMtmTestCopyWithinService::NewL(CBaseServerMtm& aServerMtm, const CMsvEntrySelection* aSelection, TMsvId aDest)

	{

	CMtmTestCopyWithinService* self = new (ELeave) CMtmTestCopyWithinService(aServerMtm, aSelection, aDest);

	CleanupStack::PushL(self);

	self->CopySelectionL(aSelection);

	CleanupStack::Pop(); // self

	return self;

	}

CMtmTestCopyWithinService::CMtmTestCopyWithinService(CBaseServerMtm& aServerMtm, const CMsvEntrySelection* /*aSelection*/, TMsvId aDest) : CMtmTestCommand(aServerMtm), iDest(aDest)

	{}

//

void CMtmTestMoveToLocal::ExecuteCommandL(TRequestStatus& aStatus)

	{

	Queue(aStatus);

	iServerMtm.MoveToLocalL(*iSelection, iDest, iStatus);

	}

HBufC* CMtmTestMoveToLocal::CommandDetailsL()

	{

	HBufC* details = HBufC::NewL(((TDesC&)K_MOVE_TO_LOCAL_COMMAND).Size());

	*details = (TDesC&)K_MOVE_TO_LOCAL_COMMAND;

	return details;

	}

CMtmTestMoveToLocal* CMtmTestMoveToLocal::NewL(CBaseServerMtm& aServerMtm, const CMsvEntrySelection* aSelection, TMsvId aDest)

	{

	CMtmTestMoveToLocal* self = new (ELeave) CMtmTestMoveToLocal(aServerMtm, aSelection, aDest);

	CleanupStack::PushL(self);

	self->CopySelectionL(aSelection);

	CleanupStack::Pop(); // self

	return self;

	}

CMtmTestMoveToLocal::CMtmTestMoveToLocal(CBaseServerMtm& aServerMtm, const CMsvEntrySelection* /*aSelection*/, TMsvId aDest) : CMtmTestCommand(aServerMtm), iDest(aDest)

	{}

//

void CMtmTestMoveFromLocal::ExecuteCommandL(TRequestStatus& aStatus)

	{

	Queue(aStatus);

	iServerMtm.MoveFromLocalL(*iSelection, iDest, iStatus);

	}

HBufC* CMtmTestMoveFromLocal::CommandDetailsL()

	{

	HBufC* details = HBufC::NewL(((TDesC&)K_MOVE_FROM_LOCAL_COMMAND).Size());

	*details = (TDesC&)K_MOVE_FROM_LOCAL_COMMAND;

	return details;