From 0a4672780c269d01813116d78609710a5975db60 Mon Sep 17 00:00:00 2001
From: Hiroyasu Nishiyama <hiroyasu.nishiyama.uq@hitachi.com>
Date: Sat, 21 Aug 2021 13:35:15 +0900
Subject: [PATCH 1/9] initial prototype of flow testing plugin

---
 nodes/flow-test-config.html |  61 +++
 nodes/flow-test-config.js   |  27 ++
 nodes/package.json          |  21 +
 src/flow-tester.html        | 902 +++++++++++++++++++++++++++++++++++-
 src/flow-tester.js          | 131 ++++++
 src/style.css               |  18 +-
 6 files changed, 1155 insertions(+), 5 deletions(-)
 create mode 100644 nodes/flow-test-config.html
 create mode 100644 nodes/flow-test-config.js
 create mode 100644 nodes/package.json

diff --git a/nodes/flow-test-config.html b/nodes/flow-test-config.html
new file mode 100644
index 0000000..4324532
--- /dev/null
+++ b/nodes/flow-test-config.html
@@ -0,0 +1,61 @@
+<!--
+  Copyright JS Foundation and other contributors, http://js.foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<!--
+     UI and related operations are defined in flow tester
+-->
+
+<script type="text/html" data-template-name="flow-test-config">
+
+    <div class="form-row">
+        <label for="node-input-name"><span data-i18n="node-red:common.label.name"></span></label>
+        <input type="text" id="node-input-name"/>
+    </div>
+
+    <div class="form-row" id="test-actions-row">
+        <div id="test-actions-container"></div>
+    </div>
+
+</script>
+
+<script type="text/javascript">
+(function () {
+    RED.nodes.registerType("flow-test-config", {
+        category: "config",		// category of node
+        defaults: {
+            name: { value: "" },
+            tests: { tests: [] },
+        },
+        label: function() {
+            return this.name || "flow test";
+        },
+        labelStyle: function() {
+            return this.name ? "node_label_italic" : "";
+        },
+        oneditprepare: function() {
+            var node = this;
+        },
+        oneditsave: function() {
+            var node = this;
+        },
+        oneditresize: function(size) {
+            var node = this;
+        }
+    });
+
+})();
+
+</script>
diff --git a/nodes/flow-test-config.js b/nodes/flow-test-config.js
new file mode 100644
index 0000000..3207cfd
--- /dev/null
+++ b/nodes/flow-test-config.js
@@ -0,0 +1,27 @@
+/**
+ * Copyright JS Foundation and other contributors, http://js.foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ **/
+
+module.exports = function(RED) {
+    "use strict";
+
+    function FlowTestConfig(n) {
+        RED.nodes.createNode(this, n);
+        const node = this;
+        node.name = n.name;
+    }
+    
+    RED.nodes.registerType("flow-test-config", FlowTestConfig);
+};
diff --git a/nodes/package.json b/nodes/package.json
new file mode 100644
index 0000000..5578f7a
--- /dev/null
+++ b/nodes/package.json
@@ -0,0 +1,21 @@
+{
+    "name": "node-red-flow-test",
+    "version": "0.0.1",
+    "description": "Node-RED node for Flow Test",
+    "node-red": {
+        "nodes": {
+            "flow-test-config": "flow-test-config.js"
+        }
+    },
+    "license": "Apache 2.0",
+    "keywords": [
+        "node-red"
+    ],
+    "author": {
+        "name": "Hiroyasu Nishiyama",
+        "email": "hiroyasu.nishiyama.uq@hitachi.com"
+    },
+    "dependencies": {},
+    "devDependencies": {
+    }
+}
diff --git a/src/flow-tester.html b/src/flow-tester.html
index 34150b7..4a139a0 100644
--- a/src/flow-tester.html
+++ b/src/flow-tester.html
@@ -1,17 +1,897 @@
+<!--
+  Copyright JS Foundation and other contributors, http://js.foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
 
 <link rel="stylesheet" href="resources/node-red-flow-tester/style.css">
+
 <script type="text/javascript">
 (function() {
+    var content = null;
+    var panels = null;
+    var treeList = null;
+    var treeRoot = null;
+
+    var suites = {};
+    var testID = 0;
+
+    var suiteCount = 0;
+    
+    var selectedTestID = undefined;
+    
     function show() {
         RED.sidebar.show("flow-tester");
     }
 
+    function resizeStack() {
+        var h = $(content).parent().height();
+        panels.resize(h);
+        var htl = $(treeList).parent().height();
+        treeList.css({
+            height: (htl -60)
+        });
+    }
+
+    function invokeAction(kind, opt) {
+        return $.ajax({
+            url: "/flow-tester/executeAction/"+ kind,
+            type: "POST",
+            contentType: "application/json",
+            data: JSON.stringify(opt)
+        });
+    }
+    
+    function executeAction(id, action, suiteNode, testCase) {
+        switch (action.kind) {
+        case "send":
+            invokeAction("send", {
+                target: action.target,
+                value: action.value
+            });
+            break;
+        case "press":
+        case "recv":
+        case "set": 
+        case "match":
+        case "wait":
+        case "function":
+        default:
+            throw new Error("unexpected kind of action: " +action.kind);
+            break;
+        }
+    }
+    
+    function initAction(id, action, suiteNode, testCase) {
+        switch (action.kind) {
+        case "send":
+            // nothing to do
+            break;
+        case "match":
+            invokeAction("matchInit", {
+                node: id,
+                value: action.value
+            });
+            break;
+        case "press":
+        case "recv":
+        case "set": 
+        case "wait":
+        case "function":
+        default:
+            throw new Error("unexpected kind of action: " +action.kind);
+            break;
+        }
+    }
+    
+    function executeTestCase(suiteNode, testCase) {
+        var actions = testCase.actions || {};
+        
+        invokeAction("init", {});
+        
+        var events = Object.keys(actions);
+        events.forEach(function (event) {
+            var eventActions = actions[event];
+            var handlerIDs = Object.keys(eventActions);
+            handlerIDs.forEach(function (id) {
+                var initActions = eventActions[id];
+                initActions.forEach(function (action) {
+                    initAction(id, action, suiteNode, testCase)
+                });
+            });
+        });
+
+        invokeAction("start", {});
+
+        var setupActions = actions.setup._global_ || [];
+        setupActions.forEach(function (action) {
+            executeAction("_global_", action, suiteNode, testCase)
+        });
+
+        invokeAction("cleanup", {});
+    }
+
+    function addTestCase(suite, newTest) {
+        var tid = newTest.id;
+        var name = newTest.name;
+        var treelist = suite.element.treeList;
+        var suiteNode = suite.node;
+        var test = {
+            element: getTestCaseLabel(tid, name, suiteNode, newTest),
+            icon: "fa fa-file-text-o",
+        };
+        treelist.addChild(test);
+        treelist.expand();
+    }
+
+    function getSuiteLabel(id, name, suiteNode) {
+        var div = $("<div/>", {
+            class: "red-ui-suite-label"
+        }).css({
+        });
+        var contentDiv = $("<div/>", {
+        }).text(name).appendTo(div);
+        var controls = $("<div/>", {
+            class: "red-ui-suite-label-control",
+        }).css({
+        }).appendTo(div);
+        var editButton = $("<button/>", {
+            class: "red-ui-button red-ui-button-small"
+        }).css({
+            "margin-left": "3px"
+        }).appendTo(controls);
+        $("<i/>", {
+            class: "fa fa-pencil"
+        }).text("edit").appendTo(editButton);
+        var addButton = $("<button/>", {
+            class: "red-ui-button red-ui-button-small"
+        }).css({
+            "margin-left": "3px"
+        }).appendTo(controls);
+        $("<i/>", {
+            class: "fa fa-plus"
+        }).text("add").appendTo(addButton);
+
+        $(addButton).on("click", function (ev) {
+            ev.preventDefault();
+            ev.stopPropagation();
+            var suite = suites[id];
+            var suiteNode = suite.node;
+            var tests = suiteNode.tests;
+            var name = "New Test " +testID;
+            var tid = "T" +testID;
+            testID++;
+            var newTest = {
+                id: tid,
+                name: name,
+                suite: id,
+                actions: {
+                    // test specific events
+                    setup: {},
+                    cleanup: {},
+                    // node specific events
+                    recv: {},
+                    stub: {},
+                    send: {},
+                }, 
+            };
+            tests.push(newTest);
+            addTestCase(suite, newTest);
+        });
+        $(editButton).on("click", function (ev) {
+            ev.preventDefault();
+            ev.stopPropagation();
+            RED.editor.edit(suiteNode);
+        });
+        return div;
+    }
+
+    function getTestCaseLabel(id, name, suiteNode, testCase) {
+        var div = $("<div/>", {
+            class: "red-ui-suite-label"
+        }).css({
+        });
+        var contentDiv = $("<div/>", {
+        }).text(name).appendTo(div);
+        var controls = $("<div/>", {
+            class: "red-ui-suite-label-control",
+        }).css({
+        }).appendTo(div);
+        var runButton = $("<button/>", {
+            class: "red-ui-button red-ui-button-small"
+        }).css({
+            "margin-left": "3px"
+        }).appendTo(controls);
+        $("<i/>", {
+            class: "fa fa-play"
+        }).text("run").appendTo(runButton);
+        var editButton = $("<button/>", {
+            class: "red-ui-button red-ui-button-small"
+        }).css({
+            "margin-left": "3px"
+        }).appendTo(controls);
+        $("<i/>", {
+            class: "fa fa-pencil"
+        }).text("edit").appendTo(editButton);
+
+        $(runButton).on("click", function (ev) {
+            ev.preventDefault();
+            ev.stopPropagation();
+            executeTestCase(suiteNode, testCase);
+        });
+
+        $(editButton).on("click", function (ev) {
+            ev.preventDefault();
+            ev.stopPropagation();
+            selectedTestID = id;
+            RED.editor.edit(suiteNode);
+        });
+
+        return div;
+    }
+
+
+    function addTestSuite(root, suite) {
+        var id = suite.id;
+        var name = suite.name;
+        var element = {
+            element: getSuiteLabel(id, name, suite),
+            icon: "fa fa-briefcase",
+            children: []
+        };
+        suites[id] = {
+            id: id,
+            node: suite,
+            element: element,
+        };
+        root.treeList.addChild(element);
+        var tests = suite.tests || [];
+        tests.forEach(function (test) {
+            addTestCase(suites[id], test);
+        });
+    }
+
+
+    function removeTestSuite(root, node) {
+        var suite = suites[node.id];
+        suite.element.treeList.remove();
+    }
+    
+    function addNewTestSuite(root) {
+        var def = RED.nodes.getType("flow-test-config");
+        var name = "Test Suite " +suiteCount++;
+        var id = RED.nodes.id();
+        var testNode = {
+            id: id,
+            _def: def,
+            type: "flow-test-config",
+            users: [],
+            name: name,
+            tests: []
+        };
+        RED.nodes.add(testNode);
+        RED.nodes.dirty(true);
+    }
+    
+    function createTestSuites(testsPanel) {
+        var labelDiv = $("<div/>", {
+            class: "form-row compact"
+        }).css({
+            "margin-left": "5px"
+        }).appendTo(testsPanel);
+        $("<b/>").css({
+        }).text("Test Suites").appendTo(labelDiv);
+        treeList = $("<div/>").css({
+            width: "100%"
+        }).appendTo(testsPanel);
+        var addSuiteButton = $("<button/>", {
+            class: "red-ui-button red-ui-button-small"
+        }).css({
+            float: "right",
+            "margin-top": "5px",
+            "margin-right": "5px",
+        }).text("+ add").appendTo(testsPanel);
+        var root = {
+            label: "Test Suites",
+            expanded: true,
+            children: []
+        };
+        treeRoot = root;
+        addSuiteButton.on("click", function (ev) {
+            ev.preventDefault();
+            addNewTestSuite(root);
+        });
+
+        treeList.treeList({
+            data: [root]
+        });
+    }
+
+
+    function createEventTab(id, container, node) {
+        var div = $("<div/>", {
+            id: id
+        }).css({
+            display: "none"
+        }).appendTo(container);
+        var actionList = $("<ul/>", {
+            id: id+"-list"
+        }).appendTo(div);
+        actionList.css({
+            "min-height": "300px",
+            "min-width": "430px" 
+        }).editableList({
+            addItem: function(con, i, opt) {
+                var row0 = $("<div/>", {
+                }).css({
+                }).appendTo(con);
+                var row1 = $("<div/>", {
+                    hidden: true
+                }).css({
+                    "margin-top": "3px"
+                }).appendTo(con);
+                
+                var kind = $("<select>", {
+                    class: "action-kind"
+                }).css({
+                    width: "100px",
+                    display: "inline-block",
+                    "text-align": "center",
+                    "margin-left": "5px",
+                    "margin-bottom": "0px",
+                }).appendTo(row0);
+                var actions = [
+                    "send", "press", "recv", "set", 
+                    "match", "wait", "function"
+                ];
+                actions.forEach(function (action) {
+                    $("<option/>", {
+                    }).val(action).text(action).appendTo(kind);
+                });
+
+                var val = $("<input/>", {
+                    class: "action-value"
+                }).css({
+                    display: "inline-block",
+                    "margin-left": "8px",
+                    width: "calc(100% - 130px)"
+                }).appendTo(row0);
+                $(val).typedInput({
+                    default: "str",
+                    types: [
+                        "str", "num", "bool", "json", "bin",
+                        "re", "date", "jsonata", "env"
+                    ]
+                });
+
+                $("<label/>", {
+                }).css({
+                    display: "inline-block",
+                    "text-align": "right",
+                    width: "100px"
+                }).text("to").appendTo(row1);
+                var target = $("<select/>", {
+                    class: "action-target"
+                }).css({
+                    "margin-left": "13px"
+                }).appendTo(row1);
+
+                $(kind).on("change", function (ev) {
+                    var val = $(kind).val();
+                    if ((val === "press") ||
+                        (val === "send")) {
+                        $(row1).show();
+                        var nodes = RED.nodes.filterNodes({});
+                        $(target).empty();
+                        nodes.forEach(function (node) {
+                            var id = node.id;
+                            var name = "["+ node.id +":" +node.type +"]" +node.name;
+                            $("<option/>", {
+                            }).css({
+                            }).text(name).val(id).appendTo(target);
+                        });
+                    }
+                    else {
+                        $(row1).hide();
+                    }
+                });
+
+                $(kind).val("send");
+                if (opt) {
+                    if (opt.kind) {
+                        $(kind).val(opt.kind);
+                    }
+                    if (opt.value) {
+                        $(val).typedInput("value", opt.value);
+                    }
+                    if (opt.target) {
+                        $(target).val(opt.target);
+                    }
+                }
+                $(kind).change();
+            },
+            removable: true,
+            sortable: true,
+        });
+    }
+
+    function getSuites() {
+        return Object.values(suites);
+    }
+
+    function updateCaseSelector(caseSel, caseInput, cases) {
+        var initVal = null;
+        caseSel.empty();
+        cases.forEach(function (def) {
+            var val = def.id;
+            var name = def.name;
+            $("<option/>").val(val).text(name).appendTo(caseSel);
+            initVal = initVal || val;
+        });
+        if (initVal) {
+            caseSel.val(initVal);
+        }
+    }
+
+    function loadActions(currentCase, events, node) {
+        if (!currentCase) {
+            return;
+        }
+        var nid = "_global_";
+        if (node.type !== "flow-test-config") {
+            nid = node.id;
+        }
+        events.forEach(function (event) {
+            var actions0 = currentCase.actions || {};
+            var actions1 = actions0[event] || {};
+            var actions = actions1[nid] || [];
+            var listID = "node-test-event-tab-" +event +"-list";
+            var list = $("#"+listID);
+            list.editableList("empty");
+            actions.forEach(function (action) {
+                list.editableList("addItem", action);
+            });
+        });
+    }
+    
+    function createTestSelector(
+        node,
+        suiteSel, suiteInput,
+        suiteAddButton, suiteDelButton, suiteUpdateButton,
+        caseSel, caseInput,
+        caseAddButton, caseDelButton, caseUpdateButton,
+        initialCaseID, events) {
+        var isConfig = (node.type === "flow-test-config");
+        var suites = getSuites();
+        var testSuites = {};
+        var suiteVal = null;
+        suites.forEach(function (suite) {
+            var n = suite.node;
+            var sid = n.id;
+            var sname = n.name;
+            suiteVal = suiteVal || sid;
+            if (suiteSel) {
+                $("<option/>", {
+                }).val(sid).text(sname).appendTo(suiteSel);
+            }
+            var tests = n.tests;
+            var testCases = [];
+            testSuites[sid] = testCases;
+            tests.forEach(function (test) {
+                testCases.push(test);
+            });
+            testCases.push({
+                id: "_NEW_",
+                name: "new..."
+            });
+        });
+        if (suiteSel) {
+            $("<option/>", {
+            }).val("_NEW_").text("new...").appendTo(suiteSel);
+        }
+        var currentCases = [];
+        if (suiteSel) {
+            suiteSel.on("change", function (ev) {
+                var sid = suiteSel.val();
+                var cases = testSuites[sid] || [];
+                updateCaseSelector(caseSel, caseInput, cases);
+                currentCases = cases;
+                if (sid === "_NEW_") {
+                    suiteAddButton.show();
+                    suiteDelButton.hide();
+                    suiteUpdateButton.hide();
+                }
+                else {
+                    var suites = getSuites();
+                    var suite = suites.find(function (x) { return x.id === sid; });
+                    if (suite) {
+                        suiteInput.val(suite.name);
+                    }
+                    suiteAddButton.hide();
+                    suiteDelButton.show();
+                    suiteUpdateButton.show();
+                }
+            });
+            suiteSel.val(suiteVal);
+            suiteSel.change();
+        }
+        else {
+            var cases = testSuites[node.id] || [];
+            updateCaseSelector(caseSel, caseInput, cases);
+            currentCases = cases;
+        }
+        var isFirstCase = true;
+        caseSel.on("change", function (ev) {
+            var caseid = caseSel.val();
+            if (caseid === "_NEW_") {
+                caseAddButton.show();
+                caseDelButton.hide();
+                caseUpdateButton.hide();
+            }
+            else {
+                var currentCase = currentCases.find(function (e) { return e.id === caseid; });
+                if (currentCase) {
+                    caseInput.val(currentCase.name);
+                }
+                caseAddButton.hide();
+                caseDelButton.show();
+                caseUpdateButton.show();
+                loadActions(currentCase, events, node);
+            }
+            // update actions list
+        });
+        caseInput.on("change", function (ev) {
+            // update test case list
+        });
+        caseSel.val(initialCaseID ? initialCaseID : "_NEW_");
+        caseSel.change();
+    }
+
+
+    function buildCaseInputs(container, kind, name) {
+        var selectRow = $("<div/>", {
+            class: "form-row"
+        }).appendTo(container);
+        $("<label/>").css({
+            "margin-left": "10px",
+            width: "90px"
+        }).text(name).appendTo(selectRow);
+        var selector = $("<select/>", {
+            id: "flow-test-" +kind,
+        }).css({
+            width: "calc(55% - 130px)",
+        }).appendTo(selectRow);
+        var input = $("<input/>", {
+            placeholder: name,
+        }).css({
+            width: "calc(55% - 110px)",
+            height: "24px",
+            "margin-bottom": "9px",
+            "margin-left": "8px",
+        }).appendTo(selectRow);
+
+        var addButton = $("<button/>", {
+            class: "red-ui-button red-ui-button-small"
+        }).css({
+            "vertical-align": "top",
+            "margin-top": "3px",
+            "margin-left": "3px"
+        }).appendTo(selectRow);
+        $("<i/>", {
+            class: "fa fa-plus"
+        }).appendTo(addButton);
+
+        var delButton = $("<button/>", {
+            class: "red-ui-button red-ui-button-small"
+        }).css({
+            "vertical-align": "top",
+            "margin-top": "3px",
+            "margin-left": "3px"
+        }).appendTo(selectRow);
+        $("<i/>", {
+            class: "fa fa-minus"
+        }).appendTo(delButton);
+
+        var updateButton = $("<button/>", {
+            class: "red-ui-button red-ui-button-small"
+        }).css({
+            "vertical-align": "top",
+            "margin-top": "3px",
+            "margin-left": "3px"
+        }).appendTo(selectRow);
+        $("<i/>", {
+            class: "fa fa-refresh"
+        }).appendTo(updateButton);
+
+        return [selector, input,
+                addButton, delButton, updateButton];
+    }
+    
+    function buildFlowTestTab(container, node) {
+        var isConfig = (node.type === "flow-test-config");
+        var labelRow = $("<div/>", {
+            class: "form-row"
+        }).appendTo(container);
+        $("<div/>", {
+        }).css({
+            width: "200px"
+        }).text("Events & Actions").appendTo(labelRow);
+        var suiteSelector = null;
+        var suiteInput = null;
+        var suiteAddButton = null;
+        var suiteDelButton = null;
+        var suiteUpdateButton = null;
+        if (!isConfig) {
+            [suiteSelector, suiteInput,
+             suiteAddButton, suiteDelButton, suiteUpdateButton]
+                = buildCaseInputs(container, "suite", "Test Suite");
+        }
+        var [testSelector, testInput,
+             testAddButton, testDelButton, testUpdateButton]
+            = buildCaseInputs(container, "test", "Test Case");
+
+        var eventsContainer = $("<div/>", {
+            class: "form-row"
+        }).css({
+        }).appendTo(container);
+        var eventsTab = $("<ul/>", {
+            id: "node-test-event-tabs"
+        }).css({
+            "min-width": "600px",
+            "margin-bottom": "20px"
+        }).appendTo(eventsContainer);
+        var tabContainer = $("<div/>", {
+            id: "node-test-event-tabs-content"
+        }).css({
+            "min-height": "calc(100% - 95px)"
+        }).appendTo(container);
+        var tabs = RED.tabs.create({
+            id: "node-test-event-tabs",
+            onchange: function(tab) {
+                $("#node-test-event-tabs-content").children().hide();
+                $("#" +tab.id).show();
+                resizeActionList(tab.id);
+            }
+        });
+        var events = [];
+        if (node.type === "flow-test-config") {
+            createEventTab("node-test-event-tab-setup", tabContainer, node); 
+            createEventTab("node-test-event-tab-cleanup", tabContainer, node); 
+            tabs.addTab({
+                id: "node-test-event-tab-setup",
+                label: "setup"
+            });
+            tabs.addTab({
+                id: "node-test-event-tab-cleanup",
+                label: "cleanup"
+            });
+            tabs.activateTab("node-test-event-tab-setup");
+            events = ["setup", "cleanup"];
+        }
+        else {
+            createEventTab("node-test-event-tab-recv", tabContainer, node); 
+            createEventTab("node-test-event-tab-stub", tabContainer, node); 
+            createEventTab("node-test-event-tab-send", tabContainer, node); 
+            tabs.addTab({
+                id: "node-test-event-tab-recv",
+                label: "receive"
+            });
+            tabs.addTab({
+                id: "node-test-event-tab-stub",
+                label: "stub"
+            });
+            tabs.addTab({
+                id: "node-test-event-tab-send",
+                label: "send"
+            });
+            tabs.activateTab("node-test-event-tab-recv");
+            events = ["recv", "stub", "send"];
+        }
+
+        createTestSelector(
+            node,
+            suiteSelector, suiteInput,
+            suiteAddButton, suiteDelButton, suiteUpdateButton,
+            testSelector, testInput,
+            testAddButton, testDelButton, testUpdateButton,
+            selectedTestID, events);
+
+    }
+
+    function buildTestActions(container, node) {
+        buildFlowTestTab(container, node);
+    }
+
+    function handleNodeDialogOpen(opt) {
+        var node = opt.node;
+        if (node.type === "flow-test-config") {
+            buildTestActions($("#test-actions-container"), node);
+            return;
+        }
+        if (node._def.category === "config") {
+            return;
+        }
+        var tabs = opt.tabs;
+        var content = opt.content;
+        var flowTestTab = {
+            id: "editor-tab-flow-test",
+            label: "Flow Test",
+            name: "Flow Test",
+            content: $('<div>', {
+                class: "red-ui-tray-content"
+            }).appendTo(content).hide(),
+            iconClass: "fa fa-check-circle",
+            onchange: function() {
+            }
+        };
+        var dialogForm = $("<form/>", {
+            class: "dialog-form form-hirizontal"
+        }).appendTo(flowTestTab.content);
+
+        buildFlowTestTab(dialogForm, node);
+        tabs.addTab(flowTestTab);
+    }
+
+    function createSidebarContent(div) {
+        content = div;
+        var controlDiv = $("<div/>", {
+            class: "form-row compact"
+        }).css({
+            "margin": "20px 10px"
+        }).appendTo(div);
+        var stackContainer = $("<div/>", {
+        }).appendTo(div);
+        var testsPanel = $("<div/>", {
+            class: "form-row compact"
+        }).appendTo(stackContainer);
+        var logPanel = $("<div/>", {
+            class: "form-row compact"
+        }).appendTo(stackContainer);
+        panels = RED.panels.create({
+            container: stackContainer
+        });
+        panels.ratio(0.7);
+
+        var run = $("<button/>", {
+            class: "red-ui-button red-ui-button-small"
+        }).appendTo(controlDiv);
+        $("<i/>", {
+            class: "fa fa-play"
+        }).appendTo(run);
+        $("<label/>").css({
+            "margin-left": "5px"
+        }).text("Run Tests").appendTo(controlDiv);
+
+        createTestSuites(testsPanel);
+    }
+
+    var currentHeight = undefined;
+
+    function resizeActionList(tabID) {
+        if (currentHeight) {
+            $("#"+tabID+"-list").editableList("height", currentHeight);
+        }
+    }
+
+    function handleNodeDialogResize(opt) {
+        var node = opt.node;
+        if ((node.category === "config") &&
+            (node.type !== "flow-test-config")) {
+            return;
+        }
+        var newHeight = opt.height -200;
+        if (node.type === "flow-test-config") {
+            $("#node-test-event-tab-setup-list").editableList("height", newHeight);
+            $("#node-test-event-tab-cleanup-list").editableList("height", newHeight);
+        }
+        else {
+            $("#node-test-event-tab-recv-list").editableList("height", newHeight);
+            $("#node-test-event-tab-stub-list").editableList("height", newHeight);
+            $("#node-test-event-tab-send-list").editableList("height", newHeight);
+        }
+        currentHeight = newHeight;
+    }
+
+    function typedInputValue(item) {
+        var val = item.typedInput("value");
+        return val;
+    }
+
+    function findTest(suite, tid) {
+        var tests = suite.tests;
+        var test = tests.find(function (x) { return (x.id === tid); });
+        return test;
+    }
+
+    function saveActions(node) {
+        var isGlobal = (node.type === "flow-test-config");
+        var suite = null;
+        var events = null;
+        var nid = null;
+        if (isGlobal) {
+            events = ["setup", "cleanup"];
+            nid = "_global_";
+            suite = node;
+        }
+        else {
+            events = ["recv", "stub", "send"];
+            var sid = $("#flow-test-suite").val();
+            suite = RED.nodes.node(sid);
+            nid = node.id;
+        }
+        var tid = $("#flow-test-test").val();
+        var test = findTest(suite, tid);
+        if (!test) {
+            return;
+        }
+        var actions = test.actions;
+        events.forEach(function (event) {
+            var listID = "node-test-event-tab-" +event +"-list";
+            var list = $("#"+listID).editableList("items");
+            var acts = [];
+            list.each(function (i) {
+                var kind = $(this).find(".action-kind").val();
+                var val = typedInputValue($(this).find(".action-value"));
+                var target = $(this).find(".action-target").val();
+                acts.push({
+                    kind: kind,
+                    value: val,
+                    target: target,
+                });
+            });
+            actions[event][nid] = acts;
+        });
+        RED.nodes.dirty(suite);
+    }
+
+    function handleNodeSave(node) {
+        if (node._def.category === "config") {
+            if (node.type !== "flow-test-config") {
+                return;
+            }
+        }
+        saveActions(node);
+    }
+
+    function handleNodeAdd(node) {
+        if (node.type === "flow-test-config") {
+            addTestSuite(treeRoot, node);
+        }
+    }
+
+    function handleNodeRemove(node) {
+        if (node.type === "flow-test-config") {
+            removeTestSuite(treeRoot, node);
+        }
+    }
+
+    function handleNodeChange(node) {
+        if (node.type === "flow-test-config") {
+        }
+    }
+
+    RED.comms.subscribe("flow-test:notify", function (type, msg) {
+        RED.notify(msg);
+    });
+    
     RED.plugins.registerPlugin("node-red-flow-tester", {
         onadd: function() {
 
             var content = $("<div>").addClass("red-ui-flow-tester");
-            var toolbar = $('<div></div>');
+            var toolbar = $('<div/>');
 
+            createSidebarContent(content);
+            
             RED.sidebar.addTab({
                 id: "flow-tester",
                 label: RED._("node-red-flow-tester/flow-tester:label.flowTesterShort"),
@@ -20,12 +900,26 @@
                 content: content,
                 toolbar: toolbar,
                 enableOnEdit: true,
-                action: "core:show-flow-tester-tab"
+                action: "core:show-flow-tester-tab",
+                onchange: function () {
+                    resizeStack()
+                }
             });
 
-
-            RED.actions.add("flow-tester:show-flow-tester-tab",show);
+            RED.events.on("nodes:add", handleNodeAdd);
+            RED.events.on("nodes:remove", handleNodeRemove);
+            RED.events.on("nodes:change", handleNodeChange);
+            
+            RED.events.on("nodes:dialog-open", handleNodeDialogOpen);
+            RED.events.on("nodes:dialog-resize", handleNodeDialogResize);
+            RED.events.on("editor:save", handleNodeSave);
+            
+            RED.actions.add("flow-tester:show-flow-tester-tab", show);
         }
     });
+
+    $(window).on("resize", resizeStack);
+    $(window).on("focus", resizeStack);
+
 })();
 </script>
diff --git a/src/flow-tester.js b/src/flow-tester.js
index fc1c93d..916d10c 100644
--- a/src/flow-tester.js
+++ b/src/flow-tester.js
@@ -1,7 +1,138 @@
+/**
+ * Copyright JS Foundation and other contributors, http://js.foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ **/
+
 module.exports = (RED) => {
+
+    let checks = [];
+    let checkSend = {};
+
+    function message(msg) {
+        RED.comms.publish("flow-test:notify", msg);
+    }
+    
+    function init() {
+        checks = [];
+        checkSend = {};
+
+        RED.hooks.add("onSend.flow-test", (events, done) => {
+            events.forEach((event) => {
+                const src = event.source;
+                const msg = event.msg;
+                const sendCB = checkSend[src.id];
+                if (sendCB) {
+                    sendCB(msg);
+                }
+            });
+            done();
+        });
+        return Promise.resolve(true);
+    }
+
+    function start() {
+        Promise.all(checks).then((results) => {
+            if (results.find(v => (v !== true)) === undefined) {
+                message("test success");
+            }
+            else {
+                message("test failed");
+            }
+        }).catch((e) => {
+            message("test failed");
+        });
+        return Promise.resolve(true);
+    }
+    
+    function cleanup() {
+        RED.hooks.remove("onSend.flow-test");
+        return Promise.resolve(true);
+    }
+
+    function executeSend(target, value) {
+        const node = RED.nodes.getNode(target);
+        node.receive({
+            payload: value
+        });
+        return Promise.resolve(true);
+    }
+
+    function initMatch(nid, value) {
+        let resolve = null;
+        let reject = null;
+        const promise = new Promise((resolve_, reject_) => {
+            resolve = resolve_;
+            reject = reject_;
+        });
+        checkSend[nid] = (msg) => {
+            if (msg && (msg.payload === value)) {
+                resolve(true);
+            }
+            else {
+                resolve(false);
+            }
+        };
+        checks.push(promise);
+        return Promise.resolve(true);
+    }
+
     RED.plugins.registerPlugin('node-red-flow-tester', {
         settings: {
             "*": { exportable: true }
+        },
+        onadd: () => {
+            const routeAuthHandler = RED.auth.needsPermission("flow-tester.write");
+            RED.httpAdmin.post(
+                "/flow-tester/executeAction/:action",
+                routeAuthHandler,
+                (req, res) => {
+                    const kind = req.params.action;
+                    const opt = req.body;
+                    let promise = Promise.resolve(null);
+                    switch (kind) {
+                    case "init":
+                        promise = init();
+                        break;
+                    case "start":
+                        promise = start();
+                        break;
+                    case "cleanup":
+                        promise = cleanup();
+                        break;
+                    case "send":
+                        promise = executeSend(opt.target, opt.value);
+                        break;
+                    case "matchInit":
+                        promise = initMatch(opt.node, opt.value);
+                        break;
+                    case "press":
+                    case "match":
+                    case "recv":
+                    case "set": 
+                    case "wait":
+                    case "function":
+                    default:
+                        console.log("unexpected action kind: ", kind);
+                        break;
+                    }
+                    promise.then((result) => {
+                        res.json(result);
+                    }).catch((err) => {
+                        res.sendStatus(400);
+                    });
+                });
         }
     });
+
 };
diff --git a/src/style.css b/src/style.css
index a4c0fb7..160bedc 100644
--- a/src/style.css
+++ b/src/style.css
@@ -3,5 +3,21 @@
     height: 100%;
     display: flex;
     flex-direction: column;
-    background: red;
 }
+
+.red-ui-suite-label {
+}
+
+.red-ui-suite-label-control {
+    position: absolute;
+    top: 0px;
+    right: 0px;
+    margin-top: 5px;
+    margin-right: 5px;
+    display: none;
+}
+
+.red-ui-suite-label:hover .red-ui-suite-label-control {
+    display: inline;
+}
+

From bddb096187ca7cd05268ad64075c6f8996c3422b Mon Sep 17 00:00:00 2001
From: Hiroyasu Nishiyama <hiroyasu.nishiyama.uq@hitachi.com>
Date: Wed, 1 Sep 2021 20:06:30 +0900
Subject: [PATCH 2/9] remove license

---
 nodes/flow-test-config.html | 16 ----------------
 nodes/flow-test-config.js   | 16 ----------------
 src/flow-tester.html        | 16 ----------------
 src/flow-tester.js          | 17 +----------------
 4 files changed, 1 insertion(+), 64 deletions(-)

diff --git a/nodes/flow-test-config.html b/nodes/flow-test-config.html
index 4324532..29adc2e 100644
--- a/nodes/flow-test-config.html
+++ b/nodes/flow-test-config.html
@@ -1,19 +1,3 @@
-<!--
-  Copyright JS Foundation and other contributors, http://js.foundation
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
--->
-
 <!--
      UI and related operations are defined in flow tester
 -->
diff --git a/nodes/flow-test-config.js b/nodes/flow-test-config.js
index 3207cfd..5eaa6d5 100644
--- a/nodes/flow-test-config.js
+++ b/nodes/flow-test-config.js
@@ -1,19 +1,3 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-
 module.exports = function(RED) {
     "use strict";
 
diff --git a/src/flow-tester.html b/src/flow-tester.html
index 4a139a0..f6810fa 100644
--- a/src/flow-tester.html
+++ b/src/flow-tester.html
@@ -1,19 +1,3 @@
-<!--
-  Copyright JS Foundation and other contributors, http://js.foundation
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
--->
-
 <link rel="stylesheet" href="resources/node-red-flow-tester/style.css">
 
 <script type="text/javascript">
diff --git a/src/flow-tester.js b/src/flow-tester.js
index 916d10c..d828133 100644
--- a/src/flow-tester.js
+++ b/src/flow-tester.js
@@ -1,19 +1,3 @@
-/**
- * Copyright JS Foundation and other contributors, http://js.foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- **/
-
 module.exports = (RED) => {
 
     let checks = [];
@@ -69,6 +53,7 @@ module.exports = (RED) => {
     }
 
     function initMatch(nid, value) {
+        console.log("; initMatch: ", nid, value);
         let resolve = null;
         let reject = null;
         const promise = new Promise((resolve_, reject_) => {

From 7dbbe6401bb3ea2ee82f1dd319475a6a47b7d80a Mon Sep 17 00:00:00 2001
From: Hiroyasu Nishiyama <hiroyasu.nishiyama.uq@hitachi.com>
Date: Wed, 1 Sep 2021 20:23:14 +0900
Subject: [PATCH 3/9] add description of runtime actions

---
 src/flow-tester.html |  2 +-
 src/flow-tester.js   | 13 +++++++++++--
 2 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/src/flow-tester.html b/src/flow-tester.html
index f6810fa..96ad124 100644
--- a/src/flow-tester.html
+++ b/src/flow-tester.html
@@ -29,7 +29,7 @@
 
     function invokeAction(kind, opt) {
         return $.ajax({
-            url: "/flow-tester/executeAction/"+ kind,
+            url: "flow-tester/executeAction/"+ kind,
             type: "POST",
             contentType: "application/json",
             data: JSON.stringify(opt)
diff --git a/src/flow-tester.js b/src/flow-tester.js
index d828133..e116b07 100644
--- a/src/flow-tester.js
+++ b/src/flow-tester.js
@@ -87,26 +87,35 @@ module.exports = (RED) => {
                     let promise = Promise.resolve(null);
                     switch (kind) {
                     case "init":
+                        // initialize runtime part of flow-tester plugin
                         promise = init();
                         break;
                     case "start":
+                        // waits for completion of tests
                         promise = start();
                         break;
                     case "cleanup":
+                        // cleanup runtime part of flow-tester plugin
                         promise = cleanup();
                         break;
                     case "send":
+                        // send a message to specified node
                         promise = executeSend(opt.target, opt.value);
                         break;
                     case "matchInit":
+                        // register callback for checking output messages  
                         promise = initMatch(opt.node, opt.value);
                         break;
                     case "press":
-                    case "match":
+                        // press the button of target node
                     case "recv":
-                    case "set": 
+                        // receive a message from input port
+                    case "set":
+                        // set context or environment variable
                     case "wait":
+                        // wait for specified time
                     case "function":
+                        // execute JavaScript code
                     default:
                         console.log("unexpected action kind: ", kind);
                         break;

From c88a60160bee8d2d6ff893383e117568431e3e4d Mon Sep 17 00:00:00 2001
From: Hiroyasu Nishiyama <hiroyasu.nishiyama.uq@hitachi.com>
Date: Mon, 15 Nov 2021 14:04:16 +0900
Subject: [PATCH 4/9] merge initial prototype

---
 bin/README.md               |   27 +
 bin/flow-test.js            |   88 +++
 nodes/flow-test-config.html |    3 +-
 nodes/flow-test-config.js   |    2 +
 nodes/package.json          |   21 -
 package.json                |   11 +-
 src/flow-tester.html        | 1438 +++++++++++++++++++++++++++--------
 src/flow-tester.js          |  747 +++++++++++++++---
 8 files changed, 1914 insertions(+), 423 deletions(-)
 create mode 100644 bin/README.md
 create mode 100644 bin/flow-test.js
 delete mode 100644 nodes/package.json

diff --git a/bin/README.md b/bin/README.md
new file mode 100644
index 0000000..ef79ffe
--- /dev/null
+++ b/bin/README.md
@@ -0,0 +1,27 @@
+Simple command line tool for runnning test cases. 
+
+1. listing list of test cases
+
+```
+% node flow-test.js [--list|-l] [[--target|-t] URL]
+```
+
+show list of test cases on Node-RED instance specified by *URL*.
+
+Example:
+```
+% node bin/flow-test.js --list
+Sample - Global
+  0: test click
+  1: test send
+  2: test wait
+  3: test function
+```
+
+2. running a test case
+
+```
+% node flow-test.js [--run|-r] no [[--target|-t] URL]
+```
+
+run the test case specified by *no* on Node-RED instance specified by *URL*.
diff --git a/bin/flow-test.js b/bin/flow-test.js
new file mode 100644
index 0000000..cfc1396
--- /dev/null
+++ b/bin/flow-test.js
@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+'use strict'
+
+const nopt = require("nopt");
+const got = require("got");
+
+function parseArgs(args) {
+    const knownOpts = {
+        target: String,
+        list: Boolean,
+        run: String
+    };
+    const shortHands = {
+        't': ["--target"],
+        'l': ["--list"],
+        'r': ["--run"]
+    };
+    return nopt(knownOpts, shortHands, args, 2);
+}
+
+
+async function getList(target) {
+    const url = `${target}/flow-tester/testCase`;
+    try {
+        const res = await got(url);
+        const body = JSON.parse(res.body);
+        return body;
+    }
+    catch (err) {
+        console.log(err);
+    }
+}
+
+async function doList(target) {
+    const list = await getList(target);
+    let id = 0;
+    list.forEach((tcase) => {
+        console.log(`${tcase.name}`);
+        const tests = tcase.tests;
+        tests.forEach((test) => {
+            console.log(`  ${id}: ${test.name}`);
+            id++;
+        });
+    });
+}
+
+async function doRun(target, no) {
+    try {
+        const cases = await getList(target);
+        let id = 0;
+        for (let tcase of cases) {
+            const tests = tcase.tests;
+            for (let test of tests) {
+                if (id === no) {
+                    const url = `${target}/flow-tester/runTestCase/${tcase.id}/${test.id}`;
+                    const res = await got(url);
+                    const body = JSON.parse(res.body);
+                    return body;
+                }
+                id++;
+            }
+        }
+    }
+    catch (err) {
+        console.log(err);
+        return undefined;
+    }
+}
+
+async function main(args) {
+    const opts = parseArgs(args);
+    let target = "http://localhost:1880";
+    if (opts.target) {
+        target = opts.target;
+    }
+    if (opts.list) {
+        await doList(target);
+    }
+    if (opts.run) {
+        const res = await doRun(target, Number(opts.run));
+        console.log(JSON.stringify(res, null, "\t"));
+    }
+}
+
+
+(async () => {
+    main(process.argv);
+})();
diff --git a/nodes/flow-test-config.html b/nodes/flow-test-config.html
index 29adc2e..5f9141c 100644
--- a/nodes/flow-test-config.html
+++ b/nodes/flow-test-config.html
@@ -21,7 +21,8 @@
         category: "config",		// category of node
         defaults: {
             name: { value: "" },
-            tests: { tests: [] },
+            tests: { value: [] },
+            currentTest: { value: null },
         },
         label: function() {
             return this.name || "flow test";
diff --git a/nodes/flow-test-config.js b/nodes/flow-test-config.js
index 5eaa6d5..81c3303 100644
--- a/nodes/flow-test-config.js
+++ b/nodes/flow-test-config.js
@@ -5,6 +5,8 @@ module.exports = function(RED) {
         RED.nodes.createNode(this, n);
         const node = this;
         node.name = n.name;
+        node.tests = n.tests;
+        node.currentTest = n.currentTest;
     }
     
     RED.nodes.registerType("flow-test-config", FlowTestConfig);
diff --git a/nodes/package.json b/nodes/package.json
deleted file mode 100644
index 5578f7a..0000000
--- a/nodes/package.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-    "name": "node-red-flow-test",
-    "version": "0.0.1",
-    "description": "Node-RED node for Flow Test",
-    "node-red": {
-        "nodes": {
-            "flow-test-config": "flow-test-config.js"
-        }
-    },
-    "license": "Apache 2.0",
-    "keywords": [
-        "node-red"
-    ],
-    "author": {
-        "name": "Hiroyasu Nishiyama",
-        "email": "hiroyasu.nishiyama.uq@hitachi.com"
-    },
-    "dependencies": {},
-    "devDependencies": {
-    }
-}
diff --git a/package.json b/package.json
index a4fa2e9..8425ee9 100644
--- a/package.json
+++ b/package.json
@@ -24,8 +24,17 @@
         "version": ">=2.0.0",
         "plugins": {
             "flow-tester": "dist/flow-tester.js"
-        }
+        },
+	"nodes": {
+            "flow-test-config": "nodes/flow-test-config.js"
+	}
     },
+    "contributors": [
+        {
+            "name": "Hiroyasu Nishiyama",
+            "email": "hiroyasu.nishiyama.uq@hitachi.com"
+	}
+    ],
     "devDependencies": {
         "fs-extra": "^10.0.0",
         "html-minifier": "^4.0.0",
diff --git a/src/flow-tester.html b/src/flow-tester.html
index 96ad124..e9d0499 100644
--- a/src/flow-tester.html
+++ b/src/flow-tester.html
@@ -6,18 +6,46 @@
     var panels = null;
     var treeList = null;
     var treeRoot = null;
-
-    var suites = {};
-    var testID = 0;
+    var logContainer = null;
+    var logEditor = null;
+    var currentHeight = undefined;
 
     var suiteCount = 0;
+    var suites = [];
+    var id2suite = {};
+    var id2test = {};
     
     var selectedTestID = undefined;
+
+    var currentTestSuite = null;
+    var currentTestCase = null;
+    var testResult = {
+        success: 0,
+        fail: 0
+    };
+    var numberOfChecks = 0;
+    var currentTimeout = null;
+
+    var workComplete = (function () {});
+
+    var currentExecution = Promise.resolve();
     
+    var MAX_LOG = 1000;
+    var logs = [];
+
+    var TIMEOUT = 10;    	// timeout period of flow execution
+    var MAX_ACTIONS = 500;  // max number of actions 
+
+    /**
+     *  Show flow-tester sidebar
+     */
     function show() {
         RED.sidebar.show("flow-tester");
     }
 
+    /**
+     *  Resize sidebar contents
+     */
     function resizeStack() {
         var h = $(content).parent().height();
         panels.resize(h);
@@ -27,103 +55,208 @@
         });
     }
 
+    /**
+     *  Invoke flow-tester action on runtime
+     *  @param {string} kind - kind of action
+     *  @param {Object} opt - options of the action
+     *  @returns {Promise} 
+     */
     function invokeAction(kind, opt) {
-        return $.ajax({
-            url: "flow-tester/executeAction/"+ kind,
-            type: "POST",
-            contentType: "application/json",
-            data: JSON.stringify(opt)
+        return new Promise(function (resolve, reject) {
+            $.ajax({
+                url: "flow-tester/executeAction/"+ kind,
+                type: "POST",
+                contentType: "application/json",
+                data: JSON.stringify(opt || {})
+            }).done(function (data) {
+                resolve();
+            }).fail(function (xhr, stat, err) {
+                console.log(err);
+                reject();
+            });
         });
     }
-    
-    function executeAction(id, action, suiteNode, testCase) {
-        switch (action.kind) {
-        case "send":
-            invokeAction("send", {
-                target: action.target,
-                value: action.value
-            });
-            break;
-        case "press":
-        case "recv":
-        case "set": 
-        case "match":
-        case "wait":
-        case "function":
-        default:
-            throw new Error("unexpected kind of action: " +action.kind);
-            break;
-        }
+
+    /**
+     *  Invoke registerActions action on runtime
+     *  @param {string} sid - test suite id
+     *  @param {string} tid - test id
+     *  @param {string} event - event name
+     *  @param {array} actions - array of action definitions
+     *  @returns {Promise}
+     */ 
+    function registerActions(sid, tid, event, actions) {
+        return invokeAction("registerActions", {
+            suiteID: sid,
+            testID: tid,
+            event: event,
+            actions: actions
+        });
     }
-    
-    function initAction(id, action, suiteNode, testCase) {
-        switch (action.kind) {
-        case "send":
-            // nothing to do
-            break;
-        case "match":
-            invokeAction("matchInit", {
-                node: id,
-                value: action.value
-            });
-            break;
-        case "press":
-        case "recv":
-        case "set": 
-        case "wait":
-        case "function":
-        default:
-            throw new Error("unexpected kind of action: " +action.kind);
-            break;
+
+    /**
+     *  Count number of expected checks for test case
+     *  @param {Object} map - action definition
+     *  @returns {Number} number of checks
+     */
+    function countNumberOfChecks(map) {
+        var count = 0;
+        var events = Object.keys(map);
+        for (let event of events) {
+            var evMap = map[event];
+            var nodes = Object.keys(evMap);
+            for (let node of nodes) {
+                var acts = evMap[node];
+                for (let act of acts) {
+                    if ((act.kind === "match") ||
+                        ((act.kind === "function") &&
+                         act.performCheck)) {
+                        count++;
+                    }
+                }
+            }
         }
+        return count;
     }
-    
+
+    /**
+     *  Execute a test case
+     *  @param {Object} suiteNode - config node for test suite
+     *  @param {Object} testCase - test case definition
+     *  @returns {Promise} promise for executing test actions
+     */
     function executeTestCase(suiteNode, testCase) {
-        var actions = testCase.actions || {};
-        
-        invokeAction("init", {});
-        
-        var events = Object.keys(actions);
-        events.forEach(function (event) {
-            var eventActions = actions[event];
-            var handlerIDs = Object.keys(eventActions);
-            handlerIDs.forEach(function (id) {
-                var initActions = eventActions[id];
-                initActions.forEach(function (action) {
-                    initAction(id, action, suiteNode, testCase)
-                });
-            });
+        let actions = testCase.actions || {};
+        let sid = suiteNode.id;
+        let tid = testCase.id;
+        let maxActions = (testCase.max_actions || MAX_ACTIONS);
+        let waitPromise = new Promise((resolve, reject) => {
+            workComplete = resolve;
         });
 
-        invokeAction("start", {});
+        return Promise.resolve().then(function () {
+            currentTestSuite = sid;
+            currentTestCase = tid;
 
-        var setupActions = actions.setup._global_ || [];
-        setupActions.forEach(function (action) {
-            executeAction("_global_", action, suiteNode, testCase)
-        });
+            numberOfChecks = countNumberOfChecks(actions);
+
+            testResult.success = 0;
+            testResult.fail = 0;
 
-        invokeAction("cleanup", {});
+            addLog("Running test: " +testCase.name);
+            return invokeAction("init", {});
+        }).then(function () {
+            let promise = Promise.resolve();
+            let events = Object.keys(actions);
+            for (let event of events) {
+                promise = promise.then(function () {
+                    return registerActions(sid, tid,
+                                           event,
+                                           actions[event]);
+                });
+            }
+            return promise;
+        }).then(function () {
+            return invokeAction("setup", {
+                maxActions: maxActions
+            });
+        }).then(function () {
+            let timeout = (testCase.timeout || TIMEOUT) *1000;
+            currentTimeout = setTimeout(function () {
+                addLog(`- timeout occured: ${testCase.timeout}s`);
+                invokeAction("cleanup").then(function () {
+                    workComplete();
+                });
+            }, timeout);
+            return waitPromise;
+        }).catch(function (e) {
+            invokeAction("cleanup").then(function () {
+                workComplete();
+            });
+        });
+        return currentExecution;
     }
 
-    function addTestCase(suite, newTest) {
+    /**
+     *  Add new test case
+     *  @param {Object} suiteNode - config node for test suite
+     *  @param {Object} newTest - definition of new test case
+     */
+    function addTestCase(suiteNode, newTest) {
         var tid = newTest.id;
         var name = newTest.name;
+        var sid = suiteNode.id;
+        var suite = id2suite[sid];
         var treelist = suite.element.treeList;
-        var suiteNode = suite.node;
         var test = {
             element: getTestCaseLabel(tid, name, suiteNode, newTest),
             icon: "fa fa-file-text-o",
         };
         treelist.addChild(test);
         treelist.expand();
+        id2test[tid] = test;
     }
 
+
+    /**
+     *  Newly creates internal test case id
+     *  @returns {string} new test case id
+     */
+    function newTestID() {
+        var id = "T"+Math.random().toString(32).substring(2);
+        return id;
+    }
+
+    /**
+     *  Create new test case
+     *  @param {Object} suiteNode - config node for test suite
+     *  @param {string} name - name of the test case
+     *  @returns {Object} definition of new test case
+     */
+    function createNewTest(suiteNode, name) {
+        var id = suiteNode.id;
+        var tests = suiteNode.tests;
+        var tid = newTestID();;
+        if (!name) {
+            name = "";
+        }
+        var newTest = {
+            id: tid,
+            name: name,
+            suite: id,
+            timeout: TIMEOUT,
+            max_actions: MAX_ACTIONS,
+            actions: {
+                // test specific events
+                setup: {},
+                cleanup: {},
+                // node specific events
+                recv: {},
+                stub: {},
+                send: {},
+            }, 
+        };
+        tests.push(newTest);
+        addTestCase(suiteNode, newTest);
+        return newTest;
+    }
+
+    /**
+     *  Creates test sute label for TreeList widget
+     *  @param {string} id - test suite id
+     *  @param {string} name - test suite name 
+     *  @param {Object} suiteNode - config node for test suite
+     *  @returns {Object} DOM element
+     */
     function getSuiteLabel(id, name, suiteNode) {
         var div = $("<div/>", {
             class: "red-ui-suite-label"
         }).css({
         });
-        var contentDiv = $("<div/>", {
+        var labelDiv = $("<div/>", {
+            class: "test-suite-label"
+        }).css({
+            "min-height": "20px",
         }).text(name).appendTo(div);
         var controls = $("<div/>", {
             class: "red-ui-suite-label-control",
@@ -149,28 +282,8 @@
         $(addButton).on("click", function (ev) {
             ev.preventDefault();
             ev.stopPropagation();
-            var suite = suites[id];
-            var suiteNode = suite.node;
-            var tests = suiteNode.tests;
-            var name = "New Test " +testID;
-            var tid = "T" +testID;
-            testID++;
-            var newTest = {
-                id: tid,
-                name: name,
-                suite: id,
-                actions: {
-                    // test specific events
-                    setup: {},
-                    cleanup: {},
-                    // node specific events
-                    recv: {},
-                    stub: {},
-                    send: {},
-                }, 
-            };
-            tests.push(newTest);
-            addTestCase(suite, newTest);
+            var suite = id2suite[id];
+            createNewTest(suite.node, "New Test");
         });
         $(editButton).on("click", function (ev) {
             ev.preventDefault();
@@ -180,12 +293,23 @@
         return div;
     }
 
+    /**
+     *  Creates test case label for TreeList widget
+     *  @param {string} id - test case id
+     *  @param {string} name - test case name 
+     *  @param {Object} suiteNode - config node for test suite
+     *  @param {Object} testCase - test case definition
+     *  @returns {Object} DOM element
+     */
     function getTestCaseLabel(id, name, suiteNode, testCase) {
         var div = $("<div/>", {
             class: "red-ui-suite-label"
         }).css({
         });
-        var contentDiv = $("<div/>", {
+        $("<div/>", {
+            class: "test-case-label"
+        }).css({
+            "min-height": "20px",
         }).text(name).appendTo(div);
         var controls = $("<div/>", {
             class: "red-ui-suite-label-control",
@@ -225,6 +349,11 @@
     }
 
 
+    /**
+     *  Add new test suite to TreeList
+     *  @param {Object} root - root of TreeList
+     *  @param {Object} suite - config node for test suite
+     */
     function addTestSuite(root, suite) {
         var id = suite.id;
         var name = suite.name;
@@ -233,24 +362,59 @@
             icon: "fa fa-briefcase",
             children: []
         };
-        suites[id] = {
+        var newSuite = {
             id: id,
             node: suite,
             element: element,
         };
+        id2suite[id] = newSuite;
+        suites.push(newSuite);
+        
         root.treeList.addChild(element);
         var tests = suite.tests || [];
-        tests.forEach(function (test) {
-            addTestCase(suites[id], test);
-        });
+        for (let test of tests) {
+            addTestCase(id2suite[id].node, test);
+        }
     }
 
 
-    function removeTestSuite(root, node) {
-        var suite = suites[node.id];
+    /**
+     *  Remove test suite
+     *  @param {string} id - test suite id 
+     */
+    function removeTestSuite(id) {
+        var suite = id2suite[id];
         suite.element.treeList.remove();
+        delete id2suite[id];
+        suites = suites.filter(function (s) {
+            return (s.id !== id);
+        });
     }
-    
+
+    /**
+     *  Remove test case
+     *  @param {string} sid - test suite id
+     *  @param {string} id - test case id
+     *  @returns {array} array of new test case definitions
+     */
+    function removeTestCase(sid, id) {
+        var suite = id2suite[sid];
+        var node = suite.node;
+        var tests = node.tests;
+        var newTests = tests.filter(function (c) {
+            return c.id !== id;
+        });
+        var test = id2test[id];
+        test.treeList.remove();
+        delete id2test[id];
+        node.tests = newTests;
+        return newTests;
+    }
+
+    /**
+     *  Creates new test suite
+     *  @param {Object} root - root of TreeList
+     */
     function addNewTestSuite(root) {
         var def = RED.nodes.getType("flow-test-config");
         var name = "Test Suite " +suiteCount++;
@@ -266,7 +430,11 @@
         RED.nodes.add(testNode);
         RED.nodes.dirty(true);
     }
-    
+
+    /**
+     *  Create side bar view for test suites
+     *  @param {Object} testPanel - DOM element for test suites
+     */
     function createTestSuites(testsPanel) {
         var labelDiv = $("<div/>", {
             class: "form-row compact"
@@ -293,6 +461,7 @@
         treeRoot = root;
         addSuiteButton.on("click", function (ev) {
             ev.preventDefault();
+            ev.stopPropagation();
             addNewTestSuite(root);
         });
 
@@ -301,7 +470,22 @@
         });
     }
 
+    /**
+     *  Check that specified node belongs to a flow 
+     *  @param {Object} node - node to be checked
+     *  @returns {boolean} true if the node belongs to a flow 
+     */
+    function isMemberOfFlow(node) {
+        var sf = RED.nodes.subflow(node.z);
+        return (!sf);
+    }
 
+    /**
+     *  Create a tab for setting event information
+     *  @param {string} id - ID of DOM element
+     *  @param {Object} container - enclosing DOM element
+     *  @param {Object} node - target node 
+     */
     function createEventTab(id, container, node) {
         var div = $("<div/>", {
             id: id
@@ -317,6 +501,7 @@
         }).editableList({
             addItem: function(con, i, opt) {
                 var row0 = $("<div/>", {
+                    class: "form-row"
                 }).css({
                 }).appendTo(con);
                 var row1 = $("<div/>", {
@@ -324,8 +509,18 @@
                 }).css({
                     "margin-top": "3px"
                 }).appendTo(con);
+                var row2 = $("<div/>", {
+                    hidden: true
+                }).css({
+                    "margin-top": "3px"
+                }).appendTo(con);
+                var row3 = $("<div/>", {
+                    hidden: true
+                }).css({
+                    "margin-top": "3px"
+                }).appendTo(con);
                 
-                var kind = $("<select>", {
+                var kind = $("<select/>", {
                     class: "action-kind"
                 }).css({
                     width: "100px",
@@ -334,23 +529,27 @@
                     "margin-left": "5px",
                     "margin-bottom": "0px",
                 }).appendTo(row0);
-                var actions = [
-                    "send", "press", "recv", "set", 
-                    "match", "wait", "function"
-                ];
-                actions.forEach(function (action) {
+                var actions =
+                    (node.type === "flow-test-config") ? [
+                        "click", "send", "wait", "function"
+                    ] : [
+                        "click", "send", "set", "match", "wait", "function"
+                    ];
+                for (let action of actions) {
                     $("<option/>", {
                     }).val(action).text(action).appendTo(kind);
-                });
+                }
+                $(kind).val("click");
 
-                var val = $("<input/>", {
+                var valSpan = $("<span/>").appendTo(row0);
+                var valField = $("<input/>", {
                     class: "action-value"
                 }).css({
                     display: "inline-block",
                     "margin-left": "8px",
                     width: "calc(100% - 130px)"
-                }).appendTo(row0);
-                $(val).typedInput({
+                }).appendTo(valSpan);
+                $(valField).typedInput({
                     default: "str",
                     types: [
                         "str", "num", "bool", "json", "bin",
@@ -358,50 +557,272 @@
                     ]
                 });
 
+                var clickTargetSpan = $("<span/>").appendTo(row0);
+                var clickTarget = $("<select/>", {
+                    class: "action-click-target"
+                }).css({
+                    "margin-left": "13px",
+                    "margin-bottom": "0px"
+                }).appendTo(clickTargetSpan);
+
+                var numSpan = $("<span/>").appendTo(row0);
+                var numField = $("<input/>", {
+                    class: "action-wait-ms"
+                }).css({
+                    "margin-left": "13px",
+                    width: "100pt"
+                }).appendTo(numSpan);
+                $(numField).typedInput({
+                    default: "num",
+                    types: [
+                        "num"
+                    ]
+                });
+                $("<label/>", {
+                }).css({
+                    "text-align": "left",
+                    width: "100px",
+                    "margin-left": "5px"
+                }).text("ms").appendTo(numSpan);
+
+                var varSpan = $("<span/>").appendTo(row0);
+                var varField = $("<input/>", {
+                    class: "action-var"
+                }).css({
+                    display: "inline-block",
+                    "margin-left": "8px",
+                    width: "calc(100% - 130px)"
+                }).appendTo(varSpan);
+                $(varField).typedInput({
+                    default: "flow",
+                    types: [
+                        "flow", "global"
+                    ]
+                });
+
+                var jsSpan = $("<span/>").appendTo(row0);
+                var jsField = $("<input/>", {
+                    class: "action-js"
+                }).css({
+                    display: "inline-block",
+                    "margin-left": "8px",
+                    width: "calc(100% - 130px)"
+                }).appendTo(jsSpan);
+                $(jsField).typedInput({
+                    default: "js",
+                    types: [
+                        {
+                            value: "js",
+                            label: "JavaScript",
+                            icon: "fa fa-edit",
+                            hasValue: true,
+                            expand: function () {
+                                var that = this;
+                                RED.editor.editJavaScript({
+                                    value: this.value().replace(/\t/g, "\n"),
+                                    complete: function (v) {
+                                        that.value(v.replace(/\n/g, "\t"));
+                                    }
+                                });
+                            }
+                        }
+                    ]
+                });
+                var checkInJS = $("<input/>", {
+                    type: "checkbox",
+                    class: "action-js-perform-check"
+                }).css({
+                    width: "fit-content",
+                    "margin-left": "120px"
+                }).appendTo(row3);
+                $("<span/>").css({
+                    "margin-left": "8px"
+                }).text("performs check").appendTo(row3);
+
                 $("<label/>", {
                 }).css({
                     display: "inline-block",
                     "text-align": "right",
                     width: "100px"
                 }).text("to").appendTo(row1);
-                var target = $("<select/>", {
-                    class: "action-target"
+                var sendTarget = $("<select/>", {
+                    class: "action-send-target"
                 }).css({
                     "margin-left": "13px"
                 }).appendTo(row1);
 
+                $("<label/>", {
+                }).css({
+                    display: "inline-block",
+                    "text-align": "right",
+                    width: "100px"
+                }).text("to the value").appendTo(row2);
+                var valFieldSet = $("<input/>", {
+                    class: "action-value-set"
+                }).css({
+                    display: "inline-block",
+                    "margin-left": "13px",
+                    width: "calc(100% - 160px)"
+                }).appendTo(row2);
+                $(valFieldSet).typedInput({
+                    default: "str",
+                    types: [
+                        "str", "num", "bool", "json", "bin",
+                        "re", "date", "jsonata", "env"
+                    ]
+                });
+
+                // node label for selection menu
+                function nodeLabel(node) {
+                    const name = node.type +":" +node.id;
+                    if (node.name && (node.name !== "")) {
+                        return (node.name +" [" +name +"]");
+                    }
+                    return name;
+                }
+
+                var sendNodes = RED.nodes.filterNodes({
+                }).filter(function (n) {
+                    return (isMemberOfFlow(n) &&
+                            (n.inputs > 0));
+                });;
+                $(sendTarget).empty();
+                for (let node of sendNodes) {
+                    var id = node.id;
+                    var name = nodeLabel(node);
+                    $("<option/>").text(name).val(id).appendTo(sendTarget);
+                }
+
+                var clickNodes = RED.nodes.filterNodes({
+                }).filter(function (n) {
+                    return (isMemberOfFlow(n) &&
+                            (n.inputs === 0) &&
+                            n._def.hasOwnProperty("button"))
+                });
+                $(clickTarget).empty();
+                for (let node of clickNodes) {
+                    var id = node.id;
+                    var name = nodeLabel(node);
+                    $("<option/>").text(name).val(id).appendTo(clickTarget);
+                }
+
+                if (opt) {
+                    var act_kind = opt.kind;
+                    if (act_kind) {
+                        $(kind).val(act_kind);
+                        switch (act_kind) {
+                        case "send":
+                            var act_val = opt.value;
+                            if (act_val) {
+                                $(valField).typedInput("value", act_val);
+                            }
+                            var act_target = opt.target;
+                            if (act_target) {
+                                $(sendTarget).val(act_target);
+                            }
+                            break;
+                        case "click":
+                            var act_target = opt.target;
+                            if (act_target) {
+                                $(clickTarget).val(act_target);
+                            }
+                            break;
+                        case "set":
+                            var act_dst = opt.dst;
+                            if (act_dst &&
+                                act_dst.hasOwnProperty("type") &&
+                                act_dst.hasOwnProperty("value")) {
+
+                                $(varField).typedInput("type", act_dst.type);
+                                $(varField).typedInput("value", act_dst.value);
+                            }
+                            var act_src = opt.src;
+                            if (act_src &&
+                                act_src.hasOwnProperty("type") &&
+                                act_src.hasOwnProperty("value")) {
+                                $(valFieldSet).typedInput("type", act_src.type);
+                                $(valFieldSet).typedInput("value", act_src.value);
+                            }
+                            break;
+                        case "match":
+                            if (opt.hasOwnProperty("value")) {
+                                $(valField).typedInput("value", opt.value);
+                            }
+                            break;
+                        case "wait":
+                            if (opt.hasOwnProperty("wait")) {
+                                $(numField).typedInput("value", opt.wait);
+                            }
+                            break;
+                        case "function":
+                            if (opt.code) {
+                                $(jsField).typedInput("value", opt.code);
+                            }
+                            checkInJS.prop("checked", !!opt.performCheck);
+                            break;
+                        default:
+                            throw new Error("unexpected kind of action: " +kind);
+                            break;
+                        }
+                    }
+                }
+
                 $(kind).on("change", function (ev) {
+                    $(row1).hide();
+                    $(row2).hide();
+                    $(row3).hide();
+
                     var val = $(kind).val();
-                    if ((val === "press") ||
-                        (val === "send")) {
+                    if(val === "send") {
+                        $(valSpan).show();
+                        $(varSpan).hide();
+                        $(clickTargetSpan).hide();
+                        $(numSpan).hide();
+                        $(jsSpan).hide();
                         $(row1).show();
-                        var nodes = RED.nodes.filterNodes({});
-                        $(target).empty();
-                        nodes.forEach(function (node) {
-                            var id = node.id;
-                            var name = "["+ node.id +":" +node.type +"]" +node.name;
-                            $("<option/>", {
-                            }).css({
-                            }).text(name).val(id).appendTo(target);
-                        });
                     }
-                    else {
-                        $(row1).hide();
+                    else if (val === "click") {
+                        $(valSpan).hide();
+                        $(varSpan).hide();
+                        $(clickTargetSpan).show();
+                        $(numSpan).hide();
+                        $(jsSpan).hide();
                     }
-                });
-
-                $(kind).val("send");
-                if (opt) {
-                    if (opt.kind) {
-                        $(kind).val(opt.kind);
+                    else if (val === "set") {
+                        $(valSpan).hide();
+                        $(varSpan).show();
+                        $(clickTargetSpan).hide();
+                        $(numSpan).hide();
+                        $(jsSpan).hide();
+                        $(row2).show();
                     }
-                    if (opt.value) {
-                        $(val).typedInput("value", opt.value);
+                    else if (val === "match") {
+                        $(valSpan).show();
+                        $(varSpan).hide();
+                        $(clickTargetSpan).hide();
+                        $(numSpan).hide();
+                        $(jsSpan).hide();
                     }
-                    if (opt.target) {
-                        $(target).val(opt.target);
+                    else if (val === "wait") {
+                        $(valSpan).hide();
+                        $(varSpan).hide();
+                        $(clickTargetSpan).hide();
+                        $(numSpan).show();
+                        $(jsSpan).hide();
                     }
-                }
+                    else if (val === "function") {
+                        $(valSpan).hide();
+                        $(varSpan).hide();
+                        $(clickTargetSpan).hide();
+                        $(numSpan).hide();
+                        $(jsSpan).show();
+                        $(row3).show();
+                    }
+                    else {
+                        throw new Error("unexpected action:"+val);
+                    }
+                });
+
                 $(kind).change();
             },
             removable: true,
@@ -409,139 +830,222 @@
         });
     }
 
+    /**
+     *  Get list of test suite definitions
+     *  @returns {array} Array of test suites
+     */
     function getSuites() {
         return Object.values(suites);
     }
 
-    function updateCaseSelector(caseSel, caseInput, cases) {
-        var initVal = null;
+    /** 
+     *  Update test case selector menu
+     *  @param {Object} caseSel - DOM of test case selector
+     *  @param {array} cases - array of test case definitions
+     *  @returns {string} id of selected item
+     */
+    function updateCaseSelector(caseSel, cases) {
+        var caseID = null;
         caseSel.empty();
-        cases.forEach(function (def) {
+        for (let def of cases) {
             var val = def.id;
             var name = def.name;
             $("<option/>").val(val).text(name).appendTo(caseSel);
-            initVal = initVal || val;
-        });
-        if (initVal) {
-            caseSel.val(initVal);
+            caseID = caseID || val;
         }
+        $("<option/>").val("_NEW_").text("new...").appendTo(caseSel);
+        caseID = caseID || "_NEW_";
+        caseSel.val(caseID);
+        return caseID;
     }
 
+    /**
+     *  Load flow test settings for specified node
+     *  @param {Object} currentCase - currently selected test case
+     *  @param {array} events - list of events
+     *  @param {Object} node - target node
+     */
     function loadActions(currentCase, events, node) {
         if (!currentCase) {
             return;
         }
-        var nid = "_global_";
+        var nid = "_global_";  // '_global_' represents global events
         if (node.type !== "flow-test-config") {
             nid = node.id;
         }
-        events.forEach(function (event) {
+        for (let event of events) {
             var actions0 = currentCase.actions || {};
             var actions1 = actions0[event] || {};
             var actions = actions1[nid] || [];
             var listID = "node-test-event-tab-" +event +"-list";
             var list = $("#"+listID);
             list.editableList("empty");
-            actions.forEach(function (action) {
+            for (let action of actions) {
                 list.editableList("addItem", action);
-            });
-        });
+            }
+        }
     }
-    
+
+    /**
+     *  Clear actions list of events tab
+     *  @param {array} events - list of events
+     */
+    function clearActions(events) {
+        for (let event of events) {
+            var listID = "node-test-event-tab-" +event +"-list";
+            var list = $("#"+listID);
+            list.editableList("empty");
+        }
+    }
+
+    /**
+     *  Update test suite selector menu
+     *  @param {Object} selector - DOM of test suite selector
+     *  @param {array} suites - array of test suites
+     *  @returns {string} id of selected item
+     */
+    function updateSuiteSelector(selector, suites) {
+        var initVal = undefined;
+        for (let suite of suites) {
+            var node = suite.node;
+            var sid = node.id;
+            var sname = node.name;
+            initVal = initVal || sid;
+
+            $("<option/>", {
+            }).val(sid).text(sname).appendTo(selector);
+        }
+        $("<option/>", {
+        }).val("_NEW_").text("new...").appendTo(selector);
+        initVal = initVal || "_NEW_";
+        selector.val(initVal);
+        return initVal;
+    }
+
+    /**
+     *  Creates interface for inputting test suite and test case
+     *  @param {Object} node - target node
+     *  @param {Object} suiteSel - DOM of test suite selector
+     *  @param {Object} suiteInput - DOM of test suite name input
+     *  @param {Object} suiteDelButton - DOM of test suite delete button
+     *  @param {Object} caseSel - DOM of test case selector
+     *  @param {Object} caseInput - DOM of test case name input
+     *  @param {Object} caseDelButton - DOM of test case delete button
+     *  @param {string} initialCaseID - initial id of test case
+     *  @param {array} events - list of events
+     */
     function createTestSelector(
         node,
-        suiteSel, suiteInput,
-        suiteAddButton, suiteDelButton, suiteUpdateButton,
-        caseSel, caseInput,
-        caseAddButton, caseDelButton, caseUpdateButton,
+        suiteSel, suiteInput, suiteDelButton, 
+        caseSel, caseInput, caseDelButton,
         initialCaseID, events) {
         var isConfig = (node.type === "flow-test-config");
         var suites = getSuites();
-        var testSuites = {};
-        var suiteVal = null;
-        suites.forEach(function (suite) {
-            var n = suite.node;
-            var sid = n.id;
-            var sname = n.name;
-            suiteVal = suiteVal || sid;
-            if (suiteSel) {
-                $("<option/>", {
-                }).val(sid).text(sname).appendTo(suiteSel);
-            }
-            var tests = n.tests;
-            var testCases = [];
-            testSuites[sid] = testCases;
-            tests.forEach(function (test) {
-                testCases.push(test);
-            });
-            testCases.push({
-                id: "_NEW_",
-                name: "new..."
-            });
-        });
-        if (suiteSel) {
-            $("<option/>", {
-            }).val("_NEW_").text("new...").appendTo(suiteSel);
-        }
+
         var currentCases = [];
+        var defaultCaseID = "_NEW_";
         if (suiteSel) {
+            var initialSuiteID = updateSuiteSelector(suiteSel, suites);
             suiteSel.on("change", function (ev) {
                 var sid = suiteSel.val();
-                var cases = testSuites[sid] || [];
-                updateCaseSelector(caseSel, caseInput, cases);
-                currentCases = cases;
                 if (sid === "_NEW_") {
-                    suiteAddButton.show();
                     suiteDelButton.hide();
-                    suiteUpdateButton.hide();
+                    $(suiteInput).typedInput("value", "New Test Suite");
+                    defaultCaseID = updateCaseSelector(caseSel, []);
+                    currentCases = tests;
                 }
                 else {
-                    var suites = getSuites();
-                    var suite = suites.find(function (x) { return x.id === sid; });
+                    var suite = id2suite[sid];
+                    var suiteNode = suite.node;
+                    var tests = suiteNode.tests;
+                    defaultCaseID = updateCaseSelector(caseSel, tests);
+                    currentCases = tests;
+
                     if (suite) {
-                        suiteInput.val(suite.name);
+                        var name = suite.node.name;
+                        $(suiteInput).typedInput("value", name);
                     }
-                    suiteAddButton.hide();
                     suiteDelButton.show();
-                    suiteUpdateButton.show();
                 }
+                $(caseSel).val(defaultCaseID);
+                $(caseSel).change();
             });
-            suiteSel.val(suiteVal);
+            suiteSel.val(initialSuiteID);
             suiteSel.change();
         }
         else {
-            var cases = testSuites[node.id] || [];
-            updateCaseSelector(caseSel, caseInput, cases);
-            currentCases = cases;
+            var suite = id2suite[node.id];
+            var suiteNode = suite.node;
+            var tests = suiteNode.tests;
+
+            defaultCaseID = updateCaseSelector(caseSel, tests);
+            currentCases = tests;
         }
-        var isFirstCase = true;
+
         caseSel.on("change", function (ev) {
             var caseid = caseSel.val();
             if (caseid === "_NEW_") {
-                caseAddButton.show();
                 caseDelButton.hide();
-                caseUpdateButton.hide();
+                var name = "";
+                $(caseInput).typedInput("value", name);
+                $("#flow-test-timeout").typedInput("value", TIMEOUT);
+                $("#flow-test-max-actions").typedInput("value", MAX_ACTIONS);
+                clearActions(events);
             }
             else {
                 var currentCase = currentCases.find(function (e) { return e.id === caseid; });
                 if (currentCase) {
-                    caseInput.val(currentCase.name);
+                    $(caseInput).typedInput("value", currentCase.name);
                 }
-                caseAddButton.hide();
                 caseDelButton.show();
-                caseUpdateButton.show();
+                var timeout = currentCase.timeout || TIMEOUT;
+                var max_actions = currentCase.max_actions || MAX_ACTIONS;
+                $("#flow-test-timeout").typedInput("value", timeout);
+                $("#flow-test-max-actions").typedInput("value", max_actions);
                 loadActions(currentCase, events, node);
             }
-            // update actions list
         });
-        caseInput.on("change", function (ev) {
-            // update test case list
-        });
-        caseSel.val(initialCaseID ? initialCaseID : "_NEW_");
+
+        var caseID = initialCaseID ? initialCaseID : defaultCaseID;
+        caseSel.val(caseID);
         caseSel.change();
+
+        if (suiteDelButton) {
+            suiteDelButton.on("click", function (ev) {
+                ev.preventDefault();
+                ev.stopPropagation();
+                var sid = suiteSel.val();
+                if (sid === "_NEW_") {
+                    removeTestSuite(sid);
+                    updateSuiteSelector(suiteSel, suites);
+                    suiteSel.val("_NEW_");
+                    suiteSel.change();
+                }            
+            });
+        }
+
+        caseDelButton.on("click", function (ev) {
+            ev.preventDefault();
+            ev.stopPropagation();
+            var caseid = caseSel.val();
+            if (caseid !== "_NEW_") {
+                var sid = suiteSel ? suiteSel.val() : node.id;
+                var newCases = removeTestCase(sid, caseid);
+                updateCaseSelector(caseSel, newCases);
+                caseSel.val("_NEW_");
+                caseSel.change();
+            }
+        });
     }
 
 
+    /**
+     *  Creates test suite/case input field
+     *  @param {Object} container - enclosing DOM element
+     *  @param {string} kind - suite/test
+     *  @param {string} name - name of test suite/case
+     *  @return {array} - array of DOMs: selector, input field, and delete button
+     */
     function buildCaseInputs(container, kind, name) {
         var selectRow = $("<div/>", {
             class: "form-row"
@@ -553,27 +1057,22 @@
         var selector = $("<select/>", {
             id: "flow-test-" +kind,
         }).css({
-            width: "calc(55% - 130px)",
+            width: "calc(30% - 25px)",
+            "margin-bottom": "0px",
         }).appendTo(selectRow);
         var input = $("<input/>", {
+            id: "flow-test-name-" +kind,
             placeholder: name,
         }).css({
-            width: "calc(55% - 110px)",
-            height: "24px",
-            "margin-bottom": "9px",
-            "margin-left": "8px",
-        }).appendTo(selectRow);
-
-        var addButton = $("<button/>", {
-            class: "red-ui-button red-ui-button-small"
-        }).css({
-            "vertical-align": "top",
-            "margin-top": "3px",
-            "margin-left": "3px"
+            width: "calc(50% - 25px)",
+            "margin-left": "10px"
         }).appendTo(selectRow);
-        $("<i/>", {
-            class: "fa fa-plus"
-        }).appendTo(addButton);
+        $(input).typedInput({
+            default: "str",
+            types: [
+                "str"
+            ]
+        });
 
         var delButton = $("<button/>", {
             class: "red-ui-button red-ui-button-small"
@@ -583,49 +1082,97 @@
             "margin-left": "3px"
         }).appendTo(selectRow);
         $("<i/>", {
-            class: "fa fa-minus"
+            class: "fa fa-trash"
         }).appendTo(delButton);
 
-        var updateButton = $("<button/>", {
-            class: "red-ui-button red-ui-button-small"
-        }).css({
-            "vertical-align": "top",
-            "margin-top": "3px",
-            "margin-left": "3px"
-        }).appendTo(selectRow);
-        $("<i/>", {
-            class: "fa fa-refresh"
-        }).appendTo(updateButton);
+        return [selector, input, delButton];
+    }
 
-        return [selector, input,
-                addButton, delButton, updateButton];
+    /**
+     *  Creates list of events for specified node
+     *  @param {Object} node - target node
+     *  @returns {array} array of events
+     */
+    function nodeEvents(node) {
+        var events = [];
+        if (node.inputs > 0) {
+            // if node has input port, recv and stub events supported
+            events = ["recv", "stub"];
+        }
+        if (node.outputs > 0) {
+            // if node has output port, send event supported
+            events.push("send");
+        }
+        return events;
     }
-    
-    function buildFlowTestTab(container, node) {
+
+    /**
+     *  Create tab for flow testing in node settings panel
+     *  @param {Object} container - enclosing DOM element
+     *  @param {Object} node - target node
+     *  @param {string} testID - test case id
+     */
+    function buildFlowTestTab(container, node, testID) {
         var isConfig = (node.type === "flow-test-config");
         var labelRow = $("<div/>", {
-            class: "form-row"
+            class: "form-row",
         }).appendTo(container);
         $("<div/>", {
         }).css({
-            width: "200px"
+            width: "170px"
         }).text("Events & Actions").appendTo(labelRow);
         var suiteSelector = null;
         var suiteInput = null;
-        var suiteAddButton = null;
         var suiteDelButton = null;
         var suiteUpdateButton = null;
         if (!isConfig) {
-            [suiteSelector, suiteInput,
-             suiteAddButton, suiteDelButton, suiteUpdateButton]
+            [suiteSelector, suiteInput, suiteDelButton]
                 = buildCaseInputs(container, "suite", "Test Suite");
         }
-        var [testSelector, testInput,
-             testAddButton, testDelButton, testUpdateButton]
+        var [testSelector, testInput, testDelButton]
             = buildCaseInputs(container, "test", "Test Case");
 
+        var timeoutDiv = $("<div/>", {
+            class: "form-row",
+        }).css({
+        }).appendTo(container);
+        $("<label/>").text("Timeout").appendTo(timeoutDiv);
+        var timeoutField = $("<input/>", {
+            id: "flow-test-timeout"
+        }).css({
+            width: "150px"
+        }).appendTo(timeoutDiv);
+        $("<label/>", {
+        }).css({
+            "margin-left": "5px"
+        }).text("sec").appendTo(timeoutDiv);
+        $(timeoutField).typedInput({
+            default: "num",
+            types: [
+                "num"
+            ]
+        });
+
+        var maxActionsDiv = $("<div/>", {
+            class: "form-row",
+        }).css({
+        }).appendTo(container);
+        $("<label/>").css({
+        }).text("Limit Actions").appendTo(maxActionsDiv);
+        var maxActionsField = $("<input/>", {
+            id: "flow-test-max-actions"
+        }).css({
+            width: "150px"
+        }).appendTo(maxActionsDiv);
+        $(maxActionsField).typedInput({
+            default: "num",
+            types: [
+                "num"
+            ]
+        });
+
         var eventsContainer = $("<div/>", {
-            class: "form-row"
+            class: "form-row",
         }).css({
         }).appendTo(container);
         var eventsTab = $("<ul/>", {
@@ -647,9 +1194,10 @@
                 resizeActionList(tab.id);
             }
         });
-        var events = [];
+        var events = null;
         if (node.type === "flow-test-config") {
-            createEventTab("node-test-event-tab-setup", tabContainer, node); 
+            // flow events & actions
+            createEventTab("node-test-event-tab-setup", tabContainer, node);
             createEventTab("node-test-event-tab-cleanup", tabContainer, node); 
             tabs.addTab({
                 id: "node-test-event-tab-setup",
@@ -663,43 +1211,75 @@
             events = ["setup", "cleanup"];
         }
         else {
-            createEventTab("node-test-event-tab-recv", tabContainer, node); 
-            createEventTab("node-test-event-tab-stub", tabContainer, node); 
-            createEventTab("node-test-event-tab-send", tabContainer, node); 
-            tabs.addTab({
-                id: "node-test-event-tab-recv",
-                label: "receive"
-            });
-            tabs.addTab({
-                id: "node-test-event-tab-stub",
-                label: "stub"
-            });
-            tabs.addTab({
-                id: "node-test-event-tab-send",
-                label: "send"
-            });
-            tabs.activateTab("node-test-event-tab-recv");
-            events = ["recv", "stub", "send"];
+            // node events & actions
+            var hasInput = (node.inputs > 0);
+            var hasOutput = (node.outputs > 0);
+
+            events = nodeEvents(node);
+            if (hasInput) {
+                createEventTab("node-test-event-tab-recv", tabContainer, node); 
+                tabs.addTab({
+                    id: "node-test-event-tab-recv",
+                    label: "receive"
+                });
+
+                createEventTab("node-test-event-tab-stub", tabContainer, node); 
+                tabs.addTab({
+                    id: "node-test-event-tab-stub",
+                    label: "stub"
+                });
+            }
+            if (hasOutput) {
+                createEventTab("node-test-event-tab-send", tabContainer, node); 
+                tabs.addTab({
+                    id: "node-test-event-tab-send",
+                    label: "send"
+                });
+            }
+            if (hasInput) {
+                tabs.activateTab("node-test-event-tab-recv");
+            }
+            else {
+                tabs.activateTab("node-test-event-tab-send");
+            }
         }
 
         createTestSelector(
             node,
-            suiteSelector, suiteInput,
-            suiteAddButton, suiteDelButton, suiteUpdateButton,
-            testSelector, testInput,
-            testAddButton, testDelButton, testUpdateButton,
-            selectedTestID, events);
-
+            suiteSelector, suiteInput, suiteDelButton, 
+            testSelector, testInput, testDelButton,
+            testID, events);
     }
 
-    function buildTestActions(container, node) {
-        buildFlowTestTab(container, node);
+
+    /**
+     *  Add logging text to sidebar panel
+     *  @param {string} line - message to be added
+     */
+    function addLog(line) {
+        logs.push(line);
+        if (logs.length > 500) {
+            logs = logs.slice(-500);
+        }
+        if (logEditor) {
+            var session = logEditor.getSession();
+            session.insert({
+                row: session.getLength(),
+                column: 0,
+            }, "\n" + line);
+            logEditor.scrollToLine(session.getLength());
+        }
     }
 
-    function handleNodeDialogOpen(opt) {
+    /**
+     *  Handle node settings dialog prepare event for setting up flow
+     *  test tab 
+     *  @param {Object} opt - dialog preparation options
+     */
+    function handleNodeDialogPrepare(opt) {
         var node = opt.node;
         if (node.type === "flow-test-config") {
-            buildTestActions($("#test-actions-container"), node);
+            buildFlowTestTab($("#test-actions-container"), node, selectedTestID);
             return;
         }
         if (node._def.category === "config") {
@@ -726,6 +1306,43 @@
         tabs.addTab(flowTestTab);
     }
 
+    /**
+     *  Execute all test cases in specified test suite
+     *  @param {Object} suite - test suite definition
+     *  @returns {Promise}
+     */
+    function executeTestSuite(suite) {
+        let node = suite.node;
+        addLog("Run test suite: " +node.name);
+        let tests = node.tests || [];
+        let  promise = Promise.resolve()
+        for (let test of tests) {
+            promise = promise.then(function () {
+                return executeTestCase(node, test);
+            });
+        }
+        return promise;
+    }
+    
+    /**
+     *  Execute all test suites
+     *  @returns {Promise}
+     */
+    function executeAllTests() {
+        addLog("Run all test suites");
+        let promise = Promise.resolve();
+        for (let suite of suites) {
+            promise = promise.then(function () {
+                return executeTestSuite(suite);
+            });
+        }
+        return promise;
+    }
+
+    /**
+     *  Create sidebar for flow testing
+     *  @param {Object} div - enclosing DOM element
+     */
     function createSidebarContent(div) {
         content = div;
         var controlDiv = $("<div/>", {
@@ -739,41 +1356,94 @@
             class: "form-row compact"
         }).appendTo(stackContainer);
         var logPanel = $("<div/>", {
-            class: "form-row compact"
+            class: "form-row node-text-editor-row",
         }).appendTo(stackContainer);
+        logContainer = $("<div/>", {
+            class: "node-text-editor",
+        }).css({
+            margin: "5px",
+            width: "95%",
+            height: "95%",
+            "min-height": "150px",
+        }).appendTo(logPanel);
         panels = RED.panels.create({
             container: stackContainer
         });
-        panels.ratio(0.7);
+        panels.ratio(0.5);
 
-        var run = $("<button/>", {
-            class: "red-ui-button red-ui-button-small"
+        var runButton = $("<button/>", {
+            class: "red-ui-button red-ui-button-small",
         }).appendTo(controlDiv);
         $("<i/>", {
             class: "fa fa-play"
-        }).appendTo(run);
+        }).appendTo(runButton);
         $("<label/>").css({
-            "margin-left": "5px"
+            "margin-left": "5px",
         }).text("Run Tests").appendTo(controlDiv);
 
         createTestSuites(testsPanel);
+
+        runButton.on("click", function (ev) {
+            ev.preventDefault();
+            ev.stopPropagation();
+            executeAllTests();
+        });
+
+        logEditor = RED.editor.createEditor({
+            mode: "ace/mode/text",
+            value: logs.join("\n"),
+            element: logContainer,
+            lineNumbers: false,
+            readOnly: true,
+        });
+        setTimeout(function () {
+            addLog("Starting Flow Tester");
+        }, 1000);
+        logEditor.resize();
     }
 
-    var currentHeight = undefined;
+    /**
+     *  Update sidebar contents related to specified node
+     *  @param {Object} suiteNode - config node for test suite
+     */
+    function updateSidebar(suiteNode) {
+        var name = suiteNode.name;
+        var suite = id2suite[suiteNode.id];
+        var element = suite.element.element;
+        var label = $(element).find(".test-suite-label");
+        label.text(name);
+
+        var tests = suiteNode.tests;
+        for (let test of tests) {
+            if (id2test[test.id]) {
+                var element = id2test[test.id].element;
+                var label = $(element).find(".test-case-label");
+                label.text(test.name);
+            }
+        }
+    }
 
+    /**
+     *  Resize editableList for actions
+     *  @param {string} tabID - target tab id
+     */
     function resizeActionList(tabID) {
         if (currentHeight) {
             $("#"+tabID+"-list").editableList("height", currentHeight);
         }
     }
 
+    /**
+     *  Handle resize event of node dialog 
+     *  @param {Object} opt - dialog resize options
+     */
     function handleNodeDialogResize(opt) {
         var node = opt.node;
         if ((node.category === "config") &&
             (node.type !== "flow-test-config")) {
             return;
         }
-        var newHeight = opt.height -200;
+        var newHeight = opt.size.height -250;
         if (node.type === "flow-test-config") {
             $("#node-test-event-tab-setup-list").editableList("height", newHeight);
             $("#node-test-event-tab-cleanup-list").editableList("height", newHeight);
@@ -786,18 +1456,40 @@
         currentHeight = newHeight;
     }
 
+    /**
+     *  Get value of typedInput field
+     *  @param {Object} item - typedInput DOM element
+     */
     function typedInputValue(item) {
         var val = item.typedInput("value");
         return val;
     }
 
-    function findTest(suite, tid) {
-        var tests = suite.tests;
-        var test = tests.find(function (x) { return (x.id === tid); });
-        return test;
+    /**
+     *  Find or creates test case definition with specified id
+     *  @param {Object} suiteNode - config node for test suite
+     *  @param {string} tid - test case id
+     *  @param {string} tname - test case name
+     *  @returns {Object} new test case definition
+     */
+    function findTest(suiteNode, tid, tname) {
+        if (tid === "_NEW_") {
+            var test = createNewTest(suiteNode, tname);
+            return test;
+        }
+        else {
+            var tests = suiteNode.tests;
+            var test = tests.find(function (x) { return (x.id === tid); });
+            test.name = tname;
+            return test;
+        }
     }
 
-    function saveActions(node) {
+    /**
+     *  Save flow test configurations
+     *  @param {Object} node - target node
+     */
+    function saveConfig(node) {
         var isGlobal = (node.type === "flow-test-config");
         var suite = null;
         var events = null;
@@ -806,72 +1498,192 @@
             events = ["setup", "cleanup"];
             nid = "_global_";
             suite = node;
+            if (!suite) {
+                throw new Error("no global suite node");
+            }
+            var sname = $("#node-input-name").val();
+            suite.name = sname;
         }
         else {
-            events = ["recv", "stub", "send"];
+            events = nodeEvents(node);
             var sid = $("#flow-test-suite").val();
             suite = RED.nodes.node(sid);
             nid = node.id;
+            if (!suite) {
+                throw new Error("suite node not found: "+ sid);
+            }
+            var sname = $("#flow-test-name-suite").typedInput("value");
+            suite.name = sname;
         }
+
         var tid = $("#flow-test-test").val();
-        var test = findTest(suite, tid);
-        if (!test) {
-            return;
-        }
-        var actions = test.actions;
-        events.forEach(function (event) {
-            var listID = "node-test-event-tab-" +event +"-list";
-            var list = $("#"+listID).editableList("items");
-            var acts = [];
-            list.each(function (i) {
-                var kind = $(this).find(".action-kind").val();
-                var val = typedInputValue($(this).find(".action-value"));
-                var target = $(this).find(".action-target").val();
-                acts.push({
-                    kind: kind,
-                    value: val,
-                    target: target,
+        var tname = $("#flow-test-name-test").typedInput("value");
+        var test = (tname !== "") ?  findTest(suite, tid, tname) : null;
+
+        if (test) {
+            test.timeout = $("#flow-test-timeout").typedInput("value");
+            test.max_actions = $("#flow-test-max-actions").typedInput("value");
+
+            var actions = test.actions;
+            for (let event of events) {
+                var listID = "node-test-event-tab-" +event +"-list";
+                var list = $("#"+listID).editableList("items");
+                var acts = [];
+                list.each(function (i) {
+                    var kind = $(this).find(".action-kind").val();
+                    var action = {
+                        kind: kind
+                    };
+                    switch (kind) {
+                    case "send":
+                        var target = $(this).find(".action-send-target").val();
+                        var value = typedInputValue($(this).find(".action-value"));
+                        action.target = target;
+                        action.value = value;
+                        break;
+                    case "click":
+                        var target = $(this).find(".action-click-target").val();
+                        action.target = target;
+                        break;
+                    case "set":
+                        var dst = $(this).find(".action-var");
+                        var src = $(this).find(".action-value-set");
+                        action.dst = {
+                            type: dst.typedInput("type"),
+                            value: dst.typedInput("value"),
+                        };
+                        action.src = {
+                            type: src.typedInput("type"),
+                            value: src.typedInput("value"),
+                        };
+                        break;
+                    case "match":
+                        var value = typedInputValue($(this).find(".action-value"));
+                        action.value = value;
+                        break;
+                    case "wait":
+                        var wait = $(this).find(".action-wait-ms").typedInput("value");
+                        action.wait = wait;
+                        break;
+                    case "function":
+                        var code = $(this).find(".action-js").typedInput("value");
+                        var check = $(this).find(".action-js-perform-check").prop("checked");
+                        action.code = code;
+                        action.performCheck = check;
+                        break;
+                    default:
+                        throw new Error("unexpected kind of action: " +kind);
+                        break;
+                    }
+                    acts.push(action);
                 });
-            });
-            actions[event][nid] = acts;
-        });
+                actions[event][nid] = acts;
+            }
+        }
         RED.nodes.dirty(suite);
+        updateSidebar(suite);
     }
 
+    /**
+     *  Handle node settings save event
+     *  @param {Object} node - target ndoe
+     */
     function handleNodeSave(node) {
         if (node._def.category === "config") {
             if (node.type !== "flow-test-config") {
+                // nothing to do for other config node
                 return;
             }
         }
-        saveActions(node);
+        saveConfig(node);
     }
 
+    /**
+     *  Handle node add event
+     *  @param {Object} node - target node
+     */
     function handleNodeAdd(node) {
         if (node.type === "flow-test-config") {
             addTestSuite(treeRoot, node);
         }
     }
 
+    /*
+     *  Handle node remove event
+     *  @param {Object} node - target node
+     */
     function handleNodeRemove(node) {
         if (node.type === "flow-test-config") {
-            removeTestSuite(treeRoot, node);
+            removeTestSuite(node.id);
         }
     }
 
+    /*
+     *  Handle node change event
+     *  @param {Object} node - target node
+     */
     function handleNodeChange(node) {
         if (node.type === "flow-test-config") {
         }
     }
 
+    //  Internal API for adding log
+    RED.comms.subscribe("flow-test:log", function (type, msg) {
+        addLog("- "+msg);
+    });
+
+    //  Internal API for showing notification
     RED.comms.subscribe("flow-test:notify", function (type, msg) {
+        addLog("- "+msg);
         RED.notify(msg);
     });
     
+    //  Internal API for handling overflow of actions execution count 
+    RED.comms.subscribe("flow-test:maxActions", function (type) {
+        var msg = `"Exceeded max actions count: ${MAX_ACTIONS}`;
+        addLog("- "+msg);
+        invokeAction("cleanup").then(function () {
+            workComplete();
+        });
+    });
+
+    //  Handle results of match actions
+    RED.comms.subscribe("flow-test:match-result", function (type, opt) {
+        if (opt.result) {
+            testResult.success++;
+        }
+        else {
+            testResult.fail++;
+            var msg = "test failed";
+            addLog("  - " +msg);
+            RED.notify(msg);
+        }
+        addLog(`- match: ${testResult.success}/${numberOfChecks}`);
+        if ((testResult.success +testResult.fail) === numberOfChecks) {
+            if (currentTimeout) {
+                clearTimeout(currentTimeout);
+                currentTimeout = null;
+            }
+            if (testResult.success) {
+                addLog("- successfully completed.");
+                RED.notify("Flow Test Successfully Completed");
+            }
+            invokeAction("cleanup").then(function () {
+                workComplete();
+            });
+        }
+    });
+
+    // Click button of target node
+    RED.comms.subscribe("flow-test:click", function (type, id) {
+        var node = RED.nodes.node(id);
+        RED.view.clickNodeButton(node);
+    });
+
+    // Register flow testing plugin
     RED.plugins.registerPlugin("node-red-flow-tester", {
         onadd: function() {
-
-            var content = $("<div>").addClass("red-ui-flow-tester");
+            var content = $("<div/>").addClass("red-ui-flow-tester");
             var toolbar = $('<div/>');
 
             createSidebarContent(content);
@@ -894,7 +1706,7 @@
             RED.events.on("nodes:remove", handleNodeRemove);
             RED.events.on("nodes:change", handleNodeChange);
             
-            RED.events.on("nodes:dialog-open", handleNodeDialogOpen);
+            RED.events.on("nodes:dialog-prepare", handleNodeDialogPrepare);
             RED.events.on("nodes:dialog-resize", handleNodeDialogResize);
             RED.events.on("editor:save", handleNodeSave);
             
diff --git a/src/flow-tester.js b/src/flow-tester.js
index e116b07..e683b4b 100644
--- a/src/flow-tester.js
+++ b/src/flow-tester.js
@@ -1,132 +1,705 @@
 module.exports = (RED) => {
+    "use strict";
 
-    let checks = [];
-    let checkSend = {};
+    const vm = require("vm");
+    const assert = require("assert");
+    const promisify = require("util").promisify;
 
-    function message(msg) {
+    let maxActions = 0;      // max number of actions 
+    let actionCount = 0;     // currently executed actions count
+
+    let numberOfChecks = 0;  // number of checks in current test case
+    let successActions = []; // info. of successful actions
+    let failActions = [];    // info. of failed actions
+
+    let resolveWait = (() => {});  // resolve function for wait promise
+    let currentWait = null;  // handle for wait action
+    const TIMEOUT = 10;      // timeout period of flow execution
+
+    // actions map: event name -> node id -> action info
+    const actionMap = {
+        setup: [],		// executed on test start 
+        cleanup: [],	// executed on test end
+
+        recv: [],		// executed on message receive
+        stub: [],		// executed on message receive to make
+                        // stubbed execution of target node
+        send: [],		// executed on message send
+    };
+
+    /**
+     *  Add event log to editor sidebar log area
+     *  @param {string} msg - message to be added
+     */
+    function log(msg) {
+        RED.comms.publish("flow-test:log", msg);
+    }
+
+    /**
+     *  Show notification on editor
+     *  @param {string} msg - message to be shown
+    */
+    function notify(msg) {
         RED.comms.publish("flow-test:notify", msg);
     }
-    
-    function init() {
-        checks = [];
-        checkSend = {};
 
-        RED.hooks.add("onSend.flow-test", (events, done) => {
-            events.forEach((event) => {
-                const src = event.source;
-                const msg = event.msg;
-                const sendCB = checkSend[src.id];
-                if (sendCB) {
-                    sendCB(msg);
-                }
-            });
-            done();
+    /**
+     *  Notify that execution reached the maxnimum number
+     */
+    function reportMaxActions() {
+        RED.comms.publish("flow-test:notifyMaxActions");
+    }
+
+    /**
+     *  Notify result of match action
+     *  @param {Object} result - result information object with:
+     *                             result: true/false
+     *                             suiteID: test suite id
+     *                             testID: test case id
+     */
+    function sendMatchResult(result) {
+        RED.comms.publish("flow-test:match-result", result);
+    }
+
+    /**
+     *  Execute send action: send value to target node
+     *  @param {string} target - target node id
+     *  @param {any} value - payload value
+     *  @returns {Promise}
+     */
+    function executeSend(target, value) {
+        log(`send: ${JSON.stringify(value)} to ${target}`);
+        const node = RED.nodes.getNode(target);
+        node.receive({
+            payload: value
         });
         return Promise.resolve(true);
     }
 
-    function start() {
-        Promise.all(checks).then((results) => {
-            if (results.find(v => (v !== true)) === undefined) {
-                message("test success");
+    /**
+     *  Execute click action: click button of target node
+     *  @param {string} target - target node id
+     *  @returns {Promise}
+     */
+    function executeClick(target) {
+        log(`click: ${target}`);
+        RED.comms.publish("flow-test:click", target);
+        return Promise.resolve(true);
+    }
+
+    /**
+     *  Execute set action: set value to msg, flow context, or global context
+     *  @param {Object} dst - destination location (type, value)
+     *  @param {Object} src - source value (type, value)
+     *  @param {string} nid - target node id
+     *  @param {Object} msg - target message
+     *  @returns {Promise}
+     */
+    function executeSet(dst, src, nid, msg) {
+        log(`set: ${dst.type}.${dst.value} = ${JSON.stringify(src.value)}`);
+        const node = nid ? RED.nodes.getNode(nid) : null;
+        let val = src.value || "";
+        switch (src.type) {
+        case "str":
+            break;
+        case "num":
+            val = Number(val);
+            break;
+        case "bool":
+            val = ((val === true) || (val === "true"));
+            break;
+        case "json":
+            val = JSON.parse(val);
+            break;
+        case "bin":
+            val = Buffer.from(JSON.parse(val));
+            break;
+        case "re":
+            break;
+        case "date":
+            val = Date.now();
+            break;
+        case "jsonata":
+            if (!src.exp) {
+                src.exp = RED.util.prepareJSONataExpression(val, node);
             }
-            else {
-                message("test failed");
+            val = RED.util.evaluateJSONataExpression(src.exp, msg);
+            break;
+        case "env":
+            val = RED.util.evaluateNodeProperty(val, "env", node);
+            break;
+        }
+        switch (dst.type) {
+        case "msg":
+            if (msg) {
+                RED.util.setMessageProperty(msg, dst.value, value);
             }
-        }).catch((e) => {
-            message("test failed");
-        });
+            break;
+        case "global":
+        case "flow":
+            const contextKey = RED.util.parseContextStore(dst.value);
+            if (/\[msg/.test(contextKey.key)) {
+                // The key has a nest msg. reference to evaluate first
+                contextKey.key = RED.util.normalisePropertyExpression(contextKey.key, msg, true)
+            }
+            const target = node.context()[dst.type];
+            const set = promisify(target.set);
+            return set(contextKey.key, val, contextKey.store);
+        default:
+            throw new Error("unexpected value type: "+src.type);
+        }
         return Promise.resolve(true);
     }
-    
-    function cleanup() {
-        RED.hooks.remove("onSend.flow-test");
+
+    /**
+     *  Report result of validation 
+     *  @param {boolean} result - result of validation
+     *  @param {Number} index - index in actions list
+     *  @param {string} sid - test suite id
+     *  @param {string} tid - test case id
+     */
+    function reportResult(result, index, sid, tid) {
+        const info = {
+            result: result,
+            suiteID: sid,
+            testID: tid,
+        };
+        var actInfo = {
+            index: index,
+            suiteID: sid,
+            testID: tid,
+        };
+        if (result) {
+            successActions.push(actInfo);
+        }
+        else {
+            failActions.push(actInfo);
+        }
+        sendMatchResult(info);
+        if ((successActions.length +failActions.length) >= numberOfChecks) {
+            if (currentWait) {
+                // clear timeout if all validations processed
+                clearTimeout(currentWait);
+            }
+            resolveWait(true);
+            resolveWait = (()=>{});
+        }
+    }
+
+    /**
+     *  Execute match action: validates message value
+     *  @param {any} val - expected value 
+     *  @param {Object} msg - message to be checked
+     *  @param {Number} index - index in actions list
+     *  @param {string} sid - test suite id
+     *  @param {string} tid - test case id
+     *  @returns {Promise}
+     */
+    function executeMatch(val, msg, index, sid, tid) {
+        log(`match: ${val}`);
+        let result = true;
+        try {
+            assert.deepEqual(val, msg.payload);
+        }
+        catch (e) {
+            result = false;
+        }
+        reportResult(result, index, sid, tid);
         return Promise.resolve(true);
     }
 
-    function executeSend(target, value) {
-        const node = RED.nodes.getNode(target);
-        node.receive({
-            payload: value
+    /**
+     *  Execute wait action: wait for specified period
+     *  @param {Number} wait - wait period in ms
+     *  @returns {Promise}
+     */
+    function executeWait(wait) {
+        log(`wait: ${wait}`);
+        return new Promise((resolve) => {
+            resolveWait = resolve;
+            currentWait = setTimeout(function () {
+                currentWait = null;
+                resolve(true);
+            }, wait);
         });
+    }
+
+    /**
+     *  Execute function action: execute JavaScript code
+     *  @param {string} code - JavaScript code text
+     *  @param {boolean} performCheck - true if the code performs check
+     *  @param {string} nid - target node id  
+     *  @param {Object} msg - message
+     *  @param {Number} index - index in actions list
+     *  @param {string} sid - test suid id
+     *  @param {string} tid - test case id
+     *  @returns {Promise}
+     */
+    function executeFunction(code, performCheck, nid, msg,
+                             index, sid, tid) {
+        log(`function: ${code}`);
+        const node = nid ? RED.nodes.getNode(nid) : null;
+        const ctxDef = {
+            console: console,
+            node: node,
+            msg: msg
+        };
+        if (performCheck) {
+            // `check` function for validation 
+            ctxDef.check = ((result) => {
+                reportResult(result, index, sid, tid);
+            });
+        }
+        const ctx = vm.createContext(ctxDef);
+        const script = `
+(function () {
+    try {
+        ${code};
+    }
+    catch (e) {
+        return Promise.reject(e);
+    }
+    return Promise.resolve(true);
+})()`;
+        return vm.runInContext(script, ctx);
+    }
+
+
+    /**
+     *  Execute action
+     *  @param {Object} action - action description object
+     *  @param {Object} node - target node
+     *  @param {Object} msg - message
+     *  @returns {Promise}
+     */
+    function executeAction(action, node, msg) {
+        actionCount++;
+        if (actionCount >= maxActions) {
+            reportMaxActions();
+            return Promise.resolve(true);
+        }
+        try {
+            switch (action.kind) {
+            case "send":
+                return executeSend(action.target, action.value);
+            case "click":
+                return executeClick(action.target);
+            case "set":
+                return executeSet(action.dst, action.src, node, msg);
+            case "match":
+                return executeMatch(action.value, msg,
+                                    action.index, action.suiteID, action.testID);
+            case "wait":
+                return executeWait(action.wait);
+            case "function":
+                return executeFunction(action.code, action.performCheck,
+                                       node, msg,
+                                       action.index, action.suiteID, action.testID);
+            default:
+                return Promise.rejject(new Error("unexpected kind of action: " +action.kind));
+            }
+        }
+        catch (e) {
+            const msg = "Error: "+ e;
+            log(msg);
+            console.log(msg);
+        }
         return Promise.resolve(true);
     }
 
-    function initMatch(nid, value) {
-        console.log("; initMatch: ", nid, value);
-        let resolve = null;
-        let reject = null;
-        const promise = new Promise((resolve_, reject_) => {
-            resolve = resolve_;
-            reject = reject_;
+    /**
+     *  Process actions defined for event
+     *  @param {array} actions - array of actions
+     *  @param {Object} node - target node
+     *  @param {Object} msg - message
+     *  @returns {Promise}
+     */
+    function processEvent(actions, node, msg) {
+        if (actions) {
+            let promise = Promise.resolve(true);
+            for (let action of actions) {
+                promise = promise.then(() => 
+                    executeAction(action, node, msg)
+                );
+            }
+            return promise;
+        }
+        return Promise.resolve(true);
+    }
+
+    /**
+     *  Clear hooks and actions map 
+     */
+    function clearActions() {
+        RED.hooks.remove("onReceive.flow-test");
+        RED.hooks.remove("preRoute.flow-test");
+        RED.hooks.remove("onSend.flow-test");
+
+        actionMap.setup = [];
+        actionMap.cleanup = [];
+
+        actionMap.recv = [];
+        actionMap.stub = [];
+        actionMap.send = [];
+    }
+
+    /**
+     *  Initialize flow testing plugin
+     *  @returns {Promise}
+     */
+    function init() {
+        if (currentWait) {
+            clearTimeout(currentWait);
+        }
+        clearActions();
+
+        // register hook for recv event
+        RED.hooks.add("onReceive.flow-test", (event, done) => {
+            const dst = event.destination.id;
+            const actions = actionMap.recv[dst];
+
+            if (actions) {
+                const msg = event.msg;
+                const promise = processEvent(actions, dst, msg);
+                promise.then(() => {
+                    done();
+                }).catch((err) => {
+                    log(err.toString());
+                    done();
+                });
+            }
+            else {
+                done();
+            }
         });
-        checkSend[nid] = (msg) => {
-            if (msg && (msg.payload === value)) {
-                resolve(true);
+
+        // register hook for stub event
+        RED.hooks.add("preRoute.flow-test", (event, done) => {
+            const src = event.source.id;
+            const actions = actionMap.stub[src];
+
+            if (actions)  {
+                const msg = event.msg;
+                const promise = processEvent(actions, src, msg);
+                promise.then(() => {
+                    done(false);
+                }).catch((err) => {
+                    log(err);
+                    done(false);
+                });
             }
             else {
-                resolve(false);
+                done();
             }
-        };
-        checks.push(promise);
+        });
+
+        // register hook for send event
+        RED.hooks.add("onSend.flow-test", (events, done) => {
+            let promise = Promise.resolve();
+            for (let event of events) {
+                const src = event.source.id;
+                const msg = event.msg;
+                const actions = actionMap.send[src];
+
+                if (actions) {
+                    promise = promise.then(() => {
+                        return processEvent(actions, src, msg);
+                    });
+                };
+            }
+            promise.then(() => {
+                done();
+            }).catch((err) => {
+                log(err);
+                done(false);
+            });
+        });
+
+
         return Promise.resolve(true);
     }
 
+
+    /**
+     *  Register actions to actionMap
+     *  @param {string} event - event name
+     *  @param {array} actions - list of actions
+     *  @param {string} sid - test suite id
+     *  @param {string} tid - test case id
+     *  @returns {Promise}
+     */
+    function registerActions(event, actions, sid, tid) {
+        switch (event) {
+        case "setup":
+        case "cleanup":
+        case "recv":
+        case "stub":
+        case "send":
+            Object.entries(actions).forEach(([node, acts]) => {
+                if (acts.length > 0) {
+                    actionMap[event][node] = acts;
+                    let i = 0;
+                    acts.forEach((act) => {
+                        act.index = i;
+                        act.suiteID = sid;
+                        act.testID = tid;
+                        i++;
+                    });
+                }
+            });
+            break;
+        default:
+            throw new Error("unexpected event: " +event);
+        }
+        return Promise.resolve(true);
+    }
+
+    /**
+     *  Initialize & process actions for setup event
+     *  @param {Number} maxActs - max number of actions
+     *  @returns {Promise}
+     */
+    function setup(maxActs) {
+        maxActions = maxActs;
+        actionCount = 0;
+        successActions = [];
+        failActions = [];
+        const actions = actionMap.setup["_global_"];
+        return processEvent(actions, null, null);
+    }
+
+
+    /**
+     *  Process actions for cleanup event
+     *  @param {Number} maxActs - max number of actions
+     *  @returns {Promise}
+     */
+    function cleanup() {
+        const actions = actionMap.cleanup["_global_"];
+
+        return processEvent(actions, null, null).then(() => {
+            clearActions();
+        });
+    }
+
+    // Register flow testing plugin
     RED.plugins.registerPlugin('node-red-flow-tester', {
         settings: {
             "*": { exportable: true }
         },
         onadd: () => {
             const routeAuthHandler = RED.auth.needsPermission("flow-tester.write");
+
+            // Internal APIs for flow testing
             RED.httpAdmin.post(
                 "/flow-tester/executeAction/:action",
                 routeAuthHandler,
                 (req, res) => {
-                    const kind = req.params.action;
-                    const opt = req.body;
-                    let promise = Promise.resolve(null);
-                    switch (kind) {
-                    case "init":
-                        // initialize runtime part of flow-tester plugin
-                        promise = init();
-                        break;
-                    case "start":
-                        // waits for completion of tests
-                        promise = start();
-                        break;
-                    case "cleanup":
-                        // cleanup runtime part of flow-tester plugin
-                        promise = cleanup();
-                        break;
-                    case "send":
-                        // send a message to specified node
-                        promise = executeSend(opt.target, opt.value);
-                        break;
-                    case "matchInit":
-                        // register callback for checking output messages  
-                        promise = initMatch(opt.node, opt.value);
-                        break;
-                    case "press":
-                        // press the button of target node
-                    case "recv":
-                        // receive a message from input port
-                    case "set":
-                        // set context or environment variable
-                    case "wait":
-                        // wait for specified time
-                    case "function":
-                        // execute JavaScript code
-                    default:
-                        console.log("unexpected action kind: ", kind);
-                        break;
+                    try {
+                        const kind = req.params.action;
+                        const opt = req.body;
+                        let promise = Promise.resolve(true);
+                        switch (kind) {
+                        case "init":
+                            // initialize runtime part of flow-tester plugin
+                            promise = init();
+                            break;
+                        case "registerActions":
+                            promise = registerActions(opt.event, opt.actions, opt.suiteID, opt.testID);
+                            break;
+                        case "setup":
+                            promise = setup(opt.maxActions);
+                            break;
+                        case "cleanup":
+                            // cleanup runtime part of flow-tester plugin
+                            promise = cleanup();
+                            break;
+                        case "send":
+                            // send a message to specified node
+                            promise = executeSend(opt.target, opt.value);
+                            break;
+                        case "click":
+                            // click the button of target node
+                            // nothing to do
+                            break;
+                        case "set":
+                            // set context or environment variable
+                            promise = executeSet(opt.dst, opt.src);
+                            break;
+                        case "wait":
+                            // wait for specified time
+                            promise = executeWait(opt.wait);
+                            break;
+                        case "function":
+                            // execute JavaScript code
+                            promise = executeFunction(opt.code);
+                            break;
+                        default:
+                            console.log("unexpected action kind: ", kind);
+                            break;
+                        }
+                        promise.then((result) => {
+                            res.json(result || {});
+                        }).catch((err) => {
+                            const msg = "error: " +err;
+                            console.log(msg);
+                            notify(msg);
+                            res.sendStatus(400);
+                        });
                     }
-                    promise.then((result) => {
-                        res.json(result);
-                    }).catch((err) => {
+                    catch (e) {
+                        console.log(e.stack);
                         res.sendStatus(400);
+                    }
+                });
+
+            // API for getting list of test cases
+            RED.httpAdmin.get(
+                "/flow-tester/testCase",
+                routeAuthHandler,
+                (req, res) => {
+                    const suiteList = [];
+                    const nodes = [];
+                    RED.nodes.eachNode((node) => {
+                        if (node.type === "flow-test-config") {
+                            nodes.push(node);
+                        }
+                    });
+                    nodes.forEach((node) => {
+                        const testList = [];
+                        const suite = {
+                            id: node.id,
+                            name: node.name,
+                            tests: testList
+                        };
+                        suiteList.push(suite);
+                        const cases = node.tests;
+                        cases.forEach((testCase) => {
+                            const test = {
+                                id: testCase.id,
+                                name: testCase.name
+                            };
+                            testList.push(test);
+                        });
+                    });
+                    res.json(suiteList);
+                }
+            );
+
+            /**
+             *  Find test information for specified ids
+             *  @param {Object} suite - test suite information
+             *  @param {string} tid - test case id
+             *  @returns {Object} test information
+             */
+            function findTest(suite, tid) {
+                if (suite) {
+                    const tests = suite.tests;
+                    const test = tests.find((t) => {
+                        return (t.id === tid);
+                    });
+                    if (test) {
+                        return test;
+                    }
+                }
+                return null;
+            }
+
+            /**
+             *  Register actions for a test case
+             *  @param {Object} suite - test suite information
+             *  @param {Object} test - test case information
+             *  @returns {Promise}
+             */
+            function registerTestActions(suite, test) {
+                log("Running test: " +test.name);
+                const sid = suite.id;
+                const tid = test.id;
+                let promise = Promise.resolve();
+                const actions = test.actions;
+                var events = Object.keys(actions);
+                events.forEach(function (event) {
+                    promise = promise.then(() => {
+                        return registerActions(event,
+                                               actions[event],
+                                               sid, tid);
                     });
                 });
+                return promise;
+            }
+
+            /**
+             *  Count number of expected checks for test case
+             *  @param {Object} map - action definition
+             *  @returns {Number} number of checks
+             */
+            function countNumberOfChecks(map) {
+                var count = 0;
+                var events = Object.keys(map);
+                events.forEach(function (event) {
+                    var evMap = map[event];
+                    var nodes = Object.keys(evMap);
+                    nodes.forEach(function (node) {
+                        var acts = evMap[node];
+                        acts.forEach(function (act) {
+                            if ((act.kind === "match") ||
+                                ((act.kind === "function") &&
+                                 act.performCheck)) {
+                                count++;
+                            }
+                        });
+                    });
+                });     
+                return count;
+            }
+
+            // API for executing a test case
+            RED.httpAdmin.get(
+                "/flow-tester/runTestCase/:suite/:test",
+                routeAuthHandler,
+                (req, res) => {
+                    const params = req.params;
+                    const sid = params.suite;
+                    const tid = params.test;
+                    const suite = RED.nodes.getNode(sid);
+                    const test = findTest(suite, tid);
+                    
+                    numberOfChecks = countNumberOfChecks(test.actions);
+
+                    if (test) {
+                        init().then(() => {
+                            return registerTestActions(suite, test);
+                        }).then(() => {
+                            return setup(suite.maxActions)
+                        }).then(() => {
+                            var timeout = (test.timeout || TIMEOUT) *1000;
+                            return executeWait(timeout);
+                        }).then(() => {
+                            return cleanup(); 
+                        }).then(() => {
+                            const result = {
+                                result: {
+                                    all: numberOfChecks,
+                                    success: successActions.length,
+                                    fail: failActions.length
+                                },
+                                info: {
+                                    success: successActions,
+                                    fail: failActions
+                                }
+                            };
+                            res.json(result);
+                        }).catch((err) => {
+                            const msg = "error: " +err;
+                            console.log(msg);
+                            res.sendStatus(400);
+                        });
+                        return;
+                    }
+                    res.sendStatus(400);
+                }
+            );
+
         }
     });
-
 };

From 1f457f6304aa3f17fb2cf1736a04b496dfe408f4 Mon Sep 17 00:00:00 2001
From: Hiroyasu Nishiyama <hiroyasu.nishiyama.uq@hitachi.com>
Date: Mon, 13 Dec 2021 10:48:44 +0900
Subject: [PATCH 5/9] add action addon with examples & other fixes

---
 bin/flow-test.js                              |  11 +-
 .../.gitignore                                |   5 +
 .../LICENSE                                   | 201 +++++++++++
 .../README.md                                 |  55 +++
 .../package.json                              |  38 ++
 .../scripts/build.js                          |  51 +++
 .../src/flow-tester-addon.html                | 142 ++++++++
 .../src/flow-tester-addon.js                  |  48 +++
 .../src/locales/en-US/flow-tester-addon.json  |   4 +
 .../src/style.css                             |   0
 .../test/test.js                              |   2 +
 src/flow-tester.html                          | 332 ++++++++++++------
 src/flow-tester.js                            | 153 +++++++-
 13 files changed, 926 insertions(+), 116 deletions(-)
 create mode 100644 examples/node-red-contrib-flow-tester-addon/.gitignore
 create mode 100644 examples/node-red-contrib-flow-tester-addon/LICENSE
 create mode 100644 examples/node-red-contrib-flow-tester-addon/README.md
 create mode 100644 examples/node-red-contrib-flow-tester-addon/package.json
 create mode 100644 examples/node-red-contrib-flow-tester-addon/scripts/build.js
 create mode 100644 examples/node-red-contrib-flow-tester-addon/src/flow-tester-addon.html
 create mode 100644 examples/node-red-contrib-flow-tester-addon/src/flow-tester-addon.js
 create mode 100644 examples/node-red-contrib-flow-tester-addon/src/locales/en-US/flow-tester-addon.json
 create mode 100644 examples/node-red-contrib-flow-tester-addon/src/style.css
 create mode 100644 examples/node-red-contrib-flow-tester-addon/test/test.js

diff --git a/bin/flow-test.js b/bin/flow-test.js
index cfc1396..a03ca40 100644
--- a/bin/flow-test.js
+++ b/bin/flow-test.js
@@ -13,7 +13,8 @@ function parseArgs(args) {
     const shortHands = {
         't': ["--target"],
         'l': ["--list"],
-        'r': ["--run"]
+        'r': ["--run"],
+        'j': ["--json"],
     };
     return nopt(knownOpts, shortHands, args, 2);
 }
@@ -31,8 +32,12 @@ async function getList(target) {
     }
 }
 
-async function doList(target) {
+async function doList(target, jsonOutput) {
     const list = await getList(target);
+    if (jsonOutput) {
+        console.log(JSON.stringify(list, undefined, "\t"));
+        return;
+    }
     let id = 0;
     list.forEach((tcase) => {
         console.log(`${tcase.name}`);
@@ -74,7 +79,7 @@ async function main(args) {
         target = opts.target;
     }
     if (opts.list) {
-        await doList(target);
+        await doList(target, opts.json);
     }
     if (opts.run) {
         const res = await doRun(target, Number(opts.run));
diff --git a/examples/node-red-contrib-flow-tester-addon/.gitignore b/examples/node-red-contrib-flow-tester-addon/.gitignore
new file mode 100644
index 0000000..75b9df9
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-addon/.gitignore
@@ -0,0 +1,5 @@
+node_modules
+dist
+package-lock.json
+.nyc_output
+resources
diff --git a/examples/node-red-contrib-flow-tester-addon/LICENSE b/examples/node-red-contrib-flow-tester-addon/LICENSE
new file mode 100644
index 0000000..261eeb9
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-addon/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/examples/node-red-contrib-flow-tester-addon/README.md b/examples/node-red-contrib-flow-tester-addon/README.md
new file mode 100644
index 0000000..ca2e0fd
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-addon/README.md
@@ -0,0 +1,55 @@
+# node-red-flow-tester-addon
+
+An Sample Addon to Flow Testing plugin for Node-RED
+
+**This is under development and not ready for general use. If you want to contribute, come talk to us in the `#core-dev` channel on https://nodered.org/slack
+
+## Developing
+
+To use the development version of Flow Tester Addon you can clone its source code repository
+and build it yourself.
+
+1. Get the source code
+
+```
+git clone https://github.com/node-red/node-red-flow-tester-addon.git
+```
+
+2. Install the dependencies
+
+```
+cd node-red-flow-tester-addon
+npm install
+```
+
+3. Build the plugin
+
+```
+npm run build
+```
+
+4. Install into Node-RED
+
+```
+cd ~/.node-red
+npm install <path-to-node-red-flow-tester-addon-directory>
+```
+
+5. Restart Node-RED to load the plugin.
+
+### Source code structure
+
+ - `scripts` - build scripts used by `npm run build`
+ - `src` - source code of the plugins
+ - `test` - tests material
+
+After `npm run build` is run, the following directories will be created:
+
+ - `dist` - contains the built plugin files
+ - `resources` contains the built plugin resource files (eg css)
+
+## License
+
+Copyright Node-RED Project Contributors.
+
+Licensed under the [Apache License, Version 2.0](LICENSE).
diff --git a/examples/node-red-contrib-flow-tester-addon/package.json b/examples/node-red-contrib-flow-tester-addon/package.json
new file mode 100644
index 0000000..f29a632
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-addon/package.json
@@ -0,0 +1,38 @@
+{
+    "name": "node-red-contrib-flow-tester-addon",
+    "version": "0.0.1",
+    "description": "A test plugin for flow tester addon",
+    "scripts": {
+        "build": "node scripts/build.js",
+        "dev": "nodemon --exec 'npm run build'  -i dist -i resources -e 'css js html'",
+        "test": "nyc mocha"
+    },
+    "keywords": [
+        "node-red",
+        "testing"
+    ],
+    "files": [
+        "dist",
+        "resources"
+    ],
+    "license": "Apache-2",
+    "node-red": {
+        "version": ">=2.0.0",
+        "plugins": {
+            "flow-tester-addon": "dist/flow-tester-addon.js"
+        }
+    },
+    "contributors": [
+        {
+            "name": "Hiroyasu Nishiyama",
+            "email": "hiroyasu.nishiyama.uq@hitachi.com"
+	}
+    ],
+    "devDependencies": {
+        "fs-extra": "^10.0.0",
+        "html-minifier": "^4.0.0",
+        "nodemon": "^2.0.7",
+        "nyc": "^15.1.0",
+        "mocha": "^8.4.0"
+    }
+}
diff --git a/examples/node-red-contrib-flow-tester-addon/scripts/build.js b/examples/node-red-contrib-flow-tester-addon/scripts/build.js
new file mode 100644
index 0000000..169b5c5
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-addon/scripts/build.js
@@ -0,0 +1,51 @@
+const minify = require("html-minifier").minify;
+const fs = require("fs-extra");
+const path = require("path");
+
+
+const projectRoot = path.join(__dirname,"..")
+const resources = path.join(projectRoot,"resources");
+const dist = path.join(projectRoot,"dist");
+const src = path.join(projectRoot,"src");
+
+const assets = {}
+assets[dist] = [
+    "locales",
+    "flow-tester-addon.html",
+    "flow-tester-addon.js"
+]
+assets[resources] = [
+    "style.css"
+]
+
+async function copyStaticAssets(dist,assets) {
+    await fs.mkdir(dist,{recursive: true});
+    for (let i=0; i<assets.length; i++) {
+        if (/\.html/.test(assets[i])) {
+            const content = await fs.readFile(path.join(src,assets[i]),"utf-8")
+            await fs.writeFile(path.join(dist,assets[i]), minify(content, {minifyCSS: true, minifyJS: true}))
+        } else if (/\.js/.test(assets[i])) {
+            await fs.copy(path.join(src,assets[i]),path.join(dist,assets[i]))
+        } else if (/\.css/.test(assets[i])) {
+            const rawCSS = await fs.readFile(path.join(src,assets[i]),"utf-8");
+            const minifiedCSS = minify("<style>"+rawCSS+"</style>", {minifyCSS: true});
+            const finalCSS = minifiedCSS.substring(7,minifiedCSS.length-8)
+            await fs.writeFile(path.join(dist,assets[i]), finalCSS)
+        } else {
+            await fs.mkdir(path.join(dist,assets[i]), {recursive: true});
+            await fs.copy(path.join(src,assets[i]),path.join(dist,assets[i]))
+        }
+    }
+}
+
+
+
+(async function() {
+    const destinations = Object.keys(assets);
+    for (let i=0, l=destinations.length; i<l; i++) {
+        await copyStaticAssets(destinations[i],assets[destinations[i]]);
+    }
+})().catch(err => {
+    console.error(err);
+    process.exit(1);
+});
diff --git a/examples/node-red-contrib-flow-tester-addon/src/flow-tester-addon.html b/examples/node-red-contrib-flow-tester-addon/src/flow-tester-addon.html
new file mode 100644
index 0000000..a2afe29
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-addon/src/flow-tester-addon.html
@@ -0,0 +1,142 @@
+// Example addon for flow tester action
+<link rel="stylesheet" href="resources/node-red-contrib-flow-tester-addon/style.css">
+
+<script type="text/javascript">
+(function() {
+    RED.plugins.registerPlugin("node-red-contrib--flow-tester-addon", {
+        type: "flow-tester-addon",
+        onadd: function() {
+        },
+        onremove: function() {
+        },
+        actions: function () {
+            return [
+                // plugin for outputting string to console
+                {
+                    name: "addon:example1",
+                    label: "output",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+                        var span = $("<span/>", {
+                            class: "addon-output-span"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var input = $("<input/>", {
+                            type: "text",
+                            class: "addon-output-input",
+                        }).css({
+                            "margin-bottom": "0px"
+                        }).appendTo(span);
+                        if (data && data.value) {
+                            input.val(data.value);
+                        }
+                        span.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span = row0.find(".addon-output-span");
+                        span.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span = row0.find(".addon-output-span");
+                        span.hide();
+                    },
+                    onSave: function (con) {
+                        var val = con.find(".addon-output-input").val();
+                        return {
+                            value: val,
+                            performCheck: false
+                        };
+                    }
+                },
+                {
+                    name: "addon:example2",
+                    label: "regexp match",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        if (node.type === "flow-test-config") {
+                            // only applicable to node events
+                            return false;
+                        }
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+                        var span = $("<span/>", {
+                            class: "addon-regexp-span"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var input = $("<input/>", {
+                            type: "text",
+                            class: "addon-regexp-input",
+                        }).css({
+                            "margin-bottom": "0px"
+                        }).appendTo(span);
+                        if (data && data.value) {
+                            input.val(data.value);
+                        }
+                        span.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span = row0.find(".addon-regexp-span");
+                        if (span) {
+                            span.show();
+                        }
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span = row0.find(".addon-regexp-span");
+                        if (span) {
+                            span.hide();
+                        }
+                    },
+                    onSave: function (con) {
+                        var val = con.find(".addon-regexp-input").val();
+                        return {
+                            value: val,
+                            performCheck: true
+                        };
+                    }
+                }
+            ];
+        }
+    });
+
+})();
+</script>
diff --git a/examples/node-red-contrib-flow-tester-addon/src/flow-tester-addon.js b/examples/node-red-contrib-flow-tester-addon/src/flow-tester-addon.js
new file mode 100644
index 0000000..551e77b
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-addon/src/flow-tester-addon.js
@@ -0,0 +1,48 @@
+module.exports = (RED) => {
+    "use strict";
+
+    console.log("; Initialize flow tester addon");
+    RED.plugins.registerPlugin('node-red-flow-tester-addon', {
+        type: "flow-tester-addon",
+        actions: function () {
+            return [
+                {
+                    name: "addon:example1",
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            console.log(action.value);
+                            resolve();
+                        });
+                    }
+                },
+                {
+                    name: "addon:example2",
+                    execute: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            const msg = opt.msg;
+                            const payload = msg.payload;
+                            if (payload) {
+                                try {
+                                    const action = opt.action;
+                                    const rex = new RegExp(action.value);
+                                    if (rex.test(payload)) {
+                                        resolve();
+                                    }
+                                }
+                                catch (e) {
+                                    console.log("error:", e);
+                                }
+                            }
+                            reject();
+                        });
+                    }
+                }
+            ];
+        }
+    });
+};
diff --git a/examples/node-red-contrib-flow-tester-addon/src/locales/en-US/flow-tester-addon.json b/examples/node-red-contrib-flow-tester-addon/src/locales/en-US/flow-tester-addon.json
new file mode 100644
index 0000000..3f29600
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-addon/src/locales/en-US/flow-tester-addon.json
@@ -0,0 +1,4 @@
+{
+    "label": {
+    }
+}
diff --git a/examples/node-red-contrib-flow-tester-addon/src/style.css b/examples/node-red-contrib-flow-tester-addon/src/style.css
new file mode 100644
index 0000000..e69de29
diff --git a/examples/node-red-contrib-flow-tester-addon/test/test.js b/examples/node-red-contrib-flow-tester-addon/test/test.js
new file mode 100644
index 0000000..be2c5fa
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-addon/test/test.js
@@ -0,0 +1,2 @@
+describe("Flow tester addon tests", function() {
+});
diff --git a/src/flow-tester.html b/src/flow-tester.html
index e9d0499..807143b 100644
--- a/src/flow-tester.html
+++ b/src/flow-tester.html
@@ -14,7 +14,7 @@
     var suites = [];
     var id2suite = {};
     var id2test = {};
-    
+
     var selectedTestID = undefined;
 
     var currentTestSuite = null;
@@ -30,6 +30,8 @@
 
     var currentExecution = Promise.resolve();
     
+    var addonList = [];
+
     var MAX_LOG = 1000;
     var logs = [];
 
@@ -108,9 +110,7 @@
             for (let node of nodes) {
                 var acts = evMap[node];
                 for (let act of acts) {
-                    if ((act.kind === "match") ||
-                        ((act.kind === "function") &&
-                         act.performCheck)) {
+                    if (act.performCheck) {
                         count++;
                     }
                 }
@@ -119,6 +119,11 @@
         return count;
     }
 
+    function clearMatchResults() {
+        testResult.success = 0;
+        testResult.fail = 0;
+    }
+
     /**
      *  Execute a test case
      *  @param {Object} suiteNode - config node for test suite
@@ -139,9 +144,7 @@
             currentTestCase = tid;
 
             numberOfChecks = countNumberOfChecks(actions);
-
-            testResult.success = 0;
-            testResult.fail = 0;
+            clearMatchResults();
 
             addLog("Running test: " +testCase.name);
             return invokeAction("init", {});
@@ -227,7 +230,7 @@
             timeout: TIMEOUT,
             max_actions: MAX_ACTIONS,
             actions: {
-                // test specific events
+                // common events
                 setup: {},
                 cleanup: {},
                 // node specific events
@@ -470,6 +473,17 @@
         });
     }
 
+    function findAddonAction(name) {
+        for (let addon of addonList) {
+            for (let def of addon.actions()) {
+                if (def.name === name) {
+                    return def;
+                }
+            }
+        }
+        return null;
+    }
+
     /**
      *  Check that specified node belongs to a flow 
      *  @param {Object} node - node to be checked
@@ -480,13 +494,40 @@
         return (!sf);
     }
 
+    function unselectAllAddon(opt) {
+        for (let addon of addonList) {
+            for (let def of addon.actions()) {
+                const onUnselect = def.onUnselect;
+                if (onUnselect) {
+                    onUnselect(opt);
+                }
+            }
+        }
+    }
+
+    function prepareAllAddon(opt) {
+        var actions = [];
+        for (let addon of addonList) {
+            for (let def of addon.actions()) {
+                const onAddItem = def.onAddItem;
+                if (onAddItem) {
+                    if (onAddItem(opt)) {
+                        actions.push(def);
+                    }
+                }
+            }
+        }
+        return actions;
+    }
+
     /**
      *  Create a tab for setting event information
      *  @param {string} id - ID of DOM element
      *  @param {Object} container - enclosing DOM element
      *  @param {Object} node - target node 
+     *  @param {string} event - name of event 
      */
-    function createEventTab(id, container, node) {
+    function createEventTab(id, container, node, event) {
         var div = $("<div/>", {
             id: id
         }).css({
@@ -529,17 +570,6 @@
                     "margin-left": "5px",
                     "margin-bottom": "0px",
                 }).appendTo(row0);
-                var actions =
-                    (node.type === "flow-test-config") ? [
-                        "click", "send", "wait", "function"
-                    ] : [
-                        "click", "send", "set", "match", "wait", "function"
-                    ];
-                for (let action of actions) {
-                    $("<option/>", {
-                    }).val(action).text(action).appendTo(kind);
-                }
-                $(kind).val("click");
 
                 var valSpan = $("<span/>").appendTo(row0);
                 var valField = $("<input/>", {
@@ -672,6 +702,33 @@
                     ]
                 });
 
+                var activeActions = prepareAllAddon({
+                    node: node,
+                    event: event,
+                    container: con,
+                    selectRow: row0,
+                    data: opt
+                });
+
+                var actions =
+                    (node.type === "flow-test-config") ? [
+                        "click", "send", "wait", "log", "function"
+                    ] : [
+                        "click", "send", "set", "match", "wait", "log", "function"
+                    ];
+                for (let action of actions) {
+                    $("<option/>", {
+                    }).val(action).text(action).appendTo(kind);
+                }
+                for (let def of activeActions) {
+                    const name = def.name;
+                    const label = def.label;
+                    $("<option/>", {
+                    }).val(name).text(label).appendTo(kind);
+                }
+
+                $(kind).val("click");
+
                 // node label for selection menu
                 function nodeLabel(node) {
                     const name = node.type +":" +node.id;
@@ -706,6 +763,63 @@
                     $("<option/>").text(name).val(id).appendTo(clickTarget);
                 }
 
+                $(kind).on("change", function (ev) {
+                    $(valSpan).hide();
+                    $(clickTargetSpan).hide();
+                    $(numSpan).hide();
+                    $(varSpan).hide();
+                    $(jsSpan).hide();
+
+                    $(row1).hide();
+                    $(row2).hide();
+                    $(row3).hide();
+
+                    unselectAllAddon({
+                        container: con,
+                        selectRow: row0
+                    });
+                    var val = $(kind).val();
+                    if(val === "send") {
+                        $(valSpan).show();
+                        $(row1).show();
+                    }
+                    else if (val === "click") {
+                        $(clickTargetSpan).show();
+                    }
+                    else if (val === "set") {
+                        $(varSpan).show();
+                        $(row2).show();
+                    }
+                    else if (val === "match") {
+                        $(valSpan).show();
+                    }
+                    else if (val === "wait") {
+                        $(numSpan).show();
+                    }
+                    else if (val === "log") {
+                        $(valSpan).show();
+                    }
+                    else if (val === "function") {
+                        $(jsSpan).show();
+                        $(row3).show();
+                    }
+                    else {
+                        var action = findAddonAction(val);
+                        if (action) {
+                            const onSelect = action.onSelect;
+                            if (onSelect) {
+                                onSelect({
+                                    container: con,
+                                    selectRow: row0
+                                });
+                            }
+                        }
+                        else {
+                            throw new Error("unexpected action:"+val);
+                        }
+                    }
+                });
+
                 if (opt) {
                     var act_kind = opt.kind;
                     if (act_kind) {
@@ -725,6 +839,7 @@
                             var act_target = opt.target;
                             if (act_target) {
                                 $(clickTarget).val(act_target);
+
                             }
                             break;
                         case "set":
@@ -754,6 +869,11 @@
                                 $(numField).typedInput("value", opt.wait);
                             }
                             break;
+                        case "log":
+                            if (opt.hasOwnProperty("value")) {
+                                $(valField).typedInput("value", opt.value);
+                            }
+                            break;
                         case "function":
                             if (opt.code) {
                                 $(jsField).typedInput("value", opt.code);
@@ -761,68 +881,13 @@
                             checkInJS.prop("checked", !!opt.performCheck);
                             break;
                         default:
-                            throw new Error("unexpected kind of action: " +kind);
+                            if (!findAddonAction(act_kind)) {
+                                throw new Error("unexpected kind of action: " +act_kind);
+                            }
                             break;
                         }
                     }
                 }
-
-                $(kind).on("change", function (ev) {
-                    $(row1).hide();
-                    $(row2).hide();
-                    $(row3).hide();
-
-                    var val = $(kind).val();
-                    if(val === "send") {
-                        $(valSpan).show();
-                        $(varSpan).hide();
-                        $(clickTargetSpan).hide();
-                        $(numSpan).hide();
-                        $(jsSpan).hide();
-                        $(row1).show();
-                    }
-                    else if (val === "click") {
-                        $(valSpan).hide();
-                        $(varSpan).hide();
-                        $(clickTargetSpan).show();
-                        $(numSpan).hide();
-                        $(jsSpan).hide();
-                    }
-                    else if (val === "set") {
-                        $(valSpan).hide();
-                        $(varSpan).show();
-                        $(clickTargetSpan).hide();
-                        $(numSpan).hide();
-                        $(jsSpan).hide();
-                        $(row2).show();
-                    }
-                    else if (val === "match") {
-                        $(valSpan).show();
-                        $(varSpan).hide();
-                        $(clickTargetSpan).hide();
-                        $(numSpan).hide();
-                        $(jsSpan).hide();
-                    }
-                    else if (val === "wait") {
-                        $(valSpan).hide();
-                        $(varSpan).hide();
-                        $(clickTargetSpan).hide();
-                        $(numSpan).show();
-                        $(jsSpan).hide();
-                    }
-                    else if (val === "function") {
-                        $(valSpan).hide();
-                        $(varSpan).hide();
-                        $(clickTargetSpan).hide();
-                        $(numSpan).hide();
-                        $(jsSpan).show();
-                        $(row3).show();
-                    }
-                    else {
-                        throw new Error("unexpected action:"+val);
-                    }
-                });
-
                 $(kind).change();
             },
             removable: true,
@@ -1094,10 +1159,11 @@
      *  @returns {array} array of events
      */
     function nodeEvents(node) {
-        var events = [];
+        var events = ["setup", "cleanup"];
         if (node.inputs > 0) {
             // if node has input port, recv and stub events supported
-            events = ["recv", "stub"];
+            events.push("recv");
+            events.push("stub");
         }
         if (node.outputs > 0) {
             // if node has output port, send event supported
@@ -1195,19 +1261,19 @@
             }
         });
         var events = null;
+        // common events & actions
+        createEventTab("node-test-event-tab-setup", tabContainer, node, "setup");
+        createEventTab("node-test-event-tab-cleanup", tabContainer, node, "cleanup"); 
+        tabs.addTab({
+            id: "node-test-event-tab-setup",
+            label: "setup"
+        });
+        tabs.addTab({
+            id: "node-test-event-tab-cleanup",
+            label: "cleanup"
+        });
+        tabs.activateTab("node-test-event-tab-setup");
         if (node.type === "flow-test-config") {
-            // flow events & actions
-            createEventTab("node-test-event-tab-setup", tabContainer, node);
-            createEventTab("node-test-event-tab-cleanup", tabContainer, node); 
-            tabs.addTab({
-                id: "node-test-event-tab-setup",
-                label: "setup"
-            });
-            tabs.addTab({
-                id: "node-test-event-tab-cleanup",
-                label: "cleanup"
-            });
-            tabs.activateTab("node-test-event-tab-setup");
             events = ["setup", "cleanup"];
         }
         else {
@@ -1217,20 +1283,20 @@
 
             events = nodeEvents(node);
             if (hasInput) {
-                createEventTab("node-test-event-tab-recv", tabContainer, node); 
+                createEventTab("node-test-event-tab-recv", tabContainer, node, "recv"); 
                 tabs.addTab({
                     id: "node-test-event-tab-recv",
                     label: "receive"
                 });
 
-                createEventTab("node-test-event-tab-stub", tabContainer, node); 
+                createEventTab("node-test-event-tab-stub", tabContainer, node, "stub"); 
                 tabs.addTab({
                     id: "node-test-event-tab-stub",
                     label: "stub"
                 });
             }
             if (hasOutput) {
-                createEventTab("node-test-event-tab-send", tabContainer, node); 
+                createEventTab("node-test-event-tab-send", tabContainer, node, "send"); 
                 tabs.addTab({
                     id: "node-test-event-tab-send",
                     label: "send"
@@ -1271,6 +1337,14 @@
         }
     }
 
+    function clearLog() {
+        logs = [];
+        if (logEditor) {
+            var session = logEditor.getSession();
+            session.setValue("", -1);
+        }        
+    }
+
     /**
      *  Handle node settings dialog prepare event for setting up flow
      *  test tab 
@@ -1363,9 +1437,23 @@
         }).css({
             margin: "5px",
             width: "95%",
-            height: "95%",
+            height: "calc(95% - 10px)",
             "min-height": "150px",
         }).appendTo(logPanel);
+        var logControl = $("<div/>", {
+        }).css({
+            "text-align": "right",
+            "margin-right": "20px"
+        }).appendTo(logPanel);
+        var logClearButton = $("<i/>", {
+            class: "red-ui-button red-ui-button-small"
+        }).css({
+            "margin-left": "3px"
+        }).appendTo(logControl);
+        $("<i/>", {
+            class: "fa fa-trash"
+        }).appendTo(logClearButton);
+
         panels = RED.panels.create({
             container: stackContainer
         });
@@ -1380,7 +1468,7 @@
         $("<label/>").css({
             "margin-left": "5px",
         }).text("Run Tests").appendTo(controlDiv);
-
+                      
         createTestSuites(testsPanel);
 
         runButton.on("click", function (ev) {
@@ -1396,6 +1484,14 @@
             lineNumbers: false,
             readOnly: true,
         });
+
+        logClearButton.on("click", function (ev) {
+            ev.preventDefault();
+            ev.stopPropagation();
+            clearLog();
+        });
+
+
         setTimeout(function () {
             addLog("Starting Flow Tester");
         }, 1000);
@@ -1560,11 +1656,16 @@
                     case "match":
                         var value = typedInputValue($(this).find(".action-value"));
                         action.value = value;
+                        action.performCheck = true;
                         break;
                     case "wait":
                         var wait = $(this).find(".action-wait-ms").typedInput("value");
                         action.wait = wait;
                         break;
+                    case "log":
+                        var value = typedInputValue($(this).find(".action-value"));
+                        action.value = value;
+                        break;
                     case "function":
                         var code = $(this).find(".action-js").typedInput("value");
                         var check = $(this).find(".action-js-perform-check").prop("checked");
@@ -1572,7 +1673,17 @@
                         action.performCheck = check;
                         break;
                     default:
-                        throw new Error("unexpected kind of action: " +kind);
+                        var addon = findAddonAction(kind);
+                        if (addon) {
+                            var onSave = addon.onSave;
+                            if (onSave) {
+                                action = onSave($(this));
+                                action.kind = kind;
+                            }
+                        }
+                        else {
+                            throw new Error("unexpected kind of action: " +kind);
+                        }
                         break;
                     }
                     acts.push(action);
@@ -1639,7 +1750,7 @@
     });
     
     //  Internal API for handling overflow of actions execution count 
-    RED.comms.subscribe("flow-test:maxActions", function (type) {
+    RED.comms.subscribe("flow-test:maxActions", function (type, opt) {
         var msg = `"Exceeded max actions count: ${MAX_ACTIONS}`;
         addLog("- "+msg);
         invokeAction("cleanup").then(function () {
@@ -1647,6 +1758,12 @@
         });
     });
 
+    //  Clear results of match actions
+    RED.comms.subscribe("flow-test:clear-match-result", function (type, opt) {
+        numberOfChecks = countNumberOfChecks(actions);
+        clearMatchResults();
+    });
+
     //  Handle results of match actions
     RED.comms.subscribe("flow-test:match-result", function (type, opt) {
         if (opt.result) {
@@ -1680,9 +1797,24 @@
         RED.view.clickNodeButton(node);
     });
 
+    function registerAddon(addon) {
+        addonList.push(addon);
+    }
+
     // Register flow testing plugin
     RED.plugins.registerPlugin("node-red-flow-tester", {
         onadd: function() {
+            var plugins = RED.plugins.getPluginsByType('flow-tester-addon');
+            plugins.forEach(function(plugin) {
+                registerAddon(plugin);
+            })
+            RED.events.on("registry:plugin-added", function (id) {
+                var plugin = RED.plugins.getPlugin(id);
+                if (plugin.type === "flow-tester-addon") {
+                    registerAddon(plugin);
+                }
+            });
+
             var content = $("<div/>").addClass("red-ui-flow-tester");
             var toolbar = $('<div/>');
 
@@ -1711,6 +1843,8 @@
             RED.events.on("editor:save", handleNodeSave);
             
             RED.actions.add("flow-tester:show-flow-tester-tab", show);
+        },
+        onremove: function() {
         }
     });
 
diff --git a/src/flow-tester.js b/src/flow-tester.js
index e683b4b..fe2d221 100644
--- a/src/flow-tester.js
+++ b/src/flow-tester.js
@@ -27,6 +27,8 @@ module.exports = (RED) => {
         send: [],		// executed on message send
     };
 
+    var addonList = [];
+
     /**
      *  Add event log to editor sidebar log area
      *  @param {string} msg - message to be added
@@ -47,7 +49,7 @@ module.exports = (RED) => {
      *  Notify that execution reached the maxnimum number
      */
     function reportMaxActions() {
-        RED.comms.publish("flow-test:notifyMaxActions");
+        RED.comms.publish("flow-test:maxActions", {});
     }
 
     /**
@@ -87,6 +89,17 @@ module.exports = (RED) => {
         return Promise.resolve(true);
     }
 
+    /**
+     *  Execute log action: log message
+     *  @param {string} value - logged string 
+     *  @returns {Promise}
+     */
+    function executeLog(value) {
+        log(`log: ${value}`);
+        RED.log.info(value);
+        return Promise.resolve(true);
+    }
+
     /**
      *  Execute set action: set value to msg, flow context, or global context
      *  @param {Object} dst - destination location (type, value)
@@ -264,6 +277,21 @@ module.exports = (RED) => {
         return vm.runInContext(script, ctx);
     }
 
+    /**
+     *  Find addon action definition 
+     *  @param {string} name - name of action
+     *  @returns {Object} action definition
+     */
+    function findAddonAction(name) {
+        for (let addon of addonList) {
+            for (let def of addon.actions()) {
+                if (def.name === name) {
+                    return def;
+                }
+            }
+        }
+        return null;
+    }
 
     /**
      *  Execute action
@@ -276,7 +304,7 @@ module.exports = (RED) => {
         actionCount++;
         if (actionCount >= maxActions) {
             reportMaxActions();
-            return Promise.resolve(true);
+            throw new Error("action count exceeded limit");
         }
         try {
             switch (action.kind) {
@@ -284,6 +312,8 @@ module.exports = (RED) => {
                 return executeSend(action.target, action.value);
             case "click":
                 return executeClick(action.target);
+            case "log":
+                return executeLog(action.value);
             case "set":
                 return executeSet(action.dst, action.src, node, msg);
             case "match":
@@ -296,11 +326,17 @@ module.exports = (RED) => {
                                        node, msg,
                                        action.index, action.suiteID, action.testID);
             default:
-                return Promise.rejject(new Error("unexpected kind of action: " +action.kind));
+                const addon = findAddonAction(action.kind);
+                if (addon) {
+                    return executeAddonAction(addon, action, node, msg);
+                }
+                else {
+                    return Promise.reject(new Error("unexpected kind of action: " +action.kind));
+                }
             }
         }
         catch (e) {
-            const msg = "Error: "+ e;
+            const msg = "error: "+ e;
             log(msg);
             console.log(msg);
         }
@@ -315,16 +351,15 @@ module.exports = (RED) => {
      *  @returns {Promise}
      */
     function processEvent(actions, node, msg) {
+        let promise = Promise.resolve(true);
         if (actions) {
-            let promise = Promise.resolve(true);
             for (let action of actions) {
                 promise = promise.then(() => 
                     executeAction(action, node, msg)
                 );
             }
-            return promise;
         }
-        return Promise.resolve(true);
+        return promise;
     }
 
     /**
@@ -464,8 +499,20 @@ module.exports = (RED) => {
         actionCount = 0;
         successActions = [];
         failActions = [];
+        // execute global actions first
         const actions = actionMap.setup["_global_"];
-        return processEvent(actions, null, null);
+        let promise = processEvent(actions, null, null);
+        // then, execute nodes events
+        for (let id of Object.keys(actionMap.setup)) {
+            if (id !== "_global_") {
+                const actions = actionMap.setup[id];
+                promise = promise.then(() => {
+                    const node = RED.nodes.getNode(id);
+                    return processEvent(actions, node, null);
+                });
+            }
+        }
+        return promise;
     }
 
 
@@ -475,13 +522,64 @@ module.exports = (RED) => {
      *  @returns {Promise}
      */
     function cleanup() {
+        // execute global actions first
         const actions = actionMap.cleanup["_global_"];
-
-        return processEvent(actions, null, null).then(() => {
+        let promise = processEvent(actions, null, null);
+        // then, execute nodes events
+        for (let id of Object.keys(actionMap.setup)) {
+            if (id !== "_global_") {
+                const actions = actionMap.cleanup[id];
+                promise = promise.then(() => {
+                    const node = RED.nodes.getNode(id);
+                    return processEvent(actions, node, null);
+                });
+            }
+        }
+        // finally, clear actions
+        return promise.then(() => {
             clearActions();
         });
     }
 
+    function registerAddon(addon) {
+        addonList.push(addon);
+    }
+
+    function executeAddonAction(addon, action, node, msg) {
+        const exec = addon.execute;
+        const report = action.performCheck;
+        const index = action.index;
+        const sid = action.suiteID;
+        const tid = action.testID;;
+        if (exec) {
+            try {
+                return exec({
+                    action: action,
+                    node: node,
+                    msg: msg
+                }).then(() => {
+                    if (report) {
+                        reportResult(true, index, sid, tid);
+                    }
+                }).catch(() => {
+                    if (report) {
+                        reportResult(false, index, sid, tid);
+                    }
+                });;
+            }
+            catch (e) {
+                const msg = "error:"+ e;
+                log(msg);
+                console.log(msg);
+                if (report) {
+                    reportResult(false, index, sid, tid);
+                }
+                return Promise.reject();
+            }
+        };
+        return Promise.resolve();
+    }
+
     // Register flow testing plugin
     RED.plugins.registerPlugin('node-red-flow-tester', {
         settings: {
@@ -490,6 +588,18 @@ module.exports = (RED) => {
         onadd: () => {
             const routeAuthHandler = RED.auth.needsPermission("flow-tester.write");
 
+            var plugins = RED.plugins.getByType('flow-tester-addon');
+            plugins.forEach(function(plugin) {
+                registerAddon(plugin);
+            })
+            RED.events.on("registry:plugin-added", function (id) {
+                var plugin = RED.plugins.get(id);
+                if (plugin.type === "flow-tester-addon") {
+                    registerAddon(plugin);
+                }
+            });
+            
+
             // Internal APIs for flow testing
             RED.httpAdmin.post(
                 "/flow-tester/executeAction/:action",
@@ -522,6 +632,10 @@ module.exports = (RED) => {
                             // click the button of target node
                             // nothing to do
                             break;
+                        case "log":
+                            // log message
+                            promise = executeLog(opt.value);
+                            break;
                         case "set":
                             // set context or environment variable
                             promise = executeSet(opt.dst, opt.src);
@@ -535,7 +649,13 @@ module.exports = (RED) => {
                             promise = executeFunction(opt.code);
                             break;
                         default:
-                            console.log("unexpected action kind: ", kind);
+                            const addon = findAddonAction(action.kind);
+                            if (addon) {
+                                promise = executeAddonAction(addon, action, node, msg);
+                            }
+                            else {
+                                console.log("unexpected action kind: ", kind);
+                            }
                             break;
                         }
                         promise.then((result) => {
@@ -642,9 +762,7 @@ module.exports = (RED) => {
                     nodes.forEach(function (node) {
                         var acts = evMap[node];
                         acts.forEach(function (act) {
-                            if ((act.kind === "match") ||
-                                ((act.kind === "function") &&
-                                 act.performCheck)) {
+                            if (act.performCheck) {
                                 count++;
                             }
                         });
@@ -653,6 +771,10 @@ module.exports = (RED) => {
                 return count;
             }
 
+            function clearMatchResults() {
+                RED.comms.publish("flow-test:clear-match-result", {});
+            }
+
             // API for executing a test case
             RED.httpAdmin.get(
                 "/flow-tester/runTestCase/:suite/:test",
@@ -665,6 +787,7 @@ module.exports = (RED) => {
                     const test = findTest(suite, tid);
                     
                     numberOfChecks = countNumberOfChecks(test.actions);
+                    clearMatchResults();
 
                     if (test) {
                         init().then(() => {
@@ -700,6 +823,8 @@ module.exports = (RED) => {
                 }
             );
 
+        },
+        onremove: () => {
         }
     });
 };

From be3f75f24644e8002f41d10c955d2ebd41f951e6 Mon Sep 17 00:00:00 2001
From: Hiroyasu Nishiyama <hiroyasu.nishiyama.uq@hitachi.com>
Date: Wed, 22 Dec 2021 20:53:23 +0900
Subject: [PATCH 6/9] update addon mechanism & refine sidebar UI

---
 .../src/flow-tester-addon.js                  |  14 ++
 src/flow-tester.html                          | 134 ++++++++++++++++--
 src/flow-tester.js                            |  41 +++++-
 3 files changed, 172 insertions(+), 17 deletions(-)

diff --git a/examples/node-red-contrib-flow-tester-addon/src/flow-tester-addon.js b/examples/node-red-contrib-flow-tester-addon/src/flow-tester-addon.js
index 551e77b..9ffc684 100644
--- a/examples/node-red-contrib-flow-tester-addon/src/flow-tester-addon.js
+++ b/examples/node-red-contrib-flow-tester-addon/src/flow-tester-addon.js
@@ -8,6 +8,20 @@ module.exports = (RED) => {
             return [
                 {
                     name: "addon:example1",
+                    onTestStart: function () {
+                        let promise = Promise.resolve();
+                        promise = promise.then(() => {
+                            console.log("; start: addon:example1");
+                        });
+                        return promise;
+                    },
+                    onTestEnd: function () {
+                        let promise = Promise.resolve();
+                        promise = promise.then(() => {
+                            console.log("; end: addon:example1");
+                        });
+                        return promise;
+                    },
                     execute: function(opt) {
                         // opt object contains:
                         // - data: optional data for action
diff --git a/src/flow-tester.html b/src/flow-tester.html
index 807143b..932594f 100644
--- a/src/flow-tester.html
+++ b/src/flow-tester.html
@@ -16,6 +16,7 @@
     var id2test = {};
 
     var selectedTestID = undefined;
+    var selectedEvent = undefined;
 
     var currentTestSuite = null;
     var currentTestCase = null;
@@ -180,6 +181,84 @@
         return currentExecution;
     }
 
+    // node label for selection menu
+    function nodeLabel(node) {
+        const name = node.type +":" +node.id;
+        if (node.name && (node.name !== "")) {
+            return (node.name +" [" +name +"]");
+        }
+        return name;
+    }
+
+    function getNodeLabel(id, node, event) {
+        var div = $("<div/>", {
+            class: "red-ui-node-list-item red-ui-info-outline-item"
+        });
+        if (node) {
+            RED.utils.createNodeIcon(node, true).appendTo(div);
+            $(div).on("dblclick", function (ev) {
+                ev.preventDefault();
+                ev.stopPropagation();
+                selectedEvent = event;
+                RED.editor.edit(node);
+            });
+            $(div).on("mouseover", function (ev) {
+                node.highlighted = true;
+                node.dirty = true;
+                RED.view.redraw();
+            });
+            $(div).on("mouseout", function (ev) {
+                node.highlighted = false;
+                node.dirty = true;
+                RED.view.redraw();
+            });
+        }
+        else {
+            $("<span/>").text(id).appendTo(div);
+        }
+        return div;
+    }
+
+    function updateNodesInTestCase(test, tree) {
+        var treelist = tree.treeList;
+        var actions = test.actions;
+        for (var event of Object.keys(actions)) {
+            var nodeActions = actions[event];
+            var ids = Object.keys(nodeActions);
+            var hasAction = false;
+
+            for (var id of ids) {
+                var list = nodeActions[id];
+                if ((id !== "_global_") && (list.length > 0)) {
+                    hasAction = true;
+                    break;
+                }
+            }
+            if (!hasAction) {
+                continue;
+            }
+
+            var element = {
+                label: event,
+                icon: "fa fa-flash",
+                children: [],
+            };
+            treelist.addChild(element);
+
+            var eventlist = element.treeList;
+            for (var id of ids) {
+                var list = nodeActions[id];
+                if ((id !== "_global_") && (list.length > 0)) {
+                    var node = RED.nodes.node(id);
+                    var nodeElement = {
+                        element: getNodeLabel(id, node, event)
+                    };
+                    eventlist.addChild(nodeElement);
+                }
+            }
+        }
+    }
+
     /**
      *  Add new test case
      *  @param {Object} suiteNode - config node for test suite
@@ -191,13 +270,17 @@
         var sid = suiteNode.id;
         var suite = id2suite[sid];
         var treelist = suite.element.treeList;
-        var test = {
+        var children = [];
+        var element = {
             element: getTestCaseLabel(tid, name, suiteNode, newTest),
             icon: "fa fa-file-text-o",
+            children: children,
+            deferBuild: true,
         };
-        treelist.addChild(test);
+        treelist.addChild(element);
+        updateNodesInTestCase(newTest, element);
         treelist.expand();
-        id2test[tid] = test;
+        id2test[tid] = element;
     }
 
 
@@ -729,15 +812,6 @@
 
                 $(kind).val("click");
 
-                // node label for selection menu
-                function nodeLabel(node) {
-                    const name = node.type +":" +node.id;
-                    if (node.name && (node.name !== "")) {
-                        return (node.name +" [" +name +"]");
-                    }
-                    return name;
-                }
-
                 var sendNodes = RED.nodes.filterNodes({
                 }).filter(function (n) {
                     return (isMemberOfFlow(n) &&
@@ -1178,7 +1252,7 @@
      *  @param {Object} node - target node
      *  @param {string} testID - test case id
      */
-    function buildFlowTestTab(container, node, testID) {
+    function buildFlowTestTab(container, node, testID, event) {
         var isConfig = (node.type === "flow-test-config");
         var labelRow = $("<div/>", {
             class: "form-row",
@@ -1309,6 +1383,9 @@
                 tabs.activateTab("node-test-event-tab-send");
             }
         }
+        if (event) {
+            tabs.activateTab("node-test-event-tab-"+event);
+        }
 
         createTestSelector(
             node,
@@ -1354,6 +1431,7 @@
         var node = opt.node;
         if (node.type === "flow-test-config") {
             buildFlowTestTab($("#test-actions-container"), node, selectedTestID);
+            selectedTestID = undefined;
             return;
         }
         if (node._def.category === "config") {
@@ -1376,8 +1454,12 @@
             class: "dialog-form form-hirizontal"
         }).appendTo(flowTestTab.content);
 
-        buildFlowTestTab(dialogForm, node);
+        buildFlowTestTab(dialogForm, node, undefined, selectedEvent);
         tabs.addTab(flowTestTab);
+        if (selectedEvent) {
+            tabs.activateTab("editor-tab-flow-test");
+            selectedEvent = undefined;
+        }
     }
 
     /**
@@ -1498,6 +1580,16 @@
         logEditor.resize();
     }
 
+    function updateTestCaseNodes(testCase, element) {
+        // todo
+        if (element.element &&
+            element.element.treelist) {
+            element.element.treelist.empty();
+        }
+        element.children = [];
+        updateNodesInTestCase(testCase, element);
+    }
+
     /**
      *  Update sidebar contents related to specified node
      *  @param {Object} suiteNode - config node for test suite
@@ -1512,9 +1604,11 @@
         var tests = suiteNode.tests;
         for (let test of tests) {
             if (id2test[test.id]) {
-                var element = id2test[test.id].element;
+                var info = id2test[test.id];
+                var element = info.element;
                 var label = $(element).find(".test-case-label");
                 label.text(test.name);
+                updateTestCaseNodes(test, info);
             }
         }
     }
@@ -1695,6 +1789,13 @@
         updateSidebar(suite);
     }
 
+    function updateSidebarAll() {
+        for (var suite of suites) {
+            var node = suite.node;
+            updateSidebar(node);
+        }
+    }
+
     /**
      *  Handle node settings save event
      *  @param {Object} node - target ndoe
@@ -1717,6 +1818,9 @@
         if (node.type === "flow-test-config") {
             addTestSuite(treeRoot, node);
         }
+        else {
+            updateSidebarAll();
+        }
     }
 
     /*
diff --git a/src/flow-tester.js b/src/flow-tester.js
index fe2d221..7f3d538 100644
--- a/src/flow-tester.js
+++ b/src/flow-tester.js
@@ -489,6 +489,37 @@ module.exports = (RED) => {
         return Promise.resolve(true);
     }
 
+    function executeTestStartAddon() {
+        let promise = Promise.resolve();
+        for (let addon of addonList) {
+            for (let action of addon.actions()) {
+                const cb = action.onTestStart;
+                if (cb) {
+                    promise = promise.then(() => {
+                        return cb();
+                    });
+                }
+            }
+        }
+        return promise;
+    }
+
+
+    function executeTestEndAddon() {
+        let promise = Promise.resolve();
+        for (let addon of addonList) {
+            for (let action of addon.actions()) {
+                const cb = action.onTestEnd;
+                if (cb) {
+                    promise = promise.then(() => {
+                        return cb();
+                    });
+                }
+            }
+        }
+        return promise;
+    }
+
     /**
      *  Initialize & process actions for setup event
      *  @param {Number} maxActs - max number of actions
@@ -499,9 +530,13 @@ module.exports = (RED) => {
         actionCount = 0;
         successActions = [];
         failActions = [];
+        // execute addon start callbacks
+        let promise = executeTestStartAddon();
         // execute global actions first
         const actions = actionMap.setup["_global_"];
-        let promise = processEvent(actions, null, null);
+        promise = promise.then(() => {
+            return processEvent(actions, null, null);
+        });
         // then, execute nodes events
         for (let id of Object.keys(actionMap.setup)) {
             if (id !== "_global_") {
@@ -515,7 +550,6 @@ module.exports = (RED) => {
         return promise;
     }
 
-
     /**
      *  Process actions for cleanup event
      *  @param {Number} maxActs - max number of actions
@@ -535,6 +569,9 @@ module.exports = (RED) => {
                 });
             }
         }
+        promise = promise.then(() => {
+            return executeTestEndAddon();
+        });
         // finally, clear actions
         return promise.then(() => {
             clearActions();

From 959b7e8739de8cc39f64b836870456195b0c80b1 Mon Sep 17 00:00:00 2001
From: Kazuhiro Ito <kazuhiro.ito.ek@hitachi-solutions.com>
Date: Fri, 18 Mar 2022 15:27:03 +0900
Subject: [PATCH 7/9] add GUI test action addon

---
 .../LICENSE                                   |  201 ++
 .../README.md                                 |   56 +
 .../examples/GUI-Test-Example.json            |    1 +
 .../package.json                              |   47 +
 .../scripts/build.js                          |   51 +
 .../src/flow-tester-gui-addon.html            | 1663 +++++++++++++++++
 .../src/flow-tester-gui-addon.js              |  617 ++++++
 .../locales/en-US/flow-tester-gui-addon.json  |    4 +
 .../src/style.css                             |    0
 .../test/test.js                              |    2 +
 10 files changed, 2642 insertions(+)
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/LICENSE
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/README.md
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/examples/GUI-Test-Example.json
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/package.json
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/scripts/build.js
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.html
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.js
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/src/locales/en-US/flow-tester-gui-addon.json
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/src/style.css
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/test/test.js

diff --git a/examples/node-red-contrib-flow-tester-gui-addon/LICENSE b/examples/node-red-contrib-flow-tester-gui-addon/LICENSE
new file mode 100644
index 0000000..261eeb9
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-gui-addon/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/README.md b/examples/node-red-contrib-flow-tester-gui-addon/README.md
new file mode 100644
index 0000000..9052440
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-gui-addon/README.md
@@ -0,0 +1,56 @@
+# node-red-flow-tester-gui-addon
+
+An GUI Test Addon to Flow Testing plugin for Node-RED
+
+**This is under development and not ready for general use. If you want to contribute, come talk to us in the `#core-dev` channel on https://nodered.org/slack
+
+## Developing
+
+To use the development version of Flow Tester Addon you can clone its source code repository
+and build it yourself.
+
+1. Get the source code
+
+```
+git clone https://github.com/node-red/node-red-flow-tester-gui-addon.git
+```
+
+2. Install the dependencies
+
+```
+cd node-red-flow-tester-gui-addon
+npm install
+```
+
+3. Build the plugin
+
+```
+npm run build
+```
+
+4. Install into Node-RED
+
+```
+cd ~/.node-red
+npm install <path-to-node-red-flow-tester-gui-addon-directory>
+```
+
+5. Restart Node-RED to load the plugin.
+
+### Source code structure
+
+ - `scripts` - build scripts used by `npm run build`
+ - `src` - source code of the plugins
+ - `test` - tests material
+ - `examples` - test flow example
+
+After `npm run build` is run, the following directories will be created:
+
+ - `dist` - contains the built plugin files
+ - `resources` contains the built plugin resource files (eg css)
+
+## License
+
+Copyright Node-RED Project Contributors.
+
+Licensed under the [Apache License, Version 2.0](LICENSE).
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/examples/GUI-Test-Example.json b/examples/node-red-contrib-flow-tester-gui-addon/examples/GUI-Test-Example.json
new file mode 100644
index 0000000..afad3ad
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-gui-addon/examples/GUI-Test-Example.json
@@ -0,0 +1 @@
+[{"id":"9b3db84fb21d2ae9","type":"tab","label":"フロー 1","disabled":false,"info":"","env":[]},{"id":"bcdef1528a38ab01","type":"flow-test-config","name":"Test Suite 0","tests":[{"id":"T1dqpqj7o1mo","name":"01-GUI-URL","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test1","url":"http://localhost:1880/test1-1","size":"1024,768","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test2","url":"http://localhost:1880/test1-2","size":"800,600","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test1","url":"","filepath":"./save/01-GUI-URL_1.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"target":"test2","url":"","filepath":"./save/01-GUI-URL_2.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"01-GUI-URL"}],"fe5f34a07f8fa02d":[],"33f0acbced5f2f2f":[],"3f1bc77ebad6fb7d":[],"89abec8dc8dcd928":[],"3433732293b0efe6":[],"4cbdf19859bd3673":[],"a57d5145d9cc69f8":[],"3a204cb1e4e7e798":[],"3b1b52e7950d2d96":[],"a8b9279ac2b7bb34":[],"3d80cb23855d1f23":[],"ea2689d761c694d9":[],"df63e899f76ec37d":[],"73b88c9ce8eb419b":[],"e2cc4ae0d72b963b":[],"fe3ad091b0d72fa6":[],"01a33fd443f37a9d":[],"5a88bb5ee5f74048":[],"de20304a494f612c":[],"46a0c697fa6f3aa9":[],"e53fcf4665e96479":[],"1851347e41085efa":[],"2135f0ed4da03687":[],"ecbdd8f3f5d1a43f":[],"6b5edcefaf047657":[],"252be38b87101a0c":[],"d9631503adada096":[],"f96271d463f3d005":[],"e9568cd8a3881f7a":[],"7deb2f295e4cf286":[],"b15db00ea98ccdb8":[],"da44efa0625b0c46":[],"b2abfc59dfd6747f":[],"9ad3814da7eb0bf8":[],"e0e8d9808cbefc12":[],"57489d4a6843ed06":[],"bf6dc3e2d4bba78a":[],"08cab205b3caa944":[],"67123a9c0d3e0d6b":[],"2ab47c47fb5f303e":[],"c7e554e9a8a3c157":[],"2486e1ca0a98c73f":[],"71f6558f1dbc157d":[],"0aac7206f22fd418":[],"2c3680f456d44179":[],"334278a4d04eef8e":[],"46fd6974c4ab4dd4":[],"006bc52baad3b791":[],"f79c8d74d708debb":[],"c5143318646fb9fd":[],"640d91fab434d070":[],"553dac4c5471d519":[],"cb0a6d52972bcc02":[],"193db0840f528392":[],"3d690e3169d2d483":[],"6717a5b7fb237bd1":[],"bf0d97744cf36e4c":[],"8e35628ea9d99957":[],"2b0fd9cc8afbdcd6":[],"b6aa9aef3d3647a3":[],"db5b2d254533ef8b":[],"46d010cd56ba8914":[],"29f54a1ad235097e":[],"a4d57d3ae7aff215":[],"f470657e71958b8f":[],"42419f5d347b6c64":[]},"cleanup":{"_global_":[],"fe5f34a07f8fa02d":[],"33f0acbced5f2f2f":[],"3f1bc77ebad6fb7d":[],"89abec8dc8dcd928":[],"3433732293b0efe6":[],"4cbdf19859bd3673":[],"a57d5145d9cc69f8":[],"3a204cb1e4e7e798":[],"3b1b52e7950d2d96":[],"a8b9279ac2b7bb34":[],"3d80cb23855d1f23":[],"ea2689d761c694d9":[],"df63e899f76ec37d":[],"73b88c9ce8eb419b":[],"e2cc4ae0d72b963b":[],"fe3ad091b0d72fa6":[],"01a33fd443f37a9d":[],"5a88bb5ee5f74048":[],"de20304a494f612c":[],"46a0c697fa6f3aa9":[],"e53fcf4665e96479":[],"1851347e41085efa":[],"2135f0ed4da03687":[],"ecbdd8f3f5d1a43f":[],"6b5edcefaf047657":[],"252be38b87101a0c":[],"d9631503adada096":[],"f96271d463f3d005":[],"e9568cd8a3881f7a":[],"7deb2f295e4cf286":[],"b15db00ea98ccdb8":[],"da44efa0625b0c46":[],"b2abfc59dfd6747f":[],"9ad3814da7eb0bf8":[],"e0e8d9808cbefc12":[],"57489d4a6843ed06":[],"bf6dc3e2d4bba78a":[],"08cab205b3caa944":[],"67123a9c0d3e0d6b":[],"2ab47c47fb5f303e":[],"c7e554e9a8a3c157":[],"2486e1ca0a98c73f":[],"71f6558f1dbc157d":[],"0aac7206f22fd418":[],"2c3680f456d44179":[],"334278a4d04eef8e":[],"46fd6974c4ab4dd4":[],"006bc52baad3b791":[],"f79c8d74d708debb":[],"c5143318646fb9fd":[],"640d91fab434d070":[],"553dac4c5471d519":[],"cb0a6d52972bcc02":[],"193db0840f528392":[],"3d690e3169d2d483":[],"6717a5b7fb237bd1":[],"bf0d97744cf36e4c":[],"8e35628ea9d99957":[],"2b0fd9cc8afbdcd6":[],"b6aa9aef3d3647a3":[],"db5b2d254533ef8b":[],"46d010cd56ba8914":[],"29f54a1ad235097e":[],"a4d57d3ae7aff215":[],"f470657e71958b8f":[],"42419f5d347b6c64":[]},"recv":{"fe5f34a07f8fa02d":[],"33f0acbced5f2f2f":[],"3f1bc77ebad6fb7d":[],"89abec8dc8dcd928":[],"a57d5145d9cc69f8":[],"3a204cb1e4e7e798":[],"3b1b52e7950d2d96":[],"a8b9279ac2b7bb34":[],"3d80cb23855d1f23":[],"ea2689d761c694d9":[],"fe3ad091b0d72fa6":[],"01a33fd443f37a9d":[],"5a88bb5ee5f74048":[],"e9568cd8a3881f7a":[],"7deb2f295e4cf286":[],"b15db00ea98ccdb8":[],"b2abfc59dfd6747f":[],"e0e8d9808cbefc12":[],"57489d4a6843ed06":[],"08cab205b3caa944":[],"67123a9c0d3e0d6b":[],"c7e554e9a8a3c157":[],"0aac7206f22fd418":[],"2c3680f456d44179":[],"334278a4d04eef8e":[],"46fd6974c4ab4dd4":[],"006bc52baad3b791":[],"f79c8d74d708debb":[],"c5143318646fb9fd":[],"640d91fab434d070":[],"553dac4c5471d519":[],"193db0840f528392":[{"kind":"match","value":"01-GUI-URL","performCheck":true}],"3d690e3169d2d483":[],"bf0d97744cf36e4c":[],"8e35628ea9d99957":[],"2b0fd9cc8afbdcd6":[],"b6aa9aef3d3647a3":[],"db5b2d254533ef8b":[],"46d010cd56ba8914":[],"29f54a1ad235097e":[],"a4d57d3ae7aff215":[]},"stub":{"fe5f34a07f8fa02d":[],"33f0acbced5f2f2f":[],"3f1bc77ebad6fb7d":[],"89abec8dc8dcd928":[],"a57d5145d9cc69f8":[],"3a204cb1e4e7e798":[],"3b1b52e7950d2d96":[],"a8b9279ac2b7bb34":[],"3d80cb23855d1f23":[],"ea2689d761c694d9":[],"fe3ad091b0d72fa6":[],"01a33fd443f37a9d":[],"5a88bb5ee5f74048":[],"e9568cd8a3881f7a":[],"7deb2f295e4cf286":[],"b15db00ea98ccdb8":[],"b2abfc59dfd6747f":[],"e0e8d9808cbefc12":[],"57489d4a6843ed06":[],"08cab205b3caa944":[],"67123a9c0d3e0d6b":[],"c7e554e9a8a3c157":[],"0aac7206f22fd418":[],"2c3680f456d44179":[],"334278a4d04eef8e":[],"46fd6974c4ab4dd4":[],"006bc52baad3b791":[],"f79c8d74d708debb":[],"c5143318646fb9fd":[],"640d91fab434d070":[],"553dac4c5471d519":[],"193db0840f528392":[],"3d690e3169d2d483":[],"bf0d97744cf36e4c":[],"8e35628ea9d99957":[],"2b0fd9cc8afbdcd6":[],"b6aa9aef3d3647a3":[],"db5b2d254533ef8b":[],"46d010cd56ba8914":[],"29f54a1ad235097e":[],"a4d57d3ae7aff215":[]},"send":{"fe5f34a07f8fa02d":[],"33f0acbced5f2f2f":[],"3f1bc77ebad6fb7d":[],"89abec8dc8dcd928":[],"3433732293b0efe6":[],"4cbdf19859bd3673":[],"a57d5145d9cc69f8":[],"3a204cb1e4e7e798":[],"3d80cb23855d1f23":[],"fe3ad091b0d72fa6":[],"01a33fd443f37a9d":[],"5a88bb5ee5f74048":[],"f96271d463f3d005":[],"e9568cd8a3881f7a":[],"b15db00ea98ccdb8":[],"da44efa0625b0c46":[],"b2abfc59dfd6747f":[],"9ad3814da7eb0bf8":[],"e0e8d9808cbefc12":[],"57489d4a6843ed06":[],"bf6dc3e2d4bba78a":[],"08cab205b3caa944":[],"67123a9c0d3e0d6b":[],"2ab47c47fb5f303e":[],"c7e554e9a8a3c157":[],"2486e1ca0a98c73f":[],"71f6558f1dbc157d":[],"0aac7206f22fd418":[],"2c3680f456d44179":[],"334278a4d04eef8e":[],"46fd6974c4ab4dd4":[],"f79c8d74d708debb":[],"c5143318646fb9fd":[],"640d91fab434d070":[],"3d690e3169d2d483":[],"6717a5b7fb237bd1":[],"8e35628ea9d99957":[],"2b0fd9cc8afbdcd6":[],"b6aa9aef3d3647a3":[],"db5b2d254533ef8b":[],"46d010cd56ba8914":[],"29f54a1ad235097e":[],"a4d57d3ae7aff215":[]}}},{"id":"Tr3j3798bung","name":"02-GUI-Keys","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test","url":"http://localhost:1880/ui/#!/0","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"kind":"send","target":"3a204cb1e4e7e798","value":"0"},{"target":"test","selector":"#\\30 2_GUI-Keys_Group_1_cards > md-card.nr-dashboard-slider._md.layout-align-space-between-center.layout-row.flex.visible","type":"str","value":"slider","timeout":"5000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test","key":"Tab,Tab","performCheck":false,"kind":"addon:GUI-Keys"},{"target":"test","key":"ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight","performCheck":false,"kind":"addon:GUI-Keys"},{"kind":"wait","wait":"1000"},{"target":"test","url":"","filepath":"./save/02-GUI-Keys.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"02-GUI-Keys"}],"193db0840f528392":[]},"cleanup":{"_global_":[],"193db0840f528392":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"02-GUI-Keys","performCheck":true}]},"stub":{"193db0840f528392":[]},"send":{}}},{"id":"Tm3obhhm6vug","name":"03-GUI-saveScreenshot","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test","url":"http://localhost:1880/test3","filepath":"./save/03-GUI-saveScreenshot.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"03-GUI-saveScreenshot"}],"193db0840f528392":[]},"cleanup":{"_global_":[],"193db0840f528392":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"03-GUI-saveScreenshot","performCheck":true}]},"stub":{"193db0840f528392":[]},"send":{}}},{"id":"T8ehjolrb0og","name":"04-GUI-setCookies","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test","url":"http://localhost:1880/test4","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","cookie":"[{\"name\":\"test1\",\"value\":\"123\"},{\"name\":\"test2\",\"value\":\"456\"},{\"name\":\"test3\",\"value\":\"789\"}]","performCheck":false,"kind":"addon:GUI-setCookies"},{"target":"test","url":"http://localhost:1880/test4","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","url":"","filepath":"./save/04-GUI-setCookies.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"04-GUI-setCookies"}],"193db0840f528392":[]},"cleanup":{"_global_":[],"193db0840f528392":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"04-GUI-setCookies","performCheck":true}]},"stub":{"193db0840f528392":[]},"send":{}}},{"id":"Tqicqojskkb","name":"05-GUI-setTimeout","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test1","timeout":"{\"pageLoad\":5000}","performCheck":false,"kind":"addon:GUI-setTimeout"},{"target":"test1","url":"http://localhost:1880/test5-1","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test2","timeout":"{\"pageLoad\":5000}","performCheck":false,"kind":"addon:GUI-setTimeout"},{"target":"test2","url":"http://localhost:1880/test5-2","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"kind":"send","target":"193db0840f528392","value":"05-GUI-setTimeout"}],"193db0840f528392":[]},"cleanup":{"_global_":[],"193db0840f528392":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"05-GUI-setTimeout","performCheck":true}]},"stub":{"193db0840f528392":[]},"send":{}}},{"id":"Tktn10o59iug","name":"06-GUI-waitUntil","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test1","url":"http://localhost:1880/test6-1","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test1","selector":"#ID_TEXT","type":"re","value":"\\d{2}","timeout":"10000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test2","url":"http://localhost:1880/test6-2","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test2","selector":"#ID_TEXT","type":"re","value":"\\d{2}","timeout":"10000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"kind":"send","target":"193db0840f528392","value":"06-GUI-waitUntil"}],"193db0840f528392":[]},"cleanup":{"_global_":[],"193db0840f528392":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"06-GUI-waitUntil","performCheck":true}]},"stub":{"193db0840f528392":[]},"send":{}}},{"id":"Taqk7q2rj9ng","name":"07-GUI-addValue","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"kind":"send","target":"640d91fab434d070","value":"test addValue "},{"target":"test","url":"http://localhost:1880/ui/#!/1","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","selector":"#input_0","type":"str","value":"","timeout":"5000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test","selector":"#input_0","value":"add1 ","performCheck":false,"kind":"addon:GUI-addValue"},{"target":"test","selector":"#input_0","value":"add2 ","performCheck":false,"kind":"addon:GUI-addValue"},{"target":"test","selector":"#input_0","value":"add3","performCheck":false,"kind":"addon:GUI-addValue"},{"target":"test","url":"","filepath":"./save/07-GUI-addValue.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"07-GUI-addValue"}],"553dac4c5471d519":[],"193db0840f528392":[]},"cleanup":{"_global_":[],"553dac4c5471d519":[],"193db0840f528392":[]},"recv":{"553dac4c5471d519":[{"kind":"match","value":"test addValue add1 add2 add3","performCheck":true}],"193db0840f528392":[{"kind":"match","value":"07-GUI-addValue","performCheck":true}]},"stub":{"553dac4c5471d519":[],"193db0840f528392":[]},"send":{}}},{"id":"T1f2t37fo80o","name":"08-GUI-clearValue","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"kind":"send","target":"640d91fab434d070","value":"test clearValue"},{"target":"test","url":"http://localhost:1880/ui/#!/1","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","selector":"#input_0","type":"str","value":"","timeout":"5000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test","selector":"#input_0","performCheck":false,"kind":"addon:GUI-clearValue"},{"target":"test","selector":"#input_0","value":"Test 08-GUI-clearValue","performCheck":false,"kind":"addon:GUI-addValue"},{"target":"test","url":"","filepath":"./save/08-GUI-clearValue.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"08-GUI-clearValue"}],"553dac4c5471d519":[],"193db0840f528392":[]},"cleanup":{"_global_":[],"553dac4c5471d519":[],"193db0840f528392":[]},"recv":{"553dac4c5471d519":[{"kind":"match","value":"Test 08-GUI-clearValue","performCheck":true}],"193db0840f528392":[{"kind":"match","value":"08-GUI-clearValue","performCheck":true}]},"stub":{"553dac4c5471d519":[],"193db0840f528392":[]},"send":{}}},{"id":"Tgbjs7hefb9","name":"09-GUI-click","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"kind":"send","target":"ea2689d761c694d9","value":""},{"target":"test","url":"http://localhost:1880/ui/#!/2","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","selector":"#\\30 9_GUI-click_Group_1_cards > md-card.nr-dashboard-button._md.visible > button","type":"str","value":"BUTTON","timeout":"5000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test","selector":"#\\30 9_GUI-click_Group_1_cards > md-card.nr-dashboard-button._md.visible > button","clickkind":"single","performCheck":false,"kind":"addon:GUI-click"},{"kind":"wait","wait":"1000"},{"target":"test","url":"","filepath":"./save/09-GUI-click.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"09-GUI-click"}],"5a88bb5ee5f74048":[],"193db0840f528392":[]},"cleanup":{"_global_":[],"5a88bb5ee5f74048":[],"193db0840f528392":[]},"recv":{"5a88bb5ee5f74048":[],"193db0840f528392":[{"kind":"match","value":"09-GUI-click","performCheck":true}]},"stub":{"5a88bb5ee5f74048":[],"193db0840f528392":[]},"send":{"5a88bb5ee5f74048":[{"kind":"match","value":"Button was clicked.","performCheck":true}]}}},{"id":"Tcacec5v6mao","name":"10-GUI-getValue","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test","url":"http://localhost:1880/test10","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"kind":"click","target":"29e3ad51752ad855"}],"193db0840f528392":[],"a4d57d3ae7aff215":[],"bf0d97744cf36e4c":[]},"cleanup":{"_global_":[],"193db0840f528392":[],"a4d57d3ae7aff215":[],"bf0d97744cf36e4c":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"10-GUI-getValue","performCheck":true}],"a4d57d3ae7aff215":[{"target":"test","selector":"#ID_TAG","getkind":"tag","getname":"","type":"global","value":"tag","performCheck":false,"kind":"addon:GUI-getValue"},{"target":"test","selector":"#ID_TEXT","getkind":"text","getname":"","type":"global","value":"text","performCheck":false,"kind":"addon:GUI-getValue"},{"target":"test","selector":"#ID_PROP","getkind":"prop","getname":"testprop","type":"flow","value":"property","performCheck":false,"kind":"addon:GUI-getValue"},{"target":"test","selector":"#ID_VALUE","getkind":"val","getname":"","type":"global","value":"value","performCheck":false,"kind":"addon:GUI-getValue"},{"target":"test","selector":"#ID_ATTR","getkind":"attr","getname":"attribute","type":"flow","value":"attribute","performCheck":false,"kind":"addon:GUI-getValue"},{"target":"test","selector":"#ID_VALUE","getkind":"prop","getname":"type","type":"flow","value":"property","performCheck":false,"kind":"addon:GUI-getValue"}],"bf0d97744cf36e4c":[]},"stub":{"193db0840f528392":[],"a4d57d3ae7aff215":[],"bf0d97744cf36e4c":[]},"send":{"a4d57d3ae7aff215":[{"kind":"wait","wait":"2000"},{"kind":"match","value":"h1TEST-TextTEST-ValueTEST-Attributetext","performCheck":true},{"kind":"send","target":"193db0840f528392","value":"10-GUI-getValue"}]}}},{"id":"T2cbqvf3cgc8","name":"11-GUI-moveTo","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test","url":"http://localhost:1880/ui/#!/3","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","selector":"#\\31 1_GUI-moveTo_Group_1_cards > md-card:nth-child(1) > button","type":"str","value":"BUTTON 1","timeout":"5000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test","selector":"#\\31 1_GUI-moveTo_Group_1_cards > md-card:nth-child(1) > button","performCheck":false,"kind":"addon:GUI-moveTo"},{"kind":"wait","wait":"1500"},{"target":"test","url":"","filepath":"./save/11-GUI-moveTo_1.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"target":"test","selector":"#\\31 1_GUI-moveTo_Group_1_cards > md-card:nth-child(2) > button","performCheck":false,"kind":"addon:GUI-moveTo"},{"kind":"wait","wait":"1500"},{"target":"test","url":"","filepath":"./save/11-GUI-moveTo_2.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"target":"test","selector":"#\\31 1_GUI-moveTo_Group_1_cards > md-card:nth-child(3) > button","performCheck":false,"kind":"addon:GUI-moveTo"},{"kind":"wait","wait":"1500"},{"target":"test","url":"","filepath":"./save/11-GUI-moveTo_3.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"11-GUI-moveTo"}],"193db0840f528392":[]},"cleanup":{"_global_":[],"193db0840f528392":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"11-GUI-moveTo","performCheck":true}]},"stub":{"193db0840f528392":[]},"send":{}}},{"id":"Tn9de8bpkfa8","name":"12-GUI-setValue","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"kind":"send","target":"a8b9279ac2b7bb34","value":""},{"target":"test","url":"http://localhost:1880/ui/#!/4","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","selector":"#input_0","type":"str","value":"","timeout":"5000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test","selector":"#input_0","value":"Test text","performCheck":false,"kind":"addon:GUI-setValue"},{"kind":"wait","wait":"1000"},{"target":"test","url":"","filepath":"./save/12-GUI-setValue.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"12-GUI-setValue"}],"fe3ad091b0d72fa6":[],"193db0840f528392":[]},"cleanup":{"_global_":[],"fe3ad091b0d72fa6":[],"193db0840f528392":[]},"recv":{"fe3ad091b0d72fa6":[],"193db0840f528392":[{"kind":"match","value":"12-GUI-setValue","performCheck":true}]},"stub":{"fe3ad091b0d72fa6":[],"193db0840f528392":[]},"send":{"fe3ad091b0d72fa6":[{"kind":"match","value":"Test text has been entered.","performCheck":true}]}}}]},{"id":"ea7e40d01b3c9e92","type":"ui_base","theme":{"name":"theme-light","lightTheme":{"default":"#0094CE","baseColor":"#0094CE","baseFont":"-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen-Sans,Ubuntu,Cantarell,Helvetica Neue,sans-serif","edited":true,"reset":false},"darkTheme":{"default":"#097479","baseColor":"#097479","baseFont":"-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen-Sans,Ubuntu,Cantarell,Helvetica Neue,sans-serif","edited":false},"customTheme":{"name":"Untitled Theme 1","default":"#4B7930","baseColor":"#4B7930","baseFont":"-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen-Sans,Ubuntu,Cantarell,Helvetica Neue,sans-serif"},"themeState":{"base-color":{"default":"#0094CE","value":"#0094CE","edited":false},"page-titlebar-backgroundColor":{"value":"#0094CE","edited":false},"page-backgroundColor":{"value":"#fafafa","edited":false},"page-sidebar-backgroundColor":{"value":"#ffffff","edited":false},"group-textColor":{"value":"#1bbfff","edited":false},"group-borderColor":{"value":"#ffffff","edited":false},"group-backgroundColor":{"value":"#ffffff","edited":false},"widget-textColor":{"value":"#111111","edited":false},"widget-backgroundColor":{"value":"#0094ce","edited":false},"widget-borderColor":{"value":"#ffffff","edited":false},"base-font":{"value":"-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen-Sans,Ubuntu,Cantarell,Helvetica Neue,sans-serif"}},"angularTheme":{"primary":"indigo","accents":"blue","warn":"red","background":"grey","palette":"light"}},"site":{"name":"Node-RED ダッシュボード","hideToolbar":"false","allowSwipe":"false","lockMenu":"false","allowTempTheme":"true","dateFormat":"YYYY/MM/DD","sizes":{"sx":48,"sy":48,"gx":6,"gy":6,"cx":6,"cy":6,"px":0,"py":0}}},{"id":"29571e93d0cd3bd8","type":"ui_group","name":"Group 1","tab":"","order":1,"disp":true,"width":6},{"id":"add392ac2ced5ed7","type":"ui_tab","name":"02 GUI-Keys","icon":"dashboard","order":1,"disabled":false,"hidden":false},{"id":"0779fd07b585202b","type":"ui_group","name":"Group 1","tab":"add392ac2ced5ed7","order":1,"disp":true,"width":"6","collapse":false,"className":""},{"id":"44d046383f6e170c","type":"ui_group","name":"Group 1","tab":"26c328d9fd99402b","order":1,"disp":true,"width":6},{"id":"26c328d9fd99402b","type":"ui_tab","name":"09 GUI-click","icon":"dashboard","order":3,"disabled":false,"hidden":false},{"id":"69ef5cd81fbe23c4","type":"ui_tab","name":"12 GUI-setValue","icon":"dashboard","order":5,"disabled":false,"hidden":false},{"id":"2b4a3bdb043675fd","type":"ui_group","name":"Group 1","tab":"69ef5cd81fbe23c4","order":1,"disp":true,"width":6},{"id":"51a7624fadecbb11","type":"ui_group","name":"Group 1","tab":"","order":1,"disp":true,"width":6},{"id":"785e79a6406a34f0","type":"ui_tab","name":"07 GUI-addValue 08-clearValue","icon":"dashboard","order":2,"disabled":false,"hidden":false},{"id":"2c037ff2393ce306","type":"ui_group","name":"Group 1","tab":"785e79a6406a34f0","order":1,"disp":true,"width":6},{"id":"d7a48474c86fb492","type":"ui_tab","name":"11 GUI-moveTo","icon":"dashboard","order":4,"disabled":false,"hidden":false},{"id":"a94a995999abb6ff","type":"ui_group","name":"Group 1","tab":"d7a48474c86fb492","order":1,"disp":true,"width":6},{"id":"3433732293b0efe6","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test1-1","method":"get","upload":false,"swaggerDoc":"","x":110,"y":100,"wires":[["89abec8dc8dcd928"]]},{"id":"9c703e8de2e3c532","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":470,"y":100,"wires":[]},{"id":"89abec8dc8dcd928","type":"template","z":"9b3db84fb21d2ae9","name":"Size: 1024x768","field":"payload","fieldType":"msg","format":"html","syntax":"plain","template":"<!DOCTYPE html>\n<html>\n\n<head>\n    <meta charset=\"utf-8\">\n    <title>01 GUI-URL TEST</title>\n</head>\n\n<body>\n    <h1>01 GUI-URL TEST1</h1>\n    <p>Size: 1024x768</p>\n    <p>test test test test test test test test test test test test test test test test test test test test test test test test\n    test test test test test test test test test test test test test test test test test test test test test test test test\n    test test test test test test test test test test test test test test test test test test test test test test test test\n    test test test test test test test test test test test test test test test</p>\n</body>\n\n</html>","output":"str","x":300,"y":100,"wires":[["9c703e8de2e3c532"]]},{"id":"4cbdf19859bd3673","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test1-2","method":"get","upload":false,"swaggerDoc":"","x":110,"y":160,"wires":[["a57d5145d9cc69f8"]]},{"id":"741bea42aff840bc","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":470,"y":160,"wires":[]},{"id":"a57d5145d9cc69f8","type":"template","z":"9b3db84fb21d2ae9","name":"Size: 800x600","field":"payload","fieldType":"msg","format":"html","syntax":"plain","template":"<!DOCTYPE html>\n<html>\n\n<head>\n    <meta charset=\"utf-8\">\n    <title>01 GUI-URL TEST</title>\n</head>\n\n<body>\n    <h1>01 GUI-URL TEST2</h1>\n    <p>Size: 800x600</p>\n    <p>test test test test test test test test test test test test test test test test test test test test test test test test\n    test test test test test test test test test test test test test test test test test test test test test test test test\n    test test test test test test test test test test test test test test test test test test test test test test test test\n    test test test test test test test test test test test test test test test</p>\n</body>\n\n</html>","output":"str","x":300,"y":160,"wires":[["741bea42aff840bc"]]},{"id":"3a204cb1e4e7e798","type":"ui_slider","z":"9b3db84fb21d2ae9","name":"","label":"slider","tooltip":"","group":"0779fd07b585202b","order":0,"width":0,"height":0,"passthru":true,"outs":"all","topic":"topic","topicType":"msg","min":0,"max":10,"step":1,"className":"","x":90,"y":260,"wires":[["3b1b52e7950d2d96"]]},{"id":"3b1b52e7950d2d96","type":"ui_gauge","z":"9b3db84fb21d2ae9","name":"","group":"0779fd07b585202b","order":1,"width":0,"height":0,"gtype":"gage","title":"gauge","label":"units","format":"{{value}}","min":0,"max":10,"colors":["#00b500","#e6e600","#ca3838"],"seg1":"","seg2":"","className":"","x":230,"y":260,"wires":[]},{"id":"01a33fd443f37a9d","type":"ui_button","z":"9b3db84fb21d2ae9","name":"","group":"44d046383f6e170c","order":1,"width":0,"height":0,"passthru":false,"label":"button","tooltip":"","color":"","bgcolor":"","className":"","icon":"","payload":"Button","payloadType":"str","topic":"topic","topicType":"msg","x":90,"y":1080,"wires":[["5a88bb5ee5f74048"]]},{"id":"ea2689d761c694d9","type":"ui_text","z":"9b3db84fb21d2ae9","group":"44d046383f6e170c","order":2,"width":0,"height":0,"name":"text","label":"","format":"{{msg.payload}}","layout":"row-center","className":"","x":490,"y":1080,"wires":[]},{"id":"5a88bb5ee5f74048","type":"function","z":"9b3db84fb21d2ae9","name":"","func":"if (msg.payload != \"\") {\n    msg.payload += \" was clicked.\"\n}\nreturn msg;","outputs":1,"noerr":0,"initialize":"","finalize":"","libs":[],"x":300,"y":1080,"wires":[["ea2689d761c694d9"]]},{"id":"3d80cb23855d1f23","type":"ui_text_input","z":"9b3db84fb21d2ae9","name":"","label":"","tooltip":"","group":"2b4a3bdb043675fd","order":1,"width":0,"height":0,"passthru":true,"mode":"text","delay":300,"topic":"topic","sendOnBlur":true,"className":"","topicType":"msg","x":100,"y":1520,"wires":[["fe3ad091b0d72fa6"]]},{"id":"fe3ad091b0d72fa6","type":"function","z":"9b3db84fb21d2ae9","name":"","func":"if (msg.payload != \"\") {\n    msg.payload += \" has been entered.\"\n}\nreturn msg;","outputs":1,"noerr":0,"initialize":"","finalize":"","libs":[],"x":300,"y":1520,"wires":[["a8b9279ac2b7bb34"]]},{"id":"a8b9279ac2b7bb34","type":"ui_text","z":"9b3db84fb21d2ae9","group":"2b4a3bdb043675fd","order":2,"width":0,"height":0,"name":"text","label":"","format":"{{msg.payload}}","layout":"row-center","className":"","x":510,"y":1520,"wires":[]},{"id":"df63e899f76ec37d","type":"comment","z":"9b3db84fb21d2ae9","name":"09 GUI-click","info":"","x":110,"y":1040,"wires":[]},{"id":"73b88c9ce8eb419b","type":"comment","z":"9b3db84fb21d2ae9","name":"12 GUI-setValue","info":"","x":120,"y":1480,"wires":[]},{"id":"e2cc4ae0d72b963b","type":"comment","z":"9b3db84fb21d2ae9","name":"02 GUI-Keys","info":"","x":110,"y":220,"wires":[]},{"id":"de20304a494f612c","type":"comment","z":"9b3db84fb21d2ae9","name":"01 GUI-URL","info":"","x":110,"y":40,"wires":[]},{"id":"46a0c697fa6f3aa9","type":"comment","z":"9b3db84fb21d2ae9","name":"03 GUI-saveScreenshot","info":"","x":140,"y":340,"wires":[]},{"id":"e53fcf4665e96479","type":"comment","z":"9b3db84fb21d2ae9","name":"04 GUI-setCookies","info":"","x":130,"y":460,"wires":[]},{"id":"1851347e41085efa","type":"comment","z":"9b3db84fb21d2ae9","name":"05 GUI-setTimeout","info":"タイムアウトしてもテストフローが停止しない。\n用途が不明","x":130,"y":580,"wires":[]},{"id":"2135f0ed4da03687","type":"comment","z":"9b3db84fb21d2ae9","name":"06 GUI-waitUntil","info":"","x":120,"y":760,"wires":[]},{"id":"ecbdd8f3f5d1a43f","type":"comment","z":"9b3db84fb21d2ae9","name":"07 GUI-addValue","info":"","x":120,"y":940,"wires":[]},{"id":"6b5edcefaf047657","type":"comment","z":"9b3db84fb21d2ae9","name":"08 GUI-clearValue","info":"","x":310,"y":940,"wires":[]},{"id":"252be38b87101a0c","type":"comment","z":"9b3db84fb21d2ae9","name":"10 GUI-getValue","info":"","x":120,"y":1140,"wires":[]},{"id":"d9631503adada096","type":"comment","z":"9b3db84fb21d2ae9","name":"11 GUI-moveTo","info":"","x":120,"y":1300,"wires":[]},{"id":"f96271d463f3d005","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test3","method":"get","upload":false,"swaggerDoc":"","x":100,"y":380,"wires":[["e9568cd8a3881f7a"]]},{"id":"3646275cbe45db61","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":550,"y":380,"wires":[]},{"id":"e9568cd8a3881f7a","type":"template","z":"9b3db84fb21d2ae9","name":"URL: http://localhost:1880/test3","field":"payload","fieldType":"msg","format":"html","syntax":"plain","template":"<!DOCTYPE html>\n<html>\n\n<head>\n    <meta charset=\"utf-8\">\n    <title>03 GUI-savaScreenshot TEST</title>\n</head>\n\n<body>\n    <h1>03 GUI-savaScreenshot TEST</h1>\n    <p>URL: http://localhost:1880/test3</p>\n</body>\n\n</html>","output":"str","x":330,"y":380,"wires":[["3646275cbe45db61"]]},{"id":"b15db00ea98ccdb8","type":"function","z":"9b3db84fb21d2ae9","name":"","func":"msg.payload = JSON.stringify(msg.req.cookies, null, 4);\nreturn msg;","outputs":1,"noerr":0,"initialize":"","finalize":"","libs":[],"x":260,"y":500,"wires":[["b2abfc59dfd6747f"]]},{"id":"da44efa0625b0c46","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test4","method":"get","upload":false,"swaggerDoc":"","x":100,"y":500,"wires":[["b15db00ea98ccdb8"]]},{"id":"b2abfc59dfd6747f","type":"template","z":"9b3db84fb21d2ae9","name":"Cookies","field":"payload","fieldType":"msg","format":"handlebars","syntax":"mustache","template":"<!DOCTYPE html>\n<head>\n    <meta charset=\"utf-8\">\n    <title>04 GUI-setCookies TEST</title>\n</head>\n<body>\n    <h1>04 GUI-setCookies TEST</h1>\n    <pre>{{ payload }}</pre>\n</body>\n</html>","output":"str","x":420,"y":500,"wires":[["c3c9bd6b22cdf5c4"]]},{"id":"c3c9bd6b22cdf5c4","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":580,"y":500,"wires":[]},{"id":"9ad3814da7eb0bf8","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test5-1","method":"get","upload":false,"swaggerDoc":"","x":110,"y":620,"wires":[["57489d4a6843ed06"]]},{"id":"e0e8d9808cbefc12","type":"template","z":"9b3db84fb21d2ae9","name":"wait page","field":"payload","fieldType":"msg","format":"html","syntax":"plain","template":"<!DOCTYPE html>\n\n<head>\n    <meta charset=\"utf-8\">\n    <title>05 GUI-setTimeout TEST</title>\n</head>\n\n<body>\n    <h1>05 GUI-setTimeout TEST1</h1>\n</body>\n\n</html>","output":"str","x":460,"y":620,"wires":[["273bd1c5fba89419"]]},{"id":"57489d4a6843ed06","type":"delay","z":"9b3db84fb21d2ae9","name":"","pauseType":"delay","timeout":"4","timeoutUnits":"seconds","rate":"1","nbRateUnits":"1","rateUnits":"second","randomFirst":"1","randomLast":"5","randomUnits":"seconds","drop":false,"allowrate":false,"outputs":1,"x":280,"y":620,"wires":[["e0e8d9808cbefc12"]]},{"id":"bf6dc3e2d4bba78a","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test5-2","method":"get","upload":false,"swaggerDoc":"","x":110,"y":680,"wires":[["08cab205b3caa944"]]},{"id":"08cab205b3caa944","type":"delay","z":"9b3db84fb21d2ae9","name":"depay 6s (time out)","pauseType":"delay","timeout":"6","timeoutUnits":"seconds","rate":"1","nbRateUnits":"1","rateUnits":"second","randomFirst":"1","randomLast":"5","randomUnits":"seconds","drop":false,"allowrate":false,"outputs":1,"x":310,"y":680,"wires":[["e0e8d9808cbefc12"]]},{"id":"2486e1ca0a98c73f","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test6-1","method":"get","upload":false,"swaggerDoc":"","x":110,"y":800,"wires":[["f79c8d74d708debb"]]},{"id":"71f6558f1dbc157d","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test6-2","method":"get","upload":false,"swaggerDoc":"","x":110,"y":860,"wires":[["c5143318646fb9fd"]]},{"id":"46fd6974c4ab4dd4","type":"template","z":"9b3db84fb21d2ae9","name":"wait text","field":"payload","fieldType":"msg","format":"handlebars","syntax":"mustache","template":"<!DOCTYPE html>\n\n<head>\n    <meta charset=\"utf-8\">\n    <title>06 GUI-waitUntil TEST</title>\n</head>\n\n<body>\n    <h1>06 GUI-waitUntil TEST</h1>\n    <p id=\"ID_TEXT\">Regular expression match test.</p></body>\n</html>\n\n<script>\nwindow.setTimeout(reWrite, {{ payload }});\nfunction reWrite()\n{\n  if (document.getElementById)\n  {\n      document.getElementById(\"ID_TEXT\").textContent=\"Test 06-GUI-waitUntil\";\n  }\n}\n</script>","output":"str","x":460,"y":800,"wires":[["6075415beb6878a0"]]},{"id":"6075415beb6878a0","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":610,"y":800,"wires":[]},{"id":"f79c8d74d708debb","type":"change","z":"9b3db84fb21d2ae9","name":"delay 9s","rules":[{"t":"set","p":"payload","pt":"msg","to":"9000","tot":"num"}],"action":"","property":"","from":"","to":"","reg":false,"x":280,"y":800,"wires":[["46fd6974c4ab4dd4"]]},{"id":"c5143318646fb9fd","type":"change","z":"9b3db84fb21d2ae9","name":"delay 11s (time out)","rules":[{"t":"set","p":"payload","pt":"msg","to":"10000","tot":"num"}],"action":"","property":"","from":"","to":"","reg":false,"x":310,"y":860,"wires":[["46fd6974c4ab4dd4"]]},{"id":"640d91fab434d070","type":"ui_text_input","z":"9b3db84fb21d2ae9","name":"","label":"","tooltip":"","group":"2c037ff2393ce306","order":0,"width":0,"height":0,"passthru":false,"mode":"text","delay":300,"topic":"topic","sendOnBlur":true,"className":"","topicType":"msg","x":100,"y":980,"wires":[["553dac4c5471d519"]]},{"id":"553dac4c5471d519","type":"debug","z":"9b3db84fb21d2ae9","name":"","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"payload","targetType":"msg","statusVal":"","statusType":"auto","x":290,"y":980,"wires":[]},{"id":"cb0a6d52972bcc02","type":"comment","z":"9b3db84fb21d2ae9","name":"99 TestEnd","info":"","x":100,"y":1600,"wires":[]},{"id":"193db0840f528392","type":"debug","z":"9b3db84fb21d2ae9","name":"","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"payload","targetType":"msg","statusVal":"","statusType":"auto","x":310,"y":1640,"wires":[]},{"id":"a009dbfb3c8dcba9","type":"inject","z":"9b3db84fb21d2ae9","name":"","props":[{"p":"payload"},{"p":"topic","vt":"str"}],"repeat":"","crontab":"","once":false,"onceDelay":0.1,"topic":"","payload":"","payloadType":"date","x":120,"y":1640,"wires":[["193db0840f528392"]]},{"id":"3d690e3169d2d483","type":"template","z":"9b3db84fb21d2ae9","name":"","field":"payload","fieldType":"msg","format":"handlebars","syntax":"mustache","template":"<!DOCTYPE html>\n<html>\n\n<head>\n    <meta charset=\"utf-8\">\n    <title>10 GUI-getValue TEST</title>\n</head>\n\n<body>\n    <h1 id=\"ID_TAG\">10 GUI-getValue TEST</h1>\n    <p id=\"ID_TEXT\">TEST-Text</p>\n    <div id=\"ID_ATTR\" attribute=\"TEST-Attribute\"></div>\n    <input type=\"text\" value=\"TEST-Value\" id=\"ID_VALUE\" />\n<body>\n\n</html>\n","output":"str","x":300,"y":1180,"wires":[["d7fe4424960b4eba"]]},{"id":"6717a5b7fb237bd1","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test10","method":"get","upload":false,"swaggerDoc":"","x":110,"y":1180,"wires":[["3d690e3169d2d483"]]},{"id":"d7fe4424960b4eba","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":490,"y":1180,"wires":[]},{"id":"29e3ad51752ad855","type":"inject","z":"9b3db84fb21d2ae9","name":"","props":[{"p":"payload"},{"p":"topic","vt":"str"}],"repeat":"","crontab":"","once":false,"onceDelay":0.1,"topic":"","payload":"","payloadType":"date","x":120,"y":1220,"wires":[["a4d57d3ae7aff215"]]},{"id":"bf0d97744cf36e4c","type":"debug","z":"9b3db84fb21d2ae9","name":"","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"payload","targetType":"msg","statusVal":"","statusType":"auto","x":510,"y":1220,"wires":[]},{"id":"b6aa9aef3d3647a3","type":"ui_button","z":"9b3db84fb21d2ae9","name":"","group":"a94a995999abb6ff","order":1,"width":0,"height":0,"passthru":false,"label":"Button 1","tooltip":"Button 1","color":"","bgcolor":"","className":"","icon":"","payload":"","payloadType":"str","topic":"topic","topicType":"msg","x":100,"y":1340,"wires":[[]]},{"id":"db5b2d254533ef8b","type":"ui_button","z":"9b3db84fb21d2ae9","name":"","group":"a94a995999abb6ff","order":2,"width":0,"height":0,"passthru":false,"label":"Button 2","tooltip":"Button 2","color":"","bgcolor":"","className":"","icon":"","payload":"","payloadType":"str","topic":"topic","topicType":"msg","x":100,"y":1380,"wires":[[]]},{"id":"46d010cd56ba8914","type":"ui_button","z":"9b3db84fb21d2ae9","name":"","group":"a94a995999abb6ff","order":3,"width":0,"height":0,"passthru":false,"label":"Button 3","tooltip":"Button 3","color":"","bgcolor":"","className":"","icon":"","payload":"","payloadType":"str","topic":"topic","topicType":"msg","x":100,"y":1420,"wires":[[]]},{"id":"a4d57d3ae7aff215","type":"change","z":"9b3db84fb21d2ae9","name":"","rules":[{"t":"set","p":"payload","pt":"msg","to":"$globalContext(\"tag\") & $globalContext(\"text\") & $globalContext(\"value\") & $flowContext(\"attribute\") &  $flowContext(\"property\")  \t","tot":"jsonata"}],"action":"","property":"","from":"","to":"","reg":false,"x":320,"y":1220,"wires":[["bf0d97744cf36e4c"]]},{"id":"f470657e71958b8f","type":"comment","z":"9b3db84fb21d2ae9","name":"Check the console log for the result.","info":"","x":580,"y":680,"wires":[]},{"id":"42419f5d347b6c64","type":"comment","z":"9b3db84fb21d2ae9","name":"Check the console log for the result.","info":"","x":580,"y":860,"wires":[]},{"id":"273bd1c5fba89419","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":620,"y":620,"wires":[]}]
\ No newline at end of file
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/package.json b/examples/node-red-contrib-flow-tester-gui-addon/package.json
new file mode 100644
index 0000000..d18ea08
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-gui-addon/package.json
@@ -0,0 +1,47 @@
+{
+    "name": "node-red-contrib-flow-tester-gui-addon",
+    "version": "0.0.1",
+    "description": "A test plugin for flow tester gui addon",
+    "scripts": {
+        "build": "node scripts/build.js",
+        "dev": "nodemon --exec 'npm run build'  -i dist -i resources -e 'css js html'",
+        "test": "nyc mocha"
+    },
+    "keywords": [
+        "node-red",
+        "testing",
+        "dashboard",
+        "gui"
+    ],
+    "files": [
+        "dist",
+        "resources"
+    ],
+    "license": "Apache-2",
+    "node-red": {
+        "version": ">=2.0.0",
+        "plugins": {
+            "flow-tester-gui-addon": "dist/flow-tester-gui-addon.js"
+        }
+    },
+    "contributors": [
+        {
+            "name": "Kazuhiro Ito",
+            "email": "kazuhiro.ito.ek@hitachi-solutions.com"
+        }
+    ],
+    "devDependencies": {
+        "@wdio/cli": "^7.16.10",
+        "@wdio/local-runner": "^7.16.10",
+        "@wdio/mocha-framework": "^7.16.6",
+        "@wdio/spec-reporter": "^7.16.9",
+        "chromedriver": "^96.0.0",
+        "fs-extra": "^10.0.0",
+        "global-agent": "^3.0.0",
+        "html-minifier": "^4.0.0",
+        "mocha": "^8.4.0",
+        "nodemon": "^2.0.7",
+        "nyc": "^15.1.0",
+        "wdio-chromedriver-service": "^7.2.2"
+    }
+}
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/scripts/build.js b/examples/node-red-contrib-flow-tester-gui-addon/scripts/build.js
new file mode 100644
index 0000000..96c50bb
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-gui-addon/scripts/build.js
@@ -0,0 +1,51 @@
+const minify = require("html-minifier").minify;
+const fs = require("fs-extra");
+const path = require("path");
+
+
+const projectRoot = path.join(__dirname,"..")
+const resources = path.join(projectRoot,"resources");
+const dist = path.join(projectRoot,"dist");
+const src = path.join(projectRoot,"src");
+
+const assets = {}
+assets[dist] = [
+    "locales",
+    "flow-tester-gui-addon.html",
+    "flow-tester-gui-addon.js"
+]
+assets[resources] = [
+    "style.css"
+]
+
+async function copyStaticAssets(dist,assets) {
+    await fs.mkdir(dist,{recursive: true});
+    for (let i=0; i<assets.length; i++) {
+        if (/\.html/.test(assets[i])) {
+            const content = await fs.readFile(path.join(src,assets[i]),"utf-8")
+            await fs.writeFile(path.join(dist,assets[i]), minify(content, {minifyCSS: true, minifyJS: true}))
+        } else if (/\.js/.test(assets[i])) {
+            await fs.copy(path.join(src,assets[i]),path.join(dist,assets[i]))
+        } else if (/\.css/.test(assets[i])) {
+            const rawCSS = await fs.readFile(path.join(src,assets[i]),"utf-8");
+            const minifiedCSS = minify("<style>"+rawCSS+"</style>", {minifyCSS: true});
+            const finalCSS = minifiedCSS.substring(7,minifiedCSS.length-8)
+            await fs.writeFile(path.join(dist,assets[i]), finalCSS)
+        } else {
+            await fs.mkdir(path.join(dist,assets[i]), {recursive: true});
+            await fs.copy(path.join(src,assets[i]),path.join(dist,assets[i]))
+        }
+    }
+}
+
+
+
+(async function() {
+    const destinations = Object.keys(assets);
+    for (let i=0, l=destinations.length; i<l; i++) {
+        await copyStaticAssets(destinations[i],assets[destinations[i]]);
+    }
+})().catch(err => {
+    console.error(err);
+    process.exit(1);
+});
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.html b/examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.html
new file mode 100644
index 0000000..2d73dc7
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.html
@@ -0,0 +1,1663 @@
+// GUI test addon for flow tester action
+<link rel="stylesheet" href="resources/node-red-contrib-flow-tester-addon/style.css">
+
+<script type="text/javascript">
+(function() {
+    RED.plugins.registerPlugin("node-red-contrib--flow-tester-addon", {
+        type: "flow-tester-addon",
+        onadd: function() {
+        },
+        onremove: function() {
+        },
+        actions: function () {
+            return [
+                // plugin for GUI-URL
+                {
+                    name: "addon:GUI-URL",
+                    label: "GUI-URL",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-url-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-url-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: url
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-url-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-url-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("url").appendTo(span1);
+                        var urlField = $("<input/>", {
+                            placeholder: "http://<target page>",
+                            type: "text",
+                            class: "addon-gui-url-url",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.url) {
+                            urlField.val(data.url);
+                        }
+
+                        // row2: size(option)
+                        var row2 = $("<div/>", {
+                            class: "addon-gui-url-div2"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span2 = $("<span/>", {
+                            class: "addon-gui-url-span2"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row2);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("size").appendTo(span2);
+                        var sizeField = $("<input/>", {
+                            placeholder: "(option) width, height",
+                            type: "text",
+                            class: "addon-gui-url-size",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span2);
+                        if (data && data.size) {
+                            sizeField.val(data.size);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-url-span0");
+                        var row1 = row0.find(".addon-gui-url-div1");
+                        var row2 = row0.find(".addon-gui-url-div2");
+                        span0.show();
+                        row1.show();
+                        row2.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-url-span0");
+                        var row1 = row0.find(".addon-gui-url-div1");
+                        var row2 = row0.find(".addon-gui-url-div2");
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                    },
+                    onSave: function (con) { 
+                        var target = con.find(".addon-gui-url-target").val();
+                        var url = con.find(".addon-gui-url-url").val();
+                        var size = con.find(".addon-gui-url-size").val();
+                        return {
+                            target: target,
+                            url: url,
+                            size: size,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-Keys
+                {
+                    name: "addon:GUI-Keys",
+                    label: "GUI-Keys",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-keys-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-keys-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: key
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-keys-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-keys-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("key").appendTo(span1);
+                        var keyField = $("<input/>", {
+                            placeholder: "key1, key2, key3, ...",
+                            type: "text",
+                            class: "addon-gui-keys-key",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.key) {
+                            keyField.val(data.key);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-keys-span0");
+                        var row1 = row0.find(".addon-gui-keys-div1");
+                        span0.show();
+                        row1.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-keys-span0");
+                        var row1 = row0.find(".addon-gui-keys-div1");
+                        span0.hide();
+                        row1.hide();
+                    },
+                    onSave: function (con) { 
+                        var target = con.find(".addon-gui-keys-target").val();
+                        var key = con.find(".addon-gui-keys-key").val();
+                        return {
+                            target: target,
+                            key: key,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-saveScreenshot
+                {
+                    name: "addon:GUI-saveScreenshot",
+                    label: "GUI-saveScreenshot",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-saveScreenshot-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-saveScreenshot-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: url(option)
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-saveScreenshot-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-saveScreenshot-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("url").appendTo(span1);
+                        var urlField = $("<input/>", {
+                            placeholder: "(option) http://<target page>",
+                            type: "text",
+                            class: "addon-gui-saveScreenshot-url",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.url) {
+                            urlField.val(data.url);
+                        }
+
+                        // row2: filepath
+                        var row2 = $("<div/>", {
+                            class: "addon-gui-saveScreenshot-div2"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span2 = $("<span/>", {
+                            class: "addon-gui-saveScreenshot-span2"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row2);
+                        $("<label/>", {
+                        }).css({
+                            display: "inline-block",
+                            "text-align": "right",
+                            width: "100px"
+                        }).text("filepath").appendTo(span2);
+                        var filepathField = $("<input/>", {
+                            placeholder: "image file path (.png suffix is required)",
+                            type: "text",
+                            class: "addon-gui-saveScreenshot-filepath",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span2);
+                        if (data && data.filepath) {
+                            filepathField.val(data.filepath);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-saveScreenshot-span0");
+                        var row1 = row0.find(".addon-gui-saveScreenshot-div1");
+                        var row2 = row0.find(".addon-gui-saveScreenshot-div2");
+                        span0.show();
+                        row1.show();
+                        row2.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-saveScreenshot-span0");
+                        var row1 = row0.find(".addon-gui-saveScreenshot-div1");
+                        var row2 = row0.find(".addon-gui-saveScreenshot-div2");
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-saveScreenshot-target").val();
+                        var url = con.find(".addon-gui-saveScreenshot-url").val();
+                        var filepath = con.find(".addon-gui-saveScreenshot-filepath").val();
+                        return {
+                            target: target,
+                            url: url,
+                            filepath: filepath,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-setCookies
+                {
+                    name: "addon:GUI-setCookies",
+                    label: "GUI-setCookies",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-setCookies-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-setCookies-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: cookie
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-setCookies-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-setCookies-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("cookie").appendTo(span1);
+                        var cookieField = $("<input/>", {
+                            placeholder: "cookies settings",
+                            class: "addon-gui-setCookies-cookie",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        $(cookieField).typedInput({
+                            default: "json",
+                            types: [
+                                "json"
+                            ]
+                        });
+                        if (data && data.cookie) {
+                            $(cookieField).typedInput("value", data.cookie);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-setCookies-span0");
+                        var row1 = row0.find(".addon-gui-setCookies-div1");
+                        span0.show();
+                        row1.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-setCookies-span0");
+                        var row1 = row0.find(".addon-gui-setCookies-div1");
+                        span0.hide();
+                        row1.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-setCookies-target").val();
+                        var cookie = con.find(".addon-gui-setCookies-cookie").typedInput("value");
+                        return {
+                            target: target,
+                            cookie : cookie,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-setTimeout
+                {
+                    name: "addon:GUI-setTimeout",
+                    label: "GUI-setTimeout",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-setTimeout-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-setTimeout-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: timeout
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-setTimeout-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-setTimeout-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("timeout").appendTo(span1);
+                        var timeoutField = $("<input/>", {
+                            placeholder: "timeouts settings",
+                            class: "addon-gui-setTimeout-timeout",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        $(timeoutField).typedInput({
+                            default: "json",
+                            types: [
+                                "json"
+                            ]
+                        });
+                        if (data && data.timeout) {
+                            $(timeoutField).typedInput("value", data.timeout);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-setTimeout-span0");
+                        var row1 = row0.find(".addon-gui-setTimeout-div1");
+                        span0.show();
+                        row1.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-setTimeout-span0");
+                        var row1 = row0.find(".addon-gui-setTimeout-div1");
+                        span0.hide();
+                        row1.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-setTimeout-target").val();
+                        var timeout = con.find(".addon-gui-setTimeout-timeout").typedInput("value");
+                        return {
+                            target: target,
+                            timeout: timeout,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-waitUntil
+                {
+                    name: "addon:GUI-waitUntil",
+                    label: "GUI-waitUntil",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-waitUntil-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-waitUntil-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: selector
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-waitUntil-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-waitUntil-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("selector").appendTo(span1);
+                        var selectorField = $("<input/>", {
+                            placeholder: "element selector",
+                            type: "text",
+                            class: "addon-gui-waitUntil-selector",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.selector) {
+                            selectorField.val(data.selector);
+                        }
+
+                        // row2: value
+                        var row2 = $("<div/>", {
+                            class: "addon-gui-waitUntil-div2"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span2 = $("<span/>", {
+                            class: "addon-gui-waitUntil-span2"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row2);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("value").appendTo(span2);
+                        var valueField = $("<input/>", {
+                            placeholder: "element value or regexp",
+                            type: "text",
+                            class: "addon-gui-waitUntil-value",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span2);
+                        $(valueField).typedInput({
+                            default: "str",
+                            types: [
+                                "str","re"
+                            ]
+                        });
+                        if (data && data.value && data.type) {
+                            $(valueField).typedInput("value", data.value);
+                            $(valueField).typedInput("type", data.type);
+                        }
+
+                        // row3: timeout
+                        var row3 = $("<div/>", {
+                            class: "addon-gui-waitUntil-div3"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span3 = $("<span/>", {
+                            class: "addon-gui-waitUntil-span3"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row3);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("timeout").appendTo(span3);
+                        var timeoutField = $("<input/>", {
+                            //placeholder: "",
+                            type: "text",
+                            class: "addon-gui-waitUntil-timeout"
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "105pt"
+                        }).appendTo(span3);
+                        $(timeoutField).typedInput({
+                            default: "num",
+                            types: [
+                                "num"
+                            ]
+                        });
+                        $("<label/>", {
+                        }).css({
+                            "text-align": "left",
+                            width: "100px",
+                            "margin-left": "5px"
+                        }).text("ms").appendTo(span3);
+
+                        if (data && data.timeout) {
+                            $(timeoutField).typedInput("value", data.timeout);
+                        } else {
+                            $(timeoutField).typedInput("value", 5000);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                        row3.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-waitUntil-span0");
+                        var row1 = row0.find(".addon-gui-waitUntil-div1");
+                        var row2 = row0.find(".addon-gui-waitUntil-div2");
+                        var row3 = row0.find(".addon-gui-waitUntil-div3");
+                        span0.show();
+                        row1.show();
+                        row2.show();
+                        row3.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-waitUntil-span0");
+                        var row1 = row0.find(".addon-gui-waitUntil-div1");
+                        var row2 = row0.find(".addon-gui-waitUntil-div2");
+                        var row3 = row0.find(".addon-gui-waitUntil-div3");
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                        row3.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-waitUntil-target").val();
+                        var selector = con.find(".addon-gui-waitUntil-selector").val();
+                        var type = con.find(".addon-gui-waitUntil-value").typedInput("type");
+                        var value = con.find(".addon-gui-waitUntil-value").typedInput("value");
+                        var timeout = con.find(".addon-gui-waitUntil-timeout").typedInput("value");
+                        return {
+                            target: target,
+                            selector: selector,
+                            type: type,
+                            value: value,
+                            timeout: timeout,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-addValue
+                {
+                    name: "addon:GUI-addValue",
+                    label: "GUI-addValue",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-addValue-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-addValue-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: selector
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-addValue-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-addValue-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("selector").appendTo(span1);
+                        var selectorField = $("<input/>", {
+                            placeholder: "element selector",
+                            type: "text",
+                            class: "addon-gui-addValue-selector",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.selector) {
+                            selectorField.val(data.selector);
+                        }
+
+                        // row2: value
+                        var row2 = $("<div/>", {
+                            class: "addon-gui-addValue-div2"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span2 = $("<span/>", {
+                            class: "addon-gui-addValue-span2"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row2);
+                        $("<label/>", {
+                        }).css({
+                            display: "inline-block",
+                            "text-align": "right",
+                            width: "100px"
+                        }).text("value").appendTo(span2);
+                        var valueField = $("<input/>", {
+                            placeholder: "value to add",
+                            type: "text",
+                            class: "addon-gui-addValue-value",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span2);
+                        $(valueField).typedInput({
+                            default: "str",
+                            types: [
+                                "str", "num", "bool"
+                            ]
+                        });
+                        if (data && data.value) {
+                            $(valueField).typedInput("value", data.value);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-addValue-span0");
+                        var row1 = row0.find(".addon-gui-addValue-div1");
+                        var row2 = row0.find(".addon-gui-addValue-div2");
+                        span0.show();
+                        row1.show();
+                        row2.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-addValue-span0");
+                        var row1 = row0.find(".addon-gui-addValue-div1");
+                        var row2 = row0.find(".addon-gui-addValue-div2");
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-addValue-target").val();
+                        var selector = con.find(".addon-gui-addValue-selector").val();
+                        var value = con.find(".addon-gui-addValue-value").typedInput("value");
+                        return {
+                            target: target,
+                            selector: selector,
+                            value: value,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-clearValue
+                {
+                    name: "addon:GUI-clearValue",
+                    label: "GUI-clearValue",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-clearValue-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-clearValue-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: selector
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-clearValue-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-clearValue-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("selector").appendTo(span1);
+                        var selectorField = $("<input/>", {
+                            placeholder: "element selector",
+                            type: "text",
+                            class: "addon-gui-clearValue-selector",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.selector) {
+                            selectorField.val(data.selector);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-clearValue-span0");
+                        var row1 = row0.find(".addon-gui-clearValue-div1");
+                        span0.show();
+                        row1.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-clearValue-span0");
+                        var row1 = row0.find(".addon-gui-clearValue-div1");
+                        span0.hide();
+                        row1.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-clearValue-target").val();
+                        var selector = con.find(".addon-gui-clearValue-selector").val();
+                        return {
+                            target: target,
+                            selector: selector,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-click
+                {
+                    name: "addon:GUI-click",
+                    label: "GUI-click",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-click-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-click-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: selector
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-click-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-click-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("selector").appendTo(span1);
+                        var selectorField = $("<input/>", {
+                            placeholder: "element selector",
+                            type: "text",
+                            class: "addon-gui-click-selector",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.selector) {
+                            selectorField.val(data.selector);
+                        }
+
+                        // row2: kind
+                        var row2 = $("<div/>", {
+                            class: "addon-gui-click-div2"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span2 = $("<span/>", {
+                            class: "addon-gui-click-span2"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row2);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("kind").appendTo(span2);
+                        var kindField = $("<select/>", {
+                            placeholder: "value",
+                            type: "text",
+                            class: "addon-gui-click-kind",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "100pt"
+                        }).appendTo(span2);
+                        $(kindField).empty();
+                        $("<option/>").text("click").val("single").appendTo(kindField);
+                        $("<option/>").text("double click").val("double").appendTo(kindField);
+                        if (data && data.clickkind) {
+                            $(kindField).val(data.clickkind);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-click-span0");
+                        var row1 = row0.find(".addon-gui-click-div1");
+                        var row2 = row0.find(".addon-gui-click-div2");
+                        span0.show();
+                        row1.show();
+                        row2.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-click-span0");
+                        var row1 = row0.find(".addon-gui-click-div1");
+                        var row2 = row0.find(".addon-gui-click-div2");
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-click-target").val();
+                        var selector = con.find(".addon-gui-click-selector").val();
+                        var clickkind = con.find(".addon-gui-click-kind").val();
+                        return {
+                            target: target,
+                            selector: selector,
+                            clickkind: clickkind,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-getValue
+                {
+                    name: "addon:GUI-getValue",
+                    label: "GUI-getValue",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-getValue-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-getValue-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: selector
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-getValue-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-getValue-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("selector").appendTo(span1);
+                        var selectorField = $("<input/>", {
+                            placeholder: "element selector",
+                            type: "text",
+                            class: "addon-gui-getValue-selector",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.selector) {
+                            selectorField.val(data.selector);
+                        }
+
+                        // row2: kind
+                        var row2 = $("<div/>", {
+                            class: "addon-gui-getValue-div2"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span2 = $("<span/>", {
+                            class: "addon-gui-getValue-span2"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row2);
+                        $("<label/>", {
+                        }).css({
+                            display: "inline-block",
+                            "text-align": "right",
+                            width: "100px"
+                        }).text("kind").appendTo(span2);
+                        var kindField = $("<select/>", {
+                            placeholder: "value",
+                            type: "text",
+                            class: "addon-gui-getValue-kind",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "100pt"
+                        }).appendTo(span2);
+                        $(kindField).empty();
+                        $("<option/>").text("attribute").val("attr").appendTo(kindField);
+                        $("<option/>").text("property").val("prop").appendTo(kindField);
+                        $("<option/>").text("tag").val("tag").appendTo(kindField);
+                        $("<option/>").text("text").val("text").appendTo(kindField);
+                        $("<option/>").text("value").val("val").appendTo(kindField);
+                        if (data && data.getkind) {
+                            $(kindField).val(data.getkind);
+                        }
+
+                        // row3: name(option prop or attr)
+                        var row3 = $("<div/>", {
+                            class: "addon-gui-getValue-div3"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span3 = $("<span/>", {
+                            class: "addon-gui-getValue-span3"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row3);
+                        $("<label/>", {
+                        }).css({
+                            display: "inline-block",
+                            "text-align": "right",
+                            width: "100px"
+                        }).text("name").appendTo(span3);
+                        var getnameField = $("<input/>", {
+                            placeholder: "name for properties or attributes",
+                            type: "text",
+                            class: "addon-gui-getValue-name",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span3);
+                        if (data && data.getname) {
+                            getnameField.val(data.getname);
+                        }
+
+                        // row4: loc
+                        var row4 = $("<div/>", {
+                            class: "addon-gui-getValue-div4"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span4 = $("<span/>", {
+                            class: "addon-gui-getValue-span4"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row4);
+                        $("<label/>", {
+                        }).css({
+                            display: "inline-block",
+                            "text-align": "right",
+                            width: "100px"
+                        }).text("loc").appendTo(span4);
+                        var locField = $("<input/>", {
+                            placeholder: "store value name",
+                            class: "addon-gui-getValue-loc"
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span4);
+                        $(locField).typedInput({
+                            default: "flow",
+                            types: [
+                                "flow", "global"
+                            ]
+                        });
+                        if (data && data.type && data.value) {
+                            $(locField).typedInput("type", data.type);
+                            $(locField).typedInput("value", data.value);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                        row3.hide();
+                        row4.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-getValue-span0");
+                        var row1 = row0.find(".addon-gui-getValue-div1");
+                        var row2 = row0.find(".addon-gui-getValue-div2");
+                        var row3 = row0.find(".addon-gui-getValue-div3");
+                        var row4 = row0.find(".addon-gui-getValue-div4");
+                        span0.show();
+                        row1.show();
+                        row2.show();
+                        row3.show();
+                        row4.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-getValue-span0");
+                        var row1 = row0.find(".addon-gui-getValue-div1");
+                        var row2 = row0.find(".addon-gui-getValue-div2");
+                        var row3 = row0.find(".addon-gui-getValue-div3");
+                        var row4 = row0.find(".addon-gui-getValue-div4");
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                        row3.hide();
+                        row4.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-getValue-target").val();
+                        var selector = con.find(".addon-gui-getValue-selector").val();
+                        var getkind = con.find(".addon-gui-getValue-kind").val();
+                        var getname = con.find(".addon-gui-getValue-name").val();
+                        var type = con.find(".addon-gui-getValue-loc").typedInput("type");
+                        var value = con.find(".addon-gui-getValue-loc").typedInput("value");
+                        return {
+                            target: target,
+                            selector: selector,
+                            getkind: getkind,
+                            getname: getname,
+                            type: type,
+                            value: value,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-moveTo
+                {
+                    name: "addon:GUI-moveTo",
+                    label: "GUI-moveTo",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-moveTo-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-moveTo-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: selector
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-moveTo-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-moveTo-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("selector").appendTo(span1);
+                        var selectorField = $("<input/>", {
+                            placeholder: "element selector",
+                            type: "text",
+                            class: "addon-gui-moveTo-selector",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.selector) {
+                            selectorField.val(data.selector);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-moveTo-span0");
+                        var row1 = row0.find(".addon-gui-moveTo-div1");
+                        span0.show();
+                        row1.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-moveTo-span0");
+                        var row1 = row0.find(".addon-gui-moveTo-div1");
+                        span0.hide();
+                        row1.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-moveTo-target").val();
+                        var selector = con.find(".addon-gui-moveTo-selector").val();
+                        return {
+                            target: target,
+                            selector: selector,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-setValue
+                {
+                    name: "addon:GUI-setValue",
+                    label: "GUI-setValue",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-setValue-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-setValue-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: selector
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-setValue-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-setValue-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("selector").appendTo(span1);
+                        var selectorField = $("<input/>", {
+                            placeholder: "element selector",
+                            type: "text",
+                            class: "addon-gui-setValue-selector",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.selector) {
+                            selectorField.val(data.selector);
+                        }
+
+                        // row2: value
+                        var row2 = $("<div/>", {
+                            class: "addon-gui-setValue-div2"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span2 = $("<span/>", {
+                            class: "addon-gui-setValue-span2"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row2);
+                        $("<label/>", {
+                        }).css({
+                            display: "inline-block",
+                            "text-align": "right",
+                            width: "100px"
+                        }).text("value").appendTo(span2);
+                        var valueField = $("<input/>", {
+                            placeholder: "value to set",
+                            type: "text",
+                            class: "addon-gui-setValue-value",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span2);
+                        $(valueField).typedInput({
+                            default: "str",
+                            types: [
+                                "str", "num", "bool"
+                            ]
+                        });
+                        if (data && data.value) {
+                            $(valueField).typedInput("value", data.value);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-setValue-span0");
+                        var row1 = row0.find(".addon-gui-setValue-div1");
+                        var row2 = row0.find(".addon-gui-setValue-div2");
+                        span0.show();
+                        row1.show();
+                        row2.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-setValue-span0");
+                        var row1 = row0.find(".addon-gui-setValue-div1");
+                        var row2 = row0.find(".addon-gui-setValue-div2");
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-setValue-target").val();
+                        var selector = con.find(".addon-gui-setValue-selector").val();
+                        var value = con.find(".addon-gui-setValue-value").typedInput("value");
+                        return {
+                            target: target,
+                            selector: selector,
+                            value: value,
+                            performCheck: false
+                        };
+                    }
+                }
+            ];
+        }
+    });
+})();
+</script>
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.js b/examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.js
new file mode 100644
index 0000000..faac1ad
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.js
@@ -0,0 +1,617 @@
+module.exports = (RED) => {
+    "use strict";
+
+    // WebDriver object
+    const { remote } = require('webdriverio');
+    const promisify = require("util").promisify;
+
+
+    // Browser instance
+    var browser_instances = [];
+
+    // Get a browser instance
+    async function getBrowser(target) {
+        let key = "_default";
+        if (target) {
+            key = target;
+        } 
+        let browser = browser_instances[key] || null;
+        if (!browser) {
+            browser = await remote({
+                capabilities: {
+                    browserName: 'chrome'
+                }
+            })
+            browser_instances[key] = browser;
+        }
+        return browser; 
+    }
+
+    async function testClose(){ 
+        for (let key in browser_instances) {
+            let browser = browser_instances[key];
+            await browser.deleteSession();
+            delete browser_instances[key];
+        }
+    }
+
+    function testClear(){ 
+        for (let key in browser_instances) {
+            delete browser_instances[key];
+        }
+    }
+
+    console.log("; Initialize flow tester gui addon");
+    RED.plugins.registerPlugin('node-red-flow-tester-gui-addon', {
+        type: "flow-tester-addon",
+        actions: function () {
+            return [
+                {
+                    name: "addon:GUI-URL",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            // Close all browser instances after test
+                            ;(async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                    //reject(err.message);
+                                }
+                            })()
+                        })
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            // Perform an operation on an object with the specified instance name
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    if (action.size) {
+                                        const size = action.size.split(',');
+                                        await browser.setWindowSize(Number(size[0]),Number(size[1]));
+                                    }
+                                    await browser.url(action.url);
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    },
+                },
+                {
+                    name: "addon:GUI-Keys",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    if (action.key) {
+                                        const keys = action.key.split(',');
+                                        await browser.keys(keys);
+                                    }
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-saveScreenshot",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    if (action.url) {
+                                        // Optional: Open the specified URL
+                                        await browser.url(action.url)
+                                    }
+                                    await browser.saveScreenshot(action.filepath);
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-setCookies",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    const cookies = JSON.parse(action.cookie);
+                                    await browser.setCookies(cookies);
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-setTimeout",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    const timeout = JSON.parse(action.timeout);
+                                    await browser.setTimeout(timeout);
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-waitUntil",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            let  timeout = Number(action.timeout);
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    await browser.waitUntil(
+                                        async () => (
+                                            action.type === "str" && (await browser.$(action.selector).getText() === action.value) || 
+                                            action.type === "re"  && (new RegExp(action.value).test(await browser.$(action.selector).getText()))),
+                                        {
+                                            //timeout: Number(action.timeout),
+                                            timeout: timeout,
+                                            timeoutMsg: 'expected text to be different after ' + action.timeout + "ms"
+                                        }
+                                    );
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-addValue",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    await browser.$(action.selector).addValue(action.value);
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-clearValue",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    await browser.$(action.selector).clearValue();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-click",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    if (action.clickkind === 'single') {
+                                        await browser.$(action.selector).click();
+                                    } else {
+                                        await browser.$(action.selector).doubleClick();
+                                    }
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-getValue",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            const nid = opt.node;
+                            const msg = opt.msg;
+                            const node = nid ? RED.nodes.getNode(nid) : null;
+                            let val = ""
+                            if (!node) {
+                                console.log("Must be run in a node instance test.");
+                                reject("Must be run in a node instance test.");
+                                return;
+                            }
+
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    if (action.getkind === 'attr') {
+                                        val = await browser.$(action.selector).getAttribute(action.getname);
+                                    } else if (action.getkind === 'prop') {
+                                        val = await browser.$(action.selector).getProperty(action.getname);
+                                    } else if (action.getkind === 'tag') {
+                                        val = await browser.$(action.selector).getTagName();
+                                    } else if (action.getkind === 'text') {
+                                        val = await browser.$(action.selector).getText();
+                                    } else if (action.getkind === 'val') {
+                                        val = await browser.$(action.selector).getValue();
+                                    }
+
+                                    switch (action.type) {
+                                        //case "msg":
+                                        //    if (msg) {
+                                        //        RED.util.setMessageProperty(msg, action.value, value);
+                                        //    }
+                                        //    break;
+                                        case "global":
+                                        case "flow":
+                                            const contextKey = RED.util.parseContextStore(action.value);
+                                            if (/\[msg/.test(contextKey.key)) {
+                                                // The key has a nest msg. reference to evaluate first
+                                                contextKey.key = RED.util.normalisePropertyExpression(contextKey.key, msg, true)
+                                            }
+                                            const target = node.context()[action.type];
+                                            const set = promisify(target.set);
+                                            set(contextKey.key, val, contextKey.store);
+                                            break;
+                                        default:
+                                            console.log("unexpected value type: "+ action.type);
+                                            reject("unexpected value type: "+ action.type);
+                                    }
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-moveTo",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    await browser.$(action.selector).moveTo();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-setValue",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    await browser.$(action.selector).setValue(action.value);
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                }
+            ];
+        }
+    });
+};
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/src/locales/en-US/flow-tester-gui-addon.json b/examples/node-red-contrib-flow-tester-gui-addon/src/locales/en-US/flow-tester-gui-addon.json
new file mode 100644
index 0000000..3f29600
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-gui-addon/src/locales/en-US/flow-tester-gui-addon.json
@@ -0,0 +1,4 @@
+{
+    "label": {
+    }
+}
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/src/style.css b/examples/node-red-contrib-flow-tester-gui-addon/src/style.css
new file mode 100644
index 0000000..e69de29
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/test/test.js b/examples/node-red-contrib-flow-tester-gui-addon/test/test.js
new file mode 100644
index 0000000..2a4de75
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-gui-addon/test/test.js
@@ -0,0 +1,2 @@
+describe("Flow tester gui addon tests", function() {
+});

From 75048a6e51fdb31cb802482c2f7df3afaadf65ff Mon Sep 17 00:00:00 2001
From: Kazuhiro Ito <kazuhiro.ito.ek@hitachi-solutions.com>
Date: Tue, 29 Mar 2022 09:43:45 +0900
Subject: [PATCH 8/9] =?UTF-8?q?Remove=20the=20GUI=E3=80=80test=20addon?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../LICENSE                                   |  201 --
 .../README.md                                 |   56 -
 .../examples/GUI-Test-Example.json            |    1 -
 .../package.json                              |   47 -
 .../scripts/build.js                          |   51 -
 .../src/flow-tester-gui-addon.html            | 1663 -----------------
 .../src/flow-tester-gui-addon.js              |  617 ------
 .../locales/en-US/flow-tester-gui-addon.json  |    4 -
 .../src/style.css                             |    0
 .../test/test.js                              |    2 -
 10 files changed, 2642 deletions(-)
 delete mode 100644 examples/node-red-contrib-flow-tester-gui-addon/LICENSE
 delete mode 100644 examples/node-red-contrib-flow-tester-gui-addon/README.md
 delete mode 100644 examples/node-red-contrib-flow-tester-gui-addon/examples/GUI-Test-Example.json
 delete mode 100644 examples/node-red-contrib-flow-tester-gui-addon/package.json
 delete mode 100644 examples/node-red-contrib-flow-tester-gui-addon/scripts/build.js
 delete mode 100644 examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.html
 delete mode 100644 examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.js
 delete mode 100644 examples/node-red-contrib-flow-tester-gui-addon/src/locales/en-US/flow-tester-gui-addon.json
 delete mode 100644 examples/node-red-contrib-flow-tester-gui-addon/src/style.css
 delete mode 100644 examples/node-red-contrib-flow-tester-gui-addon/test/test.js

diff --git a/examples/node-red-contrib-flow-tester-gui-addon/LICENSE b/examples/node-red-contrib-flow-tester-gui-addon/LICENSE
deleted file mode 100644
index 261eeb9..0000000
--- a/examples/node-red-contrib-flow-tester-gui-addon/LICENSE
+++ /dev/null
@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/README.md b/examples/node-red-contrib-flow-tester-gui-addon/README.md
deleted file mode 100644
index 9052440..0000000
--- a/examples/node-red-contrib-flow-tester-gui-addon/README.md
+++ /dev/null
@@ -1,56 +0,0 @@
-# node-red-flow-tester-gui-addon
-
-An GUI Test Addon to Flow Testing plugin for Node-RED
-
-**This is under development and not ready for general use. If you want to contribute, come talk to us in the `#core-dev` channel on https://nodered.org/slack
-
-## Developing
-
-To use the development version of Flow Tester Addon you can clone its source code repository
-and build it yourself.
-
-1. Get the source code
-
-```
-git clone https://github.com/node-red/node-red-flow-tester-gui-addon.git
-```
-
-2. Install the dependencies
-
-```
-cd node-red-flow-tester-gui-addon
-npm install
-```
-
-3. Build the plugin
-
-```
-npm run build
-```
-
-4. Install into Node-RED
-
-```
-cd ~/.node-red
-npm install <path-to-node-red-flow-tester-gui-addon-directory>
-```
-
-5. Restart Node-RED to load the plugin.
-
-### Source code structure
-
- - `scripts` - build scripts used by `npm run build`
- - `src` - source code of the plugins
- - `test` - tests material
- - `examples` - test flow example
-
-After `npm run build` is run, the following directories will be created:
-
- - `dist` - contains the built plugin files
- - `resources` contains the built plugin resource files (eg css)
-
-## License
-
-Copyright Node-RED Project Contributors.
-
-Licensed under the [Apache License, Version 2.0](LICENSE).
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/examples/GUI-Test-Example.json b/examples/node-red-contrib-flow-tester-gui-addon/examples/GUI-Test-Example.json
deleted file mode 100644
index afad3ad..0000000
--- a/examples/node-red-contrib-flow-tester-gui-addon/examples/GUI-Test-Example.json
+++ /dev/null
@@ -1 +0,0 @@
-[{"id":"9b3db84fb21d2ae9","type":"tab","label":"フロー 1","disabled":false,"info":"","env":[]},{"id":"bcdef1528a38ab01","type":"flow-test-config","name":"Test Suite 0","tests":[{"id":"T1dqpqj7o1mo","name":"01-GUI-URL","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test1","url":"http://localhost:1880/test1-1","size":"1024,768","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test2","url":"http://localhost:1880/test1-2","size":"800,600","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test1","url":"","filepath":"./save/01-GUI-URL_1.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"target":"test2","url":"","filepath":"./save/01-GUI-URL_2.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"01-GUI-URL"}],"fe5f34a07f8fa02d":[],"33f0acbced5f2f2f":[],"3f1bc77ebad6fb7d":[],"89abec8dc8dcd928":[],"3433732293b0efe6":[],"4cbdf19859bd3673":[],"a57d5145d9cc69f8":[],"3a204cb1e4e7e798":[],"3b1b52e7950d2d96":[],"a8b9279ac2b7bb34":[],"3d80cb23855d1f23":[],"ea2689d761c694d9":[],"df63e899f76ec37d":[],"73b88c9ce8eb419b":[],"e2cc4ae0d72b963b":[],"fe3ad091b0d72fa6":[],"01a33fd443f37a9d":[],"5a88bb5ee5f74048":[],"de20304a494f612c":[],"46a0c697fa6f3aa9":[],"e53fcf4665e96479":[],"1851347e41085efa":[],"2135f0ed4da03687":[],"ecbdd8f3f5d1a43f":[],"6b5edcefaf047657":[],"252be38b87101a0c":[],"d9631503adada096":[],"f96271d463f3d005":[],"e9568cd8a3881f7a":[],"7deb2f295e4cf286":[],"b15db00ea98ccdb8":[],"da44efa0625b0c46":[],"b2abfc59dfd6747f":[],"9ad3814da7eb0bf8":[],"e0e8d9808cbefc12":[],"57489d4a6843ed06":[],"bf6dc3e2d4bba78a":[],"08cab205b3caa944":[],"67123a9c0d3e0d6b":[],"2ab47c47fb5f303e":[],"c7e554e9a8a3c157":[],"2486e1ca0a98c73f":[],"71f6558f1dbc157d":[],"0aac7206f22fd418":[],"2c3680f456d44179":[],"334278a4d04eef8e":[],"46fd6974c4ab4dd4":[],"006bc52baad3b791":[],"f79c8d74d708debb":[],"c5143318646fb9fd":[],"640d91fab434d070":[],"553dac4c5471d519":[],"cb0a6d52972bcc02":[],"193db0840f528392":[],"3d690e3169d2d483":[],"6717a5b7fb237bd1":[],"bf0d97744cf36e4c":[],"8e35628ea9d99957":[],"2b0fd9cc8afbdcd6":[],"b6aa9aef3d3647a3":[],"db5b2d254533ef8b":[],"46d010cd56ba8914":[],"29f54a1ad235097e":[],"a4d57d3ae7aff215":[],"f470657e71958b8f":[],"42419f5d347b6c64":[]},"cleanup":{"_global_":[],"fe5f34a07f8fa02d":[],"33f0acbced5f2f2f":[],"3f1bc77ebad6fb7d":[],"89abec8dc8dcd928":[],"3433732293b0efe6":[],"4cbdf19859bd3673":[],"a57d5145d9cc69f8":[],"3a204cb1e4e7e798":[],"3b1b52e7950d2d96":[],"a8b9279ac2b7bb34":[],"3d80cb23855d1f23":[],"ea2689d761c694d9":[],"df63e899f76ec37d":[],"73b88c9ce8eb419b":[],"e2cc4ae0d72b963b":[],"fe3ad091b0d72fa6":[],"01a33fd443f37a9d":[],"5a88bb5ee5f74048":[],"de20304a494f612c":[],"46a0c697fa6f3aa9":[],"e53fcf4665e96479":[],"1851347e41085efa":[],"2135f0ed4da03687":[],"ecbdd8f3f5d1a43f":[],"6b5edcefaf047657":[],"252be38b87101a0c":[],"d9631503adada096":[],"f96271d463f3d005":[],"e9568cd8a3881f7a":[],"7deb2f295e4cf286":[],"b15db00ea98ccdb8":[],"da44efa0625b0c46":[],"b2abfc59dfd6747f":[],"9ad3814da7eb0bf8":[],"e0e8d9808cbefc12":[],"57489d4a6843ed06":[],"bf6dc3e2d4bba78a":[],"08cab205b3caa944":[],"67123a9c0d3e0d6b":[],"2ab47c47fb5f303e":[],"c7e554e9a8a3c157":[],"2486e1ca0a98c73f":[],"71f6558f1dbc157d":[],"0aac7206f22fd418":[],"2c3680f456d44179":[],"334278a4d04eef8e":[],"46fd6974c4ab4dd4":[],"006bc52baad3b791":[],"f79c8d74d708debb":[],"c5143318646fb9fd":[],"640d91fab434d070":[],"553dac4c5471d519":[],"cb0a6d52972bcc02":[],"193db0840f528392":[],"3d690e3169d2d483":[],"6717a5b7fb237bd1":[],"bf0d97744cf36e4c":[],"8e35628ea9d99957":[],"2b0fd9cc8afbdcd6":[],"b6aa9aef3d3647a3":[],"db5b2d254533ef8b":[],"46d010cd56ba8914":[],"29f54a1ad235097e":[],"a4d57d3ae7aff215":[],"f470657e71958b8f":[],"42419f5d347b6c64":[]},"recv":{"fe5f34a07f8fa02d":[],"33f0acbced5f2f2f":[],"3f1bc77ebad6fb7d":[],"89abec8dc8dcd928":[],"a57d5145d9cc69f8":[],"3a204cb1e4e7e798":[],"3b1b52e7950d2d96":[],"a8b9279ac2b7bb34":[],"3d80cb23855d1f23":[],"ea2689d761c694d9":[],"fe3ad091b0d72fa6":[],"01a33fd443f37a9d":[],"5a88bb5ee5f74048":[],"e9568cd8a3881f7a":[],"7deb2f295e4cf286":[],"b15db00ea98ccdb8":[],"b2abfc59dfd6747f":[],"e0e8d9808cbefc12":[],"57489d4a6843ed06":[],"08cab205b3caa944":[],"67123a9c0d3e0d6b":[],"c7e554e9a8a3c157":[],"0aac7206f22fd418":[],"2c3680f456d44179":[],"334278a4d04eef8e":[],"46fd6974c4ab4dd4":[],"006bc52baad3b791":[],"f79c8d74d708debb":[],"c5143318646fb9fd":[],"640d91fab434d070":[],"553dac4c5471d519":[],"193db0840f528392":[{"kind":"match","value":"01-GUI-URL","performCheck":true}],"3d690e3169d2d483":[],"bf0d97744cf36e4c":[],"8e35628ea9d99957":[],"2b0fd9cc8afbdcd6":[],"b6aa9aef3d3647a3":[],"db5b2d254533ef8b":[],"46d010cd56ba8914":[],"29f54a1ad235097e":[],"a4d57d3ae7aff215":[]},"stub":{"fe5f34a07f8fa02d":[],"33f0acbced5f2f2f":[],"3f1bc77ebad6fb7d":[],"89abec8dc8dcd928":[],"a57d5145d9cc69f8":[],"3a204cb1e4e7e798":[],"3b1b52e7950d2d96":[],"a8b9279ac2b7bb34":[],"3d80cb23855d1f23":[],"ea2689d761c694d9":[],"fe3ad091b0d72fa6":[],"01a33fd443f37a9d":[],"5a88bb5ee5f74048":[],"e9568cd8a3881f7a":[],"7deb2f295e4cf286":[],"b15db00ea98ccdb8":[],"b2abfc59dfd6747f":[],"e0e8d9808cbefc12":[],"57489d4a6843ed06":[],"08cab205b3caa944":[],"67123a9c0d3e0d6b":[],"c7e554e9a8a3c157":[],"0aac7206f22fd418":[],"2c3680f456d44179":[],"334278a4d04eef8e":[],"46fd6974c4ab4dd4":[],"006bc52baad3b791":[],"f79c8d74d708debb":[],"c5143318646fb9fd":[],"640d91fab434d070":[],"553dac4c5471d519":[],"193db0840f528392":[],"3d690e3169d2d483":[],"bf0d97744cf36e4c":[],"8e35628ea9d99957":[],"2b0fd9cc8afbdcd6":[],"b6aa9aef3d3647a3":[],"db5b2d254533ef8b":[],"46d010cd56ba8914":[],"29f54a1ad235097e":[],"a4d57d3ae7aff215":[]},"send":{"fe5f34a07f8fa02d":[],"33f0acbced5f2f2f":[],"3f1bc77ebad6fb7d":[],"89abec8dc8dcd928":[],"3433732293b0efe6":[],"4cbdf19859bd3673":[],"a57d5145d9cc69f8":[],"3a204cb1e4e7e798":[],"3d80cb23855d1f23":[],"fe3ad091b0d72fa6":[],"01a33fd443f37a9d":[],"5a88bb5ee5f74048":[],"f96271d463f3d005":[],"e9568cd8a3881f7a":[],"b15db00ea98ccdb8":[],"da44efa0625b0c46":[],"b2abfc59dfd6747f":[],"9ad3814da7eb0bf8":[],"e0e8d9808cbefc12":[],"57489d4a6843ed06":[],"bf6dc3e2d4bba78a":[],"08cab205b3caa944":[],"67123a9c0d3e0d6b":[],"2ab47c47fb5f303e":[],"c7e554e9a8a3c157":[],"2486e1ca0a98c73f":[],"71f6558f1dbc157d":[],"0aac7206f22fd418":[],"2c3680f456d44179":[],"334278a4d04eef8e":[],"46fd6974c4ab4dd4":[],"f79c8d74d708debb":[],"c5143318646fb9fd":[],"640d91fab434d070":[],"3d690e3169d2d483":[],"6717a5b7fb237bd1":[],"8e35628ea9d99957":[],"2b0fd9cc8afbdcd6":[],"b6aa9aef3d3647a3":[],"db5b2d254533ef8b":[],"46d010cd56ba8914":[],"29f54a1ad235097e":[],"a4d57d3ae7aff215":[]}}},{"id":"Tr3j3798bung","name":"02-GUI-Keys","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test","url":"http://localhost:1880/ui/#!/0","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"kind":"send","target":"3a204cb1e4e7e798","value":"0"},{"target":"test","selector":"#\\30 2_GUI-Keys_Group_1_cards > md-card.nr-dashboard-slider._md.layout-align-space-between-center.layout-row.flex.visible","type":"str","value":"slider","timeout":"5000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test","key":"Tab,Tab","performCheck":false,"kind":"addon:GUI-Keys"},{"target":"test","key":"ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight","performCheck":false,"kind":"addon:GUI-Keys"},{"kind":"wait","wait":"1000"},{"target":"test","url":"","filepath":"./save/02-GUI-Keys.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"02-GUI-Keys"}],"193db0840f528392":[]},"cleanup":{"_global_":[],"193db0840f528392":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"02-GUI-Keys","performCheck":true}]},"stub":{"193db0840f528392":[]},"send":{}}},{"id":"Tm3obhhm6vug","name":"03-GUI-saveScreenshot","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test","url":"http://localhost:1880/test3","filepath":"./save/03-GUI-saveScreenshot.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"03-GUI-saveScreenshot"}],"193db0840f528392":[]},"cleanup":{"_global_":[],"193db0840f528392":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"03-GUI-saveScreenshot","performCheck":true}]},"stub":{"193db0840f528392":[]},"send":{}}},{"id":"T8ehjolrb0og","name":"04-GUI-setCookies","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test","url":"http://localhost:1880/test4","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","cookie":"[{\"name\":\"test1\",\"value\":\"123\"},{\"name\":\"test2\",\"value\":\"456\"},{\"name\":\"test3\",\"value\":\"789\"}]","performCheck":false,"kind":"addon:GUI-setCookies"},{"target":"test","url":"http://localhost:1880/test4","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","url":"","filepath":"./save/04-GUI-setCookies.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"04-GUI-setCookies"}],"193db0840f528392":[]},"cleanup":{"_global_":[],"193db0840f528392":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"04-GUI-setCookies","performCheck":true}]},"stub":{"193db0840f528392":[]},"send":{}}},{"id":"Tqicqojskkb","name":"05-GUI-setTimeout","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test1","timeout":"{\"pageLoad\":5000}","performCheck":false,"kind":"addon:GUI-setTimeout"},{"target":"test1","url":"http://localhost:1880/test5-1","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test2","timeout":"{\"pageLoad\":5000}","performCheck":false,"kind":"addon:GUI-setTimeout"},{"target":"test2","url":"http://localhost:1880/test5-2","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"kind":"send","target":"193db0840f528392","value":"05-GUI-setTimeout"}],"193db0840f528392":[]},"cleanup":{"_global_":[],"193db0840f528392":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"05-GUI-setTimeout","performCheck":true}]},"stub":{"193db0840f528392":[]},"send":{}}},{"id":"Tktn10o59iug","name":"06-GUI-waitUntil","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test1","url":"http://localhost:1880/test6-1","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test1","selector":"#ID_TEXT","type":"re","value":"\\d{2}","timeout":"10000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test2","url":"http://localhost:1880/test6-2","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test2","selector":"#ID_TEXT","type":"re","value":"\\d{2}","timeout":"10000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"kind":"send","target":"193db0840f528392","value":"06-GUI-waitUntil"}],"193db0840f528392":[]},"cleanup":{"_global_":[],"193db0840f528392":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"06-GUI-waitUntil","performCheck":true}]},"stub":{"193db0840f528392":[]},"send":{}}},{"id":"Taqk7q2rj9ng","name":"07-GUI-addValue","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"kind":"send","target":"640d91fab434d070","value":"test addValue "},{"target":"test","url":"http://localhost:1880/ui/#!/1","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","selector":"#input_0","type":"str","value":"","timeout":"5000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test","selector":"#input_0","value":"add1 ","performCheck":false,"kind":"addon:GUI-addValue"},{"target":"test","selector":"#input_0","value":"add2 ","performCheck":false,"kind":"addon:GUI-addValue"},{"target":"test","selector":"#input_0","value":"add3","performCheck":false,"kind":"addon:GUI-addValue"},{"target":"test","url":"","filepath":"./save/07-GUI-addValue.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"07-GUI-addValue"}],"553dac4c5471d519":[],"193db0840f528392":[]},"cleanup":{"_global_":[],"553dac4c5471d519":[],"193db0840f528392":[]},"recv":{"553dac4c5471d519":[{"kind":"match","value":"test addValue add1 add2 add3","performCheck":true}],"193db0840f528392":[{"kind":"match","value":"07-GUI-addValue","performCheck":true}]},"stub":{"553dac4c5471d519":[],"193db0840f528392":[]},"send":{}}},{"id":"T1f2t37fo80o","name":"08-GUI-clearValue","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"kind":"send","target":"640d91fab434d070","value":"test clearValue"},{"target":"test","url":"http://localhost:1880/ui/#!/1","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","selector":"#input_0","type":"str","value":"","timeout":"5000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test","selector":"#input_0","performCheck":false,"kind":"addon:GUI-clearValue"},{"target":"test","selector":"#input_0","value":"Test 08-GUI-clearValue","performCheck":false,"kind":"addon:GUI-addValue"},{"target":"test","url":"","filepath":"./save/08-GUI-clearValue.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"08-GUI-clearValue"}],"553dac4c5471d519":[],"193db0840f528392":[]},"cleanup":{"_global_":[],"553dac4c5471d519":[],"193db0840f528392":[]},"recv":{"553dac4c5471d519":[{"kind":"match","value":"Test 08-GUI-clearValue","performCheck":true}],"193db0840f528392":[{"kind":"match","value":"08-GUI-clearValue","performCheck":true}]},"stub":{"553dac4c5471d519":[],"193db0840f528392":[]},"send":{}}},{"id":"Tgbjs7hefb9","name":"09-GUI-click","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"kind":"send","target":"ea2689d761c694d9","value":""},{"target":"test","url":"http://localhost:1880/ui/#!/2","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","selector":"#\\30 9_GUI-click_Group_1_cards > md-card.nr-dashboard-button._md.visible > button","type":"str","value":"BUTTON","timeout":"5000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test","selector":"#\\30 9_GUI-click_Group_1_cards > md-card.nr-dashboard-button._md.visible > button","clickkind":"single","performCheck":false,"kind":"addon:GUI-click"},{"kind":"wait","wait":"1000"},{"target":"test","url":"","filepath":"./save/09-GUI-click.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"09-GUI-click"}],"5a88bb5ee5f74048":[],"193db0840f528392":[]},"cleanup":{"_global_":[],"5a88bb5ee5f74048":[],"193db0840f528392":[]},"recv":{"5a88bb5ee5f74048":[],"193db0840f528392":[{"kind":"match","value":"09-GUI-click","performCheck":true}]},"stub":{"5a88bb5ee5f74048":[],"193db0840f528392":[]},"send":{"5a88bb5ee5f74048":[{"kind":"match","value":"Button was clicked.","performCheck":true}]}}},{"id":"Tcacec5v6mao","name":"10-GUI-getValue","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test","url":"http://localhost:1880/test10","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"kind":"click","target":"29e3ad51752ad855"}],"193db0840f528392":[],"a4d57d3ae7aff215":[],"bf0d97744cf36e4c":[]},"cleanup":{"_global_":[],"193db0840f528392":[],"a4d57d3ae7aff215":[],"bf0d97744cf36e4c":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"10-GUI-getValue","performCheck":true}],"a4d57d3ae7aff215":[{"target":"test","selector":"#ID_TAG","getkind":"tag","getname":"","type":"global","value":"tag","performCheck":false,"kind":"addon:GUI-getValue"},{"target":"test","selector":"#ID_TEXT","getkind":"text","getname":"","type":"global","value":"text","performCheck":false,"kind":"addon:GUI-getValue"},{"target":"test","selector":"#ID_PROP","getkind":"prop","getname":"testprop","type":"flow","value":"property","performCheck":false,"kind":"addon:GUI-getValue"},{"target":"test","selector":"#ID_VALUE","getkind":"val","getname":"","type":"global","value":"value","performCheck":false,"kind":"addon:GUI-getValue"},{"target":"test","selector":"#ID_ATTR","getkind":"attr","getname":"attribute","type":"flow","value":"attribute","performCheck":false,"kind":"addon:GUI-getValue"},{"target":"test","selector":"#ID_VALUE","getkind":"prop","getname":"type","type":"flow","value":"property","performCheck":false,"kind":"addon:GUI-getValue"}],"bf0d97744cf36e4c":[]},"stub":{"193db0840f528392":[],"a4d57d3ae7aff215":[],"bf0d97744cf36e4c":[]},"send":{"a4d57d3ae7aff215":[{"kind":"wait","wait":"2000"},{"kind":"match","value":"h1TEST-TextTEST-ValueTEST-Attributetext","performCheck":true},{"kind":"send","target":"193db0840f528392","value":"10-GUI-getValue"}]}}},{"id":"T2cbqvf3cgc8","name":"11-GUI-moveTo","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test","url":"http://localhost:1880/ui/#!/3","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","selector":"#\\31 1_GUI-moveTo_Group_1_cards > md-card:nth-child(1) > button","type":"str","value":"BUTTON 1","timeout":"5000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test","selector":"#\\31 1_GUI-moveTo_Group_1_cards > md-card:nth-child(1) > button","performCheck":false,"kind":"addon:GUI-moveTo"},{"kind":"wait","wait":"1500"},{"target":"test","url":"","filepath":"./save/11-GUI-moveTo_1.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"target":"test","selector":"#\\31 1_GUI-moveTo_Group_1_cards > md-card:nth-child(2) > button","performCheck":false,"kind":"addon:GUI-moveTo"},{"kind":"wait","wait":"1500"},{"target":"test","url":"","filepath":"./save/11-GUI-moveTo_2.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"target":"test","selector":"#\\31 1_GUI-moveTo_Group_1_cards > md-card:nth-child(3) > button","performCheck":false,"kind":"addon:GUI-moveTo"},{"kind":"wait","wait":"1500"},{"target":"test","url":"","filepath":"./save/11-GUI-moveTo_3.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"11-GUI-moveTo"}],"193db0840f528392":[]},"cleanup":{"_global_":[],"193db0840f528392":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"11-GUI-moveTo","performCheck":true}]},"stub":{"193db0840f528392":[]},"send":{}}},{"id":"Tn9de8bpkfa8","name":"12-GUI-setValue","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"kind":"send","target":"a8b9279ac2b7bb34","value":""},{"target":"test","url":"http://localhost:1880/ui/#!/4","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","selector":"#input_0","type":"str","value":"","timeout":"5000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test","selector":"#input_0","value":"Test text","performCheck":false,"kind":"addon:GUI-setValue"},{"kind":"wait","wait":"1000"},{"target":"test","url":"","filepath":"./save/12-GUI-setValue.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"12-GUI-setValue"}],"fe3ad091b0d72fa6":[],"193db0840f528392":[]},"cleanup":{"_global_":[],"fe3ad091b0d72fa6":[],"193db0840f528392":[]},"recv":{"fe3ad091b0d72fa6":[],"193db0840f528392":[{"kind":"match","value":"12-GUI-setValue","performCheck":true}]},"stub":{"fe3ad091b0d72fa6":[],"193db0840f528392":[]},"send":{"fe3ad091b0d72fa6":[{"kind":"match","value":"Test text has been entered.","performCheck":true}]}}}]},{"id":"ea7e40d01b3c9e92","type":"ui_base","theme":{"name":"theme-light","lightTheme":{"default":"#0094CE","baseColor":"#0094CE","baseFont":"-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen-Sans,Ubuntu,Cantarell,Helvetica Neue,sans-serif","edited":true,"reset":false},"darkTheme":{"default":"#097479","baseColor":"#097479","baseFont":"-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen-Sans,Ubuntu,Cantarell,Helvetica Neue,sans-serif","edited":false},"customTheme":{"name":"Untitled Theme 1","default":"#4B7930","baseColor":"#4B7930","baseFont":"-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen-Sans,Ubuntu,Cantarell,Helvetica Neue,sans-serif"},"themeState":{"base-color":{"default":"#0094CE","value":"#0094CE","edited":false},"page-titlebar-backgroundColor":{"value":"#0094CE","edited":false},"page-backgroundColor":{"value":"#fafafa","edited":false},"page-sidebar-backgroundColor":{"value":"#ffffff","edited":false},"group-textColor":{"value":"#1bbfff","edited":false},"group-borderColor":{"value":"#ffffff","edited":false},"group-backgroundColor":{"value":"#ffffff","edited":false},"widget-textColor":{"value":"#111111","edited":false},"widget-backgroundColor":{"value":"#0094ce","edited":false},"widget-borderColor":{"value":"#ffffff","edited":false},"base-font":{"value":"-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen-Sans,Ubuntu,Cantarell,Helvetica Neue,sans-serif"}},"angularTheme":{"primary":"indigo","accents":"blue","warn":"red","background":"grey","palette":"light"}},"site":{"name":"Node-RED ダッシュボード","hideToolbar":"false","allowSwipe":"false","lockMenu":"false","allowTempTheme":"true","dateFormat":"YYYY/MM/DD","sizes":{"sx":48,"sy":48,"gx":6,"gy":6,"cx":6,"cy":6,"px":0,"py":0}}},{"id":"29571e93d0cd3bd8","type":"ui_group","name":"Group 1","tab":"","order":1,"disp":true,"width":6},{"id":"add392ac2ced5ed7","type":"ui_tab","name":"02 GUI-Keys","icon":"dashboard","order":1,"disabled":false,"hidden":false},{"id":"0779fd07b585202b","type":"ui_group","name":"Group 1","tab":"add392ac2ced5ed7","order":1,"disp":true,"width":"6","collapse":false,"className":""},{"id":"44d046383f6e170c","type":"ui_group","name":"Group 1","tab":"26c328d9fd99402b","order":1,"disp":true,"width":6},{"id":"26c328d9fd99402b","type":"ui_tab","name":"09 GUI-click","icon":"dashboard","order":3,"disabled":false,"hidden":false},{"id":"69ef5cd81fbe23c4","type":"ui_tab","name":"12 GUI-setValue","icon":"dashboard","order":5,"disabled":false,"hidden":false},{"id":"2b4a3bdb043675fd","type":"ui_group","name":"Group 1","tab":"69ef5cd81fbe23c4","order":1,"disp":true,"width":6},{"id":"51a7624fadecbb11","type":"ui_group","name":"Group 1","tab":"","order":1,"disp":true,"width":6},{"id":"785e79a6406a34f0","type":"ui_tab","name":"07 GUI-addValue 08-clearValue","icon":"dashboard","order":2,"disabled":false,"hidden":false},{"id":"2c037ff2393ce306","type":"ui_group","name":"Group 1","tab":"785e79a6406a34f0","order":1,"disp":true,"width":6},{"id":"d7a48474c86fb492","type":"ui_tab","name":"11 GUI-moveTo","icon":"dashboard","order":4,"disabled":false,"hidden":false},{"id":"a94a995999abb6ff","type":"ui_group","name":"Group 1","tab":"d7a48474c86fb492","order":1,"disp":true,"width":6},{"id":"3433732293b0efe6","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test1-1","method":"get","upload":false,"swaggerDoc":"","x":110,"y":100,"wires":[["89abec8dc8dcd928"]]},{"id":"9c703e8de2e3c532","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":470,"y":100,"wires":[]},{"id":"89abec8dc8dcd928","type":"template","z":"9b3db84fb21d2ae9","name":"Size: 1024x768","field":"payload","fieldType":"msg","format":"html","syntax":"plain","template":"<!DOCTYPE html>\n<html>\n\n<head>\n    <meta charset=\"utf-8\">\n    <title>01 GUI-URL TEST</title>\n</head>\n\n<body>\n    <h1>01 GUI-URL TEST1</h1>\n    <p>Size: 1024x768</p>\n    <p>test test test test test test test test test test test test test test test test test test test test test test test test\n    test test test test test test test test test test test test test test test test test test test test test test test test\n    test test test test test test test test test test test test test test test test test test test test test test test test\n    test test test test test test test test test test test test test test test</p>\n</body>\n\n</html>","output":"str","x":300,"y":100,"wires":[["9c703e8de2e3c532"]]},{"id":"4cbdf19859bd3673","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test1-2","method":"get","upload":false,"swaggerDoc":"","x":110,"y":160,"wires":[["a57d5145d9cc69f8"]]},{"id":"741bea42aff840bc","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":470,"y":160,"wires":[]},{"id":"a57d5145d9cc69f8","type":"template","z":"9b3db84fb21d2ae9","name":"Size: 800x600","field":"payload","fieldType":"msg","format":"html","syntax":"plain","template":"<!DOCTYPE html>\n<html>\n\n<head>\n    <meta charset=\"utf-8\">\n    <title>01 GUI-URL TEST</title>\n</head>\n\n<body>\n    <h1>01 GUI-URL TEST2</h1>\n    <p>Size: 800x600</p>\n    <p>test test test test test test test test test test test test test test test test test test test test test test test test\n    test test test test test test test test test test test test test test test test test test test test test test test test\n    test test test test test test test test test test test test test test test test test test test test test test test test\n    test test test test test test test test test test test test test test test</p>\n</body>\n\n</html>","output":"str","x":300,"y":160,"wires":[["741bea42aff840bc"]]},{"id":"3a204cb1e4e7e798","type":"ui_slider","z":"9b3db84fb21d2ae9","name":"","label":"slider","tooltip":"","group":"0779fd07b585202b","order":0,"width":0,"height":0,"passthru":true,"outs":"all","topic":"topic","topicType":"msg","min":0,"max":10,"step":1,"className":"","x":90,"y":260,"wires":[["3b1b52e7950d2d96"]]},{"id":"3b1b52e7950d2d96","type":"ui_gauge","z":"9b3db84fb21d2ae9","name":"","group":"0779fd07b585202b","order":1,"width":0,"height":0,"gtype":"gage","title":"gauge","label":"units","format":"{{value}}","min":0,"max":10,"colors":["#00b500","#e6e600","#ca3838"],"seg1":"","seg2":"","className":"","x":230,"y":260,"wires":[]},{"id":"01a33fd443f37a9d","type":"ui_button","z":"9b3db84fb21d2ae9","name":"","group":"44d046383f6e170c","order":1,"width":0,"height":0,"passthru":false,"label":"button","tooltip":"","color":"","bgcolor":"","className":"","icon":"","payload":"Button","payloadType":"str","topic":"topic","topicType":"msg","x":90,"y":1080,"wires":[["5a88bb5ee5f74048"]]},{"id":"ea2689d761c694d9","type":"ui_text","z":"9b3db84fb21d2ae9","group":"44d046383f6e170c","order":2,"width":0,"height":0,"name":"text","label":"","format":"{{msg.payload}}","layout":"row-center","className":"","x":490,"y":1080,"wires":[]},{"id":"5a88bb5ee5f74048","type":"function","z":"9b3db84fb21d2ae9","name":"","func":"if (msg.payload != \"\") {\n    msg.payload += \" was clicked.\"\n}\nreturn msg;","outputs":1,"noerr":0,"initialize":"","finalize":"","libs":[],"x":300,"y":1080,"wires":[["ea2689d761c694d9"]]},{"id":"3d80cb23855d1f23","type":"ui_text_input","z":"9b3db84fb21d2ae9","name":"","label":"","tooltip":"","group":"2b4a3bdb043675fd","order":1,"width":0,"height":0,"passthru":true,"mode":"text","delay":300,"topic":"topic","sendOnBlur":true,"className":"","topicType":"msg","x":100,"y":1520,"wires":[["fe3ad091b0d72fa6"]]},{"id":"fe3ad091b0d72fa6","type":"function","z":"9b3db84fb21d2ae9","name":"","func":"if (msg.payload != \"\") {\n    msg.payload += \" has been entered.\"\n}\nreturn msg;","outputs":1,"noerr":0,"initialize":"","finalize":"","libs":[],"x":300,"y":1520,"wires":[["a8b9279ac2b7bb34"]]},{"id":"a8b9279ac2b7bb34","type":"ui_text","z":"9b3db84fb21d2ae9","group":"2b4a3bdb043675fd","order":2,"width":0,"height":0,"name":"text","label":"","format":"{{msg.payload}}","layout":"row-center","className":"","x":510,"y":1520,"wires":[]},{"id":"df63e899f76ec37d","type":"comment","z":"9b3db84fb21d2ae9","name":"09 GUI-click","info":"","x":110,"y":1040,"wires":[]},{"id":"73b88c9ce8eb419b","type":"comment","z":"9b3db84fb21d2ae9","name":"12 GUI-setValue","info":"","x":120,"y":1480,"wires":[]},{"id":"e2cc4ae0d72b963b","type":"comment","z":"9b3db84fb21d2ae9","name":"02 GUI-Keys","info":"","x":110,"y":220,"wires":[]},{"id":"de20304a494f612c","type":"comment","z":"9b3db84fb21d2ae9","name":"01 GUI-URL","info":"","x":110,"y":40,"wires":[]},{"id":"46a0c697fa6f3aa9","type":"comment","z":"9b3db84fb21d2ae9","name":"03 GUI-saveScreenshot","info":"","x":140,"y":340,"wires":[]},{"id":"e53fcf4665e96479","type":"comment","z":"9b3db84fb21d2ae9","name":"04 GUI-setCookies","info":"","x":130,"y":460,"wires":[]},{"id":"1851347e41085efa","type":"comment","z":"9b3db84fb21d2ae9","name":"05 GUI-setTimeout","info":"タイムアウトしてもテストフローが停止しない。\n用途が不明","x":130,"y":580,"wires":[]},{"id":"2135f0ed4da03687","type":"comment","z":"9b3db84fb21d2ae9","name":"06 GUI-waitUntil","info":"","x":120,"y":760,"wires":[]},{"id":"ecbdd8f3f5d1a43f","type":"comment","z":"9b3db84fb21d2ae9","name":"07 GUI-addValue","info":"","x":120,"y":940,"wires":[]},{"id":"6b5edcefaf047657","type":"comment","z":"9b3db84fb21d2ae9","name":"08 GUI-clearValue","info":"","x":310,"y":940,"wires":[]},{"id":"252be38b87101a0c","type":"comment","z":"9b3db84fb21d2ae9","name":"10 GUI-getValue","info":"","x":120,"y":1140,"wires":[]},{"id":"d9631503adada096","type":"comment","z":"9b3db84fb21d2ae9","name":"11 GUI-moveTo","info":"","x":120,"y":1300,"wires":[]},{"id":"f96271d463f3d005","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test3","method":"get","upload":false,"swaggerDoc":"","x":100,"y":380,"wires":[["e9568cd8a3881f7a"]]},{"id":"3646275cbe45db61","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":550,"y":380,"wires":[]},{"id":"e9568cd8a3881f7a","type":"template","z":"9b3db84fb21d2ae9","name":"URL: http://localhost:1880/test3","field":"payload","fieldType":"msg","format":"html","syntax":"plain","template":"<!DOCTYPE html>\n<html>\n\n<head>\n    <meta charset=\"utf-8\">\n    <title>03 GUI-savaScreenshot TEST</title>\n</head>\n\n<body>\n    <h1>03 GUI-savaScreenshot TEST</h1>\n    <p>URL: http://localhost:1880/test3</p>\n</body>\n\n</html>","output":"str","x":330,"y":380,"wires":[["3646275cbe45db61"]]},{"id":"b15db00ea98ccdb8","type":"function","z":"9b3db84fb21d2ae9","name":"","func":"msg.payload = JSON.stringify(msg.req.cookies, null, 4);\nreturn msg;","outputs":1,"noerr":0,"initialize":"","finalize":"","libs":[],"x":260,"y":500,"wires":[["b2abfc59dfd6747f"]]},{"id":"da44efa0625b0c46","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test4","method":"get","upload":false,"swaggerDoc":"","x":100,"y":500,"wires":[["b15db00ea98ccdb8"]]},{"id":"b2abfc59dfd6747f","type":"template","z":"9b3db84fb21d2ae9","name":"Cookies","field":"payload","fieldType":"msg","format":"handlebars","syntax":"mustache","template":"<!DOCTYPE html>\n<head>\n    <meta charset=\"utf-8\">\n    <title>04 GUI-setCookies TEST</title>\n</head>\n<body>\n    <h1>04 GUI-setCookies TEST</h1>\n    <pre>{{ payload }}</pre>\n</body>\n</html>","output":"str","x":420,"y":500,"wires":[["c3c9bd6b22cdf5c4"]]},{"id":"c3c9bd6b22cdf5c4","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":580,"y":500,"wires":[]},{"id":"9ad3814da7eb0bf8","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test5-1","method":"get","upload":false,"swaggerDoc":"","x":110,"y":620,"wires":[["57489d4a6843ed06"]]},{"id":"e0e8d9808cbefc12","type":"template","z":"9b3db84fb21d2ae9","name":"wait page","field":"payload","fieldType":"msg","format":"html","syntax":"plain","template":"<!DOCTYPE html>\n\n<head>\n    <meta charset=\"utf-8\">\n    <title>05 GUI-setTimeout TEST</title>\n</head>\n\n<body>\n    <h1>05 GUI-setTimeout TEST1</h1>\n</body>\n\n</html>","output":"str","x":460,"y":620,"wires":[["273bd1c5fba89419"]]},{"id":"57489d4a6843ed06","type":"delay","z":"9b3db84fb21d2ae9","name":"","pauseType":"delay","timeout":"4","timeoutUnits":"seconds","rate":"1","nbRateUnits":"1","rateUnits":"second","randomFirst":"1","randomLast":"5","randomUnits":"seconds","drop":false,"allowrate":false,"outputs":1,"x":280,"y":620,"wires":[["e0e8d9808cbefc12"]]},{"id":"bf6dc3e2d4bba78a","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test5-2","method":"get","upload":false,"swaggerDoc":"","x":110,"y":680,"wires":[["08cab205b3caa944"]]},{"id":"08cab205b3caa944","type":"delay","z":"9b3db84fb21d2ae9","name":"depay 6s (time out)","pauseType":"delay","timeout":"6","timeoutUnits":"seconds","rate":"1","nbRateUnits":"1","rateUnits":"second","randomFirst":"1","randomLast":"5","randomUnits":"seconds","drop":false,"allowrate":false,"outputs":1,"x":310,"y":680,"wires":[["e0e8d9808cbefc12"]]},{"id":"2486e1ca0a98c73f","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test6-1","method":"get","upload":false,"swaggerDoc":"","x":110,"y":800,"wires":[["f79c8d74d708debb"]]},{"id":"71f6558f1dbc157d","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test6-2","method":"get","upload":false,"swaggerDoc":"","x":110,"y":860,"wires":[["c5143318646fb9fd"]]},{"id":"46fd6974c4ab4dd4","type":"template","z":"9b3db84fb21d2ae9","name":"wait text","field":"payload","fieldType":"msg","format":"handlebars","syntax":"mustache","template":"<!DOCTYPE html>\n\n<head>\n    <meta charset=\"utf-8\">\n    <title>06 GUI-waitUntil TEST</title>\n</head>\n\n<body>\n    <h1>06 GUI-waitUntil TEST</h1>\n    <p id=\"ID_TEXT\">Regular expression match test.</p></body>\n</html>\n\n<script>\nwindow.setTimeout(reWrite, {{ payload }});\nfunction reWrite()\n{\n  if (document.getElementById)\n  {\n      document.getElementById(\"ID_TEXT\").textContent=\"Test 06-GUI-waitUntil\";\n  }\n}\n</script>","output":"str","x":460,"y":800,"wires":[["6075415beb6878a0"]]},{"id":"6075415beb6878a0","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":610,"y":800,"wires":[]},{"id":"f79c8d74d708debb","type":"change","z":"9b3db84fb21d2ae9","name":"delay 9s","rules":[{"t":"set","p":"payload","pt":"msg","to":"9000","tot":"num"}],"action":"","property":"","from":"","to":"","reg":false,"x":280,"y":800,"wires":[["46fd6974c4ab4dd4"]]},{"id":"c5143318646fb9fd","type":"change","z":"9b3db84fb21d2ae9","name":"delay 11s (time out)","rules":[{"t":"set","p":"payload","pt":"msg","to":"10000","tot":"num"}],"action":"","property":"","from":"","to":"","reg":false,"x":310,"y":860,"wires":[["46fd6974c4ab4dd4"]]},{"id":"640d91fab434d070","type":"ui_text_input","z":"9b3db84fb21d2ae9","name":"","label":"","tooltip":"","group":"2c037ff2393ce306","order":0,"width":0,"height":0,"passthru":false,"mode":"text","delay":300,"topic":"topic","sendOnBlur":true,"className":"","topicType":"msg","x":100,"y":980,"wires":[["553dac4c5471d519"]]},{"id":"553dac4c5471d519","type":"debug","z":"9b3db84fb21d2ae9","name":"","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"payload","targetType":"msg","statusVal":"","statusType":"auto","x":290,"y":980,"wires":[]},{"id":"cb0a6d52972bcc02","type":"comment","z":"9b3db84fb21d2ae9","name":"99 TestEnd","info":"","x":100,"y":1600,"wires":[]},{"id":"193db0840f528392","type":"debug","z":"9b3db84fb21d2ae9","name":"","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"payload","targetType":"msg","statusVal":"","statusType":"auto","x":310,"y":1640,"wires":[]},{"id":"a009dbfb3c8dcba9","type":"inject","z":"9b3db84fb21d2ae9","name":"","props":[{"p":"payload"},{"p":"topic","vt":"str"}],"repeat":"","crontab":"","once":false,"onceDelay":0.1,"topic":"","payload":"","payloadType":"date","x":120,"y":1640,"wires":[["193db0840f528392"]]},{"id":"3d690e3169d2d483","type":"template","z":"9b3db84fb21d2ae9","name":"","field":"payload","fieldType":"msg","format":"handlebars","syntax":"mustache","template":"<!DOCTYPE html>\n<html>\n\n<head>\n    <meta charset=\"utf-8\">\n    <title>10 GUI-getValue TEST</title>\n</head>\n\n<body>\n    <h1 id=\"ID_TAG\">10 GUI-getValue TEST</h1>\n    <p id=\"ID_TEXT\">TEST-Text</p>\n    <div id=\"ID_ATTR\" attribute=\"TEST-Attribute\"></div>\n    <input type=\"text\" value=\"TEST-Value\" id=\"ID_VALUE\" />\n<body>\n\n</html>\n","output":"str","x":300,"y":1180,"wires":[["d7fe4424960b4eba"]]},{"id":"6717a5b7fb237bd1","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test10","method":"get","upload":false,"swaggerDoc":"","x":110,"y":1180,"wires":[["3d690e3169d2d483"]]},{"id":"d7fe4424960b4eba","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":490,"y":1180,"wires":[]},{"id":"29e3ad51752ad855","type":"inject","z":"9b3db84fb21d2ae9","name":"","props":[{"p":"payload"},{"p":"topic","vt":"str"}],"repeat":"","crontab":"","once":false,"onceDelay":0.1,"topic":"","payload":"","payloadType":"date","x":120,"y":1220,"wires":[["a4d57d3ae7aff215"]]},{"id":"bf0d97744cf36e4c","type":"debug","z":"9b3db84fb21d2ae9","name":"","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"payload","targetType":"msg","statusVal":"","statusType":"auto","x":510,"y":1220,"wires":[]},{"id":"b6aa9aef3d3647a3","type":"ui_button","z":"9b3db84fb21d2ae9","name":"","group":"a94a995999abb6ff","order":1,"width":0,"height":0,"passthru":false,"label":"Button 1","tooltip":"Button 1","color":"","bgcolor":"","className":"","icon":"","payload":"","payloadType":"str","topic":"topic","topicType":"msg","x":100,"y":1340,"wires":[[]]},{"id":"db5b2d254533ef8b","type":"ui_button","z":"9b3db84fb21d2ae9","name":"","group":"a94a995999abb6ff","order":2,"width":0,"height":0,"passthru":false,"label":"Button 2","tooltip":"Button 2","color":"","bgcolor":"","className":"","icon":"","payload":"","payloadType":"str","topic":"topic","topicType":"msg","x":100,"y":1380,"wires":[[]]},{"id":"46d010cd56ba8914","type":"ui_button","z":"9b3db84fb21d2ae9","name":"","group":"a94a995999abb6ff","order":3,"width":0,"height":0,"passthru":false,"label":"Button 3","tooltip":"Button 3","color":"","bgcolor":"","className":"","icon":"","payload":"","payloadType":"str","topic":"topic","topicType":"msg","x":100,"y":1420,"wires":[[]]},{"id":"a4d57d3ae7aff215","type":"change","z":"9b3db84fb21d2ae9","name":"","rules":[{"t":"set","p":"payload","pt":"msg","to":"$globalContext(\"tag\") & $globalContext(\"text\") & $globalContext(\"value\") & $flowContext(\"attribute\") &  $flowContext(\"property\")  \t","tot":"jsonata"}],"action":"","property":"","from":"","to":"","reg":false,"x":320,"y":1220,"wires":[["bf0d97744cf36e4c"]]},{"id":"f470657e71958b8f","type":"comment","z":"9b3db84fb21d2ae9","name":"Check the console log for the result.","info":"","x":580,"y":680,"wires":[]},{"id":"42419f5d347b6c64","type":"comment","z":"9b3db84fb21d2ae9","name":"Check the console log for the result.","info":"","x":580,"y":860,"wires":[]},{"id":"273bd1c5fba89419","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":620,"y":620,"wires":[]}]
\ No newline at end of file
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/package.json b/examples/node-red-contrib-flow-tester-gui-addon/package.json
deleted file mode 100644
index d18ea08..0000000
--- a/examples/node-red-contrib-flow-tester-gui-addon/package.json
+++ /dev/null
@@ -1,47 +0,0 @@
-{
-    "name": "node-red-contrib-flow-tester-gui-addon",
-    "version": "0.0.1",
-    "description": "A test plugin for flow tester gui addon",
-    "scripts": {
-        "build": "node scripts/build.js",
-        "dev": "nodemon --exec 'npm run build'  -i dist -i resources -e 'css js html'",
-        "test": "nyc mocha"
-    },
-    "keywords": [
-        "node-red",
-        "testing",
-        "dashboard",
-        "gui"
-    ],
-    "files": [
-        "dist",
-        "resources"
-    ],
-    "license": "Apache-2",
-    "node-red": {
-        "version": ">=2.0.0",
-        "plugins": {
-            "flow-tester-gui-addon": "dist/flow-tester-gui-addon.js"
-        }
-    },
-    "contributors": [
-        {
-            "name": "Kazuhiro Ito",
-            "email": "kazuhiro.ito.ek@hitachi-solutions.com"
-        }
-    ],
-    "devDependencies": {
-        "@wdio/cli": "^7.16.10",
-        "@wdio/local-runner": "^7.16.10",
-        "@wdio/mocha-framework": "^7.16.6",
-        "@wdio/spec-reporter": "^7.16.9",
-        "chromedriver": "^96.0.0",
-        "fs-extra": "^10.0.0",
-        "global-agent": "^3.0.0",
-        "html-minifier": "^4.0.0",
-        "mocha": "^8.4.0",
-        "nodemon": "^2.0.7",
-        "nyc": "^15.1.0",
-        "wdio-chromedriver-service": "^7.2.2"
-    }
-}
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/scripts/build.js b/examples/node-red-contrib-flow-tester-gui-addon/scripts/build.js
deleted file mode 100644
index 96c50bb..0000000
--- a/examples/node-red-contrib-flow-tester-gui-addon/scripts/build.js
+++ /dev/null
@@ -1,51 +0,0 @@
-const minify = require("html-minifier").minify;
-const fs = require("fs-extra");
-const path = require("path");
-
-
-const projectRoot = path.join(__dirname,"..")
-const resources = path.join(projectRoot,"resources");
-const dist = path.join(projectRoot,"dist");
-const src = path.join(projectRoot,"src");
-
-const assets = {}
-assets[dist] = [
-    "locales",
-    "flow-tester-gui-addon.html",
-    "flow-tester-gui-addon.js"
-]
-assets[resources] = [
-    "style.css"
-]
-
-async function copyStaticAssets(dist,assets) {
-    await fs.mkdir(dist,{recursive: true});
-    for (let i=0; i<assets.length; i++) {
-        if (/\.html/.test(assets[i])) {
-            const content = await fs.readFile(path.join(src,assets[i]),"utf-8")
-            await fs.writeFile(path.join(dist,assets[i]), minify(content, {minifyCSS: true, minifyJS: true}))
-        } else if (/\.js/.test(assets[i])) {
-            await fs.copy(path.join(src,assets[i]),path.join(dist,assets[i]))
-        } else if (/\.css/.test(assets[i])) {
-            const rawCSS = await fs.readFile(path.join(src,assets[i]),"utf-8");
-            const minifiedCSS = minify("<style>"+rawCSS+"</style>", {minifyCSS: true});
-            const finalCSS = minifiedCSS.substring(7,minifiedCSS.length-8)
-            await fs.writeFile(path.join(dist,assets[i]), finalCSS)
-        } else {
-            await fs.mkdir(path.join(dist,assets[i]), {recursive: true});
-            await fs.copy(path.join(src,assets[i]),path.join(dist,assets[i]))
-        }
-    }
-}
-
-
-
-(async function() {
-    const destinations = Object.keys(assets);
-    for (let i=0, l=destinations.length; i<l; i++) {
-        await copyStaticAssets(destinations[i],assets[destinations[i]]);
-    }
-})().catch(err => {
-    console.error(err);
-    process.exit(1);
-});
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.html b/examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.html
deleted file mode 100644
index 2d73dc7..0000000
--- a/examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.html
+++ /dev/null
@@ -1,1663 +0,0 @@
-// GUI test addon for flow tester action
-<link rel="stylesheet" href="resources/node-red-contrib-flow-tester-addon/style.css">
-
-<script type="text/javascript">
-(function() {
-    RED.plugins.registerPlugin("node-red-contrib--flow-tester-addon", {
-        type: "flow-tester-addon",
-        onadd: function() {
-        },
-        onremove: function() {
-        },
-        actions: function () {
-            return [
-                // plugin for GUI-URL
-                {
-                    name: "addon:GUI-URL",
-                    label: "GUI-URL",
-                    onAddItem: function (opt) {
-                        // opt contains:
-                        // - node: target node
-                        // - event: event name
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        // - data: initial data
-                        var node = opt.node;
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var data = opt.data;
-
-                        // row0: target
-                        var span0 = $("<span/>", {
-                            class: "addon-gui-url-span0"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row0);
-                        var targetField = $("<input/>", {
-                            placeholder: "browser instance name",
-                            type: "text",
-                            class: "addon-gui-url-target",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "8px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span0);
-                        if (data && data.target) {
-                            targetField.val(data.target);
-                        }
-
-                        // row1: url
-                        var row1 = $("<div/>", {
-                            class: "addon-gui-url-div1"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span1 = $("<span/>", {
-                            class: "addon-gui-url-span1"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row1);
-                        $("<label/>", {
-                        }).css({
-                           display: "inline-block",
-                           "text-align": "right",
-                           width: "100px"
-                        }).text("url").appendTo(span1);
-                        var urlField = $("<input/>", {
-                            placeholder: "http://<target page>",
-                            type: "text",
-                            class: "addon-gui-url-url",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span1);
-                        if (data && data.url) {
-                            urlField.val(data.url);
-                        }
-
-                        // row2: size(option)
-                        var row2 = $("<div/>", {
-                            class: "addon-gui-url-div2"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span2 = $("<span/>", {
-                            class: "addon-gui-url-span2"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row2);
-                        $("<label/>", {
-                        }).css({
-                           display: "inline-block",
-                           "text-align": "right",
-                           width: "100px"
-                        }).text("size").appendTo(span2);
-                        var sizeField = $("<input/>", {
-                            placeholder: "(option) width, height",
-                            type: "text",
-                            class: "addon-gui-url-size",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span2);
-                        if (data && data.size) {
-                            sizeField.val(data.size);
-                        }
-
-                        span0.hide();
-                        row1.hide();
-                        row2.hide();
-                        return true;
-                    },
-                    onSelect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-url-span0");
-                        var row1 = row0.find(".addon-gui-url-div1");
-                        var row2 = row0.find(".addon-gui-url-div2");
-                        span0.show();
-                        row1.show();
-                        row2.show();
-                    },
-                    onUnselect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-url-span0");
-                        var row1 = row0.find(".addon-gui-url-div1");
-                        var row2 = row0.find(".addon-gui-url-div2");
-                        span0.hide();
-                        row1.hide();
-                        row2.hide();
-                    },
-                    onSave: function (con) { 
-                        var target = con.find(".addon-gui-url-target").val();
-                        var url = con.find(".addon-gui-url-url").val();
-                        var size = con.find(".addon-gui-url-size").val();
-                        return {
-                            target: target,
-                            url: url,
-                            size: size,
-                            performCheck: false
-                        };
-                    }
-                },
-                // plugin for GUI-Keys
-                {
-                    name: "addon:GUI-Keys",
-                    label: "GUI-Keys",
-                    onAddItem: function (opt) {
-                        // opt contains:
-                        // - node: target node
-                        // - event: event name
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        // - data: initial data
-                        var node = opt.node;
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var data = opt.data;
-
-                        // row0: target
-                        var span0 = $("<span/>", {
-                            class: "addon-gui-keys-span0"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row0);
-                        var targetField = $("<input/>", {
-                            placeholder: "browser instance name",
-                            type: "text",
-                            class: "addon-gui-keys-target",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "8px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span0);
-                        if (data && data.target) {
-                            targetField.val(data.target);
-                        }
-
-                        // row1: key
-                        var row1 = $("<div/>", {
-                            class: "addon-gui-keys-div1"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span1 = $("<span/>", {
-                            class: "addon-gui-keys-span1"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row1);
-                        $("<label/>", {
-                        }).css({
-                           display: "inline-block",
-                           "text-align": "right",
-                           width: "100px"
-                        }).text("key").appendTo(span1);
-                        var keyField = $("<input/>", {
-                            placeholder: "key1, key2, key3, ...",
-                            type: "text",
-                            class: "addon-gui-keys-key",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span1);
-                        if (data && data.key) {
-                            keyField.val(data.key);
-                        }
-
-                        span0.hide();
-                        row1.hide();
-                        return true;
-                    },
-                    onSelect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-keys-span0");
-                        var row1 = row0.find(".addon-gui-keys-div1");
-                        span0.show();
-                        row1.show();
-                    },
-                    onUnselect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-keys-span0");
-                        var row1 = row0.find(".addon-gui-keys-div1");
-                        span0.hide();
-                        row1.hide();
-                    },
-                    onSave: function (con) { 
-                        var target = con.find(".addon-gui-keys-target").val();
-                        var key = con.find(".addon-gui-keys-key").val();
-                        return {
-                            target: target,
-                            key: key,
-                            performCheck: false
-                        };
-                    }
-                },
-                // plugin for GUI-saveScreenshot
-                {
-                    name: "addon:GUI-saveScreenshot",
-                    label: "GUI-saveScreenshot",
-                    onAddItem: function (opt) {
-                        // opt contains:
-                        // - node: target node
-                        // - event: event name
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        // - data: initial data
-                        var node = opt.node;
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var data = opt.data;
-
-                        // row0: target
-                        var span0 = $("<span/>", {
-                            class: "addon-gui-saveScreenshot-span0"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row0);
-                        var targetField = $("<input/>", {
-                            placeholder: "browser instance name",
-                            type: "text",
-                            class: "addon-gui-saveScreenshot-target",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "8px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span0);
-                        if (data && data.target) {
-                            targetField.val(data.target);
-                        }
-
-                        // row1: url(option)
-                        var row1 = $("<div/>", {
-                            class: "addon-gui-saveScreenshot-div1"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span1 = $("<span/>", {
-                            class: "addon-gui-saveScreenshot-span1"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row1);
-                        $("<label/>", {
-                        }).css({
-                           display: "inline-block",
-                           "text-align": "right",
-                           width: "100px"
-                        }).text("url").appendTo(span1);
-                        var urlField = $("<input/>", {
-                            placeholder: "(option) http://<target page>",
-                            type: "text",
-                            class: "addon-gui-saveScreenshot-url",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span1);
-                        if (data && data.url) {
-                            urlField.val(data.url);
-                        }
-
-                        // row2: filepath
-                        var row2 = $("<div/>", {
-                            class: "addon-gui-saveScreenshot-div2"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span2 = $("<span/>", {
-                            class: "addon-gui-saveScreenshot-span2"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row2);
-                        $("<label/>", {
-                        }).css({
-                            display: "inline-block",
-                            "text-align": "right",
-                            width: "100px"
-                        }).text("filepath").appendTo(span2);
-                        var filepathField = $("<input/>", {
-                            placeholder: "image file path (.png suffix is required)",
-                            type: "text",
-                            class: "addon-gui-saveScreenshot-filepath",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span2);
-                        if (data && data.filepath) {
-                            filepathField.val(data.filepath);
-                        }
-
-                        span0.hide();
-                        row1.hide();
-                        row2.hide();
-                        return true;
-                    },
-                    onSelect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-saveScreenshot-span0");
-                        var row1 = row0.find(".addon-gui-saveScreenshot-div1");
-                        var row2 = row0.find(".addon-gui-saveScreenshot-div2");
-                        span0.show();
-                        row1.show();
-                        row2.show();
-                    },
-                    onUnselect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-saveScreenshot-span0");
-                        var row1 = row0.find(".addon-gui-saveScreenshot-div1");
-                        var row2 = row0.find(".addon-gui-saveScreenshot-div2");
-                        span0.hide();
-                        row1.hide();
-                        row2.hide();
-                    },
-                    onSave: function (con) {
-                        var target = con.find(".addon-gui-saveScreenshot-target").val();
-                        var url = con.find(".addon-gui-saveScreenshot-url").val();
-                        var filepath = con.find(".addon-gui-saveScreenshot-filepath").val();
-                        return {
-                            target: target,
-                            url: url,
-                            filepath: filepath,
-                            performCheck: false
-                        };
-                    }
-                },
-                // plugin for GUI-setCookies
-                {
-                    name: "addon:GUI-setCookies",
-                    label: "GUI-setCookies",
-                    onAddItem: function (opt) {
-                        // opt contains:
-                        // - node: target node
-                        // - event: event name
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        // - data: initial data
-                        var node = opt.node;
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var data = opt.data;
-
-                        // row0: target
-                        var span0 = $("<span/>", {
-                            class: "addon-gui-setCookies-span0"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row0);
-                        var targetField = $("<input/>", {
-                            placeholder: "browser instance name",
-                            type: "text",
-                            class: "addon-gui-setCookies-target",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "8px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span0);
-                        if (data && data.target) {
-                            targetField.val(data.target);
-                        }
-
-                        // row1: cookie
-                        var row1 = $("<div/>", {
-                            class: "addon-gui-setCookies-div1"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span1 = $("<span/>", {
-                            class: "addon-gui-setCookies-span1"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row1);
-                        $("<label/>", {
-                        }).css({
-                           display: "inline-block",
-                           "text-align": "right",
-                           width: "100px"
-                        }).text("cookie").appendTo(span1);
-                        var cookieField = $("<input/>", {
-                            placeholder: "cookies settings",
-                            class: "addon-gui-setCookies-cookie",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span1);
-                        $(cookieField).typedInput({
-                            default: "json",
-                            types: [
-                                "json"
-                            ]
-                        });
-                        if (data && data.cookie) {
-                            $(cookieField).typedInput("value", data.cookie);
-                        }
-
-                        span0.hide();
-                        row1.hide();
-                        return true;
-                    },
-                    onSelect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-setCookies-span0");
-                        var row1 = row0.find(".addon-gui-setCookies-div1");
-                        span0.show();
-                        row1.show();
-                    },
-                    onUnselect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-setCookies-span0");
-                        var row1 = row0.find(".addon-gui-setCookies-div1");
-                        span0.hide();
-                        row1.hide();
-                    },
-                    onSave: function (con) {
-                        var target = con.find(".addon-gui-setCookies-target").val();
-                        var cookie = con.find(".addon-gui-setCookies-cookie").typedInput("value");
-                        return {
-                            target: target,
-                            cookie : cookie,
-                            performCheck: false
-                        };
-                    }
-                },
-                // plugin for GUI-setTimeout
-                {
-                    name: "addon:GUI-setTimeout",
-                    label: "GUI-setTimeout",
-                    onAddItem: function (opt) {
-                        // opt contains:
-                        // - node: target node
-                        // - event: event name
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        // - data: initial data
-                        var node = opt.node;
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var data = opt.data;
-
-                        // row0: target
-                        var span0 = $("<span/>", {
-                            class: "addon-gui-setTimeout-span0"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row0);
-                        var targetField = $("<input/>", {
-                            placeholder: "browser instance name",
-                            type: "text",
-                            class: "addon-gui-setTimeout-target",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "8px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span0);
-                        if (data && data.target) {
-                            targetField.val(data.target);
-                        }
-
-                        // row1: timeout
-                        var row1 = $("<div/>", {
-                            class: "addon-gui-setTimeout-div1"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span1 = $("<span/>", {
-                            class: "addon-gui-setTimeout-span1"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row1);
-                        $("<label/>", {
-                        }).css({
-                           display: "inline-block",
-                           "text-align": "right",
-                           width: "100px"
-                        }).text("timeout").appendTo(span1);
-                        var timeoutField = $("<input/>", {
-                            placeholder: "timeouts settings",
-                            class: "addon-gui-setTimeout-timeout",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span1);
-                        $(timeoutField).typedInput({
-                            default: "json",
-                            types: [
-                                "json"
-                            ]
-                        });
-                        if (data && data.timeout) {
-                            $(timeoutField).typedInput("value", data.timeout);
-                        }
-
-                        span0.hide();
-                        row1.hide();
-                        return true;
-                    },
-                    onSelect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-setTimeout-span0");
-                        var row1 = row0.find(".addon-gui-setTimeout-div1");
-                        span0.show();
-                        row1.show();
-                    },
-                    onUnselect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-setTimeout-span0");
-                        var row1 = row0.find(".addon-gui-setTimeout-div1");
-                        span0.hide();
-                        row1.hide();
-                    },
-                    onSave: function (con) {
-                        var target = con.find(".addon-gui-setTimeout-target").val();
-                        var timeout = con.find(".addon-gui-setTimeout-timeout").typedInput("value");
-                        return {
-                            target: target,
-                            timeout: timeout,
-                            performCheck: false
-                        };
-                    }
-                },
-                // plugin for GUI-waitUntil
-                {
-                    name: "addon:GUI-waitUntil",
-                    label: "GUI-waitUntil",
-                    onAddItem: function (opt) {
-                        // opt contains:
-                        // - node: target node
-                        // - event: event name
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        // - data: initial data
-                        var node = opt.node;
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var data = opt.data;
-
-                        // row0: target
-                        var span0 = $("<span/>", {
-                            class: "addon-gui-waitUntil-span0"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row0);
-                        var targetField = $("<input/>", {
-                            placeholder: "browser instance name",
-                            type: "text",
-                            class: "addon-gui-waitUntil-target",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "8px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span0);
-                        if (data && data.target) {
-                            targetField.val(data.target);
-                        }
-
-                        // row1: selector
-                        var row1 = $("<div/>", {
-                            class: "addon-gui-waitUntil-div1"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span1 = $("<span/>", {
-                            class: "addon-gui-waitUntil-span1"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row1);
-                        $("<label/>", {
-                        }).css({
-                           display: "inline-block",
-                           "text-align": "right",
-                           width: "100px"
-                        }).text("selector").appendTo(span1);
-                        var selectorField = $("<input/>", {
-                            placeholder: "element selector",
-                            type: "text",
-                            class: "addon-gui-waitUntil-selector",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span1);
-                        if (data && data.selector) {
-                            selectorField.val(data.selector);
-                        }
-
-                        // row2: value
-                        var row2 = $("<div/>", {
-                            class: "addon-gui-waitUntil-div2"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span2 = $("<span/>", {
-                            class: "addon-gui-waitUntil-span2"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row2);
-                        $("<label/>", {
-                        }).css({
-                           display: "inline-block",
-                           "text-align": "right",
-                           width: "100px"
-                        }).text("value").appendTo(span2);
-                        var valueField = $("<input/>", {
-                            placeholder: "element value or regexp",
-                            type: "text",
-                            class: "addon-gui-waitUntil-value",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span2);
-                        $(valueField).typedInput({
-                            default: "str",
-                            types: [
-                                "str","re"
-                            ]
-                        });
-                        if (data && data.value && data.type) {
-                            $(valueField).typedInput("value", data.value);
-                            $(valueField).typedInput("type", data.type);
-                        }
-
-                        // row3: timeout
-                        var row3 = $("<div/>", {
-                            class: "addon-gui-waitUntil-div3"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span3 = $("<span/>", {
-                            class: "addon-gui-waitUntil-span3"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row3);
-                        $("<label/>", {
-                        }).css({
-                           display: "inline-block",
-                           "text-align": "right",
-                           width: "100px"
-                        }).text("timeout").appendTo(span3);
-                        var timeoutField = $("<input/>", {
-                            //placeholder: "",
-                            type: "text",
-                            class: "addon-gui-waitUntil-timeout"
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "105pt"
-                        }).appendTo(span3);
-                        $(timeoutField).typedInput({
-                            default: "num",
-                            types: [
-                                "num"
-                            ]
-                        });
-                        $("<label/>", {
-                        }).css({
-                            "text-align": "left",
-                            width: "100px",
-                            "margin-left": "5px"
-                        }).text("ms").appendTo(span3);
-
-                        if (data && data.timeout) {
-                            $(timeoutField).typedInput("value", data.timeout);
-                        } else {
-                            $(timeoutField).typedInput("value", 5000);
-                        }
-
-                        span0.hide();
-                        row1.hide();
-                        row2.hide();
-                        row3.hide();
-                        return true;
-                    },
-                    onSelect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-waitUntil-span0");
-                        var row1 = row0.find(".addon-gui-waitUntil-div1");
-                        var row2 = row0.find(".addon-gui-waitUntil-div2");
-                        var row3 = row0.find(".addon-gui-waitUntil-div3");
-                        span0.show();
-                        row1.show();
-                        row2.show();
-                        row3.show();
-                    },
-                    onUnselect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-waitUntil-span0");
-                        var row1 = row0.find(".addon-gui-waitUntil-div1");
-                        var row2 = row0.find(".addon-gui-waitUntil-div2");
-                        var row3 = row0.find(".addon-gui-waitUntil-div3");
-                        span0.hide();
-                        row1.hide();
-                        row2.hide();
-                        row3.hide();
-                    },
-                    onSave: function (con) {
-                        var target = con.find(".addon-gui-waitUntil-target").val();
-                        var selector = con.find(".addon-gui-waitUntil-selector").val();
-                        var type = con.find(".addon-gui-waitUntil-value").typedInput("type");
-                        var value = con.find(".addon-gui-waitUntil-value").typedInput("value");
-                        var timeout = con.find(".addon-gui-waitUntil-timeout").typedInput("value");
-                        return {
-                            target: target,
-                            selector: selector,
-                            type: type,
-                            value: value,
-                            timeout: timeout,
-                            performCheck: false
-                        };
-                    }
-                },
-                // plugin for GUI-addValue
-                {
-                    name: "addon:GUI-addValue",
-                    label: "GUI-addValue",
-                    onAddItem: function (opt) {
-                        // opt contains:
-                        // - node: target node
-                        // - event: event name
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        // - data: initial data
-                        var node = opt.node;
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var data = opt.data;
-
-                        // row0: target
-                        var span0 = $("<span/>", {
-                            class: "addon-gui-addValue-span0"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row0);
-                        var targetField = $("<input/>", {
-                            placeholder: "browser instance name",
-                            type: "text",
-                            class: "addon-gui-addValue-target",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "8px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span0);
-                        if (data && data.target) {
-                            targetField.val(data.target);
-                        }
-
-                        // row1: selector
-                        var row1 = $("<div/>", {
-                            class: "addon-gui-addValue-div1"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span1 = $("<span/>", {
-                            class: "addon-gui-addValue-span1"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row1);
-                        $("<label/>", {
-                        }).css({
-                           display: "inline-block",
-                           "text-align": "right",
-                           width: "100px"
-                        }).text("selector").appendTo(span1);
-                        var selectorField = $("<input/>", {
-                            placeholder: "element selector",
-                            type: "text",
-                            class: "addon-gui-addValue-selector",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span1);
-                        if (data && data.selector) {
-                            selectorField.val(data.selector);
-                        }
-
-                        // row2: value
-                        var row2 = $("<div/>", {
-                            class: "addon-gui-addValue-div2"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span2 = $("<span/>", {
-                            class: "addon-gui-addValue-span2"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row2);
-                        $("<label/>", {
-                        }).css({
-                            display: "inline-block",
-                            "text-align": "right",
-                            width: "100px"
-                        }).text("value").appendTo(span2);
-                        var valueField = $("<input/>", {
-                            placeholder: "value to add",
-                            type: "text",
-                            class: "addon-gui-addValue-value",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span2);
-                        $(valueField).typedInput({
-                            default: "str",
-                            types: [
-                                "str", "num", "bool"
-                            ]
-                        });
-                        if (data && data.value) {
-                            $(valueField).typedInput("value", data.value);
-                        }
-
-                        span0.hide();
-                        row1.hide();
-                        row2.hide();
-                        return true;
-                    },
-                    onSelect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-addValue-span0");
-                        var row1 = row0.find(".addon-gui-addValue-div1");
-                        var row2 = row0.find(".addon-gui-addValue-div2");
-                        span0.show();
-                        row1.show();
-                        row2.show();
-                    },
-                    onUnselect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-addValue-span0");
-                        var row1 = row0.find(".addon-gui-addValue-div1");
-                        var row2 = row0.find(".addon-gui-addValue-div2");
-                        span0.hide();
-                        row1.hide();
-                        row2.hide();
-                    },
-                    onSave: function (con) {
-                        var target = con.find(".addon-gui-addValue-target").val();
-                        var selector = con.find(".addon-gui-addValue-selector").val();
-                        var value = con.find(".addon-gui-addValue-value").typedInput("value");
-                        return {
-                            target: target,
-                            selector: selector,
-                            value: value,
-                            performCheck: false
-                        };
-                    }
-                },
-                // plugin for GUI-clearValue
-                {
-                    name: "addon:GUI-clearValue",
-                    label: "GUI-clearValue",
-                    onAddItem: function (opt) {
-                        // opt contains:
-                        // - node: target node
-                        // - event: event name
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        // - data: initial data
-                        var node = opt.node;
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var data = opt.data;
-
-                        // row0: target
-                        var span0 = $("<span/>", {
-                            class: "addon-gui-clearValue-span0"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row0);
-                        var targetField = $("<input/>", {
-                            placeholder: "browser instance name",
-                            type: "text",
-                            class: "addon-gui-clearValue-target",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "8px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span0);
-                        if (data && data.target) {
-                            targetField.val(data.target);
-                        }
-
-                        // row1: selector
-                        var row1 = $("<div/>", {
-                            class: "addon-gui-clearValue-div1"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span1 = $("<span/>", {
-                            class: "addon-gui-clearValue-span1"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row1);
-                        $("<label/>", {
-                        }).css({
-                           display: "inline-block",
-                           "text-align": "right",
-                           width: "100px"
-                        }).text("selector").appendTo(span1);
-                        var selectorField = $("<input/>", {
-                            placeholder: "element selector",
-                            type: "text",
-                            class: "addon-gui-clearValue-selector",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span1);
-                        if (data && data.selector) {
-                            selectorField.val(data.selector);
-                        }
-
-                        span0.hide();
-                        row1.hide();
-                        return true;
-                    },
-                    onSelect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-clearValue-span0");
-                        var row1 = row0.find(".addon-gui-clearValue-div1");
-                        span0.show();
-                        row1.show();
-                    },
-                    onUnselect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-clearValue-span0");
-                        var row1 = row0.find(".addon-gui-clearValue-div1");
-                        span0.hide();
-                        row1.hide();
-                    },
-                    onSave: function (con) {
-                        var target = con.find(".addon-gui-clearValue-target").val();
-                        var selector = con.find(".addon-gui-clearValue-selector").val();
-                        return {
-                            target: target,
-                            selector: selector,
-                            performCheck: false
-                        };
-                    }
-                },
-                // plugin for GUI-click
-                {
-                    name: "addon:GUI-click",
-                    label: "GUI-click",
-                    onAddItem: function (opt) {
-                        // opt contains:
-                        // - node: target node
-                        // - event: event name
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        // - data: initial data
-                        var node = opt.node;
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var data = opt.data;
-
-                        // row0: target
-                        var span0 = $("<span/>", {
-                            class: "addon-gui-click-span0"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row0);
-                        var targetField = $("<input/>", {
-                            placeholder: "browser instance name",
-                            type: "text",
-                            class: "addon-gui-click-target",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "8px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span0);
-                        if (data && data.target) {
-                            targetField.val(data.target);
-                        }
-
-                        // row1: selector
-                        var row1 = $("<div/>", {
-                            class: "addon-gui-click-div1"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span1 = $("<span/>", {
-                            class: "addon-gui-click-span1"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row1);
-                        $("<label/>", {
-                        }).css({
-                           display: "inline-block",
-                           "text-align": "right",
-                           width: "100px"
-                        }).text("selector").appendTo(span1);
-                        var selectorField = $("<input/>", {
-                            placeholder: "element selector",
-                            type: "text",
-                            class: "addon-gui-click-selector",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span1);
-                        if (data && data.selector) {
-                            selectorField.val(data.selector);
-                        }
-
-                        // row2: kind
-                        var row2 = $("<div/>", {
-                            class: "addon-gui-click-div2"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span2 = $("<span/>", {
-                            class: "addon-gui-click-span2"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row2);
-                        $("<label/>", {
-                        }).css({
-                           display: "inline-block",
-                           "text-align": "right",
-                           width: "100px"
-                        }).text("kind").appendTo(span2);
-                        var kindField = $("<select/>", {
-                            placeholder: "value",
-                            type: "text",
-                            class: "addon-gui-click-kind",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "100pt"
-                        }).appendTo(span2);
-                        $(kindField).empty();
-                        $("<option/>").text("click").val("single").appendTo(kindField);
-                        $("<option/>").text("double click").val("double").appendTo(kindField);
-                        if (data && data.clickkind) {
-                            $(kindField).val(data.clickkind);
-                        }
-
-                        span0.hide();
-                        row1.hide();
-                        row2.hide();
-                        return true;
-                    },
-                    onSelect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-click-span0");
-                        var row1 = row0.find(".addon-gui-click-div1");
-                        var row2 = row0.find(".addon-gui-click-div2");
-                        span0.show();
-                        row1.show();
-                        row2.show();
-                    },
-                    onUnselect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-click-span0");
-                        var row1 = row0.find(".addon-gui-click-div1");
-                        var row2 = row0.find(".addon-gui-click-div2");
-                        span0.hide();
-                        row1.hide();
-                        row2.hide();
-                    },
-                    onSave: function (con) {
-                        var target = con.find(".addon-gui-click-target").val();
-                        var selector = con.find(".addon-gui-click-selector").val();
-                        var clickkind = con.find(".addon-gui-click-kind").val();
-                        return {
-                            target: target,
-                            selector: selector,
-                            clickkind: clickkind,
-                            performCheck: false
-                        };
-                    }
-                },
-                // plugin for GUI-getValue
-                {
-                    name: "addon:GUI-getValue",
-                    label: "GUI-getValue",
-                    onAddItem: function (opt) {
-                        // opt contains:
-                        // - node: target node
-                        // - event: event name
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        // - data: initial data
-                        var node = opt.node;
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var data = opt.data;
-
-                        // row0: target
-                        var span0 = $("<span/>", {
-                            class: "addon-gui-getValue-span0"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row0);
-                        var targetField = $("<input/>", {
-                            placeholder: "browser instance name",
-                            type: "text",
-                            class: "addon-gui-getValue-target",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "8px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span0);
-                        if (data && data.target) {
-                            targetField.val(data.target);
-                        }
-
-                        // row1: selector
-                        var row1 = $("<div/>", {
-                            class: "addon-gui-getValue-div1"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span1 = $("<span/>", {
-                            class: "addon-gui-getValue-span1"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row1);
-                        $("<label/>", {
-                        }).css({
-                           display: "inline-block",
-                           "text-align": "right",
-                           width: "100px"
-                        }).text("selector").appendTo(span1);
-                        var selectorField = $("<input/>", {
-                            placeholder: "element selector",
-                            type: "text",
-                            class: "addon-gui-getValue-selector",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span1);
-                        if (data && data.selector) {
-                            selectorField.val(data.selector);
-                        }
-
-                        // row2: kind
-                        var row2 = $("<div/>", {
-                            class: "addon-gui-getValue-div2"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span2 = $("<span/>", {
-                            class: "addon-gui-getValue-span2"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row2);
-                        $("<label/>", {
-                        }).css({
-                            display: "inline-block",
-                            "text-align": "right",
-                            width: "100px"
-                        }).text("kind").appendTo(span2);
-                        var kindField = $("<select/>", {
-                            placeholder: "value",
-                            type: "text",
-                            class: "addon-gui-getValue-kind",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "100pt"
-                        }).appendTo(span2);
-                        $(kindField).empty();
-                        $("<option/>").text("attribute").val("attr").appendTo(kindField);
-                        $("<option/>").text("property").val("prop").appendTo(kindField);
-                        $("<option/>").text("tag").val("tag").appendTo(kindField);
-                        $("<option/>").text("text").val("text").appendTo(kindField);
-                        $("<option/>").text("value").val("val").appendTo(kindField);
-                        if (data && data.getkind) {
-                            $(kindField).val(data.getkind);
-                        }
-
-                        // row3: name(option prop or attr)
-                        var row3 = $("<div/>", {
-                            class: "addon-gui-getValue-div3"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span3 = $("<span/>", {
-                            class: "addon-gui-getValue-span3"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row3);
-                        $("<label/>", {
-                        }).css({
-                            display: "inline-block",
-                            "text-align": "right",
-                            width: "100px"
-                        }).text("name").appendTo(span3);
-                        var getnameField = $("<input/>", {
-                            placeholder: "name for properties or attributes",
-                            type: "text",
-                            class: "addon-gui-getValue-name",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span3);
-                        if (data && data.getname) {
-                            getnameField.val(data.getname);
-                        }
-
-                        // row4: loc
-                        var row4 = $("<div/>", {
-                            class: "addon-gui-getValue-div4"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span4 = $("<span/>", {
-                            class: "addon-gui-getValue-span4"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row4);
-                        $("<label/>", {
-                        }).css({
-                            display: "inline-block",
-                            "text-align": "right",
-                            width: "100px"
-                        }).text("loc").appendTo(span4);
-                        var locField = $("<input/>", {
-                            placeholder: "store value name",
-                            class: "addon-gui-getValue-loc"
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span4);
-                        $(locField).typedInput({
-                            default: "flow",
-                            types: [
-                                "flow", "global"
-                            ]
-                        });
-                        if (data && data.type && data.value) {
-                            $(locField).typedInput("type", data.type);
-                            $(locField).typedInput("value", data.value);
-                        }
-
-                        span0.hide();
-                        row1.hide();
-                        row2.hide();
-                        row3.hide();
-                        row4.hide();
-                        return true;
-                    },
-                    onSelect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-getValue-span0");
-                        var row1 = row0.find(".addon-gui-getValue-div1");
-                        var row2 = row0.find(".addon-gui-getValue-div2");
-                        var row3 = row0.find(".addon-gui-getValue-div3");
-                        var row4 = row0.find(".addon-gui-getValue-div4");
-                        span0.show();
-                        row1.show();
-                        row2.show();
-                        row3.show();
-                        row4.show();
-                    },
-                    onUnselect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-getValue-span0");
-                        var row1 = row0.find(".addon-gui-getValue-div1");
-                        var row2 = row0.find(".addon-gui-getValue-div2");
-                        var row3 = row0.find(".addon-gui-getValue-div3");
-                        var row4 = row0.find(".addon-gui-getValue-div4");
-                        span0.hide();
-                        row1.hide();
-                        row2.hide();
-                        row3.hide();
-                        row4.hide();
-                    },
-                    onSave: function (con) {
-                        var target = con.find(".addon-gui-getValue-target").val();
-                        var selector = con.find(".addon-gui-getValue-selector").val();
-                        var getkind = con.find(".addon-gui-getValue-kind").val();
-                        var getname = con.find(".addon-gui-getValue-name").val();
-                        var type = con.find(".addon-gui-getValue-loc").typedInput("type");
-                        var value = con.find(".addon-gui-getValue-loc").typedInput("value");
-                        return {
-                            target: target,
-                            selector: selector,
-                            getkind: getkind,
-                            getname: getname,
-                            type: type,
-                            value: value,
-                            performCheck: false
-                        };
-                    }
-                },
-                // plugin for GUI-moveTo
-                {
-                    name: "addon:GUI-moveTo",
-                    label: "GUI-moveTo",
-                    onAddItem: function (opt) {
-                        // opt contains:
-                        // - node: target node
-                        // - event: event name
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        // - data: initial data
-                        var node = opt.node;
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var data = opt.data;
-
-                        // row0: target
-                        var span0 = $("<span/>", {
-                            class: "addon-gui-moveTo-span0"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row0);
-                        var targetField = $("<input/>", {
-                            placeholder: "browser instance name",
-                            type: "text",
-                            class: "addon-gui-moveTo-target",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "8px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span0);
-                        if (data && data.target) {
-                            targetField.val(data.target);
-                        }
-
-                        // row1: selector
-                        var row1 = $("<div/>", {
-                            class: "addon-gui-moveTo-div1"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span1 = $("<span/>", {
-                            class: "addon-gui-moveTo-span1"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row1);
-                        $("<label/>", {
-                        }).css({
-                           display: "inline-block",
-                           "text-align": "right",
-                           width: "100px"
-                        }).text("selector").appendTo(span1);
-                        var selectorField = $("<input/>", {
-                            placeholder: "element selector",
-                            type: "text",
-                            class: "addon-gui-moveTo-selector",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span1);
-                        if (data && data.selector) {
-                            selectorField.val(data.selector);
-                        }
-
-                        span0.hide();
-                        row1.hide();
-                        return true;
-                    },
-                    onSelect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-moveTo-span0");
-                        var row1 = row0.find(".addon-gui-moveTo-div1");
-                        span0.show();
-                        row1.show();
-                    },
-                    onUnselect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-moveTo-span0");
-                        var row1 = row0.find(".addon-gui-moveTo-div1");
-                        span0.hide();
-                        row1.hide();
-                    },
-                    onSave: function (con) {
-                        var target = con.find(".addon-gui-moveTo-target").val();
-                        var selector = con.find(".addon-gui-moveTo-selector").val();
-                        return {
-                            target: target,
-                            selector: selector,
-                            performCheck: false
-                        };
-                    }
-                },
-                // plugin for GUI-setValue
-                {
-                    name: "addon:GUI-setValue",
-                    label: "GUI-setValue",
-                    onAddItem: function (opt) {
-                        // opt contains:
-                        // - node: target node
-                        // - event: event name
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        // - data: initial data
-                        var node = opt.node;
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var data = opt.data;
-
-                        // row0: target
-                        var span0 = $("<span/>", {
-                            class: "addon-gui-setValue-span0"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row0);
-                        var targetField = $("<input/>", {
-                            placeholder: "browser instance name",
-                            type: "text",
-                            class: "addon-gui-setValue-target",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "8px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span0);
-                        if (data && data.target) {
-                            targetField.val(data.target);
-                        }
-
-                        // row1: selector
-                        var row1 = $("<div/>", {
-                            class: "addon-gui-setValue-div1"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span1 = $("<span/>", {
-                            class: "addon-gui-setValue-span1"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row1);
-                        $("<label/>", {
-                        }).css({
-                           display: "inline-block",
-                           "text-align": "right",
-                           width: "100px"
-                        }).text("selector").appendTo(span1);
-                        var selectorField = $("<input/>", {
-                            placeholder: "element selector",
-                            type: "text",
-                            class: "addon-gui-setValue-selector",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span1);
-                        if (data && data.selector) {
-                            selectorField.val(data.selector);
-                        }
-
-                        // row2: value
-                        var row2 = $("<div/>", {
-                            class: "addon-gui-setValue-div2"
-                        }).css({
-                            "margin-top": "11px"
-                        }).appendTo(row0);
-                        var span2 = $("<span/>", {
-                            class: "addon-gui-setValue-span2"
-                        }).css({
-                            "margin-left": "5px"
-                        }).appendTo(row2);
-                        $("<label/>", {
-                        }).css({
-                            display: "inline-block",
-                            "text-align": "right",
-                            width: "100px"
-                        }).text("value").appendTo(span2);
-                        var valueField = $("<input/>", {
-                            placeholder: "value to set",
-                            type: "text",
-                            class: "addon-gui-setValue-value",
-                        }).css({
-                            display: "inline-block",
-                            "margin-left": "13px",
-                            width: "calc(100% - 130px)"
-                        }).appendTo(span2);
-                        $(valueField).typedInput({
-                            default: "str",
-                            types: [
-                                "str", "num", "bool"
-                            ]
-                        });
-                        if (data && data.value) {
-                            $(valueField).typedInput("value", data.value);
-                        }
-
-                        span0.hide();
-                        row1.hide();
-                        row2.hide();
-                        return true;
-                    },
-                    onSelect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-setValue-span0");
-                        var row1 = row0.find(".addon-gui-setValue-div1");
-                        var row2 = row0.find(".addon-gui-setValue-div2");
-                        span0.show();
-                        row1.show();
-                        row2.show();
-                    },
-                    onUnselect: function (opt) {
-                        // opt contains:
-                        // - container: container of editable list,
-                        // - selectRow: first row of the container
-                        var con = opt.container;
-                        var row0 = opt.selectRow;
-                        var span0 = row0.find(".addon-gui-setValue-span0");
-                        var row1 = row0.find(".addon-gui-setValue-div1");
-                        var row2 = row0.find(".addon-gui-setValue-div2");
-                        span0.hide();
-                        row1.hide();
-                        row2.hide();
-                    },
-                    onSave: function (con) {
-                        var target = con.find(".addon-gui-setValue-target").val();
-                        var selector = con.find(".addon-gui-setValue-selector").val();
-                        var value = con.find(".addon-gui-setValue-value").typedInput("value");
-                        return {
-                            target: target,
-                            selector: selector,
-                            value: value,
-                            performCheck: false
-                        };
-                    }
-                }
-            ];
-        }
-    });
-})();
-</script>
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.js b/examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.js
deleted file mode 100644
index faac1ad..0000000
--- a/examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.js
+++ /dev/null
@@ -1,617 +0,0 @@
-module.exports = (RED) => {
-    "use strict";
-
-    // WebDriver object
-    const { remote } = require('webdriverio');
-    const promisify = require("util").promisify;
-
-
-    // Browser instance
-    var browser_instances = [];
-
-    // Get a browser instance
-    async function getBrowser(target) {
-        let key = "_default";
-        if (target) {
-            key = target;
-        } 
-        let browser = browser_instances[key] || null;
-        if (!browser) {
-            browser = await remote({
-                capabilities: {
-                    browserName: 'chrome'
-                }
-            })
-            browser_instances[key] = browser;
-        }
-        return browser; 
-    }
-
-    async function testClose(){ 
-        for (let key in browser_instances) {
-            let browser = browser_instances[key];
-            await browser.deleteSession();
-            delete browser_instances[key];
-        }
-    }
-
-    function testClear(){ 
-        for (let key in browser_instances) {
-            delete browser_instances[key];
-        }
-    }
-
-    console.log("; Initialize flow tester gui addon");
-    RED.plugins.registerPlugin('node-red-flow-tester-gui-addon', {
-        type: "flow-tester-addon",
-        actions: function () {
-            return [
-                {
-                    name: "addon:GUI-URL",
-                    onTestStart: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            testClear();
-                            resolve();
-                        });
-                    },
-                    onTestEnd: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            // Close all browser instances after test
-                            ;(async () => {
-                                try {
-                                    await testClose();
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    resolve();
-                                    //reject(err.message);
-                                }
-                            })()
-                        })
-                    },
-                    execute: function(opt) {
-                        // opt object contains:
-                        // - data: optional data for action
-                        // - node: target node
-                        // - msg: message object
-                        return new Promise((resolve, reject) => {
-                            const action = opt.action;
-                            // Perform an operation on an object with the specified instance name
-                            (async () => {
-                                try {
-                                    const browser = await getBrowser(action.target);
-                                    if (action.size) {
-                                        const size = action.size.split(',');
-                                        await browser.setWindowSize(Number(size[0]),Number(size[1]));
-                                    }
-                                    await browser.url(action.url);
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    reject(err.message);
-                                }
-                            })()
-                        });
-                    },
-                },
-                {
-                    name: "addon:GUI-Keys",
-                    onTestStart: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            testClear();
-                            resolve();
-                        });
-                    },
-                    onTestEnd: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            (async () => {
-                                try {
-                                    await testClose();
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    resolve();
-                                }
-                            })()
-                        });
-                    },
-                    execute: function(opt) {
-                        // opt object contains:
-                        // - data: optional data for action
-                        // - node: target node
-                        // - msg: message object
-                        return new Promise((resolve, reject) => {
-                            const action = opt.action;
-                            (async () => {
-                                try {
-                                    const browser = await getBrowser(action.target);
-                                    if (action.key) {
-                                        const keys = action.key.split(',');
-                                        await browser.keys(keys);
-                                    }
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    reject(err.message);
-                                }
-                            })()
-                        });
-                    }
-                },
-                {
-                    name: "addon:GUI-saveScreenshot",
-                    onTestStart: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            testClear();
-                            resolve();
-                        });
-                    },
-                    onTestEnd: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            (async () => {
-                                try {
-                                    await testClose();
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    resolve();
-                                }
-                            })()
-                        });
-                    },
-                    execute: function(opt) {
-                        // opt object contains:
-                        // - data: optional data for action
-                        // - node: target node
-                        // - msg: message object
-                        return new Promise((resolve, reject) => {
-                            const action = opt.action;
-                            (async () => {
-                                try {
-                                    const browser = await getBrowser(action.target);
-                                    if (action.url) {
-                                        // Optional: Open the specified URL
-                                        await browser.url(action.url)
-                                    }
-                                    await browser.saveScreenshot(action.filepath);
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    reject(err.message);
-                                }
-                            })()
-                        });
-                    }
-                },
-                {
-                    name: "addon:GUI-setCookies",
-                    onTestStart: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            testClear();
-                            resolve();
-                        });
-                    },
-                    onTestEnd: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            (async () => {
-                                try {
-                                    await testClose();
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    resolve();
-                                }
-                            })()
-                        });
-                    },
-                    execute: function(opt) {
-                        // opt object contains:
-                        // - data: optional data for action
-                        // - node: target node
-                        // - msg: message object
-                        return new Promise((resolve, reject) => {
-                            const action = opt.action;
-                            (async () => {
-                                try {
-                                    const browser = await getBrowser(action.target);
-                                    const cookies = JSON.parse(action.cookie);
-                                    await browser.setCookies(cookies);
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    reject(err.message);
-                                }
-                            })()
-                        });
-                    }
-                },
-                {
-                    name: "addon:GUI-setTimeout",
-                    onTestStart: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            testClear();
-                            resolve();
-                        });
-                    },
-                    onTestEnd: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            (async () => {
-                                try {
-                                    await testClose();
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    resolve();
-                                }
-                            })()
-                        });
-                    },
-                    execute: function(opt) {
-                        // opt object contains:
-                        // - data: optional data for action
-                        // - node: target node
-                        // - msg: message object
-                        return new Promise((resolve, reject) => {
-                            const action = opt.action;
-                            (async () => {
-                                try {
-                                    const browser = await getBrowser(action.target);
-                                    const timeout = JSON.parse(action.timeout);
-                                    await browser.setTimeout(timeout);
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    reject(err.message);
-                                }
-                            })()
-                        });
-                    }
-                },
-                {
-                    name: "addon:GUI-waitUntil",
-                    onTestStart: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            testClear();
-                            resolve();
-                        });
-                    },
-                    onTestEnd: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            (async () => {
-                                try {
-                                    await testClose();
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    resolve();
-                                }
-                            })()
-                        });
-                    },
-                    execute: function(opt) {
-                        // opt object contains:
-                        // - data: optional data for action
-                        // - node: target node
-                        // - msg: message object
-                        return new Promise((resolve, reject) => {
-                            const action = opt.action;
-                            let  timeout = Number(action.timeout);
-                            (async () => {
-                                try {
-                                    const browser = await getBrowser(action.target);
-                                    await browser.waitUntil(
-                                        async () => (
-                                            action.type === "str" && (await browser.$(action.selector).getText() === action.value) || 
-                                            action.type === "re"  && (new RegExp(action.value).test(await browser.$(action.selector).getText()))),
-                                        {
-                                            //timeout: Number(action.timeout),
-                                            timeout: timeout,
-                                            timeoutMsg: 'expected text to be different after ' + action.timeout + "ms"
-                                        }
-                                    );
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    reject(err.message);
-                                }
-                            })()
-                        });
-                    }
-                },
-                {
-                    name: "addon:GUI-addValue",
-                    onTestStart: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            testClear();
-                            resolve();
-                        });
-                    },
-                    onTestEnd: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            (async () => {
-                                try {
-                                    await testClose();
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    resolve();
-                                }
-                            })()
-                        });
-                    },
-                    execute: function(opt) {
-                        // opt object contains:
-                        // - data: optional data for action
-                        // - node: target node
-                        // - msg: message object
-                        return new Promise((resolve, reject) => {
-                            const action = opt.action;
-                            (async () => {
-                                try {
-                                    const browser = await getBrowser(action.target);
-                                    await browser.$(action.selector).addValue(action.value);
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    reject(err.message);
-                                }
-                            })()
-                        });
-                    }
-                },
-                {
-                    name: "addon:GUI-clearValue",
-                    onTestStart: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            testClear();
-                            resolve();
-                        });
-                    },
-                    onTestEnd: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            (async () => {
-                                try {
-                                    await testClose();
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    resolve();
-                                }
-                            })()
-                        });
-                    },
-                    execute: function(opt) {
-                        // opt object contains:
-                        // - data: optional data for action
-                        // - node: target node
-                        // - msg: message object
-                        return new Promise((resolve, reject) => {
-                            const action = opt.action;
-                            (async () => {
-                                try {
-                                    const browser = await getBrowser(action.target);
-                                    await browser.$(action.selector).clearValue();
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    reject(err.message);
-                                }
-                            })()
-                        });
-                    }
-                },
-                {
-                    name: "addon:GUI-click",
-                    onTestStart: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            testClear();
-                            resolve();
-                        });
-                    },
-                    onTestEnd: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            (async () => {
-                                try {
-                                    await testClose();
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    resolve();
-                                }
-                            })()
-                        });
-                    },
-                    execute: function(opt) {
-                        // opt object contains:
-                        // - data: optional data for action
-                        // - node: target node
-                        // - msg: message object
-                        return new Promise((resolve, reject) => {
-                            const action = opt.action;
-                            (async () => {
-                                try {
-                                    const browser = await getBrowser(action.target);
-                                    if (action.clickkind === 'single') {
-                                        await browser.$(action.selector).click();
-                                    } else {
-                                        await browser.$(action.selector).doubleClick();
-                                    }
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    reject(err.message);
-                                }
-                            })()
-                        });
-                    }
-                },
-                {
-                    name: "addon:GUI-getValue",
-                    onTestStart: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            testClear();
-                            resolve();
-                        });
-                    },
-                    onTestEnd: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            (async () => {
-                                try {
-                                    await testClose();
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    resolve();
-                                }
-                            })()
-                        });
-                    },
-                    execute: function(opt) {
-                        // opt object contains:
-                        // - data: optional data for action
-                        // - node: target node
-                        // - msg: message object
-
-                        return new Promise((resolve, reject) => {
-                            const action = opt.action;
-                            const nid = opt.node;
-                            const msg = opt.msg;
-                            const node = nid ? RED.nodes.getNode(nid) : null;
-                            let val = ""
-                            if (!node) {
-                                console.log("Must be run in a node instance test.");
-                                reject("Must be run in a node instance test.");
-                                return;
-                            }
-
-                            (async () => {
-                                try {
-                                    const browser = await getBrowser(action.target);
-                                    if (action.getkind === 'attr') {
-                                        val = await browser.$(action.selector).getAttribute(action.getname);
-                                    } else if (action.getkind === 'prop') {
-                                        val = await browser.$(action.selector).getProperty(action.getname);
-                                    } else if (action.getkind === 'tag') {
-                                        val = await browser.$(action.selector).getTagName();
-                                    } else if (action.getkind === 'text') {
-                                        val = await browser.$(action.selector).getText();
-                                    } else if (action.getkind === 'val') {
-                                        val = await browser.$(action.selector).getValue();
-                                    }
-
-                                    switch (action.type) {
-                                        //case "msg":
-                                        //    if (msg) {
-                                        //        RED.util.setMessageProperty(msg, action.value, value);
-                                        //    }
-                                        //    break;
-                                        case "global":
-                                        case "flow":
-                                            const contextKey = RED.util.parseContextStore(action.value);
-                                            if (/\[msg/.test(contextKey.key)) {
-                                                // The key has a nest msg. reference to evaluate first
-                                                contextKey.key = RED.util.normalisePropertyExpression(contextKey.key, msg, true)
-                                            }
-                                            const target = node.context()[action.type];
-                                            const set = promisify(target.set);
-                                            set(contextKey.key, val, contextKey.store);
-                                            break;
-                                        default:
-                                            console.log("unexpected value type: "+ action.type);
-                                            reject("unexpected value type: "+ action.type);
-                                    }
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    reject(err.message);
-                                }
-                            })()
-                        });
-                    }
-                },
-                {
-                    name: "addon:GUI-moveTo",
-                    onTestStart: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            testClear();
-                            resolve();
-                        });
-                    },
-                    onTestEnd: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            (async () => {
-                                try {
-                                    await testClose();
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    resolve();
-                                }
-                            })()
-                        });
-                    },
-                    execute: function(opt) {
-                        // opt object contains:
-                        // - data: optional data for action
-                        // - node: target node
-                        // - msg: message object
-                        return new Promise((resolve, reject) => {
-                            const action = opt.action;
-                            (async () => {
-                                try {
-                                    const browser = await getBrowser(action.target);
-                                    await browser.$(action.selector).moveTo();
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    reject(err.message);
-                                }
-                            })()
-                        });
-                    }
-                },
-                {
-                    name: "addon:GUI-setValue",
-                    onTestStart: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            testClear();
-                            resolve();
-                        });
-                    },
-                    onTestEnd: function(opt) {
-                        return new Promise((resolve, reject) => {
-                            (async () => {
-                                try {
-                                    await testClose();
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    resolve();
-                                }
-                            })()
-                        });
-                    },
-                    execute: function(opt) {
-                        // opt object contains:
-                        // - data: optional data for action
-                        // - node: target node
-                        // - msg: message object
-                        return new Promise((resolve, reject) => {
-                            const action = opt.action;
-                            (async () => {
-                                try {
-                                    const browser = await getBrowser(action.target);
-                                    await browser.$(action.selector).setValue(action.value);
-                                    resolve();
-                                }catch(err){
-                                    console.log(err);
-                                    reject(err.message);
-                                }
-                            })()
-                        });
-                    }
-                }
-            ];
-        }
-    });
-};
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/src/locales/en-US/flow-tester-gui-addon.json b/examples/node-red-contrib-flow-tester-gui-addon/src/locales/en-US/flow-tester-gui-addon.json
deleted file mode 100644
index 3f29600..0000000
--- a/examples/node-red-contrib-flow-tester-gui-addon/src/locales/en-US/flow-tester-gui-addon.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
-    "label": {
-    }
-}
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/src/style.css b/examples/node-red-contrib-flow-tester-gui-addon/src/style.css
deleted file mode 100644
index e69de29..0000000
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/test/test.js b/examples/node-red-contrib-flow-tester-gui-addon/test/test.js
deleted file mode 100644
index 2a4de75..0000000
--- a/examples/node-red-contrib-flow-tester-gui-addon/test/test.js
+++ /dev/null
@@ -1,2 +0,0 @@
-describe("Flow tester gui addon tests", function() {
-});

From afb6dc54306221d1a095284bc52c7b310e3d5aba Mon Sep 17 00:00:00 2001
From: Kazuhiro Ito <kazuhiro.ito.ek@hitachi-solutions.com>
Date: Tue, 29 Mar 2022 10:01:54 +0900
Subject: [PATCH 9/9] add GUI test action addon

---
 .../LICENSE                                   |  201 ++
 .../README.md                                 |   56 +
 .../examples/GUI-Test-Example.json            |    1 +
 .../package.json                              |   47 +
 .../scripts/build.js                          |   51 +
 .../src/flow-tester-gui-addon.html            | 1663 +++++++++++++++++
 .../src/flow-tester-gui-addon.js              |  617 ++++++
 .../locales/en-US/flow-tester-gui-addon.json  |    4 +
 .../src/style.css                             |    0
 .../test/test.js                              |    2 +
 10 files changed, 2642 insertions(+)
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/LICENSE
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/README.md
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/examples/GUI-Test-Example.json
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/package.json
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/scripts/build.js
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.html
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.js
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/src/locales/en-US/flow-tester-gui-addon.json
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/src/style.css
 create mode 100644 examples/node-red-contrib-flow-tester-gui-addon/test/test.js

diff --git a/examples/node-red-contrib-flow-tester-gui-addon/LICENSE b/examples/node-red-contrib-flow-tester-gui-addon/LICENSE
new file mode 100644
index 0000000..261eeb9
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-gui-addon/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/README.md b/examples/node-red-contrib-flow-tester-gui-addon/README.md
new file mode 100644
index 0000000..9052440
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-gui-addon/README.md
@@ -0,0 +1,56 @@
+# node-red-flow-tester-gui-addon
+
+An GUI Test Addon to Flow Testing plugin for Node-RED
+
+**This is under development and not ready for general use. If you want to contribute, come talk to us in the `#core-dev` channel on https://nodered.org/slack
+
+## Developing
+
+To use the development version of Flow Tester Addon you can clone its source code repository
+and build it yourself.
+
+1. Get the source code
+
+```
+git clone https://github.com/node-red/node-red-flow-tester-gui-addon.git
+```
+
+2. Install the dependencies
+
+```
+cd node-red-flow-tester-gui-addon
+npm install
+```
+
+3. Build the plugin
+
+```
+npm run build
+```
+
+4. Install into Node-RED
+
+```
+cd ~/.node-red
+npm install <path-to-node-red-flow-tester-gui-addon-directory>
+```
+
+5. Restart Node-RED to load the plugin.
+
+### Source code structure
+
+ - `scripts` - build scripts used by `npm run build`
+ - `src` - source code of the plugins
+ - `test` - tests material
+ - `examples` - test flow example
+
+After `npm run build` is run, the following directories will be created:
+
+ - `dist` - contains the built plugin files
+ - `resources` contains the built plugin resource files (eg css)
+
+## License
+
+Copyright Node-RED Project Contributors.
+
+Licensed under the [Apache License, Version 2.0](LICENSE).
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/examples/GUI-Test-Example.json b/examples/node-red-contrib-flow-tester-gui-addon/examples/GUI-Test-Example.json
new file mode 100644
index 0000000..afad3ad
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-gui-addon/examples/GUI-Test-Example.json
@@ -0,0 +1 @@
+[{"id":"9b3db84fb21d2ae9","type":"tab","label":"フロー 1","disabled":false,"info":"","env":[]},{"id":"bcdef1528a38ab01","type":"flow-test-config","name":"Test Suite 0","tests":[{"id":"T1dqpqj7o1mo","name":"01-GUI-URL","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test1","url":"http://localhost:1880/test1-1","size":"1024,768","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test2","url":"http://localhost:1880/test1-2","size":"800,600","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test1","url":"","filepath":"./save/01-GUI-URL_1.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"target":"test2","url":"","filepath":"./save/01-GUI-URL_2.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"01-GUI-URL"}],"fe5f34a07f8fa02d":[],"33f0acbced5f2f2f":[],"3f1bc77ebad6fb7d":[],"89abec8dc8dcd928":[],"3433732293b0efe6":[],"4cbdf19859bd3673":[],"a57d5145d9cc69f8":[],"3a204cb1e4e7e798":[],"3b1b52e7950d2d96":[],"a8b9279ac2b7bb34":[],"3d80cb23855d1f23":[],"ea2689d761c694d9":[],"df63e899f76ec37d":[],"73b88c9ce8eb419b":[],"e2cc4ae0d72b963b":[],"fe3ad091b0d72fa6":[],"01a33fd443f37a9d":[],"5a88bb5ee5f74048":[],"de20304a494f612c":[],"46a0c697fa6f3aa9":[],"e53fcf4665e96479":[],"1851347e41085efa":[],"2135f0ed4da03687":[],"ecbdd8f3f5d1a43f":[],"6b5edcefaf047657":[],"252be38b87101a0c":[],"d9631503adada096":[],"f96271d463f3d005":[],"e9568cd8a3881f7a":[],"7deb2f295e4cf286":[],"b15db00ea98ccdb8":[],"da44efa0625b0c46":[],"b2abfc59dfd6747f":[],"9ad3814da7eb0bf8":[],"e0e8d9808cbefc12":[],"57489d4a6843ed06":[],"bf6dc3e2d4bba78a":[],"08cab205b3caa944":[],"67123a9c0d3e0d6b":[],"2ab47c47fb5f303e":[],"c7e554e9a8a3c157":[],"2486e1ca0a98c73f":[],"71f6558f1dbc157d":[],"0aac7206f22fd418":[],"2c3680f456d44179":[],"334278a4d04eef8e":[],"46fd6974c4ab4dd4":[],"006bc52baad3b791":[],"f79c8d74d708debb":[],"c5143318646fb9fd":[],"640d91fab434d070":[],"553dac4c5471d519":[],"cb0a6d52972bcc02":[],"193db0840f528392":[],"3d690e3169d2d483":[],"6717a5b7fb237bd1":[],"bf0d97744cf36e4c":[],"8e35628ea9d99957":[],"2b0fd9cc8afbdcd6":[],"b6aa9aef3d3647a3":[],"db5b2d254533ef8b":[],"46d010cd56ba8914":[],"29f54a1ad235097e":[],"a4d57d3ae7aff215":[],"f470657e71958b8f":[],"42419f5d347b6c64":[]},"cleanup":{"_global_":[],"fe5f34a07f8fa02d":[],"33f0acbced5f2f2f":[],"3f1bc77ebad6fb7d":[],"89abec8dc8dcd928":[],"3433732293b0efe6":[],"4cbdf19859bd3673":[],"a57d5145d9cc69f8":[],"3a204cb1e4e7e798":[],"3b1b52e7950d2d96":[],"a8b9279ac2b7bb34":[],"3d80cb23855d1f23":[],"ea2689d761c694d9":[],"df63e899f76ec37d":[],"73b88c9ce8eb419b":[],"e2cc4ae0d72b963b":[],"fe3ad091b0d72fa6":[],"01a33fd443f37a9d":[],"5a88bb5ee5f74048":[],"de20304a494f612c":[],"46a0c697fa6f3aa9":[],"e53fcf4665e96479":[],"1851347e41085efa":[],"2135f0ed4da03687":[],"ecbdd8f3f5d1a43f":[],"6b5edcefaf047657":[],"252be38b87101a0c":[],"d9631503adada096":[],"f96271d463f3d005":[],"e9568cd8a3881f7a":[],"7deb2f295e4cf286":[],"b15db00ea98ccdb8":[],"da44efa0625b0c46":[],"b2abfc59dfd6747f":[],"9ad3814da7eb0bf8":[],"e0e8d9808cbefc12":[],"57489d4a6843ed06":[],"bf6dc3e2d4bba78a":[],"08cab205b3caa944":[],"67123a9c0d3e0d6b":[],"2ab47c47fb5f303e":[],"c7e554e9a8a3c157":[],"2486e1ca0a98c73f":[],"71f6558f1dbc157d":[],"0aac7206f22fd418":[],"2c3680f456d44179":[],"334278a4d04eef8e":[],"46fd6974c4ab4dd4":[],"006bc52baad3b791":[],"f79c8d74d708debb":[],"c5143318646fb9fd":[],"640d91fab434d070":[],"553dac4c5471d519":[],"cb0a6d52972bcc02":[],"193db0840f528392":[],"3d690e3169d2d483":[],"6717a5b7fb237bd1":[],"bf0d97744cf36e4c":[],"8e35628ea9d99957":[],"2b0fd9cc8afbdcd6":[],"b6aa9aef3d3647a3":[],"db5b2d254533ef8b":[],"46d010cd56ba8914":[],"29f54a1ad235097e":[],"a4d57d3ae7aff215":[],"f470657e71958b8f":[],"42419f5d347b6c64":[]},"recv":{"fe5f34a07f8fa02d":[],"33f0acbced5f2f2f":[],"3f1bc77ebad6fb7d":[],"89abec8dc8dcd928":[],"a57d5145d9cc69f8":[],"3a204cb1e4e7e798":[],"3b1b52e7950d2d96":[],"a8b9279ac2b7bb34":[],"3d80cb23855d1f23":[],"ea2689d761c694d9":[],"fe3ad091b0d72fa6":[],"01a33fd443f37a9d":[],"5a88bb5ee5f74048":[],"e9568cd8a3881f7a":[],"7deb2f295e4cf286":[],"b15db00ea98ccdb8":[],"b2abfc59dfd6747f":[],"e0e8d9808cbefc12":[],"57489d4a6843ed06":[],"08cab205b3caa944":[],"67123a9c0d3e0d6b":[],"c7e554e9a8a3c157":[],"0aac7206f22fd418":[],"2c3680f456d44179":[],"334278a4d04eef8e":[],"46fd6974c4ab4dd4":[],"006bc52baad3b791":[],"f79c8d74d708debb":[],"c5143318646fb9fd":[],"640d91fab434d070":[],"553dac4c5471d519":[],"193db0840f528392":[{"kind":"match","value":"01-GUI-URL","performCheck":true}],"3d690e3169d2d483":[],"bf0d97744cf36e4c":[],"8e35628ea9d99957":[],"2b0fd9cc8afbdcd6":[],"b6aa9aef3d3647a3":[],"db5b2d254533ef8b":[],"46d010cd56ba8914":[],"29f54a1ad235097e":[],"a4d57d3ae7aff215":[]},"stub":{"fe5f34a07f8fa02d":[],"33f0acbced5f2f2f":[],"3f1bc77ebad6fb7d":[],"89abec8dc8dcd928":[],"a57d5145d9cc69f8":[],"3a204cb1e4e7e798":[],"3b1b52e7950d2d96":[],"a8b9279ac2b7bb34":[],"3d80cb23855d1f23":[],"ea2689d761c694d9":[],"fe3ad091b0d72fa6":[],"01a33fd443f37a9d":[],"5a88bb5ee5f74048":[],"e9568cd8a3881f7a":[],"7deb2f295e4cf286":[],"b15db00ea98ccdb8":[],"b2abfc59dfd6747f":[],"e0e8d9808cbefc12":[],"57489d4a6843ed06":[],"08cab205b3caa944":[],"67123a9c0d3e0d6b":[],"c7e554e9a8a3c157":[],"0aac7206f22fd418":[],"2c3680f456d44179":[],"334278a4d04eef8e":[],"46fd6974c4ab4dd4":[],"006bc52baad3b791":[],"f79c8d74d708debb":[],"c5143318646fb9fd":[],"640d91fab434d070":[],"553dac4c5471d519":[],"193db0840f528392":[],"3d690e3169d2d483":[],"bf0d97744cf36e4c":[],"8e35628ea9d99957":[],"2b0fd9cc8afbdcd6":[],"b6aa9aef3d3647a3":[],"db5b2d254533ef8b":[],"46d010cd56ba8914":[],"29f54a1ad235097e":[],"a4d57d3ae7aff215":[]},"send":{"fe5f34a07f8fa02d":[],"33f0acbced5f2f2f":[],"3f1bc77ebad6fb7d":[],"89abec8dc8dcd928":[],"3433732293b0efe6":[],"4cbdf19859bd3673":[],"a57d5145d9cc69f8":[],"3a204cb1e4e7e798":[],"3d80cb23855d1f23":[],"fe3ad091b0d72fa6":[],"01a33fd443f37a9d":[],"5a88bb5ee5f74048":[],"f96271d463f3d005":[],"e9568cd8a3881f7a":[],"b15db00ea98ccdb8":[],"da44efa0625b0c46":[],"b2abfc59dfd6747f":[],"9ad3814da7eb0bf8":[],"e0e8d9808cbefc12":[],"57489d4a6843ed06":[],"bf6dc3e2d4bba78a":[],"08cab205b3caa944":[],"67123a9c0d3e0d6b":[],"2ab47c47fb5f303e":[],"c7e554e9a8a3c157":[],"2486e1ca0a98c73f":[],"71f6558f1dbc157d":[],"0aac7206f22fd418":[],"2c3680f456d44179":[],"334278a4d04eef8e":[],"46fd6974c4ab4dd4":[],"f79c8d74d708debb":[],"c5143318646fb9fd":[],"640d91fab434d070":[],"3d690e3169d2d483":[],"6717a5b7fb237bd1":[],"8e35628ea9d99957":[],"2b0fd9cc8afbdcd6":[],"b6aa9aef3d3647a3":[],"db5b2d254533ef8b":[],"46d010cd56ba8914":[],"29f54a1ad235097e":[],"a4d57d3ae7aff215":[]}}},{"id":"Tr3j3798bung","name":"02-GUI-Keys","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test","url":"http://localhost:1880/ui/#!/0","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"kind":"send","target":"3a204cb1e4e7e798","value":"0"},{"target":"test","selector":"#\\30 2_GUI-Keys_Group_1_cards > md-card.nr-dashboard-slider._md.layout-align-space-between-center.layout-row.flex.visible","type":"str","value":"slider","timeout":"5000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test","key":"Tab,Tab","performCheck":false,"kind":"addon:GUI-Keys"},{"target":"test","key":"ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight,ArrowRight","performCheck":false,"kind":"addon:GUI-Keys"},{"kind":"wait","wait":"1000"},{"target":"test","url":"","filepath":"./save/02-GUI-Keys.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"02-GUI-Keys"}],"193db0840f528392":[]},"cleanup":{"_global_":[],"193db0840f528392":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"02-GUI-Keys","performCheck":true}]},"stub":{"193db0840f528392":[]},"send":{}}},{"id":"Tm3obhhm6vug","name":"03-GUI-saveScreenshot","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test","url":"http://localhost:1880/test3","filepath":"./save/03-GUI-saveScreenshot.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"03-GUI-saveScreenshot"}],"193db0840f528392":[]},"cleanup":{"_global_":[],"193db0840f528392":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"03-GUI-saveScreenshot","performCheck":true}]},"stub":{"193db0840f528392":[]},"send":{}}},{"id":"T8ehjolrb0og","name":"04-GUI-setCookies","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test","url":"http://localhost:1880/test4","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","cookie":"[{\"name\":\"test1\",\"value\":\"123\"},{\"name\":\"test2\",\"value\":\"456\"},{\"name\":\"test3\",\"value\":\"789\"}]","performCheck":false,"kind":"addon:GUI-setCookies"},{"target":"test","url":"http://localhost:1880/test4","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","url":"","filepath":"./save/04-GUI-setCookies.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"04-GUI-setCookies"}],"193db0840f528392":[]},"cleanup":{"_global_":[],"193db0840f528392":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"04-GUI-setCookies","performCheck":true}]},"stub":{"193db0840f528392":[]},"send":{}}},{"id":"Tqicqojskkb","name":"05-GUI-setTimeout","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test1","timeout":"{\"pageLoad\":5000}","performCheck":false,"kind":"addon:GUI-setTimeout"},{"target":"test1","url":"http://localhost:1880/test5-1","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test2","timeout":"{\"pageLoad\":5000}","performCheck":false,"kind":"addon:GUI-setTimeout"},{"target":"test2","url":"http://localhost:1880/test5-2","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"kind":"send","target":"193db0840f528392","value":"05-GUI-setTimeout"}],"193db0840f528392":[]},"cleanup":{"_global_":[],"193db0840f528392":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"05-GUI-setTimeout","performCheck":true}]},"stub":{"193db0840f528392":[]},"send":{}}},{"id":"Tktn10o59iug","name":"06-GUI-waitUntil","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test1","url":"http://localhost:1880/test6-1","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test1","selector":"#ID_TEXT","type":"re","value":"\\d{2}","timeout":"10000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test2","url":"http://localhost:1880/test6-2","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test2","selector":"#ID_TEXT","type":"re","value":"\\d{2}","timeout":"10000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"kind":"send","target":"193db0840f528392","value":"06-GUI-waitUntil"}],"193db0840f528392":[]},"cleanup":{"_global_":[],"193db0840f528392":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"06-GUI-waitUntil","performCheck":true}]},"stub":{"193db0840f528392":[]},"send":{}}},{"id":"Taqk7q2rj9ng","name":"07-GUI-addValue","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"kind":"send","target":"640d91fab434d070","value":"test addValue "},{"target":"test","url":"http://localhost:1880/ui/#!/1","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","selector":"#input_0","type":"str","value":"","timeout":"5000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test","selector":"#input_0","value":"add1 ","performCheck":false,"kind":"addon:GUI-addValue"},{"target":"test","selector":"#input_0","value":"add2 ","performCheck":false,"kind":"addon:GUI-addValue"},{"target":"test","selector":"#input_0","value":"add3","performCheck":false,"kind":"addon:GUI-addValue"},{"target":"test","url":"","filepath":"./save/07-GUI-addValue.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"07-GUI-addValue"}],"553dac4c5471d519":[],"193db0840f528392":[]},"cleanup":{"_global_":[],"553dac4c5471d519":[],"193db0840f528392":[]},"recv":{"553dac4c5471d519":[{"kind":"match","value":"test addValue add1 add2 add3","performCheck":true}],"193db0840f528392":[{"kind":"match","value":"07-GUI-addValue","performCheck":true}]},"stub":{"553dac4c5471d519":[],"193db0840f528392":[]},"send":{}}},{"id":"T1f2t37fo80o","name":"08-GUI-clearValue","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"kind":"send","target":"640d91fab434d070","value":"test clearValue"},{"target":"test","url":"http://localhost:1880/ui/#!/1","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","selector":"#input_0","type":"str","value":"","timeout":"5000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test","selector":"#input_0","performCheck":false,"kind":"addon:GUI-clearValue"},{"target":"test","selector":"#input_0","value":"Test 08-GUI-clearValue","performCheck":false,"kind":"addon:GUI-addValue"},{"target":"test","url":"","filepath":"./save/08-GUI-clearValue.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"08-GUI-clearValue"}],"553dac4c5471d519":[],"193db0840f528392":[]},"cleanup":{"_global_":[],"553dac4c5471d519":[],"193db0840f528392":[]},"recv":{"553dac4c5471d519":[{"kind":"match","value":"Test 08-GUI-clearValue","performCheck":true}],"193db0840f528392":[{"kind":"match","value":"08-GUI-clearValue","performCheck":true}]},"stub":{"553dac4c5471d519":[],"193db0840f528392":[]},"send":{}}},{"id":"Tgbjs7hefb9","name":"09-GUI-click","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"kind":"send","target":"ea2689d761c694d9","value":""},{"target":"test","url":"http://localhost:1880/ui/#!/2","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","selector":"#\\30 9_GUI-click_Group_1_cards > md-card.nr-dashboard-button._md.visible > button","type":"str","value":"BUTTON","timeout":"5000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test","selector":"#\\30 9_GUI-click_Group_1_cards > md-card.nr-dashboard-button._md.visible > button","clickkind":"single","performCheck":false,"kind":"addon:GUI-click"},{"kind":"wait","wait":"1000"},{"target":"test","url":"","filepath":"./save/09-GUI-click.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"09-GUI-click"}],"5a88bb5ee5f74048":[],"193db0840f528392":[]},"cleanup":{"_global_":[],"5a88bb5ee5f74048":[],"193db0840f528392":[]},"recv":{"5a88bb5ee5f74048":[],"193db0840f528392":[{"kind":"match","value":"09-GUI-click","performCheck":true}]},"stub":{"5a88bb5ee5f74048":[],"193db0840f528392":[]},"send":{"5a88bb5ee5f74048":[{"kind":"match","value":"Button was clicked.","performCheck":true}]}}},{"id":"Tcacec5v6mao","name":"10-GUI-getValue","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test","url":"http://localhost:1880/test10","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"kind":"click","target":"29e3ad51752ad855"}],"193db0840f528392":[],"a4d57d3ae7aff215":[],"bf0d97744cf36e4c":[]},"cleanup":{"_global_":[],"193db0840f528392":[],"a4d57d3ae7aff215":[],"bf0d97744cf36e4c":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"10-GUI-getValue","performCheck":true}],"a4d57d3ae7aff215":[{"target":"test","selector":"#ID_TAG","getkind":"tag","getname":"","type":"global","value":"tag","performCheck":false,"kind":"addon:GUI-getValue"},{"target":"test","selector":"#ID_TEXT","getkind":"text","getname":"","type":"global","value":"text","performCheck":false,"kind":"addon:GUI-getValue"},{"target":"test","selector":"#ID_PROP","getkind":"prop","getname":"testprop","type":"flow","value":"property","performCheck":false,"kind":"addon:GUI-getValue"},{"target":"test","selector":"#ID_VALUE","getkind":"val","getname":"","type":"global","value":"value","performCheck":false,"kind":"addon:GUI-getValue"},{"target":"test","selector":"#ID_ATTR","getkind":"attr","getname":"attribute","type":"flow","value":"attribute","performCheck":false,"kind":"addon:GUI-getValue"},{"target":"test","selector":"#ID_VALUE","getkind":"prop","getname":"type","type":"flow","value":"property","performCheck":false,"kind":"addon:GUI-getValue"}],"bf0d97744cf36e4c":[]},"stub":{"193db0840f528392":[],"a4d57d3ae7aff215":[],"bf0d97744cf36e4c":[]},"send":{"a4d57d3ae7aff215":[{"kind":"wait","wait":"2000"},{"kind":"match","value":"h1TEST-TextTEST-ValueTEST-Attributetext","performCheck":true},{"kind":"send","target":"193db0840f528392","value":"10-GUI-getValue"}]}}},{"id":"T2cbqvf3cgc8","name":"11-GUI-moveTo","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"target":"test","url":"http://localhost:1880/ui/#!/3","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","selector":"#\\31 1_GUI-moveTo_Group_1_cards > md-card:nth-child(1) > button","type":"str","value":"BUTTON 1","timeout":"5000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test","selector":"#\\31 1_GUI-moveTo_Group_1_cards > md-card:nth-child(1) > button","performCheck":false,"kind":"addon:GUI-moveTo"},{"kind":"wait","wait":"1500"},{"target":"test","url":"","filepath":"./save/11-GUI-moveTo_1.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"target":"test","selector":"#\\31 1_GUI-moveTo_Group_1_cards > md-card:nth-child(2) > button","performCheck":false,"kind":"addon:GUI-moveTo"},{"kind":"wait","wait":"1500"},{"target":"test","url":"","filepath":"./save/11-GUI-moveTo_2.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"target":"test","selector":"#\\31 1_GUI-moveTo_Group_1_cards > md-card:nth-child(3) > button","performCheck":false,"kind":"addon:GUI-moveTo"},{"kind":"wait","wait":"1500"},{"target":"test","url":"","filepath":"./save/11-GUI-moveTo_3.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"11-GUI-moveTo"}],"193db0840f528392":[]},"cleanup":{"_global_":[],"193db0840f528392":[]},"recv":{"193db0840f528392":[{"kind":"match","value":"11-GUI-moveTo","performCheck":true}]},"stub":{"193db0840f528392":[]},"send":{}}},{"id":"Tn9de8bpkfa8","name":"12-GUI-setValue","suite":"bcdef1528a38ab01","timeout":"10","max_actions":"500","actions":{"setup":{"_global_":[{"kind":"send","target":"a8b9279ac2b7bb34","value":""},{"target":"test","url":"http://localhost:1880/ui/#!/4","size":"","performCheck":false,"kind":"addon:GUI-URL"},{"target":"test","selector":"#input_0","type":"str","value":"","timeout":"5000","performCheck":false,"kind":"addon:GUI-waitUntil"},{"target":"test","selector":"#input_0","value":"Test text","performCheck":false,"kind":"addon:GUI-setValue"},{"kind":"wait","wait":"1000"},{"target":"test","url":"","filepath":"./save/12-GUI-setValue.png","performCheck":false,"kind":"addon:GUI-saveScreenshot"},{"kind":"send","target":"193db0840f528392","value":"12-GUI-setValue"}],"fe3ad091b0d72fa6":[],"193db0840f528392":[]},"cleanup":{"_global_":[],"fe3ad091b0d72fa6":[],"193db0840f528392":[]},"recv":{"fe3ad091b0d72fa6":[],"193db0840f528392":[{"kind":"match","value":"12-GUI-setValue","performCheck":true}]},"stub":{"fe3ad091b0d72fa6":[],"193db0840f528392":[]},"send":{"fe3ad091b0d72fa6":[{"kind":"match","value":"Test text has been entered.","performCheck":true}]}}}]},{"id":"ea7e40d01b3c9e92","type":"ui_base","theme":{"name":"theme-light","lightTheme":{"default":"#0094CE","baseColor":"#0094CE","baseFont":"-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen-Sans,Ubuntu,Cantarell,Helvetica Neue,sans-serif","edited":true,"reset":false},"darkTheme":{"default":"#097479","baseColor":"#097479","baseFont":"-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen-Sans,Ubuntu,Cantarell,Helvetica Neue,sans-serif","edited":false},"customTheme":{"name":"Untitled Theme 1","default":"#4B7930","baseColor":"#4B7930","baseFont":"-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen-Sans,Ubuntu,Cantarell,Helvetica Neue,sans-serif"},"themeState":{"base-color":{"default":"#0094CE","value":"#0094CE","edited":false},"page-titlebar-backgroundColor":{"value":"#0094CE","edited":false},"page-backgroundColor":{"value":"#fafafa","edited":false},"page-sidebar-backgroundColor":{"value":"#ffffff","edited":false},"group-textColor":{"value":"#1bbfff","edited":false},"group-borderColor":{"value":"#ffffff","edited":false},"group-backgroundColor":{"value":"#ffffff","edited":false},"widget-textColor":{"value":"#111111","edited":false},"widget-backgroundColor":{"value":"#0094ce","edited":false},"widget-borderColor":{"value":"#ffffff","edited":false},"base-font":{"value":"-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen-Sans,Ubuntu,Cantarell,Helvetica Neue,sans-serif"}},"angularTheme":{"primary":"indigo","accents":"blue","warn":"red","background":"grey","palette":"light"}},"site":{"name":"Node-RED ダッシュボード","hideToolbar":"false","allowSwipe":"false","lockMenu":"false","allowTempTheme":"true","dateFormat":"YYYY/MM/DD","sizes":{"sx":48,"sy":48,"gx":6,"gy":6,"cx":6,"cy":6,"px":0,"py":0}}},{"id":"29571e93d0cd3bd8","type":"ui_group","name":"Group 1","tab":"","order":1,"disp":true,"width":6},{"id":"add392ac2ced5ed7","type":"ui_tab","name":"02 GUI-Keys","icon":"dashboard","order":1,"disabled":false,"hidden":false},{"id":"0779fd07b585202b","type":"ui_group","name":"Group 1","tab":"add392ac2ced5ed7","order":1,"disp":true,"width":"6","collapse":false,"className":""},{"id":"44d046383f6e170c","type":"ui_group","name":"Group 1","tab":"26c328d9fd99402b","order":1,"disp":true,"width":6},{"id":"26c328d9fd99402b","type":"ui_tab","name":"09 GUI-click","icon":"dashboard","order":3,"disabled":false,"hidden":false},{"id":"69ef5cd81fbe23c4","type":"ui_tab","name":"12 GUI-setValue","icon":"dashboard","order":5,"disabled":false,"hidden":false},{"id":"2b4a3bdb043675fd","type":"ui_group","name":"Group 1","tab":"69ef5cd81fbe23c4","order":1,"disp":true,"width":6},{"id":"51a7624fadecbb11","type":"ui_group","name":"Group 1","tab":"","order":1,"disp":true,"width":6},{"id":"785e79a6406a34f0","type":"ui_tab","name":"07 GUI-addValue 08-clearValue","icon":"dashboard","order":2,"disabled":false,"hidden":false},{"id":"2c037ff2393ce306","type":"ui_group","name":"Group 1","tab":"785e79a6406a34f0","order":1,"disp":true,"width":6},{"id":"d7a48474c86fb492","type":"ui_tab","name":"11 GUI-moveTo","icon":"dashboard","order":4,"disabled":false,"hidden":false},{"id":"a94a995999abb6ff","type":"ui_group","name":"Group 1","tab":"d7a48474c86fb492","order":1,"disp":true,"width":6},{"id":"3433732293b0efe6","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test1-1","method":"get","upload":false,"swaggerDoc":"","x":110,"y":100,"wires":[["89abec8dc8dcd928"]]},{"id":"9c703e8de2e3c532","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":470,"y":100,"wires":[]},{"id":"89abec8dc8dcd928","type":"template","z":"9b3db84fb21d2ae9","name":"Size: 1024x768","field":"payload","fieldType":"msg","format":"html","syntax":"plain","template":"<!DOCTYPE html>\n<html>\n\n<head>\n    <meta charset=\"utf-8\">\n    <title>01 GUI-URL TEST</title>\n</head>\n\n<body>\n    <h1>01 GUI-URL TEST1</h1>\n    <p>Size: 1024x768</p>\n    <p>test test test test test test test test test test test test test test test test test test test test test test test test\n    test test test test test test test test test test test test test test test test test test test test test test test test\n    test test test test test test test test test test test test test test test test test test test test test test test test\n    test test test test test test test test test test test test test test test</p>\n</body>\n\n</html>","output":"str","x":300,"y":100,"wires":[["9c703e8de2e3c532"]]},{"id":"4cbdf19859bd3673","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test1-2","method":"get","upload":false,"swaggerDoc":"","x":110,"y":160,"wires":[["a57d5145d9cc69f8"]]},{"id":"741bea42aff840bc","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":470,"y":160,"wires":[]},{"id":"a57d5145d9cc69f8","type":"template","z":"9b3db84fb21d2ae9","name":"Size: 800x600","field":"payload","fieldType":"msg","format":"html","syntax":"plain","template":"<!DOCTYPE html>\n<html>\n\n<head>\n    <meta charset=\"utf-8\">\n    <title>01 GUI-URL TEST</title>\n</head>\n\n<body>\n    <h1>01 GUI-URL TEST2</h1>\n    <p>Size: 800x600</p>\n    <p>test test test test test test test test test test test test test test test test test test test test test test test test\n    test test test test test test test test test test test test test test test test test test test test test test test test\n    test test test test test test test test test test test test test test test test test test test test test test test test\n    test test test test test test test test test test test test test test test</p>\n</body>\n\n</html>","output":"str","x":300,"y":160,"wires":[["741bea42aff840bc"]]},{"id":"3a204cb1e4e7e798","type":"ui_slider","z":"9b3db84fb21d2ae9","name":"","label":"slider","tooltip":"","group":"0779fd07b585202b","order":0,"width":0,"height":0,"passthru":true,"outs":"all","topic":"topic","topicType":"msg","min":0,"max":10,"step":1,"className":"","x":90,"y":260,"wires":[["3b1b52e7950d2d96"]]},{"id":"3b1b52e7950d2d96","type":"ui_gauge","z":"9b3db84fb21d2ae9","name":"","group":"0779fd07b585202b","order":1,"width":0,"height":0,"gtype":"gage","title":"gauge","label":"units","format":"{{value}}","min":0,"max":10,"colors":["#00b500","#e6e600","#ca3838"],"seg1":"","seg2":"","className":"","x":230,"y":260,"wires":[]},{"id":"01a33fd443f37a9d","type":"ui_button","z":"9b3db84fb21d2ae9","name":"","group":"44d046383f6e170c","order":1,"width":0,"height":0,"passthru":false,"label":"button","tooltip":"","color":"","bgcolor":"","className":"","icon":"","payload":"Button","payloadType":"str","topic":"topic","topicType":"msg","x":90,"y":1080,"wires":[["5a88bb5ee5f74048"]]},{"id":"ea2689d761c694d9","type":"ui_text","z":"9b3db84fb21d2ae9","group":"44d046383f6e170c","order":2,"width":0,"height":0,"name":"text","label":"","format":"{{msg.payload}}","layout":"row-center","className":"","x":490,"y":1080,"wires":[]},{"id":"5a88bb5ee5f74048","type":"function","z":"9b3db84fb21d2ae9","name":"","func":"if (msg.payload != \"\") {\n    msg.payload += \" was clicked.\"\n}\nreturn msg;","outputs":1,"noerr":0,"initialize":"","finalize":"","libs":[],"x":300,"y":1080,"wires":[["ea2689d761c694d9"]]},{"id":"3d80cb23855d1f23","type":"ui_text_input","z":"9b3db84fb21d2ae9","name":"","label":"","tooltip":"","group":"2b4a3bdb043675fd","order":1,"width":0,"height":0,"passthru":true,"mode":"text","delay":300,"topic":"topic","sendOnBlur":true,"className":"","topicType":"msg","x":100,"y":1520,"wires":[["fe3ad091b0d72fa6"]]},{"id":"fe3ad091b0d72fa6","type":"function","z":"9b3db84fb21d2ae9","name":"","func":"if (msg.payload != \"\") {\n    msg.payload += \" has been entered.\"\n}\nreturn msg;","outputs":1,"noerr":0,"initialize":"","finalize":"","libs":[],"x":300,"y":1520,"wires":[["a8b9279ac2b7bb34"]]},{"id":"a8b9279ac2b7bb34","type":"ui_text","z":"9b3db84fb21d2ae9","group":"2b4a3bdb043675fd","order":2,"width":0,"height":0,"name":"text","label":"","format":"{{msg.payload}}","layout":"row-center","className":"","x":510,"y":1520,"wires":[]},{"id":"df63e899f76ec37d","type":"comment","z":"9b3db84fb21d2ae9","name":"09 GUI-click","info":"","x":110,"y":1040,"wires":[]},{"id":"73b88c9ce8eb419b","type":"comment","z":"9b3db84fb21d2ae9","name":"12 GUI-setValue","info":"","x":120,"y":1480,"wires":[]},{"id":"e2cc4ae0d72b963b","type":"comment","z":"9b3db84fb21d2ae9","name":"02 GUI-Keys","info":"","x":110,"y":220,"wires":[]},{"id":"de20304a494f612c","type":"comment","z":"9b3db84fb21d2ae9","name":"01 GUI-URL","info":"","x":110,"y":40,"wires":[]},{"id":"46a0c697fa6f3aa9","type":"comment","z":"9b3db84fb21d2ae9","name":"03 GUI-saveScreenshot","info":"","x":140,"y":340,"wires":[]},{"id":"e53fcf4665e96479","type":"comment","z":"9b3db84fb21d2ae9","name":"04 GUI-setCookies","info":"","x":130,"y":460,"wires":[]},{"id":"1851347e41085efa","type":"comment","z":"9b3db84fb21d2ae9","name":"05 GUI-setTimeout","info":"タイムアウトしてもテストフローが停止しない。\n用途が不明","x":130,"y":580,"wires":[]},{"id":"2135f0ed4da03687","type":"comment","z":"9b3db84fb21d2ae9","name":"06 GUI-waitUntil","info":"","x":120,"y":760,"wires":[]},{"id":"ecbdd8f3f5d1a43f","type":"comment","z":"9b3db84fb21d2ae9","name":"07 GUI-addValue","info":"","x":120,"y":940,"wires":[]},{"id":"6b5edcefaf047657","type":"comment","z":"9b3db84fb21d2ae9","name":"08 GUI-clearValue","info":"","x":310,"y":940,"wires":[]},{"id":"252be38b87101a0c","type":"comment","z":"9b3db84fb21d2ae9","name":"10 GUI-getValue","info":"","x":120,"y":1140,"wires":[]},{"id":"d9631503adada096","type":"comment","z":"9b3db84fb21d2ae9","name":"11 GUI-moveTo","info":"","x":120,"y":1300,"wires":[]},{"id":"f96271d463f3d005","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test3","method":"get","upload":false,"swaggerDoc":"","x":100,"y":380,"wires":[["e9568cd8a3881f7a"]]},{"id":"3646275cbe45db61","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":550,"y":380,"wires":[]},{"id":"e9568cd8a3881f7a","type":"template","z":"9b3db84fb21d2ae9","name":"URL: http://localhost:1880/test3","field":"payload","fieldType":"msg","format":"html","syntax":"plain","template":"<!DOCTYPE html>\n<html>\n\n<head>\n    <meta charset=\"utf-8\">\n    <title>03 GUI-savaScreenshot TEST</title>\n</head>\n\n<body>\n    <h1>03 GUI-savaScreenshot TEST</h1>\n    <p>URL: http://localhost:1880/test3</p>\n</body>\n\n</html>","output":"str","x":330,"y":380,"wires":[["3646275cbe45db61"]]},{"id":"b15db00ea98ccdb8","type":"function","z":"9b3db84fb21d2ae9","name":"","func":"msg.payload = JSON.stringify(msg.req.cookies, null, 4);\nreturn msg;","outputs":1,"noerr":0,"initialize":"","finalize":"","libs":[],"x":260,"y":500,"wires":[["b2abfc59dfd6747f"]]},{"id":"da44efa0625b0c46","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test4","method":"get","upload":false,"swaggerDoc":"","x":100,"y":500,"wires":[["b15db00ea98ccdb8"]]},{"id":"b2abfc59dfd6747f","type":"template","z":"9b3db84fb21d2ae9","name":"Cookies","field":"payload","fieldType":"msg","format":"handlebars","syntax":"mustache","template":"<!DOCTYPE html>\n<head>\n    <meta charset=\"utf-8\">\n    <title>04 GUI-setCookies TEST</title>\n</head>\n<body>\n    <h1>04 GUI-setCookies TEST</h1>\n    <pre>{{ payload }}</pre>\n</body>\n</html>","output":"str","x":420,"y":500,"wires":[["c3c9bd6b22cdf5c4"]]},{"id":"c3c9bd6b22cdf5c4","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":580,"y":500,"wires":[]},{"id":"9ad3814da7eb0bf8","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test5-1","method":"get","upload":false,"swaggerDoc":"","x":110,"y":620,"wires":[["57489d4a6843ed06"]]},{"id":"e0e8d9808cbefc12","type":"template","z":"9b3db84fb21d2ae9","name":"wait page","field":"payload","fieldType":"msg","format":"html","syntax":"plain","template":"<!DOCTYPE html>\n\n<head>\n    <meta charset=\"utf-8\">\n    <title>05 GUI-setTimeout TEST</title>\n</head>\n\n<body>\n    <h1>05 GUI-setTimeout TEST1</h1>\n</body>\n\n</html>","output":"str","x":460,"y":620,"wires":[["273bd1c5fba89419"]]},{"id":"57489d4a6843ed06","type":"delay","z":"9b3db84fb21d2ae9","name":"","pauseType":"delay","timeout":"4","timeoutUnits":"seconds","rate":"1","nbRateUnits":"1","rateUnits":"second","randomFirst":"1","randomLast":"5","randomUnits":"seconds","drop":false,"allowrate":false,"outputs":1,"x":280,"y":620,"wires":[["e0e8d9808cbefc12"]]},{"id":"bf6dc3e2d4bba78a","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test5-2","method":"get","upload":false,"swaggerDoc":"","x":110,"y":680,"wires":[["08cab205b3caa944"]]},{"id":"08cab205b3caa944","type":"delay","z":"9b3db84fb21d2ae9","name":"depay 6s (time out)","pauseType":"delay","timeout":"6","timeoutUnits":"seconds","rate":"1","nbRateUnits":"1","rateUnits":"second","randomFirst":"1","randomLast":"5","randomUnits":"seconds","drop":false,"allowrate":false,"outputs":1,"x":310,"y":680,"wires":[["e0e8d9808cbefc12"]]},{"id":"2486e1ca0a98c73f","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test6-1","method":"get","upload":false,"swaggerDoc":"","x":110,"y":800,"wires":[["f79c8d74d708debb"]]},{"id":"71f6558f1dbc157d","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test6-2","method":"get","upload":false,"swaggerDoc":"","x":110,"y":860,"wires":[["c5143318646fb9fd"]]},{"id":"46fd6974c4ab4dd4","type":"template","z":"9b3db84fb21d2ae9","name":"wait text","field":"payload","fieldType":"msg","format":"handlebars","syntax":"mustache","template":"<!DOCTYPE html>\n\n<head>\n    <meta charset=\"utf-8\">\n    <title>06 GUI-waitUntil TEST</title>\n</head>\n\n<body>\n    <h1>06 GUI-waitUntil TEST</h1>\n    <p id=\"ID_TEXT\">Regular expression match test.</p></body>\n</html>\n\n<script>\nwindow.setTimeout(reWrite, {{ payload }});\nfunction reWrite()\n{\n  if (document.getElementById)\n  {\n      document.getElementById(\"ID_TEXT\").textContent=\"Test 06-GUI-waitUntil\";\n  }\n}\n</script>","output":"str","x":460,"y":800,"wires":[["6075415beb6878a0"]]},{"id":"6075415beb6878a0","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":610,"y":800,"wires":[]},{"id":"f79c8d74d708debb","type":"change","z":"9b3db84fb21d2ae9","name":"delay 9s","rules":[{"t":"set","p":"payload","pt":"msg","to":"9000","tot":"num"}],"action":"","property":"","from":"","to":"","reg":false,"x":280,"y":800,"wires":[["46fd6974c4ab4dd4"]]},{"id":"c5143318646fb9fd","type":"change","z":"9b3db84fb21d2ae9","name":"delay 11s (time out)","rules":[{"t":"set","p":"payload","pt":"msg","to":"10000","tot":"num"}],"action":"","property":"","from":"","to":"","reg":false,"x":310,"y":860,"wires":[["46fd6974c4ab4dd4"]]},{"id":"640d91fab434d070","type":"ui_text_input","z":"9b3db84fb21d2ae9","name":"","label":"","tooltip":"","group":"2c037ff2393ce306","order":0,"width":0,"height":0,"passthru":false,"mode":"text","delay":300,"topic":"topic","sendOnBlur":true,"className":"","topicType":"msg","x":100,"y":980,"wires":[["553dac4c5471d519"]]},{"id":"553dac4c5471d519","type":"debug","z":"9b3db84fb21d2ae9","name":"","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"payload","targetType":"msg","statusVal":"","statusType":"auto","x":290,"y":980,"wires":[]},{"id":"cb0a6d52972bcc02","type":"comment","z":"9b3db84fb21d2ae9","name":"99 TestEnd","info":"","x":100,"y":1600,"wires":[]},{"id":"193db0840f528392","type":"debug","z":"9b3db84fb21d2ae9","name":"","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"payload","targetType":"msg","statusVal":"","statusType":"auto","x":310,"y":1640,"wires":[]},{"id":"a009dbfb3c8dcba9","type":"inject","z":"9b3db84fb21d2ae9","name":"","props":[{"p":"payload"},{"p":"topic","vt":"str"}],"repeat":"","crontab":"","once":false,"onceDelay":0.1,"topic":"","payload":"","payloadType":"date","x":120,"y":1640,"wires":[["193db0840f528392"]]},{"id":"3d690e3169d2d483","type":"template","z":"9b3db84fb21d2ae9","name":"","field":"payload","fieldType":"msg","format":"handlebars","syntax":"mustache","template":"<!DOCTYPE html>\n<html>\n\n<head>\n    <meta charset=\"utf-8\">\n    <title>10 GUI-getValue TEST</title>\n</head>\n\n<body>\n    <h1 id=\"ID_TAG\">10 GUI-getValue TEST</h1>\n    <p id=\"ID_TEXT\">TEST-Text</p>\n    <div id=\"ID_ATTR\" attribute=\"TEST-Attribute\"></div>\n    <input type=\"text\" value=\"TEST-Value\" id=\"ID_VALUE\" />\n<body>\n\n</html>\n","output":"str","x":300,"y":1180,"wires":[["d7fe4424960b4eba"]]},{"id":"6717a5b7fb237bd1","type":"http in","z":"9b3db84fb21d2ae9","name":"","url":"/test10","method":"get","upload":false,"swaggerDoc":"","x":110,"y":1180,"wires":[["3d690e3169d2d483"]]},{"id":"d7fe4424960b4eba","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":490,"y":1180,"wires":[]},{"id":"29e3ad51752ad855","type":"inject","z":"9b3db84fb21d2ae9","name":"","props":[{"p":"payload"},{"p":"topic","vt":"str"}],"repeat":"","crontab":"","once":false,"onceDelay":0.1,"topic":"","payload":"","payloadType":"date","x":120,"y":1220,"wires":[["a4d57d3ae7aff215"]]},{"id":"bf0d97744cf36e4c","type":"debug","z":"9b3db84fb21d2ae9","name":"","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"payload","targetType":"msg","statusVal":"","statusType":"auto","x":510,"y":1220,"wires":[]},{"id":"b6aa9aef3d3647a3","type":"ui_button","z":"9b3db84fb21d2ae9","name":"","group":"a94a995999abb6ff","order":1,"width":0,"height":0,"passthru":false,"label":"Button 1","tooltip":"Button 1","color":"","bgcolor":"","className":"","icon":"","payload":"","payloadType":"str","topic":"topic","topicType":"msg","x":100,"y":1340,"wires":[[]]},{"id":"db5b2d254533ef8b","type":"ui_button","z":"9b3db84fb21d2ae9","name":"","group":"a94a995999abb6ff","order":2,"width":0,"height":0,"passthru":false,"label":"Button 2","tooltip":"Button 2","color":"","bgcolor":"","className":"","icon":"","payload":"","payloadType":"str","topic":"topic","topicType":"msg","x":100,"y":1380,"wires":[[]]},{"id":"46d010cd56ba8914","type":"ui_button","z":"9b3db84fb21d2ae9","name":"","group":"a94a995999abb6ff","order":3,"width":0,"height":0,"passthru":false,"label":"Button 3","tooltip":"Button 3","color":"","bgcolor":"","className":"","icon":"","payload":"","payloadType":"str","topic":"topic","topicType":"msg","x":100,"y":1420,"wires":[[]]},{"id":"a4d57d3ae7aff215","type":"change","z":"9b3db84fb21d2ae9","name":"","rules":[{"t":"set","p":"payload","pt":"msg","to":"$globalContext(\"tag\") & $globalContext(\"text\") & $globalContext(\"value\") & $flowContext(\"attribute\") &  $flowContext(\"property\")  \t","tot":"jsonata"}],"action":"","property":"","from":"","to":"","reg":false,"x":320,"y":1220,"wires":[["bf0d97744cf36e4c"]]},{"id":"f470657e71958b8f","type":"comment","z":"9b3db84fb21d2ae9","name":"Check the console log for the result.","info":"","x":580,"y":680,"wires":[]},{"id":"42419f5d347b6c64","type":"comment","z":"9b3db84fb21d2ae9","name":"Check the console log for the result.","info":"","x":580,"y":860,"wires":[]},{"id":"273bd1c5fba89419","type":"http response","z":"9b3db84fb21d2ae9","name":"","statusCode":"","headers":{},"x":620,"y":620,"wires":[]}]
\ No newline at end of file
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/package.json b/examples/node-red-contrib-flow-tester-gui-addon/package.json
new file mode 100644
index 0000000..d18ea08
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-gui-addon/package.json
@@ -0,0 +1,47 @@
+{
+    "name": "node-red-contrib-flow-tester-gui-addon",
+    "version": "0.0.1",
+    "description": "A test plugin for flow tester gui addon",
+    "scripts": {
+        "build": "node scripts/build.js",
+        "dev": "nodemon --exec 'npm run build'  -i dist -i resources -e 'css js html'",
+        "test": "nyc mocha"
+    },
+    "keywords": [
+        "node-red",
+        "testing",
+        "dashboard",
+        "gui"
+    ],
+    "files": [
+        "dist",
+        "resources"
+    ],
+    "license": "Apache-2",
+    "node-red": {
+        "version": ">=2.0.0",
+        "plugins": {
+            "flow-tester-gui-addon": "dist/flow-tester-gui-addon.js"
+        }
+    },
+    "contributors": [
+        {
+            "name": "Kazuhiro Ito",
+            "email": "kazuhiro.ito.ek@hitachi-solutions.com"
+        }
+    ],
+    "devDependencies": {
+        "@wdio/cli": "^7.16.10",
+        "@wdio/local-runner": "^7.16.10",
+        "@wdio/mocha-framework": "^7.16.6",
+        "@wdio/spec-reporter": "^7.16.9",
+        "chromedriver": "^96.0.0",
+        "fs-extra": "^10.0.0",
+        "global-agent": "^3.0.0",
+        "html-minifier": "^4.0.0",
+        "mocha": "^8.4.0",
+        "nodemon": "^2.0.7",
+        "nyc": "^15.1.0",
+        "wdio-chromedriver-service": "^7.2.2"
+    }
+}
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/scripts/build.js b/examples/node-red-contrib-flow-tester-gui-addon/scripts/build.js
new file mode 100644
index 0000000..96c50bb
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-gui-addon/scripts/build.js
@@ -0,0 +1,51 @@
+const minify = require("html-minifier").minify;
+const fs = require("fs-extra");
+const path = require("path");
+
+
+const projectRoot = path.join(__dirname,"..")
+const resources = path.join(projectRoot,"resources");
+const dist = path.join(projectRoot,"dist");
+const src = path.join(projectRoot,"src");
+
+const assets = {}
+assets[dist] = [
+    "locales",
+    "flow-tester-gui-addon.html",
+    "flow-tester-gui-addon.js"
+]
+assets[resources] = [
+    "style.css"
+]
+
+async function copyStaticAssets(dist,assets) {
+    await fs.mkdir(dist,{recursive: true});
+    for (let i=0; i<assets.length; i++) {
+        if (/\.html/.test(assets[i])) {
+            const content = await fs.readFile(path.join(src,assets[i]),"utf-8")
+            await fs.writeFile(path.join(dist,assets[i]), minify(content, {minifyCSS: true, minifyJS: true}))
+        } else if (/\.js/.test(assets[i])) {
+            await fs.copy(path.join(src,assets[i]),path.join(dist,assets[i]))
+        } else if (/\.css/.test(assets[i])) {
+            const rawCSS = await fs.readFile(path.join(src,assets[i]),"utf-8");
+            const minifiedCSS = minify("<style>"+rawCSS+"</style>", {minifyCSS: true});
+            const finalCSS = minifiedCSS.substring(7,minifiedCSS.length-8)
+            await fs.writeFile(path.join(dist,assets[i]), finalCSS)
+        } else {
+            await fs.mkdir(path.join(dist,assets[i]), {recursive: true});
+            await fs.copy(path.join(src,assets[i]),path.join(dist,assets[i]))
+        }
+    }
+}
+
+
+
+(async function() {
+    const destinations = Object.keys(assets);
+    for (let i=0, l=destinations.length; i<l; i++) {
+        await copyStaticAssets(destinations[i],assets[destinations[i]]);
+    }
+})().catch(err => {
+    console.error(err);
+    process.exit(1);
+});
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.html b/examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.html
new file mode 100644
index 0000000..2d73dc7
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.html
@@ -0,0 +1,1663 @@
+// GUI test addon for flow tester action
+<link rel="stylesheet" href="resources/node-red-contrib-flow-tester-addon/style.css">
+
+<script type="text/javascript">
+(function() {
+    RED.plugins.registerPlugin("node-red-contrib--flow-tester-addon", {
+        type: "flow-tester-addon",
+        onadd: function() {
+        },
+        onremove: function() {
+        },
+        actions: function () {
+            return [
+                // plugin for GUI-URL
+                {
+                    name: "addon:GUI-URL",
+                    label: "GUI-URL",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-url-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-url-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: url
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-url-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-url-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("url").appendTo(span1);
+                        var urlField = $("<input/>", {
+                            placeholder: "http://<target page>",
+                            type: "text",
+                            class: "addon-gui-url-url",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.url) {
+                            urlField.val(data.url);
+                        }
+
+                        // row2: size(option)
+                        var row2 = $("<div/>", {
+                            class: "addon-gui-url-div2"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span2 = $("<span/>", {
+                            class: "addon-gui-url-span2"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row2);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("size").appendTo(span2);
+                        var sizeField = $("<input/>", {
+                            placeholder: "(option) width, height",
+                            type: "text",
+                            class: "addon-gui-url-size",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span2);
+                        if (data && data.size) {
+                            sizeField.val(data.size);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-url-span0");
+                        var row1 = row0.find(".addon-gui-url-div1");
+                        var row2 = row0.find(".addon-gui-url-div2");
+                        span0.show();
+                        row1.show();
+                        row2.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-url-span0");
+                        var row1 = row0.find(".addon-gui-url-div1");
+                        var row2 = row0.find(".addon-gui-url-div2");
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                    },
+                    onSave: function (con) { 
+                        var target = con.find(".addon-gui-url-target").val();
+                        var url = con.find(".addon-gui-url-url").val();
+                        var size = con.find(".addon-gui-url-size").val();
+                        return {
+                            target: target,
+                            url: url,
+                            size: size,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-Keys
+                {
+                    name: "addon:GUI-Keys",
+                    label: "GUI-Keys",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-keys-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-keys-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: key
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-keys-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-keys-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("key").appendTo(span1);
+                        var keyField = $("<input/>", {
+                            placeholder: "key1, key2, key3, ...",
+                            type: "text",
+                            class: "addon-gui-keys-key",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.key) {
+                            keyField.val(data.key);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-keys-span0");
+                        var row1 = row0.find(".addon-gui-keys-div1");
+                        span0.show();
+                        row1.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-keys-span0");
+                        var row1 = row0.find(".addon-gui-keys-div1");
+                        span0.hide();
+                        row1.hide();
+                    },
+                    onSave: function (con) { 
+                        var target = con.find(".addon-gui-keys-target").val();
+                        var key = con.find(".addon-gui-keys-key").val();
+                        return {
+                            target: target,
+                            key: key,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-saveScreenshot
+                {
+                    name: "addon:GUI-saveScreenshot",
+                    label: "GUI-saveScreenshot",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-saveScreenshot-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-saveScreenshot-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: url(option)
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-saveScreenshot-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-saveScreenshot-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("url").appendTo(span1);
+                        var urlField = $("<input/>", {
+                            placeholder: "(option) http://<target page>",
+                            type: "text",
+                            class: "addon-gui-saveScreenshot-url",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.url) {
+                            urlField.val(data.url);
+                        }
+
+                        // row2: filepath
+                        var row2 = $("<div/>", {
+                            class: "addon-gui-saveScreenshot-div2"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span2 = $("<span/>", {
+                            class: "addon-gui-saveScreenshot-span2"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row2);
+                        $("<label/>", {
+                        }).css({
+                            display: "inline-block",
+                            "text-align": "right",
+                            width: "100px"
+                        }).text("filepath").appendTo(span2);
+                        var filepathField = $("<input/>", {
+                            placeholder: "image file path (.png suffix is required)",
+                            type: "text",
+                            class: "addon-gui-saveScreenshot-filepath",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span2);
+                        if (data && data.filepath) {
+                            filepathField.val(data.filepath);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-saveScreenshot-span0");
+                        var row1 = row0.find(".addon-gui-saveScreenshot-div1");
+                        var row2 = row0.find(".addon-gui-saveScreenshot-div2");
+                        span0.show();
+                        row1.show();
+                        row2.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-saveScreenshot-span0");
+                        var row1 = row0.find(".addon-gui-saveScreenshot-div1");
+                        var row2 = row0.find(".addon-gui-saveScreenshot-div2");
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-saveScreenshot-target").val();
+                        var url = con.find(".addon-gui-saveScreenshot-url").val();
+                        var filepath = con.find(".addon-gui-saveScreenshot-filepath").val();
+                        return {
+                            target: target,
+                            url: url,
+                            filepath: filepath,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-setCookies
+                {
+                    name: "addon:GUI-setCookies",
+                    label: "GUI-setCookies",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-setCookies-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-setCookies-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: cookie
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-setCookies-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-setCookies-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("cookie").appendTo(span1);
+                        var cookieField = $("<input/>", {
+                            placeholder: "cookies settings",
+                            class: "addon-gui-setCookies-cookie",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        $(cookieField).typedInput({
+                            default: "json",
+                            types: [
+                                "json"
+                            ]
+                        });
+                        if (data && data.cookie) {
+                            $(cookieField).typedInput("value", data.cookie);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-setCookies-span0");
+                        var row1 = row0.find(".addon-gui-setCookies-div1");
+                        span0.show();
+                        row1.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-setCookies-span0");
+                        var row1 = row0.find(".addon-gui-setCookies-div1");
+                        span0.hide();
+                        row1.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-setCookies-target").val();
+                        var cookie = con.find(".addon-gui-setCookies-cookie").typedInput("value");
+                        return {
+                            target: target,
+                            cookie : cookie,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-setTimeout
+                {
+                    name: "addon:GUI-setTimeout",
+                    label: "GUI-setTimeout",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-setTimeout-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-setTimeout-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: timeout
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-setTimeout-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-setTimeout-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("timeout").appendTo(span1);
+                        var timeoutField = $("<input/>", {
+                            placeholder: "timeouts settings",
+                            class: "addon-gui-setTimeout-timeout",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        $(timeoutField).typedInput({
+                            default: "json",
+                            types: [
+                                "json"
+                            ]
+                        });
+                        if (data && data.timeout) {
+                            $(timeoutField).typedInput("value", data.timeout);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-setTimeout-span0");
+                        var row1 = row0.find(".addon-gui-setTimeout-div1");
+                        span0.show();
+                        row1.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-setTimeout-span0");
+                        var row1 = row0.find(".addon-gui-setTimeout-div1");
+                        span0.hide();
+                        row1.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-setTimeout-target").val();
+                        var timeout = con.find(".addon-gui-setTimeout-timeout").typedInput("value");
+                        return {
+                            target: target,
+                            timeout: timeout,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-waitUntil
+                {
+                    name: "addon:GUI-waitUntil",
+                    label: "GUI-waitUntil",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-waitUntil-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-waitUntil-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: selector
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-waitUntil-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-waitUntil-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("selector").appendTo(span1);
+                        var selectorField = $("<input/>", {
+                            placeholder: "element selector",
+                            type: "text",
+                            class: "addon-gui-waitUntil-selector",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.selector) {
+                            selectorField.val(data.selector);
+                        }
+
+                        // row2: value
+                        var row2 = $("<div/>", {
+                            class: "addon-gui-waitUntil-div2"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span2 = $("<span/>", {
+                            class: "addon-gui-waitUntil-span2"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row2);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("value").appendTo(span2);
+                        var valueField = $("<input/>", {
+                            placeholder: "element value or regexp",
+                            type: "text",
+                            class: "addon-gui-waitUntil-value",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span2);
+                        $(valueField).typedInput({
+                            default: "str",
+                            types: [
+                                "str","re"
+                            ]
+                        });
+                        if (data && data.value && data.type) {
+                            $(valueField).typedInput("value", data.value);
+                            $(valueField).typedInput("type", data.type);
+                        }
+
+                        // row3: timeout
+                        var row3 = $("<div/>", {
+                            class: "addon-gui-waitUntil-div3"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span3 = $("<span/>", {
+                            class: "addon-gui-waitUntil-span3"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row3);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("timeout").appendTo(span3);
+                        var timeoutField = $("<input/>", {
+                            //placeholder: "",
+                            type: "text",
+                            class: "addon-gui-waitUntil-timeout"
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "105pt"
+                        }).appendTo(span3);
+                        $(timeoutField).typedInput({
+                            default: "num",
+                            types: [
+                                "num"
+                            ]
+                        });
+                        $("<label/>", {
+                        }).css({
+                            "text-align": "left",
+                            width: "100px",
+                            "margin-left": "5px"
+                        }).text("ms").appendTo(span3);
+
+                        if (data && data.timeout) {
+                            $(timeoutField).typedInput("value", data.timeout);
+                        } else {
+                            $(timeoutField).typedInput("value", 5000);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                        row3.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-waitUntil-span0");
+                        var row1 = row0.find(".addon-gui-waitUntil-div1");
+                        var row2 = row0.find(".addon-gui-waitUntil-div2");
+                        var row3 = row0.find(".addon-gui-waitUntil-div3");
+                        span0.show();
+                        row1.show();
+                        row2.show();
+                        row3.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-waitUntil-span0");
+                        var row1 = row0.find(".addon-gui-waitUntil-div1");
+                        var row2 = row0.find(".addon-gui-waitUntil-div2");
+                        var row3 = row0.find(".addon-gui-waitUntil-div3");
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                        row3.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-waitUntil-target").val();
+                        var selector = con.find(".addon-gui-waitUntil-selector").val();
+                        var type = con.find(".addon-gui-waitUntil-value").typedInput("type");
+                        var value = con.find(".addon-gui-waitUntil-value").typedInput("value");
+                        var timeout = con.find(".addon-gui-waitUntil-timeout").typedInput("value");
+                        return {
+                            target: target,
+                            selector: selector,
+                            type: type,
+                            value: value,
+                            timeout: timeout,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-addValue
+                {
+                    name: "addon:GUI-addValue",
+                    label: "GUI-addValue",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-addValue-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-addValue-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: selector
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-addValue-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-addValue-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("selector").appendTo(span1);
+                        var selectorField = $("<input/>", {
+                            placeholder: "element selector",
+                            type: "text",
+                            class: "addon-gui-addValue-selector",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.selector) {
+                            selectorField.val(data.selector);
+                        }
+
+                        // row2: value
+                        var row2 = $("<div/>", {
+                            class: "addon-gui-addValue-div2"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span2 = $("<span/>", {
+                            class: "addon-gui-addValue-span2"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row2);
+                        $("<label/>", {
+                        }).css({
+                            display: "inline-block",
+                            "text-align": "right",
+                            width: "100px"
+                        }).text("value").appendTo(span2);
+                        var valueField = $("<input/>", {
+                            placeholder: "value to add",
+                            type: "text",
+                            class: "addon-gui-addValue-value",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span2);
+                        $(valueField).typedInput({
+                            default: "str",
+                            types: [
+                                "str", "num", "bool"
+                            ]
+                        });
+                        if (data && data.value) {
+                            $(valueField).typedInput("value", data.value);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-addValue-span0");
+                        var row1 = row0.find(".addon-gui-addValue-div1");
+                        var row2 = row0.find(".addon-gui-addValue-div2");
+                        span0.show();
+                        row1.show();
+                        row2.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-addValue-span0");
+                        var row1 = row0.find(".addon-gui-addValue-div1");
+                        var row2 = row0.find(".addon-gui-addValue-div2");
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-addValue-target").val();
+                        var selector = con.find(".addon-gui-addValue-selector").val();
+                        var value = con.find(".addon-gui-addValue-value").typedInput("value");
+                        return {
+                            target: target,
+                            selector: selector,
+                            value: value,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-clearValue
+                {
+                    name: "addon:GUI-clearValue",
+                    label: "GUI-clearValue",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-clearValue-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-clearValue-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: selector
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-clearValue-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-clearValue-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("selector").appendTo(span1);
+                        var selectorField = $("<input/>", {
+                            placeholder: "element selector",
+                            type: "text",
+                            class: "addon-gui-clearValue-selector",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.selector) {
+                            selectorField.val(data.selector);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-clearValue-span0");
+                        var row1 = row0.find(".addon-gui-clearValue-div1");
+                        span0.show();
+                        row1.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-clearValue-span0");
+                        var row1 = row0.find(".addon-gui-clearValue-div1");
+                        span0.hide();
+                        row1.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-clearValue-target").val();
+                        var selector = con.find(".addon-gui-clearValue-selector").val();
+                        return {
+                            target: target,
+                            selector: selector,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-click
+                {
+                    name: "addon:GUI-click",
+                    label: "GUI-click",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-click-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-click-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: selector
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-click-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-click-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("selector").appendTo(span1);
+                        var selectorField = $("<input/>", {
+                            placeholder: "element selector",
+                            type: "text",
+                            class: "addon-gui-click-selector",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.selector) {
+                            selectorField.val(data.selector);
+                        }
+
+                        // row2: kind
+                        var row2 = $("<div/>", {
+                            class: "addon-gui-click-div2"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span2 = $("<span/>", {
+                            class: "addon-gui-click-span2"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row2);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("kind").appendTo(span2);
+                        var kindField = $("<select/>", {
+                            placeholder: "value",
+                            type: "text",
+                            class: "addon-gui-click-kind",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "100pt"
+                        }).appendTo(span2);
+                        $(kindField).empty();
+                        $("<option/>").text("click").val("single").appendTo(kindField);
+                        $("<option/>").text("double click").val("double").appendTo(kindField);
+                        if (data && data.clickkind) {
+                            $(kindField).val(data.clickkind);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-click-span0");
+                        var row1 = row0.find(".addon-gui-click-div1");
+                        var row2 = row0.find(".addon-gui-click-div2");
+                        span0.show();
+                        row1.show();
+                        row2.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-click-span0");
+                        var row1 = row0.find(".addon-gui-click-div1");
+                        var row2 = row0.find(".addon-gui-click-div2");
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-click-target").val();
+                        var selector = con.find(".addon-gui-click-selector").val();
+                        var clickkind = con.find(".addon-gui-click-kind").val();
+                        return {
+                            target: target,
+                            selector: selector,
+                            clickkind: clickkind,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-getValue
+                {
+                    name: "addon:GUI-getValue",
+                    label: "GUI-getValue",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-getValue-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-getValue-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: selector
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-getValue-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-getValue-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("selector").appendTo(span1);
+                        var selectorField = $("<input/>", {
+                            placeholder: "element selector",
+                            type: "text",
+                            class: "addon-gui-getValue-selector",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.selector) {
+                            selectorField.val(data.selector);
+                        }
+
+                        // row2: kind
+                        var row2 = $("<div/>", {
+                            class: "addon-gui-getValue-div2"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span2 = $("<span/>", {
+                            class: "addon-gui-getValue-span2"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row2);
+                        $("<label/>", {
+                        }).css({
+                            display: "inline-block",
+                            "text-align": "right",
+                            width: "100px"
+                        }).text("kind").appendTo(span2);
+                        var kindField = $("<select/>", {
+                            placeholder: "value",
+                            type: "text",
+                            class: "addon-gui-getValue-kind",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "100pt"
+                        }).appendTo(span2);
+                        $(kindField).empty();
+                        $("<option/>").text("attribute").val("attr").appendTo(kindField);
+                        $("<option/>").text("property").val("prop").appendTo(kindField);
+                        $("<option/>").text("tag").val("tag").appendTo(kindField);
+                        $("<option/>").text("text").val("text").appendTo(kindField);
+                        $("<option/>").text("value").val("val").appendTo(kindField);
+                        if (data && data.getkind) {
+                            $(kindField).val(data.getkind);
+                        }
+
+                        // row3: name(option prop or attr)
+                        var row3 = $("<div/>", {
+                            class: "addon-gui-getValue-div3"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span3 = $("<span/>", {
+                            class: "addon-gui-getValue-span3"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row3);
+                        $("<label/>", {
+                        }).css({
+                            display: "inline-block",
+                            "text-align": "right",
+                            width: "100px"
+                        }).text("name").appendTo(span3);
+                        var getnameField = $("<input/>", {
+                            placeholder: "name for properties or attributes",
+                            type: "text",
+                            class: "addon-gui-getValue-name",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span3);
+                        if (data && data.getname) {
+                            getnameField.val(data.getname);
+                        }
+
+                        // row4: loc
+                        var row4 = $("<div/>", {
+                            class: "addon-gui-getValue-div4"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span4 = $("<span/>", {
+                            class: "addon-gui-getValue-span4"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row4);
+                        $("<label/>", {
+                        }).css({
+                            display: "inline-block",
+                            "text-align": "right",
+                            width: "100px"
+                        }).text("loc").appendTo(span4);
+                        var locField = $("<input/>", {
+                            placeholder: "store value name",
+                            class: "addon-gui-getValue-loc"
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span4);
+                        $(locField).typedInput({
+                            default: "flow",
+                            types: [
+                                "flow", "global"
+                            ]
+                        });
+                        if (data && data.type && data.value) {
+                            $(locField).typedInput("type", data.type);
+                            $(locField).typedInput("value", data.value);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                        row3.hide();
+                        row4.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-getValue-span0");
+                        var row1 = row0.find(".addon-gui-getValue-div1");
+                        var row2 = row0.find(".addon-gui-getValue-div2");
+                        var row3 = row0.find(".addon-gui-getValue-div3");
+                        var row4 = row0.find(".addon-gui-getValue-div4");
+                        span0.show();
+                        row1.show();
+                        row2.show();
+                        row3.show();
+                        row4.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-getValue-span0");
+                        var row1 = row0.find(".addon-gui-getValue-div1");
+                        var row2 = row0.find(".addon-gui-getValue-div2");
+                        var row3 = row0.find(".addon-gui-getValue-div3");
+                        var row4 = row0.find(".addon-gui-getValue-div4");
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                        row3.hide();
+                        row4.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-getValue-target").val();
+                        var selector = con.find(".addon-gui-getValue-selector").val();
+                        var getkind = con.find(".addon-gui-getValue-kind").val();
+                        var getname = con.find(".addon-gui-getValue-name").val();
+                        var type = con.find(".addon-gui-getValue-loc").typedInput("type");
+                        var value = con.find(".addon-gui-getValue-loc").typedInput("value");
+                        return {
+                            target: target,
+                            selector: selector,
+                            getkind: getkind,
+                            getname: getname,
+                            type: type,
+                            value: value,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-moveTo
+                {
+                    name: "addon:GUI-moveTo",
+                    label: "GUI-moveTo",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-moveTo-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-moveTo-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: selector
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-moveTo-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-moveTo-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("selector").appendTo(span1);
+                        var selectorField = $("<input/>", {
+                            placeholder: "element selector",
+                            type: "text",
+                            class: "addon-gui-moveTo-selector",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.selector) {
+                            selectorField.val(data.selector);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-moveTo-span0");
+                        var row1 = row0.find(".addon-gui-moveTo-div1");
+                        span0.show();
+                        row1.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-moveTo-span0");
+                        var row1 = row0.find(".addon-gui-moveTo-div1");
+                        span0.hide();
+                        row1.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-moveTo-target").val();
+                        var selector = con.find(".addon-gui-moveTo-selector").val();
+                        return {
+                            target: target,
+                            selector: selector,
+                            performCheck: false
+                        };
+                    }
+                },
+                // plugin for GUI-setValue
+                {
+                    name: "addon:GUI-setValue",
+                    label: "GUI-setValue",
+                    onAddItem: function (opt) {
+                        // opt contains:
+                        // - node: target node
+                        // - event: event name
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        // - data: initial data
+                        var node = opt.node;
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var data = opt.data;
+
+                        // row0: target
+                        var span0 = $("<span/>", {
+                            class: "addon-gui-setValue-span0"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row0);
+                        var targetField = $("<input/>", {
+                            placeholder: "browser instance name",
+                            type: "text",
+                            class: "addon-gui-setValue-target",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "8px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span0);
+                        if (data && data.target) {
+                            targetField.val(data.target);
+                        }
+
+                        // row1: selector
+                        var row1 = $("<div/>", {
+                            class: "addon-gui-setValue-div1"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span1 = $("<span/>", {
+                            class: "addon-gui-setValue-span1"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row1);
+                        $("<label/>", {
+                        }).css({
+                           display: "inline-block",
+                           "text-align": "right",
+                           width: "100px"
+                        }).text("selector").appendTo(span1);
+                        var selectorField = $("<input/>", {
+                            placeholder: "element selector",
+                            type: "text",
+                            class: "addon-gui-setValue-selector",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span1);
+                        if (data && data.selector) {
+                            selectorField.val(data.selector);
+                        }
+
+                        // row2: value
+                        var row2 = $("<div/>", {
+                            class: "addon-gui-setValue-div2"
+                        }).css({
+                            "margin-top": "11px"
+                        }).appendTo(row0);
+                        var span2 = $("<span/>", {
+                            class: "addon-gui-setValue-span2"
+                        }).css({
+                            "margin-left": "5px"
+                        }).appendTo(row2);
+                        $("<label/>", {
+                        }).css({
+                            display: "inline-block",
+                            "text-align": "right",
+                            width: "100px"
+                        }).text("value").appendTo(span2);
+                        var valueField = $("<input/>", {
+                            placeholder: "value to set",
+                            type: "text",
+                            class: "addon-gui-setValue-value",
+                        }).css({
+                            display: "inline-block",
+                            "margin-left": "13px",
+                            width: "calc(100% - 130px)"
+                        }).appendTo(span2);
+                        $(valueField).typedInput({
+                            default: "str",
+                            types: [
+                                "str", "num", "bool"
+                            ]
+                        });
+                        if (data && data.value) {
+                            $(valueField).typedInput("value", data.value);
+                        }
+
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                        return true;
+                    },
+                    onSelect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-setValue-span0");
+                        var row1 = row0.find(".addon-gui-setValue-div1");
+                        var row2 = row0.find(".addon-gui-setValue-div2");
+                        span0.show();
+                        row1.show();
+                        row2.show();
+                    },
+                    onUnselect: function (opt) {
+                        // opt contains:
+                        // - container: container of editable list,
+                        // - selectRow: first row of the container
+                        var con = opt.container;
+                        var row0 = opt.selectRow;
+                        var span0 = row0.find(".addon-gui-setValue-span0");
+                        var row1 = row0.find(".addon-gui-setValue-div1");
+                        var row2 = row0.find(".addon-gui-setValue-div2");
+                        span0.hide();
+                        row1.hide();
+                        row2.hide();
+                    },
+                    onSave: function (con) {
+                        var target = con.find(".addon-gui-setValue-target").val();
+                        var selector = con.find(".addon-gui-setValue-selector").val();
+                        var value = con.find(".addon-gui-setValue-value").typedInput("value");
+                        return {
+                            target: target,
+                            selector: selector,
+                            value: value,
+                            performCheck: false
+                        };
+                    }
+                }
+            ];
+        }
+    });
+})();
+</script>
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.js b/examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.js
new file mode 100644
index 0000000..faac1ad
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-gui-addon/src/flow-tester-gui-addon.js
@@ -0,0 +1,617 @@
+module.exports = (RED) => {
+    "use strict";
+
+    // WebDriver object
+    const { remote } = require('webdriverio');
+    const promisify = require("util").promisify;
+
+
+    // Browser instance
+    var browser_instances = [];
+
+    // Get a browser instance
+    async function getBrowser(target) {
+        let key = "_default";
+        if (target) {
+            key = target;
+        } 
+        let browser = browser_instances[key] || null;
+        if (!browser) {
+            browser = await remote({
+                capabilities: {
+                    browserName: 'chrome'
+                }
+            })
+            browser_instances[key] = browser;
+        }
+        return browser; 
+    }
+
+    async function testClose(){ 
+        for (let key in browser_instances) {
+            let browser = browser_instances[key];
+            await browser.deleteSession();
+            delete browser_instances[key];
+        }
+    }
+
+    function testClear(){ 
+        for (let key in browser_instances) {
+            delete browser_instances[key];
+        }
+    }
+
+    console.log("; Initialize flow tester gui addon");
+    RED.plugins.registerPlugin('node-red-flow-tester-gui-addon', {
+        type: "flow-tester-addon",
+        actions: function () {
+            return [
+                {
+                    name: "addon:GUI-URL",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            // Close all browser instances after test
+                            ;(async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                    //reject(err.message);
+                                }
+                            })()
+                        })
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            // Perform an operation on an object with the specified instance name
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    if (action.size) {
+                                        const size = action.size.split(',');
+                                        await browser.setWindowSize(Number(size[0]),Number(size[1]));
+                                    }
+                                    await browser.url(action.url);
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    },
+                },
+                {
+                    name: "addon:GUI-Keys",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    if (action.key) {
+                                        const keys = action.key.split(',');
+                                        await browser.keys(keys);
+                                    }
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-saveScreenshot",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    if (action.url) {
+                                        // Optional: Open the specified URL
+                                        await browser.url(action.url)
+                                    }
+                                    await browser.saveScreenshot(action.filepath);
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-setCookies",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    const cookies = JSON.parse(action.cookie);
+                                    await browser.setCookies(cookies);
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-setTimeout",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    const timeout = JSON.parse(action.timeout);
+                                    await browser.setTimeout(timeout);
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-waitUntil",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            let  timeout = Number(action.timeout);
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    await browser.waitUntil(
+                                        async () => (
+                                            action.type === "str" && (await browser.$(action.selector).getText() === action.value) || 
+                                            action.type === "re"  && (new RegExp(action.value).test(await browser.$(action.selector).getText()))),
+                                        {
+                                            //timeout: Number(action.timeout),
+                                            timeout: timeout,
+                                            timeoutMsg: 'expected text to be different after ' + action.timeout + "ms"
+                                        }
+                                    );
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-addValue",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    await browser.$(action.selector).addValue(action.value);
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-clearValue",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    await browser.$(action.selector).clearValue();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-click",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    if (action.clickkind === 'single') {
+                                        await browser.$(action.selector).click();
+                                    } else {
+                                        await browser.$(action.selector).doubleClick();
+                                    }
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-getValue",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            const nid = opt.node;
+                            const msg = opt.msg;
+                            const node = nid ? RED.nodes.getNode(nid) : null;
+                            let val = ""
+                            if (!node) {
+                                console.log("Must be run in a node instance test.");
+                                reject("Must be run in a node instance test.");
+                                return;
+                            }
+
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    if (action.getkind === 'attr') {
+                                        val = await browser.$(action.selector).getAttribute(action.getname);
+                                    } else if (action.getkind === 'prop') {
+                                        val = await browser.$(action.selector).getProperty(action.getname);
+                                    } else if (action.getkind === 'tag') {
+                                        val = await browser.$(action.selector).getTagName();
+                                    } else if (action.getkind === 'text') {
+                                        val = await browser.$(action.selector).getText();
+                                    } else if (action.getkind === 'val') {
+                                        val = await browser.$(action.selector).getValue();
+                                    }
+
+                                    switch (action.type) {
+                                        //case "msg":
+                                        //    if (msg) {
+                                        //        RED.util.setMessageProperty(msg, action.value, value);
+                                        //    }
+                                        //    break;
+                                        case "global":
+                                        case "flow":
+                                            const contextKey = RED.util.parseContextStore(action.value);
+                                            if (/\[msg/.test(contextKey.key)) {
+                                                // The key has a nest msg. reference to evaluate first
+                                                contextKey.key = RED.util.normalisePropertyExpression(contextKey.key, msg, true)
+                                            }
+                                            const target = node.context()[action.type];
+                                            const set = promisify(target.set);
+                                            set(contextKey.key, val, contextKey.store);
+                                            break;
+                                        default:
+                                            console.log("unexpected value type: "+ action.type);
+                                            reject("unexpected value type: "+ action.type);
+                                    }
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-moveTo",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    await browser.$(action.selector).moveTo();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                },
+                {
+                    name: "addon:GUI-setValue",
+                    onTestStart: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            testClear();
+                            resolve();
+                        });
+                    },
+                    onTestEnd: function(opt) {
+                        return new Promise((resolve, reject) => {
+                            (async () => {
+                                try {
+                                    await testClose();
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    resolve();
+                                }
+                            })()
+                        });
+                    },
+                    execute: function(opt) {
+                        // opt object contains:
+                        // - data: optional data for action
+                        // - node: target node
+                        // - msg: message object
+                        return new Promise((resolve, reject) => {
+                            const action = opt.action;
+                            (async () => {
+                                try {
+                                    const browser = await getBrowser(action.target);
+                                    await browser.$(action.selector).setValue(action.value);
+                                    resolve();
+                                }catch(err){
+                                    console.log(err);
+                                    reject(err.message);
+                                }
+                            })()
+                        });
+                    }
+                }
+            ];
+        }
+    });
+};
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/src/locales/en-US/flow-tester-gui-addon.json b/examples/node-red-contrib-flow-tester-gui-addon/src/locales/en-US/flow-tester-gui-addon.json
new file mode 100644
index 0000000..3f29600
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-gui-addon/src/locales/en-US/flow-tester-gui-addon.json
@@ -0,0 +1,4 @@
+{
+    "label": {
+    }
+}
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/src/style.css b/examples/node-red-contrib-flow-tester-gui-addon/src/style.css
new file mode 100644
index 0000000..e69de29
diff --git a/examples/node-red-contrib-flow-tester-gui-addon/test/test.js b/examples/node-red-contrib-flow-tester-gui-addon/test/test.js
new file mode 100644
index 0000000..2a4de75
--- /dev/null
+++ b/examples/node-red-contrib-flow-tester-gui-addon/test/test.js
@@ -0,0 +1,2 @@
+describe("Flow tester gui addon tests", function() {
+});