1 /*
   2  * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 
  25 import java.awt.*;
  26 import java.awt.event.*;
  27 import java.lang.reflect.InvocationTargetException;
  28 import javax.swing.SwingUtilities;
  29 import java.io.*;
  30 
  31 /**
  32  * AWT Mixing test for HierarchyBoundsListener ancestors.
  33  * <p>See <a href="https://bugs.openjdk.java.net/browse/JDK-6768230">CR6768230</a> for details.
  34  */
  35 /*
  36 @test
  37 @bug 6768230
  38 @summary Mixing test for HierarchyBoundsListener ancestors
  39 @build FrameBorderCounter
  40 @run main HierarchyBoundsListenerMixingTest
  41  */
  42 public class HierarchyBoundsListenerMixingTest {
  43 
  44     protected void prepareControls() {
  45         dummy = new Frame();
  46         dummy.setSize(100, 100);
  47         dummy.setLocation(0, 350);
  48         dummy.setVisible(true);
  49 
  50         frame = new Frame("Test Frame");
  51         frame.setLayout(new FlowLayout());
  52 
  53         panel = new Panel();
  54         button = new Button("Button");
  55         label = new Label("Label");
  56         list = new List();
  57         list.add("One");
  58         list.add("Two");
  59         list.add("Three");
  60         choice = new Choice();
  61         choice.add("Red");
  62         choice.add("Orange");
  63         choice.add("Yellow");
  64         checkbox = new Checkbox("Checkbox");
  65         scrollbar = new Scrollbar(Scrollbar.HORIZONTAL, 0, 1, 0, 255);
  66         textfield = new TextField(15);
  67         textarea = new TextArea(5, 15);
  68 
  69         components = new Component[] {
  70             panel, button, label, list, choice, checkbox, scrollbar, textfield, textarea
  71         };
  72         ancestorResized = new boolean[components.length];
  73         ancestorMoved = new boolean[components.length];
  74 
  75         frame.addWindowListener(new WindowAdapter() {
  76             @Override
  77             public void windowClosing(WindowEvent event) {
  78                 System.err.println("User closed the window");
  79                 System.exit(1);
  80             }
  81         });
  82 
  83         HierarchyBoundsListener listener = new HierarchyBoundsListenerImpl();
  84         for (int i = 0; i < components.length; i++) {
  85             components[i].addHierarchyBoundsListener(listener);
  86             frame.add(components[i]);
  87         }
  88         frame.setSize(300, 300);
  89         frame.setVisible(true);
  90     }
  91 
  92     private int frameBorderCounter() {
  93         String JAVA_HOME = System.getProperty("java.home");
  94 
  95         try {
  96             Process p = Runtime.getRuntime().exec(JAVA_HOME + "/bin/java FrameBorderCounter");
  97             try {
  98                 p.waitFor();
  99             } catch (InterruptedException e) {
 100                 e.printStackTrace();
 101                 throw new RuntimeException(e);
 102             }
 103             if (p.exitValue() != 0) {
 104                 throw new RuntimeException("FrameBorderCounter exited with not null code!\n" + readInputStream(p.getErrorStream()));
 105             }
 106             return Integer.parseInt(readInputStream(p.getInputStream()).trim());
 107         } catch (IOException e) {
 108             e.printStackTrace();
 109             throw new RuntimeException(e);
 110         }
 111     }
 112 
 113     private String readInputStream(InputStream is) throws IOException {
 114         byte[] buffer = new byte[4096];
 115         int len = 0;
 116         StringBuilder sb = new StringBuilder();
 117         try (InputStreamReader isr = new InputStreamReader(is)) {
 118             while ((len = is.read(buffer)) > 0) {
 119                 sb.append(new String(buffer, 0, len));
 120             }
 121         }
 122         return sb.toString();
 123     }
 124 
 125     protected boolean performTest() {
 126         int BORDER_SHIFT = frameBorderCounter();
 127         BORDER_SHIFT = Math.abs(BORDER_SHIFT) == 1 ? BORDER_SHIFT : BORDER_SHIFT / 2;
 128         Robot robot = null;
 129         try {
 130             robot = new Robot();
 131             Thread.sleep(delay * 10);
 132         } catch (Exception e) {
 133             e.printStackTrace();
 134             System.exit(1);
 135         }
 136 
 137         robot.mouseMove((int) components[0].getLocationOnScreen().x + components[0].getSize().width / 2,
 138                         (int) components[0].getLocationOnScreen().y + components[0].getSize().height / 2);
 139         robot.delay(delay);
 140         robot.mousePress(InputEvent.BUTTON1_MASK);
 141         robot.delay(delay);
 142         robot.mouseRelease(InputEvent.BUTTON1_MASK);
 143         robot.delay(delay);
 144 
 145         resetValues();
 146         try {
 147             EventQueue.invokeAndWait(new Runnable() {
 148                 public void run() {
 149                     frame.setSize(new Dimension(frame.getSize().width + 10, frame.getSize().height + 10));
 150                     frame.invalidate();
 151                     frame.validate();
 152                 }
 153             });
 154         } catch (Exception e) {
 155             e.printStackTrace();
 156             passed = false;
 157         }
 158         if (! resizeTriggered) {
 159             synchronized (resizeLock) {
 160                 try {
 161                     resizeLock.wait(delay * 10);
 162                 } catch (Exception e) {
 163                 }
 164             }
 165         }
 166         for (int i = 0; i < components.length; i++) {
 167             if (! ancestorResized[i]) {
 168                 System.err.println("FAIL: Frame resized using API call. " +
 169                                    "Ancestor resized event did not occur for " + components[i].getClass());
 170                 passed = false;
 171             }
 172         }
 173         if (moveCount > 0) {
 174             System.err.println("FAIL: Ancestor moved event occured when Frame resized using API");
 175             passed = false;
 176         }
 177         robot.delay(delay * 5);
 178 
 179         resetValues();
 180         int x = (int) frame.getLocationOnScreen().x;
 181         int y = (int) frame.getLocationOnScreen().y;
 182         int w = frame.getSize().width;
 183         int h = frame.getSize().height;
 184 
 185         robot.mouseMove(x + w + BORDER_SHIFT, y + h / 2);
 186         robot.delay(delay);
 187         robot.mousePress(InputEvent.BUTTON1_MASK);
 188         robot.delay(delay);
 189         for (int i = 0; i < 20; i++) {
 190             robot.mouseMove(x + w + i + BORDER_SHIFT, y + h / 2);
 191             robot.delay(50);
 192         }
 193         robot.delay(delay);
 194         robot.mouseRelease(InputEvent.BUTTON1_MASK);
 195 
 196         if (! resizeTriggered) {
 197             synchronized (resizeLock) {
 198                 try {
 199                     resizeLock.wait(delay * 10);
 200                 } catch (Exception e) {
 201                 }
 202             }
 203         }
 204 
 205         for (int i = 0; i < components.length; i++) {
 206             if (! ancestorResized[i]) {
 207                 System.err.println("FAIL: Frame resized using mouse action. " +
 208                                    "Ancestor resized event did not occur for " +
 209                                    components[i].getClass());
 210                 passed = false;
 211             }
 212         }
 213         if (moveCount > 0) {
 214             System.err.println("FAIL: Ancestor moved event occured when Frame resized using mouse");
 215             passed = false;
 216         }
 217 
 218         resetValues();
 219         try {
 220             EventQueue.invokeAndWait(new Runnable() {
 221                 public void run() {
 222                     frame.setLocation(frame.getLocation().x + 20, frame.getLocation().y + 20);
 223                     frame.invalidate();
 224                     frame.validate();
 225                 }
 226             });
 227         } catch (Exception e) {
 228             e.printStackTrace();
 229             passed = false;
 230         }
 231         if (! moveTriggered) {
 232             synchronized (moveLock) {
 233                 try {
 234                     moveLock.wait(delay * 10);
 235                 } catch (Exception e) {
 236                 }
 237             }
 238         }
 239         for (int i = 0; i < components.length; i++) {
 240             if (! ancestorMoved[i]) {
 241                 System.err.println("FAIL: Frame moved using API call. " +
 242                                    "Ancestor moved event did not occur for " + components[i].getClass());
 243                 passed = false;
 244             }
 245         }
 246         if (resizeCount > 0) {
 247             System.err.println("FAIL: Ancestor resized event occured when Frame moved using API");
 248             passed = false;
 249         }
 250         robot.delay(delay * 10);
 251 
 252         resetValues();
 253         x = (int) frame.getLocationOnScreen().x;
 254         y = (int) frame.getLocationOnScreen().y;
 255         w = frame.getSize().width;
 256         h = frame.getSize().height;
 257 
 258         //Click on the dummy frame so that the test frame loses focus. This is to workaround
 259         //a bug in Linux AS.
 260         robot.mouseMove((int) dummy.getLocationOnScreen().x + dummy.getSize().width / 2,
 261                         (int) dummy.getLocationOnScreen().y + dummy.getSize().height / 2);
 262         robot.delay(delay);
 263         robot.mousePress(InputEvent.BUTTON1_MASK);
 264         robot.delay(delay);
 265         robot.mouseRelease(InputEvent.BUTTON1_MASK);
 266         robot.delay(delay);
 267 
 268         robot.mouseMove(x + w / 2, y + 10);
 269         robot.delay(delay);
 270         robot.mousePress(InputEvent.BUTTON1_MASK);
 271         robot.delay(delay);
 272         for (int i = 1; i <= 20; i++) {
 273             robot.mouseMove(x + w / 2 + i, y + 10);
 274             robot.delay(50);
 275         }
 276         robot.delay(delay);
 277         robot.mouseRelease(InputEvent.BUTTON1_MASK);
 278 
 279         if (! moveTriggered) {
 280             synchronized (moveLock) {
 281                 try {
 282                     moveLock.wait(delay * 10);
 283                 } catch (Exception e) {
 284                 }
 285             }
 286         }
 287 
 288         for (int i = 0; i < components.length; i++) {
 289             if (! ancestorMoved[i]) {
 290                 System.err.println("FAIL: Frame moved using mouse action. " +
 291                                    "Ancestor moved event did not occur for " + components[i].getClass());
 292                 passed = false;
 293             }
 294         }
 295         if (resizeCount > 0) {
 296             System.err.println("FAIL: Ancestor resized event occured when Frame moved using mouse");
 297             passed = false;
 298         }
 299 
 300         return passed;
 301     }
 302 
 303     private void resetValues() {
 304         moveTriggered = false;
 305         resizeTriggered = false;
 306         moveCount = 0;
 307         resizeCount = 0;
 308         for (int i = 0; i < ancestorResized.length; i++) {
 309             ancestorResized[i] = false;
 310             ancestorMoved[i] = false;
 311         }
 312     }
 313 
 314     private void keyType(int key, Robot robot) throws Exception {
 315         robot.keyPress(key);
 316         robot.delay(keyDelay);
 317         robot.keyRelease(key);
 318         robot.delay(keyDelay);
 319     }
 320 
 321     class HierarchyBoundsListenerImpl implements HierarchyBoundsListener {
 322         // checks for Ancestor_Moved events
 323         public void ancestorMoved(HierarchyEvent ce) {
 324             if (check) {
 325                 System.out.println("Moved " + ce.getComponent());
 326             }
 327             for (int i = 0; i < components.length; i++) {
 328                 if (components[i].equals(ce.getComponent())) {
 329                     //setting this array for purpose of checking ancestor_moved.
 330                     ancestorMoved[i] = true;
 331                     moveCount++;
 332                     if (moveCount == components.length) {
 333                         moveTriggered = true;
 334                         synchronized (moveLock) {
 335                             try {
 336                                 moveLock.notifyAll();
 337                             } catch (Exception e) {
 338                             }
 339                         }
 340                     }
 341                 }
 342             }
 343         }
 344         // checks for Ancestor_Moved events
 345         public void ancestorResized(HierarchyEvent ce) {
 346             if (check) {
 347                 System.out.println("Resized " + ce.getComponent());
 348             }
 349             for (int i = 0; i < components.length; i++) {
 350                 if (components[i].equals(ce.getComponent())) {
 351                     if (! frame.equals(ce.getChanged()) || ce.getChangedParent() != null) {
 352                         System.err.println("FAIL: Invalid value of HierarchyEvent.getXXX");
 353                         System.err.println("ce.getChanged() : " + ce.getChanged());
 354                         System.err.println("ce.getChangedParent() : " + ce.getChangedParent());
 355                         passed = false;
 356                     }
 357                     //setting this array for purpose of checking ancestor_resized
 358                     ancestorResized[i] = true;
 359                     resizeCount++;
 360                     if (resizeCount == components.length) {
 361                         resizeTriggered = true;
 362                         synchronized (resizeLock) {
 363                             try {
 364                                 resizeLock.notifyAll();
 365                             } catch (Exception e) {
 366                             }
 367                         }
 368                     }
 369                 }
 370             }
 371         }
 372     }
 373 
 374     private Frame frame, dummy;
 375     private Panel panel;
 376     private Button button;
 377     private Label label;
 378     private List list;
 379     private Choice choice;
 380     private Checkbox checkbox;
 381     private Scrollbar scrollbar;
 382     private TextField textfield;
 383     private TextArea textarea;
 384     private Component[] components;
 385     private boolean[] ancestorResized;
 386     private boolean[] ancestorMoved;
 387 
 388     private int delay = 500;
 389     private int keyDelay = 50;
 390     private int moveCount = 0;
 391     private int resizeCount = 0;
 392 
 393     private boolean passed = true;
 394     private boolean moveTriggered = false;
 395     private boolean resizeTriggered = false;
 396     private final Object moveLock = new Object();
 397     private final Object resizeLock = new Object();
 398 
 399     private boolean check = false;
 400 
 401     private void invoke() throws InterruptedException {
 402         try {
 403             SwingUtilities.invokeAndWait(new Runnable() {
 404 
 405                 public void run() {
 406                     prepareControls();
 407                 }
 408             });
 409             try {
 410                 Thread.sleep(1000); // wait for graphic effects on systems like Win7
 411             } catch (InterruptedException ex) {
 412             }
 413             if (!performTest()) {
 414                 fail("Test failed");
 415             }
 416         } catch (InvocationTargetException ex) {
 417             fail(ex.getMessage());
 418         }
 419     }
 420 
 421     /*****************************************************
 422      * Standard Test Machinery Section
 423      * DO NOT modify anything in this section -- it's a
 424      * standard chunk of code which has all of the
 425      * synchronisation necessary for the test harness.
 426      * By keeping it the same in all tests, it is easier
 427      * to read and understand someone else's test, as
 428      * well as insuring that all tests behave correctly
 429      * with the test harness.
 430      * There is a section following this for test-
 431      * classes
 432      ******************************************************/
 433     private static void init() throws InterruptedException {
 434         //*** Create instructions for the user here ***
 435         //System.setProperty("sun.awt.disableMixing", "true");
 436 
 437         String[] instructions = {
 438             "This is an AUTOMATIC test, simply wait until it is done.",
 439             "The result (passed or failed) will be shown in the",
 440             "message window below."
 441         };
 442         Sysout.createDialog();
 443         Sysout.printInstructions(instructions);
 444 
 445         HierarchyBoundsListenerMixingTest instance = new HierarchyBoundsListenerMixingTest();
 446 
 447         instance.invoke();
 448 
 449         pass();
 450     }//End  init()
 451     private static boolean theTestPassed = false;
 452     private static boolean testGeneratedInterrupt = false;
 453     private static String failureMessage = "";
 454     private static Thread mainThread = null;
 455     private static int sleepTime = 300000;
 456 
 457     // Not sure about what happens if multiple of this test are
 458     //  instantiated in the same VM.  Being static (and using
 459     //  static vars), it aint gonna work.  Not worrying about
 460     //  it for now.
 461     public static void main(String args[]) throws InterruptedException {
 462         mainThread = Thread.currentThread();
 463         try {
 464             init();
 465         } catch (TestPassedException e) {
 466             //The test passed, so just return from main and harness will
 467             // interepret this return as a pass
 468             return;
 469         }
 470         //At this point, neither test pass nor test fail has been
 471         // called -- either would have thrown an exception and ended the
 472         // test, so we know we have multiple threads.
 473 
 474         //Test involves other threads, so sleep and wait for them to
 475         // called pass() or fail()
 476         try {
 477             Thread.sleep(sleepTime);
 478             //Timed out, so fail the test
 479             throw new RuntimeException("Timed out after " + sleepTime / 1000 + " seconds");
 480         } catch (InterruptedException e) {
 481             //The test harness may have interrupted the test.  If so, rethrow the exception
 482             // so that the harness gets it and deals with it.
 483             if (!testGeneratedInterrupt) {
 484                 throw e;
 485             }
 486 
 487             //reset flag in case hit this code more than once for some reason (just safety)
 488             testGeneratedInterrupt = false;
 489 
 490             if (theTestPassed == false) {
 491                 throw new RuntimeException(failureMessage);
 492             }
 493         }
 494 
 495     }//main
 496 
 497     public static synchronized void setTimeoutTo(int seconds) {
 498         sleepTime = seconds * 1000;
 499     }
 500 
 501     public static synchronized void pass() {
 502         Sysout.println("The test passed.");
 503         Sysout.println("The test is over, hit  Ctl-C to stop Java VM");
 504         //first check if this is executing in main thread
 505         if (mainThread == Thread.currentThread()) {
 506             //Still in the main thread, so set the flag just for kicks,
 507             // and throw a test passed exception which will be caught
 508             // and end the test.
 509             theTestPassed = true;
 510             throw new TestPassedException();
 511         }
 512         theTestPassed = true;
 513         testGeneratedInterrupt = true;
 514         mainThread.interrupt();
 515     }//pass()
 516 
 517     public static synchronized void fail() {
 518         //test writer didn't specify why test failed, so give generic
 519         fail("it just plain failed! :-)");
 520     }
 521 
 522     public static synchronized void fail(String whyFailed) {
 523         Sysout.println("The test failed: " + whyFailed);
 524         Sysout.println("The test is over, hit  Ctl-C to stop Java VM");
 525         //check if this called from main thread
 526         if (mainThread == Thread.currentThread()) {
 527             //If main thread, fail now 'cause not sleeping
 528             throw new RuntimeException(whyFailed);
 529         }
 530         theTestPassed = false;
 531         testGeneratedInterrupt = true;
 532         failureMessage = whyFailed;
 533         mainThread.interrupt();
 534     }//fail()
 535 }// class LWComboBox
 536 class TestPassedException extends RuntimeException {
 537 }
 538 
 539 //*********** End Standard Test Machinery Section **********
 540 //************ Begin classes defined for the test ****************
 541 // if want to make listeners, here is the recommended place for them, then instantiate
 542 //  them in init()
 543 
 544 /* Example of a class which may be written as part of a test
 545 class NewClass implements anInterface
 546 {
 547 static int newVar = 0;
 548 
 549 public void eventDispatched(AWTEvent e)
 550 {
 551 //Counting events to see if we get enough
 552 eventCount++;
 553 
 554 if( eventCount == 20 )
 555 {
 556 //got enough events, so pass
 557 
 558 LWComboBox.pass();
 559 }
 560 else if( tries == 20 )
 561 {
 562 //tried too many times without getting enough events so fail
 563 
 564 LWComboBox.fail();
 565 }
 566 
 567 }// eventDispatched()
 568 
 569 }// NewClass class
 570 
 571  */
 572 //************** End classes defined for the test *******************
 573 /****************************************************
 574 Standard Test Machinery
 575 DO NOT modify anything below -- it's a standard
 576 chunk of code whose purpose is to make user
 577 interaction uniform, and thereby make it simpler
 578 to read and understand someone else's test.
 579  ****************************************************/
 580 /**
 581 This is part of the standard test machinery.
 582 It creates a dialog (with the instructions), and is the interface
 583 for sending text messages to the user.
 584 To print the instructions, send an array of strings to Sysout.createDialog
 585 WithInstructions method.  Put one line of instructions per array entry.
 586 To display a message for the tester to see, simply call Sysout.println
 587 with the string to be displayed.
 588 This mimics System.out.println but works within the test harness as well
 589 as standalone.
 590  */
 591 class Sysout {
 592 
 593     private static TestDialog dialog;
 594 
 595     public static void createDialogWithInstructions(String[] instructions) {
 596         dialog = new TestDialog(new Frame(), "Instructions");
 597         dialog.printInstructions(instructions);
 598         dialog.setVisible(true);
 599         println("Any messages for the tester will display here.");
 600     }
 601 
 602     public static void createDialog() {
 603         dialog = new TestDialog(new Frame(), "Instructions");
 604         String[] defInstr = {"Instructions will appear here. ", ""};
 605         dialog.printInstructions(defInstr);
 606         dialog.setVisible(true);
 607         println("Any messages for the tester will display here.");
 608     }
 609 
 610     public static void printInstructions(String[] instructions) {
 611         dialog.printInstructions(instructions);
 612     }
 613 
 614     public static void println(String messageIn) {
 615         dialog.displayMessage(messageIn);
 616         System.out.println(messageIn);
 617     }
 618 }// Sysout  class
 619 
 620 /**
 621 This is part of the standard test machinery.  It provides a place for the
 622 test instructions to be displayed, and a place for interactive messages
 623 to the user to be displayed.
 624 To have the test instructions displayed, see Sysout.
 625 To have a message to the user be displayed, see Sysout.
 626 Do not call anything in this dialog directly.
 627  */
 628 class TestDialog extends Dialog {
 629 
 630     TextArea instructionsText;
 631     TextArea messageText;
 632     int maxStringLength = 80;
 633 
 634     //DO NOT call this directly, go through Sysout
 635     public TestDialog(Frame frame, String name) {
 636         super(frame, name);
 637         int scrollBoth = TextArea.SCROLLBARS_BOTH;
 638         instructionsText = new TextArea("", 15, maxStringLength, scrollBoth);
 639         add("North", instructionsText);
 640 
 641         messageText = new TextArea("", 5, maxStringLength, scrollBoth);
 642         add("Center", messageText);
 643 
 644         pack();
 645 
 646         setVisible(true);
 647     }// TestDialog()
 648 
 649     //DO NOT call this directly, go through Sysout
 650     public void printInstructions(String[] instructions) {
 651         //Clear out any current instructions
 652         instructionsText.setText("");
 653 
 654         //Go down array of instruction strings
 655 
 656         String printStr, remainingStr;
 657         for (int i = 0; i < instructions.length; i++) {
 658             //chop up each into pieces maxSringLength long
 659             remainingStr = instructions[i];
 660             while (remainingStr.length() > 0) {
 661                 //if longer than max then chop off first max chars to print
 662                 if (remainingStr.length() >= maxStringLength) {
 663                     //Try to chop on a word boundary
 664                     int posOfSpace = remainingStr.lastIndexOf(' ', maxStringLength - 1);
 665 
 666                     if (posOfSpace <= 0) {
 667                         posOfSpace = maxStringLength - 1;
 668                     }
 669 
 670                     printStr = remainingStr.substring(0, posOfSpace + 1);
 671                     remainingStr = remainingStr.substring(posOfSpace + 1);
 672                 } //else just print
 673                 else {
 674                     printStr = remainingStr;
 675                     remainingStr = "";
 676                 }
 677 
 678                 instructionsText.append(printStr + "\n");
 679 
 680             }// while
 681 
 682         }// for
 683 
 684     }//printInstructions()
 685 
 686     //DO NOT call this directly, go through Sysout
 687     public void displayMessage(String messageIn) {
 688         messageText.append(messageIn + "\n");
 689         System.out.println(messageIn);
 690     }
 691 }// TestDialog  class
 692