// 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:

// Test harness for Email Notification Parser

// 

//

//Create a buffer containing an sms message with the relevant field

//then pass it by reference to the parser dll

#include <e32uid.h>

#include <e32test.h>

#include <e32cons.h>

#include <s32file.h>

#include <e32base.h>

#include "TESTENV.H"

#include <regpsdll.h>

#include "biotestutils.h"

#define BIO_MSG_ENTRY_PARSED     1 // Set entry .iMtmData3 to 1 to indicate that the entry has store i.e parsed,externalised

#define KTestEnpPriority    (1)    //Change this....

#define KEmailNotificationTextFilePath  _L("c:\\test\\bio\\enp\\")

//

//forward reference

class CExampleScheduler;

LOCAL_C void DisplayErrorReason(TInt& aReason);

//global declarations

LOCAL_D RTest test(_L("ENP Test Harness"));

    //

    // CExampleScheduler //

    //

class CExampleScheduler : public CActiveScheduler

    {

    public:

    void Error (TInt aError) const;

    };

void CExampleScheduler::Error(TInt anError) const

    {

    CActiveScheduler::Stop();

    test.Printf(_L("\nLeave signalled, reason=%d\n"),anError);

    }

// end CExampleScheduler::Error(TInt) const

    //

    // CTestEnp: INTERFACE //

    //

LOCAL_D CExampleScheduler *exampleScheduler;

class CTestEnp : public CActive

    {

    public:

        ~CTestEnp();

        CTestEnp();

        static CTestEnp* NewL();

        void ConstructL();

        void Start(TInt aCmd);

        void RunL();

        void DoCancel();

		void RequestComplete(TRequestStatus& aStatus,TInt aCompletion);

        enum TSessionState

            {

            EParse,

            EProcess,

			EReparse,

			EDisplay,  //Display entry data

            };

    private:

        TInt						iState;

		TInt						iMsgCtr;

		TInt						iMsgCount;

		TInt						iTestCtr;

        CBaseScriptParser2*			iParser;

		CMsvEntrySelection*			iMsvSelection;

        CArrayPtrSeg<CParsedField>* iTestParsedFieldArray;

		CBioTestUtils*				iBioTestUtils;

		HBufC*						iMsgBuffer;

    };

    //

    // CTestEnp: IMPLEMENTATION //

    //

CTestEnp* CTestEnp::NewL()

    {

    CTestEnp* self = new (ELeave) CTestEnp();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();  //self

    return self;

    }

// end CTestEnp::NewL(CMsvServerEntry*)

void CTestEnp::ConstructL()

    {

	// create test utilities object & go server side

	iBioTestUtils = CBioTestUtils::NewL(test, ETuGoClientSide | ETuDeleteService | ETuCreateService);

	// create some messages

	iMsvSelection = iBioTestUtils->GenerateMessagesL(KEmailNotificationTextFilePath);

	iMsgCount = iMsvSelection->Count();

	// create the parser

	TBool finished = EFalse;

#ifdef _DEBUG

	TInt failCount = 0;

#endif

	while(!finished)

		{

		__UHEAP_FAILNEXT(failCount++);

		// 

		TRAPD(error, iParser = iBioTestUtils->CreateParserTypeL(KUidBIOEmailNotificationMsg););

		if (error == KErrNone)

			{

			__UHEAP_RESET;

			finished = ETrue;

			__UHEAP_RESET;

			}

		// Handle error

		else

			{

			// Check if error is out of memory or a specific fax rendering error

			test(error == KErrNoMemory);

			__UHEAP_RESET;

			}

		}

    CActiveScheduler::Add(this);

    }

// end CTestEnp::ConstructL()

void CTestEnp::Start(TInt aCmd)

    {

	TInt error = KErrNone;

	TBool finished = EFalse;

#ifdef _DEBUG

	TInt failCount = 0;

#endif

    iState=aCmd;

    switch (iState)

        {

        case EParse:

			test.Printf(_L("Parsing...\n"));

			iBioTestUtils->TestStart(iTestCtr,_L("Parsing"));

			delete iMsgBuffer;

			iMsgBuffer = iBioTestUtils->MessageBodyL((*iMsvSelection)[iMsgCtr]).AllocL();

			while(!finished)

				{

				__UHEAP_FAILNEXT(failCount++);

				// 

				TRAP(error, iParser->ParseL(iStatus,*iMsgBuffer));

				if (error == KErrNone)

					{

					__UHEAP_RESET;

					finished = ETrue;

					SetActive();

					}

				// Handle error

				else

					{

					// Check if error is out of memory or a specific fax rendering error

					test(error == KErrNoMemory);

					__UHEAP_RESET;

					}

				}

            break;

        case EProcess:

			test.Printf(_L("process...(This is not supported in Email Notification Parser)\n"));

			iBioTestUtils->TestStart(iTestCtr,_L("Calling process"));

			TRAP(error,iParser->ProcessL(iStatus); );

			while(!finished)

				{

				__UHEAP_FAILNEXT(failCount++);

				// 

				TRAP(error, iParser->ProcessL(iStatus));

				if (error == KErrNone)

					{

					__UHEAP_RESET;

					finished = ETrue;

					SetActive();

					}

				// Handle error

				else

					{

					// Check if error is out of memory or a specific fax rendering error

					test(error == KErrNoMemory);

					__UHEAP_RESET;

					}

				}

            break;

		case EReparse:

			test.Printf(_L("Reparsing...\n"));

			iBioTestUtils->TestStart(iTestCtr,_L("Re-Parsing"));

			while(!finished)

				{

				__UHEAP_FAILNEXT(failCount++);

				// 

				TRAP(error, iParser->ParseL(iStatus,*iMsgBuffer));

				if (error == KErrNone)

					{

					__UHEAP_RESET;

					finished = ETrue;

					SetActive();

					}

				// Handle error

				else

					{

					// Check if error is out of memory or a specific fax rendering error

					test(error == KErrNoMemory);

					__UHEAP_RESET;

					}

				}

            break;

		case EDisplay:

			iBioTestUtils->TestStart(iTestCtr,_L("Printing parsed fields"));

			TRAP(error,iBioTestUtils->LogExtractedFieldsL((*iMsvSelection)[iMsgCtr]));

			RequestComplete(iStatus,error);

            SetActive();

			break;

		default:

            break;

        }

    }

// end CTestEnp::StartL(TInt)

void CTestEnp::RunL()

    {

    TInt result=iStatus.Int();

    if (result != KErrNone && result != KErrNotSupported)

        {

        test.Console()->ClearScreen();

        test.Console()->SetPos(0,0);

        DisplayErrorReason(result);

		iBioTestUtils->TestHarnessFailed(result);

        CActiveScheduler::Stop();

        return;

        }

	if(iState==EProcess)

		iBioTestUtils->WriteComment(_L("ProcessL not supported"));

	iBioTestUtils->TestFinish(iTestCtr);

	iTestCtr++;

    switch (iState)

        {

        case EParse:

            Start(EProcess);

            break;

		case EProcess:

			Start(EReparse);

			break;

		case EReparse:

			Start(EDisplay);

			break;

		case EDisplay:

			{

			if(++iMsgCtr < iMsgCount)

				Start(EParse);

			else

				{

				test.Console()->ClearScreen();

				test.Console()->SetPos(0,0);

				DisplayErrorReason(result);

				iParser->Cancel();

				iBioTestUtils->TestHarnessCompleted();

				CActiveScheduler::Stop();

				}

			}

			break;

        default:

            break;

        }

    }

// end CTestEnp::RunL()

void CTestEnp::DoCancel()

    {

    }

// end CTestEnp::DoCancel()

void CTestEnp::RequestComplete(TRequestStatus& aStatus,TInt aCompletion)

	{

	TRequestStatus* statusPtr=&aStatus;

	User::RequestComplete(statusPtr,aCompletion);

	}

LOCAL_C void DisplayErrorReason(TInt& aReason)

    {

    switch (aReason)

        {

       case KErrNone:

            test.Printf(_L("Session completed successfully"));

            break;

        case KErrCancel:

            test.Printf(_L("Session cancelled"));

            break;

        case KErrEof:

            test.Printf(_L("KErrEof"));

            break;

        case KErrNoMemory:

            test.Printf(_L("No memory"));

            break;

        case KErrDisconnected:

            test.Printf(_L(" KErrDisconnected"));

            break;

        case KErrAccessDenied:

            test.Printf(_L("KErrAccessDenied"));

            break;

        case KErrNotSupported:

            test.Printf(_L("Function Not Supported, Error = %d\n"), aReason);

            break;

        default:

            test.Printf(_L("Error !!!= %d\n"), aReason );

            break;

        }

    }

LOCAL_C void doMainL()

    {

    //create a scheduler

    exampleScheduler = new (ELeave) CExampleScheduler;

    CleanupStack::PushL( exampleScheduler );

    CActiveScheduler::Install( exampleScheduler );

    CTestEnp* testParser = CTestEnp::NewL();

    CleanupStack::PushL(testParser);

    test(testParser != NULL);

    testParser->Start(CTestEnp::EParse);

    CActiveScheduler::Start();

    CleanupStack::PopAndDestroy(2); // testParser, exampleScheduler, sEntry ,theServer

    }

// end doMainL()

CTestEnp::CTestEnp()

:CActive(KTestEnpPriority)

    {

    }

// end CTestEnp::CTestEnp()

CTestEnp::~CTestEnp()

    {

    Cancel();

	delete iParser;

	delete iMsvSelection;

	delete iBioTestUtils;

	delete iMsgBuffer;

	if(iTestParsedFieldArray)

		{

		iTestParsedFieldArray->ResetAndDestroy();

		delete iTestParsedFieldArray;

		iTestParsedFieldArray=NULL;

		}

    }

// end CTestEnp::~CTestEnp()

GLDEF_C TInt E32Main()

    {

    test.Title();

    test.Start(_L("ENP Test Harness"));

    __UHEAP_MARK;

    CTrapCleanup* cleanup=CTrapCleanup::New();

    test(cleanup!=NULL);

    TRAPD(error,doMainL());

    if (error) test.Printf(_L("Completed with return code %d"),error);

    delete cleanup;

    __UHEAP_MARKEND;

    test.Close();

    test.End();

    return KErrNone;

    }

// end E32Main()