stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8209789: Synchronize test/jdk/sanity/client/lib/jemmy with code-tools/jemmy/v2

Browse Source 
Reviewed-by: serb
This commit is contained in:
Abdul Kolarkunnu 2018-08-27 03:46:44 -07:00 committed by Abdul Kolarkunnu
parent 8b373393e6
commit 13ce063178
6 changed files with 594 additions and 78 deletions

46
test/jdk/sanity/client/lib/jemmy/src/org/netbeans/jemmy/operators/ComponentOperator.java

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2018, 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
@ -59,8 +59,6 @@ import java.io.PrintWriter;
import java.util.Hashtable;
import java.util.Locale;
import static java.lang.Math.abs;
import org.netbeans.jemmy.CharBindingMap;
import org.netbeans.jemmy.ComponentChooser;
import org.netbeans.jemmy.ComponentSearcher;
@ -1221,6 +1219,48 @@ public class ComponentOperator extends Operator
});
}
/**
* Wait till the component reaches exact location on screen.
*
* @param exactLocation exact expected screen location.
*/
public void waitComponentLocationOnScreen(Point exactlocation) {
waitComponentLocationOnScreen(exactlocation, exactlocation);
}
/**
* Wait till the component location on screen reaches between minLocation
* and maxLocation
*
* @param minLocation minimum expected location on screen.
* @param maxLocation maximum expected location on screen.
*/
public void waitComponentLocationOnScreen(
final Point minLocation, final Point maxLocation) {
waitState(new ComponentChooser() {
@Override
public boolean checkComponent(Component comp) {
Point location = comp.getLocationOnScreen();
return location.x >= minLocation.x
&& location.x <= maxLocation.x
&& location.y >= minLocation.y
&& location.y <= maxLocation.y;
}
@Override
public String getDescription() {
return "Component location on screen reaches between :"
+ minLocation + "and " + maxLocation;
}
@Override
public String toString() {
return "ComponentOperator.waitComponentLocationOnScreen"
+ ".Waitable{description = " + getDescription() + '}';
}
});
}
/**
* Returns information about component.
*/

70
test/jdk/sanity/client/lib/jemmy/src/org/netbeans/jemmy/operators/JComponentOperator.java

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2018, 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
@ -47,7 +47,6 @@ import javax.swing.event.AncestorListener;
import org.netbeans.jemmy.ComponentChooser;
import org.netbeans.jemmy.ComponentSearcher;
import org.netbeans.jemmy.JemmyProperties;
import org.netbeans.jemmy.Outputable;
import org.netbeans.jemmy.TestOut;
import org.netbeans.jemmy.TimeoutExpiredException;
@ -307,15 +306,7 @@ public class JComponentOperator extends ContainerOperator<Container>
}
public JToolTip waitToolTip() {
return ((JToolTip) waitComponent(WindowOperator.
waitWindow(new JToolTipWindowFinder(),
0,
getTimeouts(),
getOutput()),
new JToolTipFinder(),
0,
getTimeouts(),
getOutput()));
return JToolTipOperator.waitJToolTip(this);
}
/**
@ -1228,61 +1219,4 @@ public class JComponentOperator extends ContainerOperator<Container>
}
}
static class JToolTipWindowFinder implements ComponentChooser {
ComponentChooser ppFinder;
public JToolTipWindowFinder() {
ppFinder = new ComponentChooser() {
@Override
public boolean checkComponent(Component comp) {
return (comp.isShowing()
&& comp.isVisible()
&& comp instanceof JToolTip);
}
@Override
public String getDescription() {
return "A tool tip";
}
@Override
public String toString() {
return "JComponentOperator.JToolTipWindowFinder.ComponentChooser{description = " + getDescription() + '}';
}
};
}
@Override
public boolean checkComponent(Component comp) {
if (comp.isShowing() && comp instanceof Window) {
ComponentSearcher cs = new ComponentSearcher((Container) comp);
cs.setOutput(JemmyProperties.getCurrentOutput().createErrorOutput());
return (cs.findComponent(ppFinder)
!= null);
}
return false;
}
@Override
public String getDescription() {
return "A tool tip window";
}
@Override
public String toString() {
return "JToolTipWindowFinder{" + "ppFinder=" + ppFinder + '}';
}
}
class JToolTipFinder extends Finder {
public JToolTipFinder(ComponentChooser sf) {
super(JToolTip.class, sf);
}
public JToolTipFinder() {
super(JToolTip.class);
}
}
}

519
test/jdk/sanity/client/lib/jemmy/src/org/netbeans/jemmy/operators/JToolTipOperator.java Normal file

@ -0,0 +1,519 @@
/*
* Copyright (c) 2018, 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. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* 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.Window;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Hashtable;
import java.util.List;
import javax.swing.JComponent;
import javax.swing.JToolTip;
import javax.swing.plaf.ToolTipUI;
import org.netbeans.jemmy.ComponentChooser;
import org.netbeans.jemmy.ComponentSearcher;
import org.netbeans.jemmy.TimeoutExpiredException;
import org.netbeans.jemmy.Waitable;
/**
* <BR>
* <BR>
* Timeouts used: <BR>
* {@code ComponentOperator.WaitComponentTimeout} - time to wait component
* displayed.<BR>
* {@code ComponentOperator.WaitStateTimeout} - time to wait for tip text. <BR>
*
* @see org.netbeans.jemmy.Timeouts
*/
public class JToolTipOperator extends JComponentOperator {
/**
* Identifier for a "tip text" property.
*
* @see #getDump()
*/
public static final String TIP_TEXT_DPROP = "TipText";
/**
* Constructs a JToolTipOperator object, waiting for a shown
* JToolTip.
*/
public JToolTipOperator() {
this(TRUE_CHOOSER);
}
/**
* Constructs a JToolTipOperator object for a given JToolTip component.
*
* @param toolTip
* a component
*/
public JToolTipOperator(JToolTip toolTip) {
super(toolTip);
}
/**
* Constructs a JToolTipOperator object waiting for the JToolTip having a
* given tip text (compared using default string comparator).
*
* @param tipText
* tip text.
* @see #getDefaultStringComparator()
*/
public JToolTipOperator(String tipText) {
this(waitJToolTip(new JToolTipByTipTextFinder(tipText,
getDefaultStringComparator())));
}
/**
* Constructs a JToolTipOperator object waiting for the JToolTip
* associated with the given component. Uses {@code comp}'s timeout and
* output for waiting. Copies environment from {@code comp}.
*
* @param comp
* component on which tool tip associated
* @see #copyEnvironment(org.netbeans.jemmy.operators.Operator)
*/
public JToolTipOperator(ComponentOperator comp) {
this(comp, TRUE_CHOOSER);
}
/**
* Constructs a JToolTipOperator object waiting for the JToolTip
* conforming to the given component chooser.
*
* @param chooser
* a component chooser specifying searching criteria.
*/
public JToolTipOperator(ComponentChooser chooser) {
this(null, chooser);
}
/**
* Constructs a JToolTipOperator object waiting for the JToolTip
* associated with the given component and conforming to the given
* component chooser. Uses {@code comp}'s timeout and output for waiting.
* Copies environment from {@code comp}.
*
* @param comp
* component on which tool tip associated
* @param chooser
* a component chooser specifying searching criteria.
* @see #copyEnvironment(org.netbeans.jemmy.operators.Operator)
*/
public JToolTipOperator(ComponentOperator comp, ComponentChooser chooser) {
this(waitJToolTip(comp, chooser));
if(comp != null) {
copyEnvironment(comp);
}
}
/**
* Constructs a JToolTipOperator object waiting for the JToolTip
* associated with the given component and having the given tip text.
* Uses {@code comp}'s string comparator for tip text comparison, timeout
* and output for waiting. Copies environment from {@code comp}.
*
* @param comp
* component on which tool tip associated
* @param tipText
* tip text
* @see #getComparator()
* @see #copyEnvironment(org.netbeans.jemmy.operators.Operator)
*/
public JToolTipOperator(ComponentOperator comp, String tipText) {
this(waitJToolTip(comp,
new JToolTipByTipTextFinder(tipText, comp.getComparator())));
copyEnvironment(comp);
}
/**
* Searches for the JToolTip associated with the given component and
* conforming to the given component chooser. Uses {@code comp}'s timeout
* and output for waiting.
*
* @param comp
* component on which tool tip associated
* @param chooser
* a component chooser specifying searching criteria.
* @return JToolTip instance or null if component was not found.
*/
public static JToolTip findJToolTip(ComponentOperator comp,
ComponentChooser chooser) {
List<Window> windowList;
if(comp != null && comp.getWindow() != null) {
windowList = new ArrayList<>(
Arrays.asList(comp.getWindow().getOwnedWindows()));
windowList.add(comp.getWindow());
} else {
windowList = new ArrayList<>(
Arrays.asList(WindowOperator.getWindows()));
}
ComponentChooser toolTipChooser = new JToolTipFinder(chooser);
for (Window w : windowList) {
ComponentSearcher searcher = new ComponentSearcher(w);
Component[] components = searcher.findComponents(toolTipChooser);
if (components.length > 0) {
if(comp!= null && comp.getSource() != null) {
if(comp.getSource().equals(
((JToolTip) components[0]).getComponent())) {
return (JToolTip) components[0];
}
} else {
return (JToolTip) components[0];
}
}
}
return null;
}
/**
* Searches for a JToolTip.
*
* @return JToolTip instance or null if component was not found.
*/
public static JToolTip findJToolTip() {
return findJToolTip(null);
}
/**
* Searches for the JToolTip associated with the given component. Uses
* {@code comp}'s timeout and output for waiting.
*
* @param comp
* component on which tool tip associated
* @return JToolTip instance or null if component was not found.
*/
public static JToolTip findJToolTip(ComponentOperator comp) {
return findJToolTip(comp, TRUE_CHOOSER);
}
/**
* Searches for the JToolTip associated with the given component and
* looking for given tip text using specified string comparator options.
* Uses {@code comp}'s timeout and output for waiting.
*
* @param comp
* component on which tool tip associated
* @param tipText
* Tip text.
* @param ce
* Compare text exactly.
* @param ccs
* Compare text case sensitively.
* @return JToolTip instance or null if component was not found.
* @see DefaultStringComparator
* @see JToolTipByTipTextFinder
*/
public static JToolTip findJToolTip(ComponentOperator comp, String tipText,
boolean ce, boolean ccs) {
return findJToolTip(comp, new JToolTipByTipTextFinder(tipText,
new DefaultStringComparator(ce, ccs)));
}
/**
* Waits for a JToolTip.
*
* @return JToolTip instance.
* @see TimeoutExpiredException
*/
public static JToolTip waitJToolTip() {
return waitJToolTip(TRUE_CHOOSER);
}
/**
* Waits for the first JToolTip associated with the given component.
*
* @param comp
* component on which tool tip associated
* @return JToolTip instance.
* @see TimeoutExpiredException
*/
public static JToolTip waitJToolTip(ComponentOperator comp) {
return waitJToolTip(comp, TRUE_CHOOSER);
}
/**
* Waits for the JToolTip conforming to the given component
* chooser.
*
* @param chooser
* a component chooser specifying searching criteria.
* @return JToolTip instance.
* @see TimeoutExpiredException
*/
public static JToolTip waitJToolTip(ComponentChooser chooser) {
return waitJToolTip(null, chooser);
}
/**
* Waits for the JToolTip associated with the given component and
* conforming to the specified component chooser.
*
* @param comp
* component on which tool tip associated
* @param chooser
* a component chooser specifying searching criteria.
* @return JToolTip instance.
* @see TimeoutExpiredException
*/
public static JToolTip waitJToolTip(ComponentOperator comp,
ComponentChooser chooser) {
return Operator.getEnvironmentOperator().
waitState(new Waitable<JToolTip, Void>() {
@Override
public JToolTip actionProduced(Void obj) {
return findJToolTip(comp, chooser);
}
@Override
public String getDescription() {
return "Wait for JTooltip to be displayed for Component = "
+ comp + ", " + "chooser = " + chooser;
}
@Override
public String toString() {
return "JToolTipOperator.waitJToolTip.Waitable{description = "
+ getDescription() + '}';
}
});
}
/**
* Waits for the JToolTip associated with the given component and having
* the given tip text compared using given string comparator options.
*
* @param comp
* component on which tool tip associated
* @param tipText
* Tip text.
* @param ce
* Compare text exactly.
* @param ccs
* Compare text case sensitively.
* @return JToolTip instance.
* @see TimeoutExpiredException
*/
public static JToolTip waitJToolTip(ComponentOperator comp, String tipText,
boolean ce, boolean ccs) {
return waitJToolTip(comp, new JToolTipByTipTextFinder(tipText,
new DefaultStringComparator(ce, ccs)));
}
/**
* Waits for the given tip text. Uses {@linkplain #getComparator()}
* comparator.
*
* @param tipText
* Tip text to wait for.
* @see TimeoutExpiredException
*/
public void waitTipText(String tipText) {
getOutput().printLine("Wait \"" + tipText
+ "\" tip text in JToolTip \n : " + toStringSource());
getOutput().printGolden("Wait \"" + tipText + "\" tip text");
waitState(new JToolTipByTipTextFinder(tipText, getComparator()));
}
/**
* Returns information about the component.
*
* @return Map of component properties.
*/
@Override
public Hashtable<String, Object> getDump() {
Hashtable<String, Object> result = super.getDump();
String tipText = getTipText();
if (tipText != null) {
result.put(TIP_TEXT_DPROP, tipText);
} else {
result.put(TIP_TEXT_DPROP, "null");
}
return result;
}
////////////////////////////////////////////////////////
// Mapping //
/**
* Maps {@linkplain JToolTip#getTipText()} through queue
*
* @return
*/
public String getTipText() {
return runMapping(new MapAction<String>("getTipText") {
@Override
public String map() {
return ((JToolTip) getSource()).getTipText();
}
});
}
/**
* Maps {@linkplain JToolTip#getComponent()} through queue
*
* @return
*/
public JComponent getComponent() {
return runMapping(new MapAction<JComponent>("getComponent") {
@Override
public JComponent map() {
return ((JToolTip) getSource()).getComponent();
}
});
}
/**
* Maps {@linkplain JToolTip#getUI()} through queue
*
* @return
*/
public ToolTipUI getUI() {
return runMapping(new MapAction<ToolTipUI>("getUI") {
@Override
public ToolTipUI map() {
return ((JToolTip) getSource()).getUI();
}
});
}
/**
* Maps {@linkplain JToolTip#setTipText(String)} through queue
*
* @param tipText
*/
public void setTipText(final String tipText) {
runMapping(new MapVoidAction("setTipText") {
@Override
public void map() {
((JToolTip) getSource()).setTipText(tipText);
}
});
}
/**
* Maps {@linkplain JToolTip#setComponent(JComponent)} through queue
*
* @param component
*/
public void setComponent(final JComponent component) {
runMapping(new MapVoidAction("setComponent") {
@Override
public void map() {
((JToolTip) getSource()).setComponent(component);
}
});
}
// End of mapping //
////////////////////////////////////////////////////////
/**
* Allows to find JToolTip by tip text.
*/
public static class JToolTipByTipTextFinder implements ComponentChooser {
String tipText;
StringComparator comparator;
/**
* Constructs JToolTipByTipTextFinder.
*
* @param tipText
* a tip text pattern
* @param comparator
* specifies string comparison algorithm.
*/
public JToolTipByTipTextFinder(String tipText,
StringComparator comparator) {
this.tipText = tipText;
this.comparator = comparator;
}
/**
* Constructs JToolTipByTipTextFinder.
*
* @param tipText
* a tip text pattern
*/
public JToolTipByTipTextFinder(String tipText) {
this(tipText, Operator.getDefaultStringComparator());
}
@Override
public boolean checkComponent(Component comp) {
if (comp instanceof JToolTip) {
if (((JToolTip) comp).getTipText() != null) {
return (comparator.equals(((JToolTip) comp).getTipText(),
tipText));
}
}
return false;
}
@Override
public String getDescription() {
return "JToolTip with tip text \"" + tipText + "\"";
}
@Override
public String toString() {
return "JToolTipByTipTextFinder{" + "tipText=" + tipText
+ ", comparator=" + comparator + '}';
}
}
/**
* Allows to find JToolTips among components.
*/
public static class JToolTipFinder extends Finder {
/**
* Constructs JToolTipFinder chaining another component chooser.
*
* @param sf
* other searching criteria.
*/
public JToolTipFinder(ComponentChooser sf) {
super(JToolTip.class, sf);
}
/**
* Constructs JToolTipFinder.
*/
public JToolTipFinder() {
super(JToolTip.class);
}
}
private static final ComponentChooser TRUE_CHOOSER = ComponentSearcher
.getTrueChooser("Any JToolTip");
}

17
test/jdk/sanity/client/lib/jemmy/src/org/netbeans/jemmy/operators/Operator.java

@ -693,7 +693,7 @@ public abstract class Operator
* defined by {@code "ComponentOperator.WaitStateTimeout"}
*/
public void waitState(final ComponentChooser state) {
Waiter<String, Void> stateWaiter = new Waiter<>(new Waitable<String, Void>() {
waitState(new Waitable<String, Void>() {
@Override
public String actionProduced(Void obj) {
return state.checkComponent(getSource()) ? "" : null;
@ -710,13 +710,20 @@ public abstract class Operator
return "Operator.waitState.Waitable{description = " + getDescription() + '}';
}
});
stateWaiter.setTimeoutsToCloneOf(getTimeouts(), "ComponentOperator.WaitStateTimeout");
}
public <R> R waitState(Waitable<R, Void> waitable) {
Waiter<R, Void> stateWaiter = new Waiter<>(waitable);
stateWaiter.setTimeoutsToCloneOf(getTimeouts(),
"ComponentOperator.WaitStateTimeout");
stateWaiter.setOutput(getOutput().createErrorOutput());
try {
stateWaiter.waitAction(null);
return stateWaiter.waitAction(null);
} catch (InterruptedException e) {
throw (new JemmyException("Waiting of \"" + state.getDescription()
+ "\" state has been interrupted!"));
Thread.currentThread().interrupt();
throw (new JemmyException(
"Waiting of \"" + waitable.getDescription()
+ "\" state has been interrupted!"));
}
}

18
test/jdk/sanity/client/lib/jemmy/src/org/netbeans/jemmy/operators/WindowOperator.java

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2018, 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
@ -36,6 +36,7 @@ import org.netbeans.jemmy.ComponentSearcher;
import org.netbeans.jemmy.JemmyException;
import org.netbeans.jemmy.JemmyProperties;
import org.netbeans.jemmy.Outputable;
import org.netbeans.jemmy.QueueTool;
import org.netbeans.jemmy.TestOut;
import org.netbeans.jemmy.TimeoutExpiredException;
import org.netbeans.jemmy.Timeouts;
@ -585,6 +586,21 @@ public class WindowOperator extends ContainerOperator<Window>
});
}
/**
* Maps {@code Window.getWindows()} through queue
*
* @return result of {@code Window.getWindows()}
*/
public static Window[] getWindows() {
return new QueueTool().invokeSmoothly(
new QueueTool.QueueAction<Window[]>("getWindows") {
@Override
public Window[] launch() throws Exception {
return Window.getWindows();
}
});
}
//End of mapping //
////////////////////////////////////////////////////////
////////////////////////////////////////////////////////

2
test/jdk/sanity/client/lib/jemmy/src/org/netbeans/jemmy/version_info

@ -1,6 +1,6 @@
Manifest-version: 1.0
Main-Class: org.netbeans.jemmy.JemmyProperties
Jemmy-MajorVersion: 3.0
Jemmy-MinorVersion: 3.0
Jemmy-MinorVersion: 4.0
Jemmy-Build: @BUILD_NUMBER@