InternalTestStep.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2025 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Single operation used in InternalTests
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <utils/foxtools/fxheader.h>
 
#include "InternalTest.h"
 
 
// ===========================================================================
// class definitions
// ===========================================================================
 
class InternalTestStep {
 
public:
    enum class Category {
        META,           // Meta step (used for packing set of steps like click or write)
        INIT,           // Setup and start step
        APP,            // send signal to APP (Either GUIAppWindows or GNEApplicationWindow)
        VIEW,           // send signal to view (either GUIView or GNEViewNet)
        TLS_PHASES,     // send signal to TLS Phases module (used for TLS Phases)
        TLS_PHASETABLE, // send signal to TLSTable (used for TLS Phases)
        COLOR,          // send signal to color dialog
    };
 
    class DialogTest {
 
    public:
        DialogTest(const FXuint value);
 
        DialogTest(const std::vector<FXuint>& values);
 
        DialogTest(const std::string& solution);
 
        static const FXuint yes = 1;
 
        static const FXuint no = 2;
 
        static const FXuint esc = 4;
 
        static const std::string colorValue;
 
        const std::vector<FXuint> questionDialogValues;
 
        const std::string fixSolution;
 
    private:
        DialogTest() = delete;
 
        DialogTest(const DialogTest&) = delete;
    };
 
    class TLSTableTest {
 
    public:
        TLSTableTest(FXSelector sel_, const int row_);
 
        TLSTableTest(FXSelector sel_, const int row_, const int column_, const std::string& text_);
 
        const FXSelector sel = 0;
 
        const int row = 0;
 
        const int column = 0;
 
        const std::string text = "";
 
    private:
        TLSTableTest() = delete;
 
        TLSTableTest(const TLSTableTest&) = delete;
    };
 
    InternalTestStep(InternalTest* testSystem, const std::string& step);
 
    InternalTestStep(InternalTest* testSystem, FXSelector messageType, FXSelector messageID,
                     Category category, const std::string description);
 
    InternalTestStep(InternalTest* testSystem, FXSelector messageType, Category category,
                     FXEvent* event, const bool updateView, const std::string description);
 
    InternalTestStep(InternalTestStep* parent, const std::string& solution, const std::string description);
 
    InternalTestStep(InternalTestStep* parent, FXSelector messageType, FXEvent* event, const std::string description);
 
    ~InternalTestStep();
 
    FXSelector getMessageType() const;
 
    FXSelector getMessageID() const;
 
    DialogTest* getDialogTest() const;
 
    TLSTableTest* getTLSTableTest() const;
 
    FXSelector getSelector() const;
 
    bool updateView() const;
 
    Category getCategory() const;
 
    void* getEvent() const;
 
    const std::vector<const InternalTestStep*>& getModalDialogTestSteps() const;
 
    const std::string& getDescription() const;
 
private:
    InternalTest* myTestSystem = nullptr;
 
    FXSelector myMessageType = SEL_COMMAND;
 
    FXSelector myMessageID = 0;
 
    Category myCategory = Category::META;
 
    bool myUpdateView = false;
 
    std::string myDescription;
 
    std::vector<std::string> myArguments;
 
    FXEvent* myEvent = nullptr;
 
    DialogTest* myDialogTest = nullptr;
 
    TLSTableTest* myTLSTableTest = nullptr;
 
    std::vector<const InternalTestStep*> myDialogTestSteps;
 
    std::string parseStep(const std::string& rowText);
 
    void parseArguments(const std::string& arguments);
 
    void setupAndStart();
 
    void mouseClick(const std::string& button, const std::string& modifier) const;
 
    void leftClickOffset(const std::string& button) const;
 
    void moveElementHorizontal() const;
 
    void moveElementVertical() const;
 
    void moveElement() const;
 
    void typeKey() const;
 
    void contextualMenuOperation() const;
 
    void protectElements() const;
 
    void waitDeleteWarning() const;
 
    void modifyAttribute(const int overlappedTabs) const;
 
    void modifyBoolAttribute(const int overlappedTabs) const;
 
    void modifyColorAttribute(const int overlappedTabs) const;
 
    void modifyVClassDialog_NoDisallowAll(const int overlappedTabs) const;
 
    void modifyVClassDialog_DisallowAll(const int overlappedTabs) const;
 
    void modifyVClassDialog_Cancel(const int overlappedTabs) const;
 
    void modifyVClassDialog_Reset(const int overlappedTabs) const;
 
    void modifyVTypeDialogAttribute() const;
 
    void createConnection(const std::string& keyModifier) const;
 
    void createCrossing() const;
 
    void modifyCrossingDefaultValue() const;
 
    void modifyCrossingDefaultBoolValue() const;
 
    void crossingClearEdges() const;
 
    void crossingInvertEdges() const;
 
    void saveConnectionEdit() const;
 
    void fixCrossings();
 
    void fixStoppingPlace();
 
    void fixRoute();
 
    void createTLS(const int overlappedTabs) const;
 
    void copyTLS() const;
 
    void joinTSL() const;
 
    void disJoinTLS() const;
 
    void deleteTLS() const;
 
    void modifyTLSTable();
 
    void resetSingleTLSPhases() const;
 
    void resetAllTLSPhases() const;
 
    void pressTLSPhaseButton() const;
 
    void addPhase(const std::string& type);
 
    void pressTLSButton(const std::string& type);
 
    void checkParameters(const int overlappedTabs) const;
 
    void checkDoubleParameters(const int overlappedTabs) const;
 
    void changeEditMode();
 
    void saveExistentShortcut();
 
    void checkUndoRedo() const;
 
    void deleteFunction() const;
 
    void selection() const;
 
    void selectNetworkItems() const;
 
    void lockSelection() const;
 
    void selectionRectangle() const;
 
    void createDataSet() const;
 
    void createDataInterval() const;
 
    void undo() const;
 
    void redo() const;
 
    void changeSupermode();
 
    void changeMode();
 
    void changeElement() const;
 
    void changePlan() const;
 
    void computeJunctions();
 
    void computeJunctionsVolatileOptions();
 
    void selectAdditionalChild();
 
    void createRectangledShape();
 
    void createSquaredShape();
 
    void createLineShape();
 
    void createMeanData();
 
    void deleteMeanData();
 
    void copyMeanData();
 
    void quit();
 
    bool checkIntArgument(const std::string& argument) const;
 
    int getIntArgument(const std::string& argument) const;
 
    bool checkBoolArgument(const std::string& argument) const;
 
    bool getBoolArgument(const std::string& argument) const;
 
    bool checkStringArgument(const std::string& argument) const;
 
    std::string getStringArgument(const std::string& argument) const;
 
    std::string stripSpaces(const std::string& str) const;
 
    void writeError(const std::string& function, const int overlapping,
                    const std::string& expected) const;
 
    void createShape(const InternalTest::ViewPosition& viewPosition,
                     const int sizeX, const int sizeY, const bool close,
                     const bool line) const;
 
 
    void modifyStringAttribute(const int tabs, const int overlappedTabs, const std::string& value) const;
 
    void modifyBoolAttribute(const int tabs, const int overlappedTabs) const;
 
 
 
    void buildUndo(const int number) const;
 
    void buildRedo(const int number) const;
 
 
 
    std::pair<FXint, FXString> translateKey(const std::string& key) const;
 
    FXEvent* buildKeyPressEvent(const std::string& key) const;
 
    FXEvent* buildKeyReleaseEvent(const std::string& key) const;
 
    void buildPressKeyEvent(const std::string& key, const bool updateView) const;
 
    void buildPressKeyEvent(InternalTestStep* parent, const std::string& key) const;
 
    void buildTwoPressKeyEvent(const std::string& keyA, const std::string& keyB, const bool updateView) const;
 
    void buildTwoPressKeyEvent(InternalTestStep* parent, const std::string& keyA, const std::string& keyB) const;
 
 
 
    void buildMouseClick(const InternalTest::ViewPosition& viewPosition,
                         const int offsetX, const int offsetY,
                         const std::string& button, const std::string& keyModifier) const;
 
    void buildMouseDragDrop(const InternalTest::ViewPosition& viewStartPosition,
                            const int offsetStartX, const int offsetStartY,
                            const InternalTest::ViewPosition& viewEndPosition,
                            const int offsetEndX, const int offsetEndY,
                            const std::string& keyModifier) const;
 
    FXEvent* buildMouseMoveEvent(const InternalTest::ViewPosition& viewPosition,
                                 const int offsetX, const int offsetY, const int clickedButton,
                                 const std::string& keyModifier, const int numberOfClicks) const;
 
    FXEvent* buildMouseClickEvent(FXSelType type, const InternalTest::ViewPosition& viewPosition,
                                  const int offsetX, const int offsetY, const std::string& keyModifier,
                                  const int numberOfClicks) const;
 
    void writeClickInfo(const InternalTest::ViewPosition& viewPosition,
                        const int offsetX, const int offsetY,
                        const std::string modifier) const;
 
 
    InternalTestStep() = delete;
 
    InternalTestStep(const InternalTestStep&) = delete;
 
    InternalTestStep& operator=(const InternalTestStep&) = delete;
};