libgth.h

Go to the documentation of this file.

/*
        libgth.h

        Copyright 2012 - 2017 Brenton Ross

This file is part of VICI.

VICI is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

VICI is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with VICI. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef GTH_LIBGTH_H
#define GTH_LIBGTH_H

#include <vici/testmgr.h>
#include <vici/proc.h>
#include <vici/fdstream.h>
#include <vici/xml.h>
#include "libgui.h"
#include "gth.h"
#include <map>
#include <memory>
#include <mutex>
#include <condition_variable>
#include <QThread>
#include <QGraphicsView>
#ifdef HAVE_QT4
#include <QtGui>
#endif
#ifdef HAVE_QT5
#include <QtWidgets>
#endif

extern "C" {
// forward declaration
struct lua_State;       // this stops the requirement for Lua from leaking into other projects.
}



namespace VICI
{

namespace gth
{

class GTHTest;
class ScriptXML;

typedef std::vector< std::string > ParamList;

typedef std::vector< std::list< std::string> > ListOfLists;

typedef std::shared_ptr< ScriptXML > ScriptXmlPtr;

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


class Adaptor
{
protected:
        void mouseDoubleClick(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = 0,
            QPoint pos = QPoint(), int delay=-1);

        GTHTest * gthTest;              // reference

        std::string widgetName;
public:
        Adaptor( csr name, GTHTest *gth) : gthTest(gth), widgetName(name) {}

        virtual ~Adaptor(){}


        virtual std::string action( csr tcname, csr cmnd, const ParamList  &params ) = 0;


        virtual VICI::gth::WidgetType getType() = 0;

        csr getWidgetName() { return widgetName; }
};

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


class LuaScript
{
private:
        lua_State *L;
public:
        LuaScript( csr chunk );

        ~LuaScript();

        std::string call( csr cmnd, const ParamList &params );

        static int luaVersion();
};

typedef std::shared_ptr<LuaScript> LuaScriptPtr;

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


struct TestAction
{
        std::string label;              
        int delay;                              
        std::string widgetName; 
        std::string command;    
        ParamList params;               
        std::string assignmentRegex;    
        ParamList assignmentNames;              

        std::vector< std::pair<std::string, std::string > > jumps;
};


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

enum ConDes { Constructor, Destructor };

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


class TestsForWindow : public QThread
{
        Q_OBJECT
private:
        // the list of test case names as used to install the test cases.
        ListOfLists testCases;
        ListOfLists::iterator seq;

        std::string windowName;
        bool forMainWindow;
        GTHTest *owner;
        LuaScriptPtr luaScript;

        // wait for other windows to complete
        bool paused;
        std::mutex pauseMx;
        std::condition_variable pauseCV;

        std::mutex jumpMx;
        std::condition_variable jumpCV;
        bool jumpCompleted;

public:
        TestsForWindow(GTHTest *, csr window, bool isMainWindow);

        ~TestsForWindow();

        void addSequence();

        void addTest(csr testCase);

        void addAction( csr testCase, ConDes, const TestAction &);

        void addScript( csr chunk );

        csr name() { return windowName; }

        virtual void run();

        void pause();

        void resume();

        bool checkPaused();

        void jumpThread( csr tcname, csr widgetName, csr command, const std::vector< std::string> &params);

        void jumpNotify();

signals:
        void sendAdaptor( const std::string &tcname, const std::string & widgetName,
                        const std::string & command,
                        const std::vector< std::string> &params);
};

typedef std::shared_ptr< TestsForWindow > TestsForWindowPtr;

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

class UserEscaper : public QObject
{
        Q_OBJECT
private:
        bool &escapeFlag;
public:
        UserEscaper( bool &flag ) : escapeFlag(flag) {} 
protected:
        bool eventFilter(QObject *obj, QEvent *event);  
};

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


class GTHTest : public QObject, public VICI::cdi::ScenarioT<GTHTest>, public VICI::WidgetMgrClient
{
        Q_OBJECT
private:
        // map from widget name to its adaptor
        std::map< std::string, Adaptor * > adaptors;
        Adaptor *makeAdaptor( void *w, VICI::gth::WidgetType, csr widgetName, GTHTest *);
        void describeAdaptors();
public:
        void jumpThread( csr tcname, csr widgetName, csr command, const std::vector< std::string> &params);

private slots:
        void runAdaptor( const std::string &tcname, const std::string & widgetName,
                        const std::string & command,
                        const std::vector< std::string > &params);

private:
        // registering widgets
        void registerStandardWindow(QWidget *);
        void registerMessageBox(QWidget *w);
        void registerFileDialog(QWidget *w);
        void registerFontDialog(QWidget *w);
        void registerColorDialog(QWidget *w);
        void registerInputDialog(QWidget *w);
        void registerButtons(QWidget *w, csr prefix );
        void clean( std::string & );
        std::string widgetTypeToString( WidgetType );

        void newActiveWindow( QWidget *);

        QWidget *mainWindow;

        ScriptXmlPtr script;
        void loadScript();
        std::set<TestsForWindowPtr> activeTests;
        TestsForWindowPtr currentActiveTests;

        // map from window name to the test thread
        std::map< std::string, TestsForWindowPtr > testsForWindows;

        // map from test case name to test thread
        std::map< std::string, TestsForWindowPtr > testCases;
        void installDefaultTestCases();

        // map test case, constructor/destructor to the vector of test actions
        std::map< std::pair<std::string, ConDes>, std::vector<TestAction> > actions;

        // map from variable name to its value
        std::map< std::string, std::string> variables;

        // std::mutex focusMx;
        // support for allowing user to escape from the test
        bool userEscape;
        UserEscaper *escaper;

private slots:
        void focusChanged(QWidget *, QWidget * );
        //void beginTests();

public:
        GTHTest(csr name);

        ~GTHTest();

        csr getName() { return scenarioName; }

        virtual bool willRunTests() { return true; }

        virtual void runTests(csr scenarioName, cdi::ScenarioResults *);

        cdi::ScenarioResults *results;

        void endMainWindow();

        void runActions( csr testCase, ConDes );

        void assignVariables( const TestAction &, csr result );

        std::string getJump( const TestAction &, csr result);

        csr getVar( csr varName ) const;

        void substVars( const ParamList &, ParamList &);

        virtual void windowHasRegistered( GTHWindowWidget * );
        virtual void windowHasDeregistered( GTHWindowWidget * );

        void regWidget( void *w, VICI::gth::WidgetType t, csr n);

        std::string prefix();

signals:
        void testingCompleted();
};

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


class GTHTestCase
{
protected:
        GTHTest *myScenario;                    
        const std::string & name;               
        csr getVar(csr);                                
protected:
        GTHTestCase(csr name);

        ~GTHTestCase();

};

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


class DefaultTestCase : public VICI::gth::GTHTestCase, public VICI::cdi::TestCaseT<DefaultTestCase>
{
protected:
        virtual bool runTest(){ return true; }
public:
        DefaultTestCase(csr nm)
        : GTHTestCase(nm), VICI::cdi::TestCaseT<DefaultTestCase>(nm)
          {}

        ~DefaultTestCase() {}
};

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


class ScriptXML : public VICI::cfi::Xml
{
public:
        ScriptXML( const VICI::Path &, bool create);

        ~ScriptXML();

        // get the necessaries for running a test

        void getWindows( ParamList &);

        void getTestsForWindow( csr wnm, ListOfLists &);

        void getTestActions(csr tnm, ConDes, std::vector< TestAction > & );

        void getScripts(std::map< std::string, std::string > &);

        void addExecFilePath(csr fileName);

        void addTest( csr testName, bool unreferenced );

        void addWindow( csr windowName, bool unreferenced );

        void addWidget( csr widgetName, csr widgetType );

        void addWidgetType( csr widgetType, const ListOfLists &);
};


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


class MouseEventReporter : public QObject
{
        Q_OBJECT
private:
        QGraphicsView *view;

public:
        MouseEventReporter(QGraphicsView *v) : view(v) {}

protected:
    bool eventFilter(QObject *obj, QEvent *event);
};

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


template < VICI::gth::WidgetType wt >
class AdaptorST : public Adaptor
{
private:
public:
        AdaptorST(csr name, GTHTest *gth) : Adaptor(name, gth) {}

        static void describe( ListOfLists & );
};

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



template < VICI::gth::WidgetType wt, class T >
class AdaptorT : public AdaptorST<wt>
{
private:
        T *w;           // reference
        static const VICI::gth::WidgetType wType = wt;
public:

        AdaptorT( void *p, csr name, GTHTest *gth)
                : AdaptorST<wt>(name, gth), w( reinterpret_cast<T *>(p)) {}

        virtual ~AdaptorT(){}


        VICI::gth::WidgetType getType() { return wType; }

        virtual std::string action( csr tcname, csr cmnd, const ParamList  & params );
};

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

} // namespace gth

} // namespace VICI
// ----------------------------------------------------------

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

#endif