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 import java.awt.*;
  25 import java.awt.event.*;
  26 import java.awt.peer.ComponentPeer;
  27 import java.lang.reflect.Constructor;
  28 import java.lang.reflect.InvocationTargetException;
  29 import java.lang.reflect.Method;
  30 import java.util.ArrayList;
  31 import javax.swing.*;
  32 import sun.awt.*;
  33 import java.io.*;
  34 
  35 /**
  36  * <p>This class provides basis for AWT Mixing testing.
  37  * <p>It provides all standard test machinery and should be used by
  38  * extending and overriding next methods:
  39  * <li> {@link OverlappingTestBase#prepareControls()} - setup UI components
  40  * <li> {@link OverlappingTestBase#performTest()} -  run particular test
  41  * Those methods would be run in the loop for each AWT component.
  42  * <p>Current AWT component should be added to the tested UI by {@link OverlappingTestBase#propagateAWTControls(java.awt.Container) ()}.
  43  * There AWT components are prepared to be tested as being overlayed by other (e.g. Swing) components - they are colored to
  44  * {@link OverlappingTestBase#AWT_BACKGROUND_COLOR} and throws failure on catching mouse event.
  45  * <p> Validation of component being overlayed should be tested by {@link OverlappingTestBase#clickAndBlink(java.awt.Robot, java.awt.Point) }
  46  * See each method javadoc for more details.
  47  *
  48  * <p>Due to test machinery limitations all test should be run from their own main() by calling next coe
  49  * <code>
  50  *     public static void main(String args[]) throws InterruptedException {
  51  *        instance = new YourTestInstance();
  52  *        OverlappingTestBase.doMain(args);
  53  *     }
  54  * </code>
  55  *
  56  * @author Sergey Grinev
  57  */
  58 public abstract class OverlappingTestBase {
  59     // working variables
  60     private static volatile boolean wasHWClicked = false;
  61     private static volatile boolean passed = true;
  62     // constants
  63     /**
  64      * Default color for AWT component used for validate correct drawing of overlapping. <b>Never</b> use it for lightweight components.
  65      */
  66     protected static final Color AWT_BACKGROUND_COLOR = new Color(21, 244, 54);
  67     protected static Color AWT_VERIFY_COLOR = AWT_BACKGROUND_COLOR;
  68     protected static final int ROBOT_DELAY = 500;
  69     private static final String[] simpleAwtControls = {"Button", "Checkbox", "Label", "TextArea"};
  70     /**
  71      * Generic strings array. To be used for population of List based controls.
  72      */
  73     protected static final String[] petStrings = {"Bird", "Cat", "Dog", "Rabbit", "Rhynocephalia Granda", "Bear", "Tiger", "Mustang"};
  74     // "properties"
  75     /**
  76      * Tests customization. Set this variable to test only control from java.awt
  77      * <p>Usage of this variable should be marked with CR being the reason.
  78      * <p>Do not use this variable simultaneously with {@link OverlappingTestBase#skipClassNames}
  79      */
  80     protected String onlyClassName = null;
  81     /**
  82      * For customizing tests. List classes' simple names to skip them from testings.
  83      * <p>Usage of this variable should be marked with CR being the reason.
  84      */
  85     protected String[] skipClassNames = null;
  86     /**
  87      * Set to false to avoid event delivery validation
  88      * @see OverlappingTestBase#clickAndBlink(java.awt.Robot, java.awt.Point, boolean)
  89      */
  90     protected boolean useClickValidation = true;
  91     /**
  92      * Set to false if test doesn't supposed to verify EmbeddedFrame
  93      */
  94     protected boolean testEmbeddedFrame = false;
  95     /**
  96      * Set this variable to true if testing embedded frame is impossible (on Mac, for instance, for now).
  97      * The testEmbeddedFrame is explicitly set to true in dozen places.
  98      */
  99     protected boolean skipTestingEmbeddedFrame = false;
 100 
 101     public static final boolean isMac = System.getProperty("os.name").toLowerCase().contains("os x");
 102     private boolean isFrameBorderCalculated;
 103     private int borderShift;
 104 
 105     {    if (Toolkit.getDefaultToolkit().getClass().getName().matches(".*L.*Toolkit")) {
 106              // No EmbeddedFrame in LWToolkit/LWCToolkit, yet
 107              // And it should be programmed some other way, too, in any case
 108              System.err.println("skipTestingEmbeddedFrame");
 109              skipTestingEmbeddedFrame = true;
 110          }else {
 111              System.err.println("do not skipTestingEmbeddedFrame");
 112          }
 113     }
 114 
 115     protected int frameBorderCounter() {
 116         if (!isFrameBorderCalculated) {
 117             try {
 118                 new FrameBorderCounter(); // force compilation by jtreg
 119                 String JAVA_HOME = System.getProperty("java.home");
 120                 Process p = Runtime.getRuntime().exec(JAVA_HOME + "/bin/java FrameBorderCounter");
 121                 try {
 122                     p.waitFor();
 123                 } catch (InterruptedException e) {
 124                     e.printStackTrace();
 125                     throw new RuntimeException(e);
 126                 }
 127                 if (p.exitValue() != 0) {
 128                     throw new RuntimeException("FrameBorderCounter exited with not null code!\n" + readInputStream(p.getErrorStream()));
 129                 }
 130                 borderShift = Integer.parseInt(readInputStream(p.getInputStream()).trim());
 131                 isFrameBorderCalculated = true;
 132             } catch (IOException e) {
 133                 e.printStackTrace();
 134                 System.exit(1);
 135             }
 136         }
 137         return borderShift;
 138     }
 139 
 140     public void getVerifyColor() {
 141         try {
 142             final int size = 200;
 143             final SunToolkit toolkit = (SunToolkit) Toolkit.getDefaultToolkit();
 144             final Point[] p = new Point[1];
 145             SwingUtilities.invokeAndWait(new Runnable() {
 146                 public void run(){
 147                     JFrame frame = new JFrame("set back");
 148                     frame.getContentPane().setBackground(AWT_BACKGROUND_COLOR);
 149                     frame.setSize(size, size);
 150                     frame.setUndecorated(true);
 151                     frame.setVisible(true);
 152                     frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
 153                     p[0] = frame.getLocation();
 154                 }
 155             });
 156             Robot robot = new Robot();
 157             toolkit.realSync();
 158             Thread.sleep(ROBOT_DELAY);
 159             AWT_VERIFY_COLOR = robot.getPixelColor(p[0].x+size/2, p[0].y+size/2);
 160             System.out.println("Color will be compared with " + AWT_VERIFY_COLOR + " instead of " + AWT_BACKGROUND_COLOR);
 161         } catch (Exception e) {
 162             System.err.println("Cannot get verify color: "+e.getMessage());
 163         }
 164     }
 165 
 166     private String readInputStream(InputStream is) throws IOException {
 167         byte[] buffer = new byte[4096];
 168         int len = 0;
 169         StringBuilder sb = new StringBuilder();
 170         try (InputStreamReader isr = new InputStreamReader(is)) {
 171             while ((len = is.read(buffer)) > 0) {
 172                 sb.append(new String(buffer, 0, len));
 173             }
 174         }
 175         return sb.toString();
 176     }
 177 
 178     private void setupControl(final Component control) {
 179         if (useClickValidation) {
 180             control.addMouseListener(new MouseAdapter() {
 181                 @Override
 182                 public void mouseClicked(MouseEvent e) {
 183                     System.err.println("ERROR: " + control.getClass() + " received mouse click.");
 184                     wasHWClicked = true;
 185                 }
 186             });
 187         }
 188         control.setBackground(AWT_BACKGROUND_COLOR);
 189         control.setForeground(AWT_BACKGROUND_COLOR);
 190         control.setPreferredSize(new Dimension(150, 150));
 191         control.setFocusable(false);
 192     }
 193 
 194     private void addAwtControl(java.util.List<Component> container, final Component control) {
 195         String simpleName = control.getClass().getSimpleName();
 196         if (onlyClassName != null && !simpleName.equals(onlyClassName)) {
 197             return;
 198         }
 199         if (skipClassNames != null) {
 200             for (String skipMe : skipClassNames) {
 201                 if (simpleName.equals(skipMe)) {
 202                     return;
 203                 }
 204             }
 205         }
 206         setupControl(control);
 207         container.add(control);
 208     }
 209 
 210     private void addSimpleAwtControl(java.util.List<Component> container, String className) {
 211         try {
 212             Class definition = Class.forName("java.awt." + className);
 213             Constructor constructor = definition.getConstructor(new Class[]{String.class});
 214             java.awt.Component component = (java.awt.Component) constructor.newInstance(new Object[]{"AWT Component " + className});
 215             addAwtControl(container, component);
 216         } catch (Exception ex) {
 217             System.err.println(ex.getMessage());
 218             fail("Setup error, this jdk doesn't have awt conrol " + className);
 219         }
 220     }
 221 
 222     /**
 223      * Adds current AWT control to container
 224      * <p>N.B.: if testEmbeddedFrame == true this method will also add EmbeddedFrame over Canvas
 225      * and it should be called <b>after</b> Frame.setVisible(true) call
 226      * @param container container to hold AWT component
 227      */
 228     protected final void propagateAWTControls(Container container) {
 229         if (currentAwtControl != null) {
 230             container.add(currentAwtControl);
 231         } else { // embedded frame
 232             try {
 233 
 234                 //create embedder
 235                 Canvas embedder = new Canvas();
 236                 embedder.setBackground(Color.RED);
 237                 embedder.setPreferredSize(new Dimension(150, 150));
 238                 container.add(embedder);
 239                 container.setVisible(true); // create peer
 240 
 241                 long frameWindow = 0;
 242                 String getWindowMethodName = "getHWnd";
 243                 if (Toolkit.getDefaultToolkit().getClass().getName().contains("XToolkit")) {
 244                     getWindowMethodName = "getWindow";
 245                 }
 246                 ComponentPeer peer = embedder.getPeer();
 247 //                System.err.println("Peer: " + peer);
 248                 Method getWindowMethod = peer.getClass().getMethod(getWindowMethodName);
 249                 frameWindow = (Long) getWindowMethod.invoke(peer);
 250 //                System.err.println("frame peer ID: " + frameWindow);
 251 
 252                 String eframeClassName = "sun.awt.windows.WEmbeddedFrame";
 253                 if (Toolkit.getDefaultToolkit().getClass().getName().contains("XToolkit")) {
 254                     eframeClassName = "sun.awt.X11.XEmbeddedFrame";
 255                 }
 256                 Class eframeClass = Class.forName(eframeClassName);
 257                 Constructor eframeCtor = eframeClass.getConstructor(long.class);
 258                 EmbeddedFrame eframe = (EmbeddedFrame) eframeCtor.newInstance(frameWindow);
 259                 setupControl(eframe);
 260                 eframe.setSize(new Dimension(150, 150));
 261                 eframe.setVisible(true);
 262 //                System.err.println(eframe.getSize());
 263             } catch (Exception ex) {
 264                 ex.printStackTrace();
 265                 fail("Failed to instantiate EmbeddedFrame: " + ex.getMessage());
 266             }
 267         }
 268     }
 269     private static final Font hugeFont = new Font("Arial", Font.BOLD, 70);
 270 
 271     private java.util.List<Component> getAWTControls() {
 272         java.util.List<Component> components = new ArrayList<Component>();
 273 
 274         for (String clazz : simpleAwtControls) {
 275             addSimpleAwtControl(components, clazz);
 276         }
 277 
 278         TextField tf = new TextField();
 279         tf.setFont(hugeFont);
 280         addAwtControl(components, tf);
 281 
 282         // more complex controls
 283         Choice c = new Choice();
 284         for (int i = 0; i < petStrings.length; i++) {
 285             c.add(petStrings[i]);
 286         }
 287         addAwtControl(components, c);
 288         c.setPreferredSize(null);
 289         c.setFont(hugeFont); // to make control bigger as setPrefferedSize don't do his job here
 290 
 291         List l = new List(petStrings.length);
 292         for (int i = 0; i < petStrings.length; i++) {
 293             l.add(petStrings[i]);
 294         }
 295         addAwtControl(components, l);
 296 
 297         Canvas canvas = new Canvas();
 298         canvas.setSize(100, 200);
 299         addAwtControl(components, canvas);
 300 
 301         Scrollbar sb = new Scrollbar(Scrollbar.VERTICAL, 500, 1, 0, 500);
 302         addAwtControl(components, sb);
 303 
 304         Scrollbar sb2 = new Scrollbar(Scrollbar.HORIZONTAL, 500, 1, 0, 500);
 305         addAwtControl(components, sb2);
 306 
 307         return components;
 308     }
 309     /**
 310      * Default shift for {@link OverlappingTestBase#clickAndBlink(java.awt.Robot, java.awt.Point) }
 311      */
 312     protected static Point shift = new Point(16, 16);
 313 
 314     /**
 315      * Verifies point using specified AWT Robot. Supposes <code>defaultShift == true</code> for {@link OverlappingTestBase#clickAndBlink(java.awt.Robot, java.awt.Point, boolean) }.
 316      * This method is used to verify controls by providing just their plain screen coordinates.
 317      * @param robot AWT Robot. Usually created by {@link Util#createRobot() }
 318      * @param lLoc point to verify
 319      * @see OverlappingTestBase#clickAndBlink(java.awt.Robot, java.awt.Point, boolean)
 320      */
 321     protected void clickAndBlink(Robot robot, Point lLoc) {
 322         clickAndBlink(robot, lLoc, true);
 323     }
 324     /**
 325      * Default failure message for color check
 326      * @see OverlappingTestBase#performTest()
 327      */
 328     protected String failMessageColorCheck = "The LW component did not pass pixel color check and is overlapped";
 329     /**
 330      * Default failure message event check
 331      * @see OverlappingTestBase#performTest()
 332      */
 333     protected String failMessage = "The LW component did not received the click.";
 334 
 335     private static boolean isValidForPixelCheck(Component component) {
 336         if ((component instanceof java.awt.Scrollbar) || isMac && (component instanceof java.awt.Button)) {
 337             return false;
 338         }
 339         return true;
 340     }
 341 
 342     /**
 343      * Preliminary validation - should be run <b>before</b> overlapping happens to ensure test is correct.
 344      * @param robot AWT Robot. Usually created by {@link Util#createRobot() }
 345      * @param lLoc point to validate to be <b>of</b> {@link OverlappingTestBase#AWT_BACKGROUND_COLOR}
 346      * @param component tested component, should be pointed out as not all components are valid for pixel check.
 347      */
 348     protected void pixelPreCheck(Robot robot, Point lLoc, Component component) {
 349         if (isValidForPixelCheck(component)) {
 350             int tries = 10;
 351             Color c = null;
 352             while (tries-- > 0) {
 353                 c = robot.getPixelColor(lLoc.x, lLoc.y);
 354                 System.out.println("Precheck. color: "+c+" compare with "+AWT_VERIFY_COLOR);
 355                 if (c.equals(AWT_VERIFY_COLOR)) {
 356                     return;
 357                 }
 358                 try {
 359                     Thread.sleep(100);
 360                 } catch (InterruptedException e) {
 361                 }
 362             }
 363             System.err.println(lLoc + ": " + c);
 364             fail("Dropdown test setup failure, colored part of AWT component is not located at click area");
 365         }
 366     }
 367 
 368     /**
 369      * Verifies point using specified AWT Robot.
 370      * <p>Firstly, verifies point by color pixel check
 371      * <p>Secondly, verifies event delivery by mouse click
 372      * @param robot AWT Robot. Usually created by {@link Util#createRobot() }
 373      * @param lLoc point to verify
 374      * @param defaultShift if true verified position will be shifted by {@link OverlappingTestBase#shift }.
 375      */
 376     protected void clickAndBlink(Robot robot, Point lLoc, boolean defaultShift) {
 377         Point loc = lLoc.getLocation();
 378         //check color
 379         Util.waitForIdle(robot);
 380         try{
 381             Thread.sleep(500);
 382         }catch(Exception exx){
 383             exx.printStackTrace();
 384         }
 385 
 386         if (defaultShift) {
 387             loc.translate(shift.x, shift.y);
 388         }
 389         if (!(System.getProperty("os.name").toLowerCase().contains("os x"))) {
 390             Color c = robot.getPixelColor(loc.x, loc.y);
 391             System.out.println("C&B. color: "+c+" compare with "+AWT_VERIFY_COLOR);
 392             if (c.equals(AWT_VERIFY_COLOR)) {
 393                 fail(failMessageColorCheck);
 394                 passed = false;
 395             }
 396 
 397             // perform click
 398             Util.waitForIdle(robot);
 399         }
 400 
 401         robot.mouseMove(loc.x, loc.y);
 402 
 403         robot.mousePress(InputEvent.BUTTON1_MASK);
 404         robot.mouseRelease(InputEvent.BUTTON1_MASK);
 405         Util.waitForIdle(robot);
 406     }
 407 
 408     /**
 409      * This method should be overriden with code which setups UI for testing.
 410      * Code in this method <b>will</b> be called only from AWT thread so Swing operations can be called directly.
 411      *
 412      * @see {@link OverlappingTestBase#propagateAWTControls(java.awt.Container) } for instructions about adding tested AWT control to UI
 413      */
 414     protected abstract void prepareControls();
 415 
 416     /**
 417      * This method should be overriden with test execution. It will <b>not</b> be called from AWT thread so all Swing operations should be treated accordingly.
 418      * @return true if test passed. Otherwise fail with default fail message.
 419      * @see {@link OverlappingTestBase#failMessage} default fail message
 420      */
 421     protected abstract boolean performTest();
 422     /**
 423      * This method can be overriden with cleanup routines. It will be called from AWT thread so all Swing operations should be treated accordingly.
 424      */
 425     protected void cleanup() {
 426         // intentionally do nothing
 427     }
 428     /**
 429      * Currect tested AWT Control. Usually shouldn't be accessed directly.
 430      *
 431      * @see {@link OverlappingTestBase#propagateAWTControls(java.awt.Container) } for instructions about adding tested AWT control to UI
 432      */
 433     protected Component currentAwtControl;
 434 
 435     private void testComponent(Component component) throws InterruptedException, InvocationTargetException {
 436         currentAwtControl = component;
 437         System.out.println("Testing " + currentAwtControl.getClass().getSimpleName());
 438         SwingUtilities.invokeAndWait(new Runnable() {
 439             public void run() {
 440                 prepareControls();
 441             }
 442         });
 443         if (component != null) {
 444             Util.waitTillShown(component);
 445         }
 446         Util.waitForIdle(null);
 447         try {
 448             Thread.sleep(500); // wait for graphic effects on systems like Win7
 449         } catch (InterruptedException ex) {
 450         }
 451         if (!instance.performTest()) {
 452             fail(failMessage);
 453             passed = false;
 454         }
 455         SwingUtilities.invokeAndWait(new Runnable() {
 456             public void run() {
 457                 cleanup();
 458             }
 459         });
 460     }
 461 
 462     private void testEmbeddedFrame() throws InvocationTargetException, InterruptedException {
 463         System.out.println("Testing EmbeddedFrame");
 464         currentAwtControl = null;
 465         SwingUtilities.invokeAndWait(new Runnable() {
 466             public void run() {
 467                 prepareControls();
 468             }
 469         });
 470         Util.waitForIdle(null);
 471         try {
 472             Thread.sleep(500); // wait for graphic effects on systems like Win7
 473         } catch (InterruptedException ex) {
 474         }
 475         if (!instance.performTest()) {
 476             fail(failMessage);
 477             passed = false;
 478         }
 479         SwingUtilities.invokeAndWait(new Runnable() {
 480             public void run() {
 481                 cleanup();
 482             }
 483         });
 484     }
 485 
 486     private void testAwtControls() throws InterruptedException {
 487         try {
 488             for (Component component : getAWTControls()) {
 489                 testComponent(component);
 490             }
 491             if (testEmbeddedFrame && !skipTestingEmbeddedFrame) {
 492                 testEmbeddedFrame();
 493             }
 494         } catch (InvocationTargetException ex) {
 495             ex.printStackTrace();
 496             fail(ex.getMessage());
 497         }
 498     }
 499     /**
 500      * Used by standard test machinery. See usage at {@link OverlappingTestBase }
 501      */
 502     protected static OverlappingTestBase instance;
 503 
 504     protected OverlappingTestBase() {
 505         getVerifyColor();
 506     }
 507 
 508     /*****************************************************
 509      * Standard Test Machinery Section
 510      * DO NOT modify anything in this section -- it's a
 511      * standard chunk of code which has all of the
 512      * synchronisation necessary for the test harness.
 513      * By keeping it the same in all tests, it is easier
 514      * to read and understand someone else's test, as
 515      * well as insuring that all tests behave correctly
 516      * with the test harness.
 517      * There is a section following this for test-
 518      * classes
 519      ******************************************************/
 520     private static void init() throws InterruptedException {
 521         //*** Create instructions for the user here ***
 522         //System.setProperty("sun.awt.disableMixing", "true");
 523 
 524         String[] instructions = {
 525             "This is an AUTOMATIC test, simply wait until it is done.",
 526             "The result (passed or failed) will be shown in the",
 527             "message window below."
 528         };
 529         Sysout.createDialog();
 530         Sysout.printInstructions(instructions);
 531 
 532         instance.testAwtControls();
 533 
 534         if (wasHWClicked) {
 535             fail("HW component received the click.");
 536             passed = false;
 537         }
 538         if (passed) {
 539             pass();
 540         }
 541     }//End  init()
 542     private static boolean theTestPassed = false;
 543     private static boolean testGeneratedInterrupt = false;
 544     private static String failureMessage = "";
 545     private static Thread mainThread = null;
 546     private static int sleepTime = 300000;
 547 
 548     // Not sure about what happens if multiple of this test are
 549     //  instantiated in the same VM.  Being static (and using
 550     //  static vars), it aint gonna work.  Not worrying about
 551     //  it for now.
 552     /**
 553      * Starting point for test runs. See usage at {@link OverlappingTestBase }
 554      * @param args regular main args, not used.
 555      * @throws InterruptedException
 556      */
 557     public static void doMain(String args[]) throws InterruptedException {
 558         mainThread = Thread.currentThread();
 559         try {
 560             init();
 561         } catch (TestPassedException e) {
 562             //The test passed, so just return from main and harness will
 563             // interepret this return as a pass
 564             return;
 565         }
 566         //At this point, neither test pass nor test fail has been
 567         // called -- either would have thrown an exception and ended the
 568         // test, so we know we have multiple threads.
 569 
 570         //Test involves other threads, so sleep and wait for them to
 571         // called pass() or fail()
 572         try {
 573             Thread.sleep(sleepTime);
 574             //Timed out, so fail the test
 575             throw new RuntimeException("Timed out after " + sleepTime / 1000 + " seconds");
 576         } catch (InterruptedException e) {
 577             //The test harness may have interrupted the test.  If so, rethrow the exception
 578             // so that the harness gets it and deals with it.
 579             if (!testGeneratedInterrupt) {
 580                 throw e;
 581             }
 582 
 583             //reset flag in case hit this code more than once for some reason (just safety)
 584             testGeneratedInterrupt = false;
 585 
 586             if (theTestPassed == false) {
 587                 throw new RuntimeException(failureMessage);
 588             }
 589         }
 590 
 591     }//main
 592 
 593     /**
 594      * Test will fail if not passed after this timeout. Default timeout is 300 seconds.
 595      * @param seconds timeout in seconds
 596      */
 597     public static synchronized void setTimeoutTo(int seconds) {
 598         sleepTime = seconds * 1000;
 599     }
 600 
 601     /**
 602      * Set test as passed. Usually shoudn't be called directly.
 603      */
 604     public static synchronized void pass() {
 605         Sysout.println("The test passed.");
 606         Sysout.println("The test is over, hit  Ctl-C to stop Java VM");
 607         //first check if this is executing in main thread
 608         if (mainThread == Thread.currentThread()) {
 609             //Still in the main thread, so set the flag just for kicks,
 610             // and throw a test passed exception which will be caught
 611             // and end the test.
 612             theTestPassed = true;
 613             throw new TestPassedException();
 614         }
 615         theTestPassed = true;
 616         testGeneratedInterrupt = true;
 617         mainThread.interrupt();
 618     }//pass()
 619 
 620     /**
 621      * Fail test generic message.
 622      */
 623     public static synchronized void fail() {
 624         //test writer didn't specify why test failed, so give generic
 625         fail("it just plain failed! :-)");
 626     }
 627 
 628     /**
 629      * Fail test providing specific reason.
 630      * @param whyFailed reason
 631      */
 632     public static synchronized void fail(String whyFailed) {
 633         Sysout.println("The test failed: " + whyFailed);
 634         Sysout.println("The test is over, hit  Ctl-C to stop Java VM");
 635         //check if this called from main thread
 636         if (mainThread == Thread.currentThread()) {
 637             //If main thread, fail now 'cause not sleeping
 638             throw new RuntimeException(whyFailed);
 639         }
 640         theTestPassed = false;
 641         testGeneratedInterrupt = true;
 642         failureMessage = whyFailed;
 643         mainThread.interrupt();
 644     }//fail()
 645 }// class LWComboBox
 646 class TestPassedException extends RuntimeException {
 647 }
 648 
 649 //*********** End Standard Test Machinery Section **********
 650 //************ Begin classes defined for the test ****************
 651 // if want to make listeners, here is the recommended place for them, then instantiate
 652 //  them in init()
 653 
 654 /* Example of a class which may be written as part of a test
 655 class NewClass implements anInterface
 656 {
 657 static int newVar = 0;
 658 
 659 public void eventDispatched(AWTEvent e)
 660 {
 661 //Counting events to see if we get enough
 662 eventCount++;
 663 
 664 if( eventCount == 20 )
 665 {
 666 //got enough events, so pass
 667 
 668 LWComboBox.pass();
 669 }
 670 else if( tries == 20 )
 671 {
 672 //tried too many times without getting enough events so fail
 673 
 674 LWComboBox.fail();
 675 }
 676 
 677 }// eventDispatched()
 678 
 679 }// NewClass class
 680 
 681  */
 682 //************** End classes defined for the test *******************
 683 /****************************************************
 684 Standard Test Machinery
 685 DO NOT modify anything below -- it's a standard
 686 chunk of code whose purpose is to make user
 687 interaction uniform, and thereby make it simpler
 688 to read and understand someone else's test.
 689  ****************************************************/
 690 /**
 691 This is part of the standard test machinery.
 692 It creates a dialog (with the instructions), and is the interface
 693 for sending text messages to the user.
 694 To print the instructions, send an array of strings to Sysout.createDialog
 695 WithInstructions method.  Put one line of instructions per array entry.
 696 To display a message for the tester to see, simply call Sysout.println
 697 with the string to be displayed.
 698 This mimics System.out.println but works within the test harness as well
 699 as standalone.
 700  */
 701 class Sysout {
 702     private static TestDialog dialog;
 703 
 704     public static void createDialogWithInstructions(String[] instructions) {
 705         dialog = new TestDialog(new Frame(), "Instructions");
 706         dialog.printInstructions(instructions);
 707         //dialog.setVisible(true);
 708         println("Any messages for the tester will display here.");
 709     }
 710 
 711     public static void createDialog() {
 712         dialog = new TestDialog(new Frame(), "Instructions");
 713         String[] defInstr = {"Instructions will appear here. ", ""};
 714         dialog.printInstructions(defInstr);
 715         //dialog.setVisible(true);
 716         println("Any messages for the tester will display here.");
 717     }
 718 
 719     public static void printInstructions(String[] instructions) {
 720         dialog.printInstructions(instructions);
 721     }
 722 
 723     public static void println(String messageIn) {
 724         dialog.displayMessage(messageIn);
 725         System.out.println(messageIn);
 726     }
 727 }// Sysout  class
 728 
 729 /**
 730 This is part of the standard test machinery.  It provides a place for the
 731 test instructions to be displayed, and a place for interactive messages
 732 to the user to be displayed.
 733 To have the test instructions displayed, see Sysout.
 734 To have a message to the user be displayed, see Sysout.
 735 Do not call anything in this dialog directly.
 736  */
 737 class TestDialog extends Dialog {
 738     TextArea instructionsText;
 739     TextArea messageText;
 740     int maxStringLength = 80;
 741 
 742     //DO NOT call this directly, go through Sysout
 743     public TestDialog(Frame frame, String name) {
 744         super(frame, name);
 745         int scrollBoth = TextArea.SCROLLBARS_BOTH;
 746         instructionsText = new TextArea("", 15, maxStringLength, scrollBoth);
 747         add("North", instructionsText);
 748 
 749         messageText = new TextArea("", 5, maxStringLength, scrollBoth);
 750         add("Center", messageText);
 751 
 752         pack();
 753 
 754        //setVisible(true);
 755     }// TestDialog()
 756 
 757     //DO NOT call this directly, go through Sysout
 758     public void printInstructions(String[] instructions) {
 759         //Clear out any current instructions
 760         instructionsText.setText("");
 761 
 762         //Go down array of instruction strings
 763 
 764         String printStr, remainingStr;
 765         for (int i = 0; i < instructions.length; i++) {
 766             //chop up each into pieces maxSringLength long
 767             remainingStr = instructions[i];
 768             while (remainingStr.length() > 0) {
 769                 //if longer than max then chop off first max chars to print
 770                 if (remainingStr.length() >= maxStringLength) {
 771                     //Try to chop on a word boundary
 772                     int posOfSpace = remainingStr.lastIndexOf(' ', maxStringLength - 1);
 773 
 774                     if (posOfSpace <= 0) {
 775                         posOfSpace = maxStringLength - 1;
 776                     }
 777 
 778                     printStr = remainingStr.substring(0, posOfSpace + 1);
 779                     remainingStr = remainingStr.substring(posOfSpace + 1);
 780                 } //else just print
 781                 else {
 782                     printStr = remainingStr;
 783                     remainingStr = "";
 784                 }
 785 
 786                 instructionsText.append(printStr + "\n");
 787 
 788             }// while
 789 
 790         }// for
 791 
 792     }//printInstructions()
 793 
 794     //DO NOT call this directly, go through Sysout
 795     public void displayMessage(String messageIn) {
 796         messageText.append(messageIn + "\n");
 797         System.out.println(messageIn);
 798     }
 799 }// TestDialog  class
 800