private TreeView<String> generateRandomTree() {
    // create a demonstration tree view to use as the contents for a dock node
    TreeItem<String> root = new TreeItem<String>("Root");
    TreeView<String> treeView = new TreeView<String>(root);
    treeView.setShowRoot(false);

    // populate the prototype tree with some random nodes
    Random rand = new Random();
    for (int i = 4 + rand.nextInt(8); i > 0; i--) {
        TreeItem<String> treeItem = new TreeItem<String>("Item " + i);
        root.getChildren().add(treeItem);
        for (int j = 2 + rand.nextInt(4); j > 0; j--) {
            TreeItem<String> childItem = new TreeItem<String>("Child " + j);
            treeItem.getChildren().add(childItem);
        }
    }

    return treeView;
}
 

private void focusFoundItem(TreeItem<Item> searchFoundItem) {
    if (Objects.nonNull(searchFoundItem)) {

        TreeView<Item> fileSystemView = controller.getFileSystemView();
        threadService.runActionLater(() -> {

            fileSystemView.getSelectionModel().clearSelection();

            int selectedIndex = findIndex(searchFoundItem);

            fileSystemView.getSelectionModel().select(searchFoundItem);

            fileSystemView.scrollTo(selectedIndex);

            TreeItem<Item> parent = searchFoundItem.getParent();
            if (Objects.nonNull(parent)) {
                if (!parent.isExpanded()) {
                    parent.setExpanded(true);
                }
            }
        }, true);
    }
}
 

private void initialiseTreeViewReflection() {

        // we can't use wrapped.getSkin() because it may be null.
        // we don't care about the specific instance, we just want the class
        @SuppressWarnings("PMD.UselessOverridingMethod")
        Skin<?> dftSkin = new TreeView<Object>() {
            @Override
            protected Skin<?> createDefaultSkin() {
                return super.createDefaultSkin();
            }
        }.createDefaultSkin();

        Object flow = getVirtualFlow(dftSkin);

        if (flow == null) {
            return;
        }

        treeViewFirstVisibleMethod = MethodUtils.getMatchingMethod(flow.getClass(), "getFirstVisibleCell");
        treeViewLastVisibleMethod = MethodUtils.getMatchingMethod(flow.getClass(), "getLastVisibleCell");
    }
 

/**
 * 刷新数据源下的 table
 * <p>
 * 对table
 */
private void refreshDataSource(TreeView<DataItem> treeViewDataSource) {
    TreeItem<DataItem> dataSourceTreeItem = treeViewDataSource.getSelectionModel().getSelectedItem();
    DataSource dataSource = (DataSource) dataSourceTreeItem.getValue();
    List<Table> tables = tableService.refreshTables(dataSource);
    if (!tables.isEmpty()) {
        ObservableList<TreeItem<DataItem>> children = dataSourceTreeItem.getChildren();
        children.remove(0, children.size());
        tables.forEach(table -> {
            TreeItem<DataItem> tableTreeItem = TreeUtils.add2Tree(table, dataSourceTreeItem);
            tableTreeItem.setGraphic(new ImageView("/image/table.png"));
        });
    }

    // 关闭右边的 Border 展示
    this.rightBorderShowClose(dataSource);
}
 

/**
 * Customizing treeView
 *
 * @param tree treeView
 */
private void setTreeCellFactory(TreeView<SimpleTreeElement> tree) {
    tree.setCellFactory(param -> new TreeCell<SimpleTreeElement>() {
        @Override
        public void updateItem(SimpleTreeElement item, boolean empty) {
            super.updateItem(item, empty);
            //setDisclosureNode(null);

            if (empty) {
                setText("");
                setGraphic(null);
            } else {
                setText(item.getName());
            }
        }

    });

    tree.getSelectionModel().selectedItemProperty()
            .addListener((observable, oldValue, newValue) -> {
                if (newValue != null) {
                    System.out.println(newValue.getValue());
                }
            });
}
 

/**
 * 点击处理方法.
 *
 * @param treeView treeView
 */
@Override
protected void setAction(TreeView treeView) {
    super.setOnAction(
        (event) -> {
            TreeItem<Label> item = (TreeItem) treeView.getSelectionModel().getSelectedItem();
            String flag = item.getValue().getAccessibleHelp();
            if ("link".equals(flag)) {
                String poolId = item.getValue().getAccessibleText();
                ConnectPanel connectPanel = new ConnectPanel();
                connectPanel.isNewLink(false);
                connectPanel.showConnectPanel(poolId);
            }
        }
    );
}
 

@Override
public void start(Stage primaryStage) {
    TreeView<Path> view = new TreeView<>();
    view.setShowRoot(false);

    try {
        // create a LiveDirs instance for use on the JavaFX Application Thread
        LiveDirs<ChangeSource, Path> dirs = LiveDirs.getInstance(ChangeSource.EXTERNAL);

        // set directory to watch
        dirs.addTopLevelDirectory(Paths.get(System.getProperty("user.home"), "Documents").toAbsolutePath());
        view.setRoot(dirs.model().getRoot());

        // stop DirWatcher's thread
        primaryStage.setOnCloseRequest(val -> dirs.dispose());
    } catch (IOException e) {
        e.printStackTrace();
    }

    primaryStage.setScene(new Scene(view, 500, 500));
    primaryStage.show();
}
 

private Node createTree() {
    VBox treeContentBox = new VBox();
    tree.setRoot(functionInfo.getRoot(true));
    tree.setShowRoot(false);
    tree.getSelectionModel().selectedItemProperty().addListener(new TreeViewSelectionChangeListener());
    tree.setCellFactory(new Callback<TreeView<Object>, TreeCell<Object>>() {
        @Override
        public TreeCell<Object> call(TreeView<Object> param) {
            return new FunctionTreeCell();
        }
    });
    filterByName.setOnAction((e) -> {
        tree.setRoot(functionInfo.refreshNode(filterByName.isSelected()));
        expandAll();
    });
    filterByName.setSelected(true);
    expandAll();
    treeContentBox.getChildren().addAll(topButtonBar, tree, filterByName);
    VBox.setVgrow(tree, Priority.ALWAYS);
    return treeContentBox;
}
 

private TreeView<String> generateRandomTree() {
  // create a demonstration tree view to use as the contents for a dock node
  TreeItem<String> root = new TreeItem<String>("Root");
  TreeView<String> treeView = new TreeView<String>(root);
  treeView.setShowRoot(false);

  // populate the prototype tree with some random nodes
  Random rand = new Random();
  for (int i = 4 + rand.nextInt(8); i > 0; i--) {
    TreeItem<String> treeItem = new TreeItem<String>("Item " + i);
    root.getChildren().add(treeItem);
    for (int j = 2 + rand.nextInt(4); j > 0; j--) {
      TreeItem<String> childItem = new TreeItem<String>("Child " + j);
      treeItem.getChildren().add(childItem);
    }
  }

  return treeView;
}
 

public int getRowAt(TreeView<?> treeView, Point2D point) {
    if (point == null) {
        return treeView.getSelectionModel().getSelectedIndex();
    }
    point = treeView.localToScene(point);
    int itemCount = treeView.getExpandedItemCount();
    @SuppressWarnings("rawtypes")
    List<TreeCell> cells = new ArrayList<>();
    for (int i = 0; i < itemCount; i++) {
        cells.add(getCellAt(treeView, i));
    }
    TreeCell<?> selected = null;
    for (Node cellNode : cells) {
        Bounds boundsInScene = cellNode.localToScene(cellNode.getBoundsInLocal(), true);
        if (boundsInScene.contains(point)) {
            selected = (TreeCell<?>) cellNode;
            break;
        }
    }
    if (selected == null) {
        return -1;
    }
    return selected.getIndex();
}
 

@Override
public List<IJavaFXElement> getByPseudoElement(String selector, Object[] params) {
    if (selector.equals("select-by-properties")) {
        return findNodeByProperties(new JSONObject((String) params[0]));
    } else if (selector.equals("root")) {
        return Arrays.asList(new JavaFXTreeViewNodeElement(this, 0));
    } else if (selector.equals("nth-node")) {
        return Arrays.asList(new JavaFXTreeViewNodeElement(this, ((Integer) params[0]).intValue() - 1));
    } else if (selector.equals("all-nodes")) {
        TreeView<?> treeView = (TreeView<?>) getComponent();
        ArrayList<IJavaFXElement> r = new ArrayList<>();
        int nrows = treeView.getExpandedItemCount();
        for (int i = 0; i < nrows; i++) {
            r.add(new JavaFXTreeViewNodeElement(this, i));
        }
        return r;
    }
    return super.getByPseudoElement(selector, params);
}
 

public FXTree()
{
    tree_view = new TreeView<>();
    tree_view.setCellFactory(cell -> new TreeModelItemCell());

    // Publish currently selected PV
    tree_view.getSelectionModel().selectedItemProperty().addListener((prop, old_item, selected) ->
    {
        ProcessVariable selection = null;
        if (selected != null)
        {
            final TreeModelItem item = selected.getValue();
            if (item.getSeverity() != null)
                selection = new ProcessVariable(item.getPVName());
        }
        SelectionService.getInstance().setSelection("PVTree", selection == null ? Collections.emptyList() : Arrays.asList(selection));
    });

    // Provide context menu
    createContextMenu();

    model.addListener(model_listener);
}
 

@SuppressWarnings("unchecked")
private boolean setSelectionPath(String value) {
    TreeView<?> treeView = (TreeView<?>) getComponent();
    JSONArray pathElements = new JSONArray(value);
    List<TreeItem<?>> paths = new ArrayList<>();
    for (int i = 0; i < pathElements.length(); i++) {
        paths.add(getPath(treeView, pathElements.getString(i)));
    }
    treeView.getSelectionModel().clearSelection();
    for (@SuppressWarnings("rawtypes")
    TreeItem treeItem : paths) {
        if (getVisibleCellAt(treeView, treeItem) == null) {
            treeView.scrollTo(treeView.getRow(treeItem));
        }
        treeView.getSelectionModel().select(treeItem);
    }
    return true;
}
 

@SuppressWarnings("unchecked")
@Override
public List<IJavaFXElement> getByPseudoElement(String selector, Object[] params) {
    TreeView<?> treeView = (TreeView<?>) getComponent();
    @SuppressWarnings("rawtypes")
    TreeItem item = getPath(treeView, path);
    if (item == null)
        return Arrays.asList();
    if (getVisibleCellAt(treeView, item) == null) {
        EventQueueWait.exec(() -> treeView.scrollTo(treeView.getRow(item)));
        return Arrays.asList();
    }
    if (selector.equals("editor")) {
        return Arrays.asList(JavaFXElementFactory.createElement(getEditor(), driver, window));
    }
    return super.getByPseudoElement(selector, params);
}
 

private TreeView<String> generateRandomTree() {
    // create a demonstration tree view to use as the contents for a dock node
    TreeItem<String> root = new TreeItem<String>("Root");
    TreeView<String> treeView = new TreeView<String>(root);
    treeView.setShowRoot(false);

    // populate the prototype tree with some random nodes
    Random rand = new Random();
    for (int i = 4 + rand.nextInt(8); i > 0; i--) {
        TreeItem<String> treeItem = new TreeItem<String>("Item " + i);
        root.getChildren().add(treeItem);
        for (int j = 2 + rand.nextInt(4); j > 0; j--) {
            TreeItem<String> childItem = new TreeItem<String>("Child " + j);
            treeItem.getChildren().add(childItem);
        }
    }

    return treeView;
}
 

/**
 * Generate treeView of file items
 * TODO: work with VUFS items
 *
 * @return tree view
 */
public TreeView<SimpleTreeElement> getSimple() {
    TreeView<SimpleTreeElement> tree = new TreeView<>();
    TreeItem<SimpleTreeElement> root = new TreeItem<>(new SimpleTreeElement("root", 0));
    TreeItem<SimpleTreeElement> outer1 =
            makeBranch(new SimpleTreeElement("Folder1", 1), root);
    TreeItem<SimpleTreeElement> outer2 =
            makeBranch(new SimpleTreeElement("Documents", 2), root);
    TreeItem<SimpleTreeElement> inner1;
    TreeItem<SimpleTreeElement> inner2;

    makeBranch(new SimpleTreeElement("MyFotos", 3), outer1);
    makeBranch(new SimpleTreeElement("OtherFiles", 4), outer1);
    makeBranch(new SimpleTreeElement("WorkFiles", 5), root);
    makeBranch(new SimpleTreeElement("Projects", 6), root);

    tree.setRoot(root);
    tree.setPrefWidth(200);

    setTreeCellFactory(tree);

    tree.setShowRoot(false);
    return tree;

}
 

@Test
public void selectTreeItemCheckBoxSelectedNotSelected() {
    TreeView<?> treeViewNode = (TreeView<?>) getPrimaryStage().getScene().getRoot().lookup(".tree-view");
    CheckBoxTreeItem<?> treeItem = (CheckBoxTreeItem<?>) treeViewNode.getTreeItem(2);
    treeItem.setSelected(true);
    JSONObject o = new JSONObject();
    o.put("select", "/Root node/Child Node 2");
    IJavaFXElement item = treeView.findElementByCssSelector(".::select-by-properties('" + o.toString() + "')");
    IJavaFXElement cb = item.findElementByCssSelector(".::editor");
    cb.marathon_select("Child Node 2:unchecked");
    new Wait("Wait for tree item check box to be deselected") {
        @Override
        public boolean until() {
            String selected = cb.getAttribute("selected");
            return selected.equals("false");
        }
    };
}
 

@Test
public void marathon_select_none() throws Throwable {
    TreeView<?> treeViewNode = (TreeView<?>) getPrimaryStage().getScene().getRoot().lookup(".tree-view");
    Platform.runLater(() -> treeView.marathon_select("[\"/Root node/Child Node 2\"]"));
    new Wait("Waiting for the text item to be selected.") {
        @Override
        public boolean until() {
            return 2 == treeViewNode.getSelectionModel().getSelectedIndex();
        }
    };
    Platform.runLater(() -> treeView.marathon_select("[]"));
    new Wait("Waiting for no items selected.") {
        @Override
        public boolean until() {
            return 0 == treeViewNode.getSelectionModel().getSelectedIndices().size();
        }
    };
}
 

@Override
protected JComponent getCenter()
{
	// Build the settings panel
	JPanel emptyPanel = new JPanel();
	emptyPanel.setPreferredSize(new Dimension(780, 420));

	settingsTree = new TreeView<>();
	settingsTree.setRoot(new TreeItem<>(null));

	// Build the split pane
	splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, GuiUtility.wrapParentAsJFXPanel(settingsTree),
			emptyPanel
	);
	splitPane.setOneTouchExpandable(true);
	splitPane.setDividerSize(10);

	return splitPane;
}
 

public TreeViewSample() {
    final TreeItem<String> treeRoot = new TreeItem<String>("Root node");
    treeRoot.getChildren().addAll(Arrays.asList(
            new TreeItem<String>("Child Node 1"),
            new TreeItem<String>("Child Node 2"),
            new TreeItem<String>("Child Node 3")));

    treeRoot.getChildren().get(2).getChildren().addAll(Arrays.asList(
            new TreeItem<String>("Child Node 4"),
            new TreeItem<String>("Child Node 5"),
            new TreeItem<String>("Child Node 6"),
            new TreeItem<String>("Child Node 7"),
            new TreeItem<String>("Child Node 8"),
            new TreeItem<String>("Child Node 9"),
            new TreeItem<String>("Child Node 10"),
            new TreeItem<String>("Child Node 11"),
            new TreeItem<String>("Child Node 12")));

    final TreeView treeView = new TreeView();
    treeView.setShowRoot(true);
    treeView.setRoot(treeRoot);
    treeRoot.setExpanded(true);

    getChildren().add(treeView);
}
 

public TextFieldTreeViewSample() {
    final TreeItem<String> treeRoot = new TreeItem<String>("Root node");
    treeRoot.getChildren().addAll(Arrays.asList(new TreeItem<String>("Child Node 1"), new TreeItem<String>("Child Node 2"),
            new TreeItem<String>("Child Node 3")));

    treeRoot.getChildren().get(2).getChildren().addAll(Arrays.asList(new TreeItem<String>("Child Node 4"),
            new TreeItem<String>("Child Node 5"), new TreeItem<String>("Child Node 6"), new TreeItem<String>("Child Node 7"),
            new TreeItem<String>("Child Node 8"), new TreeItem<String>("Child Node 9"), new TreeItem<String>("Child Node 10"),
            new TreeItem<String>("Child Node 11"), new TreeItem<String>("Child Node 12")));

    final TreeView treeView = new TreeView();
    treeView.setShowRoot(true);
    treeView.setRoot(treeRoot);
    treeRoot.setExpanded(true);
    treeView.setEditable(true);
    treeView.setCellFactory(TextFieldTreeCell.forTreeView());

    getChildren().add(treeView);
}
 

public ChoiceBoxTreeViewSample() {
    final TreeItem<String> treeRoot = new TreeItem<String>("Root node");
    treeRoot.getChildren().addAll(Arrays.asList(new TreeItem<String>("Option 1"), new TreeItem<String>("Option 2"),
            new TreeItem<String>("Option 3")));

    treeRoot.getChildren().get(2).getChildren().addAll(Arrays.asList(new TreeItem<String>("Option 4"),
            new TreeItem<String>("Option 5"), new TreeItem<String>("Option 6")));

    final TreeView treeView = new TreeView();
    treeView.setShowRoot(true);
    treeView.setRoot(treeRoot);
    treeRoot.setExpanded(true);
    treeView.setEditable(true);
    treeView.setCellFactory(ChoiceBoxTreeCell.forTreeView(items));

    getChildren().add(treeView);
}
 

public ComboBoxTreeViewSample() {
    final TreeItem<String> treeRoot = new TreeItem<String>("Root node");
    treeRoot.getChildren().addAll(Arrays.asList(new TreeItem<String>("Option 1"), new TreeItem<String>("Option 2"),
            new TreeItem<String>("Option 3")));

    treeRoot.getChildren().get(2).getChildren().addAll(Arrays.asList(new TreeItem<String>("Option 4"),
            new TreeItem<String>("Option 5"), new TreeItem<String>("Option 6")));

    final TreeView treeView = new TreeView();
    treeView.setShowRoot(true);
    treeView.setRoot(treeRoot);
    treeRoot.setExpanded(true);
    treeView.setEditable(true);
    treeView.setCellFactory(ComboBoxTreeCell.forTreeView(items));

    getChildren().add(treeView);
}
 

public CheckBoxTreeViewSample() {
    final CheckBoxTreeItem<String> treeRoot = new CheckBoxTreeItem<String>("Root node");
    treeRoot.getChildren().addAll(Arrays.asList(new CheckBoxTreeItem<String>("Child Node 1"),
            new CheckBoxTreeItem<String>("Child Node 2"), new CheckBoxTreeItem<String>("Child Node 3")));

    treeRoot.getChildren().get(2).getChildren()
            .addAll(Arrays.asList(new CheckBoxTreeItem<String>("Child Node 4"), new CheckBoxTreeItem<String>("Child Node 5"),
                    new CheckBoxTreeItem<String>("Child Node 6"), new CheckBoxTreeItem<String>("Child Node 7"),
                    new TreeItem<String>("Child Node 8"), new CheckBoxTreeItem<String>("Child Node 9"),
                    new CheckBoxTreeItem<String>("Child Node 10"), new CheckBoxTreeItem<String>("Child Node 11"),
                    new CheckBoxTreeItem<String>("Child Node 12")));

    final TreeView treeView = new TreeView();
    treeView.setCellFactory(CheckBoxTreeCell.forTreeView());
    treeView.setShowRoot(true);
    treeView.setRoot(treeRoot);
    treeRoot.setExpanded(true);

    getChildren().add(treeView);
}
 

public TreeViewSample1() {
    final TreeItem<String> treeRoot = new TreeItem<String>("Root node");
    treeRoot.getChildren().addAll(Arrays.asList(new TreeItem<String>("Child Node 1"), new TreeItem<String>("Child Node 2"),
            new TreeItem<String>("Child Node 3")));

    treeRoot.getChildren().get(2).getChildren().addAll(Arrays.asList(new TreeItem<String>("Child Node 4"),
            new TreeItem<String>("Child Node 5"), new TreeItem<String>("Child Node 6"), new TreeItem<String>("Child Node 7"),
            new TreeItem<String>("Child Node 8"), new TreeItem<String>("Child Node 9"), new TreeItem<String>("Child Node 10"),
            new TreeItem<String>("Child Node 11"), new TreeItem<String>("Child Node 12"), new TreeItem<String>("Child Node 13"),
            new TreeItem<String>("Child Node 14"), new TreeItem<String>("Child Node 15"), new TreeItem<String>("Child Node 16"),
            new TreeItem<String>("Child Node 17"), new TreeItem<String>("Child Node 18"), new TreeItem<String>("Child Node 19"),
            new TreeItem<String>("Child Node 20"), new TreeItem<String>("Child Node 21"), new TreeItem<String>("Child Node 22"),
            new TreeItem<String>("Child Node 23"), new TreeItem<String>("Child Node 24")));

    final TreeView treeView = new TreeView();
    treeView.setShowRoot(true);
    treeView.setRoot(treeRoot);
    treeRoot.setExpanded(true);

    getChildren().add(treeView);
}
 

@Test
public void getText() {
    @SuppressWarnings("rawtypes")
    TreeView treeView = (TreeView) getPrimaryStage().getScene().getRoot().lookup(".tree-view");
    LoggingRecorder lr = new LoggingRecorder();
    List<String> text = new ArrayList<>();
    Platform.runLater(new Runnable() {
        @Override
        public void run() {
            RFXTreeView rTreeView = new RFXTreeView(treeView, null, null, lr);
            treeView.getSelectionModel().select(2);
            rTreeView.focusLost(new RFXTreeView(null, null, null, null));
            text.add(rTreeView.getAttribute("text"));
        }
    });
    new Wait("Waiting for tree text.") {
        @Override
        public boolean until() {
            return text.size() > 0;
        }
    };
    AssertJUnit.assertEquals("[\"/Root node/Child Node 2\"]", text.get(0));
}
 

@Test
public void getTextForMultipleSelection() {
    @SuppressWarnings("rawtypes")
    TreeView treeView = (TreeView) getPrimaryStage().getScene().getRoot().lookup(".tree-view");
    LoggingRecorder lr = new LoggingRecorder();
    List<String> text = new ArrayList<>();
    Platform.runLater(new Runnable() {
        @Override
        public void run() {
            RFXTreeView rTreeView = new RFXTreeView(treeView, null, null, lr);
            @SuppressWarnings("rawtypes")
            MultipleSelectionModel selectionModel = treeView.getSelectionModel();
            selectionModel.setSelectionMode(SelectionMode.MULTIPLE);
            selectionModel.selectIndices(2, 3);
            rTreeView.focusLost(new RFXTreeView(null, null, null, null));
            text.add(rTreeView.getAttribute("text"));
        }
    });
    new Wait("Waiting for tree text.") {
        @Override
        public boolean until() {
            return text.size() > 0;
        }
    };
    AssertJUnit.assertEquals("[\"/Root node/Child Node 2\",\"/Root node/Child Node 3\"]", text.get(0));
}
 

@Test
public void select() {
    TreeView<?> treeView = (TreeView<?>) getPrimaryStage().getScene().getRoot().lookup(".tree-view");
    LoggingRecorder lr = new LoggingRecorder();
    Platform.runLater(new Runnable() {
        @Override
        public void run() {
            Point2D point = getPoint(treeView, 1);
            RFXTreeView rfxListView = new RFXTreeView(treeView, null, point, lr);
            rfxListView.focusGained(rfxListView);
            CheckBoxTreeItem<?> treeItem = (CheckBoxTreeItem<?>) treeView.getTreeItem(1);
            treeItem.setSelected(true);
            rfxListView.focusLost(rfxListView);
        }
    });
    List<Recording> recordings = lr.waitAndGetRecordings(1);
    Recording recording = recordings.get(0);
    AssertJUnit.assertEquals("recordSelect", recording.getCall());
    AssertJUnit.assertEquals("Child Node 1:checked", recording.getParameters()[0]);
}
 

@Test
public void selectSelectedTreeItemCheckBox() {
    TreeView<?> treeView = (TreeView<?>) getPrimaryStage().getScene().getRoot().lookup(".tree-view");
    LoggingRecorder lr = new LoggingRecorder();
    Platform.runLater(new Runnable() {
        @Override
        public void run() {
            Point2D point = getPoint(treeView, 1);
            RFXTreeView rfxListView = new RFXTreeView(treeView, null, point, lr);
            CheckBoxTreeItem<?> treeItem = (CheckBoxTreeItem<?>) treeView.getTreeItem(1);
            treeItem.setSelected(true);
            rfxListView.focusGained(rfxListView);
            treeItem.setSelected(false);
            rfxListView.focusLost(rfxListView);
        }
    });
    List<Recording> recordings = lr.waitAndGetRecordings(1);
    Recording recording = recordings.get(0);
    AssertJUnit.assertEquals("recordSelect", recording.getCall());
    AssertJUnit.assertEquals("Child Node 1:unchecked", recording.getParameters()[0]);
}
 

@Test
public void select() {
    @SuppressWarnings("unchecked")
    TreeView<String> treeView = (TreeView<String>) getPrimaryStage().getScene().getRoot().lookup(".tree-view");
    LoggingRecorder lr = new LoggingRecorder();
    Platform.runLater(() -> {
        @SuppressWarnings("unchecked")
        TextFieldTreeCell<String> cell = (TextFieldTreeCell<String>) getCellAt(treeView, 2);
        Point2D point = getPoint(treeView, 2);
        RFXTreeView rfxTreeView = new RFXTreeView(treeView, null, point, lr);
        rfxTreeView.focusGained(rfxTreeView);
        cell.startEdit();
        cell.updateItem("Child node 4 Modified", false);
        cell.commitEdit("Child node 4 Modified");
        rfxTreeView.focusLost(rfxTreeView);
    });
    List<Recording> recordings = lr.waitAndGetRecordings(1);
    Recording recording = recordings.get(0);
    AssertJUnit.assertEquals("recordSelect", recording.getCall());
    AssertJUnit.assertEquals("Child node 4 Modified", recording.getParameters()[0]);
}