jdk-sandbox: comparison jdk/test/sanity/client/lib/jemmy/src/org/netbeans/jemmy/operators/JTreeOperator.java

equal deleted inserted replaced

-:bdc3f1b79fb7
+:a00905527ec2
+/*
+* Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
+* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+*
+* This code is free software; you can redistribute it and/or modify it
+* under the terms of the GNU General Public License version 2 only, as
+* published by the Free Software Foundation.
+*
+* This code is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+* version 2 for more details (a copy is included in the LICENSE file that
+* accompanied this code).
+*
+* You should have received a copy of the GNU General Public License version
+* 2 along with this work; if not, write to the Free Software Foundation,
+* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+*
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+* or visit www.oracle.com if you need additional information or have any
+* questions.
+*/
+package org.netbeans.jemmy.operators;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import javax.swing.JPopupMenu;
+import javax.swing.JScrollPane;
+import javax.swing.JTree;
+import javax.swing.event.TreeExpansionListener;
+import javax.swing.event.TreeSelectionListener;
+import javax.swing.event.TreeWillExpandListener;
+import javax.swing.plaf.TreeUI;
+import javax.swing.tree.ExpandVetoException;
+import javax.swing.tree.TreeCellEditor;
+import javax.swing.tree.TreeCellRenderer;
+import javax.swing.tree.TreeModel;
+import javax.swing.tree.TreePath;
+import javax.swing.tree.TreeSelectionModel;
+import org.netbeans.jemmy.ComponentChooser;
+import org.netbeans.jemmy.ComponentSearcher;
+import org.netbeans.jemmy.JemmyException;
+import org.netbeans.jemmy.JemmyInputException;
+import org.netbeans.jemmy.Outputable;
+import org.netbeans.jemmy.QueueTool;
+import org.netbeans.jemmy.TestOut;
+import org.netbeans.jemmy.TimeoutExpiredException;
+import org.netbeans.jemmy.Timeoutable;
+import org.netbeans.jemmy.Timeouts;
+import org.netbeans.jemmy.Waitable;
+import org.netbeans.jemmy.Waiter;
+import org.netbeans.jemmy.drivers.DriverManager;
+import org.netbeans.jemmy.drivers.TreeDriver;
+import org.netbeans.jemmy.util.EmptyVisualizer;
+/**
+* <BR><BR>Timeouts used: <BR>
+* JTreeOperator.WaitNodeExpandedTimeout - time to wait node expanded <BR>
+* JTreeOperator.WaitNodeCollapsedTimeout - time to wait node collapsed <BR>
+* JTreeOperator.WaitAfterNodeExpandedTimeout - time to to sleep after node
+* expanded <BR>
+* JTreeOperator.WaitNextNodeTimeout - time to wait next node displayed <BR>
+* JTreeOperator.WaitNodeVisibleTimeout - time to wait node visible <BR>
+* JTreeOperator.BeforeEditTimeout - time to sleep before edit click <BR>
+* JTreeOperator.WaitEditingTimeout - time to wait node editing <BR>
+* ComponentOperator.WaitComponentTimeout - time to wait component displayed
+* <BR>
+* ComponentOperator.WaitStateTimeout - time to wait for path to be expanded,
+* collapsed, selected, time to wait for a text in a row <BR>
+* WindowWaiter.WaitWindowTimeout - time to wait popup window displayed <BR>
+* JScrollBarOperator.WholeScrollTimeout - time for the whole scrolling <BR>.
+*
+* @see org.netbeans.jemmy.Timeouts
+*
+* @author Alexandre Iline (alexandre.iline@oracle.com)
+*
+*/
+public class JTreeOperator extends JComponentOperator
+implements Timeoutable, Outputable {
+/**
+* Identifier for a "root" property.
+*
+* @see #getDump
+*/
+public static final String ROOT_DPROP = "Root";
+/**
+* Identifier for a "node" properties.
+*
+* @see #getDump
+*/
+public static final String NODE_PREFIX_DPROP = "Node";
+/**
+* Identifier for a "first selected" property.
+*
+* @see #getDump
+*/
+public static final String SELECTION_FIRST_DPROP = "First selected";
+/**
+* Identifier for a "last selected" property.
+*
+* @see #getDump
+*/
+public static final String SELECTION_LAST_DPROP = "Last selected";
+private final static long WAIT_NODE_EXPANDED_TIMEOUT = 60000;
+private final static long WAIT_NODE_COLLAPSED_TIMEOUT = 60000;
+private final static long WAIT_AFTER_NODE_EXPANDED_TIMEOUT = 0;
+private final static long WAIT_NEXT_NODE_TIMEOUT = 60000;
+private final static long WAIT_NODE_VISIBLE_TIMEOUT = 60000;
+private final static long BEFORE_EDIT_TIMEOUT = 1000;
+private final static long WAIT_EDITING_TIMEOUT = 60000;
+private TestOut output;
+private Timeouts timeouts;
+private TreeDriver driver;
+/**
+* Constructor.
+*
+* @param b a component
+*/
+public JTreeOperator(JTree b) {
+super(b);
+driver = DriverManager.getTreeDriver(getClass());
+}
+/**
+* Constructs a JTreeOperator object.
+*
+* @param cont a container
+* @param chooser a component chooser specifying searching criteria.
+* @param index an index between appropriate ones.
+*/
+public JTreeOperator(ContainerOperator<?> cont, ComponentChooser chooser, int index) {
+this((JTree) cont.
+waitSubComponent(new JTreeFinder(chooser),
+index));
+copyEnvironment(cont);
+}
+/**
+* Constructs a JTreeOperator object.
+*
+* @param cont a container
+* @param chooser a component chooser specifying searching criteria.
+*/
+public JTreeOperator(ContainerOperator<?> cont, ComponentChooser chooser) {
+this(cont, chooser, 0);
+}
+/**
+* Constructor. Waits component in container first. Uses cont's timeout and
+* output for waiting and to init operator.
+*
+* @param cont a container
+* @param text Text of a row which is currently selected.
+* @param row a row index to check text in. If equals to -1, selected row is
+* checked.
+* @param index Ordinal component index.
+* @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
+* @throws TimeoutExpiredException
+*/
+public JTreeOperator(ContainerOperator<?> cont, String text, int row, int index) {
+this((JTree) waitComponent(cont,
+new JTreeByItemFinder(text, row,
+cont.getComparator()),
+index));
+copyEnvironment(cont);
+}
+/**
+* Constructor. Waits component in container first. Uses cont's timeout and
+* output for waiting and to init operator.
+*
+* @param cont a container
+* @param text Text of a row which is currently selected.
+* @param index Ordinal component index.
+* @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
+* @throws TimeoutExpiredException
+*/
+public JTreeOperator(ContainerOperator<?> cont, String text, int index) {
+this(cont, text, -1, index);
+}
+/**
+* Constructor. Waits component in container first. Uses cont's timeout and
+* output for waiting and to init operator.
+*
+* @param cont a container
+* @param text Text of a row which is currently selected.
+* @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
+* @throws TimeoutExpiredException
+*/
+public JTreeOperator(ContainerOperator<?> cont, String text) {
+this(cont, text, 0);
+}
+/**
+* Constructor. Waits component in container first. Uses cont's timeout and
+* output for waiting and to init operator.
+*
+* @param cont a container
+* @param index Ordinal component index.
+* @throws TimeoutExpiredException
+*/
+public JTreeOperator(ContainerOperator<?> cont, int index) {
+this((JTree) waitComponent(cont,
+new JTreeFinder(),
+index));
+copyEnvironment(cont);
+}
+/**
+* Constructor. Waits component in container first. Uses cont's timeout and
+* output for waiting and to init operator.
+*
+* @param cont a container
+* @throws TimeoutExpiredException
+*/
+public JTreeOperator(ContainerOperator<?> cont) {
+this(cont, 0);
+}
+/**
+* Searches JTree in container.
+*
+* @param cont Container to search component in.
+* @param chooser org.netbeans.jemmy.ComponentChooser implementation.
+* @param index Ordinal component index.
+* @return JTree instance or null if component was not found.
+*/
+public static JTree findJTree(Container cont, ComponentChooser chooser, int index) {
+return (JTree) findComponent(cont, new JTreeFinder(chooser), index);
+}
+/**
+* Searches 0'th JTree in container.
+*
+* @param cont Container to search component in.
+* @param chooser org.netbeans.jemmy.ComponentChooser implementation.
+* @return JTree instance or null if component was not found.
+*/
+public static JTree findJTree(Container cont, ComponentChooser chooser) {
+return findJTree(cont, chooser, 0);
+}
+/**
+* Searches JTree by item.
+*
+* @param cont Container to search component in.
+* @param text Item text. If null, contents is not checked.
+* @param ce Compare text exactly.
+* @param ccs Compare text case sensitively.
+* @param rowIndex Index of row to compare text. If -1, selected row is
+* checked.
+* @param index Ordinal component index.
+* @return JTree instance or null if component was not found.
+* @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
+*/
+public static JTree findJTree(Container cont, String text, boolean ce, boolean ccs, int rowIndex, int index) {
+return findJTree(cont, new JTreeByItemFinder(text, rowIndex, new DefaultStringComparator(ce, ccs)), index);
+}
+/**
+* Searches JTree by item.
+*
+* @param cont Container to search component in.
+* @param text Item text. If null, contents is not checked.
+* @param ce Compare text exactly.
+* @param ccs Compare text case sensitively.
+* @param rowIndex Index of row to compare text. If -1, selected row is
+* checked.
+* @return JTree instance or null if component was not found.
+* @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
+*/
+public static JTree findJTree(Container cont, String text, boolean ce, boolean ccs, int rowIndex) {
+return findJTree(cont, text, ce, ccs, rowIndex, 0);
+}
+/**
+* Waits JTree in container.
+*
+* @param cont Container to search component in.
+* @param chooser org.netbeans.jemmy.ComponentChooser implementation.
+* @param index Ordinal component index.
+* @return JTree instance or null if component was not found.
+* @throws TimeoutExpiredException
+*/
+public static JTree waitJTree(Container cont, ComponentChooser chooser, int index) {
+return (JTree) waitComponent(cont, new JTreeFinder(chooser), index);
+}
+/**
+* Waits 0'th JTree in container.
+*
+* @param cont Container to search component in.
+* @param chooser org.netbeans.jemmy.ComponentChooser implementation.
+* @return JTree instance or null if component was not found.
+* @throws TimeoutExpiredException
+*/
+public static JTree waitJTree(Container cont, ComponentChooser chooser) {
+return waitJTree(cont, chooser, 0);
+}
+/**
+* Waits JTree by item.
+*
+* @param cont Container to search component in.
+* @param text Item text. If null, contents is not checked.
+* @param ce Compare text exactly.
+* @param ccs Compare text case sensitively.
+* @param rowIndex Index of row to compare text. If -1, selected row is
+* checked.
+* @param index Ordinal component index.
+* @return JTree instance or null if component was not found.
+* @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
+* @throws TimeoutExpiredException
+*/
+public static JTree waitJTree(Container cont, String text, boolean ce, boolean ccs, int rowIndex, int index) {
+return waitJTree(cont, new JTreeByItemFinder(text, rowIndex, new DefaultStringComparator(ce, ccs)), index);
+}
+/**
+* Waits JTree by item.
+*
+* @param cont Container to search component in.
+* @param text Item text. If null, contents is not checked.
+* @param ce Compare text exactly.
+* @param ccs Compare text case sensitively.
+* @param rowIndex Index of row to compare text. If -1, selected row is
+* checked.
+* @return JTree instance or null if component was not found.
+* @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
+* @throws TimeoutExpiredException
+*/
+public static JTree waitJTree(Container cont, String text, boolean ce, boolean ccs, int rowIndex) {
+return waitJTree(cont, text, ce, ccs, rowIndex, 0);
+}
+static {
+Timeouts.initDefault("JTreeOperator.WaitNodeExpandedTimeout", WAIT_NODE_EXPANDED_TIMEOUT);
+Timeouts.initDefault("JTreeOperator.WaitNodeCollapsedTimeout", WAIT_NODE_COLLAPSED_TIMEOUT);
+Timeouts.initDefault("JTreeOperator.WaitAfterNodeExpandedTimeout", WAIT_AFTER_NODE_EXPANDED_TIMEOUT);
+Timeouts.initDefault("JTreeOperator.WaitNextNodeTimeout", WAIT_NEXT_NODE_TIMEOUT);
+Timeouts.initDefault("JTreeOperator.WaitNodeVisibleTimeout", WAIT_NODE_VISIBLE_TIMEOUT);
+Timeouts.initDefault("JTreeOperator.BeforeEditTimeout", BEFORE_EDIT_TIMEOUT);
+Timeouts.initDefault("JTreeOperator.WaitEditingTimeout", WAIT_EDITING_TIMEOUT);
+}
+@Override
+public void setTimeouts(Timeouts times) {
+this.timeouts = times;
+super.setTimeouts(timeouts);
+}
+@Override
+public Timeouts getTimeouts() {
+return timeouts;
+}
+@Override
+public void setOutput(TestOut out) {
+output = out;
+super.setOutput(output.createErrorOutput());
+}
+@Override
+public TestOut getOutput() {
+return output;
+}
+@Override
+public void copyEnvironment(Operator anotherOperator) {
+super.copyEnvironment(anotherOperator);
+driver
+= (TreeDriver) DriverManager.
+getDriver(DriverManager.TREE_DRIVER_ID,
+getClass(),
+anotherOperator.getProperties());
+}
+/**
+* Expands path.
+*
+* @param path a path to be expanded.
+* @throws TimeoutExpiredException
+*/
+public void doExpandPath(TreePath path) {
+if (path != null) {
+output.printLine("Expanding \"" + path.getPathComponent(path.getPathCount() - 1).toString()
++ "\" node");
+output.printGolden("Expanding \"" + path.getPathComponent(path.getPathCount() - 1).toString()
++ "\" node");
+driver.expandItem(this, getRowForPath(path));
+waitExpanded(path);
+} else {
+throw (new NoSuchPathException());
+}
+}
+/**
+* Expands path on row.
+*
+* @param row a row index to be expanded.
+* @throws TimeoutExpiredException
+*/
+public void doExpandRow(int row) {
+output.printLine("Expanding " + Integer.toString(row)
++ " row");
+output.printGolden("Expanding " + Integer.toString(row)
++ " row");
+driver.expandItem(this, row);
+waitExpanded(row);
+}
+/**
+* Ensures that the node identified by path is currently viewable.
+*
+* @param path a path to be made visible.
+* @throws TimeoutExpiredException
+*/
+public void doMakeVisible(TreePath path) {
+if (path != null) {
+output.printLine("Making \"" + path.toString() + "\" path visible");
+output.printGolden("Making path visible");
+makeVisible(path);
+waitVisible(path);
+} else {
+throw (new NoSuchPathException());
+}
+}
+/**
+* Returns number of child.
+*
+* @param node a node to count children of.
+* @return a number of children.
+*/
+public int getChildCount(final Object node) {
+return runMapping(new MapIntegerAction("getChildCount") {
+@Override
+public int map() {
+return ((JTree) getSource()).getModel().getChildCount(node);
+}
+});
+}
+/**
+* Returns node children.
+*
+* @param node a node to get children of.
+* @return an array of node children.
+*/
+public Object[] getChildren(final Object node) {
+return (Object[]) runMapping(new MapAction<Object>("getChildren") {
+@Override
+public Object map() {
+TreeModel md = ((JTree) getSource()).getModel();
+Object[] result = new Object[md.getChildCount(node)];
+for (int i = 0; i < md.getChildCount(node); i++) {
+result[i] = md.getChild(node, i);
+}
+return result;
+}
+});
+}
+/**
+* Returns node child.
+*
+* @param node a node to get a child of.
+* @param index a child index.
+* @return a node child.
+*/
+public Object getChild(final Object node, final int index) {
+return runMapping(new MapAction<Object>("getChild") {
+@Override
+public Object map() {
+return ((JTree) getSource()).getModel().getChild(node, index);
+}
+});
+}
+/**
+* Returns number of child.
+*
+* @param path a path indicating a node to count children of.
+* @return a number of children.
+*/
+public int getChildCount(TreePath path) {
+if (path != null) {
+return (getChildCount(path.
+getLastPathComponent()));
+} else {
+throw (new NoSuchPathException());
+}
+}
+/**
+* Constructs new path from a path and index's subnode of it last node.
+*
+* @param path a path indicating a node to get a child of.
+* @param index a child node index.
+* @return a number of children.
+*/
+public TreePath getChildPath(TreePath path, int index) {
+if (path != null) {
+return (path.
+pathByAddingChild(getChild(path.
+getLastPathComponent(), index)));
+} else {
+throw (new NoSuchPathException());
+}
+}
+/**
+* Constructs new paths from a path and all subnodes of it last node.
+*
+* @param path a path indicating a node to get children of.
+* @return a number of children.
+*/
+public TreePath[] getChildPaths(TreePath path) {
+if (path != null) {
+Object[] children = getChildren(path.
+getLastPathComponent());
+TreePath[] result = new TreePath[children.length];
+for (int i = 0; i < children.length; i++) {
+result[i] = path.
+pathByAddingChild(children[i]);
+}
+return result;
+} else {
+throw (new NoSuchPathException());
+}
+}
+/**
+* Returns the root of the tree.
+*
+* @return tree root.
+* @throws TimeoutExpiredException
+*/
+public Object getRoot() {
+Waiter<Object, Void> rootWaiter = new Waiter<>(new Waitable<Object, Void>() {
+@Override
+public Object actionProduced(Void obj) {
+Object root = getModel().getRoot();
+if (root == null || root.toString().equals("null")) {
+return null;
+} else {
+return root;
+}
+}
+@Override
+public String getDescription() {
+return "Wait root node";
+}
+@Override
+public String toString() {
+return "JTreeOperator.getRoot.Waitable{description = " + getDescription() + '}';
+}
+});
+rootWaiter.setTimeoutsToCloneOf(timeouts, "JTreeOperator.WaitNodeVisibleTimeout");
+rootWaiter.setOutput(output.createErrorOutput());
+try {
+return rootWaiter.waitAction(null);
+} catch (InterruptedException e) {
+output.printStackTrace(e);
+return null;
+}
+}
+/**
+* Searches path in tree.
+*
+* @param chooser TreePathChooser implementation.
+* @return a path fitting the criteria.
+* @see TreePathChooser
+* @see #findPath
+* @throws TimeoutExpiredException
+*/
+public TreePath findPath(TreePathChooser chooser) {
+output.printLine("Search for a tree path " + chooser.getDescription());
+output.printGolden("Search for a tree path");
+TreePath rootPath = new TreePath(getRoot());
+if (chooser.checkPath(rootPath, 0)) {
+return rootPath;
+}
+Waiter<Object[], Object[]> loadedWaiter = new Waiter<>(new Waitable<Object[], Object[]>() {
+// fields used in getDescription() method
+TreePath currentPath;
+String requestedPath;
+@Override
+public Object[] actionProduced(Object[] obj) {
+TreePathChooser chsr = (TreePathChooser) obj[0];
+requestedPath = chsr.getDescription();
+TreePath path = (TreePath) obj[1];
+currentPath = path;
+Object[] result = new Object[2];
+Object[] children = getChildren(path.getLastPathComponent());
+for (int j = 0; j < children.length; j++) {
+result[0] = path.pathByAddingChild(children[j]);
+if (chsr.checkPath((TreePath) result[0], j)) {
+result[1] = Boolean.TRUE;
+return result;
+}
+if (chsr.hasAsParent((TreePath) result[0], j)) {
+result[1] = Boolean.FALSE;
+return result;
+}
+}
+return null;
+}
+@Override
+public String getDescription() {
+return "Wait next node loaded under parent " + currentPath + " when requested was " + requestedPath;
+}
+@Override
+public String toString() {
+return "JTreeOperator.findPath.Waitable{description = " + getDescription() + '}';
+}
+});
+loadedWaiter.setTimeoutsToCloneOf(timeouts, "JTreeOperator.WaitNextNodeTimeout");
+loadedWaiter.setOutput(output.createErrorOutput());
+return findPathPrimitive(rootPath, chooser, loadedWaiter);
+}
+/**
+* Searches index'th row by row chooser.
+*
+* @param chooser a path searching criteria.
+* @param index a child index.
+* @return Row index or -1 if search was insuccessful.
+* @see JTreeOperator.TreeRowChooser
+*/
+public int findRow(TreeRowChooser chooser, int index) {
+int count = 0;
+for (int i = 0; i < getRowCount(); i++) {
+if (chooser.checkRow(this, i)) {
+if (count == index) {
+return i;
+} else {
+count++;
+}
+}
+}
+return -1;
+}
+/**
+* Searches a row by row chooser.
+*
+* @param chooser a path searching criteria.
+* @return Row index or -1 if search was insuccessful.
+* @see JTreeOperator.TreeRowChooser
+*/
+public int findRow(TreeRowChooser chooser) {
+return findRow(chooser, 0);
+}
+/**
+* Searches index'th row by substring.
+*
+* @param item Substring.
+* @param comparator a string comparision algorithm
+* @param index an ordinal row index between ones matching the criteria
+* @return Row index or -1 if search was insuccessful.
+*/
+public int findRow(String item, StringComparator comparator, int index) {
+return findRow(new BySubStringTreeRowChooser(item, comparator), index);
+}
+/**
+* Searches index'th row by substring.
+*
+* @param item Substring.
+* @param ce Compare exactly
+* @param cc Compare case sensitivelly.
+* @param index an ordinal row index between ones matching the criteria
+* @return Row index or -1 if search was insuccessful.
+* @deprecated Use findRow(String, int) or findRow(String, StringComparator,
+* int)
+*/
+@Deprecated
+public int findRow(String item, boolean ce, boolean cc, int index) {
+return (findRow(item,
+new DefaultStringComparator(ce, cc),
+index));
+}
+/**
+* Searches index'th row by substring. Uses StringComparator assigned to
+* this object.
+*
+* @param item Substring.
+* @param index an ordinal row index between ones matching the criteria
+* @return Row index or -1 if search was insuccessful.
+*/
+public int findRow(String item, int index) {
+return (findRow(item,
+getComparator(),
+index));
+}
+/**
+* Searches a row by substring.
+*
+* @param item Substring.
+* @param comparator a string comparision algorithm
+* @return Row index or -1 if search was insuccessful.
+*/
+public int findRow(String item, StringComparator comparator) {
+return findRow(item, comparator, 0);
+}
+/**
+* Searches a row by substring.
+*
+* @param item Substring.
+* @param ce Compare exactly
+* @param cc Compare case sensitivelly.
+* @return Row index or -1 if search was insuccessful.
+* @deprecated Use findRow(String) or findRow(String, StringComparator)
+*/
+@Deprecated
+public int findRow(String item, boolean ce, boolean cc) {
+return findRow(item, ce, cc, 0);
+}
+/**
+* Searches a row by substring. Uses StringComparator assigned to this
+* object.
+*
+* @param item Substring.
+* @return Row index or -1 if search was insuccessful.
+*/
+public int findRow(String item) {
+return (findRow(item,
+getComparator(),
+0));
+}
+/**
+* Searches index'th row by rendered component.
+*
+* @param chooser Component checking object.
+* @param index an ordinal row index between ones matching the criteria
+* @return Row index or -1 if search was insuccessful.
+*/
+public int findRow(ComponentChooser chooser, int index) {
+return findRow(new ByRenderedComponentTreeRowChooser(chooser), index);
+}
+/**
+* Searches a row by rendered component.
+*
+* @param chooser Component checking object.
+* @return Row index or -1 if search was insuccessful.
+*/
+public int findRow(ComponentChooser chooser) {
+return findRow(chooser, 0);
+}
+/**
+* Searches path in tree. Can be used to find one of the nodes with the same
+* text. Example:<BR>
+* <pre>
+* root
+* +-+node
+* | +--subnode
+* +-+node
+* | +--subnode
+* | +--subnode
+* ...
+* String[] names = {"node", "subnode"};<BR>
+* int[] indexes = {1, 0};<BR>
+* </pre> TreePath path = findPath(names, indexes, true, true);<BR>
+* "path" will points to the second (from the top) "subnode" node.
+*
+* @param names Node texts array.
+* @param indexes Nodes indexes.
+* @param comparator a string comparision algorithm
+* @return a tree path matching the criteria
+* @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
+* @see #findPath
+* @throws TimeoutExpiredException
+*/
+public TreePath findPath(String[] names, int[] indexes, StringComparator comparator) {
+return findPath(new StringArrayPathChooser(names, indexes, comparator));
+}
+/**
+* Searches path in tree. Can be used to find one of the nodes with the same
+* text. Example:<BR>
+* <pre>
+* root
+* +-+node
+* | +--subnode
+* +-+node
+* | +--subnode
+* | +--subnode
+* ...
+* String[] names = {"node", "subnode"};<BR>
+* int[] indexes = {1, 0};<BR>
+* </pre> TreePath path = findPath(names, indexes, true, true);<BR>
+* "path" will points to the second (from the top) "subnode" node.
+*
+* @param names Node texts array.
+* @param indexes Nodes indexes.
+* @param ce Compare exactly.
+* @param ccs Compare case sensitively.
+* @return a tree path matching the criteria
+* @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
+* @see #findPath
+* @throws TimeoutExpiredException
+* @deprecated Use findPath(String[], int[]) or findCellRow(String[], int[],
+* StringComparator)
+*/
+@Deprecated
+public TreePath findPath(String[] names, int[] indexes, boolean ce, boolean ccs) {
+return findPath(names, indexes, new DefaultStringComparator(ce, ccs));
+}
+/**
+* Searches path in tree. Uses StringComparator assigned to this object.
+*
+* @param names Node texts array.
+* @param indexes Nodes indexes.
+* @return a tree path matching the criteria
+* @see #findPath
+* @throws TimeoutExpiredException
+*/
+public TreePath findPath(String[] names, int[] indexes) {
+return findPath(names, indexes, getComparator());
+}
+/**
+* Searches path in tree.
+*
+* @param names Node texts array.
+* @param comparator a string comparision algorithm
+* @return a tree path matching the criteria
+* @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
+* @see #findPath
+* @throws TimeoutExpiredException
+*/
+public TreePath findPath(String[] names, StringComparator comparator) {
+int[] indexes = new int[0];
+return findPath(names, indexes, comparator);
+}
+/**
+* Searches path in tree.
+*
+* @param names Node texts array.
+* @param ce Compare exactly.
+* @param ccs Compare case sensitively.
+* @return a tree path matching the criteria
+* @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
+* @see #findPath
+* @throws TimeoutExpiredException
+* @deprecated Use findPath(String[]) or findCellRow(String[],
+* StringComparator)
+*/
+@Deprecated
+public TreePath findPath(String[] names, boolean ce, boolean ccs) {
+int[] indexes = new int[0];
+return findPath(names, indexes, ce, ccs);
+}
+/**
+* Searches path in tree. Uses StringComparator assigned to this object.
+*
+* @param names Node texts array.
+* @return a tree path matching the criteria
+* @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
+* @see #findPath
+* @throws TimeoutExpiredException
+*/
+public TreePath findPath(String[] names) {
+int[] indexes = new int[0];
+return findPath(names, indexes, getComparator());
+}
+/**
+* Searches path in tree.
+*
+* @param path String representing tree path. Path components should be
+* devided by "delim" parameter.
+* @param indexes String representing indexes to search path components.
+* Indexes should be devided by "delim" parameter.
+* @param delim Path components delimiter.
+* @param comparator a string comparision algorithm
+* @return a tree path matching the criteria
+* @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
+* @see #findPath
+* @throws TimeoutExpiredException
+*/
+public TreePath findPath(String path, String indexes, String delim, StringComparator comparator) {
+String[] indexStrings = parseString(indexes, delim);
+int[] indInts = new int[indexStrings.length];
+for (int i = 0; i < indexStrings.length; i++) {
+indInts[i] = Integer.parseInt(indexStrings[i]);
+}
+return findPath(parseString(path, delim), indInts, comparator);
+}
+/**
+* Searches path in tree.
+*
+* @param path String representing tree path. Path components should be
+* devided by "delim" parameter.
+* @param indexes String representing indexes to search path components.
+* Indexes should be devided by "delim" parameter.
+* @param delim Path components delimiter.
+* @param ce Compare exactly.
+* @param ccs Compare case sensitively.
+* @return a tree path matching the criteria
+* @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
+* @see #findPath
+* @throws TimeoutExpiredException
+* @deprecated Use findPath(String, String, String) or findCellRow(String,
+* String, String, StringComparator)
+*/
+@Deprecated
+public TreePath findPath(String path, String indexes, String delim, boolean ce, boolean ccs) {
+return findPath(path, indexes, delim, new DefaultStringComparator(ce, ccs));
+}
+/**
+* Searches path in tree. Uses StringComparator assigned to this object.
+*
+* @param path String representing tree path. Path components should be
+* devided by "delim" parameter.
+* @param indexes String representing indexes to search path components.
+* Indexes should be devided by "delim" parameter.
+* @param delim Path components delimiter.
+* @return a tree path matching the criteria
+* @see #findPath
+* @throws TimeoutExpiredException
+*/
+public TreePath findPath(String path, String indexes, String delim) {
+return findPath(path, indexes, delim, getComparator());
+}
+/**
+* Searches path in tree.
+*
+* @param path String representing tree path. Path components should be
+* devided by "delim" parameter.
+* @param delim Path components delimiter.
+* @param comparator a string comparision algorithm
+* @return a tree path matching the criteria
+* @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
+* @see #findPath
+* @throws TimeoutExpiredException
+*/
+public TreePath findPath(String path, String delim, StringComparator comparator) {
+return findPath(parseString(path, delim), comparator);
+}
+/**
+* Searches path in tree.
+*
+* @param path String representing tree path.
+* @param comparator a string comparision algorithm
+* @return a tree path matching the criteria
+* @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
+* @see #findPath
+* @throws TimeoutExpiredException
+*/
+public TreePath findPath(String path, StringComparator comparator) {
+return findPath(parseString(path), comparator);
+}
+/**
+* Searches path in tree.
+*
+* @param path String representing tree path. Path components should be
+* devided by "delim" parameter.
+* @param delim Path components delimiter.
+* @param ce Compare exactly.
+* @param ccs Compare case sensitively.
+* @return a tree path matching the criteria
+* @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
+* @see #findPath
+* @throws TimeoutExpiredException
+* @deprecated Use findPath(String, String) or findCellRow(String, String,
+* StringComparator)
+*/
+@Deprecated
+public TreePath findPath(String path, String delim, boolean ce, boolean ccs) {
+return findPath(parseString(path, delim), ce, ccs);
+}
+/**
+* Searches path in tree. Uses StringComparator assigned to this object.
+*
+* @param path String representing tree path. Path components should be
+* devided by "delim" parameter.
+* @param delim Path components delimiter.
+* @return a tree path matching the criteria
+* @see #findPath
+* @throws TimeoutExpiredException
+*/
+public TreePath findPath(String path, String delim) {
+return findPath(parseString(path, delim));
+}
+/**
+* Searches path in tree. Uses StringComparator assigned to this object.
+* Uses PathParser assigned to this object.
+*
+* @param path String representing tree path.
+* @return a tree path matching the criteria
+* @see #findPath
+* @throws TimeoutExpiredException
+*/
+public TreePath findPath(String path) {
+return findPath(parseString(path));
+}
+/**
+* Ensures that the node identified by the specified path is collapsed and
+* viewable.
+*
+* @param path a path to collapse.
+* @throws TimeoutExpiredException
+*/
+public void doCollapsePath(TreePath path) {
+if (path != null) {
+output.printLine("Collapsing \"" + path.toString() + "\" path");
+output.printGolden("Collapsing path");
+driver.collapseItem(this, getRowForPath(path));
+if (getVerification()) {
+waitCollapsed(path);
+}
+} else {
+throw (new NoSuchPathException());
+}
+}
+/**
+* Ensures that the node in the specified row is collapsed.
+*
+* @param row a row index to collapse.
+* @throws TimeoutExpiredException
+*/
+public void doCollapseRow(int row) {
+output.printLine("Collapsing \"" + Integer.toString(row) + "\" row");
+output.printGolden("Collapsing path");
+driver.collapseItem(this, row);
+if (getVerification()) {
+waitCollapsed(row);
+}
+}
+/**
+* Selects the path.
+*
+* @param path a path to select.
+*/
+public void selectPath(final TreePath path) {
+if (path != null) {
+output.printLine("Selecting \"" + path.toString() + "\" path");
+output.printGolden("Selecting path");
+scrollToPath(path);
+getQueueTool().invokeSmoothly(new QueueTool.QueueAction<Void>("Path selecting") {
+@Override
+public Void launch() {
+driver.selectItem(JTreeOperator.this, getRowForPath(path));
+return null;
+}
+});
+if (getVerification()) {
+waitSelected(path);
+}
+} else {
+throw (new NoSuchPathException());
+}
+}
+/**
+* Selects the node in the specified row.
+*
+* @param row an index of row to select.
+*/
+public void selectRow(int row) {
+output.printLine("Collapsing \"" + Integer.toString(row) + "\" row");
+output.printGolden("Collapsing path");
+driver.selectItem(this, row);
+if (getVerification()) {
+waitSelected(row);
+}
+}
+/**
+* Selects some pathes. If verification mode is on, checks that right paths
+* have been selected.
+*
+* @param paths a paths to select.
+*/
+public void selectPaths(TreePath[] paths) {
+output.printLine("Selecting paths:");
+int[] rows = new int[paths.length];
+for (int i = 0; i < paths.length; i++) {
+output.printLine("    " + paths[i].toString());
+rows[i] = getRowForPath(paths[i]);
+}
+output.printGolden("Selecting paths");
+driver.selectItems(this, rows);
+if (getVerification()) {
+waitSelected(paths);
+}
+}
+/**
+* Retuns points which can be used to click on path.
+*
+* @param path a tree path to click on.
+* @return a Point in component's coordinate system.
+*/
+public Point getPointToClick(TreePath path) {
+if (path != null) {
+Rectangle rect = getPathBounds(path);
+if (rect != null) {
+return (new Point((int) (rect.getX() + rect.getWidth() / 2),
+(int) (rect.getY() + rect.getHeight() / 2)));
+} else {
+throw (new NoSuchPathException(path));
+}
+} else {
+throw (new NoSuchPathException());
+}
+}
+/**
+* Retuns points which can be used to click on path.
+*
+* @param row a row index to click on.
+* @return a Point in component's coordinate system.
+*/
+public Point getPointToClick(int row) {
+Rectangle rect = getRowBounds(row);
+if (rect != null) {
+return (new Point((int) (rect.getX() + rect.getWidth() / 2),
+(int) (rect.getY() + rect.getHeight() / 2)));
+} else {
+throw (new NoSuchPathException(row));
+}
+}
+/**
+* Clicks on the node.
+*
+* @param path a path to click on.
+* @param clickCount a number of clicks
+* @param mouseButton InputEvent.BUTTON1/2/3_MASK value
+* @param modifiers Combination of InputEvent.*_MASK values
+* @throws TimeoutExpiredException
+*/
+public void clickOnPath(TreePath path, int clickCount, int mouseButton, int modifiers) {
+if (path != null) {
+output.printLine("Click on \"" + path.toString()
++ "\" path");
+output.printGolden("Click on path");
+makeComponentVisible();
+if (path.getParentPath() != null) {
+expandPath(path.getParentPath());
+}
+makeVisible(path);
+scrollToPath(path);
+Point point = getPointToClick(path);
+clickMouse((int) point.getX(), (int) point.getY(), clickCount, mouseButton, modifiers);
+} else {
+throw (new NoSuchPathException());
+}
+}
+/**
+* Clicks on the node.
+*
+* @param path a path to click on.
+* @param clickCount a number of clicks
+* @param mouseButton InputEvent.BUTTON1/2/3_MASK value
+* @throws TimeoutExpiredException
+*/
+public void clickOnPath(TreePath path, int clickCount, int mouseButton) {
+clickOnPath(path, clickCount, mouseButton, 0);
+}
+/**
+* Clicks on the node.
+*
+* @param path a path to click on.
+* @param clickCount a number of clicks
+* @throws TimeoutExpiredException
+*/
+public void clickOnPath(TreePath path, int clickCount) {
+clickOnPath(path, clickCount, getDefaultMouseButton());
+}
+/**
+* Clicks on the node.
+*
+* @param path a path to click on.
+* @throws TimeoutExpiredException
+*/
+public void clickOnPath(TreePath path) {
+clickOnPath(path, 1);
+}
+/**
+* Calls popup on the specified pathes.
+*
+* @param paths an array of paths to select before invoking popup on one of
+* them
+* @param mouseButton a mouse button tused to call popup.
+* @return an opened popup menu.
+* @throws TimeoutExpiredException
+*/
+public JPopupMenu callPopupOnPaths(TreePath[] paths, int mouseButton) {
+if (paths.length == 1) {
+output.printLine("Call popup on \"" + paths[0].toString()
++ "\" path");
+output.printGolden("Call popup on path");
+} else {
+output.printLine("Call popup on some pathes:");
+for (TreePath path : paths) {
+output.printLine("    " + path.toString());
+}
+output.printGolden("Call popup on paths");
+}
+makeComponentVisible();
+for (TreePath path : paths) {
+if (path.getParentPath() != null) {
+expandPath(path.getParentPath());
+}
+}
+selectPaths(paths);
+scrollToPath(paths[paths.length - 1]);
+Point point = getPointToClick(paths[paths.length - 1]);
+return (JPopupMenuOperator.callPopup(this,
+(int) point.getX(),
+(int) point.getY(),
+mouseButton));
+}
+/**
+* Calls popup on the specified pathes.
+*
+* @param paths an array of paths to select before invoking popup on one of
+* them
+* @return an opened popup menu.
+* @throws TimeoutExpiredException
+*/
+public JPopupMenu callPopupOnPaths(TreePath[] paths) {
+return callPopupOnPaths(paths, getPopupMouseButton());
+}
+/**
+* Calls popup on the specified path.
+*
+* @param path a path to invoking popup on.
+* @param mouseButton a mouse button tused to call popup.
+* @return an opened popup menu.
+* @throws TimeoutExpiredException
+*/
+public JPopupMenu callPopupOnPath(TreePath path, int mouseButton) {
+if (path != null) {
+TreePath[] paths = {path};
+return callPopupOnPaths(paths, mouseButton);
+} else {
+throw (new NoSuchPathException());
+}
+}
+/**
+* Calls popup on the specified path.
+*
+* @param path a path to invoking popup on.
+* @return an opened popup menu.
+* @throws TimeoutExpiredException
+*/
+public JPopupMenu callPopupOnPath(TreePath path) {
+return callPopupOnPath(path, getPopupMouseButton());
+}
+/**
+* Scrolls to a path if the tree is on a JScrollPane component.
+*
+* @param path a tree path to scroll to.
+*/
+public void scrollToPath(TreePath path) {
+if (path != null) {
+output.printTrace("Scroll JTree to path \"" + path.toString() + "\"\n    : "
++ toStringSource());
+output.printGolden("Scroll JTree to path \"" + path.toString() + "\"");
+makeComponentVisible();
+//try to find JScrollPane under.
+JScrollPane scroll = (JScrollPane) getContainer(new JScrollPaneOperator.JScrollPaneFinder(ComponentSearcher.
+getTrueChooser("JScrollPane")));
+if (scroll == null) {
+return;
+}
+JScrollPaneOperator scroller = new JScrollPaneOperator(scroll);
+scroller.copyEnvironment(this);
+scroller.setVisualizer(new EmptyVisualizer());
+Rectangle rect = getPathBounds(path);
+if (rect != null) {
+scroller.scrollToComponentRectangle(getSource(),
+(int) rect.getX(),
+(int) rect.getY(),
+(int) rect.getWidth(),
+(int) rect.getHeight());
+} else {
+throw (new NoSuchPathException(path));
+}
+} else {
+throw (new NoSuchPathException());
+}
+}
+/**
+* Scrolls to a row if the tree is on a JScrollPane component.
+*
+* @param row a row index to scroll to.
+*/
+public void scrollToRow(int row) {
+scrollToPath(getPathForRow(row));
+}
+/**
+* Turns path to the editing mode.
+*
+* @param path a tree path to click on.
+* @throws TimeoutExpiredException
+*/
+public void clickForEdit(TreePath path) {
+driver.startEditing(this, getRowForPath(path),
+timeouts.create("JTreeOperator.WaitEditingTimeout"));
+}
+/**
+* Ask renderer for component to be displayed.
+*
+* @param path a path indicating the rendered node.
+* @param isSelected True if the specified cell is selected.
+* @param isExpanded True if the specified cell is expanded.
+* @param cellHasFocus True if the specified cell has the focus.
+* @return Component to be displayed.
+*/
+public Component getRenderedComponent(TreePath path, boolean isSelected, boolean isExpanded, boolean cellHasFocus) {
+if (path != null) {
+return (getCellRenderer().
+getTreeCellRendererComponent((JTree) getSource(),
+path.getLastPathComponent(),
+isSelected,
+isExpanded,
+getModel().isLeaf(path.getLastPathComponent()),
+getRowForPath(path),
+cellHasFocus));
+} else {
+throw (new NoSuchPathException());
+}
+}
+/**
+* Ask renderer for component to be displayed. Uses isPathSelected(TreePath)
+* to determine whether path is selected. Uses isExpanded(TreePath) to
+* determine whether path is expanded.
+*
+* @param path a path indicating the rendered node.
+* @return Component to be displayed.
+*/
+public Component getRenderedComponent(TreePath path) {
+return (getRenderedComponent(path,
+isPathSelected(path),
+isExpanded(path),
+false));
+}
+/**
+* Changes text of last path component.
+*
+* @param path a path indicating the node to change value for.
+* @param newNodeText a new node value
+* @deprecated Use changePathObject(TreePath, Object) instead.
+* @see #changePathObject(TreePath, Object)
+* @throws TimeoutExpiredException
+*/
+@Deprecated
+public void changePathText(TreePath path, String newNodeText) {
+changePathObject(path, newNodeText);
+}
+/**
+* Changes last path component using getCellEditor() editor.
+*
+* @param path a path indicating the node to change value for.
+* @param newValue a new node value
+* @throws TimeoutExpiredException
+*/
+public void changePathObject(TreePath path, Object newValue) {
+scrollToPath(path);
+driver.editItem(this, getRowForPath(path), newValue,
+timeouts.create("JTreeOperator.WaitEditingTimeout"));
+}
+/**
+* Waits path to be expanded.
+*
+* @param path a path to wait expanded.
+*/
+public void waitExpanded(final TreePath path) {
+if (path != null) {
+getOutput().printLine("Wait \"" + path.toString() + "\" path to be expanded in component \n    : "
++ toStringSource());
+getOutput().printGolden("Wait \"" + path.toString() + "\" path to be expanded");
+waitState(new ComponentChooser() {
+@Override
+public boolean checkComponent(Component comp) {
+return isExpanded(path);
+}
+@Override
+public String getDescription() {
+return "Has \"" + path.toString() + "\" path expanded";
+}
+@Override
+public String toString() {
+return "JTreeOperator.waitExpanded.ComponentChooser{description = " + getDescription() + '}';
+}
+});
+} else {
+throw (new NoSuchPathException());
+}
+}
+/**
+* Waits row to be expanded.
+*
+* @param row a row index to wait expanded.
+*/
+public void waitExpanded(final int row) {
+getOutput().printLine("Wait " + Integer.toString(row) + "'th row to be expanded in component \n    : "
++ toStringSource());
+getOutput().printGolden("Wait " + Integer.toString(row) + "'th row to be expanded");
+waitState(new ComponentChooser() {
+@Override
+public boolean checkComponent(Component comp) {
+return isExpanded(row);
+}
+@Override
+public String getDescription() {
+return "Has " + Integer.toString(row) + "'th row expanded";
+}
+@Override
+public String toString() {
+return "JTreeOperator.waitExpanded.ComponentChooser{description = " + getDescription() + '}';
+}
+});
+}
+/**
+* Waits path to be collapsed.
+*
+* @param path a path to wait collapsed.
+*/
+public void waitCollapsed(final TreePath path) {
+if (path != null) {
+getOutput().printLine("Wait \"" + path.toString() + "\" path to be collapsed in component \n    : "
++ toStringSource());
+getOutput().printGolden("Wait \"" + path.toString() + "\" path to be collapsed");
+waitState(new ComponentChooser() {
+@Override
+public boolean checkComponent(Component comp) {
+return isCollapsed(path);
+}
+@Override
+public String getDescription() {
+return "Has \"" + path.toString() + "\" path collapsed";
+}
+@Override
+public String toString() {
+return "JTreeOperator.waitCollapsed.ComponentChooser{description = " + getDescription() + '}';
+}
+});
+} else {
+throw (new NoSuchPathException());
+}
+}
+/**
+* Waits row to be collapsed.
+*
+* @param row a row index to wait collapsed.
+*/
+public void waitCollapsed(final int row) {
+getOutput().printLine("Wait " + Integer.toString(row) + "'th row to be collapsed in component \n    : "
++ toStringSource());
+getOutput().printGolden("Wait " + Integer.toString(row) + "'th row to be collapsed");
+waitState(new ComponentChooser() {
+@Override
+public boolean checkComponent(Component comp) {
+return isCollapsed(row);
+}
+@Override
+public String getDescription() {
+return "Has " + Integer.toString(row) + "'th row collapsed";
+}
+@Override
+public String toString() {
+return "JTreeOperator.waitCollapsed.ComponentChooser{description = " + getDescription() + '}';
+}
+});
+}
+/**
+* Waits path to be visible.
+*
+* @param path a path to wait visible.
+*/
+public void waitVisible(final TreePath path) {
+if (path != null) {
+getOutput().printLine("Wait \"" + path.toString() + "\" path to be visible in component \n    : "
++ toStringSource());
+getOutput().printGolden("Wait \"" + path.toString() + "\" path to be visible");
+waitState(new ComponentChooser() {
+@Override
+public boolean checkComponent(Component comp) {
+return isVisible(path);
+}
+@Override
+public String getDescription() {
+return "Has \"" + path.toString() + "\" path visible";
+}
+@Override
+public String toString() {
+return "JTreeOperator.waitVisible.ComponentChooser{description = " + getDescription() + '}';
+}
+});
+} else {
+throw (new NoSuchPathException());
+}
+}
+/**
+* Waits some paths to be selected.
+*
+* @param paths an array of paths to be selected.
+*/
+public void waitSelected(final TreePath[] paths) {
+getOutput().printLine("Wait right selection in component \n    : "
++ toStringSource());
+getOutput().printGolden("Wait right selection");
+waitState(new ComponentChooser() {
+@Override
+public boolean checkComponent(Component comp) {
+TreePath[] rpaths = getSelectionModel().getSelectionPaths();
+if (rpaths != null) {
+for (int i = 0; i < rpaths.length; i++) {
+if (!rpaths[i].equals(paths[i])) {
+return false;
+}
+}
+return true;
+} else {
+return false;
+}
+}
+@Override
+public String getDescription() {
+return "Has right selection";
+}
+@Override
+public String toString() {
+return "JTreeOperator.waitSelected.ComponentChooser{description = " + getDescription() + '}';
+}
+});
+}
+/**
+* Waits path to be selected.
+*
+* @param path a tree path to be selected.
+*/
+public void waitSelected(final TreePath path) {
+waitSelected(new TreePath[]{path});
+}
+/**
+* Waits rows to be selected.
+*
+* @param rows an indices of rows to be selected.
+*/
+public void waitSelected(int[] rows) {
+TreePath[] paths = new TreePath[rows.length];
+for (int i = 0; i < rows.length; i++) {
+paths[i] = getPathForRow(rows[i]);
+}
+waitSelected(paths);
+}
+/**
+* Waits row to be selected.
+*
+* @param row an index of a row to be selected.
+*/
+public void waitSelected(int row) {
+waitSelected(new int[]{row});
+}
+/**
+* Wat for text in certain row.
+*
+* @param rowText Text to be compared with row text be
+* {@code getComparator()} comparator.
+* @param row Row index. If -1, selected one is checked.
+*/
+public void waitRow(String rowText, int row) {
+getOutput().printLine("Wait \"" + rowText + "\" text in "
++ Integer.toString(row) + "'th line in component \n    : "
++ toStringSource());
+getOutput().printGolden("Wait \"" + rowText + " \" text in "
++ Integer.toString(row) + "'th line");
+waitState(new JTreeByItemFinder(rowText, row, getComparator()));
+}
+public Object chooseSubnode(Object parent, String text, int index, StringComparator comparator) {
+int count = -1;
+Object node;
+for (int i = 0; i < getChildCount(parent); i++) {
+try {
+node = getChild(parent, i);
+} catch (JemmyException e) {
+if (e.getInnerThrowable() instanceof IndexOutOfBoundsException) {
+// tree probably re-generated because we haven't found child with specified index
+return null;
+} else {
+throw e;
+}
+}
+if (comparator.equals(node.toString(),
+text)) {
+count++;
+if (count == index) {
+return node;
+}
+}
+}
+return null;
+}
+public Object chooseSubnode(Object parent, String text, StringComparator comparator) {
+return chooseSubnode(parent, text, 0, comparator);
+}
+public Object chooseSubnode(Object parent, String text, int index) {
+return chooseSubnode(parent, text, index, getComparator());
+}
+public Object chooseSubnode(Object parent, String text) {
+return chooseSubnode(parent, text, 0, getComparator());
+}
+/**
+* Returns information about component.
+*/
+@Override
+public Hashtable<String, Object> getDump() {
+Hashtable<String, Object> result = super.getDump();
+Object root = ((JTree) getSource()).getModel().getRoot();
+// only if root is not hidden
+result.put(ROOT_DPROP, root.toString());
+addChildrenToDump(result, NODE_PREFIX_DPROP, root, new TreePath(root));
+int minSelection = ((JTree) getSource()).getMinSelectionRow();
+if (minSelection >= 0) {
+Object minObject = ((JTree) getSource()).
+getPathForRow(minSelection).
+getLastPathComponent();
+result.put(SELECTION_FIRST_DPROP, minObject.toString());
+int maxSelection = ((JTree) getSource()).getMaxSelectionRow();
+if (maxSelection > minSelection) {
+Object maxObject = ((JTree) getSource()).
+getPathForRow(maxSelection).
+getLastPathComponent();
+result.put(SELECTION_LAST_DPROP, maxObject.toString());
+}
+}
+return result;
+}
+////////////////////////////////////////////////////////
+//Mapping                                             //
+/**
+* Maps {@code JTree.addSelectionInterval(int, int)} through queue
+*/
+public void addSelectionInterval(final int i, final int i1) {
+runMapping(new MapVoidAction("addSelectionInterval") {
+@Override
+public void map() {
+((JTree) getSource()).addSelectionInterval(i, i1);
+}
+});
+}
+/**
+* Maps {@code JTree.addSelectionPath(TreePath)} through queue
+*/
+public void addSelectionPath(final TreePath treePath) {
+runMapping(new MapVoidAction("addSelectionPath") {
+@Override
+public void map() {
+((JTree) getSource()).addSelectionPath(treePath);
+}
+});
+}
+/**
+* Maps {@code JTree.addSelectionPaths(TreePath[])} through queue
+*/
+public void addSelectionPaths(final TreePath[] treePath) {
+runMapping(new MapVoidAction("addSelectionPaths") {
+@Override
+public void map() {
+((JTree) getSource()).addSelectionPaths(treePath);
+}
+});
+}
+/**
+* Maps {@code JTree.addSelectionRow(int)} through queue
+*/
+public void addSelectionRow(final int i) {
+runMapping(new MapVoidAction("addSelectionRow") {
+@Override
+public void map() {
+((JTree) getSource()).addSelectionRow(i);
+}
+});
+}
+/**
+* Maps {@code JTree.addSelectionRows(int[])} through queue
+*/
+public void addSelectionRows(final int[] i) {
+runMapping(new MapVoidAction("addSelectionRows") {
+@Override
+public void map() {
+((JTree) getSource()).addSelectionRows(i);
+}
+});
+}
+/**
+* Maps {@code JTree.addTreeExpansionListener(TreeExpansionListener)}
+* through queue
+*/
+public void addTreeExpansionListener(final TreeExpansionListener treeExpansionListener) {
+runMapping(new MapVoidAction("addTreeExpansionListener") {
+@Override
+public void map() {
+((JTree) getSource()).addTreeExpansionListener(treeExpansionListener);
+}
+});
+}
+/**
+* Maps {@code JTree.addTreeSelectionListener(TreeSelectionListener)}
+* through queue
+*/
+public void addTreeSelectionListener(final TreeSelectionListener treeSelectionListener) {
+runMapping(new MapVoidAction("addTreeSelectionListener") {
+@Override
+public void map() {
+((JTree) getSource()).addTreeSelectionListener(treeSelectionListener);
+}
+});
+}
+/**
+* Maps {@code JTree.addTreeWillExpandListener(TreeWillExpandListener)}
+* through queue
+*/
+public void addTreeWillExpandListener(final TreeWillExpandListener treeWillExpandListener) {
+runMapping(new MapVoidAction("addTreeWillExpandListener") {
+@Override
+public void map() {
+((JTree) getSource()).addTreeWillExpandListener(treeWillExpandListener);
+}
+});
+}
+/**
+* Maps {@code JTree.cancelEditing()} through queue
+*/
+public void cancelEditing() {
+runMapping(new MapVoidAction("cancelEditing") {
+@Override
+public void map() {
+((JTree) getSource()).cancelEditing();
+}
+});
+}
+/**
+* Maps {@code JTree.clearSelection()} through queue
+*/
+public void clearSelection() {
+runMapping(new MapVoidAction("clearSelection") {
+@Override
+public void map() {
+((JTree) getSource()).clearSelection();
+}
+});
+}
+/**
+* Maps {@code JTree.collapsePath(TreePath)} through queue
+*/
+public void collapsePath(final TreePath treePath) {
+runMapping(new MapVoidAction("collapsePath") {
+@Override
+public void map() {
+((JTree) getSource()).collapsePath(treePath);
+}
+});
+}
+/**
+* Maps {@code JTree.collapseRow(int)} through queue
+*/
+public void collapseRow(final int i) {
+runMapping(new MapVoidAction("collapseRow") {
+@Override
+public void map() {
+((JTree) getSource()).collapseRow(i);
+}
+});
+}
+/**
+* Maps
+* {@code JTree.convertValueToText(Object, boolean, boolean, boolean, int, boolean)}
+* through queue
+*/
+public String convertValueToText(final Object object, final boolean b, final boolean b1, final boolean b2, final int i, final boolean b3) {
+return (runMapping(new MapAction<String>("convertValueToText") {
+@Override
+public String map() {
+return ((JTree) getSource()).convertValueToText(object, b, b1, b2, i, b3);
+}
+}));
+}
+/**
+* Maps {@code JTree.expandPath(TreePath)} through queue
+*/
+public void expandPath(final TreePath treePath) {
+runMapping(new MapVoidAction("expandPath") {
+@Override
+public void map() {
+((JTree) getSource()).expandPath(treePath);
+}
+});
+}
+/**
+* Maps {@code JTree.expandRow(int)} through queue
+*/
+public void expandRow(final int i) {
+runMapping(new MapVoidAction("expandRow") {
+@Override
+public void map() {
+((JTree) getSource()).expandRow(i);
+}
+});
+}
+/**
+* Maps {@code JTree.fireTreeCollapsed(TreePath)} through queue
+*/
+public void fireTreeCollapsed(final TreePath treePath) {
+runMapping(new MapVoidAction("fireTreeCollapsed") {
+@Override
+public void map() {
+((JTree) getSource()).fireTreeCollapsed(treePath);
+}
+});
+}
+/**
+* Maps {@code JTree.fireTreeExpanded(TreePath)} through queue
+*/
+public void fireTreeExpanded(final TreePath treePath) {
+runMapping(new MapVoidAction("fireTreeExpanded") {
+@Override
+public void map() {
+((JTree) getSource()).fireTreeExpanded(treePath);
+}
+});
+}
+/**
+* Maps {@code JTree.fireTreeWillCollapse(TreePath)} through queue
+*/
+public void fireTreeWillCollapse(final TreePath treePath) {
+runMapping(new MapVoidAction("fireTreeWillCollapse") {
+@Override
+public void map() throws ExpandVetoException {
+((JTree) getSource()).fireTreeWillCollapse(treePath);
+}
+});
+}
+/**
+* Maps {@code JTree.fireTreeWillExpand(TreePath)} through queue
+*/
+public void fireTreeWillExpand(final TreePath treePath) {
+runMapping(new MapVoidAction("fireTreeWillExpand") {
+@Override
+public void map() throws ExpandVetoException {
+((JTree) getSource()).fireTreeWillExpand(treePath);
+}
+});
+}
+/**
+* Maps {@code JTree.getCellEditor()} through queue
+*/
+public TreeCellEditor getCellEditor() {
+return (runMapping(new MapAction<TreeCellEditor>("getCellEditor") {
+@Override
+public TreeCellEditor map() {
+return ((JTree) getSource()).getCellEditor();
+}
+}));
+}
+/**
+* Maps {@code JTree.getCellRenderer()} through queue
+*/
+public TreeCellRenderer getCellRenderer() {
+return (runMapping(new MapAction<TreeCellRenderer>("getCellRenderer") {
+@Override
+public TreeCellRenderer map() {
+return ((JTree) getSource()).getCellRenderer();
+}
+}));
+}
+/**
+* Maps {@code JTree.getClosestPathForLocation(int, int)} through queue
+*/
+public TreePath getClosestPathForLocation(final int i, final int i1) {
+return (runMapping(new MapAction<TreePath>("getClosestPathForLocation") {
+@Override
+public TreePath map() {
+return ((JTree) getSource()).getClosestPathForLocation(i, i1);
+}
+}));
+}
+/**
+* Maps {@code JTree.getClosestRowForLocation(int, int)} through queue
+*/
+public int getClosestRowForLocation(final int i, final int i1) {
+return (runMapping(new MapIntegerAction("getClosestRowForLocation") {
+@Override
+public int map() {
+return ((JTree) getSource()).getClosestRowForLocation(i, i1);
+}
+}));
+}
+/**
+* Maps {@code JTree.getEditingPath()} through queue
+*/
+public TreePath getEditingPath() {
+return (runMapping(new MapAction<TreePath>("getEditingPath") {
+@Override
+public TreePath map() {
+return ((JTree) getSource()).getEditingPath();
+}
+}));
+}
+/**
+* Maps {@code JTree.getExpandedDescendants(TreePath)} through queue
+*/
+public Enumeration<TreePath> getExpandedDescendants(final TreePath treePath) {
+return (runMapping(new MapAction<Enumeration<TreePath>>("getExpandedDescendants") {
+@Override
+public Enumeration<TreePath> map() {
+return ((JTree) getSource()).getExpandedDescendants(treePath);
+}
+}));
+}
+/**
+* Maps {@code JTree.getInvokesStopCellEditing()} through queue
+*/
+public boolean getInvokesStopCellEditing() {
+return (runMapping(new MapBooleanAction("getInvokesStopCellEditing") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).getInvokesStopCellEditing();
+}
+}));
+}
+/**
+* Maps {@code JTree.getLastSelectedPathComponent()} through queue
+*/
+public Object getLastSelectedPathComponent() {
+return (runMapping(new MapAction<Object>("getLastSelectedPathComponent") {
+@Override
+public Object map() {
+return ((JTree) getSource()).getLastSelectedPathComponent();
+}
+}));
+}
+/**
+* Maps {@code JTree.getLeadSelectionPath()} through queue
+*/
+public TreePath getLeadSelectionPath() {
+return (runMapping(new MapAction<TreePath>("getLeadSelectionPath") {
+@Override
+public TreePath map() {
+return ((JTree) getSource()).getLeadSelectionPath();
+}
+}));
+}
+/**
+* Maps {@code JTree.getLeadSelectionRow()} through queue
+*/
+public int getLeadSelectionRow() {
+return (runMapping(new MapIntegerAction("getLeadSelectionRow") {
+@Override
+public int map() {
+return ((JTree) getSource()).getLeadSelectionRow();
+}
+}));
+}
+/**
+* Maps {@code JTree.getMaxSelectionRow()} through queue
+*/
+public int getMaxSelectionRow() {
+return (runMapping(new MapIntegerAction("getMaxSelectionRow") {
+@Override
+public int map() {
+return ((JTree) getSource()).getMaxSelectionRow();
+}
+}));
+}
+/**
+* Maps {@code JTree.getMinSelectionRow()} through queue
+*/
+public int getMinSelectionRow() {
+return (runMapping(new MapIntegerAction("getMinSelectionRow") {
+@Override
+public int map() {
+return ((JTree) getSource()).getMinSelectionRow();
+}
+}));
+}
+/**
+* Maps {@code JTree.getModel()} through queue
+*/
+public TreeModel getModel() {
+return (runMapping(new MapAction<TreeModel>("getModel") {
+@Override
+public TreeModel map() {
+return ((JTree) getSource()).getModel();
+}
+}));
+}
+/**
+* Maps {@code JTree.getPathBounds(TreePath)} through queue
+*/
+public Rectangle getPathBounds(final TreePath treePath) {
+return (runMapping(new MapAction<Rectangle>("getPathBounds") {
+@Override
+public Rectangle map() {
+return ((JTree) getSource()).getPathBounds(treePath);
+}
+}));
+}
+/**
+* Maps {@code JTree.getPathForLocation(int, int)} through queue
+*/
+public TreePath getPathForLocation(final int i, final int i1) {
+return (runMapping(new MapAction<TreePath>("getPathForLocation") {
+@Override
+public TreePath map() {
+return ((JTree) getSource()).getPathForLocation(i, i1);
+}
+}));
+}
+/**
+* Maps {@code JTree.getPathForRow(int)} through queue
+*/
+public TreePath getPathForRow(final int i) {
+return (runMapping(new MapAction<TreePath>("getPathForRow") {
+@Override
+public TreePath map() {
+return ((JTree) getSource()).getPathForRow(i);
+}
+}));
+}
+/**
+* Maps {@code JTree.getPreferredScrollableViewportSize()} through queue
+*/
+public Dimension getPreferredScrollableViewportSize() {
+return (runMapping(new MapAction<Dimension>("getPreferredScrollableViewportSize") {
+@Override
+public Dimension map() {
+return ((JTree) getSource()).getPreferredScrollableViewportSize();
+}
+}));
+}
+/**
+* Maps {@code JTree.getRowBounds(int)} through queue
+*/
+public Rectangle getRowBounds(final int i) {
+return (runMapping(new MapAction<Rectangle>("getRowBounds") {
+@Override
+public Rectangle map() {
+return ((JTree) getSource()).getRowBounds(i);
+}
+}));
+}
+/**
+* Maps {@code JTree.getRowCount()} through queue
+*/
+public int getRowCount() {
+return (runMapping(new MapIntegerAction("getRowCount") {
+@Override
+public int map() {
+return ((JTree) getSource()).getRowCount();
+}
+}));
+}
+/**
+* Maps {@code JTree.getRowForLocation(int, int)} through queue
+*/
+public int getRowForLocation(final int i, final int i1) {
+return (runMapping(new MapIntegerAction("getRowForLocation") {
+@Override
+public int map() {
+return ((JTree) getSource()).getRowForLocation(i, i1);
+}
+}));
+}
+/**
+* Maps {@code JTree.getRowForPath(TreePath)} through queue
+*/
+public int getRowForPath(final TreePath treePath) {
+return (runMapping(new MapIntegerAction("getRowForPath") {
+@Override
+public int map() {
+return ((JTree) getSource()).getRowForPath(treePath);
+}
+}));
+}
+/**
+* Maps {@code JTree.getRowHeight()} through queue
+*/
+public int getRowHeight() {
+return (runMapping(new MapIntegerAction("getRowHeight") {
+@Override
+public int map() {
+return ((JTree) getSource()).getRowHeight();
+}
+}));
+}
+/**
+* Maps {@code JTree.getScrollableBlockIncrement(Rectangle, int, int)}
+* through queue
+*/
+public int getScrollableBlockIncrement(final Rectangle rectangle, final int i, final int i1) {
+return (runMapping(new MapIntegerAction("getScrollableBlockIncrement") {
+@Override
+public int map() {
+return ((JTree) getSource()).getScrollableBlockIncrement(rectangle, i, i1);
+}
+}));
+}
+/**
+* Maps {@code JTree.getScrollableTracksViewportHeight()} through queue
+*/
+public boolean getScrollableTracksViewportHeight() {
+return (runMapping(new MapBooleanAction("getScrollableTracksViewportHeight") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).getScrollableTracksViewportHeight();
+}
+}));
+}
+/**
+* Maps {@code JTree.getScrollableTracksViewportWidth()} through queue
+*/
+public boolean getScrollableTracksViewportWidth() {
+return (runMapping(new MapBooleanAction("getScrollableTracksViewportWidth") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).getScrollableTracksViewportWidth();
+}
+}));
+}
+/**
+* Maps {@code JTree.getScrollableUnitIncrement(Rectangle, int, int)}
+* through queue
+*/
+public int getScrollableUnitIncrement(final Rectangle rectangle, final int i, final int i1) {
+return (runMapping(new MapIntegerAction("getScrollableUnitIncrement") {
+@Override
+public int map() {
+return ((JTree) getSource()).getScrollableUnitIncrement(rectangle, i, i1);
+}
+}));
+}
+/**
+* Maps {@code JTree.getScrollsOnExpand()} through queue
+*/
+public boolean getScrollsOnExpand() {
+return (runMapping(new MapBooleanAction("getScrollsOnExpand") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).getScrollsOnExpand();
+}
+}));
+}
+/**
+* Maps {@code JTree.getSelectionCount()} through queue
+*/
+public int getSelectionCount() {
+return (runMapping(new MapIntegerAction("getSelectionCount") {
+@Override
+public int map() {
+return ((JTree) getSource()).getSelectionCount();
+}
+}));
+}
+/**
+* Maps {@code JTree.getSelectionModel()} through queue
+*/
+public TreeSelectionModel getSelectionModel() {
+return (runMapping(new MapAction<TreeSelectionModel>("getSelectionModel") {
+@Override
+public TreeSelectionModel map() {
+return ((JTree) getSource()).getSelectionModel();
+}
+}));
+}
+/**
+* Maps {@code JTree.getSelectionPath()} through queue
+*/
+public TreePath getSelectionPath() {
+return (runMapping(new MapAction<TreePath>("getSelectionPath") {
+@Override
+public TreePath map() {
+return ((JTree) getSource()).getSelectionPath();
+}
+}));
+}
+/**
+* Maps {@code JTree.getSelectionPaths()} through queue
+*/
+public TreePath[] getSelectionPaths() {
+return ((TreePath[]) runMapping(new MapAction<Object>("getSelectionPaths") {
+@Override
+public Object map() {
+return ((JTree) getSource()).getSelectionPaths();
+}
+}));
+}
+/**
+* Maps {@code JTree.getSelectionRows()} through queue
+*/
+public int[] getSelectionRows() {
+return ((int[]) runMapping(new MapAction<Object>("getSelectionRows") {
+@Override
+public Object map() {
+return ((JTree) getSource()).getSelectionRows();
+}
+}));
+}
+/**
+* Maps {@code JTree.getShowsRootHandles()} through queue
+*/
+public boolean getShowsRootHandles() {
+return (runMapping(new MapBooleanAction("getShowsRootHandles") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).getShowsRootHandles();
+}
+}));
+}
+/**
+* Maps {@code JTree.getUI()} through queue
+*/
+public TreeUI getUI() {
+return (runMapping(new MapAction<TreeUI>("getUI") {
+@Override
+public TreeUI map() {
+return ((JTree) getSource()).getUI();
+}
+}));
+}
+/**
+* Maps {@code JTree.getVisibleRowCount()} through queue
+*/
+public int getVisibleRowCount() {
+return (runMapping(new MapIntegerAction("getVisibleRowCount") {
+@Override
+public int map() {
+return ((JTree) getSource()).getVisibleRowCount();
+}
+}));
+}
+/**
+* Maps {@code JTree.hasBeenExpanded(TreePath)} through queue
+*/
+public boolean hasBeenExpanded(final TreePath treePath) {
+return (runMapping(new MapBooleanAction("hasBeenExpanded") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).hasBeenExpanded(treePath);
+}
+}));
+}
+/**
+* Maps {@code JTree.isCollapsed(int)} through queue
+*/
+public boolean isCollapsed(final int i) {
+return (runMapping(new MapBooleanAction("isCollapsed") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).isCollapsed(i);
+}
+}));
+}
+/**
+* Maps {@code JTree.isCollapsed(TreePath)} through queue
+*/
+public boolean isCollapsed(final TreePath treePath) {
+return (runMapping(new MapBooleanAction("isCollapsed") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).isCollapsed(treePath);
+}
+}));
+}
+/**
+* Maps {@code JTree.isEditable()} through queue
+*/
+public boolean isEditable() {
+return (runMapping(new MapBooleanAction("isEditable") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).isEditable();
+}
+}));
+}
+/**
+* Maps {@code JTree.isEditing()} through queue
+*/
+public boolean isEditing() {
+return (runMapping(new MapBooleanAction("isEditing") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).isEditing();
+}
+}));
+}
+/**
+* Maps {@code JTree.isExpanded(int)} through queue
+*/
+public boolean isExpanded(final int i) {
+return (runMapping(new MapBooleanAction("isExpanded") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).isExpanded(i);
+}
+}));
+}
+/**
+* Maps {@code JTree.isExpanded(TreePath)} through queue
+*/
+public boolean isExpanded(final TreePath treePath) {
+return (runMapping(new MapBooleanAction("isExpanded") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).isExpanded(treePath);
+}
+}));
+}
+/**
+* Maps {@code JTree.isFixedRowHeight()} through queue
+*/
+public boolean isFixedRowHeight() {
+return (runMapping(new MapBooleanAction("isFixedRowHeight") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).isFixedRowHeight();
+}
+}));
+}
+/**
+* Maps {@code JTree.isLargeModel()} through queue
+*/
+public boolean isLargeModel() {
+return (runMapping(new MapBooleanAction("isLargeModel") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).isLargeModel();
+}
+}));
+}
+/**
+* Maps {@code JTree.isPathEditable(TreePath)} through queue
+*/
+public boolean isPathEditable(final TreePath treePath) {
+return (runMapping(new MapBooleanAction("isPathEditable") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).isPathEditable(treePath);
+}
+}));
+}
+/**
+* Maps {@code JTree.isPathSelected(TreePath)} through queue
+*/
+public boolean isPathSelected(final TreePath treePath) {
+return (runMapping(new MapBooleanAction("isPathSelected") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).isPathSelected(treePath);
+}
+}));
+}
+/**
+* Maps {@code JTree.isRootVisible()} through queue
+*/
+public boolean isRootVisible() {
+return (runMapping(new MapBooleanAction("isRootVisible") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).isRootVisible();
+}
+}));
+}
+/**
+* Maps {@code JTree.isRowSelected(int)} through queue
+*/
+public boolean isRowSelected(final int i) {
+return (runMapping(new MapBooleanAction("isRowSelected") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).isRowSelected(i);
+}
+}));
+}
+/**
+* Maps {@code JTree.isSelectionEmpty()} through queue
+*/
+public boolean isSelectionEmpty() {
+return (runMapping(new MapBooleanAction("isSelectionEmpty") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).isSelectionEmpty();
+}
+}));
+}
+/**
+* Maps {@code JTree.isVisible(TreePath)} through queue
+*/
+public boolean isVisible(final TreePath treePath) {
+return (runMapping(new MapBooleanAction("isVisible") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).isVisible(treePath);
+}
+}));
+}
+/**
+* Maps {@code JTree.makeVisible(TreePath)} through queue
+*/
+public void makeVisible(final TreePath treePath) {
+runMapping(new MapVoidAction("makeVisible") {
+@Override
+public void map() {
+((JTree) getSource()).makeVisible(treePath);
+}
+});
+}
+/**
+* Maps {@code JTree.removeSelectionInterval(int, int)} through queue
+*/
+public void removeSelectionInterval(final int i, final int i1) {
+runMapping(new MapVoidAction("removeSelectionInterval") {
+@Override
+public void map() {
+((JTree) getSource()).removeSelectionInterval(i, i1);
+}
+});
+}
+/**
+* Maps {@code JTree.removeSelectionPath(TreePath)} through queue
+*/
+public void removeSelectionPath(final TreePath treePath) {
+runMapping(new MapVoidAction("removeSelectionPath") {
+@Override
+public void map() {
+((JTree) getSource()).removeSelectionPath(treePath);
+}
+});
+}
+/**
+* Maps {@code JTree.removeSelectionPaths(TreePath[])} through queue
+*/
+public void removeSelectionPaths(final TreePath[] treePath) {
+runMapping(new MapVoidAction("removeSelectionPaths") {
+@Override
+public void map() {
+((JTree) getSource()).removeSelectionPaths(treePath);
+}
+});
+}
+/**
+* Maps {@code JTree.removeSelectionRow(int)} through queue
+*/
+public void removeSelectionRow(final int i) {
+runMapping(new MapVoidAction("removeSelectionRow") {
+@Override
+public void map() {
+((JTree) getSource()).removeSelectionRow(i);
+}
+});
+}
+/**
+* Maps {@code JTree.removeSelectionRows(int[])} through queue
+*/
+public void removeSelectionRows(final int[] i) {
+runMapping(new MapVoidAction("removeSelectionRows") {
+@Override
+public void map() {
+((JTree) getSource()).removeSelectionRows(i);
+}
+});
+}
+/**
+* Maps
+* {@code JTree.removeTreeExpansionListener(TreeExpansionListener)}
+* through queue
+*/
+public void removeTreeExpansionListener(final TreeExpansionListener treeExpansionListener) {
+runMapping(new MapVoidAction("removeTreeExpansionListener") {
+@Override
+public void map() {
+((JTree) getSource()).removeTreeExpansionListener(treeExpansionListener);
+}
+});
+}
+/**
+* Maps
+* {@code JTree.removeTreeSelectionListener(TreeSelectionListener)}
+* through queue
+*/
+public void removeTreeSelectionListener(final TreeSelectionListener treeSelectionListener) {
+runMapping(new MapVoidAction("removeTreeSelectionListener") {
+@Override
+public void map() {
+((JTree) getSource()).removeTreeSelectionListener(treeSelectionListener);
+}
+});
+}
+/**
+* Maps
+* {@code JTree.removeTreeWillExpandListener(TreeWillExpandListener)}
+* through queue
+*/
+public void removeTreeWillExpandListener(final TreeWillExpandListener treeWillExpandListener) {
+runMapping(new MapVoidAction("removeTreeWillExpandListener") {
+@Override
+public void map() {
+((JTree) getSource()).removeTreeWillExpandListener(treeWillExpandListener);
+}
+});
+}
+/**
+* Maps {@code JTree.scrollPathToVisible(TreePath)} through queue
+*/
+public void scrollPathToVisible(final TreePath treePath) {
+runMapping(new MapVoidAction("scrollPathToVisible") {
+@Override
+public void map() {
+((JTree) getSource()).scrollPathToVisible(treePath);
+}
+});
+}
+/**
+* Maps {@code JTree.scrollRowToVisible(int)} through queue
+*/
+public void scrollRowToVisible(final int i) {
+runMapping(new MapVoidAction("scrollRowToVisible") {
+@Override
+public void map() {
+((JTree) getSource()).scrollRowToVisible(i);
+}
+});
+}
+/**
+* Maps {@code JTree.setCellEditor(TreeCellEditor)} through queue
+*/
+public void setCellEditor(final TreeCellEditor treeCellEditor) {
+runMapping(new MapVoidAction("setCellEditor") {
+@Override
+public void map() {
+((JTree) getSource()).setCellEditor(treeCellEditor);
+}
+});
+}
+/**
+* Maps {@code JTree.setCellRenderer(TreeCellRenderer)} through queue
+*/
+public void setCellRenderer(final TreeCellRenderer treeCellRenderer) {
+runMapping(new MapVoidAction("setCellRenderer") {
+@Override
+public void map() {
+((JTree) getSource()).setCellRenderer(treeCellRenderer);
+}
+});
+}
+/**
+* Maps {@code JTree.setEditable(boolean)} through queue
+*/
+public void setEditable(final boolean b) {
+runMapping(new MapVoidAction("setEditable") {
+@Override
+public void map() {
+((JTree) getSource()).setEditable(b);
+}
+});
+}
+/**
+* Maps {@code JTree.setInvokesStopCellEditing(boolean)} through queue
+*/
+public void setInvokesStopCellEditing(final boolean b) {
+runMapping(new MapVoidAction("setInvokesStopCellEditing") {
+@Override
+public void map() {
+((JTree) getSource()).setInvokesStopCellEditing(b);
+}
+});
+}
+/**
+* Maps {@code JTree.setLargeModel(boolean)} through queue
+*/
+public void setLargeModel(final boolean b) {
+runMapping(new MapVoidAction("setLargeModel") {
+@Override
+public void map() {
+((JTree) getSource()).setLargeModel(b);
+}
+});
+}
+/**
+* Maps {@code JTree.setModel(TreeModel)} through queue
+*/
+public void setModel(final TreeModel treeModel) {
+runMapping(new MapVoidAction("setModel") {
+@Override
+public void map() {
+((JTree) getSource()).setModel(treeModel);
+}
+});
+}
+/**
+* Maps {@code JTree.setRootVisible(boolean)} through queue
+*/
+public void setRootVisible(final boolean b) {
+runMapping(new MapVoidAction("setRootVisible") {
+@Override
+public void map() {
+((JTree) getSource()).setRootVisible(b);
+}
+});
+}
+/**
+* Maps {@code JTree.setRowHeight(int)} through queue
+*/
+public void setRowHeight(final int i) {
+runMapping(new MapVoidAction("setRowHeight") {
+@Override
+public void map() {
+((JTree) getSource()).setRowHeight(i);
+}
+});
+}
+/**
+* Maps {@code JTree.setScrollsOnExpand(boolean)} through queue
+*/
+public void setScrollsOnExpand(final boolean b) {
+runMapping(new MapVoidAction("setScrollsOnExpand") {
+@Override
+public void map() {
+((JTree) getSource()).setScrollsOnExpand(b);
+}
+});
+}
+/**
+* Maps {@code JTree.setSelectionInterval(int, int)} through queue
+*/
+public void setSelectionInterval(final int i, final int i1) {
+runMapping(new MapVoidAction("setSelectionInterval") {
+@Override
+public void map() {
+((JTree) getSource()).setSelectionInterval(i, i1);
+}
+});
+}
+/**
+* Maps {@code JTree.setSelectionModel(TreeSelectionModel)} through queue
+*/
+public void setSelectionModel(final TreeSelectionModel treeSelectionModel) {
+runMapping(new MapVoidAction("setSelectionModel") {
+@Override
+public void map() {
+((JTree) getSource()).setSelectionModel(treeSelectionModel);
+}
+});
+}
+/**
+* Maps {@code JTree.setSelectionPath(TreePath)} through queue
+*/
+public void setSelectionPath(final TreePath treePath) {
+runMapping(new MapVoidAction("setSelectionPath") {
+@Override
+public void map() {
+((JTree) getSource()).setSelectionPath(treePath);
+}
+});
+}
+/**
+* Maps {@code JTree.setSelectionPaths(TreePath[])} through queue
+*/
+public void setSelectionPaths(final TreePath[] treePath) {
+runMapping(new MapVoidAction("setSelectionPaths") {
+@Override
+public void map() {
+((JTree) getSource()).setSelectionPaths(treePath);
+}
+});
+}
+/**
+* Maps {@code JTree.setSelectionRow(int)} through queue
+*/
+public void setSelectionRow(final int i) {
+runMapping(new MapVoidAction("setSelectionRow") {
+@Override
+public void map() {
+((JTree) getSource()).setSelectionRow(i);
+}
+});
+}
+/**
+* Maps {@code JTree.setSelectionRows(int[])} through queue
+*/
+public void setSelectionRows(final int[] i) {
+runMapping(new MapVoidAction("setSelectionRows") {
+@Override
+public void map() {
+((JTree) getSource()).setSelectionRows(i);
+}
+});
+}
+/**
+* Maps {@code JTree.setShowsRootHandles(boolean)} through queue
+*/
+public void setShowsRootHandles(final boolean b) {
+runMapping(new MapVoidAction("setShowsRootHandles") {
+@Override
+public void map() {
+((JTree) getSource()).setShowsRootHandles(b);
+}
+});
+}
+/**
+* Maps {@code JTree.setUI(TreeUI)} through queue
+*/
+public void setUI(final TreeUI treeUI) {
+runMapping(new MapVoidAction("setUI") {
+@Override
+public void map() {
+((JTree) getSource()).setUI(treeUI);
+}
+});
+}
+/**
+* Maps {@code JTree.setVisibleRowCount(int)} through queue
+*/
+public void setVisibleRowCount(final int i) {
+runMapping(new MapVoidAction("setVisibleRowCount") {
+@Override
+public void map() {
+((JTree) getSource()).setVisibleRowCount(i);
+}
+});
+}
+/**
+* Maps {@code JTree.startEditingAtPath(TreePath)} through queue
+*/
+public void startEditingAtPath(final TreePath treePath) {
+runMapping(new MapVoidAction("startEditingAtPath") {
+@Override
+public void map() {
+((JTree) getSource()).startEditingAtPath(treePath);
+}
+});
+}
+/**
+* Maps {@code JTree.stopEditing()} through queue
+*/
+public boolean stopEditing() {
+return (runMapping(new MapBooleanAction("stopEditing") {
+@Override
+public boolean map() {
+return ((JTree) getSource()).stopEditing();
+}
+}));
+}
+/**
+* Maps {@code JTree.treeDidChange()} through queue
+*/
+public void treeDidChange() {
+runMapping(new MapVoidAction("treeDidChange") {
+@Override
+public void map() {
+((JTree) getSource()).treeDidChange();
+}
+});
+}
+//End of mapping                                      //
+////////////////////////////////////////////////////////
+/**
+* Iterface to choose tree row. Defines criteria to distinguish row.
+*/
+public interface TreeRowChooser {
+/**
+* Should be true if row is good.
+*
+* @param oper Operator used to search item.
+* @param row Row be checked.
+* @return true if the row fits the criteria
+*/
+public boolean checkRow(JTreeOperator oper, int row);
+/**
+* Row description.
+*
+* @return a criteria description.
+*/
+public String getDescription();
+}
+private TreePath findPathPrimitive(TreePath path, TreePathChooser chooser, Waiter<Object[], Object[]> loadedWaiter) {
+if (!isExpanded(path)) {
+if (!isPathSelected(path)) {
+clickOnPath(path);
+}
+expandPath(path);
+}
+Object[] waitParam = {chooser, path};
+Object[] waitResult = null;
+try {
+waitResult = loadedWaiter.waitAction(waitParam);
+} catch (InterruptedException e) {
+output.printStackTrace(e);
+return null;
+}
+TreePath nextPath = (TreePath) waitResult[0];
+boolean found = (Boolean) waitResult[1];
+if (found) {
+return nextPath;
+} else {
+return findPathPrimitive(nextPath, chooser, loadedWaiter);
+}
+}
+private String[] addChildrenToDump(Hashtable<String, Object> table, String title, Object node, TreePath path) {
+if (((JTree) getSource()).isExpanded(path)) {
+Object[] subNodes = getChildren(node);
+String[] names = addToDump(table, title, subNodes);
+for (int i = 0; i < subNodes.length; i++) {
+addChildrenToDump(table, names[i], subNodes[i], path.pathByAddingChild(subNodes[i]));
+}
+return names;
+} else {
+return new String[0];
+}
+}
+private static String pathToString(String[] path) {
+StringBuilder desc = new StringBuilder("[ ");
+for (String aPath : path) {
+desc.append(aPath).append(", ");
+}
+if (desc.length() > 2) {
+desc.setLength(desc.length() - 2);
+}
+desc.append(" ]");
+return desc.toString();
+}
+/**
+* Can be throught during item selecting if list does not have item
+* requested.
+*/
+public class NoSuchPathException extends JemmyInputException {
+private static final long serialVersionUID = 42L;
+/**
+* Constructor.
+*/
+public NoSuchPathException() {
+super("Unknown/null/invalid tree path.", null);
+}
+/**
+* Constructor.
+*
+* @param path a nonexistent path.
+*/
+public NoSuchPathException(String[] path) {
+super("No such path as \"" + pathToString(path) + "\"", getSource());
+}
+/**
+* Constructor.
+*
+* @param index a nonexistent line index.
+*/
+public NoSuchPathException(int index) {
+super("Tree does not contain " + index + "'th line", getSource());
+}
+/**
+* Constructor.
+*
+* @param path a nonexistent path.
+*/
+public NoSuchPathException(TreePath path) {
+super("No such path as \"" + path.toString() + "\"", getSource());
+}
+}
+/**
+* Specifies criteria for path searching.
+*/
+public interface TreePathChooser {
+/**
+* Checks if the path fits the criteria.
+*
+* @param path TreePath to check.
+* @param indexInParent Index of the "path" in path's parent.
+* @return true if the path fits the criteria
+*/
+public boolean checkPath(TreePath path, int indexInParent);
+/**
+* Checks if the path has another path as a parent.
+*
+* @param path TreePath to check.
+* @param indexInParent Index of the "path" in path's parent.
+* @return true if path looked for is a child/grandchild of a path
+* passed as a parameter.
+*/
+public boolean hasAsParent(TreePath path, int indexInParent);
+/**
+* Returns the description.
+*
+* @return a description.
+*/
+public String getDescription();
+}
+/**
+* Specifies searching criteria basing on nodes' text.
+*/
+class StringArrayPathChooser implements TreePathChooser {
+String[] arr;
+int[] indices;
+StringComparator comparator;
+/**
+* Constructs StringArrayPathChooser.
+*
+* @param arr a node text array. First element defines a text of a first
+* node under a tree root, second element - a children of the first
+* node, ...
+* @param indices indexes of nodes in nodes' parents.
+* @param comparator String comparision criteria.
+*/
+StringArrayPathChooser(String[] arr, int[] indices, StringComparator comparator) {
+this.arr = arr;
+this.comparator = comparator;
+this.indices = indices;
+}
+@Override
+public boolean checkPath(TreePath path, int indexInParent) {
+return (path.getPathCount() - 1 == arr.length
+&& hasAsParent(path, indexInParent));
+}
+@Override
+public boolean hasAsParent(TreePath path, int indexInParent) {
+Object[] comps = path.getPath();
+Object node;
+for (int i = 1; i < comps.length; i++) {
+if (arr.length < path.getPathCount() - 1) {
+return false;
+}
+/*
+if(!comparator.equals(comps[i].toString(), arr[i - 1])) {
+return false;
+}
+*/
+if (indices.length >= path.getPathCount() - 1) {
+node = chooseSubnode(comps[i - 1], arr[i - 1], indices[i - 1], comparator);
+} else {
+node = chooseSubnode(comps[i - 1], arr[i - 1], comparator);
+}
+if (node != comps[i]) {
+return false;
+}
+}
+return true;
+}
+@Override
+public String getDescription() {
+return pathToString(arr);
+}
+@Override
+public String toString() {
+return "StringArrayPathChooser{" + "arr=" + arr + ", indices=" + indices + ", comparator=" + comparator + '}';
+}
+}
+private static class BySubStringTreeRowChooser implements TreeRowChooser {
+String subString;
+StringComparator comparator;
+public BySubStringTreeRowChooser(String subString, StringComparator comparator) {
+this.subString = subString;
+this.comparator = comparator;
+}
+@Override
+public boolean checkRow(JTreeOperator oper, int row) {
+return (comparator.equals(oper.getPathForRow(row).getLastPathComponent().toString(),
+subString));
+}
+@Override
+public String getDescription() {
+return "Row containing \"" + subString + "\" string";
+}
+@Override
+public String toString() {
+return "BySubStringTreeRowChooser{" + "subString=" + subString + ", comparator=" + comparator + '}';
+}
+}
+private static class ByRenderedComponentTreeRowChooser implements TreeRowChooser {
+ComponentChooser chooser;
+public ByRenderedComponentTreeRowChooser(ComponentChooser chooser) {
+this.chooser = chooser;
+}
+@Override
+public boolean checkRow(JTreeOperator oper, int row) {
+return chooser.checkComponent(oper.getRenderedComponent(oper.getPathForRow(row)));
+}
+@Override
+public String getDescription() {
+return chooser.getDescription();
+}
+@Override
+public String toString() {
+return "ByRenderedComponentTreeRowChooser{" + "chooser=" + chooser + '}';
+}
+}
+/**
+* Checks component type.
+*/
+public static class JTreeFinder extends Finder {
+/**
+* Constructs JTreeFinder.
+*
+* @param sf other searching criteria.
+*/
+public JTreeFinder(ComponentChooser sf) {
+super(JTree.class, sf);
+}
+/**
+* Constructs JTreeFinder.
+*/
+public JTreeFinder() {
+super(JTree.class);
+}
+}
+/**
+* Allows to find component by node text.
+*/
+public static class JTreeByItemFinder implements ComponentChooser {
+String label;
+int rowIndex;
+StringComparator comparator;
+/**
+* Constructs JTreeByItemFinder.
+*
+* @param lb a text pattern
+* @param ii row index to check. If equal to -1, selected row is
+* checked.
+* @param comparator specifies string comparision algorithm.
+*/
+public JTreeByItemFinder(String lb, int ii, StringComparator comparator) {
+label = lb;
+rowIndex = ii;
+this.comparator = comparator;
+}
+/**
+* Constructs JTreeByItemFinder.
+*
+* @param lb a text pattern
+* @param ii row index to check. If equal to -1, selected row is
+* checked.
+*/
+public JTreeByItemFinder(String lb, int ii) {
+this(lb, ii, Operator.getDefaultStringComparator());
+}
+@Override
+public boolean checkComponent(Component comp) {
+if (comp instanceof JTree) {
+if (label == null) {
+return true;
+}
+if (((JTree) comp).getRowCount() > rowIndex) {
+int ii = rowIndex;
+if (ii == -1) {
+int[] rows = ((JTree) comp).getSelectionRows();
+if (rows != null && rows.length > 0) {
+ii = rows[0];
+} else {
+return false;
+}
+}
+TreePath path = ((JTree) comp).getPathForRow(ii);
+if (path != null) {
+return (comparator.equals(path.getPathComponent(path.getPathCount() - 1).toString(),
+label));
+}
+}
+}
+return false;
+}
+@Override
+public String getDescription() {
+return ("JTree with text \"" + label + "\" in "
++ rowIndex + "'th row");
+}
+@Override
+public String toString() {
+return "JTreeByItemFinder{" + "label=" + label + ", rowIndex=" + rowIndex + ", comparator=" + comparator + '}';
+}
+}
+}