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 <netedit/dialogs/GNEDialogEnum.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
        FINISH,         // Write last line
        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)
        DIALOG,         // send signal to dialog (used for modal dialogs)
    };
 
    class DialogArgument {
 
    public:
        enum class Action {
            ACCEPT,     // press accept button
            CANCEL,     // press cancel button
            RESET,      // press reset button
            ABORT,      // abort dialog
            CUSTOM,     // custom action
            NONE,       // no action
        };
 
        DialogArgument(DialogType type, Action action);
 
        DialogArgument(DialogType type, const std::string& customAction);
 
        DialogArgument(DialogType type, const std::string& customAction, const int index);
 
        DialogArgument(DialogType type, const std::string& prefixToRemove, const std::string& customAction);
 
        DialogType getType() const;
 
        Action getAction() const;
 
        const std::string& getCustomAction() const;
 
        int getIndex() const;
 
    protected:
        DialogType myType = DialogType::DEFAULT;
 
        Action myAction = Action::NONE;
 
        std::string myCustomAction;
 
        int myIndex = 0;
 
    private:
        DialogArgument() = delete;
 
        DialogArgument(const DialogArgument&) = 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(InternalTest* testSystem, DialogArgument* dialogArgument,
                     const std::string& description);
 
    ~InternalTestStep();
 
 
    InternalTestStep* getNextStep() const;
 
    void setNextStep(InternalTestStep* nextStep);
 
 
    FXSelector getMessageType() const;
 
    FXSelector getMessageID() const;
 
    DialogArgument* getDialogArgument() const;
 
    TLSTableTest* getTLSTableTest() const;
 
    FXSelector getSelector() const;
 
    bool updateView() const;
 
    Category getCategory() const;
 
    void* getEvent() const;
 
    const std::string& getDescription() const;
 
private:
    InternalTest* myTestSystem = nullptr;
 
    InternalTestStep* myNextStep = 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;
 
    DialogArgument* myDialogArgument = nullptr;
 
    TLSTableTest* myTLSTableTest = nullptr;
 
    std::string parseStep(const std::string& rowText);
 
    void parseArguments(const std::string& arguments);
 
    void setupAndStart();
 
    void finish();
 
    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 focusOnFrame() 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 saveExistentFile();
 
    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 openAboutDialog();
 
    void loadFile();
 
    void saveNewFile();
 
    void saveFileAs();
 
    void reloadFile();
 
    void selectEdgeType();
 
    void createNewEdgeType();
 
    void overwritingAccept();
 
    void overwritingCancel();
 
    void overwritingAbort();
 
    void overwritingApplyToAll();
 
    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(Category category, const int tabs, const int overlappedTabs, const std::string& value) const;
 
    void modifyBoolAttribute(Category category, 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(Category category, const std::string& key, const bool updateView) const;
 
    void buildTwoPressKeyEvent(Category category, const std::string& keyA, const std::string& keyB, const bool updateView) 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;
};