1 /*

     2  * Copyright 2006-2007 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  */

    23 

    24 /*

    25   @test

    26   @bug 6494016

    27   @summary Nonresizable dialogs should not be resized using the Size SystemMenu command

    28   @author anthony.petrov@...: area=awt.toplevel

    29   @library ../../regtesthelpers

    30   @build Util

    31   @run main NonResizableDialogSysMenuResize

    32 */

    33 

    34 

    35 /**

    36  * NonResizableDialogSysMenuResize.java

    37  *

    38  * summary: Nonresizable dialogs should not be resized using the Size SystemMenu command

    39  */

    40 

    41 import java.awt.*;

    42 import java.awt.event.*;

    43 import test.java.awt.regtesthelpers.Util;

    44 

    45 

    46 public class NonResizableDialogSysMenuResize

    47 {

    48 

    49     //*** test-writer defined static variables go here ***

    50 

    51 

    52     private static void init()

    53     {

    54         //*** Create instructions for the user here ***

    55 

    56         String[] instructions =

    57         {

    58             "This is an AUTOMATIC test, simply wait until it is done.",

    59             "The result (passed or failed) will be shown in the",

    60             "message window below."

    61         };

    62         Sysout.createDialog( );

    63         Sysout.printInstructions( instructions );

    64 

    65         // We must be sure that the Size system command has the S key as the shortcut one in the System menu.

    66         Sysout.println("NOTE: The test is known to work correctly with English MS Windows only.");

    67 

    68         String s = Toolkit.getDefaultToolkit().getClass().getName();

    69 

    70         // This is Windows-only test

    71         if (!s.contains("WToolkit")) {

    72             pass();

    73             return;

    74         }

    75 

    76         Dialog d = new Dialog((Frame)null, "dlg", false);

    77         d.setResizable(false);

    78         d.setSize(100, 100);

    79         d.setLocation(200, 200);

    80         d.setVisible(true);

    81 

    82         Robot robot = Util.createRobot();

    83         robot.setAutoDelay(20);

    84 

    85         // To be sure both the frame and the dialog are shown and packed

    86         Util.waitForIdle(robot);

    87 

    88 

    89         // The initial dialog position and size.

    90         Point loc1 = d.getLocation();

    91         Dimension dim1 = d.getSize();

    92 

    93         System.out.println("The initial position of the dialog is: " + loc1 + "; the size is: " + dim1);

    94 

    95         try { Thread.sleep(1000); } catch (Exception e) {};

    96 

    97         // Alt-Space opens System menu

    98         robot.keyPress(KeyEvent.VK_ALT);

    99         robot.keyPress(KeyEvent.VK_SPACE);

   100         robot.keyRelease(KeyEvent.VK_SPACE);

   101         robot.keyRelease(KeyEvent.VK_ALT);

   102 

   103         // Try to choose the Size command

   104         robot.keyPress(KeyEvent.VK_S);

   105         robot.keyRelease(KeyEvent.VK_S);

   106 

   107         // Try to change the size a little

   108         for (int i = 0; i < 5; i++) {

   109             robot.keyPress(KeyEvent.VK_DOWN);

   110             robot.keyRelease(KeyEvent.VK_DOWN);

   111             robot.keyPress(KeyEvent.VK_LEFT);

   112             robot.keyRelease(KeyEvent.VK_LEFT);

   113         }

   114 

   115         // End the Size loop

   116         robot.keyPress(KeyEvent.VK_ENTER);

   117         robot.keyRelease(KeyEvent.VK_ENTER);

   118 

   119         Util.waitForIdle(robot);

   120 

   121         // The dialog position and size after trying to change its size.

   122         Point loc2 = d.getLocation();

   123         Dimension dim2 = d.getSize();

   124 

   125         System.out.println("AFTER RESIZE: The position of the dialog is: " + loc2 + "; the size is: " + dim2);

   126 

   127         if (loc2.equals(loc1) && dim2.equals(dim1)) {

   128             pass();

   129         } else {

   130             fail("The non-resizable dialog has changed its size and/or location.");

   131         }

   132 

   133     }//End  init()

   134 

   135 

   136 

   137     /*****************************************************

   138      * Standard Test Machinery Section

   139      * DO NOT modify anything in this section -- it's a

   140      * standard chunk of code which has all of the

   141      * synchronisation necessary for the test harness.

   142      * By keeping it the same in all tests, it is easier

   143      * to read and understand someone else's test, as

   144      * well as insuring that all tests behave correctly

   145      * with the test harness.

   146      * There is a section following this for test-

   147      * classes

   148      ******************************************************/

   149     private static boolean theTestPassed = false;

   150     private static boolean testGeneratedInterrupt = false;

   151     private static String failureMessage = "";

   152 

   153     private static Thread mainThread = null;

   154 

   155     private static int sleepTime = 300000;

   156 

   157     // Not sure about what happens if multiple of this test are

   158     //  instantiated in the same VM.  Being static (and using

   159     //  static vars), it aint gonna work.  Not worrying about

   160     //  it for now.

   161     public static void main( String args[] ) throws InterruptedException

   162     {

   163         mainThread = Thread.currentThread();

   164         try

   165         {

   166             init();

   167         }

   168         catch( TestPassedException e )

   169         {

   170             //The test passed, so just return from main and harness will

   171             // interepret this return as a pass

   172             return;

   173         }

   174         //At this point, neither test pass nor test fail has been

   175         // called -- either would have thrown an exception and ended the

   176         // test, so we know we have multiple threads.

   177 

   178         //Test involves other threads, so sleep and wait for them to

   179         // called pass() or fail()

   180         try

   181         {

   182             Thread.sleep( sleepTime );

   183             //Timed out, so fail the test

   184             throw new RuntimeException( "Timed out after " + sleepTime/1000 + " seconds" );

   185         }

   186         catch (InterruptedException e)

   187         {

   188             //The test harness may have interrupted the test.  If so, rethrow the exception

   189             // so that the harness gets it and deals with it.

   190             if( ! testGeneratedInterrupt ) throw e;

   191 

   192             //reset flag in case hit this code more than once for some reason (just safety)

   193             testGeneratedInterrupt = false;

   194 

   195             if ( theTestPassed == false )

   196             {

   197                 throw new RuntimeException( failureMessage );

   198             }

   199         }

   200 

   201     }//main

   202 

   203     public static synchronized void setTimeoutTo( int seconds )

   204     {

   205         sleepTime = seconds * 1000;

   206     }

   207 

   208     public static synchronized void pass()

   209     {

   210         Sysout.println( "The test passed." );

   211         Sysout.println( "The test is over, hit  Ctl-C to stop Java VM" );

   212         //first check if this is executing in main thread

   213         if ( mainThread == Thread.currentThread() )

   214         {

   215             //Still in the main thread, so set the flag just for kicks,

   216             // and throw a test passed exception which will be caught

   217             // and end the test.

   218             theTestPassed = true;

   219             throw new TestPassedException();

   220         }

   221         theTestPassed = true;

   222         testGeneratedInterrupt = true;

   223         mainThread.interrupt();

   224     }//pass()

   225 

   226     public static synchronized void fail()

   227     {

   228         //test writer didn't specify why test failed, so give generic

   229         fail( "it just plain failed! :-)" );

   230     }

   231 

   232     public static synchronized void fail( String whyFailed )

   233     {

   234         Sysout.println( "The test failed: " + whyFailed );

   235         Sysout.println( "The test is over, hit  Ctl-C to stop Java VM" );

   236         //check if this called from main thread

   237         if ( mainThread == Thread.currentThread() )

   238         {

   239             //If main thread, fail now 'cause not sleeping

   240             throw new RuntimeException( whyFailed );

   241         }

   242         theTestPassed = false;

   243         testGeneratedInterrupt = true;

   244         failureMessage = whyFailed;

   245         mainThread.interrupt();

   246     }//fail()

   247 

   248 }// class NonResizableDialogSysMenuResize

   249 

   250 //This exception is used to exit from any level of call nesting

   251 // when it's determined that the test has passed, and immediately

   252 // end the test.

   253 class TestPassedException extends RuntimeException

   254 {

   255 }

   256 

   257 //*********** End Standard Test Machinery Section **********

   258 

   259 

   260 //************ Begin classes defined for the test ****************

   261 

   262 // if want to make listeners, here is the recommended place for them, then instantiate

   263 //  them in init()

   264 

   265 /* Example of a class which may be written as part of a test

   266 class NewClass implements anInterface

   267  {

   268    static int newVar = 0;

   269 

   270    public void eventDispatched(AWTEvent e)

   271     {

   272       //Counting events to see if we get enough

   273       eventCount++;

   274 

   275       if( eventCount == 20 )

   276        {

   277          //got enough events, so pass

   278 

   279          NonResizableDialogSysMenuResize.pass();

   280        }

   281       else if( tries == 20 )

   282        {

   283          //tried too many times without getting enough events so fail

   284 

   285          NonResizableDialogSysMenuResize.fail();

   286        }

   287 

   288     }// eventDispatched()

   289 

   290  }// NewClass class

   291 

   292 */

   293 

   294 

   295 //************** End classes defined for the test *******************

   296 

   297 

   298 

   299 

   300 /****************************************************

   301  Standard Test Machinery

   302  DO NOT modify anything below -- it's a standard

   303   chunk of code whose purpose is to make user

   304   interaction uniform, and thereby make it simpler

   305   to read and understand someone else's test.

   306  ****************************************************/

   307 

   308 /**

   309  This is part of the standard test machinery.

   310  It creates a dialog (with the instructions), and is the interface

   311   for sending text messages to the user.

   312  To print the instructions, send an array of strings to Sysout.createDialog

   313   WithInstructions method.  Put one line of instructions per array entry.

   314  To display a message for the tester to see, simply call Sysout.println

   315   with the string to be displayed.

   316  This mimics System.out.println but works within the test harness as well

   317   as standalone.

   318  */

   319 

   320 class Sysout

   321 {

   322     private static TestDialog dialog;

   323 

   324     public static void createDialogWithInstructions( String[] instructions )

   325     {

   326         dialog = new TestDialog( new Frame(), "Instructions" );

   327         dialog.printInstructions( instructions );

   328         dialog.setVisible(true);

   329         println( "Any messages for the tester will display here." );

   330     }

   331 

   332     public static void createDialog( )

   333     {

   334         dialog = new TestDialog( new Frame(), "Instructions" );

   335         String[] defInstr = { "Instructions will appear here. ", "" } ;

   336         dialog.printInstructions( defInstr );

   337         dialog.setVisible(true);

   338         println( "Any messages for the tester will display here." );

   339     }

   340 

   341 

   342     public static void printInstructions( String[] instructions )

   343     {

   344         dialog.printInstructions( instructions );

   345     }

   346 

   347 

   348     public static void println( String messageIn )

   349     {

   350         dialog.displayMessage( messageIn );

   351         System.out.println(messageIn);

   352     }

   353 

   354 }// Sysout  class

   355 

   356 /**

   357   This is part of the standard test machinery.  It provides a place for the

   358    test instructions to be displayed, and a place for interactive messages

   359    to the user to be displayed.

   360   To have the test instructions displayed, see Sysout.

   361   To have a message to the user be displayed, see Sysout.

   362   Do not call anything in this dialog directly.

   363   */

   364 class TestDialog extends Dialog

   365 {

   366 

   367     TextArea instructionsText;

   368     TextArea messageText;

   369     int maxStringLength = 80;

   370 

   371     //DO NOT call this directly, go through Sysout

   372     public TestDialog( Frame frame, String name )

   373     {

   374         super( frame, name );

   375         int scrollBoth = TextArea.SCROLLBARS_BOTH;

   376         instructionsText = new TextArea( "", 15, maxStringLength, scrollBoth );

   377         add( "North", instructionsText );

   378 

   379         messageText = new TextArea( "", 5, maxStringLength, scrollBoth );

   380         add("Center", messageText);

   381 

   382         pack();

   383 

   384         setVisible(true);

   385     }// TestDialog()

   386 

   387     //DO NOT call this directly, go through Sysout

   388     public void printInstructions( String[] instructions )

   389     {

   390         //Clear out any current instructions

   391         instructionsText.setText( "" );

   392 

   393         //Go down array of instruction strings

   394 

   395         String printStr, remainingStr;

   396         for( int i=0; i < instructions.length; i++ )

   397         {

   398             //chop up each into pieces maxSringLength long

   399             remainingStr = instructions[ i ];

   400             while( remainingStr.length() > 0 )

   401             {

   402                 //if longer than max then chop off first max chars to print

   403                 if( remainingStr.length() >= maxStringLength )

   404                 {

   405                     //Try to chop on a word boundary

   406                     int posOfSpace = remainingStr.

   407                         lastIndexOf( ' ', maxStringLength - 1 );

   408 

   409                     if( posOfSpace <= 0 ) posOfSpace = maxStringLength - 1;

   410 

   411                     printStr = remainingStr.substring( 0, posOfSpace + 1 );

   412                     remainingStr = remainingStr.substring( posOfSpace + 1 );

   413                 }

   414                 //else just print

   415                 else

   416                 {

   417                     printStr = remainingStr;

   418                     remainingStr = "";

   419                 }

   420 

   421                 instructionsText.append( printStr + "\n" );

   422 

   423             }// while

   424 

   425         }// for

   426 

   427     }//printInstructions()

   428 

   429     //DO NOT call this directly, go through Sysout

   430     public void displayMessage( String messageIn )

   431     {

   432         messageText.append( messageIn + "\n" );

   433         System.out.println(messageIn);

   434     }

   435 

   436 }// TestDialog  class