Java ComponentChooser.getDescription方法代码示例

import org.netbeans.jemmy.ComponentChooser; //导入方法依赖的package包/类
/** Waits for index-th TopComponent with given name in IDE registry.
 * It throws JemmyException when TopComponent is not find until timeout
 * expires.
 * @param cont container where to search
 * @param name name of TopComponent
 * @param index index of TopComponent
 * @param subchooser ComponentChooser to determine exact TopComponent
 * @return TopComponent instance or throws JemmyException if not found
 * @see #findTopComponent
 */
protected static JComponent waitTopComponent(final ContainerOperator cont, final String name, final int index, final ComponentChooser subchooser) {
    try {
        Waiter waiter = new Waiter(new Waitable() {

            @Override
            public Object actionProduced(Object obj) {
                return findTopComponent(cont, name, index, subchooser);
            }

            @Override
            public String getDescription() {
                return ("Wait TopComponent with name=" + name
                        + " index=" + String.valueOf(index)
                        + (subchooser == null ? "" : " subchooser=" + subchooser.getDescription())
                        + " loaded");
            }
        });
        Timeouts times = JemmyProperties.getCurrentTimeouts().cloneThis();
        times.setTimeout("Waiter.WaitingTime", times.getTimeout("ComponentOperator.WaitComponentTimeout"));
        waiter.setTimeouts(times);
        waiter.setOutput(JemmyProperties.getCurrentOutput());
        return ((JComponent) waiter.waitAction(null));
    } catch (InterruptedException e) {
        return (null);
    }
}
 

import org.netbeans.jemmy.ComponentChooser; //导入方法依赖的package包/类
/**
 * A method to be used from subclasses. Uses timeouts and output passed as
 * parameters during the waiting.
 *
 * @param cont Container to search component in.
 * @param chooser org.netbeans.jemmy.ComponentChooser implementation.
 * @param index Ordinal component index.
 * @param timeouts timeouts to be used during the waiting.
 * @param output an output to be used during the waiting.
 * @return Component instance or null if component was not found.
 * @throws TimeoutExpiredException
 */
protected static Component waitComponent(final Container cont,
        final ComponentChooser chooser,
        final int index,
        Timeouts timeouts, final TestOut output) {
    try {
        Waiter<Component, Void> waiter = new Waiter<>(new Waitable<Component, Void>() {
            @Override
            public Component actionProduced(Void obj) {
                return findComponent(cont, new VisibleComponentFinder(chooser), index,
                        output.createErrorOutput());
            }

            @Override
            public String getDescription() {
                return "Wait " + chooser.getDescription() + " loaded";
            }

            @Override
            public String toString() {
                return "ComponentOperator.waitComponent.Waitable{description = " + getDescription() + '}';
            }
        });
        waiter.setTimeoutsToCloneOf(timeouts, "ComponentOperator.WaitComponentTimeout");
        waiter.setOutput(output);
        return waiter.waitAction(null);
    } catch (InterruptedException e) {
        return null;
    }
}
 

import org.netbeans.jemmy.ComponentChooser; //导入方法依赖的package包/类
/**
 * Waits for a subcomponent.
 *
 * @param chooser a chooser specifying searching criteria.
 * @param index Ordinal component index.
 * @return Component instance.
 */
public Component waitSubComponent(final ComponentChooser chooser, final int index) {
    getOutput().printLine("Waiting for \"" + chooser.getDescription()
            + "\" subcomponent");
    final ComponentSearcher searcher = new ComponentSearcher((Container) getSource());
    searcher.setOutput(getOutput().createErrorOutput());
    Waiter<Component, Void> waiter = new Waiter<>(new Waitable<Component, Void>() {
        @Override
        public Component actionProduced(Void obj) {
            return searcher.findComponent(chooser, index);
        }

        @Override
        public String getDescription() {
            return ("Wait for \"" + chooser.getDescription()
                    + "\" subcomponent to be displayed");
        }

        @Override
        public String toString() {
            return "ContainerOperator.waitSubComponent.Waitable{description = " + getDescription() + '}';
        }
    });
    waiter.setTimeoutsToCloneOf(getTimeouts(), "ComponentOperator.WaitComponentTimeout");
    waiter.setOutput(getOutput());
    try {
        return waiter.waitAction(null);
    } catch (InterruptedException e) {
        throw (new JemmyException("Waiting for \"" + chooser.getDescription()
                + "\" component has been interrupted", e));
    }
}
 

import org.netbeans.jemmy.ComponentChooser; //导入方法依赖的package包/类
/**
 * Waits a state specified by a ComponentChooser instance.
 *
 * @param state a ComponentChooser defining the state criteria.
 * @throws TimeoutExpiredException if the state has not achieved in a value
 * defined by {@code "ComponentOperator.WaitStateTimeout"}
 */
public void waitState(final ComponentChooser state) {
    Waiter<String, Void> stateWaiter = new Waiter<>(new Waitable<String, Void>() {
        @Override
        public String actionProduced(Void obj) {
            return state.checkComponent(getSource()) ? "" : null;
        }

        @Override
        public String getDescription() {
            return "Wait \"" + state.getDescription()
                    + "\" state to be reached";
        }

        @Override
        public String toString() {
            return "Operator.waitState.Waitable{description = " + getDescription() + '}';
        }
    });
    stateWaiter.setTimeoutsToCloneOf(getTimeouts(), "ComponentOperator.WaitStateTimeout");
    stateWaiter.setOutput(getOutput().createErrorOutput());
    try {
        stateWaiter.waitAction(null);
    } catch (InterruptedException e) {
        throw (new JemmyException("Waiting of \"" + state.getDescription()
                + "\" state has been interrupted!"));
    }
}
 

import org.netbeans.jemmy.ComponentChooser; //导入方法依赖的package包/类
/**
 * Waits an index'th window between windows owned by this window.
 *
 * @param chooser a component chooser specifying searching criteria.
 * @param index an index between appropriate ones.
 * @return a subwindow
 */
public Window waitSubWindow(ComponentChooser chooser, int index) {
    getOutput().printLine("Waiting for \"" + chooser.getDescription()
            + "\" subwindow");
    WindowWaiter ww = new WindowWaiter();
    ww.setOutput(getOutput());
    ww.setTimeouts(getTimeouts());
    try {
        return ww.waitWindow((Window) getSource(), chooser, index);
    } catch (InterruptedException e) {
        throw (new JemmyException("Waiting for \"" + chooser.getDescription()
                + "\" window has been interrupted", e));
    }
}
 

import org.netbeans.jemmy.ComponentChooser; //导入方法依赖的package包/类
/**
 * Waits JInternalframe in container.
 *
 * @param cont Container to search component in.
 * @param chooser a component chooser specifying searching criteria.
 * @param index Ordinal component index.
 * @return JInternalframe instance.
 *
 */
public static JInternalFrame waitJInternalFrame(final Container cont, final ComponentChooser chooser, final int index) {
    Component res = waitComponent(cont, new JInternalFrameFinder(chooser), index);
    if (res instanceof JInternalFrame) {
        return (JInternalFrame) res;
    } else if (res instanceof JInternalFrame.JDesktopIcon) {
        return ((JInternalFrame.JDesktopIcon) res).getInternalFrame();
    } else {
        throw (new TimeoutExpiredException(chooser.getDescription()));
    }
}