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

// Component: IMCM

// Owner: KP

// Brief description of test harness:

// Tests the client-side API of POP3 MTM; Query capability; standard POP3 

// functionality; CImPop3GetMail API.

// Detailed description of test harness:

// As above.

// Input files required to run test harness:

// None

// Intermediate files produced while running test harness:

// <DRIVE>:\msglogs\T_POPC\T_IMCM.log

// <DRIVE>:\msglogs\T_POPC\Entry_Structure.txt

// Output files produced by running test harness:

// <DRIVE>:\msglogs\T_POPC.<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_POPC.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_POPC.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_POPC.exe on the other platform

// 

//

#include "emailtestutils.h"

#include <txtrich.h>

#include <c32comm.h>

#include <commdb.h>

#include <mtmuids.h>

#include "TESTENV.h"

#include <bacline.h>

#include <cemailaccounts.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

#include "cimmessagepart.h"

#endif

// For loading the serial comms device drivers 

#if defined (__WINS__)

	#define PDD_NAME		_L("ECDRV")

	#define LDD_NAME		_L("ECOMM")

#else

	#define PDD_NAME		_L("EUART1")

	#define LDD_NAME		_L("ECOMM")

#endif

// local variables etc //

_LIT(KImcmTest, "T_POPC - Testing CImPop3GetMail");

RTest test(KImcmTest);

_LIT(KTestParams,"-testparams");

enum TCmdLineArgs

	{

	EArgProgramName,

	EArgTestParams,

	EArgServerAddress,

	EArgLogin,

	EArgPassword,

	EArgPopulationLimit,

	EArgEnd

	};

LOCAL_D TMsvId Pop3Service;

LOCAL_D TMsvId smtpService;

LOCAL_D CTrapCleanup* theCleanup;

LOCAL_D CEmailTestUtils* testUtils;

LOCAL_D CMsvOperation* msvOperation;

LOCAL_D CMsvEntrySelection* msvSelection;

LOCAL_D CMsvEntrySelection* messageSelection;

LOCAL_D CConsoleBase* console;

class COperationActive;

LOCAL_D COperationActive* opActive;

LOCAL_D TInt testNo = 1;

LOCAL_D TInt globalError = 0;

LOCAL_D TBool iDoCancel = EFalse;

_LIT(KTestSettingsServerAddress,"2.2.2.2");

const TInt KTestSettingsPort = 111;

_LIT8(KTestSettingsLoginName,"testuser");

_LIT8(KTestSettingsPassword,"password");

const TInt KTestPopulationLimit=30;

_LIT(KServer, "lon-cn-exchng2k.msexchange2k.closedtest.intra");

_LIT8(KLoginName, "t_popc");

_LIT8(KPassword, "t_popc");

//

class TestUiTimer : public CTimer

	{

public:

	static TestUiTimer* NewLC(CConsoleBase* aConsole);

	~TestUiTimer();

	void RunL();

	void DoCancel();

	void ConstructL();

	void IssueRequest();

	void SetOperation(CMsvOperation* aOperation);

	TTimeIntervalMicroSeconds32 period;

	TPtrC Progress(TInt progressNumber);

	void SetCancelState(TInt aState);

protected:

	TestUiTimer(CConsoleBase* aConsole);

	CConsoleBase*		iConsole;

public:

	CMsvOperation*		iOperation;

private:

	TInt	iCancelState;

	};

//

TestUiTimer* TestUiTimer::NewLC(CConsoleBase* aConsole)

	{

	TestUiTimer* self = new(ELeave) TestUiTimer(aConsole);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

TestUiTimer::TestUiTimer(CConsoleBase* aConsole)

	: CTimer(1), iCancelState(KMaxTInt)

	{

	iConsole = aConsole;

	period = 10000;

	}

TestUiTimer::~TestUiTimer()

	{

	delete iOperation;

	}

void TestUiTimer::ConstructL()

	{

	CTimer::ConstructL();

	CActiveScheduler::Add(this);

	}

void TestUiTimer::IssueRequest()

	{

	After(period);

	}

void TestUiTimer::SetOperation(CMsvOperation* aOperation)

	{

	if(iOperation)

		{

		delete iOperation;

		iOperation=NULL;

		}

	iOperation = aOperation;

	}

void TestUiTimer::DoCancel()

	{

	CTimer::DoCancel();

	}

TPtrC TestUiTimer::Progress(TInt progressNumber)

	{

	switch (progressNumber)

		{

		case 0:

			return _L("Refreshing              ");

		case 1:

			return _L("Copying                 ");

		case 2:

			return _L("Deleting                ");

		case 3:

			return _L("Connecting              ");

		case 4:

			return _L("Tidying                 ");

		case 5:

			return _L("Connected and Idle      ");

		case 6:

			return _L("Disconnecting           ");

		case 7:

			return _L("Disconnected            ");

		case 8:

			return _L("Moving                  ");

		case 9:

			return _L("Copying New Mail        ");

		case 10:

			return _L("Moving New Mail         ");

		case 11:

			return _L("Copying Mail Selection  ");

		case 12:

			return _L("Moving Mail Selection   ");

		case 13:

			return _L("Copying All Mail        ");

		case 14:

			return _L("Moving All Mail         ");

		default:

			return _L("Unknown Progress        ");

		}

	}

void TestUiTimer::SetCancelState(TInt aState)

	{

	iCancelState = aState;

	}

void TestUiTimer::RunL()

	{

	// display the current progress

	if(iOperation!=NULL)

		{

		if(iDoCancel == TBool(ETrue))

			{

			iOperation->Cancel();

			}

		TPop3Progress temp;	

		TPckgC<TPop3Progress> paramPack(temp);

		paramPack.Set(iOperation->ProgressL());

		TPop3Progress progress=paramPack();	

		if (iCancelState == progress.iPop3SubStateProgress)

			{

			iConsole->Printf(_L("	Calling Cancel\n"));

			iOperation->Cancel();

			}

		iConsole->SetPos(0, 12);

		TBuf<80> progressBuf = Progress(progress.iPop3Progress);

		iConsole->Printf(TRefByValue<const TDesC>_L("   Super Operation Progress: %S           "), &progressBuf);

		iConsole->SetPos(0, 13);

		progressBuf = Progress(progress.iPop3SubStateProgress);

		iConsole->Printf(TRefByValue<const TDesC>_L("   Sub Operation Progress  : %S           "), &progressBuf);

		iConsole->SetPos(0, 14);

		iConsole->Printf(TRefByValue<const TDesC>_L("   Progress:  %d/%d %d/%d Total:%d                \n"),

					progress.iTotalMsgs-progress.iMsgsToProcess,

					progress.iTotalMsgs,

					progress.iBytesDone,

					progress.iTotalBytes,

					progress.iTotalSize);

		iConsole->SetPos(0, 15);

		iConsole->Printf(TRefByValue<const TDesC>_L("   Error: %d                             \n"), progress.iErrorCode);

		if (progress.iErrorCode && !globalError)

			{

			if(!iDoCancel || progress.iErrorCode!=KErrCancel)

				{// we should not report KErrCancel as an error when iDoCancel is true because that is expected behviour

				globalError=progress.iErrorCode;

				}

			}

		}

	IssueRequest();

	};

//

class COperationActive : public CActive

	{

public:

	COperationActive();

	~COperationActive();

	static COperationActive* NewL();

	void StartL(TBool aDisableProgress = EFalse);

	void SetOperation(CMsvOperation*);

	void SetCancelState(TInt aCancelState);

protected:

	void DoCancel();

	void RunL();

public:	

	TestUiTimer* iTimer;

private:

	TBool iSetActive;

	};

//

COperationActive::COperationActive()

: CActive(0)

	{

	}

COperationActive::~COperationActive()

	{

	Cancel();

	delete iTimer;

	}

COperationActive* COperationActive::NewL()

	{

	COperationActive* self = new (ELeave) COperationActive;

	CActiveScheduler::Add(self);

	self->iSetActive = ETrue;

	self->iTimer = TestUiTimer::NewLC(test.Console());

	CleanupStack::Pop();

	return self;

	}

void COperationActive::DoCancel()

	{

	iTimer->DoCancel();

	}

void COperationActive::StartL(TBool aDisableProgress)

	{

	if(aDisableProgress)

		{

		iTimer->IssueRequest();	// Start the connect observation timer

		SetActive();

		test.Printf(TRefByValue<const TDesC>_L("POP3 progress disabled"));

		}

	else

		{	

		TPop3Progress temp;	

		TPckgC<TPop3Progress> paramPack(temp);

		paramPack.Set(iTimer->iOperation->ProgressL());

		TPop3Progress progress=paramPack();	

		switch(progress.iPop3Progress)

			{

			case TPop3Progress::EPopDisconnected:

			case TPop3Progress::EPopDisconnecting:

				// don't set active

				iSetActive = EFalse;

				break;

			case TPop3Progress::EPopCopyNewMail:

			case TPop3Progress::EPopMoveNewMail:

			case TPop3Progress::EPopCopyMailSelection:

			case TPop3Progress::EPopMoveMailSelection:

			case TPop3Progress::EPopCopyAllMail:

			case TPop3Progress::EPopMoveAllMail:

			case TPop3Progress::EPopPopulating:

			default:

				switch(progress.iPop3SubStateProgress)

					{

					// don't set active if we are in the disconnecting state or if we have disconnected.

					case TPop3Progress::EPopDisconnected:

					case TPop3Progress::EPopDisconnecting:

					default:

						// don't set active

						iSetActive = EFalse;	

						break;

					case TPop3Progress::EPopCopying:

					case TPop3Progress::EPopDeleting:

					case TPop3Progress::EPopConnectedAndIdle:

					case TPop3Progress::EPopMoving:

					case TPop3Progress::EPopRefreshing:

					case TPop3Progress::EPopConnecting:

					case TPop3Progress::EPopTidying:

						{

						if (iSetActive && iTimer->iOperation->IsActive())

							{

							iTimer->IssueRequest();	// Start the connect observation timer

							SetActive();

							}

						}

					}

			}

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

		test.Printf(TRefByValue<const TDesC>_L("Operation TRequestStatus %d"), iStatus);

		}

	}

void COperationActive::SetOperation(CMsvOperation *aOperation)

	{

	iTimer->SetOperation(aOperation);

	}

void COperationActive::SetCancelState(TInt aCancelState)

	{

	iTimer->SetCancelState(aCancelState);

	}

void COperationActive::RunL() 

	{

	iTimer->Cancel();

	test.Console()->SetPos(25, 17);

	test.Printf(_L("                "));

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

	test.Printf(TRefByValue<const TDesC>_L("Operation TRequestStatus %d"), iStatus);

	CActiveScheduler::Stop();

	}

//

LOCAL_C void StoreClientSettingsL()

//

// Dummy settings for checking that StoreSettingsL work for the client mtm

//	

	{

	testUtils->WriteComment(_L("Storing settings in client mtm"));

	CImPop3Settings* pop3Settings = new(ELeave)CImPop3Settings;

	CleanupStack::PushL(pop3Settings);

	pop3Settings->CopyL(testUtils->iPopClientMtm->Settings());

    pop3Settings->SetServerAddressL(KTestSettingsServerAddress);

	pop3Settings->SetPort(KTestSettingsPort);

	pop3Settings->SetLoginNameL(KTestSettingsLoginName);

	pop3Settings->SetPasswordL(KTestSettingsPassword);

	pop3Settings->SetPopulationLimitL(KTestPopulationLimit);

	testUtils->iPopClientMtm->SetSettingsL(*pop3Settings);

	CleanupStack::PopAndDestroy(pop3Settings);

	testUtils->iPopClientMtm->StoreSettingsL();

	}

LOCAL_C TInt VerifyStoredClientSettingsL()

//

// Comparison of the settings stored to see that the client commits after storing

//

	{

	// Handle command line arguments

	CCommandLineArguments* cmdLineArg=CCommandLineArguments::NewLC();

	TInt count = cmdLineArg->Count();

	TBool isCmdLine=FALSE;

	if (count>2)	// Command line arguments?

		{

		if ((!(cmdLineArg->Arg(EArgTestParams).Compare(KTestParams))) && count==EArgEnd)

			isCmdLine=TRUE;

		}	

	testUtils->WriteComment(_L("Checking stored settings in client mtm"));

	testUtils->iPopClientMtm->RestoreSettingsL();

	CImPop3Settings* pop3Settings = new(ELeave)CImPop3Settings;

	CleanupStack::PushL(pop3Settings);

	pop3Settings->CopyL(testUtils->iPopClientMtm->Settings());

    TInt result=0;

	result += pop3Settings->ServerAddress().Compare(KTestSettingsServerAddress);

	result += pop3Settings->Port() - KTestSettingsPort;

	result += pop3Settings->LoginName().Compare(KTestSettingsLoginName);

	result += pop3Settings->Password().Compare(KTestSettingsPassword);

    result += (pop3Settings->PopulationLimit()!=KTestPopulationLimit);

	pop3Settings->Reset();

	if (isCmdLine)

		{

		TBuf<100> buf;

		TLex lex(cmdLineArg->Arg(EArgServerAddress));

		buf=lex.NextToken();

		pop3Settings->SetServerAddressL(buf);

		}

	else

		{

		pop3Settings->SetServerAddressL(KServer);

		}

	if (isCmdLine)

		{

		TBuf<100> buf;

		TBuf8<64> data;

		TLex lex(cmdLineArg->Arg(EArgLogin));

		buf=lex.NextToken();

		data.Copy(buf);

		pop3Settings->SetLoginNameL(data);

		}

	else

		{

		pop3Settings->SetLoginNameL(KLoginName);

		}

	if (isCmdLine)

		{

		TBuf<100> buf;

		TBuf8<64> data;

		TLex lex(cmdLineArg->Arg(EArgPassword));

		buf=lex.NextToken();

		data.Copy(buf);

		pop3Settings->SetPasswordL(data);

		}

	else

		{

		pop3Settings->SetPasswordL(KPassword);

		}

	if (isCmdLine)

		{

		TBuf<100> buf;

		TLex lex(cmdLineArg->Arg(EArgPopulationLimit));

		buf=lex.NextToken();

		TInt limit;

		TLex lex2(buf);

		lex2.Val(limit);

		pop3Settings->SetPopulationLimitL(limit);

		}

	else

		{

		TInt populationLimit=40;

		pop3Settings->SetPopulationLimitL(populationLimit);

		}