// Copyright (c) 2004-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:

// __ACTION_INFO_BEGIN__

// [Action Name]

// CompareEmailMessages

// [Action Parameters]

// CMsvSession&			session   <input>			: Reference to the session.

// CMsvEntrySelection&	SentMailSelection <input>	: Reference to the

// sent mail selection

// CMsvEntrySelection&	RecvMailSelection <input>	: Reference to the

// received mail selection

// CMtfTestParameter&	Download limits <input>		: The CMTfTestParameter object

// which stores either full download

// limits or partial download limits

// that was set during mail download

// [Action Description]

// Compares the sent and received email messages for size and contents based on

// the download limits set.  The sent and received messages with the same 

// Subject field are compared.  The Complete and Partial download flags set for 

// the message parts are verified.

// Restrictions:

// 1. The Test Action supports comparison of simple emails messages with Body Text,

// Html part and attachments of B64 encoding format.  Needs to be enhanced to 

// support emails with embedded messages, all attachment types and MHTML messages.

// 2. The size of the encoded message parts (Body text, Attachment and Html) are not 

// available as there are no APIs available to get this information

// Workarounds in the Test Action:

// For Body Text part:

// 1. [WorkAround for Body Text Ref1]

// The size of the encoded body text is not available. Hence the size of the 

// body text in the message store will be used.  In the Test Case, care has

// to be taken to have the limits set, such that, the limits considers the 

// size of the encoded body text part and not the size of the body text present

// in the store.

// 2. [WorkAround for Body Text Ref2]

// For the defect "The CRLF characters is NOT interpreted  correctly".

// The body text size is reduced by the tolerance length to overcome

// the message comparison failure

// 3. [WorkAround for Body Text Ref3]

// The Communigate Pro server adds a disclaimer at the beginning

// of the body text in the received message.  This message has to be removed 

// from the body text of the received message before comparison.  The function

// needs to be enhanced to handle different server messages.

// 4. [WorkAround for Body Text Ref4]

// For the defect "The size of the body text in the sent and the received emails

// differ by 2 bytes.".  The size of the sent message's body text is set to

// that of the received message's body text size.

// 5. [WorkAround for Body Text Ref5]

// For the defect "For partially downloaded Body text of a message, 

// the corresponding TMsvEntry.iSize represents the size present in the 

// RFC822 message body text size. It does NOT indicate the partially downloaded

// body text size".  The size of the set message is set to that of partially

// downloaded body text before comparing.  It is required to manually verify

// the size of the partially downloaded message text in the email log files.

// 6. [WorkAround for Body Text Ref6]

// The remaining size of the body text or Html part on the server 

// is not available, hence expected remaining size of the Body text on

// the server cannot be calculated.  Hence verification of the footer message

// information is not possible.  The value of the remaining size

// of the body text size on the server needs to be manually verified 

// by checking the email logs. In the test action, the footer message present

// in the buffer is printed in the log file.

// 7. [WorkAround for Body Text Ref7]

// When a message with only attachment is created, one byte of body text is

// getting added.  To take care of this conditions, the sent body text size

// is checked for being greater than 1 instead of 0.  This means the Body text

// part used for testing should be greater than 1 Byte.

// For Html part:

// 1. [WorkAround for Html Part Ref1]

// Not verifying relative URIs, since message with only one Html part considered

// 2. [WorkAround for Html Part Ref2]

// The size of the encoded html part is not available, hence the size of the Html 

// file in the message store is considered.  Test Case need to ensure that the 

// download limits consider the encoded Html size rather than the size got from the store

// For Attachments:

// 1.	[WorkAround for Attachments Ref1]

// The attachment download limits refers to the encoded attachment 

// size.  This size is not available through any of the APIs.  The

// available size of the attachment is the size of the file that 

// is present in the message store. This size is smaller than the 

// encoded size. Hence adding a correction value to get the approximate

// size of the encoded attachment.

// Note: this correction holds good for only B64 encoding.

// For All Message Parts:

// 1.   [WorkAround for general Ref1]

// Though the TMsvEntry::Complete() and TMsvEmailEntry::PartialDownloaded()

// returns a TBool value, the returned value will not equal to the value of 

// ETrue and EFalse.  Hence the direct comparison of the set flag value 

// and the expected flag value is not possible

// [APIs Used]

// CImEmailMessage::AttachmentSelection()

// CMsvEntry::SetEntry()

// __ACTION_INFO_END__

// 

//

/**

 @file

*/

#include <cemailaccounts.h>

#include <iapprefs.h>

#include <imapset.h>

#include <cmsvattachment.h>

#include <mmsvattachmentmanager.h>

#include <miutmsg.h>

// User include

#include "CMtfTestActionCompareEmailMessages.h"

#include "CMtfTestActionParameters.h"

#include "TestFrameworkActionsUtils.h"

//Granularity for CArrayFixFlat arrays

const TInt KArrayGranularity = 8;

// Correction to attachment size

const TReal ATTACHMENT_SIZE_CORRECTION = 1.32;

/**

  NewL()

  Constructs a CMtfTestActionCompareEmailMessages object.

  Uses two phase construction and leaves nothing on the CleanupStack.

  @internalTechnology

  @param  aTestCase          Test Case to which the Test Action belongs

  @param  aActionParameters  Action parameters, must not be NULL

  @return Created object of type CMtfTestAction

  @pre    None

  @post   None

*/

CMtfTestAction* CMtfTestActionCompareEmailMessages::NewL(CMtfTestCase& aTestCase,

													CMtfTestActionParameters* aActionParameters)

	{

	CMtfTestActionCompareEmailMessages* self = 

					new (ELeave) CMtfTestActionCompareEmailMessages(aTestCase);

	CleanupStack::PushL(self);

	self->ConstructL(aActionParameters);

	CleanupStack::Pop(self);

	return self;

	}

/**

  Constructor

  Constructs a CMtfTestActionCompareEmailMessages object and initialises the member variables.

  @internalTechnology

  @param  aTestCase  Test Case to which the Test Action belongs

  @pre    None

  @post   None

*/

CMtfTestActionCompareEmailMessages::CMtfTestActionCompareEmailMessages(CMtfTestCase& aTestCase)

	: CMtfSynchronousTestAction(aTestCase), iParamSession(NULL), iDownloadType(EFullDownload),

  	  iCumulativeSize(0), iSentMessageInfo(NULL), iRecvMessageInfo(NULL)

	{

	}

/**

  Destructor

  Destructor of the class CMtfTestActionCompareEmailMessages.

  Deletes the message information stored in the CMtfTestActionUtilsEmailMessage

  objects

  @internalTechnology

  @param  None

  @pre    None

  @post   None

*/

CMtfTestActionCompareEmailMessages::~CMtfTestActionCompareEmailMessages()

	{

	delete 	iSentMessageInfo;

	delete 	iRecvMessageInfo;

	}

/**

  ExecuteActionL

  Obtains the parameters for the test action and then calls CompareEmailMessagesL()

  function to compare the sent and the received messages, based on the download

  limits set.

  @internalTechnology 

  @pre    None

  @post   None

*/

void CMtfTestActionCompareEmailMessages::ExecuteActionL()

	{

	TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionCompareEmailMessages);

	// Get the session object 

	iParamSession				= ObtainParameterReferenceL<CMsvSession>

									(TestCase(),ActionParameters().Parameter(0));

	// Get the selection object of messages in sent folder - Sent

	CMsvEntrySelection*	sentMsgSelectionList = 

									ObtainParameterReferenceL<CMsvEntrySelection>

									(TestCase(), ActionParameters().Parameter(1)); 

	// Get the selection object of messages in received folder - Inbox

	CMsvEntrySelection*	recvMsgSelectionList = 

									ObtainParameterReferenceL<CMsvEntrySelection>

									(TestCase(), ActionParameters().Parameter(2)); 

	if( iParamSession == NULL || sentMsgSelectionList == NULL ||

		 recvMsgSelectionList == NULL)

		{

		// Invalid input parameter value

		TestCase().ERR_PRINTF1(_L("Invalid session or message selection object found"));

		TestCase().SetTestStepResult(EFail);

		}

	else

		{

		if(IsTestCaseStatusPass())

			{

			// Get the download limits provided as the test action input and

			// store the limit values

			SetDownloadLimits();

			if(IsTestCaseStatusPass())

				{

				// Compare sent and received messages

				CompareEmailMessagesL(*sentMsgSelectionList, *recvMsgSelectionList);

				}

			}

		}

	// Test Action is complete

	TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionCompareEmailMessages);

	TestCase().ActionCompletedL(*this);

	}	

/**

  SetDownloadLimitsL

  Obtains the parameter that contians download limits.  Checks for the type of

  the download limits being set.  Retrieves the values of the limits and stores

  them in member variables.

  @internalTechnology

  @pre    None

  @post   None

*/

void CMtfTestActionCompareEmailMessages::SetDownloadLimits()

	{

	// Get the Partial download limits or  full download limits

	const CMtfTestParameter& paramDownloadLimits = TestCase().ObtainParameterL

										  	 (ActionParameters().Parameter(3));

	// Buffer to store the download limits set

	HBufC8* buf=reinterpret_cast<HBufC8*>(paramDownloadLimits.Parameter());

	// Verify CMtfTestParameter object - Partial/Complete 

	if ( paramDownloadLimits.SpecificTypeId() == EMtfTImImap4GetPartialMailInfo)

		{

		// Partial download limits set

		TImImap4GetPartialMailInfo value;

		TPckgC<TImImap4GetPartialMailInfo> unpack(value);

		unpack.Set(*buf);

		iImapPartialDownloadLimits = unpack();

		// Set the download type as partial download

		iDownloadType = EPartialDownload;

		TestCase().INFO_PRINTF1(_L("TImImap4GetPartialMailInfo received as input"));

		TestCase().INFO_PRINTF4(_L("TotalSizeLimit = %d, BodyTextSizeLimit %d, AttachmentSizeLimit %d"),

								iImapPartialDownloadLimits.iTotalSizeLimit,

								iImapPartialDownloadLimits.iBodyTextSizeLimit,

								iImapPartialDownloadLimits.iAttachmentSizeLimit);

		}

	else if(paramDownloadLimits.SpecificTypeId() == EMtfTImImap4GetMailInfo)

		{

		// Full download limits set

		TImImap4GetMailInfo value;

		TPckgC<TImImap4GetMailInfo> unpack(value);

		unpack.Set(*buf);

		iImapCompleteDownloadLimits = unpack();

		// Set the download type as full download

		iDownloadType = EFullDownload;

		TestCase().INFO_PRINTF1(_L("TImImap4GetMailInfo received as input"));

		TestCase().INFO_PRINTF2(_L("iMaxEmailSize = %d"),

									iImapCompleteDownloadLimits.iMaxEmailSize);

		}	

	else

		{

		// No specified download type mentioned 

		TestCase().ERR_PRINTF1(_L("Incorrect Download type provided as input"));

		TestCase().SetTestStepResult(EFail);

		}

	}

/**

  CompareEmailMessagesL

  For the sent messages, searches for the received message with the same 

  Subject field.  If the received message is found, sets the sent and received

  message information and then calls CompareMessagesL() function to compare the 

  contents of the message based on the download limits set.

  @internalTechnology 

  @param  aSentMsgSelection  Selection of sent email messages

  @param  aRecvMsgSelection  Selection of received email messages

  @pre    None

  @post   None

*/

void CMtfTestActionCompareEmailMessages::CompareEmailMessagesL(

										 const CMsvEntrySelection& aSentMsgSelection,

										 const CMsvEntrySelection& aRecvMsgSelection)

	{

	// Verify the input parameters

	if( (!&aSentMsgSelection) || (!&aRecvMsgSelection))	

		{

		TestCase().ERR_PRINTF1(_L("Invalid Message selection"));

		User::LeaveIfError(KErrArgument);

		}

	// Get the count of messages in both the selection object.

	TInt sentMsgCount = aSentMsgSelection.Count();

	TInt recvMsgCount = aRecvMsgSelection.Count();

	TestCase().INFO_PRINTF2(_L("Sent Message count = %d"),sentMsgCount);

	TestCase().INFO_PRINTF2(_L("Received Message count = %d"),recvMsgCount);

	// Check if all the sent messages have to be received.

	if(recvMsgCount != sentMsgCount)

		{

		// Number of received messages is not equal to number of sent messages

		TestCase().ERR_PRINTF1(_L("Sent and Received message count not equal"));

		TestCase().SetTestStepResult(EFail);

		}

	/* Loop through the list of sent messages.  For each of the sent messages,

	   verify if the message has been received.  The comparison is done based

	   on the subject field.  If message is not received - ERROR

	   Obtain the message entry with the session object, setting it to root 

	   entry now, will be changed to the sent and received messages entries during 

	   message comparison 

	*/

	if(IsTestCaseStatusPass())

		{

		CMsvEntry* sentMsvEntry = iParamSession->GetEntryL(KMsvRootIndexEntryId);

		CleanupStack::PushL(sentMsvEntry);

		CMsvEntry* recvMsvEntry = iParamSession->GetEntryL(KMsvRootIndexEntryId);

		CleanupStack::PushL(recvMsvEntry);

		if((!sentMsvEntry) || (!recvMsvEntry))

			{

			TestCase().ERR_PRINTF1(_L("Invalid Message Entry"));

			User::LeaveIfError(KErrGeneral);

			}

		// Loop through the list of sent messages

		for ( TInt sentMsgIndex = 0 ; (sentMsgIndex < sentMsgCount) &&

									  (IsTestCaseStatusPass());

									   sentMsgIndex ++)

			{

			// Get the sent message Id

			TMsvId sentMsgId = aSentMsgSelection.At(sentMsgIndex);

			// Set the context to the sent message entry

			sentMsvEntry->SetEntryL(sentMsgId);

			TBool found = EFalse;

			TestCase().INFO_PRINTF3(_L("Comparison of Message: %d,  Subject: %S"),

							(sentMsgIndex + 1), &(sentMsvEntry->Entry().iDescription));

			// Loop through the list received messages - Inbox folder

			for(TInt recvMsgIndex= 0; recvMsgIndex < recvMsgCount && !found

														    ; recvMsgIndex++)	

				{

				// Get the received message entry

				TMsvId recvMsgId = aRecvMsgSelection.At(recvMsgIndex);

				// Set the context to the received message entry

				recvMsvEntry->SetEntryL(recvMsgId);

				// Compare the subject field of the two messages

				if (sentMsvEntry->Entry().iDescription.

								Compare(recvMsvEntry->Entry().iDescription) == 0)

					{

					TestCase().INFO_PRINTF2(_L("Message with Subject field in the received selection: %S found "),

												  &(recvMsvEntry->Entry().iDescription));

					// Sent message has been received

					found = ETrue;

					// Set the email information with the sent and received emails

					// to be compared

					SetEmailMessageInfoL(*sentMsvEntry, *recvMsvEntry);

					}

				}	

			if ( found )

				{

				if(IsTestCaseStatusPass())

					{

					// Message is found now compare the two messages

					if( iDownloadType == EPartialDownload )

						{

						CompareMessagesWithPartialDownloadLimitsSetL();

						}

					else 

						{

						CompareMessagesWithFullDownloadLimitsSetL();

						}

					if(IsTestCaseStatusPass())

						{

						// Delete the email information

						DeleteEmailMessageInfo();

						}

					}

				}

			else{

				TestCase().ERR_PRINTF2(_L("Email with subject %S is not received"), &sentMsvEntry->Entry().iDescription);

				TestCase().SetTestStepResult(EFail);

				}

			}

		// Cleanup the stack

		CleanupStack::PopAndDestroy(recvMsvEntry);

		CleanupStack::PopAndDestroy(sentMsvEntry);

		}

	}

/**

  DeleteEmailMessageInfo

  If any message information was stored for sent and received messages,

  delete the infromation.

  @internalTechnology 

  @pre    None

  @post   None

*/

void CMtfTestActionCompareEmailMessages::DeleteEmailMessageInfo()

	{

	// Delete sent message information

	delete 	iSentMessageInfo;

	iSentMessageInfo = NULL;

	// Delete received message information

	delete 	iRecvMessageInfo ;

	iRecvMessageInfo = NULL;

	}

/**

  SetEmailMessageInfoL

  Stores the message informationsent and received messages

  @internalTechnology 

  @param  aSentMsvEntry Entry for the sent message

  @param  aRecvMsvEntry Entry for the received message

  @pre    None

  @post   None

*/

void CMtfTestActionCompareEmailMessages::SetEmailMessageInfoL(

											CMsvEntry& aSentMsvEntry,

											CMsvEntry& aRecvMsvEntry)

	{

	// Store sent message info

	TestCase().INFO_PRINTF1(_L("Setting information for SENT message"));

	iSentMessageInfo = CMtfTestActionUtilsEmailMessage::NewL(aSentMsvEntry, TestCase());

	// Store received message info

	TestCase().INFO_PRINTF1(_L("Setting information for RECEIVED message"));

	iRecvMessageInfo = CMtfTestActionUtilsEmailMessage::NewL(aRecvMsvEntry, TestCase());

	}

/**

  CompareMessagesWithPartialDownloadLimitsSetL

  Compares the sent and the received message based on the partial download limits set

  @internalTechnology 

  @pre    None

  @post   None

*/

void CMtfTestActionCompareEmailMessages::CompareMessagesWithPartialDownloadLimitsSetL()

	{

	// Partial download limits set

	switch( iImapPartialDownloadLimits.iPartialMailOptions )

		{

		case ENoSizeLimits:

			// No limits, the entire message was to be downloaded

			TestCase().INFO_PRINTF1(_L("PartailDownloadLimits ENoSizeLimits option set"));

			CompareCompleteDownloadOfMessageL();

			break;

		case EAttachmentsOnly:

			// Only attachments to be downloaded based on the attachment size limit

			// Body text and html parts should not be downloaded

			TestCase().INFO_PRINTF1(_L("PartailDownloadLimits EAttachmentsOnly option set"));

			CompareMessageWithAttachmentsOnlyOptionSetL();

			break;

		case EBodyTextOnly:

			/*  When EBodyTextOnly option is set, Body text and html part should

				be downloaded based on the body text limit set. The attachments

				should not be downloaded. CompareAttachmentsL() is a generic

				function which compares the attachments for any download option set.

				So this case makes use of the function 

				CompareMessagePartialDownloadWithBodyTextAndAttachmentsL() to compare 

				the body text and html contents based on the body text limit set. The