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
+      }
+    }
+  }
 }