/*

* 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: QT C++ based Class.

*              Unit Test to StfQtUI's controller and model.

*

*/

#include "testcontroller.h"

#include "stfqtuimodel.h"

#include "stfqtuicontroller.h"

#include "cstfcase.h"

#include "cstfmodule.h"

#include <QProcess>

const QString KConfigFile1 = "c:\\STFQTUI_Test\\testframework1.ini";

const QString KConfigFile2 = "c:\\STFQTUI_Test\\testframework2.ini";

const QString KDefaultModuleName = "demomodule";

const QString KDefaultSetName = "stfqtuitesting.set";

testcontroller::testcontroller() 

    : OnSetListChangedFired(false),

            OnCaseStatisticChangedFired(false),

            OnRunningCaseChangedFired(false)

    {

    // TODO Auto-generated constructor stub

    model = new StfQtUIModel();

    model->AddStifModelEventListener(this);

    controller = new StfQtUIController(model);

    controller->AddStfEventListener(this);

    controller->OpenEngineIniFile(KConfigFile1);

    }

testcontroller::~testcontroller()

    {

    // TODO Auto-generated destructor stub

    delete controller;

    delete model;

    }

void testcontroller::T_GetModuleList_ModuleNumber()

    {

    controller->OpenEngineIniFile(KConfigFile1);

    int moduleSize = controller->GetModuleList().size();

    QCOMPARE(moduleSize, 1);

    }

void testcontroller::T_GetModuleList_ModuleName()

    {

    controller->OpenEngineIniFile(KConfigFile1);

    QList<QString> moduleList = controller->GetModuleList();

    bool find = false;

    foreach(QString m, moduleList)

        {

        if(m.toLower() == KDefaultModuleName)

            {

            find = true;

            break;

            }

        }

    QCOMPARE(find, true);

    }

void testcontroller::T_OpenEngineIniFile_ModuleNumber()

    {

    controller->OpenEngineIniFile(KConfigFile2);    

    int moduleSize = controller->GetModuleList().size();

    QCOMPARE(moduleSize, 2);

    }

void testcontroller::T_OpenEngineIniFile()

    {

    bool rst;

    rst = controller->OpenEngineIniFile(KConfigFile2);

    QCOMPARE(rst, true);

    rst = controller->OpenEngineIniFile(KConfigFile1);    

    QCOMPARE(rst, true);

    rst = controller->OpenEngineIniFile(KConfigFile2);

    QCOMPARE(rst, true);

    rst = controller->OpenEngineIniFile("z:\\abc.ini");

    //QCOMPARE(rst, false);

    rst = controller->OpenEngineIniFile(KConfigFile1);    

    QCOMPARE(rst, true);                

    }

void testcontroller::T_GetCaseListByModule()

    {

    controller->OpenEngineIniFile(KConfigFile1); 

    QList<QString> list = controller->GetCaseListByModule(KDefaultModuleName);

    QCOMPARE(list.size(), 6);

    list = controller->GetCaseListByModule("null");

    QCOMPARE(list.size(), 0);

    }

void testcontroller::T_GetCase()

    {

    CSTFCase theCase = controller->GetCase(KDefaultModuleName, 1);

    QCOMPARE(theCase.Index(), 1);

    theCase = controller->GetCase(KDefaultModuleName, 21);    

    QCOMPARE(theCase.Index(), -1);

    QCOMPARE(theCase.Name(), QString(""));

    theCase = controller->GetCase("null", 0);

    QCOMPARE(theCase.Name(), QString(""));

    }

void testcontroller::T_GetSetList()

    {

    OnSetListChangedFired = false;

    QList<QString> list = controller->GetSetList();

    bool find = false;

    foreach(QString set, list)

        {

        if(set == KDefaultSetName)

            {

            find = true;

            break;

            }

        }

    QCOMPARE(find, true);

    QCOMPARE(OnSetListChangedFired, false);//ensure SetListChanged does not be fired.

    }

void testcontroller::T_GetCaseListBySet()

    {

    OnSetListChangedFired = false;

    QList<QString> list = controller->GetCaseListBySet(KDefaultSetName);

    QCOMPARE(list.size(),5);

    list = controller->GetCaseListBySet("null");

    QCOMPARE(list.size(),0);

    QCOMPARE(OnSetListChangedFired, false);//ensure SetListChanged does not be fired.

    }

void testcontroller::T_AddCaseToSet()

    {

    OnSetListChangedFired = false;

    QList<QString> list = controller->GetSetList();

    int before_count = list.count();

    QList<CSTFCase> cases;

    QList<QString> caselist = controller->GetCaseListByModule(KDefaultModuleName);

    for(int i=0;i<caselist.size();i++)

        {

        CSTFCase theCase = controller->GetCase(KDefaultModuleName, i);

        cases.append(theCase);

        }

    controller->AddCaseToSet(cases, "test1");

    list = controller->GetSetList();    

    int after_count = list.count();

    QCOMPARE(before_count + 1, after_count);

    QCOMPARE(OnSetListChangedFired, true);

    }

void testcontroller::T_CreateSet()

    {

    //tested object is still not implemented.

    }

void testcontroller::T_DeleteSet()

    {

    //tested object is still not implemented.

    }

void testcontroller::T_ShowOutput()

    {

    QCOMPARE(controller->ShowOutput(), false);

    controller->SetShowOutput(true);

    QCOMPARE(controller->ShowOutput(), true);

    controller->SetShowOutput(false);

    QCOMPARE(controller->ShowOutput(), false);     

    }

void testcontroller::T_Model_ClearCasesStatus()

    {

    OnCaseStatisticChangedFired = false;

    model->ClearCasesStatus();

    QCOMPARE(OnCaseStatisticChangedFired, true);

    QCOMPARE(model->GetCasesByStatus(EStatusExecuted).size(), 0);

    QCOMPARE(model->GetCasesByStatus(EStatusPassed).size(), 0);

    QCOMPARE(model->GetCasesByStatus(EStatusFailed).size(), 0);

    QCOMPARE(model->GetCasesByStatus(EStatusAborted).size(), 0);

    QCOMPARE(model->GetCasesByStatus(EStatusCrashed).size(), 0);

    }

void testcontroller::T_Model_AddRunningCase_RemoveRunningCase()

    {

    CStartedTestCase* startedCase = 0;

    CSTFCase aCase;

    OnRunningCaseChangedFired = false;

    QCOMPARE(model->GetCasesByStatus(EStatusRunning).size(), 0);

    model->AddRunningCase(startedCase, aCase);

    QCOMPARE(OnRunningCaseChangedFired, true);

    QCOMPARE(model->GetCasesByStatus(EStatusRunning).size(), 1);

    OnRunningCaseChangedFired = false;    

    model->RemoveRunningCase(startedCase);

    QCOMPARE(OnRunningCaseChangedFired, true);    

    QCOMPARE(model->GetCasesByStatus(EStatusRunning).size(), 0);    

    }

void testcontroller::T_Model_AddCaseByStatus_GetCasesByStatus()

    {

    CSTFCase aCase;

    model->ClearCasesStatus();

    OnCaseStatisticChangedFired = false;

    QCOMPARE(model->GetCasesByStatus(EStatusExecuted).size(), 0);

    model->AddCaseByStatus(EStatusExecuted,aCase);

    QCOMPARE(OnCaseStatisticChangedFired, true);

    QCOMPARE(model->GetCasesByStatus(EStatusExecuted).size(), 1);

    OnCaseStatisticChangedFired = false;

    QCOMPARE(model->GetCasesByStatus(EStatusPassed).size(), 0);

    model->AddCaseByStatus(EStatusPassed,aCase);    

    QCOMPARE(OnCaseStatisticChangedFired, true);

    QCOMPARE(model->GetCasesByStatus(EStatusPassed).size(), 1);

    OnCaseStatisticChangedFired = false;

    QCOMPARE(model->GetCasesByStatus(EStatusFailed).size(), 0);

    model->AddCaseByStatus(EStatusFailed,aCase);    

    QCOMPARE(OnCaseStatisticChangedFired, true);

    QCOMPARE(model->GetCasesByStatus(EStatusFailed).size(), 1);

    OnCaseStatisticChangedFired = false;

    QCOMPARE(model->GetCasesByStatus(EStatusAborted).size(), 0);

    model->AddCaseByStatus(EStatusAborted,aCase);    

    QCOMPARE(OnCaseStatisticChangedFired, true);

    QCOMPARE(model->GetCasesByStatus(EStatusAborted).size(), 1);

    OnCaseStatisticChangedFired = false;

    QCOMPARE(model->GetCasesByStatus(EStatusCrashed).size(), 0);

    model->AddCaseByStatus(EStatusCrashed,aCase);    

    QCOMPARE(OnCaseStatisticChangedFired, true);

    QCOMPARE(model->GetCasesByStatus(EStatusCrashed).size(), 1);

    model->ClearCasesStatus();

    }

void testcontroller::T_RunCase()

    {

    model->ClearCasesStatus();

    OnCaseStatisticChangedFired = false;

    OnRunningCaseChangedFired = false;

    controller->OpenEngineIniFile(KConfigFile1); 

    QList<CSTFCase> caseList;

    caseList.append(controller->GetCase(KDefaultModuleName,2));//math test

    controller->RunCases(caseList, Sequentially);

    QTest::qWait(2000);

    QCOMPARE(OnCaseStatisticChangedFired, true);

    QCOMPARE(model->GetCasesByStatus(EStatusRunning).size(), 0);

    QCOMPARE(model->GetCasesByStatus(EStatusExecuted).size(), 1);

    QCOMPARE(model->GetCasesByStatus(EStatusPassed).size(), 1);

    model->ClearCasesStatus();

    }

void testcontroller::T_RunSet()

    {

    model->ClearCasesStatus();

    //controller->OpenEngineIniFile(KConfigFile1); 

    QList<QString> list = controller->GetCaseListBySet(KDefaultSetName);    

    QCOMPARE(list.size(),5);

    controller->RunSets(KDefaultSetName,Parallel);

    QTest::qWait(20000);

    QCOMPARE(model->GetCasesByStatus(EStatusExecuted).size(), 5);

    QCOMPARE(model->GetCasesByStatus(EStatusPassed).size(), 4);

    QCOMPARE(model->GetCasesByStatus(EStatusFailed).size(), 0);

    QCOMPARE(model->GetCasesByStatus(EStatusAborted).size(), 0);

    QCOMPARE(model->GetCasesByStatus(EStatusCrashed).size(), 1);

    model->ClearCasesStatus();    

    }

void testcontroller::T_PauseCase_ResumeCase()

    {

    model->ClearCasesStatus();

    OnCaseStatisticChangedFired = false;

    OnRunningCaseChangedFired = false;

    controller->OpenEngineIniFile(KConfigFile1); 

    QList<CSTFCase> caseList;

    caseList.append(controller->GetCase(KDefaultModuleName,0));  //loop test

    controller->RunCases(caseList, Sequentially);

    QTest::qWait(500);

    QCOMPARE(OnRunningCaseChangedFired, true);

    QCOMPARE(model->GetCasesByStatus(EStatusRunning).size(), 1);

    QCOMPARE(model->GetCasesByStatus(EStatusExecuted).size(), 0);

    controller->PauseCase();

    QTest::qWait(15000);

    QCOMPARE(model->GetCasesByStatus(EStatusRunning).size(), 1);

    controller->ResumeCase();

    QTest::qWait(15000);

    QCOMPARE(OnCaseStatisticChangedFired, true);

    QCOMPARE(model->GetCasesByStatus(EStatusRunning).size(), 0);

    QCOMPARE(model->GetCasesByStatus(EStatusExecuted).size(), 1);

    QCOMPARE(model->GetCasesByStatus(EStatusPassed).size(), 1);

    }

void testcontroller::T_AbortCase()

    {

    model->ClearCasesStatus();

    OnCaseStatisticChangedFired = false;

    OnRunningCaseChangedFired = false;

    controller->OpenEngineIniFile(KConfigFile1); 

    QList<CSTFCase> caseList;

    caseList.append(controller->GetCase(KDefaultModuleName,0));  //loop test

    controller->RunCases(caseList, Sequentially);

    QTest::qWait(500);

    QCOMPARE(OnRunningCaseChangedFired, true);

    QCOMPARE(model->GetCasesByStatus(EStatusRunning).size(), 1);

    QCOMPARE(model->GetCasesByStatus(EStatusExecuted).size(), 0);

    controller->AbortCase();

    QTest::qWait(1000);

    QCOMPARE(OnCaseStatisticChangedFired, true);

    QCOMPARE(model->GetCasesByStatus(EStatusRunning).size(), 0);

    QCOMPARE(model->GetCasesByStatus(EStatusExecuted).size(), 0);

    QCOMPARE(model->GetCasesByStatus(EStatusAborted).size(), 1);

    }

//===========================================================

void testcontroller::OnSetListChanged()

    {

    OnSetListChangedFired = true;

    }

void testcontroller::OnCaseStatisticChanged()

    {

    OnCaseStatisticChangedFired = true;

    }

void testcontroller::OnRunningCaseChanged()

    {

    OnRunningCaseChangedFired = true;

    }

void testcontroller::OnGetMessage(const QString& /*aMessage*/)

    {

    //nothing.

    }

void testcontroller::OnCaseOutputChanged(const CaseOutputCommand& /*cmd*/,

        const QString& , const QString&)

    {}