// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// To build: bldmake bldfiles

// abld test build wins udeb

// To run from windows command prompt:

// cd epoc32\release\wins\udeb 

// T_CIMEMAILMESSAGE -dtextshell --

// 

//

#include <e32base.h>

#include <e32std.h>

#include <e32cons.h>

#include <e32test.h>

#include <s32file.h>

// Message Server headers for linking to msgs.dll. 

#include <msvapi.h>

#include <msvids.h>

#include <msvuids.h>

#include <msvstd.h>

// Class under test.

#include <miutmsg.h>

#include <mmsvattachmentmanager.h>

#include "emailtestutils.h"

typedef enum

	{

	EGetBodyTextL,

	EFindFirstHTMLPageL,

	EGetMessageDigestEntriesL,

	EGetAttachmentListsL,

	EDeleteAttachmentLId1,

	EDeleteAttachmentLId2,

	EFindUniversalResourceIdentifierL,

	EAddMessageAsAttachmentLId1,

	EAddMessageAsAttachmentLId2,

	EAddRelatedPartL,

	EStoreBodyTextL,

	EGetCharacterSetL,

	EDeleteAttachedMessageL

	} TMethodType;

// Forwards

class CMyScheduler;

class CObserver;

// Test harness constants and global variables...

_LIT(KTitle, "T_CIMEMAILMESSAGE");

_LIT(KFolderName, "DeleteMe");

CTrapCleanup* pcleanup = NULL;

CMyScheduler* pscheduler = NULL;

RTest test(KTitle);

LOCAL_D CEmailTestUtils* testUtils;

RFs gFs;

CMsvSession* pSession = NULL;

CObserver* pObserver = NULL;

CMsvEntry* pContext = NULL;

CTestActive* pTestActive = NULL;

// Global email message entry identifiers.

TMsvId gEmailMessageID;

TMsvId gEmailMessageID2;

TMethodType gMethodType;

// Test utility classes

class CMyScheduler : public CActiveScheduler

	{

private:

	void Error(TInt aError) const;

	};

void CMyScheduler::Error(TInt /*aError*/) const {}

class CObserver : public MMsvSessionObserver

	{

	public:

		void HandleSessionEvent(TMsvSessionEvent aEvent, TAny* aArg1, TAny* aArg2, TAny* aArg3);

		void HandleSessionEventL(TMsvSessionEvent aEvent, TAny* aArg1, TAny* aArg2, TAny* aArg3);

	};

void CObserver::HandleSessionEvent(TMsvSessionEvent /*aEvent*/, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/)

	{

	}

void CObserver::HandleSessionEventL(TMsvSessionEvent /*aEvent*/, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/)

	{

	}

// Test Case Prototypes

LOCAL_C TBool TestAttachmentFlagL();

LOCAL_C void TestGetBodyTextL(CImEmailMessage* aEmailMessage, TRequestStatus& aStatus);

LOCAL_C void TestStoreBodyTextL(CImEmailMessage* aEmailMessage, TRequestStatus& aStatus);

LOCAL_C TBool TestPanicsL();

// Test Harness Prototypes

LOCAL_C void DoTestThreadWorkL();

static TInt DoTestThreadStart(TAny*);

LOCAL_C void InitL();

LOCAL_C void UninitL();

LOCAL_C void doTests();

LOCAL_C void doMainL();

GLDEF_C TInt E32Main();

_LIT(KTestThreadName, "CImEmailMessage Test Thread");

LOCAL_C void TestGetBodyTextL(CImEmailMessage* aEmailMessage, TRequestStatus& aStatus)

	{

	CParaFormatLayer* paraFormatLayer=CParaFormatLayer::NewL();

	CleanupStack::PushL(paraFormatLayer);

	CCharFormatLayer* charFormatLayer=CCharFormatLayer::NewL(); 

	CleanupStack::PushL(charFormatLayer);

	CRichText* bodyText=CRichText::NewL(paraFormatLayer, charFormatLayer, CEditableText::EFlatStorage, 256);

	CleanupStack::PushL(bodyText);

	TBuf<100> bodyContents = _L("Test body contents so that we can test the store body text code.");

	bodyText->InsertL(0, bodyContents); 

	aEmailMessage->GetBodyTextL(

		aStatus,

		gEmailMessageID2, 

		CImEmailMessage::EThisMessageOnly,

		*bodyText, 

		*paraFormatLayer, 

		*charFormatLayer);

	CleanupStack::PopAndDestroy(3, paraFormatLayer);

	}

LOCAL_C void TestStoreBodyTextL(CImEmailMessage* aEmailMessage, TRequestStatus& aStatus)

	{

	CParaFormatLayer* paraFormatLayer=CParaFormatLayer::NewL();

	CleanupStack::PushL(paraFormatLayer);

	CCharFormatLayer* charFormatLayer=CCharFormatLayer::NewL(); 

	CleanupStack::PushL(charFormatLayer);

	CRichText* bodyText=CRichText::NewL(paraFormatLayer, charFormatLayer, CEditableText::EFlatStorage, 256);

	CleanupStack::PushL(bodyText);

	TBuf<100> bodyContents = _L("Test body contents so that we can test the store body text code.");

	bodyText->InsertL(0, bodyContents); 

	aEmailMessage->StoreBodyTextL(gEmailMessageID2, *bodyText, aStatus);

	CleanupStack::PopAndDestroy(3, paraFormatLayer);

	}

LOCAL_C void DoTestThreadWorkL()

    {

    CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

    CActiveScheduler::Install(scheduler);

    CleanupStack::PushL(scheduler);

	// Connect to the Message Server...

    CObserver* ob = new (ELeave) CObserver;

    CleanupStack::PushL(ob);

    CMsvSession* session = CMsvSession::OpenSyncL(*ob);

    CleanupStack::PushL(session);

	CMsvEntry* cEntry = CMsvEntry::NewL(*session, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());

	CleanupStack::PushL(cEntry);

	CImEmailMessage* emailMessage = CImEmailMessage::NewLC(*cEntry);

	switch(gMethodType)

		{

		case EGetBodyTextL:

			TestGetBodyTextL(emailMessage, pTestActive->iStatus);

			break;

		case EFindFirstHTMLPageL:

			emailMessage->FindFirstHTMLPageL(gEmailMessageID2, pTestActive->iStatus);

			break;

		case EGetMessageDigestEntriesL:

			emailMessage->GetMessageDigestEntriesL(pTestActive->iStatus, gEmailMessageID2);

			break;

		case EGetAttachmentListsL:

			emailMessage->GetAttachmentsListL(

				gEmailMessageID2,

				CImEmailMessage::EAllAttachments,

				CImEmailMessage::EThisMessageOnly);

			break;

		case EDeleteAttachmentLId1:

			{

			TMsvAttachmentId attachmentId = gEmailMessageID;

			emailMessage->AttachmentManager().RemoveAttachmentL(attachmentId,pTestActive->iStatus);			

			}

			break;

		case EDeleteAttachmentLId2:

			{

			TMsvAttachmentId attachmentId = gEmailMessageID;

			emailMessage->AttachmentManager().RemoveAttachmentL(attachmentId,pTestActive->iStatus);			

			}

			break;

		case EFindUniversalResourceIdentifierL:

			emailMessage->FindUniversalResourceIdentifierL(

				gEmailMessageID2, 

				_L("a description"), 

				_L("http://someuri.com"), 

				pTestActive->iStatus);

			break;

		case EAddMessageAsAttachmentLId1:

			{

			CMsvAttachment* attachmentInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);

			CleanupStack::PushL(attachmentInfo);

			emailMessage->AttachmentManager().AddEntryAsAttachmentL(gEmailMessageID,attachmentInfo,pTestActive->iStatus);

			CleanupStack::Pop(attachmentInfo);

			}

			break;

		case EAddMessageAsAttachmentLId2:

			{

			CMsvAttachment* attachmentInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);

			CleanupStack::PushL(attachmentInfo);

			emailMessage->AttachmentManager().AddEntryAsAttachmentL(gEmailMessageID2,attachmentInfo,pTestActive->iStatus);

			CleanupStack::Pop(attachmentInfo);

			}

			break;

		case EAddRelatedPartL:

			emailMessage->AddRelatedPartL(gEmailMessageID2, _L("some text"), pTestActive->iStatus, gEmailMessageID, _L8("some text"));

			break;

		case EStoreBodyTextL:

			TestStoreBodyTextL(emailMessage, pTestActive->iStatus);

			break;

		case EGetCharacterSetL:

			{

			TUint charSetId = 0;

			TBool override  = EFalse;

			emailMessage->GetCharacterSetL(gEmailMessageID2, charSetId, override);

			break;

			}

		case EDeleteAttachedMessageL:

			{

			TMsvAttachmentId attachmentId = gEmailMessageID;

			emailMessage->AttachmentManager().RemoveAttachmentL(attachmentId,pTestActive->iStatus);

			}

			break;

		}

    CleanupStack::PopAndDestroy(5, scheduler);

    }

static TInt DoTestThreadStart(TAny*)

    {

    // Entry function for the child thread which is created then killed.

    CTrapCleanup* cleanup = CTrapCleanup::New();

    test(cleanup != NULL);

    TRAPD(ret, DoTestThreadWorkL());

    delete cleanup;

    return 0;

    }

LOCAL_C TBool TestAttachmentFlagL()

	{

	TBool result = EFalse;

	TMsvId emailMessageID;

	TMsvId attachMessageID;

	// Create an email message entry.

	CImEmailOperation* emailOp = CImEmailOperation::CreateNewL(pTestActive->iStatus, *pSession, KMsvGlobalInBoxIndexEntryId, KMsvMessagePartBody, 0, KUidMsgTypeSMTP); 

	CleanupStack::PushL(emailOp);

	pTestActive->StartL(); // Active object which stops the active scheduler

	CActiveScheduler::Start();

	// Get the new message id.

	TPckg<TMsvId> param(emailMessageID);

	param.Copy(emailOp->FinalProgress());

	CleanupStack::PopAndDestroy(emailOp);

	emailOp = CImEmailOperation::CreateNewL(pTestActive->iStatus, *pSession, KMsvGlobalInBoxIndexEntryId, KMsvMessagePartBody, 0, KUidMsgTypeSMTP); 

	CleanupStack::PushL(emailOp);

	pTestActive->StartL(); // Active object which stops the active scheduler

	CActiveScheduler::Start();

	TPckg<TMsvId> param2(attachMessageID);

	param2.Copy(emailOp->FinalProgress());

	CleanupStack::PopAndDestroy(emailOp);

	CImEmailMessage* obj = CImEmailMessage::NewLC(*pContext);

	pContext->SetEntryL(emailMessageID);

	TMsvEntry entry = pContext->Entry();

	result = !(entry.Attachment());

	CMsvAttachment* attachmentInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);

	CleanupStack::PushL(attachmentInfo);	

	obj->AttachmentManager().AddEntryAsAttachmentL(attachMessageID,attachmentInfo,pTestActive->iStatus);

	CleanupStack::Pop(attachmentInfo);

	pTestActive->StartL();

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(obj);

	obj = NULL;

	// Want to test that the entry's attachment flag is true;

	pContext->SetEntryL(emailMessageID);

	entry = pContext->Entry();

	result &= (entry.Attachment() != EFalse);

	pContext->DeleteL(attachMessageID);

	pContext->DeleteL(emailMessageID);

	return result;

	}

LOCAL_C TBool TestPanicsL()

	{

	const TInt KMinTestHeapSize = 0x10000;

    const TInt KMaxTestHeapSize = 0x100000;

	RThread testThread;

	TRequestStatus requestStatus;

	TBool result = ETrue;

	TMsvEntry entry;

	// Make sure paniced threads don't cause us trouble.

	User::SetJustInTime(EFalse);

	//

	//--------------------------------------------------------------------------

	// Create email message entries.

	//--------------------------------------------------------------------------

	//

	CImEmailOperation* emailOp = CImEmailOperation::CreateNewL(pTestActive->iStatus, *pSession, KMsvGlobalInBoxIndexEntryId, KMsvMessagePartBody, 0, KUidMsgTypeSMTP); 

	CleanupStack::PushL(emailOp);

	pTestActive->StartL(); // Active object which stops the active scheduler

	CActiveScheduler::Start();

	// Get the new message id.

	TPckg<TMsvId> param(gEmailMessageID);

	param.Copy(emailOp->FinalProgress());

	CleanupStack::PopAndDestroy(emailOp);

	emailOp = CImEmailOperation::CreateNewL(pTestActive->iStatus, *pSession, KMsvGlobalInBoxIndexEntryId, KMsvMessagePartBody, 0, KUidMsgTypeSMTP); 

	CleanupStack::PushL(emailOp);

	pTestActive->StartL(); // Active object which stops the active scheduler

	CActiveScheduler::Start();

	TPckg<TMsvId> param2(gEmailMessageID2);

	param2.Copy(emailOp->FinalProgress());

	CleanupStack::PopAndDestroy(emailOp);

	CImEmailMessage* emailMessage = CImEmailMessage::NewLC(*pContext);

	pContext->SetEntryL(gEmailMessageID2);

	entry = pContext->Entry();

	// Set to something inappropriate

	entry.iType = KUidMsvAttachmentEntry;

	pContext->ChangeL(entry);

	//

	//--------------------------------------------------------------------------

	//- Test CImEmailMessage::GetBodyTextL -------------------------------------

	//--------------------------------------------------------------------------

	//

	gMethodType = EGetBodyTextL;

	testThread.Create(

		KTestThreadName, 

		DoTestThreadStart, 

		KDefaultStackSize, 

		KMinTestHeapSize, 

		KMaxTestHeapSize, 

		NULL, 

		EOwnerThread);

	testThread.Logon(requestStatus);

    // Let the thread run

    testThread.Resume();

    User::WaitForRequest(requestStatus);

	result &= 

		((testThread.ExitType() == EExitPanic) && 

		(testThread.ExitReason() == EEntryIsNotMessage));

    testThread.Close();

	//

	//--------------------------------------------------------------------------

	//- Test CImEmailMessage::FindFirstHTMLPageL -------------------------------

	//--------------------------------------------------------------------------

	//

	gMethodType = EFindFirstHTMLPageL;

	testThread.Create(

		KTestThreadName, 

		DoTestThreadStart, 

		KDefaultStackSize, 

		KMinTestHeapSize, 

		KMaxTestHeapSize, 

		NULL, 

		EOwnerThread);

	testThread.Logon(requestStatus);

    // Let the thread run

    testThread.Resume();

    User::WaitForRequest(requestStatus);

	result &= 

		((testThread.ExitType() == EExitPanic) && 

		(testThread.ExitReason() == EEntryIsNotMessage));

    testThread.Close();

	//

	//--------------------------------------------------------------------------

	//- Test CImEmailMessage::GetMessageDigestEntriesL -------------------------

	//--------------------------------------------------------------------------

	//

	gMethodType = EGetMessageDigestEntriesL;

	testThread.Create(

		KTestThreadName, 

		DoTestThreadStart, 

		KDefaultStackSize, 

		KMinTestHeapSize, 

		KMaxTestHeapSize, 

		NULL, 

		EOwnerThread);

	testThread.Logon(requestStatus);

    // Let the thread run

    testThread.Resume();

    User::WaitForRequest(requestStatus);

	result &= 

		((testThread.ExitType() == EExitPanic) && 

		(testThread.ExitReason() == EEntryIsNotMessage));

    testThread.Close();

	//

	//--------------------------------------------------------------------------

	//- Test CImEmailMessage::GetAttachmentListsL ------------------------------

	//--------------------------------------------------------------------------

	//

	gMethodType = EGetAttachmentListsL;

	testThread.Create(

		KTestThreadName, 

		DoTestThreadStart, 

		KDefaultStackSize, 

		KMinTestHeapSize, 

		KMaxTestHeapSize, 

		NULL, 

		EOwnerThread);

	testThread.Logon(requestStatus);

    // Let the thread run

    testThread.Resume();

    User::WaitForRequest(requestStatus);

	result &= 

		((testThread.ExitType() == EExitPanic) && 

		(testThread.ExitReason() == EEntryIsNotMessage));

    testThread.Close();

	//

	//--------------------------------------------------------------------------

	//- Test CImEmailMessage::DeleteAttachmentL --------------------------------

	//--------------------------------------------------------------------------

	//

	gMethodType = EDeleteAttachmentLId1;

	testThread.Create(

		KTestThreadName, 

		DoTestThreadStart, 

		KDefaultStackSize, 

		KMinTestHeapSize, 

		KMaxTestHeapSize, 

		NULL, 

		EOwnerThread);

	testThread.Logon(requestStatus);

    // Let the thread run

    testThread.Resume();

    User::WaitForRequest(requestStatus);

	result &= 

		((testThread.ExitType() == EExitPanic) && 

		(testThread.ExitReason() == EEntryIsNotMessage));

    testThread.Close();

	pContext->SetEntryL(gEmailMessageID2);

	entry = pContext->Entry();

	entry.iType = KUidMsvMessageEntry;

	pContext->ChangeL(entry);

	// The first message ID points to an entry of type KUidMsvMessageEntry.

	// The second message ID will cause a leave because it isn't a KUidMsvAttachmentEntry

	gMethodType = EDeleteAttachmentLId2;

	testThread.Create(

		KTestThreadName, 

		DoTestThreadStart, 

		KDefaultStackSize, 

		KMinTestHeapSize, 

		KMaxTestHeapSize, 

		NULL,

		EOwnerThread);

	testThread.Logon(requestStatus);

    // Let the thread run

    testThread.Resume();

    User::WaitForRequest(requestStatus);

	result &= 

		((testThread.ExitType() == EExitPanic) && 

		(testThread.ExitReason() == EEntryIsNotMessage));

    testThread.Close();

	pContext->SetEntryL(gEmailMessageID2);

	entry = pContext->Entry();

	entry.iType = KUidMsvAttachmentEntry;

	pContext->ChangeL(entry);