diff -r 000000000000 -r 72b543305e3a email/pop3andsmtpmtm/clientmtms/test/src/T_MIUT01.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/email/pop3andsmtpmtm/clientmtms/test/src/T_MIUT01.cpp	Thu Dec 17 08:44:11 2009 +0200
@@ -0,0 +1,1906 @@
+// Copyright (c) 1998-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:
+// Name of test harness: T_MIUT01
+// Component: IMCM
+// Owner: KP
+// Brief description of test harness:
+// Tests storing/retrieving data from CImHeader - most of the functionality is
+// tested - some new functions may not be tested!
+// Detailed description of test harness:
+// As above.
+// Input files required to run test harness:
+// None
+// Intermediate files produced while running test harness:
+// <DRIVE>:\msgtest\T_MIUT01\T_IMCM.log
+// Output files produced by running test harness:
+// <DRIVE>:\msglogs\T_MIUT01.<PLATFORM>.<VARIANT>.LOG.txt
+// Description of how to build test harness:
+// cd \msg\imcm\
+// bldmake bldfiles
+// abld test build
+// Description of how to run test harness:
+// The following instructions are the same for all platforms:
+// 1. Build T_DB test harness from COMMDB component:
+// cd \commdb\group
+// bldmake bldfiles
+// abld test build t_db
+// 2. Build the test utilities:
+// cd \msg\testutils\group\
+// bldmake bldfiles
+// abld build
+// WINS running instructions:
+// 1. \epoc32\release\wins\<VARIANT>\T_MIUT01.exe can be used at the command prompt
+// or executable can be run from Windows Explorer.
+// All other platform running instructions:
+// 1. Copy \epoc32\release\<PLATFORM>\<VARIANT>\T_MIUT01.exe onto the other platform
+// 2. Copy \epoc32\release\<PLATFORM>\<VARIANT>\MSVTESTUTILS.DLL into 
+// <DRIVE>:\system\libs on the other platform
+// 3. Copy \epoc32\release\<PLATFORM>\<VARIANT>\EMAILTESTUTILS.DLL into 
+// <DRIVE>:\system\libs on the other platform
+// 4. Run T_MIUT01.exe on the other platform
+// 
+//
+
+#include "emailtestutils.h"
+#include "MIUTHDR.H"    // CImHeader
+#include <pop3set.h>
+#include <miutlog.h>
+
+#include <msventry.h>
+#include "MSVSERV.H"
+#include <msvids.h>
+#include <miutconv.h>
+#include <charconv.h>
+#include <imcvcodc.h>
+#include <cemailaccounts.h>
+#include <iapprefs.h>
+
+//
+// Still need to test:
+//	- Charset()/SetCharset()
+//	- EncodingInfo()/AddEncodingInfo()
+//
+
+// local variables etc //
+
+_LIT(KMiut01Test, "T_MIUT01 - Test CImHeader class");
+RTest test(KMiut01Test);
+LOCAL_D CTrapCleanup* theCleanup;
+
+LOCAL_D CImHeader* imHeader;
+LOCAL_D CImHeader* imHeader2;
+LOCAL_D CImHeader* imHeaderVerify;	// To verify stored header identical to original
+LOCAL_D TMsvEntry entry; 
+LOCAL_D CEmailTestUtils* testUtils;
+LOCAL_D CImLog* log;
+
+_LIT(KMiutSubject, "short mail about something interesting");
+_LIT8(KMiutMsgId, "0123456789AB.CdeFGHIj@symbian.com");
+_LIT(KMiutReceiptAddress, "i-want-a.receipt.com>");
+_LIT(KMiutFrom, "ralph-greenwell@psion.com");
+_LIT(KMiutReplyTo, "ralph.greenwell@virgin.net");
+_LIT(KMiutToRecipients1, "recipient1@address.com");
+_LIT(KMiutToRecipients2, "recipient2@address.com");
+_LIT(KMiutCcRecipients1, "cc1@address.com");
+_LIT(KMiutCcRecipients2, "cc2@address.com");
+_LIT(KMiutBccRecipients, "bcc@address.com");
+_LIT8(KMiutResentMsgId, "0123456789AB.CdeFGHIj@symbian.com");
+_LIT(KMiutResentFrom, "test@psion6.demon.co.uk");
+_LIT(KMiutResentToRecipients1, "recipient1@address.com");
+_LIT(KMiutResentToRecipients2, "recipient2@address.com");
+_LIT(KMiutResentCcRecipients1, "cc1@address.com");
+_LIT(KMiutResentCcRecipients2, "cc2@address.com");
+_LIT(KMiutResentBccRecipients, "bcc@address.com");
+
+_LIT(KMiutTestPassed, "PASSED test %d\n");
+_LIT(KMiutTestFailed, "FAILED test %d\n");
+
+
+
+#define KMiutRemoteSize 					123456
+#define KMaxImHeaderStringLengthLong		KMaxImHeaderStringLength+1
+
+LOCAL_D TBuf<KMaxImHeaderStringLengthLong> longValue;
+LOCAL_D TBuf8<KMaxImHeaderStringLengthLong> longValue2;
+
+//
+
+LOCAL_C void ResultOfTest(TBool aResult,TInt aTestNo)
+	{
+	if (aResult)
+		{
+		test.Printf(KMiutTestPassed, aTestNo);
+		}
+	else
+		{
+		test.Printf(KMiutTestFailed, aTestNo);
+		}
+	}
+
+LOCAL_C void StoreMessageHeaderL(CImHeader* aCImHeader)
+	{
+	testUtils->iMsvEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId);
+	testUtils->iMsvEntry->CreateL(entry);
+	TRAPD(error,testUtils->iMsvEntry->SetEntryL(entry.Id()));
+	CMsvStore* fileStore = testUtils->iMsvEntry->EditStoreL();
+	CleanupStack::PushL(fileStore);
+	aCImHeader->StoreL(*fileStore);
+	fileStore->CommitL();
+	CleanupStack::PopAndDestroy(); // filestore
+	}
+
+LOCAL_C void RestoreMessageHeaderL(CImHeader* aCImHeader)
+	{
+	aCImHeader->Reset();
+	CMsvStore* fStore=testUtils->iMsvEntry->ReadStoreL();
+	CleanupStack::PushL(fStore);
+	aCImHeader->RestoreL(*fStore);
+	CleanupStack::PopAndDestroy(); //fStore
+	}
+
+//
+// CImHeader Test Functions //
+//
+
+LOCAL_C void CreateMessageHeader()
+	{
+	// a bunch of data for the header object....
+	imHeader->Reset();
+	imHeader->SetSubjectL(KMiutSubject);
+	imHeader->SetImMsgIdL(KMiutMsgId);
+	imHeader->SetFromL(KMiutFrom);
+	imHeader->SetReplyToL(KMiutReplyTo);
+	imHeader->SetReceiptAddressL(KMiutReceiptAddress);
+	imHeader->SetRemoteSize(KMiutRemoteSize);
+
+	imHeader->ToRecipients().AppendL(KMiutToRecipients1);
+	imHeader->ToRecipients().AppendL(KMiutToRecipients2);
+	imHeader->CcRecipients().AppendL(KMiutCcRecipients1);
+	imHeader->CcRecipients().AppendL(KMiutCcRecipients2);
+	imHeader->BccRecipients().AppendL(KMiutBccRecipients);
+	imHeader->SetBodyEncoding(EMsgOutboxMIME);
+	log->AppendComment(_L8("\tCreated Message Header 1"));
+	}
+
+LOCAL_C void CreateMessageHeader2()
+	{
+	// a bunch of data for the header object....
+	imHeader->Reset();
+	imHeader->SetSubjectL(KMiutSubject);
+
+	imHeader->SetImMsgIdL(KMiutMsgId);
+	imHeader->SetReceiptAddressL(KMiutReceiptAddress);
+
+	imHeader->SetFromL(KMiutFrom);
+	imHeader->SetReplyToL(KMiutReplyTo);
+	imHeader->SetRemoteSize(KMiutRemoteSize);
+
+	imHeader->ToRecipients().AppendL(KMiutToRecipients1);
+	imHeader->ToRecipients().AppendL(KMiutToRecipients2);
+	imHeader->CcRecipients().AppendL(KMiutCcRecipients1);
+	imHeader->CcRecipients().AppendL(KMiutCcRecipients2);
+	imHeader->BccRecipients().AppendL(KMiutBccRecipients);
+	
+	imHeader->SetResentMsgIdL(KMiutResentMsgId);
+	imHeader->SetResentFromL(KMiutResentFrom);
+	imHeader->ResentToRecipients().AppendL(KMiutResentToRecipients1);
+	imHeader->ResentToRecipients().AppendL(KMiutResentToRecipients2);
+	imHeader->ResentCcRecipients().AppendL(KMiutResentCcRecipients1);
+	imHeader->ResentCcRecipients().AppendL(KMiutResentCcRecipients2);
+	imHeader->ResentBccRecipients().AppendL(KMiutResentBccRecipients);
+	imHeader->SetBodyEncoding(EMsgOutboxMIME);
+	log->AppendComment(_L8("\tCreated Message Header 2"));
+	}
+
+LOCAL_C void CreateMessageHeader3()
+	{
+	//Create message header without receipt address
+	imHeader->Reset();
+	imHeader->SetSubjectL(KMiutSubject);
+	imHeader->SetImMsgIdL(KMiutMsgId);
+	imHeader->SetFromL(KMiutFrom);
+	imHeader->SetReplyToL(KMiutReplyTo);
+	imHeader->SetRemoteSize(KMiutRemoteSize);
+
+	imHeader->ToRecipients().AppendL(KMiutToRecipients1);
+	imHeader->ToRecipients().AppendL(KMiutToRecipients2);
+	imHeader->CcRecipients().AppendL(KMiutCcRecipients1);
+	imHeader->CcRecipients().AppendL(KMiutCcRecipients2);
+	imHeader->BccRecipients().AppendL(KMiutBccRecipients);
+	imHeader->SetBodyEncoding(EMsgOutboxMIME);
+	log->AppendComment(_L8("\tCreated Message Header 1"));
+	}
+
+//The function populates the header with sender address in Cc list. 
+//Also inserts duplicate addresses in both To and Cc list.
+LOCAL_C void CreateMessageHeader4()
+	{
+	imHeader->Reset();
+	imHeader->SetSubjectL(KMiutSubject);
+	imHeader->SetImMsgIdL(KMiutMsgId);
+	imHeader->SetFromL(KMiutFrom);
+	imHeader->SetRemoteSize(KMiutRemoteSize);
+
+	imHeader->ToRecipients().AppendL(KMiutToRecipients1);
+	imHeader->ToRecipients().AppendL(KMiutToRecipients2);
+	imHeader->ToRecipients().AppendL(KMiutToRecipients2);
+	
+	imHeader->CcRecipients().AppendL(KMiutFrom);
+	imHeader->CcRecipients().AppendL(KMiutCcRecipients1);
+	imHeader->CcRecipients().AppendL(KMiutCcRecipients1);
+	
+	imHeader->SetBodyEncoding(EMsgOutboxMIME);
+	log->AppendComment(_L8("\tCreated Message Header 4"));
+	}
+
+LOCAL_C void CreateLongMessageHeader()
+	{
+	// a bunch of data for the header object....
+	// all the fields are set to a length greater than 1000 i.e 1001
+
+	imHeader->Reset();
+	longValue.Fill('x',KMaxImHeaderStringLengthLong);
+	longValue2.Fill('x',KMaxImHeaderStringLengthLong);
+
+	imHeader->SetSubjectL(longValue);
+
+	imHeader->SetImMsgIdL(longValue2);
+	imHeader->SetReceiptAddressL(longValue);
+
+	imHeader->SetFromL(longValue);
+	imHeader->SetReplyToL(longValue);
+	imHeader->SetRemoteSize(KMiutRemoteSize);
+
+	imHeader->ToRecipients().AppendL(longValue);
+	imHeader->ToRecipients().AppendL(longValue);
+	imHeader->CcRecipients().AppendL(longValue);
+	imHeader->CcRecipients().AppendL(longValue);
+	imHeader->BccRecipients().AppendL(longValue);
+
+	imHeader->SetResentMsgIdL(longValue2);
+	imHeader->SetResentFromL(longValue);
+	imHeader->ResentToRecipients().AppendL(longValue);
+	imHeader->ResentToRecipients().AppendL(longValue);
+	imHeader->ResentCcRecipients().AppendL(longValue);
+	imHeader->ResentCcRecipients().AppendL(longValue);
+	imHeader->ResentBccRecipients().AppendL(longValue);
+	imHeader->SetBodyEncoding(EMsgOutboxMIME);
+	log->AppendComment(_L8("\tCreated Long Message Header"));
+	}
+
+LOCAL_C TBool CheckGB2312Descriptor(const TDesC &aDes)
+	{
+	TUint16 refDecodeData[42]={0x7F8E,0xFFFD,0x5766,0x627F,0x7BA1,0x5236,0x6838,0x5B50,0x539F,0x6599,
+		0x8D70,0x79C1,0x56F0,0xFFFD,0x003C,0x0069,0x0062,0x0072,0x0061,0x0068,0x0069,
+		0x006D,0x002E,0x0072,0x0061,0x0068,0x006D,0x0061,0x006E,0x0040,0x0073,0x0079,
+		0x006D,0x0062,0x0069,0x0061,0x006E,0x002E,0x0063,0x006F,0x006D,0x003E};
+
+
+	TPtrC16 compareagainst(refDecodeData,42);
+
+	return(aDes.Compare(compareagainst)==0 ? ETrue : EFalse);
+	}
+
+LOCAL_C void CreateGB2312EncodedNonMimeMessageHeader(CImHeader *aHeader)
+	{
+	// a bunch of data for the header object....
+	// all the fields are set to a length greater than 1000 i.e 1001
+	aHeader->Reset();
+	longValue.Zero();
+	longValue.Copy(_L8("美國坦承管制核子原料走私困難<ibrahim.rahman@symbian.com>"));
+
+	
+	aHeader->SetSubjectL(longValue);
+	aHeader->ToRecipients().AppendL(longValue);
+	log->AppendComment(_L8("\tCreated Encoded Non Mime Message Header"));
+
+	longValue.Zero();
+	}
+
+LOCAL_C void CreateEncodedMessageHeader(TBool aWrongEncoding, CImHeader *aHeader)
+	{
+	// a bunch of data for the header object....
+	// all the fields are set to a length greater than 1000 i.e 1001
+	aHeader->Reset();
+	//longValue.Fill('x',KMaxImHeaderStringLengthLong);
+	//longValue2.Fill('x',KMaxImHeaderStringLengthLong);
+	longValue.Zero();
+	if (!aWrongEncoding)
+		longValue.Copy(_L8("=?gb2312?B?yrnTw1NPSFW3/s7xxve3osvN08q8/iB0ZXN0IGNoaW5lc2UgY2hhcmFjdGU=?=<ibrahim.rahman@symbian.com>"));
+	else
+		longValue.Copy(_L8("=?utf-7?B?yrnTw1NPSFW3/s7xxve3osvN08q8/iB0ZXN0IGNoaW5lc2UgY2hhcmFjdGU=?=<ibrahim.rahman@symbian.com>"));
+
+	longValue2.Zero();
+	if (!aWrongEncoding)
+		longValue2.Copy(_L8("=?gb2312?B?suLK1NbQzsTX1rf7oaF0ZXN0IGNoaW5lc2UgY2hhcmFjdGVycw==?="));
+	else
+		longValue2.Copy(_L8("=?utf-7?B?suLK1NbQzsTX1rf7oaF0ZXN0IGNoaW5lc2UgY2hhcmFjdGVycw==?="));
+
+	aHeader->SetSubjectL(longValue2);
+	aHeader->SetFromL(longValue);
+
+	aHeader->ToRecipients().AppendL(longValue);
+	aHeader->ToRecipients().AppendL(longValue);
+
+	aHeader->CcRecipients().AppendL(longValue);
+	aHeader->CcRecipients().AppendL(longValue);
+
+	aHeader->BccRecipients().AppendL(longValue);
+
+	log->AppendComment(_L8("\tCreated Encoded Message Header"));
+
+	longValue.Zero();
+	longValue2.Zero();
+	}
+
+
+LOCAL_C TBool CompareFilledMessageHeader(TInt aTest)
+	{
+	// need to check each of the fields of the stored header (imHeaderVerify) are 
+	// the same as that originally entered (imHeader)
+	TBool result = ETrue;
+	log->AppendComment(_L8("\tComparing Filled Message Header"));
+	TBool result1=((imHeader->Subject())==(imHeaderVerify->Subject()));
+	if (!result1)
+		log->AppendError(_L8("\t\tSubjects not identical"),-1);
+	result &= result1;
+	TBool result2=((imHeader->ImMsgId())==(imHeaderVerify->ImMsgId()));
+	if (!result2)
+		log->AppendError(_L8("\t\tMsgIds not identical"),-1);
+	result &= result2;
+	TBool result3=((imHeader->From())==(imHeaderVerify->From()));
+	if (!result3)
+		log->AppendError(_L8("\t\tFrom fields not identical"),-1);
+	result &= result3;
+	TBool result3a=((imHeader->ReceiptAddress())==(imHeaderVerify->ReceiptAddress()));
+	if (!result3a)
+		log->AppendError(_L8("\t\tRecipient Address fields not identical"),-1);
+	result &= result3a;
+	TBool result4=((imHeader->ReplyTo())==(imHeaderVerify->ReplyTo()));
+	if (!result4)
+		log->AppendError(_L8("\t\tReplyTo fields not identical"),-1);
+	result &= result4;
+
+	TInt ii;
+	TBool result5 = ETrue;
+	for ( ii=0; ii<imHeader->ToRecipients().Count(); ii++)
+		{
+		if (imHeader->ToRecipients().Count()==imHeaderVerify->ToRecipients().Count())
+			result5&=((imHeader->ToRecipients()[ii])==(imHeaderVerify->ToRecipients()[ii]));
+		else
+			result5&=EFalse;
+		}
+	if (!result5)
+		log->AppendError(_L8("\t\tTo Recipients not identical"),-1);
+	result &= result5;
+
+	TBool result6 = ETrue;
+	for ( ii=0; ii<imHeader->CcRecipients().Count(); ii++)
+		{
+		if (imHeader->CcRecipients().Count()==imHeaderVerify->CcRecipients().Count())
+			result6&=((imHeader->CcRecipients()[ii])==(imHeaderVerify->CcRecipients()[ii]));
+		else
+			result6&=EFalse;
+		}
+	if (!result6)
+		log->AppendError(_L8("\t\tCc Recipients not identical"),-1);
+	result &= result6;
+
+	TBool result7 = ETrue;
+	for ( ii=0; ii<imHeader->BccRecipients().Count(); ii++)
+		{
+		if (imHeader->BccRecipients().Count()==imHeaderVerify->BccRecipients().Count())
+			result7&=((imHeader->BccRecipients()[ii])==(imHeaderVerify->BccRecipients()[ii]));
+		else
+			result7&=EFalse;
+		}
+	if (!result7)
+		log->AppendError(_L8("\t\tBcc Recipients not identical"),-1);
+	result &= result7;
+
+	TBool result8=((imHeader->ResentMsgId())==(imHeaderVerify->ResentMsgId()));
+	if (!result8)
+		log->AppendError(_L8("\t\tResent-MsgIds not identical"),-1);
+	result &= result8;
+	TBool result9=((imHeader->ResentFrom())==(imHeaderVerify->ResentFrom()));
+	if (!result9)
+		log->AppendError(_L8("\t\tResent-From fields not identical"),-1);
+	result &= result9;
+
+	TBool result10 = ETrue;
+	for ( ii=0; ii<imHeader->ResentToRecipients().Count(); ii++)
+		{
+		if (imHeader->ResentToRecipients().Count()==imHeaderVerify->ResentToRecipients().Count())
+			result10&=((imHeader->ResentToRecipients()[ii])==(imHeaderVerify->ResentToRecipients()[ii]));
+		else
+			result10&=EFalse;
+		}
+	if (!result10)
+		log->AppendError(_L8("\t\tResent-To Recipients not identical"),-1);
+	result &= result10;
+
+	TBool result11 = ETrue;
+	for ( ii=0; ii<imHeader->ResentCcRecipients().Count(); ii++)
+		{
+		if (imHeader->ResentCcRecipients().Count()==imHeaderVerify->ResentCcRecipients().Count())
+			result11&=((imHeader->ResentCcRecipients()[ii])==(imHeaderVerify->ResentCcRecipients()[ii]));
+		else
+			result11&=EFalse;
+		}
+	if (!result11)
+		log->AppendError(_L8("\t\tResent-Cc Recipients not identical"),-1);
+	result &= result11;
+
+	TBool result12 = ETrue;
+	for ( ii=0; ii<imHeader->ResentBccRecipients().Count(); ii++)
+		{
+		if (imHeader->ResentBccRecipients().Count()==imHeaderVerify->ResentBccRecipients().Count())
+			result12&=((imHeader->ResentBccRecipients()[ii])==(imHeaderVerify->ResentBccRecipients()[ii]));
+		else
+			result12&=EFalse;
+		}
+	if (!result12)
+		log->AppendError(_L8("\t\tResent-Bcc Recipients not identical"),-1);
+	result &= result12;
+
+	TBool result13=((imHeader->BodyEncoding())==(imHeaderVerify->BodyEncoding()));
+	if (!result13)
+		log->AppendError(_L8("\t\tBody Encoding (charset) not identical"),-1);
+	result &= result13;
+
+	ResultOfTest(result,aTest);
+	log->AppendComment(_L8("\tCompared Filled Message Header"));
+	return result;
+	}
+
+LOCAL_C TBool CompareBlankMessageHeader(TInt aTest)
+	{
+	// need to check each of the fields of the stored header (imHeaderVerify) are 
+	// the same as that originally entered (imHeader).  Here the length should be 
+	// 0 so we don't actually need to compare!
+	TBool result = ETrue;
+	log->AppendComment(_L8("\tComparing Blank Message Header"));
+	TBool result1=((imHeader->Subject().Length()==0)==(imHeaderVerify->Subject().Length()==0));
+	if (!result1)
+		log->AppendError(_L8("\t\tSubjects not identical"),-1);
+	result &= result1;
+	TBool result2=((imHeader->ImMsgId().Length()==0)==(imHeaderVerify->ImMsgId().Length()==0));
+	if (!result2)
+		log->AppendError(_L8("\t\tMsgIds not identical"),-1);
+	result &= result2;
+	TBool result3=((imHeader->From().Length()==0)==(imHeaderVerify->From().Length()==0));
+	if (!result3)
+		log->AppendError(_L8("\t\tFrom fields not identical"),-1);
+	result &= result3;
+	TBool result3a=((imHeader->ReceiptAddress().Length()==0)==(imHeaderVerify->ReceiptAddress().Length()==0));
+	if (!result3a)
+		log->AppendError(_L8("\t\tRecipient Address fields not identical"),-1);
+	result &= result3a;
+	TBool result4=((imHeader->ReplyTo().Length()==0)==(imHeaderVerify->ReplyTo().Length()==0));
+	if (!result4)
+		log->AppendError(_L8("\t\tReplyTos not identical"),-1);
+	result &= result4;
+
+	TBool result5=(imHeader->ToRecipients().Count()==imHeaderVerify->ToRecipients().Count()!=EFalse);
+	if (!result5)
+		log->AppendError(_L8("\t\tTo Recipients not identical"),-1);
+	result &= result5;
+	TBool result6=(imHeader->CcRecipients().Count()==imHeaderVerify->CcRecipients().Count()!=EFalse);
+	if (!result6)
+		log->AppendError(_L8("\t\tCc Recipients not identical"),-1);
+	result &= result6;
+	TBool result7=(imHeader->BccRecipients().Count()==imHeaderVerify->BccRecipients().Count()!=EFalse);
+	if (!result7)
+		log->AppendError(_L8("\t\tBcc Recipients not identical"),-1);
+	result &= result7;
+
+	TBool result8=((imHeader->ResentMsgId().Length()==0)==(imHeaderVerify->ResentMsgId().Length()==0));
+	if (!result8)
+		log->AppendError(_L8("\t\tResent-MsgIds not identical"),-1);
+	result &= result8;
+	TBool result9=((imHeader->ResentFrom().Length()==0)==(imHeaderVerify->ResentFrom().Length()==0));
+	if (!result9)
+		log->AppendError(_L8("\t\tResent-From fields not identical"),-1);
+	result &= result9;
+
+	TBool result10=(imHeader->ResentToRecipients().Count()==imHeaderVerify->ResentToRecipients().Count()!=EFalse);
+	if (!result10)
+		log->AppendError(_L8("\t\tResent-To Recipients not identical"),-1);
+	result &= result10;
+	TBool result11=(imHeader->ResentCcRecipients().Count()==imHeaderVerify->ResentCcRecipients().Count()!=EFalse);
+	if (!result11)
+		log->AppendError(_L8("\t\tResent-Cc Recipients not identical"),-1);
+	result &= result11;
+	TBool result12=(imHeader->ResentBccRecipients().Count()==imHeaderVerify->ResentBccRecipients().Count()!=EFalse);
+	if (!result12)
+		log->AppendError(_L8("\t\tResent-Bcc Recipients not identical"),-1);
+	result &= result12;
+
+	TBool result13=((imHeader->BodyEncoding())==(imHeaderVerify->BodyEncoding()));
+	if (!result13)
+		log->AppendError(_L8("\t\tBody Encoding (charset) not identical"),-1);
+	result &= result13;
+
+	ResultOfTest(result,aTest);
+	log->AppendComment(_L8("\tCompared Blank Message Header"));
+	return result;
+	}
+
+LOCAL_C TBool CompareLongMessageHeader(TInt aTest)
+	{
+	log->AppendComment(_L8("\tComparing Long Message Header"));
+	TBool result = ETrue;
+	TBool result1=((imHeader->Subject().Left(KMaxImHeaderStringLength))==(imHeaderVerify->Subject()));
+	if (!result1)
+		log->AppendError(_L8("\t\tSubjects not identical"),-1);
+	result &= result1;
+	TBool result2=((imHeader->ImMsgId().Left(KMaxImHeaderStringLength))==(imHeaderVerify->ImMsgId()));
+	if (!result2)
+		log->AppendError(_L8("\t\tMessageIds not identical"),-1);
+	result &= result2;
+	TBool result3=((imHeader->From().Left(KMaxImHeaderStringLength))==(imHeaderVerify->From()));
+	if (!result3)
+		log->AppendError(_L8("\t\tFrom Fields not identical"),-1);
+	result &= result3;
+	TBool result3a=((imHeader->ReceiptAddress().Left(KMaxImHeaderStringLength))==(imHeaderVerify->ReceiptAddress()));
+	if (!result3a)
+		log->AppendError(_L8("\t\tReplyTos not identical"),-1);
+	result &= result3a;
+	TBool result4=((imHeader->ReplyTo().Left(KMaxImHeaderStringLength))==(imHeaderVerify->ReplyTo()));
+	if (!result4)
+		log->AppendError(_L8("\t\tReplyTos not identical"),-1);
+	result &= result4;
+
+	TBool result5 = ETrue;
+	TInt ii;
+	for ( ii=0; ii<imHeader->ToRecipients().Count(); ii++)
+		{
+		if (imHeader->ToRecipients().Count()==imHeaderVerify->ToRecipients().Count())
+			{
+			longValue=(imHeader->ToRecipients()[ii]);
+			longValue.SetLength(KMaxImHeaderStringLength);
+			result5&=((longValue)==(imHeaderVerify->ToRecipients()[ii].Left(KMaxImHeaderStringLength)));
+			if (!result5)
+				log->AppendError(_L8("\t\tTo Recipients not identical"),-1);
+			}
+		else
+			result5&=EFalse;
+		}
+	result &= result5;
+	TBool result6 = ETrue;
+	for ( ii=0; ii<imHeader->CcRecipients().Count(); ii++)
+		{
+		if (imHeader->CcRecipients().Count()==imHeaderVerify->CcRecipients().Count())
+			{
+			longValue=(imHeader->CcRecipients()[ii]);
+			longValue.SetLength(KMaxImHeaderStringLength);
+			result6&=((longValue)==(imHeaderVerify->CcRecipients()[ii].Left(KMaxImHeaderStringLength)));
+			if (!result6)
+				log->AppendError(_L8("\t\tCc Recipients not identical"),-1);
+			}
+		else
+			result6&=EFalse;
+		}
+	result &= result6;
+	TBool result7 = ETrue;
+	for ( ii=0; ii<imHeader->BccRecipients().Count(); ii++)
+		{
+		if (imHeader->BccRecipients().Count()==imHeaderVerify->BccRecipients().Count())
+			{
+			longValue=(imHeader->BccRecipients()[ii]);
+			longValue.SetLength(KMaxImHeaderStringLength);
+			result7&=((longValue)==(imHeaderVerify->BccRecipients()[ii].Left(KMaxImHeaderStringLength)));
+			if (!result7)
+				log->AppendError(_L8("\t\tBcc Recipients not identical"),-1);
+			}
+		else
+			result7&=EFalse;
+		}
+	result &= result7;
+
+	TBool result8=((imHeader->ResentMsgId().Left(KMaxImHeaderStringLength))==(imHeaderVerify->ResentMsgId()));
+	if (!result8)
+		log->AppendError(_L8("\t\tResent-MessageIDs not identical"),-1);
+	result &= result8;
+	TBool result9=((imHeader->ResentFrom().Left(KMaxImHeaderStringLength))==(imHeaderVerify->ResentFrom()));
+	if (!result9)
+		log->AppendError(_L8("\t\tResent-Froms not identical"),-1);
+	result &= result9;
+	TBool result10 = ETrue;
+	for ( ii=0; ii<imHeader->ResentToRecipients().Count(); ii++)
+		{
+		if (imHeader->ResentToRecipients().Count()==imHeaderVerify->ResentToRecipients().Count())
+			{
+			longValue=(imHeader->ResentToRecipients()[ii]);
+			longValue.SetLength(KMaxImHeaderStringLength);
+			result10&=((longValue)==(imHeaderVerify->ResentToRecipients()[ii].Left(KMaxImHeaderStringLength)));
+			if (!result10)
+				log->AppendError(_L8("\t\tResent-To Recipients not identical"),-1);
+			}
+		else
+			result10&=EFalse;
+		}
+	result &= result10;
+	TBool result11 = ETrue;
+	for ( ii=0; ii<imHeader->ResentCcRecipients().Count(); ii++)
+		{
+		if (imHeader->ResentCcRecipients().Count()==imHeaderVerify->ResentCcRecipients().Count())
+			{
+			longValue=(imHeader->ResentCcRecipients()[ii]);
+			longValue.SetLength(KMaxImHeaderStringLength);
+			result11&=((longValue)==(imHeaderVerify->ResentCcRecipients()[ii].Left(KMaxImHeaderStringLength)));
+			if (!result11)
+				log->AppendError(_L8("\t\tResent-Cc Recipients not identical"),-1);
+			}
+		else
+			result11&=EFalse;
+		}
+	result &= result11;
+	TBool result12 = ETrue;
+	for ( ii=0; ii<imHeader->ResentBccRecipients().Count(); ii++)
+		{
+		if (imHeader->ResentBccRecipients().Count()==imHeaderVerify->ResentBccRecipients().Count())
+			{
+			longValue=(imHeader->ResentBccRecipients()[ii]);
+			longValue.SetLength(KMaxImHeaderStringLength);
+			result12&=((longValue)==(imHeaderVerify->ResentBccRecipients()[ii].Left(KMaxImHeaderStringLength)));
+			if (!result12)
+				log->AppendError(_L8("\t\tResent-Bcc Recipients not identical"),-1);
+			}
+		else
+			result12&=EFalse;
+		}
+	result &= result12;
+
+	TBool result13=((imHeader->BodyEncoding())==(imHeaderVerify->BodyEncoding()));
+	if (!result13)
+		log->AppendError(_L8("\t\tBody Encoding (charset) not identical"),-1);
+	result &= result13;
+
+	log->AppendComment(_L8("\tCompared Long Message Header"));
+	ResultOfTest(result,aTest);
+
+	return result;
+	}
+
+//
+
+
+LOCAL_C TBool CompareEncodedMessageHeader(TInt aTest)
+	{
+	log->AppendComment(_L8("\tComparing Encoded Message Header"));
+	TBool result = ETrue;
+
+	TBool result1=((imHeader->Subject().Left(KMaxImHeaderStringLength))==(imHeaderVerify->Subject()));
+	if (!result1)
+		log->AppendError(_L8("\t\tSubjects not identical"),-1);
+	result &= result1;
+
+	TBool result3=((imHeader->From().Left(KMaxImHeaderStringLength))==(imHeaderVerify->From()));
+	if (!result3)
+		log->AppendError(_L8("\t\tFrom Fields not identical"),-1);
+	result &= result3;
+
+	TBool result4=((imHeader->ReplyTo().Left(KMaxImHeaderStringLength))==(imHeaderVerify->ReplyTo()));
+	if (!result4)
+		log->AppendError(_L8("\t\tReplyTos not identical"),-1);
+	result &= result4;
+
+	TBool result5 = ETrue;
+	TInt ii;
+	for ( ii=0; ii<imHeader->ToRecipients().Count(); ii++)
+		{
+		if (imHeader->ToRecipients().Count()==imHeaderVerify->ToRecipients().Count())
+			{
+			longValue=(imHeader->ToRecipients()[ii]);
+			result5&=((longValue)==(imHeaderVerify->ToRecipients()[ii]));
+			if (!result5)
+				log->AppendError(_L8("\t\tTo Recipients not identical"),-1);
+			}
+		else
+			result5&=EFalse;
+		}
+	result &= result5;
+	TBool result6 = ETrue;
+	for ( ii=0; ii<imHeader->CcRecipients().Count(); ii++)
+		{
+		if (imHeader->CcRecipients().Count()==imHeaderVerify->CcRecipients().Count())
+			{
+			longValue=(imHeader->CcRecipients()[ii]);
+			result6&=((longValue)==(imHeaderVerify->CcRecipients()[ii]));
+			if (!result6)
+				log->AppendError(_L8("\t\tCc Recipients not identical"),-1);
+			}
+		else
+			result6&=EFalse;
+		}
+	result &= result6;
+	TBool result7 = ETrue;
+	for ( ii=0; ii<imHeader->BccRecipients().Count(); ii++)
+		{
+		if (imHeader->BccRecipients().Count()==imHeaderVerify->BccRecipients().Count())
+			{
+			longValue=(imHeader->BccRecipients()[ii]);
+			result7&=((longValue)==(imHeaderVerify->BccRecipients()[ii]));
+			if (!result7)
+				log->AppendError(_L8("\t\tBcc Recipients not identical"),-1);
+			}
+		else
+			result7&=EFalse;
+		}
+	result &= result7;
+
+	
+	TBool result13=((imHeader->BodyEncoding())==(imHeaderVerify->BodyEncoding()));
+	if (!result13)
+		log->AppendError(_L8("\t\tBody Encoding (charset) not identical"),-1);
+	result &= result13;
+
+	log->AppendComment(_L8("\tCompared Encoded Message Header"));
+	ResultOfTest(result, aTest);
+
+	return result;
+	}
+
+
+
+LOCAL_C TBool CompareEncodedMessageHeaderExpectDifferent(TInt aTest)
+	{
+	log->AppendComment(_L8("\tComparing Encoded Message Header"));
+	TBool result = ETrue;
+
+	TBool result1=((imHeader->Subject().Left(KMaxImHeaderStringLength))==(imHeaderVerify->Subject()));
+	result &= result1;
+
+	TBool result3=((imHeader->From().Left(KMaxImHeaderStringLength))==(imHeaderVerify->From()));
+	result &= result3;
+
+	TBool result4=((imHeader->ReplyTo().Left(KMaxImHeaderStringLength))==(imHeaderVerify->ReplyTo()));
+	result &= result4;
+
+	TBool result5 = ETrue;
+	TInt ii;
+	for ( ii=0; ii<imHeader->ToRecipients().Count(); ii++)
+		{
+		if (imHeader->ToRecipients().Count()==imHeaderVerify->ToRecipients().Count())
+			{
+			longValue=(imHeader->ToRecipients()[ii]);
+			result5&=((longValue)==(imHeaderVerify->ToRecipients()[ii]));
+			}
+		else
+			result5&=EFalse;
+		}
+	result &= result5;
+	TBool result6 = ETrue;
+	for ( ii=0; ii<imHeader->CcRecipients().Count(); ii++)
+		{
+		if (imHeader->CcRecipients().Count()==imHeaderVerify->CcRecipients().Count())
+			{
+			longValue=(imHeader->CcRecipients()[ii]);
+			result6&=((longValue)==(imHeaderVerify->CcRecipients()[ii]));
+			}
+		else
+			result6&=EFalse;
+		}
+	result &= result6;
+	TBool result7 = ETrue;
+	for ( ii=0; ii<imHeader->BccRecipients().Count(); ii++)
+		{
+		if (imHeader->BccRecipients().Count()==imHeaderVerify->BccRecipients().Count())
+			{
+			longValue=(imHeader->BccRecipients()[ii]);
+			result7&=((longValue)==(imHeaderVerify->BccRecipients()[ii]));
+			}
+		else
+			result7&=EFalse;
+		}
+	result &= result7;
+
+	
+	TBool result13=((imHeader->BodyEncoding())==(imHeaderVerify->BodyEncoding()));
+	result &= result13;
+
+	log->AppendComment(_L8("\tCompared Encoded Message Header Different"));
+	result = !result;
+	ResultOfTest(result, aTest);
+
+	return result;
+	}
+
+
+//
+
+LOCAL_C TBool FilledMessageHeader(TInt aTest)
+	{
+	// Fill in the fields in the header
+	log->AppendComment(_L8("\tFilled Message Header Test (Test 1)"));
+	entry.iType = KUidMsvMessageEntry;
+	entry.iMtm = KUidMsgTypeIMAP4;
+	entry.iServiceId = KMsvLocalServiceIndexEntryId;
+
+	imHeader = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	imHeaderVerify = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	CreateMessageHeader();
+	StoreMessageHeaderL(imHeader);
+	RestoreMessageHeaderL(imHeaderVerify);
+	TBool result=CompareFilledMessageHeader(aTest);
+	CleanupStack::PopAndDestroy(2); //imHeader, imHeaderVerify
+	return result;
+	}
+
+LOCAL_C TBool BlankMessageHeader(TInt aTest)
+	{
+	// the Headers contain blank fields
+	log->AppendComment(_L8("\tBlank Message Header Test (Test 2)"));
+	entry.iType = KUidMsvMessageEntry;
+	entry.iMtm = KUidMsgTypeIMAP4;
+	entry.iServiceId = KMsvLocalServiceIndexEntryId;
+	imHeader = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	imHeaderVerify = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	StoreMessageHeaderL(imHeader);
+	RestoreMessageHeaderL(imHeaderVerify);
+	TBool result=CompareBlankMessageHeader(aTest);
+	CleanupStack::PopAndDestroy(2); //imHeader, imHeaderVerify
+	return result;
+	}
+
+LOCAL_C TBool LongMessageHeader(TInt aTest)
+	{
+	log->AppendComment(_L8("\tLong Message Header Test (Test 3)"));
+	entry.iType = KUidMsvMessageEntry;
+	entry.iMtm = KUidMsgTypeIMAP4;
+	entry.iServiceId = KMsvLocalServiceIndexEntryId;
+	// the Headers contain fields that are longer than 1000 chars
+	imHeader = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	imHeaderVerify = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	CreateLongMessageHeader();
+	StoreMessageHeaderL(imHeader);
+	RestoreMessageHeaderL(imHeaderVerify);
+	TBool result=CompareLongMessageHeader(aTest);
+	CleanupStack::PopAndDestroy(2); //imHeader, imHeaderVerify
+	return result;
+	}
+
+
+LOCAL_C TBool MessageHeaderReDecodeHeadersOOMTest(TInt aTest)
+	{
+	log->AppendComment(_L8("\tEncoded Message Header Test (Test 13)"));
+	entry.iType = KUidMsvMessageEntry;
+	entry.iMtm = KUidMsgTypeIMAP4;
+	entry.iServiceId = KMsvLocalServiceIndexEntryId;
+	
+	imHeaderVerify = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	
+	RFs& fileSvrSession = testUtils->iMsvEntry->Session().FileSession();
+	CCnvCharacterSetConverter* characterConverter = CCnvCharacterSetConverter::NewL();
+	CleanupStack::PushL(characterConverter);
+	CImConvertCharconv* charConv = CImConvertCharconv::NewL(*characterConverter, fileSvrSession);
+	CleanupStack::PushL(charConv);
+	CImConvertHeader* headerConverter = CImConvertHeader::NewL(*charConv); 
+	CleanupStack::PushL(headerConverter);
+
+	// Create the correct result in imHeaderVerify
+	CreateEncodedMessageHeader(EFalse, imHeaderVerify);
+	headerConverter->SetMessageType(ETrue);
+	headerConverter->DecodeAllHeaderFieldsL(*imHeaderVerify);
+
+	// Memory failure loop.
+	TBool result = ETrue;
+	TBool finished = EFalse;
+	TInt  theFailCount=0;
+	while (!finished)
+		{
+		// Create the correct result in imHeader
+		__UHEAP_MARK;
+		imHeader = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+		CreateEncodedMessageHeader(EFalse, imHeader);
+		headerConverter->SetMessageType(ETrue);
+		headerConverter->DecodeAllHeaderFieldsL(*imHeader);
+		imHeader->SetOverrideCharset(0x10000fbe);
+
+		__UHEAP_FAILNEXT(theFailCount);
+		theFailCount++;
+		TRAPD(err, imHeader->ReDecodeL(fileSvrSession));
+		__UHEAP_RESET;
+
+		if (err == KErrNone)
+			{
+			TBool compareResult = CompareEncodedMessageHeader(aTest);
+			if (!compareResult)
+				log->AppendError(_L8("\t\t\tComparing different out-of-memory redecode tests"), -1);
+			result &= compareResult;
+			finished = ETrue;
+			}
+		else
+			{
+			if (err != KErrNoMemory)
+				{
+				log->AppendError(_L8("\t\t\tOut-of-memory redecode tests resulted in leave other than KErrNoMemory"), -1);
+				result &= EFalse;
+				finished = ETrue;
+				}
+			}
+		CleanupStack::PopAndDestroy(imHeader);
+		__UHEAP_MARKEND;
+		}
+	CleanupStack::PopAndDestroy(4, imHeaderVerify);
+	return result;
+	}
+
+
+LOCAL_C TBool MessageHeaderDecodeAllHeadersOOMTest(TInt aTest)
+	{
+	log->AppendComment(_L8("\tEncoded Message Header Test (Test 12)"));
+	entry.iType = KUidMsvMessageEntry;
+	entry.iMtm = KUidMsgTypeIMAP4;
+	entry.iServiceId = KMsvLocalServiceIndexEntryId;
+	
+	imHeaderVerify = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	
+	RFs& fileSvrSession = testUtils->iMsvEntry->Session().FileSession();
+	CCnvCharacterSetConverter* characterConverter = CCnvCharacterSetConverter::NewL();
+	CleanupStack::PushL(characterConverter);
+	CImConvertCharconv* charConv = CImConvertCharconv::NewL(*characterConverter, fileSvrSession);
+	CleanupStack::PushL(charConv);
+	CImConvertHeader* headerConverter = CImConvertHeader::NewL(*charConv); 
+	CleanupStack::PushL(headerConverter);
+
+	// Create the correct result in imHeaderVerify
+	CreateEncodedMessageHeader(EFalse, imHeaderVerify);
+	headerConverter->SetMessageType(ETrue);
+	headerConverter->DecodeAllHeaderFieldsL(*imHeaderVerify);
+
+	// Memory failure loop.
+	TBool result = ETrue;
+	TBool finished = EFalse;
+	TInt  theFailCount=0;
+	while (!finished)
+		{
+		// Create the correct result in imHeader
+		__UHEAP_MARK;
+		imHeader = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+		CreateEncodedMessageHeader(EFalse, imHeader);
+		headerConverter->SetMessageType(ETrue);
+
+		__UHEAP_FAILNEXT(theFailCount);
+		theFailCount++;
+		TRAPD(err, headerConverter->DecodeAllHeaderFieldsL(*imHeader));
+		__UHEAP_RESET;
+
+		if (err == KErrNone)
+			{
+			TBool compareResult = CompareEncodedMessageHeader(aTest);
+			if (!compareResult)
+				log->AppendError(_L8("\t\t\tComparing different out-of-memory tests"), -1);
+			result &= compareResult;
+			finished = ETrue;
+			}
+		else
+			{
+			if (err != KErrNoMemory)
+				{
+				log->AppendError(_L8("\t\t\tOut-of-memory tests resulted in leave other than KErrNoMemory"), -1);
+				result &= EFalse;
+				finished = ETrue;
+				}
+			}
+		CleanupStack::PopAndDestroy(imHeader);
+		__UHEAP_MARKEND;
+		}
+	CleanupStack::PopAndDestroy(4, imHeaderVerify);
+	return result;
+	}
+
+LOCAL_C TBool EncodedMessageHeaderDecode(TInt aTest)
+	{
+	log->AppendComment(_L8("\tEncoded Message Header Test (Test 11)"));
+	entry.iType = KUidMsvMessageEntry;
+	entry.iMtm = KUidMsgTypeIMAP4;
+	entry.iServiceId = KMsvLocalServiceIndexEntryId;
+
+	imHeader = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	imHeaderVerify = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	
+	RFs& fileSvrSession = testUtils->iMsvEntry->Session().FileSession();
+	CCnvCharacterSetConverter* characterConverter = CCnvCharacterSetConverter::NewL();
+	CleanupStack::PushL(characterConverter);
+	CImConvertCharconv* charConv = CImConvertCharconv::NewL(*characterConverter, fileSvrSession);
+	CleanupStack::PushL(charConv);
+	CImConvertHeader* headerConverter = CImConvertHeader::NewL(*charConv); 
+	CleanupStack::PushL(headerConverter);
+
+	// Create the correct result in imHeaderVerify
+	CreateEncodedMessageHeader(EFalse, imHeaderVerify);
+	// Mime test verify header.
+	headerConverter->SetMessageType(ETrue);
+	headerConverter->DecodeAllHeaderFieldsL(*imHeaderVerify);
+	
+
+// Create the correct result in imHeader
+	CreateEncodedMessageHeader(EFalse, imHeader);
+	// Mime test verify header.
+	headerConverter->SetMessageType(ETrue);
+	headerConverter->DecodeAllHeaderFieldsL(*imHeader);
+	StoreMessageHeaderL(imHeader);
+	imHeader->Reset();
+	RestoreMessageHeaderL(imHeader);
+	_LIT(KDisappearMessage, "This should disappear.");
+
+	imHeader->SetSubjectL(KDisappearMessage);
+	TBool result = CompareEncodedMessageHeaderExpectDifferent(aTest);
+	if (!result)
+		log->AppendError(_L8("\t\t\tComparing different after SetSubject failed"), -1);
+
+	// Perform normal decoding initially then redecode to test copy encoded data in redecode
+	// step doesn't overwrite real encoded data with disappear message.
+	headerConverter->SetMessageType(ETrue);
+	headerConverter->DecodeAllHeaderFieldsL(*imHeader);
+	imHeader->ReDecodeL(fileSvrSession);
+	TBool result2 = CompareEncodedMessageHeader(aTest);
+	if (!result2)
+		log->AppendError(_L8("\t\t\tComparing after DecodeAllHeaderFields and ReDecode failed"), -1);
+	result &= result2;
+
+	CleanupStack::PopAndDestroy(5, imHeader);
+	return result;
+	}
+
+LOCAL_C TBool EncodedNonMimeMessageHeader(TInt)
+	{
+	log->AppendComment(_L8("\tEncoded Message Header Test (Test 10)"));
+	entry.iType = KUidMsvMessageEntry;
+	entry.iMtm = KUidMsgTypeIMAP4;
+	entry.iServiceId = KMsvLocalServiceIndexEntryId;
+
+	imHeader = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	imHeaderVerify = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	
+	RFs& fileSvrSession = testUtils->iMsvEntry->Session().FileSession();
+	CCnvCharacterSetConverter* characterConverter = CCnvCharacterSetConverter::NewL();
+	CleanupStack::PushL(characterConverter);
+	CImConvertCharconv* charConv = CImConvertCharconv::NewL(*characterConverter, fileSvrSession);
+	CleanupStack::PushL(charConv);
+	CImConvertHeader* headerConverter = CImConvertHeader::NewL(*charConv); 
+	CleanupStack::PushL(headerConverter);
+
+	// Create the correct result in imHeaderVerify
+	CreateGB2312EncodedNonMimeMessageHeader(imHeaderVerify);
+	// Non-Mime test verify header, this will decode with system default
+	// as this isn't GB2312 the verify header is incorrectly decoded
+	headerConverter->DecodeAllHeaderFieldsL(*imHeaderVerify);
+	
+	TBool result = ETrue;
+	if (CheckGB2312Descriptor(imHeaderVerify->Subject()) != EFalse || 
+		CheckGB2312Descriptor(imHeaderVerify->ToRecipients()[0]) != EFalse)
+		{
+		// The imVerifyHeader was decoded with the system default charset.
+		// It should not be the same as the properly decoded data.
+		result = EFalse;
+		}
+	if (!result)
+		log->AppendError(_L8("\t\t\tBad header decoded correctly with system charset"),-1);
+
+
+	// Create a header with bad data.
+	// Purposely use the incorrect charset data for a mime header.
+	CreateGB2312EncodedNonMimeMessageHeader(imHeader);
+	// imHeader should contain incorrect data.
+	headerConverter->DecodeAllHeaderFieldsL(*imHeader);
+	// Save bad header to CMsvStore,
+	StoreMessageHeaderL(imHeader);
+
+	CMsvStore* fStore=testUtils->iMsvEntry->ReadStoreL();
+	CleanupStack::PushL(fStore);
+	const TUid KUidMsgFileIMailEncodedHeader = {0x101FD0E3};
+	TBool result1=fStore->IsPresentL(KUidMsgFileIMailEncodedHeader);
+	CleanupStack::PopAndDestroy(); //fStore
+	if (!result1)
+		log->AppendError(_L8("\t\t\tEncoded Header stream missing"),-1);
+	result &= result1;
+
+	// Clear header and restore from the CMsvStore with the bad data.
+	imHeader->Reset();
+	RestoreMessageHeaderL(imHeader);
+
+	TBool result2 = ETrue;
+	if (CheckGB2312Descriptor(imHeader->Subject()) != EFalse || 
+		CheckGB2312Descriptor(imHeader->ToRecipients()[0]) != EFalse)
+		{
+		// The imHeader was decoded with the system default charset.
+		// It should not be the same as the properly decoded data.
+		result2 = EFalse;
+		}
+	if (!result2)
+		log->AppendError(_L8("\t\t\tBad header restored correctly"),-1);
+	result &= result2;
+		
+	imHeader->SetOverrideCharset(0x10000fbe);
+	TBool result3 = (imHeader->OverrideCharset() == 0x10000fbe);
+	if (!result3)
+		log->AppendError(_L8("\t\t\tGet / Set Overridecharset failed"),-1);
+	result &=result3;
+
+	// Redecode imHeader with the correct charset set as the override charset
+	// and compare with initial result.
+	imHeader->ReDecodeL(fileSvrSession);
+	TBool result4 = EFalse;
+	if (CheckGB2312Descriptor(imHeader->Subject()) != EFalse || 
+		CheckGB2312Descriptor(imHeader->ToRecipients()[0]) != EFalse)
+		{
+		// The imHeader was decoded with the override charset
+		// and matches the reference data.
+		result4 = ETrue;
+		}
+	if (!result4)
+		log->AppendError(_L8("\t\t\tRedecode with correct charset failed"),-1);
+	result &= result4;
+	
+	CleanupStack::PopAndDestroy(5, imHeader);
+	return result;
+	}
+
+LOCAL_C TBool EncodedMessageHeader(TInt aTest)
+	{
+	log->AppendComment(_L8("\tEncoded Message Header Test (Test 9)"));
+	entry.iType = KUidMsvMessageEntry;
+	entry.iMtm = KUidMsgTypeIMAP4;
+	entry.iServiceId = KMsvLocalServiceIndexEntryId;
+
+	// the Headers contain fields that are longer than 1000 chars
+
+	imHeader = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	imHeaderVerify = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	
+	RFs& fileSvrSession = testUtils->iMsvEntry->Session().FileSession();
+	CCnvCharacterSetConverter* characterConverter = CCnvCharacterSetConverter::NewL();
+	CleanupStack::PushL(characterConverter);
+	CImConvertCharconv* charConv = CImConvertCharconv::NewL(*characterConverter, fileSvrSession);
+	CleanupStack::PushL(charConv);
+	CImConvertHeader* headerConverter = CImConvertHeader::NewL(*charConv); 
+	CleanupStack::PushL(headerConverter);
+
+	// Create the correct result in imHeaderVerify
+	CreateEncodedMessageHeader(EFalse, imHeaderVerify);
+	// Mime test verify header.
+	headerConverter->SetMessageType(ETrue);
+	headerConverter->DecodeAllHeaderFieldsL(*imHeaderVerify);
+
+
+	// Create a header with bad data.
+	// Purposely use the incorrect charset data for a mime header.
+	CreateEncodedMessageHeader(ETrue, imHeader);
+	headerConverter->SetMessageType(ETrue);
+	// imHeader should contain incorrect data.
+	headerConverter->DecodeAllHeaderFieldsL(*imHeader);
+	// Save bad header to CMsvStore,
+	StoreMessageHeaderL(imHeader);
+
+	// for Chris
+	// Clear header and restore from the CMsvStore with the bad data.
+	imHeader->Reset();
+	RestoreMessageHeaderL(imHeader);
+
+	TBool result = CompareEncodedMessageHeaderExpectDifferent(aTest);
+	if (!result)
+		log->AppendError(_L8("\t\t\tRestore failed comparision"),-1);
+		
+	// set override charset and store the header
+	imHeader->SetOverrideCharset(0x10000fbe);
+	StoreMessageHeaderL(imHeader);
+	
+	// reset imHeader and check the override charset is also reset
+	imHeader->Reset();
+	imHeader->OverrideCharset();
+	TBool result1 = (imHeader->OverrideCharset() == 0);
+	if (!result1)
+		log->AppendError(_L8("\t\t\tOveride charset not zero after reset"),-1);
+	result &=result1;
+
+	// should have restored the bad data, and the override charset
+	RestoreMessageHeaderL(imHeader);
+	TBool result2 = (imHeader->OverrideCharset() == 0x10000fbe);
+	if (!result2)
+		log->AppendError(_L8("\t\t\tGet / Set Overridecharset failed"),-1);
+	result &=result2;
+
+	// Redecode imHeader with the correct charset set as the override charset
+	// and compare with initial result.
+	imHeader->ReDecodeL(fileSvrSession);
+	TBool result3 = CompareEncodedMessageHeader(aTest);
+	if (!result3)
+		log->AppendError(_L8("\t\t\tRedecode failed"),-1);
+	result &=result3;
+
+	// Test below is decode imHeader with correct charset.
+	// Override with purposely bad charset.
+	// Set override charset back to zero.
+	// Check it is back to its original state (i.e. imHeaderVerify)
+	imHeader->Reset();
+	CreateEncodedMessageHeader(EFalse, imHeader);
+	headerConverter->SetMessageType(ETrue);
+	// imHeader should contain correct data.
+	headerConverter->DecodeAllHeaderFieldsL(*imHeader);
+	// Should now be the same as the imHeaderVerify object.
+	TBool result4 = CompareEncodedMessageHeader(aTest);
+	if (!result4)
+		log->AppendError(_L8("\t\t\tCreated header data does not match verify header."),-1);
+	result &=result4;
+
+	// Set override charset to a purposely incorrect charset.
+	imHeader->SetOverrideCharset(0x10003b10);
+	imHeader->ReDecodeL(fileSvrSession);
+	TBool result5 = CompareEncodedMessageHeaderExpectDifferent(aTest);
+	if (!result5)
+		log->AppendError(_L8("\t\t\tReDecoding with bad charset still matches verify header with good charset."),-1);
+	result &= result5;
+
+	// Set override charset to be not used. I.e. zero
+	imHeader->SetOverrideCharset(0);
+	imHeader->ReDecodeL(fileSvrSession);
+
+	TBool result6 = CompareEncodedMessageHeader(aTest);
+	if (!result6)
+		log->AppendError(_L8("\t\t\tRedecoded header with zeroed override charset does not match verify header."),-1);
+	result &=result6;
+
+	// Save bad header to CMsvStore,
+	StoreMessageHeaderL(imHeader);
+
+	CleanupStack::PopAndDestroy(5, imHeader);
+	return result;
+	}
+
+//checks for duplicate recipients in the to and cc list.
+LOCAL_C TBool CheckForDuplicateRecipients(CImHeader* aCImHeader)
+	{
+	//check for duplicates in To list 
+	TInt toCount = aCImHeader->ToRecipients().Count();
+	for(TInt toCounter=0; toCounter<toCount; ++toCounter)
+		{
+		for(TInt jj=toCounter+1; jj<toCount; ++jj)
+			{
+			if((aCImHeader->ToRecipients()[jj].FindF(aCImHeader->ToRecipients()[toCounter])) >= 0)
+				{
+				return ETrue;
+				}
+			}
+		}
+ 
+ 	//check for duplicates in Cc list
+	TInt ccCount = aCImHeader->CcRecipients().Count();
+	for(TInt ccCounter=0; ccCounter<ccCount; ++ccCounter)
+		{
+		for(TInt jj=ccCounter+1; jj<ccCount; ++jj)
+			{
+			if((aCImHeader->CcRecipients()[jj].FindF(aCImHeader->CcRecipients()[ccCounter])) >= 0)
+				{
+				return ETrue;
+				}
+			}
+		}
+
+	//check for duplicates across To and Cc lists
+	for(TInt tcCounter=0; tcCounter<ccCount; ++tcCounter)
+		{
+		for(TInt jj=0; jj<toCount; ++jj)
+			{
+			if((aCImHeader->ToRecipients()[jj].FindF(aCImHeader->CcRecipients()[tcCounter])) >= 0)
+				{
+				return ETrue;
+				}
+			}
+		}
+
+	return EFalse;
+	}
+
+LOCAL_C TBool ReplyHeader1(TInt aTest)
+	{
+	// Fill in the fields in the header
+	log->AppendComment(_L8("\tReply Header Test 1 (Test 4)"));
+	entry.iType = KUidMsvMessageEntry;
+	entry.iMtm = KUidMsgTypeIMAP4;
+	entry.iServiceId = KMsvLocalServiceIndexEntryId;
+	imHeader = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	imHeader2 = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	imHeaderVerify = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+
+	log->AppendComment(_L8("\t\tReply To Originator"));
+	CreateMessageHeader();
+	TBuf<10> buf = _L("Re: %S");
+	imHeader->CreateReplyL(*imHeaderVerify, CImHeader::EOriginator, buf);
+	StoreMessageHeaderL(imHeaderVerify);
+	RestoreMessageHeaderL(imHeader2);
+
+	TBool result = ETrue;
+
+	TBool result1=(imHeader2->ToRecipients()[0] == imHeader->ReplyTo());
+	if (!result1)
+		log->AppendError(_L8("\t\t\tTo Recipient not identical to From"),-1);
+	result &= result1;
+	TBool result2=(imHeader2->Subject() == (_L("Re: short mail about something interesting")));
+	if (!result2)
+		log->AppendError(_L8("\t\t\tSubjects not identical"),-1);
+	result &= result2;
+	TBool result3=(imHeader2->InReplyTo() == imHeader->ImMsgId());
+	if (!result3)
+		log->AppendError(_L8("\t\t\tInReplyTo field not identical to MsgId"),-1);
+	result &= result3;
+
+	log->AppendComment(_L8("\t\tReply To Sender"));
+	CreateMessageHeader();
+	imHeader->CreateReplyL(*imHeaderVerify, CImHeader::ESender, buf);
+	StoreMessageHeaderL(imHeaderVerify);
+	RestoreMessageHeaderL(imHeader2);
+
+	TBool result4=(imHeader2->ToRecipients()[0] == imHeader->ReplyTo());
+	if (!result4)
+		log->AppendError(_L8("\t\t\tTo Recipient not identical to From"),-1);
+	result &= result4;
+	TBool result5=(imHeader2->Subject() == (_L("Re: short mail about something interesting")));
+	if (!result5)
+		log->AppendError(_L8("\t\t\tSubjects not identical"),-1);
+	result &= result5;
+	TBool result6=(imHeader2->InReplyTo() == imHeader->ImMsgId());
+	if (!result6)
+		log->AppendError(_L8("\t\t\tInReplyTo field not identical to MsgId"),-1);
+	result &= result6;
+
+	log->AppendComment(_L8("\t\tReply To All"));
+	CreateMessageHeader();
+	imHeader->CreateReplyL(*imHeaderVerify, CImHeader::EAll, buf);
+	StoreMessageHeaderL(imHeaderVerify);
+	RestoreMessageHeaderL(imHeader2);
+
+	TBool result7=(imHeader2->ToRecipients()[0] == imHeader->ReplyTo());
+	if (!result7)
+		log->AppendError(_L8("\t\t\tTo Recipients not identical to From"),-1);
+	result &= result7;
+
+	TBool result8=(imHeader2->CcRecipients()[0] == imHeader->ToRecipients()[0]);
+	result8 &= (imHeader2->CcRecipients()[1] == imHeader->ToRecipients()[1]);
+	if (!result8)
+		log->AppendError(_L8("\t\t\tTo Recipients not identical to To Recipients"),-1);
+	result &= result8;
+
+	TBool result9=(imHeader2->CcRecipients()[2] == imHeader->CcRecipients()[0]);
+	result9 &= (imHeader2->CcRecipients()[3] == imHeader->CcRecipients()[1]);
+	if (!result9)
+		log->AppendError(_L8("\t\t\tTo Recipients not identical to Cc Recipients"),-1);
+	result &= result9;
+	TBool result10=(imHeader2->Subject() == (_L("Re: short mail about something interesting")));
+	if (!result10)
+		log->AppendError(_L8("\t\t\tSubject fields not identical"),-1);
+	result &= result10;
+	TBool result11=(imHeader2->InReplyTo() == imHeader->ImMsgId());
+	if (!result11)
+		log->AppendError(_L8("\t\t\tInReplyTo field not identical to MsgId"),-1);
+	result &= result11;
+
+//
+
+	log->AppendComment(_L8("\t\tReply To Recipients"));
+	CreateMessageHeader();
+	imHeader->CreateReplyL(*imHeaderVerify, CImHeader::ERecipients, buf);
+	StoreMessageHeaderL(imHeaderVerify);
+	RestoreMessageHeaderL(imHeader2);
+
+	TBool result12=(imHeader2->ToRecipients()[0] == imHeader->ToRecipients()[0]);
+	result12 &= (imHeader2->ToRecipients()[1] == imHeader->ToRecipients()[1]);
+	if (!result12)
+		log->AppendError(_L8("\t\t\tTo Recipients not identical to To Recipients"),-1);
+	result &= result12;
+	TBool result13=(imHeader2->CcRecipients()[0] == imHeader->CcRecipients()[0]);
+	result13 &= (imHeader2->CcRecipients()[1] == imHeader->CcRecipients()[1]);
+	if (!result13)
+		log->AppendError(_L8("\t\t\tTo Recipients not identical to Cc Recipients"),-1);
+	result &= result13;
+	TBool result14=(imHeader2->Subject() == (_L("Re: short mail about something interesting")));
+	if (!result14)
+		log->AppendError(_L8("\t\t\tSubject fields not identical"),-1);
+	result &= result14;
+	TBool result15=(imHeader2->InReplyTo() == imHeader->ImMsgId());
+	if (!result15)
+		log->AppendError(_L8("\t\t\tInReplyTo field not identical to MsgId"),-1);
+	result &= result15;
+	
+	
+	log->AppendComment(_L8("\t\tReply To All - Duplicate To Recipients in Cc list"));
+	CreateMessageHeader4();
+	imHeader->CreateReplyL(*imHeaderVerify, CImHeader::EAll, buf);
+	StoreMessageHeaderL(imHeaderVerify);
+	RestoreMessageHeaderL(imHeader2);
+
+	TBool result16=(imHeader2->ToRecipients().Count() == 1);
+	result16 &= (imHeader2->CcRecipients().Count() == 3);
+	result16 &= (CheckForDuplicateRecipients(imHeader2) == EFalse);
+	if (!result16)
+		log->AppendError(_L8("\t\t\tDuplicate Recipients in To, Cc lists"),-1);
+	result &= result16;
+
+
+	log->AppendComment(_L8("\t\tReply To All - Duplicate Recipients in To and Cc list"));
+	CreateMessageHeader4();
+	imHeader->CreateReplyL(*imHeaderVerify, CImHeader::ERecipients, buf);
+	StoreMessageHeaderL(imHeaderVerify);
+	RestoreMessageHeaderL(imHeader2);
+
+	TBool result17=(imHeader2->ToRecipients().Count() == 2);
+	result17 &= (imHeader2->CcRecipients().Count() == 2);
+	result17 &= (CheckForDuplicateRecipients(imHeader2) == EFalse);
+	if (!result17)
+		log->AppendError(_L8("\t\t\tDuplicate Recipients in To, Cc list"),-1);
+	result &= result17;
+
+
+	ResultOfTest(result,aTest);
+	CleanupStack::PopAndDestroy(3); //imHeader, imHeaderVerify, imHeader
+	log->AppendComment(_L8("Reply Header Test 1 completed"));
+	return result;
+	}
+
+LOCAL_C TBool ReplyHeader2(TInt aTest)
+	{
+	// Fill in the fields in the header
+	log->AppendComment(_L8("\tReply Header Test 2 (Test 5)"));
+	entry.iType = KUidMsvMessageEntry;
+	entry.iMtm = KUidMsgTypeIMAP4;
+	entry.iServiceId = KMsvLocalServiceIndexEntryId;
+	imHeader = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	imHeader2 = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	imHeaderVerify = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+
+	log->AppendComment(_L8("\t\tReply To Originator"));
+	CreateMessageHeader2();
+	TBuf<10> buf = _L("Re: %S");
+	imHeader->CreateReplyL(*imHeaderVerify, CImHeader::EOriginator, buf);
+	StoreMessageHeaderL(imHeaderVerify);
+	RestoreMessageHeaderL(imHeader2);
+
+	TBool result = ETrue;
+
+	TBool result1=(imHeader2->ToRecipients()[0] == imHeader->ReplyTo());
+	if (!result1)
+		log->AppendError(_L8("\t\t\tTo Recipients not identical to ReplyTo"),-1);
+	result &= result1;
+	TBool result2=(imHeader2->Subject() == (_L("Re: short mail about something interesting")));
+	if (!result2)
+		log->AppendError(_L8("\t\t\tSubjects not identical"),-1);
+	result &= result2;
+	TBool result3=(imHeader2->InReplyTo() == imHeader->ImMsgId());
+	if (!result3)
+		log->AppendError(_L8("\t\t\tInReplyTo field not identical to MsgId"),-1);
+	result &= result3;
+
+	log->AppendComment(_L8("\t\tReply To Sender"));
+	CreateMessageHeader2();
+	imHeader->CreateReplyL(*imHeaderVerify, CImHeader::ESender, buf);
+	StoreMessageHeaderL(imHeaderVerify);
+	RestoreMessageHeaderL(imHeader2);
+
+	TBool result4=(imHeader2->ToRecipients()[0] == imHeader->ResentFrom());
+	if (!result4)
+		log->AppendError(_L8("\t\t\tTo Recipients not identical to ResentFrom"),-1);
+	result &= result4;
+	TBool result4a=(imHeader2->ToRecipients()[0] == imHeader->ResentFrom());
+	if (!result4a)
+		log->AppendError(_L8("\t\t\tTo Recipients not identical to ResentFrom"),-1);
+	result &= result4a;
+	TBool result5=(imHeader2->Subject() == (_L("Re: short mail about something interesting")));
+	if (!result5)
+		log->AppendError(_L8("\t\t\tSubjects not identical"),-1);
+	result &= result5;
+	TBool result6=(imHeader2->InReplyTo() == imHeader->ImMsgId());
+	if (!result6)
+		log->AppendError(_L8("\t\t\tInReplyTo not identical to MsgId"),-1);
+	result &= result6;
+
+	log->AppendComment(_L8("\t\tReply To All"));
+	CreateMessageHeader2();
+	imHeader->CreateReplyL(*imHeaderVerify, CImHeader::EAll, buf);
+	StoreMessageHeaderL(imHeaderVerify);
+	RestoreMessageHeaderL(imHeader2);
+
+	TBool result7=(imHeader2->ToRecipients()[0] == imHeader->From());
+	if (!result7)
+		log->AppendError(_L8("\t\t\tTo Recipients not identical to From"),-1);
+	result &= result7;
+	TBool result7a=(imHeader2->ToRecipients()[1] == imHeader->ResentFrom());
+	if (!result7a)
+		log->AppendError(_L8("\t\t\tTo Recipients not identical to Resent-From"),-1);
+	result &= result7a;
+	TBool result8=(imHeader2->ToRecipients()[2] == imHeader->ToRecipients()[0]);
+	result8 &= (imHeader2->ToRecipients()[3] == imHeader->ToRecipients()[1]);
+	if (!result8)
+		log->AppendError(_L8("\t\t\tTo Recipients not identical to To Recipients"),-1);
+	result &= result8;
+	TBool result9=(imHeader2->CcRecipients()[0] == imHeader->CcRecipients()[0]);
+	result9 &= (imHeader2->CcRecipients()[1] == imHeader->CcRecipients()[1]);
+	if (!result9)
+		log->AppendError(_L8("\t\t\tCc Recipients not identical to Cc Recipients"),-1);
+	result &= result9;
+	TBool result10=(imHeader2->Subject() == (_L("Re: short mail about something interesting")));
+	if (!result10)
+		log->AppendError(_L8("\t\t\tSubjects not identical"),-1);
+	result &= result10;
+	TBool result11=(imHeader2->InReplyTo() == imHeader->ImMsgId());
+	if (!result11)
+		log->AppendError(_L8("\t\t\tInReplyTo not identical to MsgId"),-1);
+	result &= result11;
+
+	log->AppendComment(_L8("\t\tReply To Recipients"));
+	CreateMessageHeader2();
+	imHeader->CreateReplyL(*imHeaderVerify, CImHeader::ERecipients, buf);
+	StoreMessageHeaderL(imHeaderVerify);
+	RestoreMessageHeaderL(imHeader2);
+
+	TBool result12=(imHeader2->ToRecipients()[0] == imHeader->ToRecipients()[0]);
+	result12 &= (imHeader2->ToRecipients()[1] == imHeader->ToRecipients()[1]);
+	if (!result12)
+		log->AppendError(_L8("\t\t\tTo Recipients not identical to To Recipients"),-1);
+	result &= result12;
+	TBool result13=(imHeader2->CcRecipients()[0] == imHeader->CcRecipients()[0]);
+	result13 &= (imHeader2->CcRecipients()[1] == imHeader->CcRecipients()[1]);
+	if (!result13)
+		log->AppendError(_L8("\t\t\tCc Recipients not identical to Cc Recipients"),-1);
+	result &= result13;
+	TBool result14=(imHeader2->Subject() == (_L("Re: short mail about something interesting")));
+	if (!result14)
+		log->AppendError(_L8("\t\t\tSubjects not identical"),-1);
+	result &= result14;
+	TBool result15=(imHeader2->InReplyTo() == imHeader->ImMsgId());
+	if (!result15)
+		log->AppendError(_L8("\t\t\tInReplyTo not identical to MsgId"),-1);
+	result &= result15;
+
+	ResultOfTest(result,aTest);
+	CleanupStack::PopAndDestroy(3); //imHeader, imHeaderVerify, imHeader
+	return result;
+	}
+
+LOCAL_C TBool ReceiptHeader1(TInt aTest)
+	{
+	// Fill in the fields in the header
+	log->AppendComment(_L8("\tReceipt Header Test (Test 6)"));
+	entry.iType = KUidMsvMessageEntry;
+	entry.iMtm = KUidMsgTypeIMAP4;
+	entry.iServiceId = KMsvLocalServiceIndexEntryId;
+	imHeader = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	imHeader2 = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	imHeaderVerify = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+
+	CreateMessageHeader();
+	TBuf<10> buf = _L("Re: %S");
+	imHeader->CreateReceiptL(*imHeaderVerify, buf);
+	StoreMessageHeaderL(imHeaderVerify);
+	RestoreMessageHeaderL(imHeader2);
+
+	TBool result = ETrue;
+	TBool result1=(imHeader2->ToRecipients()[0] == imHeader->ReceiptAddress());
+	if (!result1)
+		log->AppendError(_L8("\t\tTo Recipients not identical to Recipient Address"),-1);
+	result &= result1;
+	TBool result2=(imHeader2->InReplyTo() == imHeader->ImMsgId());
+	if (!result2)
+		log->AppendError(_L8("\t\tInReplyTo not identical to MsgId"),-1);
+	result &= result2;
+	TBool result3=(imHeader2->Subject() == (_L("Re: short mail about something interesting")));
+	if (!result3)
+		log->AppendError(_L8("\t\tSubjects not identical"),-1);
+	result &= result3;
+	
+	ResultOfTest(result,aTest);
+	CleanupStack::PopAndDestroy(3); //imHeader, imHeaderVerify, imHeader
+	return result;
+	}
+
+LOCAL_C TBool ReceiptHeader2(TInt aTest)
+	{
+	// Fill in the fields in the header
+	log->AppendComment(_L8("\tReceipt Header Test (Test 7)"));
+	entry.iType = KUidMsvMessageEntry;
+	entry.iMtm = KUidMsgTypeIMAP4;
+	entry.iServiceId = KMsvLocalServiceIndexEntryId;
+	imHeader = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	imHeader2 = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	imHeaderVerify = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+
+	CreateMessageHeader3();
+	TBuf<10> buf = _L("Re: %S");
+	imHeader->CreateReceiptL(*imHeaderVerify, buf);
+	StoreMessageHeaderL(imHeaderVerify);
+	RestoreMessageHeaderL(imHeader2);
+
+	TBool result = ETrue;
+	TBool result1=(imHeader2->ToRecipients()[0] == imHeader->From());
+	if (!result1)
+		log->AppendError(_L8("\t\tTo Recipients not identical to Recipient Address"),-1);
+	result &= result1;
+	TBool result2=(imHeader2->InReplyTo() == imHeader->ImMsgId());
+	if (!result2)
+		log->AppendError(_L8("\t\tInReplyTo not identical to MsgId"),-1);
+	result &= result2;
+	TBool result3=(imHeader2->Subject() == (_L("Re: short mail about something interesting")));
+	if (!result3)
+		log->AppendError(_L8("\t\tSubjects not identical"),-1);
+	result &= result3;
+	
+	ResultOfTest(result,aTest);
+	CleanupStack::PopAndDestroy(3); //imHeader, imHeaderVerify, imHeader
+	return result;
+	}
+
+LOCAL_C TBool ForwardHeader(TInt aTest)
+	{
+	// Fill in the fields in the header
+	log->AppendComment(_L8("\tForward Header Test (Test 8)"));
+	entry.iType = KUidMsvMessageEntry;
+	entry.iMtm = KUidMsgTypeIMAP4;
+	entry.iServiceId = KMsvLocalServiceIndexEntryId;
+	imHeader = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	imHeader2 = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+	imHeaderVerify = CImHeader::NewLC(); // Cleaned up when exiting this menu selection
+
+	CreateMessageHeader();
+	TBuf<10> buf = _L("Fwd: %S");
+	imHeader->CreateForwardL(*imHeaderVerify, buf);
+	StoreMessageHeaderL(imHeaderVerify);
+	RestoreMessageHeaderL(imHeader2);
+
+	TBool result = ETrue;
+	result &= (imHeader2->Subject() == (_L("Fwd: short mail about something interesting")));
+	if (!result)
+		log->AppendError(_L8("\t\tSubjects not identical"),-1);
+	
+	ResultOfTest(result,aTest);
+	CleanupStack::PopAndDestroy(3); //imHeader, imHeaderVerify, imHeader
+	return result;
+	}
+
+
+
+#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)
+LOCAL_C void CreateAccount()
+	{
+	log->AppendComment(_L8("\tCreating email accounts..."));
+	CEmailAccounts* accounts = CEmailAccounts::NewLC();
+	CImImap4Settings* imapSetting = new (ELeave) CImImap4Settings;
+	CImIAPPreferences* iap = CImIAPPreferences::NewLC();
+
+	_LIT(KIMAPAccountName, "ImapAccount");
+	accounts->PopulateDefaultImapSettingsL(*imapSetting, *iap);
+	TImapAccount imapAccount = accounts->CreateImapAccountL(KIMAPAccountName, *imapSetting, *iap, EFalse);
+	CleanupStack::PopAndDestroy(2);
+	delete imapSetting;
+	log->AppendComment(_L8("\tAccount Created succesfully."));
+	}
+	
+#endif
+
+
+//
+
+LOCAL_C void ImHeaderSelectionL()
+	{
+	TBool result = ETrue;
+
+#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)
+	CreateAccount();
+#endif
+	
+	testUtils->TestStart(1);
+	TBool result1=FilledMessageHeader(1);
+	if (result1)
+		log->AppendComment(_L8("PASSED Test 1"));
+	else
+		log->AppendError(_L8("FAILED Test 1"),-1);
+	result &= result1;
+	testUtils->TestFinish(1);
+
+	testUtils->TestStart(2);
+	TBool result2=BlankMessageHeader(2);
+	if (result2)
+		log->AppendComment(_L8("PASSED Test 2"));
+	else
+		log->AppendError(_L8("FAILED Test 2"),-1);
+	result &= result2;
+	testUtils->TestFinish(2);
+	
+	testUtils->TestStart(3);
+	TBool result3=LongMessageHeader(3);
+	if (result3)
+		log->AppendComment(_L8("PASSED Test 3"));
+	else
+		log->AppendError(_L8("FAILED Test 3"),-1);
+	result &= result3;
+	testUtils->TestFinish(3);
+	
+	testUtils->TestStart(4);
+	TBool result4=ReplyHeader1(4);
+	if (result4)
+		log->AppendComment(_L8("PASSED Test 4"));
+	else
+		log->AppendError(_L8("FAILED Test 4"),-1);
+	result &= result4;
+	testUtils->TestFinish(4);
+	
+	testUtils->TestStart(5);
+	TBool result5=ReplyHeader2(5);
+	if (result5)
+		log->AppendComment(_L8("PASSED Test 5"));
+	else
+		log->AppendError(_L8("FAILED Test 5"),-1);
+	result &= result5;
+	testUtils->TestFinish(5);
+	
+	testUtils->TestStart(6);
+	TBool result6=ReceiptHeader1(6);
+	if (result6)
+		log->AppendComment(_L8("PASSED Test 6"));
+	else
+		log->AppendError(_L8("FAILED Test 6"),-1);
+	result &= result6;
+	testUtils->TestFinish(6);
+	
+	testUtils->TestStart(7);
+	TBool result7=ReceiptHeader2(7);
+	if (result7)
+		log->AppendComment(_L8("PASSED Test 7"));
+	else
+		log->AppendError(_L8("FAILED Test 7"),-1);
+	result &= result7;
+	testUtils->TestFinish(7);
+
+	testUtils->TestStart(8);
+	TBool result8=ForwardHeader(8);
+	if (result8)
+		log->AppendComment(_L8("PASSED Test 8"));
+	else
+		log->AppendError(_L8("FAILED Test 8"),-1);
+	result &= result8;
+	testUtils->TestFinish(8);
+
+	
+	testUtils->TestStart(9);
+	TBool result9 = EncodedMessageHeader(9);
+	if (result9)
+		log->AppendComment(_L8("PASSED Test 9"));
+	else
+		log->AppendError(_L8("FAILED Test 9"),-1);
+	result &= result9;
+	testUtils->TestFinish(9);
+
+	
+	testUtils->TestStart(10);
+	TBool result10 = EncodedNonMimeMessageHeader(10);
+	if (result10)
+		log->AppendComment(_L8("PASSED Test 10"));
+	else
+		log->AppendError(_L8("FAILED Test 10"),-1);
+	result &= result10;
+	testUtils->TestFinish(10);
+
+	
+	testUtils->TestStart(11);
+	TBool result11 = EncodedMessageHeaderDecode(11);
+	if (result11)
+		log->AppendComment(_L8("PASSED Test 11"));
+	else
+		log->AppendError(_L8("FAILED Test 11"),-1);
+	result &= result11;
+	testUtils->TestFinish(11);
+
+	
+	testUtils->TestStart(12);
+	TBool result12 = MessageHeaderDecodeAllHeadersOOMTest(12);
+	if (result12)
+		log->AppendComment(_L8("PASSED Test 12"));
+	else
+		log->AppendError(_L8("FAILED Test 12"),-1);
+	result &= result12;
+	testUtils->TestFinish(12);
+
+	testUtils->TestStart(13);
+	TBool result13 = MessageHeaderReDecodeHeadersOOMTest(13);
+	if (result13)
+		log->AppendComment(_L8("PASSED Test 13"));
+	else
+		log->AppendError(_L8("FAILED Test 13"),-1);
+	result &= result13;
+	testUtils->TestFinish(13);
+
+	if (result)
+		{
+		log->AppendComment(_L8("PASSED All tests"));
+		test.Printf(_L("PASSED all Tests"));
+		testUtils->TestHarnessCompleted();
+		}
+	else
+		{
+		test.Printf(_L("FAILED  Tests"));
+		log->AppendError(_L8("FAILED At Least one test"),-1);
+		testUtils->TestHarnessFailed(KErrGeneral);
+		}
+	}
+
+//
+
+LOCAL_C void InitL()
+	{
+	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;
+	CActiveScheduler::Install(scheduler);
+	CleanupStack::PushL(scheduler);
+
+	testUtils = CEmailTestUtils::NewLC(test);
+	testUtils->CreateAllTestDirectories();
+	testUtils->FileSession().SetSessionPath(_L("C:\\"));
+	testUtils->CleanMessageFolderL();
+	testUtils->GoServerSideL();
+
+	log = CImLog::NewL(_L("c:\\logs\\email\\T_IMCM.log"), EAppend);
+	CleanupStack::PushL(log);
+	log->AppendComment(_L8("********* T_MIUT01 Test CImHeader Class **********"));
+	TBuf8<80> buf;
+
+#if defined(__WINS__)	
+	buf.Append(_L8("WINS "));
+#else
+	buf.Append(_L8("MARM "));
+#endif
+#if defined(_UNICODE)
+	buf.Append(_L8("U"));
+#endif
+#if defined(_DEBUG)
+	buf.Append(_L8("DEB"));
+#else
+	buf.Append(_L8("REL"));
+#endif
+	log->AppendComment(buf);
+	}
+	
+LOCAL_C void Closedown()
+	{
+	log->AppendComment(_L8("**********    T_MIUT01 Tests Complete    **********"));
+	log->AppendComment(_L8(""));
+
+	CleanupStack::PopAndDestroy(3);  //testUtils, log, scheduler
+	}
+
+//
+
+LOCAL_C void doMainL()
+	{
+	InitL();
+	testUtils->GoClientSideL();
+	test.Printf(_L("Performing Header Tests\n"));
+
+	ImHeaderSelectionL();
+
+	Closedown();
+	}
+
+GLDEF_C TInt E32Main()
+	{	
+	__UHEAP_MARK;
+	test.Start(_L("T_MIUT01 Test CImHeader class"));
+	theCleanup=CTrapCleanup::New();
+	TRAPD(ret,doMainL());		
+	test(ret==KErrNone);
+	delete theCleanup;	
+	test.End();
+	test.Close();
+	__UHEAP_MARKEND;
+	User::Heap().Check();
+	return(KErrNone);
+	}