--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/messagingfw/msgtest/integration/email/src/imaptestparsers.cpp Mon Jan 18 20:36:02 2010 +0200
@@ -0,0 +1,584 @@
+// 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 "imaptestparsers.h"
+#include "imaptests.h"
+
+_LIT(KCommandImapClientTest, "imap_client_test");
+_LIT(KCommandImapService, "imap_service"); // 1 parameter, creates an imap service
+_LIT(KCommandImapUseService, "use_service"); // 0 parameters, uses the currently selected service
+
+// IMAP settings strings
+_LIT(KCommandImapSetServer, "set_server"); // 1 parameter, sets the IMAP server
+_LIT(KCommandImapSetUserName, "set_user"); // 1 parameter, sets the username for the IMAP service
+_LIT(KCommandImapSetPassword, "set_pass"); // 1 parameter, sets the password for the IMAP service
+_LIT(KCommandImapSetName, "set_name"); // 1 parameter, sets the name of the IMAP service
+_LIT(KCommandImapSetFolderPath, "set_folder_path"); // 1 parameter, sets the folder path of the IMAP service
+_LIT(KCommandImapSetTLS, "set_tls"); // 1 parameter, sets the secure connection for IMAP service. Value should be 0 or 1
+_LIT(KCommandImapSetUpdatingSeenFlags, "set_updating_seen_flag"); // 1 parameter, sets the updating seen flag value to the parameter value
+_LIT(KCommandImapSetWrappedTLS, "set_wrapped_tls"); // 1 parameter, sets the secure connection for IMAP service. value should be 1 or 0
+_LIT(KCommandImapSetPort, "set_port"); // 1 parameter, sets the port no for IMAP service.
+
+// IMAP Operations
+_LIT(KCommandImapConnect, "connect"); // 0 parameters, connects to the IMAP service
+_LIT(KCommandImapConnectAndCancel, "connect_and_cancel"); // 1 parameters, connects to the IMAP service, starts the sync process then cancels after the specified interval
+_LIT(KCommandImapConnectAndMonitor, "connect_and_monitor"); // 0 parameters, connects to the IMAP service and monitors connection
+_LIT(KCommandImapConnectMonitorAndSync, "connect_monitor_and_sync"); // 0 parameters, connects to the IMAP service and monitors connection, then syncs
+_LIT(KCommandImapConnectAndSync, "connect_and_sync"); // 0 parameters, connects to the IMAP service and automatically synchronises
+_LIT(KCommandImapConnectAndPeriodicSync, "connect_and_periodic_sync"); // 0 parameters, connects to the IMAP service and automatically synchronises
+_LIT(KCommandImapDisconnect, "disconnect"); // 0 parameters, disconnects from the IMAP service
+
+_LIT(KCommandImapSetSyncRate, "set_sync_rate"); // 1 parameters, sets the sync rate - in seconds
+_LIT(KCommandImapGetSyncRate, "get_sync_rate"); // 1 parameters, gets the sync rate and validates with given rate param
+
+_LIT(KCommandImapCheckStatus, "check_imap_error"); // 1 parameter, checks the last error code and compares it to param 1
+ // Note: must only be used to check commands that have been set using
+ // CMsvClientTest::SetCurrentOperation
+
+_LIT(KCommandImapSyncTree, "sync_tree"); // 0 parameters, synchronises the local IMAP structure with the remote
+_LIT(KCommandImapCheckRemoteInbox, "check_remote_inbox"); // 0 parameters, checks the remote inbox for new mail and retrieves headers
+_LIT(KCommandImapSyncFolder, "sync_folder"); // 0 parameters, synchonises the currently selected IMAP folder with the server
+_LIT(KCommandImapSubscribeFolder, "subscribe_folder"); // 0 parameters, subscribes to the currently selected folder
+_LIT(KCommandImapUnsubscribeFolder, "unsubscribe_folder"); // 0 parameters, unsubscribes from the currently selected folder
+_LIT(KCommandImapPopulateFolder, "populate_folder"); // 0 parameters, populates the bodies of the currently selected messages
+_LIT(KCommandImapPerformFullSync, "perform_full_sync"); // 0 parameters, performs a full synchronisation with the selected remote service
+_LIT(KCommandImapSetSyncLimits, "set_sync_limits"); // 2 parameters, resets the sync limits for currently selected imap service
+
+//Commands for IMAP read status testing - defect INC016632
+//mark_selection_unread
+//check_selection
+
+_LIT(KCommandImapMarkSelection, "mark_selection_unread"); // 1 parameter, marks all the messages in mailbox as specified in parameter
+_LIT(KCommandImapCheckSelectionUnread, "check_selection_unread"); // 1 parameter, checks the unread flag all the messages in mailbox as specified in parameter
+_LIT(KCommandImapCheckSelectionSeen, "check_selection_seen"); // 1 parameter, checks the seen flag all the messages in mailbox as specified in parameter
+_LIT(KCommandImapMarkSelectedMail, "mark_selected_mail"); // 0 parameters, marks selected messages in mailbox as read
+_LIT(KCommandImapCheckSelectedMail, "check_selected_mail"); // 0 parameters, checks selected messages in mailbox as read
+
+//
+//
+// CNewImapTestCommandParser
+//
+// A command parser
+// Parses the command which generates a new Imap test harness
+// This command would usually be found in an email test section
+
+CNewImapTestCommandParser* CNewImapTestCommandParser::NewL(CTestScript& aScript, CEmailClientTest& aEmailClientTest)
+ {
+ CNewImapTestCommandParser* self = new (ELeave) CNewImapTestCommandParser(aScript, aEmailClientTest);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ };
+
+void CNewImapTestCommandParser::ProcessL()
+ {
+ // Create an smtp test, give it the test utilities
+ CImapClientTest* imapTest = CImapClientTest::NewL(iEmailClientTest.EmailTestUtils(), iEmailClientTest.TestConsole());
+ CleanupStack::PushL(imapTest);
+
+ // Attach the email test to the main test
+ iEmailClientTest.AddStateL(imapTest, iDebugInfo);
+ CleanupStack::Pop(imapTest); // 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
+ CImapClientSectionParser* sectionParser = CImapClientSectionParser::NewL(*imapTest, iScript, (*iArgumentList)[0]);
+ CleanupStack::PushL(sectionParser);
+ sectionParser->ParseL();
+ CleanupStack::PopAndDestroy(sectionParser);
+ }
+
+void CNewImapTestCommandParser::ConstructL()
+ {
+ CBaseCommandParser::ConstructL();
+ AddCommandL(KCommandImapClientTest);
+ }
+
+CNewImapTestCommandParser::CNewImapTestCommandParser(CTestScript& aScript, CEmailClientTest& aEmailClientTest) : iEmailClientTest(aEmailClientTest), iScript(aScript)
+ {
+ }
+
+
+
+
+//
+//
+// CImapClientSectionParser
+//
+// A section parser
+// Parses an IMAP test section
+
+CImapClientSectionParser* CImapClientSectionParser::NewL(CImapClientTest& aImapClientTest, CTestScript& aScript, const TDesC& aNewSectionName)
+ {
+ CImapClientSectionParser* self = new (ELeave) CImapClientSectionParser(aImapClientTest, aScript);
+ CleanupStack::PushL(self);
+ self->ConstructL(aNewSectionName);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+void CImapClientSectionParser::ConstructL(const TDesC& aNewSectionName)
+ {
+ CEmailClientSectionParser::ConstructL(aNewSectionName);
+ AddCommandParserL(CImapServiceCommandParser::NewL(iScript, iImapTest));
+ AddCommandParserL(CImapOperationParser::NewL(iImapTest));
+ AddCommandParserL(CImapCheckStatusParser::NewL(iImapTest));
+ }
+
+CImapClientSectionParser::CImapClientSectionParser(CImapClientTest& aImapTest, CTestScript& aScript) : CEmailClientSectionParser(aImapTest, aScript), iImapTest(aImapTest)
+ {
+ }
+
+
+
+//
+//
+// CImapServiceCommandParser
+//
+
+void CImapServiceCommandParser::ProcessL()
+ {
+ CheckNumberOfArgumentsL(1);
+ // Create the settings object which we will give to the settings section parser
+ CImapServiceSectionParser* serviceParser = CImapServiceSectionParser::NewL(iScript, iImapClientTest, (*iArgumentList)[0]);
+ CleanupStack::PushL(serviceParser);
+
+ serviceParser->ParseL();
+ CleanupStack::PopAndDestroy(serviceParser);
+ }
+
+CImapServiceCommandParser* CImapServiceCommandParser::NewL(CTestScript& aScript, CImapClientTest& aImapClientTest)
+ {
+ CImapServiceCommandParser* self = new (ELeave) CImapServiceCommandParser(aScript, aImapClientTest);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+void CImapServiceCommandParser::ConstructL()
+ {
+ CBaseCommandParser::ConstructL();
+ AddCommandL(KCommandImapService);
+ }
+
+CImapServiceCommandParser::CImapServiceCommandParser(CTestScript& aScript, CImapClientTest& aImapClientTest) : iImapClientTest(aImapClientTest), iScript(aScript)
+ {
+ }
+
+
+
+
+//
+//
+// CImapServiceSectionParser
+//
+
+// A section parser
+// Parses a IMAP section to create a IMAP service
+
+CImapServiceSectionParser* CImapServiceSectionParser::NewL(CTestScript& aScript, CEmailClientTest& aTestHarness, const TDesC& aSectionName)
+ {
+ CImapServiceSectionParser* self = new (ELeave) CImapServiceSectionParser(aScript, aTestHarness);
+ CleanupStack::PushL(self);
+ self->ConstructL(aSectionName);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+void CImapServiceSectionParser::ConstructL(const TDesC& aSectionName)
+ {
+ CBaseSectionParser::ConstructL(aSectionName);
+
+ // Add the state to generate the imap service
+ CCreateImapService* testState = CCreateImapService::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(CImapServiceCommands::NewL(*testState));
+
+ CEmailServiceSectionParser::ConstructL(aSectionName, *testState);
+ }
+
+CImapServiceSectionParser::CImapServiceSectionParser(CTestScript& aScript, CEmailClientTest& aTestHarness) : CEmailServiceSectionParser(aScript, aTestHarness)
+ {
+ }
+
+CImapServiceSectionParser::~CImapServiceSectionParser()
+ {
+ }
+
+
+
+//
+//
+// CImapServiceCommands
+//
+// A command parser
+// Parses the commands that generate the IMAP service
+
+CImapServiceCommands* CImapServiceCommands::NewL(CCreateImapService& aTestState)
+ {
+ CImapServiceCommands* self = new (ELeave) CImapServiceCommands(aTestState);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+void CImapServiceCommands::ProcessL()
+ {
+ if ((*iCurrentCommand) == KCommandImapSetServer)
+ {
+ CheckNumberOfArgumentsL(1);
+ iTestState.Settings().SetServerAddressL((*iArgumentList)[0]);
+ }
+ else if ((*iCurrentCommand) == KCommandImapSetUserName)
+ {
+ CheckNumberOfArgumentsL(1);
+ TBuf8<128> loginName;
+ loginName.Copy((*iArgumentList)[0]);
+ iTestState.Settings().SetLoginNameL(loginName);
+ }
+ else if ((*iCurrentCommand) == KCommandImapSetPassword)
+ {
+ CheckNumberOfArgumentsL(1);
+ TBuf8<128> password;
+ password.Copy((*iArgumentList)[0]);
+ iTestState.Settings().SetPasswordL(password);
+ }
+ else if ((*iCurrentCommand) == KCommandImapSetName)
+ {
+ iTestState.SetDetailsStringL((*iArgumentList)[0]);
+ }
+ else if ((*iCurrentCommand) == KCommandImapSetFolderPath)
+ {
+ CheckNumberOfArgumentsL(1);
+ TBuf8<128> folderName;
+ folderName.Copy((*iArgumentList)[0]);
+ iTestState.Settings().SetFolderPathL(folderName);
+ }
+ else if ((*iCurrentCommand) == KCommandImapSetTLS)
+ {
+ CheckNumberOfArgumentsL(1);
+ TLex lex((*iArgumentList)[0]);
+ TInt setTls=0;
+ User::LeaveIfError(lex.Val(setTls));
+ iTestState.Settings().SetSecureSockets(setTls);
+ }
+ else if ((*iCurrentCommand) == KCommandImapSetUpdatingSeenFlags)
+ {
+
+ CheckNumberOfArgumentsL(1);
+ TLex lex((*iArgumentList)[0]);
+ TInt updateseenflag;
+ User::LeaveIfError(lex.Val(updateseenflag));
+ iTestState.Settings().SetUpdatingSeenFlags(updateseenflag);
+ }
+ else if ((*iCurrentCommand) == KCommandImapSetPort)
+ {
+
+ CheckNumberOfArgumentsL(1);
+ TLex lex((*iArgumentList)[0]);
+ TInt setPort=0;
+ User::LeaveIfError(lex.Val(setPort));
+ iTestState.Settings().SetPort(setPort);
+ }
+ else if ((*iCurrentCommand) == KCommandImapSetWrappedTLS)
+ {
+ CheckNumberOfArgumentsL(1);
+ TLex lex((*iArgumentList)[0]);
+ TInt setWrappedTls=0;
+ User::LeaveIfError(lex.Val(setWrappedTls));
+ iTestState.Settings().SetSSLWrapper(setWrappedTls);
+ }
+ }
+
+CImapServiceCommands::CImapServiceCommands(CCreateImapService& aTestState) : iTestState(aTestState)
+ {
+ }
+
+void CImapServiceCommands::ConstructL()
+ {
+ CBaseCommandParser::ConstructL();
+ AddCommandL(KCommandImapSetServer);
+ AddCommandL(KCommandImapSetUserName);
+ AddCommandL(KCommandImapSetPassword);
+ AddCommandL(KCommandImapSetName);
+ AddCommandL(KCommandImapSetFolderPath);
+ AddCommandL(KCommandImapSetTLS);
+ AddCommandL(KCommandImapSetUpdatingSeenFlags);
+ AddCommandL(KCommandImapSetPort);
+ AddCommandL(KCommandImapSetWrappedTLS);
+ }
+
+
+//
+//
+// CImapOperationParser
+//
+
+CImapOperationParser* CImapOperationParser::NewL(CImapClientTest& aImapClientTest)
+ {
+ CImapOperationParser* self = new (ELeave) CImapOperationParser(aImapClientTest);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+void CImapOperationParser::ProcessL()
+ {
+
+ if ((*iCurrentCommand) == KCommandImapConnect)
+ {
+ CheckNumberOfArgumentsL(0);
+ iImapClientTest.AddStateL(new (ELeave) CCheckService(iImapClientTest), iDebugInfo);
+ iImapClientTest.AddStateL(new (ELeave) CImapConnect(iImapClientTest, CImapConnect::ENoSync), iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapConnectAndCancel)
+ {
+ CheckNumberOfArgumentsL(1);
+ TUint cancelDelay;
+ TLex cancelDelayLex((*iArgumentList)[0]);
+ User::LeaveIfError(cancelDelayLex.Val(cancelDelay));
+
+ iImapClientTest.AddStateL(new (ELeave) CCheckService(iImapClientTest), iDebugInfo);
+ iImapClientTest.AddStateL(new (ELeave) CImapConnectAndCancel(iImapClientTest, cancelDelay), iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapConnectAndMonitor)
+ {
+ CheckNumberOfArgumentsL(0);
+ iImapClientTest.AddStateL(new (ELeave) CCheckService(iImapClientTest), iDebugInfo);
+ iImapClientTest.AddStateL(new (ELeave) CImapConnectAndMonitor(iImapClientTest, EFalse), iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapConnectMonitorAndSync)
+ {
+ CheckNumberOfArgumentsL(0);
+ iImapClientTest.AddStateL(new (ELeave) CCheckService(iImapClientTest), iDebugInfo);
+ iImapClientTest.AddStateL(new (ELeave) CImapConnectAndMonitor(iImapClientTest, ETrue), iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapConnectAndSync)
+ {
+ CheckNumberOfArgumentsL(0);
+ iImapClientTest.AddStateL(new (ELeave) CCheckService(iImapClientTest), iDebugInfo);
+ iImapClientTest.AddStateL(new (ELeave) CImapConnect(iImapClientTest, CImapConnect::EConnectAndSync), iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapConnectAndPeriodicSync)
+ {
+ CheckNumberOfArgumentsL(0);
+ iImapClientTest.AddStateL(new (ELeave) CCheckService(iImapClientTest), iDebugInfo);
+ iImapClientTest.AddStateL(new (ELeave) CImapConnect(iImapClientTest, CImapConnect::EConnectAndPeriodicSync), iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapDisconnect)
+ {
+ CheckNumberOfArgumentsL(0);
+ iImapClientTest.AddStateL(new (ELeave) CImapDisconnect(iImapClientTest), iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapUseService)
+ {
+ CheckNumberOfArgumentsL(0);
+ iImapClientTest.AddStateL(new (ELeave) CImapUseService(iImapClientTest), iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapCheckRemoteInbox)
+ {
+ CheckNumberOfArgumentsL(0);
+ iImapClientTest.AddStateL(new (ELeave) CImapInboxNewSync(iImapClientTest), iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapSyncTree)
+ {
+ CheckNumberOfArgumentsL(0);
+ iImapClientTest.AddStateL(new (ELeave) CImapSyncTree(iImapClientTest), iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapSyncFolder)
+ {
+ CheckNumberOfArgumentsL(0);
+ iImapClientTest.AddStateL(new (ELeave) CImapFolderSync(iImapClientTest), iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapSubscribeFolder)
+ {
+ CheckNumberOfArgumentsL(0);
+ iImapClientTest.AddStateL(new (ELeave) CImapSubscribeFolder(ETrue,iImapClientTest), iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapUnsubscribeFolder)
+ {
+ CheckNumberOfArgumentsL(0);
+ iImapClientTest.AddStateL(new (ELeave) CImapSubscribeFolder(EFalse,iImapClientTest), iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapPopulateFolder)
+ {
+ CheckNumberOfArgumentsL(0);
+ iImapClientTest.AddStateL(new (ELeave) CImapPopulateFolder(iImapClientTest), iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapPerformFullSync)
+ {
+ CheckNumberOfArgumentsL(0);
+ iImapClientTest.AddStateL(new (ELeave) CImapPerformFullSync(iImapClientTest), iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapSetSyncLimits)
+ {
+ CheckNumberOfArgumentsL(2);
+
+ TInt inboxSyncLimit,folderSyncLimit;
+ TLex inboxLex((*iArgumentList)[0]);
+ TLex folderLex((*iArgumentList)[1]);
+ User::LeaveIfError(inboxLex.Val(inboxSyncLimit));
+ User::LeaveIfError(folderLex.Val(folderSyncLimit));
+
+ iImapClientTest.AddStateL(new (ELeave) CImapSetSyncLimits(inboxSyncLimit,folderSyncLimit,iImapClientTest), iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapMarkSelection)
+ {
+
+ CheckNumberOfArgumentsL(1);
+
+ TBool Unreadflag;
+ TLex unreadflaglex((*iArgumentList)[0]);
+ User::LeaveIfError(unreadflaglex.Val(Unreadflag));
+
+ iImapClientTest.AddStateL(new (ELeave) CImapMarkSelection(Unreadflag,*(iImapClientTest.iCurrentSelection), iImapClientTest.MsvTestUtils())
+ , iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapCheckSelectionUnread)
+ {
+
+ CheckNumberOfArgumentsL(1);
+
+ TInt TestType;
+ TLex TestTypelex((*iArgumentList)[0]);
+ User::LeaveIfError(TestTypelex.Val(TestType));
+ iImapClientTest.AddStateL(new (ELeave) CImapCheckSelectionUnread(TestType, *(iImapClientTest.iCurrentSelection), iImapClientTest.MsvTestUtils())
+ , iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapCheckSelectionSeen)
+ {
+
+ CheckNumberOfArgumentsL(1);
+
+ TInt Seenflag;
+ TLex Seenflaglex((*iArgumentList)[0]);
+ User::LeaveIfError(Seenflaglex.Val(Seenflag));
+ iImapClientTest.AddStateL(new (ELeave) CImapCheckSelectionSeen(Seenflag, *(iImapClientTest.iCurrentSelection), iImapClientTest.MsvTestUtils())
+ , iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapMarkSelectedMail)
+ {
+ CheckNumberOfArgumentsL(0);
+ iImapClientTest.AddStateL(new (ELeave) CImapMarkSelectedMail(*(iImapClientTest.iCurrentSelection), iImapClientTest.MsvTestUtils())
+ , iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapCheckSelectedMail)
+ {
+ CheckNumberOfArgumentsL(0);
+ iImapClientTest.AddStateL(new (ELeave) CImapCheckSelectedMail(*(iImapClientTest.iCurrentSelection), iImapClientTest.MsvTestUtils())
+ , iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapSetSyncRate)
+ {
+ CheckNumberOfArgumentsL(1);
+ TUint syncRate;
+ TLex syncRateLex((*iArgumentList)[0]);
+ User::LeaveIfError(syncRateLex.Val(syncRate));
+
+ iImapClientTest.AddStateL(new (ELeave) CImapSetSyncRate(syncRate,iImapClientTest), iDebugInfo);
+ }
+ else if ((*iCurrentCommand) == KCommandImapGetSyncRate)
+ {
+ CheckNumberOfArgumentsL(1);
+ TUint syncRate;
+ TLex syncRateLex((*iArgumentList)[0]);
+ User::LeaveIfError(syncRateLex.Val(syncRate));
+
+ iImapClientTest.AddStateL(new (ELeave) CImapGetSyncRate(syncRate,iImapClientTest), iDebugInfo);
+ }
+ else
+ {
+ User::Leave(KErrNotFound);
+ }
+ }
+
+void CImapOperationParser::ConstructL()
+ {
+ CBaseCommandParser::ConstructL();
+ AddCommandL(KCommandImapConnect);
+ AddCommandL(KCommandImapConnectAndCancel);
+ AddCommandL(KCommandImapConnectAndMonitor);
+ AddCommandL(KCommandImapConnectMonitorAndSync);
+ AddCommandL(KCommandImapConnectAndSync);
+ AddCommandL(KCommandImapConnectAndPeriodicSync);
+ AddCommandL(KCommandImapDisconnect);
+ AddCommandL(KCommandImapUseService);
+ AddCommandL(KCommandImapCheckRemoteInbox);
+ AddCommandL(KCommandImapSyncTree);
+ AddCommandL(KCommandImapSyncFolder);
+ AddCommandL(KCommandImapSubscribeFolder);
+ AddCommandL(KCommandImapUnsubscribeFolder);
+ AddCommandL(KCommandImapPopulateFolder);
+ AddCommandL(KCommandImapPerformFullSync);
+ AddCommandL(KCommandImapSetSyncLimits);
+ AddCommandL(KCommandImapMarkSelection);
+ AddCommandL(KCommandImapCheckSelectionUnread);
+ AddCommandL(KCommandImapCheckSelectionSeen);
+ AddCommandL(KCommandImapMarkSelectedMail);
+ AddCommandL(KCommandImapCheckSelectedMail);
+ AddCommandL(KCommandImapSetSyncRate);
+ AddCommandL(KCommandImapGetSyncRate);
+ }
+
+CImapOperationParser::CImapOperationParser(CImapClientTest& aImapClientTest) : iImapClientTest(aImapClientTest)
+ {
+ }
+
+
+
+
+//
+//
+// CImapCheckStatusParser
+//
+
+
+CImapCheckStatusParser* CImapCheckStatusParser::NewL(CImapClientTest& aImapTestHarness)
+ {
+ CImapCheckStatusParser* self = new (ELeave) CImapCheckStatusParser(aImapTestHarness);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+void CImapCheckStatusParser::ProcessL()
+ {
+ TLex lex((*iArgumentList)[0]);
+ TInt expectedStatus;
+ User::LeaveIfError(lex.Val(expectedStatus));
+ iTestHarness.AddStateL(new (ELeave) CCheckImapOperation(expectedStatus, iTestHarness), iDebugInfo);
+ }
+
+CImapCheckStatusParser::CImapCheckStatusParser(CImapClientTest& aImapTestHarness) : iTestHarness(aImapTestHarness)
+ {
+ }
+
+void CImapCheckStatusParser::ConstructL()
+ {
+ CBaseCommandParser::ConstructL();
+ AddCommandL(KCommandImapCheckStatus);
+ }
+