This is the mail archive of the
mauve-discuss@sourceware.org
mailing list for the Mauve project.
Re: Tweaking default java.awt.Robot settings
- From: "Steve McKayâ" <smckay at google dot com>
- To: "Thomas Fitzsimmons" <fitzsim at redhat dot com>
- Cc: "David Herron" <David dot Herron at sun dot com>, mauve-discuss at sources dot redhat dot com, "Dan Kegel" <dkegel at google dot com>
- Date: Wed, 3 Oct 2007 17:42:43 -0700
- Subject: Re: Tweaking default java.awt.Robot settings
- References: <4f2ee4520709241331o1a77379cudffb314dc1622914@mail.gmail.com> <46F8238C.8020606@sun.com> <46F95466.7070700@redhat.com> <4f2ee4520709251156yde57b65tbb97032939ac75e6@mail.gmail.com> <46F96854.6080706@redhat.com> <4f2ee4520709251328s388c16ebs46f66ce3232cb48f@mail.gmail.com>
Here's a patch for the test. Everything seems to be working well. I
haven't looked through the other tests yet to see how this might be
shared.
--steve
On 9/25/07, Steve McKayâ <smckay@google.com> wrote:
> Thomas,
>
> > Even after you've ensured that the frame has responded, subsequent checks will
> > still need to be synchronized, since Robot calls are not synchronous.
>
> That was just a code snippet to demonstrate how to solve one part of
> the problem. The code that does the actual testing is synchronized on
> the lock as well. But like I said, there were liveness issues. I'll
> try to work those out. Still, I can't honestly say that I'd want to go
> through the same amount of effort for every test involving Robot, so
> this change is sorta speculative rather than practical.
>
> --
> Steve McKay <smckay@google.com>
>
--
Steve McKay <smckay@google.com>
Index: keyPressTest.java
===================================================================
RCS file: /cvs/mauve/mauve/gnu/testlet/java/awt/Component/keyPressTest.java,v
retrieving revision 1.2
diff -u -r1.2 keyPressTest.java
--- keyPressTest.java 31 Mar 2006 23:08:06 -0000 1.2
+++ keyPressTest.java 4 Oct 2007 00:36:00 -0000
@@ -31,17 +31,26 @@
public class keyPressTest implements Testlet
{
- int key = 0;
+ //arbitrary lock for use in synchronizing test and awt threads
+ final Object lock = new Object();
+
+ volatile Integer key = null;
+
Robot r;
myFrame f;
TestHarness h;
-
+
public void test (TestHarness h)
{
f = new myFrame();
r = h.createRobot ();
this.h = h;
-
+
+ f.setSize(200,200); // assumes that the window is positioned at 0,0.
+ f.show();
+
+ waitForWindow();
+
runTest(KeyEvent.VK_A, 'a');
runTest(KeyEvent.VK_B, 'b');
runTest(KeyEvent.VK_C, 'c');
@@ -68,31 +77,84 @@
runTest(KeyEvent.VK_X, 'x');
runTest(KeyEvent.VK_Y, 'y');
runTest(KeyEvent.VK_Z, 'z');
+
+ f.dispose();
}
-
+
public void runTest(int code, char chr)
{
- KeyEvent e = new KeyEvent(f, KeyEvent.KEY_PRESSED, 0, 0, code, chr, KeyEvent.KEY_LOCATION_STANDARD);
- f.dispatchEvent(e);
-
-
- f.setSize(200,200);
- f.show();
+ int k; // assigned in the synchronized block
r.mouseMove(60, 60);
- r.keyPress(code);
- r.keyRelease(code);
- h.check(key, (int) chr);
- }
+ synchronized(lock) {
+ key = null; // reset the key
+
+ // queue the events
+ r.keyPress(code);
+ r.keyRelease(code); // don't press they key forever
- class myFrame
- extends Frame
- {
-
- public boolean keyDown(Event e, int i)
- {
- key = e.key;
+ try {
+
+ // release the lock so that the frame can handle the keypress event
+ // once it has handled the event, it will notify on the lock.
+ // at this point the key should be non-null. We test the result
+ // and return
+ lock.wait();
+ } catch (InterruptedException e) {
+ // ignore, we want to get started again
+ }
+
+ k = key.intValue();
+ }
+
+ h.check(k, chr);
+ }
+
+ class myFrame extends Frame {
+
+ public boolean keyDown(Event e, int i) {
+ synchronized(lock) {
+ key = new Integer(e.key);
+ lock.notifyAll();
+ }
return super.keyDown(e, i);
}
}
+
+ /**
+ * Blocks until the frame has able to respond to keypress events
+ */
+ private void waitForWindow() {
+
+ // wait until the window starts process events
+ synchronized(lock) {
+ while (key == null) {
+ r.keyPress(KeyEvent.VK_EQUALS); // send a key press event
+ r.keyRelease(KeyEvent.VK_EQUALS); // don't press the key forever
+ try {
+
+ // wait for a notify from the frame, or timeout in case the
+ // window missed the key press event entirely
+ lock.wait(100);
+ }
+ catch (InterruptedException ie) {
+ // interrupted, if key is still null, we'll try again
+ }
+ }
+
+ // send one more "magic" key press as a marker that we've processed
+ // all of our probing key strokes
+ r.keyPress(KeyEvent.VK_SEMICOLON); // send a key press event
+ r.keyRelease(KeyEvent.VK_SEMICOLON); // don't press the key forever
+ }
+
+ // Eat up any straggler key strokes, wait for the final magic key press
+ while(key != KeyEvent.VK_SEMICOLON) {
+ try {
+ Thread.sleep(100);
+ } catch (InterruptedException e) {
+ // shouldn't happen
+ }
+ }
+ }
}