/*

* Copyright (c) 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: CATSInterface: This object executes test cases from 

* STIF Test Framework.

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <e32cons.h>

#include <e32svr.h>

#include "ATSInterface.h"

#include "ATSInterfaceRunner.h"

#include "StifTestInterface.h"

// EXTERNAL DATA STRUCTURES

// None

// EXTERNAL FUNCTION PROTOTYPES  

// None

// CONSTANTS

// None

// MACROS

// None

// LOCAL CONSTANTS AND MACROS

// None

// MODULE DATA STRUCTURES

// None

// LOCAL FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

// None

// ==================== LOCAL FUNCTIONS ======================================= 

// None

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

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

/*

-------------------------------------------------------------------------------

    Class: CATSInterface

    Method: CATSInterface

    Description: Default constructor

    C++ default constructor can NOT contain any code, that

    might leave.

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Approved

-------------------------------------------------------------------------------

*/

CATSInterface::CATSInterface()

    {

    // Initialize buffers to zero

    iEngineIniFile.Zero();

    iModuleIniFile.Zero();

    iConfigFile.Zero();

    iTestModule.Zero();

    }

/*

-------------------------------------------------------------------------------

    Class: CATSInterface

    Method: ConstructL

    Description: Symbian OS second phase constructor

    Symbian OS default constructor can leave.

    Parameters: None

    Return Values: None

    Errors/Exceptions: Leaves if some of called leaving functions leaves

                       Leaves each time the LogErrorAndLeaveL is called

    Status: Proposal

-------------------------------------------------------------------------------

*/

void CATSInterface::ConstructL()

    {

    RDebug::Print(_L("Creating module list object"));

    TRAPD(err, iModuleList = CTestModuleList::NewL(NULL));

    if(err != KErrNone)

        {

        LogErrorAndLeaveL(_L("CATSInterface::ConstructL"), _L("CTestModuleList::NewL"), err);

        return;

        }

    if(!iModuleList)

        {

        LogErrorAndLeaveL(_L("CATSInterface::ConstructL"), _L("CTestModuleList::NewL - iModuleList is NULL"), KErrGeneral);

        return;

        }

    // Read command line

    ParseCommandLineL();

    // Add to module list info about module taken from command line

    RDebug::Print(_L("Adding command line module to list"));

    TName moduleName;

    moduleName.Copy(iTestModule);

    moduleName.LowerCase();

    err = iModuleList->AddTestModule(moduleName);

    if(err != KErrNone && err != KErrAlreadyExists)

        {

        LogErrorAndLeaveL(_L("CATSInterface::ConstructL"), _L("CTestModuleList::AddTestModule - Could not add module to list of modules"), err);

        return;

        }

    //Get added module

    CTestModuleInfo* moduleInfo = iModuleList->GetModule(moduleName);

    if(!moduleInfo)

        {

        LogErrorAndLeaveL(_L("CATSInterface::ConstructL"), _L("CTestModuleList::GetModule - Could not add get module info from list"), KErrGeneral);

        return;

        }

    //Add ini file if given

    if(iModuleIniFile.Length() > 0)

        {

        TFileName filename;

        filename.Copy(iModuleIniFile);

        filename.LowerCase();

        moduleInfo->SetIniFile(filename);

        }

    //Add config file if given

    if(iConfigFile.Length() > 0)

        {

        TFileName filename;

        filename.Copy(iConfigFile);

        filename.LowerCase();

        moduleInfo->AddCfgFile(filename);

        }

    //Now check all config files if there are included modules

    _LIT(KIncludeModuleStart, "[New_Include_Module]");

    _LIT(KIncludeModuleEnd, "[End_Include_Module]");

    RDebug::Print(_L("Start parsing included modules"));

    CTestCaseFileInfo* finfo = iModuleList->GetUncheckedCfgFile();

    while(finfo)

        {

        TFileName fname;

        finfo->GetCfgFileName(fname);

        RDebug::Print(_L("Checking file: '%S'"), &fname);

        finfo->SetChecked();

        CStifParser* parser = NULL;

        TRAP(err, parser = CStifParser::NewL(_L(""), fname));

        if(err != KErrNone)

            {

            LogErrorAndLeaveL(_L("CATSInterface::ConstructL"), _L("CStifParser::NewL - Could not create parser"), err);

            return;

            }

        CleanupStack::PushL(parser);

        ParseTestModulesL(parser, iModuleList, KIncludeModuleStart, KIncludeModuleEnd);

        CleanupStack::PopAndDestroy(parser);

        finfo = iModuleList->GetUncheckedCfgFile();

        }

    RDebug::Print(_L("End parsing included modules"));

    // Create Test Engine

    RDebug::Print(_L("Creating test engine"));

    TInt ret = iTestEngineServ.Connect();

    if ( ret != KErrNone )

        {

        // Log error

        LogErrorAndLeaveL( _L("CATSInterface::ConstructL"), _L("iTestEngineServ.Connect"), ret );

        return;

        }

    ret = iTestEngine.Open( iTestEngineServ, iEngineIniFile );

    if ( ret != KErrNone )

        {

        // Log error

        LogErrorAndLeaveL( _L("CATSInterface::ConstructL"), _L("iTestEngine.Open"), ret );

        return;

        }

/*

    // Add test module

    ret = iTestEngine.AddTestModule( iTestModule, iModuleIniFile );

    if ( ret != KErrNone && ret != KErrAlreadyExists )

        {

        // Log error

        LogErrorAndLeaveL( _L("CATSInterface::ConstructL"), _L("iTestEngine.AddTestModule"), ret );

        return;

        }

*/

    // Add all test modules and config files

    RDebug::Print(_L("Start creating test modules"));

    moduleInfo = NULL;

    TInt i;

    TInt modCnt = iModuleList->Count();

    for(i = 0; i < modCnt; i++)

        {

        RDebug::Print(_L("Processing module"));

        // Get module

        moduleInfo = iModuleList->GetModule(i);

        if(!moduleInfo)

            {

            RDebug::Print(_L("Could not get module info at index %d"), i);

            continue;

            }

        // Get module name

        TName moduleName;

        moduleInfo->GetModuleName(moduleName);

        RDebug::Print(_L("module name: '%S'"), &moduleName);

        // Get ini file, if exists

        TFileName ini;

        moduleInfo->GetIniFileName(ini);

        if(ini.Length() == 0)

            {

            RDebug::Print(_L("ini file not found"));

            }

        else

            {

            RDebug::Print(_L("ini file: '%S'"), &ini);

            }

        // Create test module

        RDebug::Print(_L("Adding module to test engine"));

        ret = iTestEngine.AddTestModule(moduleName, ini);

        if(ret != KErrNone && ret != KErrAlreadyExists)

            {

            LogErrorAndLeaveL(_L("CATSInterface::ConstructL"), _L("iTestEngine.AddTestModule"), ret);

            return;

            }

        //Add test case files

        TInt cfgCnt = moduleInfo->CountCfgFiles();

        TInt j;

        TFileName cfgFile;

        for(j = 0; j < cfgCnt; j++)

            {

            moduleInfo->GetCfgFileName(j, cfgFile);

            if(cfgFile.Length() > 0)

                {

                RDebug::Print(_L("config file: '%S'"), &cfgFile);

                ret = iTestEngine.AddConfigFile(moduleName, cfgFile);

                if(ret != KErrNone && ret != KErrAlreadyExists)

                    {

                    // Log error

                    LogErrorAndLeaveL(_L("CATSInterface::ConstructL"), _L("RTestEngine::AddConfigFile"), ret);

                    return;

                    }

                }

            else

                {

                RDebug::Print(_L("Got empty cfg file"));

                }

            }

        if(cfgCnt == 0)

            {

            RDebug::Print(_L("cfg file not found"));

            }

        RDebug::Print(_L("Module '%S' processed correctly"), &moduleName);

        }

    RDebug::Print(_L("End creating test modules"));

    // Create console screen

    iConsole = Console::NewL(

        iTestModule, TSize( KConsFullScreen, KConsFullScreen ) );

    }

/*

-------------------------------------------------------------------------------

    Class: CATSInterface

    Method: NewL

    Description: Two-phased constructor.

    Parameters: None

    Return Values: CATSInterface* : pointer to created CATSInterface object

    Errors/Exceptions: Leaves if memory allocation for CATSInterface fails

                       Leaves if ConstructL leaves

    Status: Approved

-------------------------------------------------------------------------------

*/

CATSInterface* CATSInterface::NewL()

    {

    // Create CATSInterface and return it

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

/*

-------------------------------------------------------------------------------

    Class: CATSInterface

    Method: ~CATSInterface

    Description: Destructor

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Approved

-------------------------------------------------------------------------------

*/

CATSInterface::~CATSInterface()

    {

    // Close Test Engine

    iTestEngine.Close();

    iTestEngineServ.Close();

    delete iModuleList;

    delete iConsole;

    }

/*

-------------------------------------------------------------------------------

    Class: CATSInterface

    Method: ParseTestModulesL

    Description: Parse and search for module info and fill list of modules.

    Parameters: CStifParser*     aParser:       in: CStifParser object

                CTestModuleList* aModuleList:   in: list of modules

                TPtrC&           aSectionStart: in: descriptor with start of section string

                TPTrC&           aSectionEnd:   in: descriptor with end of section string

    Return Values: None

    Errors/Exceptions: Leaves if some of called leaving methods leaves

    Status: Approved

-------------------------------------------------------------------------------

*/

void CATSInterface::ParseTestModulesL(CStifParser* aParser, CTestModuleList* aModuleList, const TDesC& aSectionStart, const TDesC& aSectionEnd)

    {

    //First let's find all modules given in Stif's ini file and store that info in CTestModuleList object

    CStifSectionParser* sectionParser = NULL;

    CStifItemParser* item = NULL;

    sectionParser = aParser->SectionL(aSectionStart, aSectionEnd);

    while(sectionParser)

        {

        RDebug::Print(_L("Found '%S' and '%S' sections"), &aSectionStart, &aSectionEnd);

        CleanupStack::PushL(sectionParser);

        RDebug::Print(_L("Starting to read module information"));

        // Get name of module

        _LIT(KModuleName, "ModuleName=");

        item = sectionParser->GetItemLineL(KModuleName);

        CleanupStack::PushL(item);

        if(!item)

            {

            CleanupStack::PopAndDestroy(item);

            LogErrorAndLeaveL(_L("CATSInterface::ParseTestModulesL"), _L("CStifItemParser::GetItemLineL - line not found from module section"), KErrNotFound);

            return;

            }

        else

            {

            RDebug::Print(_L("'%S' found"), &KModuleName);

            }

        TPtrC name;

        TName moduleName;

        TInt ret(KErrNone);

        ret = item->GetString(KModuleName, name);

        if(ret != KErrNone)

            {

            CleanupStack::PopAndDestroy(item);

            LogErrorAndLeaveL(_L("CATSInterface::ParseTestModulesL"), _L("CStifItemParser::GetString - Module name parsing left with error"), ret);

            return;

            }

        else

            {

            RDebug::Print(_L("Module '%S' found from ini-file"), &name);

            moduleName.Copy(name);

            moduleName.LowerCase();

            ret = aModuleList->AddTestModule(moduleName);

            if(ret != KErrNone && ret != KErrAlreadyExists)

                {

                LogErrorAndLeaveL(_L("CATSInterface::ParseTestModulesL"), _L("CTestModuleList::AddTestModule - Could not add module to list of modules"), ret);

                return;

                }

            }

        CleanupStack::PopAndDestroy(item);

        //Get pointer to added module

        CTestModuleInfo* moduleInfo = aModuleList->GetModule(moduleName);

        if(!moduleInfo)

            {

                LogErrorAndLeaveL(_L("CATSInterface::ParseTestModulesL"), _L("CTestModuleList::GetModule - Could not add get module info from list"), KErrNotFound);

                return;

            }

        // Get ini file, if it exists

        RDebug::Print(_L("Start parsing ini file"));

        _LIT(KIniFile, "IniFile=");

        item = sectionParser->GetItemLineL(KIniFile);

        if(item)

            {

            RDebug::Print(_L("'%S' found"), &KIniFile);

            CleanupStack::PushL(item);

            TPtrC iniFile;

            ret = item->GetString(KIniFile, iniFile);

            if(ret == KErrNone)

                {

                RDebug::Print(_L("Initialization file '%S' found, file can be empty"), &iniFile);

                TFileName filename;

                filename.Copy(iniFile);

                filename.LowerCase();

                TStifUtil::CorrectFilePathL( filename );

                moduleInfo->SetIniFile(filename);

                }

            else

                {

                RDebug::Print(_L("Initialization file not found"));

                }

            CleanupStack::PopAndDestroy(item);

            }

        else

            {

            RDebug::Print(_L("'%S' not found"), &KIniFile);

            }

        // Get config (testcase) file

        RDebug::Print(_L("Start parsing cfg files"));

        TPtrC cfgTag;

        for(TInt i = 0; i < 2; i++)

            {

            //Set tag for config files

            if(i == 0)

                {

                cfgTag.Set(_L("ConfigFile="));

                }

                else

                {

                cfgTag.Set(_L("TestCaseFile="));

                }

            //Read data

            item = sectionParser->GetItemLineL(cfgTag);

            while(item)

                {

                CleanupStack::PushL(item);

                RDebug::Print(_L("Item '%S' found"), &cfgTag);

                TPtrC cfgFile;

                ret = item->GetString(cfgTag, cfgFile);

                if(ret == KErrNone)

                    {

                    TFileName ifile;

                    ifile.Copy(cfgFile);

                    ifile.LowerCase();

                    TStifUtil::CorrectFilePathL( ifile );

                    RDebug::Print(_L("Configuration file '%S' found"), &ifile);

                    moduleInfo->AddCfgFile(ifile);

                    }

                else

                    {

                    RDebug::Print(_L("Configuration file not found"));

                    }

                CleanupStack::PopAndDestroy(item);

                item = sectionParser->GetNextItemLineL(cfgTag);

                }

            }

        RDebug::Print(_L("Module '%S' information read correctly"), &moduleName);