/* ============================================================================

 *  Name        :  popimapprofiletesterBlocks.cpp

 *  Part of     :  ipsservices / profiletester 

 *  Description :: STIF test cases

 *  Version     : %version: 1 % << Don't touch! Updated by Synergy at check-out.

 *

 *  Copyright © 2010-2010 Nokia and/or its subsidiary(-ies).  All rights reserved.

 *  This material, including documentation and any related computer

 *  programs, is protected by copyright controlled by Nokia.  All

 *  rights are reserved.  Copying, including reproducing, storing,

 *  adapting or translating, any or all of this material requires the

 *  prior written consent of Nokia.  This material also contains

 *  confidential information which may not be disclosed to others

 *  without the prior written consent of Nokia.

 * ============================================================================

 */

//--INCLUDE FILES-- 

#include <e32svr.h>

#include <StifParser.h>

#include <StifTestInterface.h>

#include <e32math.h>

#include <msvids.h>

#include "popimapprofiletester.h"

_LIT( KPopImapProfileTester, "c:\\TestFramework\\TestFramework_ips.ini" );

_LIT( KStifEmailSubject, "STIF Basic Operations test" );

_LIT( KStifEmailSubjectDes,"STIF_");

_LIT( KStifEmailBodyText, "This is a temporary STIF test message");

_LIT( KStifEmailSubjectAttHandling, "STIF Attachment Handling Test" );

_LIT( KStifEmailToRec1, "dummyTo1@empty.com" );

_LIT( KStifEmailCcRec1, "dummyCc1@empty.com" );

_LIT( KStifEmailCcRec2, "dummyCc2@empty.com" );

_LIT( KStifEmailBccRec1, "dummyBcc1@empty.com" );

// ============================ MEMBER FUNCTIONS ===============================

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

// CPopImapProfileTester::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

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

//

void CPopImapProfileTester::Delete()

    {

    }

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

// CPopImapProfileTester::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

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

//

TInt CPopImapProfileTester::RunMethodL(CStifItemParser& aItem)

    {

    static TStifFunctionInfo const

            KFunctions[] =

                {

                        // Copy this line for every implemented function.

                        // First string is the function name used in TestScripter script file.

                        // Second is the actual implementation member function. 

                        ENTRY( "SetupAccount", CPopImapProfileTester::SetupAccountL ),

                        ENTRY( "GoOnline", CPopImapProfileTester::GoOnlineL ),

                        ENTRY( "GoOffline", CPopImapProfileTester::GoOfflineL ),

                        ENTRY( "RefreshNow", CPopImapProfileTester::RefreshNowL ),

                        ENTRY( "CancelSync", CPopImapProfileTester::CancelSyncL ),

                        ENTRY( "ListStandardFolders", CPopImapProfileTester::ListStandardFoldersL ),

                        ENTRY( "ListFolders", CPopImapProfileTester::ListFoldersL ),

                        ENTRY( "ListMessages", CPopImapProfileTester::ListMessagesL ),

                        ENTRY( "FetchMessages", CPopImapProfileTester::FetchMessagesL ),

                        ENTRY( "SendMessage", CPopImapProfileTester::SendMessageL ),

                        ENTRY( "BasicMsgOperations", CPopImapProfileTester::BasicMsgOperationsL ),

                        ENTRY( "CopyMoveMsgs", CPopImapProfileTester::CopyMoveMsgsL ),

                        ENTRY( "Search", CPopImapProfileTester::SearchL ),

                        ENTRY( "AttachmentHandling", CPopImapProfileTester::AttachmentHandlingL ),

                        ENTRY( "Branding", CPopImapProfileTester::BrandingL ),

                        ENTRY( "DeleteMsgs", CPopImapProfileTester::DeleteMsgsL ),

                        ENTRY( "RemoveAccount", CPopImapProfileTester::RemoveAccountL ),

                };

    const TInt count = sizeof(KFunctions) / sizeof(TStifFunctionInfo);

    InitMailboxL();

    return RunInternalL(KFunctions, count, aItem);

    }

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

// CPopImapProfileTester:: SetupAccountL

// Method used to create an imap or pop account, depends on .cfg file

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

//

TInt CPopImapProfileTester::SetupAccountL(CStifItemParser& /* aItem */)

    {

    //I.Check if mail client exists

    if (NULL == iMailClient)

        {

        iLog->Log(_L( "Error: Failed to create test instance(No Memory)." ));

        return KErrNoMemory;

        }

    TInt err(KErrNone);

    // II. Check if imap/pop profile already exists

    if (NULL != iIPSMailbox)

        {

        iLog->Log(_L("Error: There is IMAP/POP profile alredy existed"));

        return KErrAlreadyExists;

        }

    iLog->Log(_L( "== SetupAccount Begins ==" ));

    TAccountSetting settings;

    // III. Read settings and write to CR

    ReadAccountSettings(settings);

    err = WriteToWizardCRL(settings);

    iLog->Log(_L( "== WriteToWizardCR Ends err=%d" ), err);

    iLog->Log(_L( "== End a transaction in SetupAccount ==" ));

    // IV. Create mailbox through WizardDataAvailableL()

    err = iMailClient->WizardDataAvailableL();

    if (KErrNone == err)

        WaitForEvent(TFSEventNewMailbox, NULL, NULL, KTenSecondsTime);

    err = InitMailboxL();

    if ((KErrNone == err) && NULL != iIPSMailbox)

        err = KErrNone;

    else

        err = KErrGeneral;

    iLog->Log(_L( "== SetupAccount Ends err=%d" ), err);

    return err;

    }

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

// CPopImapProfileTester:: GoOnlineL

// Method used to let phone online

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

//

TInt CPopImapProfileTester::GoOnlineL(CStifItemParser& /* aItem */)

    {

    TInt err(KErrNone);

    if (NULL == iIPSMailbox)

        {

        iLog->Log(_L("Error: IMAP/POP profile does NOT exist"));

        return KErrGeneral;

        }

    iLog->Log(_L( "== GoOnline Begins ==" ));

    // check current mailbox status

    TBuf<10> statusDes;

    TFSMailBoxStatus status = iIPSMailbox->GetMailBoxStatus();

    if (status == EFSMailBoxOffline)

        {

        statusDes.Copy(_L("offline"));

        }

    else if (status == EFSMailBoxOnline)

        {

        statusDes.Copy(_L("online"));

        iLog->Log(_L("Mailbox has been Online, go offline firstly"));

        iLog->Log(_L( "== GoOnline ends err=%d" ), err);

        return KErrGeneral;

        }

    else

        {

        statusDes.Copy(_L("unknown"));

        }

    iLog->Log(_L("Going online (from %S)..."), &statusDes);

    TSSMailSyncState syncstatus = iIPSMailbox->CurrentSyncState();

    // call function to go online

    iEventSynchronousCall = ETrue;

    iIPSMailbox->GoOnlineL();

    syncstatus = iIPSMailbox->CurrentSyncState();

    // we should likely base on TFSEventMailboxOnline, but this does not come always (?)

    err = WaitForEvent(TFSEventMailboxOnline, NULL, NULL, KOneMinuteTime);

    syncstatus = iIPSMailbox->CurrentSyncState();

    //check status of current mailbox again

    status = iIPSMailbox->GetMailBoxStatus();

    if (status == EFSMailBoxOnline)

        {

        err = KErrNone;

        iLog->Log(_L("Success: mailbox online"));

        }

    else

        {

        err = KErrGeneral;

        iLog->Log(_L("Failed: mailbox status- %S"), &statusDes);

        }

    iLog->Log(_L( "== GoOnline ends err=%d" ), err);

    return err;

    }

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

// CPopImapProfileTester:: GoOfflineL

// Method used to let phone offline

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

//

TInt CPopImapProfileTester::GoOfflineL(CStifItemParser& /* aItem */)

    {

    TInt err(KErrNone);

    if (NULL == iIPSMailbox)

        {

        iLog->Log(_L("Error: IMAP/POP profile does NOT exist"));

        return KErrGeneral;

        }

    iLog->Log(_L( "== GoOffline Begins ==" ));

    TBuf<10> statusDes;

    TFSMailBoxStatus status = iIPSMailbox->GetMailBoxStatus();

    if (status == EFSMailBoxOffline)

        {

        statusDes.Copy(_L("offline"));

        iLog->Log(_L("Mailbox has been Offline, go online firstly"));

        iLog->Log(_L( "== GoOffline ends err=%d" ), err);

        return KErrGeneral;

        }

    else if (status == EFSMailBoxOnline)

        {

        statusDes.Copy(_L("online"));

        }

    else

        {

        statusDes.Copy(_L("unknown"));

        }

    iLog->Log(_L("Going offline (from %S)..."), &statusDes);

    // call function to go offline

    iEventSynchronousCall = ETrue;

    TSSMailSyncState syncstatus = iIPSMailbox->CurrentSyncState();

    iIPSMailbox->GoOfflineL();

    syncstatus = iIPSMailbox->CurrentSyncState();

    err = WaitForEvent(TFSEventMailboxOffline, NULL, NULL, KOneMinuteTime);

    syncstatus = iIPSMailbox->CurrentSyncState();

    //check status of current mailbox again

    status = iIPSMailbox->GetMailBoxStatus();

    if (status == EFSMailBoxOffline)

        {

        iLog->Log(_L("Success: mailbox offline"));

        }

    else

        {

        err = KErrGeneral;

        iLog->Log(_L("Failed: mailbox status- %S"), &statusDes);

        }

    iLog->Log(_L( "GoOffline ends err=%d" ), err);

    return err;

    }

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

// CPopImapProfileTester:: RefreshNowL

// Method used to let phone refresh

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

//

TInt CPopImapProfileTester::RefreshNowL(CStifItemParser& /* aItem */)

    {

    TInt err(KErrNone);

    if (NULL == iIPSMailbox)

        {

        iLog->Log(_L("Error: IMAP/POP profile does NOT exist"));

        return KErrGeneral;

        }

    iLog->Log(_L( "RefreshNow begins" ));

    TInt reqId = iIPSMailbox->RefreshNowL(*this);

    iLog->Log(_L("Request Id -> %d"), reqId);

    TSSMailSyncState syncstatus = iIPSMailbox->CurrentSyncState();

    if ((StartingSync == syncstatus) || (EmailSyncing == syncstatus))

        err = WaitForEvent(TFSEventMailboxOnline);

    else

        err = KErrGeneral;

    if (err == KErrNone)

        {

        WaitForResponse(TFSProgress::EFSStatus_RequestComplete, KOneMinuteTime*3);

        syncstatus = iIPSMailbox->CurrentSyncState();

        }

    iLog->Log(_L( "RefreshNow ends err=%d" ), err);

    return err;

    }

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

// CPopImapProfileTester:: CancelSyncL

// Method used to cancle action of Sync.

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

//

TInt CPopImapProfileTester::CancelSyncL(CStifItemParser& /* aItem */)

    {

    TInt err(KErrNone);

    if (NULL == iIPSMailbox)

        {

        iLog->Log(_L("Error: IMAP/POP profile does NOT exist"));

        return KErrGeneral;

        }

    iLog->Log(_L( "CancelSync begins" ));

    iIPSMailbox->RefreshNowL(*this);

    err = WaitForEvent(TFSEventMailboxOnline);

    if (KErrNone == err)

        {

        iIPSMailbox->CancelSyncL();

        err = WaitForEvent(TFSEventMailboxOffline);

        TSSMailSyncState syncstatus = iIPSMailbox->CurrentSyncState();

        if ((err != KErrNone) || (Idle != syncstatus))

        	{

            err = KErrGeneral;

        	}

        }

    iLog->Log(_L( "CancelSync ends err=%d" ), err);

    return err;

    }

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

// CPopImapProfileTester::ListStandardFoldersL

// Method used to list standard folders

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

//

TInt CPopImapProfileTester::ListStandardFoldersL(CStifItemParser& /* aItem */)

    {

    if (NULL == iIPSMailbox)

        {

        iLog->Log(_L("Error: IMAP/POP profile does NOT exist"));

        return KErrGeneral;

        }

    TInt err(KErrNone);

    iLog->Log(_L( "ListStandardFolders begins" ));

    // list all root folders

    RPointerArray<CFSMailFolder> rootFolders;

    iIPSMailbox->ListFolders(TFSMailMsgId(), rootFolders);

    // how many root folders we have

    TInt rootFolderCount = rootFolders.Count();

    /* Standard folders are:

     * EFSInbox, EFSOutbox, EFSDraftsFolder, EFSSentFolder, EFSDeleted

     * IMAP/POP may not have 'EFSDeleted'? Four only?

     */

    // check if all standard folders are present among root folders

    TFSMailMsgId folderId = TFSMailMsgId();

    iLog->Log(_L("== List of Standard Folders == "));

    for (TInt i = 1; i < EFSDeleted; ++i)

        {

        folderId = iIPSMailbox->GetStandardFolderId((TFSFolderType) i);

        TBool folderPresent = EFalse;

        for (TInt ii = 0; ii < rootFolderCount; ++ii)

            {

            if (rootFolders[ii]->GetFolderId() == folderId)

                {

                iLog->Log(_L("   %S"), &rootFolders[ii]->GetFolderName());

                folderPresent = ETrue;

                break;

                }

            }

        if (NULL == folderPresent)

            {

            iLog->Log(_L("  Error: folder of id %d is missing"), i);

            err = KErrNotFound;

            }

        }

    rootFolders.ResetAndDestroy();

    iLog->Log(_L( "ListStandardFolders ends err=%d" ), err);

    return err;

    }

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

// CPopImapProfileTester::ListFoldersL

// Method used to list all folders

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

//

TInt CPopImapProfileTester::ListFoldersL(CStifItemParser& aItem)

    {

    if (NULL == iIPSMailbox)

        {

        iLog->Log(_L("Error: IMAP/POP profile does NOT exist"));

        return KErrGeneral;

        }

    /**

     * 1. Check subfolders of given folder - use ListFolders(FSMailMsgId, RPointerArray<CFSMailFolder>&)

     * 2. List all folders and compare check cout of listed folders - use ListFolders()

     * 

     */

    TInt paramErr(KErrNone);

    TInt err(KErrNone);

    iLog->Log(_L( "ListFoldersL begins" ));

    iLog->Log(_L( "Mailbox's Id: %x"), iIPSMailbox->GetId().Id());

    RPointerArray<CFSMailFolder>& folders = iIPSMailbox->ListFolders();

    //.. 

    // 1. subfolders check

    TPtrC parentFolderS, subfolderSetS, subfolderS;

    //get parent folder name  

    paramErr = aItem.GetString(_L("_parentFolder:"), parentFolderS);

    TFSMailMsgId parentFolderId = GetFolderIdFromName(parentFolderS);

    if (!parentFolderId.IsNullId())

        {

        iLog->Log(_L("Testing folder hierachy"));

        iLog->Log(_L("Parent folder found; id: %x"), parentFolderId.Id());

        RPointerArray<CFSMailFolder> subfolders;

        iIPSMailbox->ListFolders(parentFolderId, subfolders);

        TInt subfolderErr(KErrNone);

        //there should be at least one subfolder defined  

        paramErr &= aItem.GetString(_L("_subfolders:"), subfolderSetS);

        TInt idx(0);

        do

            {

            idx = subfolderSetS.Locate(',');

            if (idx > 0)

                {

                // extract next subfolder

                subfolderS.Set(subfolderSetS.Left(idx));

                // skip current subfolder

                subfolderSetS.Set(subfolderSetS.Mid(idx + 1));

                }

            else

                {

                subfolderS.Set(subfolderSetS);

                }

            // check subfolder 

            subfolderErr = KErrNotFound;

            for (TInt i = 0; (i < folders.Count() && !paramErr); i++)

                {

                if (folders[i]->GetFolderName().Compare(subfolderS) == 0)

                    {

                    subfolderErr = KErrNone;

                    iLog->Log(

                            _L("Subfolder %S of parent folder %S found; id: %x"),

                            &(folders[i]->GetFolderName()), &parentFolderS,

                            folders[i]->GetFolderId().Id());

                    break;

                    }

                }

            }

        while (!subfolderErr && idx >= 0);

        //set global err value - zeroes err if OK 

        err &= subfolderErr;

        subfolders.ResetAndDestroy();

        }//end if '!parentFolderId.IsNullId()'

    //parse params - we have to know what actualy we are testing

    TInt foldersCount(0);

    paramErr &= aItem.GetInt(_L("_expectedFoldersCount:"), foldersCount);

    //.. 

    // 2. total number of folders

    if (foldersCount > 0)

        {

        (folders.Count() == foldersCount) ? err = KErrNone : err = KErrGeneral;

        iLog->Log(_L("Actual folders count: %d vs. %d expected"),

                folders.Count(), foldersCount);

        }

    //..

    if (paramErr != 0)

        {

        iLog->Log(_L("  Error: Invalid test case parameters!"));

        }

    iLog->Log(_L( "ListFolders ends err=%d" ), err);

    return err;

    }

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

// CPopImapProfileTester::ListMessagesL

// Method used to list messages in a specific folder

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

//

TInt CPopImapProfileTester::ListMessagesL(CStifItemParser& aItem)

    {

    if (NULL == iIPSMailbox)

        {

        iLog->Log(_L("Error: IMAP/POP profile does NOT exist"));

        return KErrGeneral;

        }

    TInt err(KErrNone);

    iLog->Log(_L( "ListMessagesL begins" ));

    // I. get test case params

    TPtrC folderName;

    TInt msgCount(0);

    // since folder name might consists of more than one word

    // lets use quote parsing for param

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    if (aItem.GetString(_L("_folder:"), folderName))

        {

        iLog->Log(_L("Error: test case argument is missing"));

        err = KErrArgument;

        }

    else

        {

        // II. Get folder of given name and list its emails

        CFSMailFolder* folder = FindFolder(folderName);

        if (NULL != folder)

            {

            RPointerArray<CFSMailMessage> messages;

            TInt gotMsgs = GetMessagesFromFolderL(messages, folder,

                    EFSMsgDataSubject, EFSMailSortByDate, msgCount);

            if (gotMsgs > 0)

                {

                iLog->Log(_L("  Listing first %d emails:"), gotMsgs);

                }

            for (TInt i = 0; i < messages.Count(); ++i)

                {

                iLog->Log(_L("    %d. %S"), i + 1, &messages[i]->GetSubject());

                }

            if (gotMsgs != messages.Count())

                { // warning, NextL() returned fewer entries than expected

                TInt diff = gotMsgs > messages.Count() ? gotMsgs

                        - messages.Count() : messages.Count() - gotMsgs;

                iLog->Log(_L("Warning: %d entries are still not be listed."),

                        diff);

                err = KErrNotFound;

                }

            messages.ResetAndDestroy();

            }//end if 'folder'

        else

            {

            iLog->Log(_L("Error: %S folder not found"), &folderName);

            err = KErrNotFound;

            }

        }//end if 'folderName'

    iLog->Log(_L( "ListMessages ends err=%d" ), err);

    return err;