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

//

#include "smtptestparsers.h"

#include "smtptests.h"

_LIT(KCommandSmtpClientTest, "smtp_client_test");

// SMTP commands

_LIT(KCommandSmtpService, "smtp_service");

// SMTP settings strings

_LIT(KCommandEmailSetServer, "set_server");

_LIT(KCommandEmailSetAlias, "set_alias");

_LIT(KCommandEmailSetAddress, "set_email_address");

_LIT(KCommandEmailSetReplyAddress, "set_reply_address");

_LIT(KCommandEmailSetReceiptAddress, "set_receipt_address");

_LIT(KCommandSmtpSetTLS,			"set_tls");				// 1 parameter, sets the secure connection for SMTP service

_LIT(KCommandSmtp3SetWrappedTLS,  "set_wrapped_tls");	    // 1 parameter, sets the secure connection for SMTP service.  value should be 1 or 0

_LIT(KCommandSmtpSetPort,  "set_port");	                    // 1 parameter, sets the port no for SMTP service.

_LIT(KCommandSmtpCheckStatus, "check_smtp_error");

_LIT(KCommandSmtpCopyAndMonitor,			"copy_and_monitor");	// 0 parameters, copies and monitors SMTP service

// Smtp Operations

_LIT(KCommandSmtpUseService,		"use_service");	// 0 parameters, uses the currently selected service

//

//

// CNewSmtpTestCommandParser

//

// A command parser

// Parses the command which generates a new SMTP test harness

// This command would usually be found in an email test section

CNewSmtpTestCommandParser* CNewSmtpTestCommandParser::NewL(CTestScript& aScript, CEmailClientTest& aEmailClientTest)

	{

	CNewSmtpTestCommandParser* self = new (ELeave) CNewSmtpTestCommandParser(aScript, aEmailClientTest);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	};

void CNewSmtpTestCommandParser::ProcessL()

	{

	// Create an smtp test, give it the test utilities

	CSmtpClientTest* smtpTest = CSmtpClientTest::NewL(iEmailClientTest.EmailTestUtils(), iEmailClientTest.TestConsole());

	CleanupStack::PushL(smtpTest);

	// Attach the email test to the main test

	iEmailClientTest.AddStateL(smtpTest, iDebugInfo);

	CleanupStack::Pop(smtpTest); // emailTest is now owned by the iMainTest

	// Check that there is one argument, the email test section name

	CheckNumberOfArgumentsL(1);

	// Create an email section parser

	CSmtpClientSectionParser* sectionParser = CSmtpClientSectionParser::NewL(*smtpTest, iScript, (*iArgumentList)[0]);

	CleanupStack::PushL(sectionParser);

	sectionParser->ParseL();

	CleanupStack::PopAndDestroy(sectionParser);

	}

void CNewSmtpTestCommandParser::ConstructL()

	{

	CBaseCommandParser::ConstructL();

	AddCommandL(KCommandSmtpClientTest);

	}

CNewSmtpTestCommandParser::CNewSmtpTestCommandParser(CTestScript& aScript, CEmailClientTest& aEmailClientTest) : iEmailClientTest(aEmailClientTest), iScript(aScript)

	{

	}

//

//

// CSmtpClientSectionParser

//

// A section parser

// Parses an SMTP test section

CSmtpClientSectionParser* CSmtpClientSectionParser::NewL(CSmtpClientTest& aSmtpClientTest, CTestScript& aScript, const TDesC& aNewSectionName)

	{

	CSmtpClientSectionParser* self = new (ELeave) CSmtpClientSectionParser(aSmtpClientTest, aScript);

	CleanupStack::PushL(self);

	self->ConstructL(aNewSectionName);

	CleanupStack::Pop(self);

	return self;

	}

void CSmtpClientSectionParser::ConstructL(const TDesC& aNewSectionName)

	{

	CEmailClientSectionParser::ConstructL(aNewSectionName);

	AddCommandParserL(CSmtpServiceCommandParser::NewL(iScript, iSmtpTest));

	AddCommandParserL(CSmtpCheckStatusParser::NewL(iSmtpTest));

	AddCommandParserL(CSmtpOperationParser::NewL(iSmtpTest));	

	}

CSmtpClientSectionParser::CSmtpClientSectionParser(CSmtpClientTest& aSmtpTest, CTestScript& aScript) : CEmailClientSectionParser(aSmtpTest, aScript), iSmtpTest(aSmtpTest)

	{

	}

//

//

// CSmtpServiceCommandParser

//

void CSmtpServiceCommandParser::ProcessL()

	{

	CheckNumberOfArgumentsL(1);

	// Create the settings object which we will give to the settings section parser

	CSmtpServiceSectionParser* serviceParser = CSmtpServiceSectionParser::NewL(iScript, iSmtpClientTest, (*iArgumentList)[0]);

	CleanupStack::PushL(serviceParser);

	serviceParser->ParseL();

	CleanupStack::PopAndDestroy(serviceParser);

	}

CSmtpServiceCommandParser* CSmtpServiceCommandParser::NewL(CTestScript& aScript, CSmtpClientTest& aSmtpClientTest)

	{

	CSmtpServiceCommandParser* self = new (ELeave) CSmtpServiceCommandParser(aScript, aSmtpClientTest);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CSmtpServiceCommandParser::ConstructL()

	{

	CBaseCommandParser::ConstructL();

	AddCommandL(KCommandSmtpService);

	}

CSmtpServiceCommandParser::CSmtpServiceCommandParser(CTestScript& aScript, CSmtpClientTest& aSmtpClientTest) : iSmtpClientTest(aSmtpClientTest), iScript(aScript)

	{

	}

//

//

// CSmtpServiceSectionParser

//

// A section parser

// Parses a SMTP section to create a SMTP service

CSmtpServiceSectionParser* CSmtpServiceSectionParser::NewL(CTestScript& aScript, CEmailClientTest& aTestHarness, const TDesC& aSectionName)

	{

	CSmtpServiceSectionParser* self = new (ELeave) CSmtpServiceSectionParser(aScript, aTestHarness);

	CleanupStack::PushL(self);

	self->ConstructL(aSectionName);

	CleanupStack::Pop(self);

	return self;

	}

void CSmtpServiceSectionParser::ConstructL(const TDesC& aSectionName)

	{

	CBaseSectionParser::ConstructL(aSectionName);

	// Add the state to generate the smtp service

	CCreateSmtpService* testState = CCreateSmtpService::NewL(iTestHarness);

	TTestDebugInfo debugInfo(iScript, iSection->SectionPosition(), 0);

	iTestHarness.AddStateL(testState, debugInfo);

	// The parsers will fill in the entry and service details before the state that creates the entry is run.

	AddCommandParserL(CSmtpServiceCommands::NewL(*testState));

	CEmailServiceSectionParser::ConstructL(aSectionName, *testState);

	}

CSmtpServiceSectionParser::CSmtpServiceSectionParser(CTestScript& aScript, CEmailClientTest& aTestHarness) : CEmailServiceSectionParser(aScript, aTestHarness)

	{

	}

CSmtpServiceSectionParser::~CSmtpServiceSectionParser()

	{

	}

//

//

// CSmtpServiceCommands

//

// A command parser

// Parses the commands that generate the SMTP service

CSmtpServiceCommands* CSmtpServiceCommands::NewL(CCreateSmtpService& aTestState)

	{

	CSmtpServiceCommands* self = new (ELeave) CSmtpServiceCommands(aTestState);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CSmtpServiceCommands::ProcessL()

	{

	// eh xxxx, check args

	if ((*iCurrentCommand) == KCommandEmailSetServer)

		{

		iTestState.Settings().SetServerAddressL((*iArgumentList)[0]);

		}

	else if ((*iCurrentCommand) == KCommandEmailSetAlias)

		{

		iTestState.Settings().SetEmailAliasL((*iArgumentList)[0]);

		iTestState.SetDetailsStringL((*iArgumentList)[0]);

		}

	else if ((*iCurrentCommand) == KCommandEmailSetAddress)

		{

		iTestState.Settings().SetEmailAddressL((*iArgumentList)[0]);

		}

	else if ((*iCurrentCommand) == KCommandEmailSetReplyAddress)

		{

		iTestState.Settings().SetReplyToAddressL((*iArgumentList)[0]);

		}

	else if ((*iCurrentCommand) == KCommandEmailSetReceiptAddress)

		{

		iTestState.Settings().SetReceiptAddressL((*iArgumentList)[0]);

		}

	else if ((*iCurrentCommand) == KCommandSmtpSetTLS)

		{

		CheckNumberOfArgumentsL(1);

		TLex lex((*iArgumentList)[0]);

		TInt setTls=0;

		User::LeaveIfError(lex.Val(setTls));

		iTestState.Settings().SetSecureSockets(setTls);

		}

	else if ((*iCurrentCommand) == KCommandSmtp3SetWrappedTLS)

		{

		CheckNumberOfArgumentsL(1);

		TLex lex((*iArgumentList)[0]);

		TInt setWrappedTls=0;

		User::LeaveIfError(lex.Val(setWrappedTls));

		iTestState.Settings().SetSSLWrapper(setWrappedTls);

		}

	else if ((*iCurrentCommand) == KCommandSmtpSetPort)

		{

		CheckNumberOfArgumentsL(1);

		TLex lex((*iArgumentList)[0]);

		TInt setPort=0;

		User::LeaveIfError(lex.Val(setPort));

		iTestState.Settings().SetPort(setPort);

		}

	}

CSmtpServiceCommands::CSmtpServiceCommands(CCreateSmtpService& aTestState) : iTestState(aTestState)

	{

	}

void CSmtpServiceCommands::ConstructL()

	{

	CBaseCommandParser::ConstructL();

	AddCommandL(KCommandEmailSetServer);

	AddCommandL(KCommandEmailSetAlias);

	AddCommandL(KCommandEmailSetAddress);

	AddCommandL(KCommandEmailSetReplyAddress);

	AddCommandL(KCommandEmailSetReceiptAddress);

	AddCommandL(KCommandSmtpSetTLS);

	AddCommandL(KCommandSmtp3SetWrappedTLS);

	AddCommandL(KCommandSmtpSetPort);

	}

//

//

// CSmtpCheckStatusParser

//

CSmtpCheckStatusParser* CSmtpCheckStatusParser::NewL(CSmtpClientTest& aSmtpTestHarness)

	{

	CSmtpCheckStatusParser* self = new (ELeave) CSmtpCheckStatusParser(aSmtpTestHarness);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CSmtpCheckStatusParser::ProcessL()

	{

	TLex lex((*iArgumentList)[0]);

	TInt expectedStatus;

	User::LeaveIfError(lex.Val(expectedStatus));

	iTestHarness.AddStateL(new (ELeave) CCheckSmtpOperation(expectedStatus, iTestHarness), iDebugInfo);

	}

CSmtpCheckStatusParser::CSmtpCheckStatusParser(CSmtpClientTest& aSmtpTestHarness) : iTestHarness(aSmtpTestHarness)

	{

	}

void CSmtpCheckStatusParser::ConstructL()

	{

	CBaseCommandParser::ConstructL();

	AddCommandL(KCommandSmtpCheckStatus);

	}

//

//

// CSmtpOperationParser

//

CSmtpOperationParser* CSmtpOperationParser::NewL(CSmtpClientTest& aSmtpClientTest)

	{

	CSmtpOperationParser* self = new (ELeave) CSmtpOperationParser(aSmtpClientTest);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CSmtpOperationParser::ProcessL()

	{

	if ((*iCurrentCommand) == KCommandSmtpUseService)

		{

		CheckNumberOfArgumentsL(0);

		iSmtpClientTest.AddStateL(new (ELeave) CSmtpUseService(iSmtpClientTest), iDebugInfo);

		}

	else if ((*iCurrentCommand) == KCommandSmtpCopyAndMonitor)

		{

		CheckNumberOfArgumentsL(0);

		iSmtpClientTest.AddStateL(new (ELeave) CCopySelectionAndMonitor(iSmtpClientTest, EFalse), iDebugInfo);

		}

	else

		{

		User::Leave(KErrNotFound);

		}

	}

void CSmtpOperationParser::ConstructL()

	{

	CBaseCommandParser::ConstructL();

	AddCommandL(KCommandSmtpUseService);

	AddCommandL(KCommandSmtpCopyAndMonitor);

	}

CSmtpOperationParser::CSmtpOperationParser(CSmtpClientTest& aSmtpClientTest) : iSmtpClientTest(aSmtpClientTest)

	{

	}