1 /* 2 * Copyright (c) 2008, 2015, 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 @test %W% %E% 26 @bug 6594131 27 @summary Tests the AWTUtilities.get/setWindowOpacity() methods 28 @author anthony.petrov@...: area=awt.toplevel 29 @modules java.desktop/com.sun.awt 30 @run main WindowOpacity 31 */ 32 33 import java.awt.*; 34 import java.awt.event.*; 35 36 import com.sun.awt.AWTUtilities; 37 38 public class WindowOpacity 39 { 40 //*** test-writer defined static variables go here *** 41 42 private static Robot robot; 43 44 45 private static void init() 46 { 47 //*** Create instructions for the user here *** 48 String[] instructions = 49 { 50 "This is an AUTOMATIC test, simply wait until it is done.", 51 "The result (passed or failed) will be shown in the", 52 "message window below." 53 }; 54 Sysout.createDialog( ); 55 Sysout.printInstructions( instructions ); 56 57 if (!AWTUtilities.isTranslucencySupported(AWTUtilities.Translucency.TRANSLUCENT)) { 58 System.out.println("Either the Toolkit or the native system does not support controlling the window opacity level."); 59 pass(); 60 } 61 try { 62 robot = new Robot(); 63 }catch(Exception ex) { 64 ex.printStackTrace(); 65 throw new RuntimeException ("Unexpected failure"); 66 } 67 68 boolean passed; 69 70 Frame f = new Frame("Opacity test"); 71 f.setUndecorated(true); 72 73 passed = false; 74 try { 75 AWTUtilities.getWindowOpacity(null); 76 } catch (NullPointerException e) { 77 passed = true; 78 } 79 if (!passed) { 80 fail("getWindowOpacity() allows passing null."); 81 } 82 83 84 passed = false; 85 try { 86 AWTUtilities.setWindowOpacity(null, 0.5f); 87 } catch (NullPointerException e) { 88 passed = true; 89 } 90 if (!passed) { 91 fail("setWindowOpacity() allows passing null."); 92 } 93 94 95 float curOpacity = AWTUtilities.getWindowOpacity(f); 96 if (curOpacity < 1.0f || curOpacity > 1.0f) { 97 fail("getWindowOpacity() reports the initial opacity level other than 1.0: " + curOpacity); 98 } 99 100 101 102 passed = false; 103 try { 104 AWTUtilities.setWindowOpacity(f, -0.5f); 105 } catch (IllegalArgumentException e) { 106 passed = true; 107 } 108 if (!passed) { 109 fail("setWindowOpacity() allows passing negative opacity level."); 110 } 111 112 113 114 passed = false; 115 try { 116 AWTUtilities.setWindowOpacity(f, 1.5f); 117 } catch (IllegalArgumentException e) { 118 passed = true; 119 } 120 if (!passed) { 121 fail("setWindowOpacity() allows passing opacity level greater than 1.0."); 122 } 123 124 125 AWTUtilities.setWindowOpacity(f, 0.5f); 126 127 curOpacity = AWTUtilities.getWindowOpacity(f); 128 if (curOpacity < 0.5f || curOpacity > 0.5f) { 129 fail("getWindowOpacity() reports the opacity level that differs from the value set with setWindowOpacity: " + curOpacity); 130 } 131 132 133 AWTUtilities.setWindowOpacity(f, 0.75f); 134 135 curOpacity = AWTUtilities.getWindowOpacity(f); 136 if (curOpacity < 0.75f || curOpacity > 0.75f) { 137 fail("getWindowOpacity() reports the opacity level that differs from the value set with setWindowOpacity the second time: " + curOpacity); 138 } 139 140 141 f.setBounds(100, 100, 300, 200); 142 f.setVisible(true); 143 144 robot.waitForIdle(); 145 146 curOpacity = AWTUtilities.getWindowOpacity(f); 147 if (curOpacity < 0.75f || curOpacity > 0.75f) { 148 fail("getWindowOpacity() reports the opacity level that differs from the value set with setWindowOpacity before showing the frame: " + curOpacity); 149 } 150 151 152 153 AWTUtilities.setWindowOpacity(f, 0.5f); 154 robot.waitForIdle(); 155 156 curOpacity = AWTUtilities.getWindowOpacity(f); 157 if (curOpacity < 0.5f || curOpacity > 0.5f) { 158 fail("getWindowOpacity() reports the opacity level that differs from the value set with setWindowOpacity after showing the frame: " + curOpacity); 159 } 160 161 WindowOpacity.pass(); 162 163 }//End init() 164 165 166 167 /***************************************************** 168 * Standard Test Machinery Section 169 * DO NOT modify anything in this section -- it's a 170 * standard chunk of code which has all of the 171 * synchronisation necessary for the test harness. 172 * By keeping it the same in all tests, it is easier 173 * to read and understand someone else's test, as 174 * well as insuring that all tests behave correctly 175 * with the test harness. 176 * There is a section following this for test- 177 * classes 178 ******************************************************/ 179 private static boolean theTestPassed = false; 180 private static boolean testGeneratedInterrupt = false; 181 private static String failureMessage = ""; 182 183 private static Thread mainThread = null; 184 185 private static int sleepTime = 300000; 186 187 // Not sure about what happens if multiple of this test are 188 // instantiated in the same VM. Being static (and using 189 // static vars), it aint gonna work. Not worrying about 190 // it for now. 191 public static void main( String args[] ) throws InterruptedException 192 { 193 mainThread = Thread.currentThread(); 194 try 195 { 196 init(); 197 } 198 catch( TestPassedException e ) 199 { 200 //The test passed, so just return from main and harness will 201 // interepret this return as a pass 202 return; 203 } 204 //At this point, neither test pass nor test fail has been 205 // called -- either would have thrown an exception and ended the 206 // test, so we know we have multiple threads. 207 208 //Test involves other threads, so sleep and wait for them to 209 // called pass() or fail() 210 try 211 { 212 Thread.sleep( sleepTime ); 213 //Timed out, so fail the test 214 throw new RuntimeException( "Timed out after " + sleepTime/1000 + " seconds" ); 215 } 216 catch (InterruptedException e) 217 { 218 //The test harness may have interrupted the test. If so, rethrow the exception 219 // so that the harness gets it and deals with it. 220 if( ! testGeneratedInterrupt ) throw e; 221 222 //reset flag in case hit this code more than once for some reason (just safety) 223 testGeneratedInterrupt = false; 224 225 if ( theTestPassed == false ) 226 { 227 throw new RuntimeException( failureMessage ); 228 } 229 } 230 231 }//main 232 233 public static synchronized void setTimeoutTo( int seconds ) 234 { 235 sleepTime = seconds * 1000; 236 } 237 238 public static synchronized void pass() 239 { 240 Sysout.println( "The test passed." ); 241 Sysout.println( "The test is over, hit Ctl-C to stop Java VM" ); 242 //first check if this is executing in main thread 243 if ( mainThread == Thread.currentThread() ) 244 { 245 //Still in the main thread, so set the flag just for kicks, 246 // and throw a test passed exception which will be caught 247 // and end the test. 248 theTestPassed = true; 249 throw new TestPassedException(); 250 } 251 theTestPassed = true; 252 testGeneratedInterrupt = true; 253 mainThread.interrupt(); 254 }//pass() 255 256 public static synchronized void fail() 257 { 258 //test writer didn't specify why test failed, so give generic 259 fail( "it just plain failed! :-)" ); 260 } 261 262 public static synchronized void fail( String whyFailed ) 263 { 264 Sysout.println( "The test failed: " + whyFailed ); 265 Sysout.println( "The test is over, hit Ctl-C to stop Java VM" ); 266 //check if this called from main thread 267 if ( mainThread == Thread.currentThread() ) 268 { 269 //If main thread, fail now 'cause not sleeping 270 throw new RuntimeException( whyFailed ); 271 } 272 theTestPassed = false; 273 testGeneratedInterrupt = true; 274 failureMessage = whyFailed; 275 mainThread.interrupt(); 276 }//fail() 277 278 }// class WindowOpacity 279 280 //This exception is used to exit from any level of call nesting 281 // when it's determined that the test has passed, and immediately 282 // end the test. 283 class TestPassedException extends RuntimeException 284 { 285 } 286 287 //*********** End Standard Test Machinery Section ********** 288 289 290 //************ Begin classes defined for the test **************** 291 292 // if want to make listeners, here is the recommended place for them, then instantiate 293 // them in init() 294 295 /* Example of a class which may be written as part of a test 296 class NewClass implements anInterface 297 { 298 static int newVar = 0; 299 300 public void eventDispatched(AWTEvent e) 301 { 302 //Counting events to see if we get enough 303 eventCount++; 304 305 if( eventCount == 20 ) 306 { 307 //got enough events, so pass 308 309 WindowOpacity.pass(); 310 } 311 else if( tries == 20 ) 312 { 313 //tried too many times without getting enough events so fail 314 315 WindowOpacity.fail(); 316 } 317 318 }// eventDispatched() 319 320 }// NewClass class 321 322 */ 323 324 325 //************** End classes defined for the test ******************* 326 327 328 329 330 /**************************************************** 331 Standard Test Machinery 332 DO NOT modify anything below -- it's a standard 333 chunk of code whose purpose is to make user 334 interaction uniform, and thereby make it simpler 335 to read and understand someone else's test. 336 ****************************************************/ 337 338 /** 339 This is part of the standard test machinery. 340 It creates a dialog (with the instructions), and is the interface 341 for sending text messages to the user. 342 To print the instructions, send an array of strings to Sysout.createDialog 343 WithInstructions method. Put one line of instructions per array entry. 344 To display a message for the tester to see, simply call Sysout.println 345 with the string to be displayed. 346 This mimics System.out.println but works within the test harness as well 347 as standalone. 348 */ 349 350 class Sysout 351 { 352 private static TestDialog dialog; 353 354 public static void createDialogWithInstructions( String[] instructions ) 355 { 356 dialog = new TestDialog( new Frame(), "Instructions" ); 357 dialog.printInstructions( instructions ); 358 dialog.setVisible(true); 359 println( "Any messages for the tester will display here." ); 360 } 361 362 public static void createDialog( ) 363 { 364 dialog = new TestDialog( new Frame(), "Instructions" ); 365 String[] defInstr = { "Instructions will appear here. ", "" } ; 366 dialog.printInstructions( defInstr ); 367 dialog.setVisible(true); 368 println( "Any messages for the tester will display here." ); 369 } 370 371 372 public static void printInstructions( String[] instructions ) 373 { 374 dialog.printInstructions( instructions ); 375 } 376 377 378 public static void println( String messageIn ) 379 { 380 dialog.displayMessage( messageIn ); 381 System.out.println(messageIn); 382 } 383 384 }// Sysout class 385 386 /** 387 This is part of the standard test machinery. It provides a place for the 388 test instructions to be displayed, and a place for interactive messages 389 to the user to be displayed. 390 To have the test instructions displayed, see Sysout. 391 To have a message to the user be displayed, see Sysout. 392 Do not call anything in this dialog directly. 393 */ 394 class TestDialog extends Dialog 395 { 396 397 TextArea instructionsText; 398 TextArea messageText; 399 int maxStringLength = 80; 400 401 //DO NOT call this directly, go through Sysout 402 public TestDialog( Frame frame, String name ) 403 { 404 super( frame, name ); 405 int scrollBoth = TextArea.SCROLLBARS_BOTH; 406 instructionsText = new TextArea( "", 15, maxStringLength, scrollBoth ); 407 add( "North", instructionsText ); 408 409 messageText = new TextArea( "", 5, maxStringLength, scrollBoth ); 410 add("Center", messageText); 411 412 pack(); 413 414 setVisible(true); 415 }// TestDialog() 416 417 //DO NOT call this directly, go through Sysout 418 public void printInstructions( String[] instructions ) 419 { 420 //Clear out any current instructions 421 instructionsText.setText( "" ); 422 423 //Go down array of instruction strings 424 425 String printStr, remainingStr; 426 for( int i=0; i < instructions.length; i++ ) 427 { 428 //chop up each into pieces maxSringLength long 429 remainingStr = instructions[ i ]; 430 while( remainingStr.length() > 0 ) 431 { 432 //if longer than max then chop off first max chars to print 433 if( remainingStr.length() >= maxStringLength ) 434 { 435 //Try to chop on a word boundary 436 int posOfSpace = remainingStr. 437 lastIndexOf( ' ', maxStringLength - 1 ); 438 439 if( posOfSpace <= 0 ) posOfSpace = maxStringLength - 1; 440 441 printStr = remainingStr.substring( 0, posOfSpace + 1 ); 442 remainingStr = remainingStr.substring( posOfSpace + 1 ); 443 } 444 //else just print 445 else 446 { 447 printStr = remainingStr; 448 remainingStr = ""; 449 } 450 451 instructionsText.append( printStr + "\n" ); 452 453 }// while 454 455 }// for 456 457 }//printInstructions() 458 459 //DO NOT call this directly, go through Sysout 460 public void displayMessage( String messageIn ) 461 { 462 messageText.append( messageIn + "\n" ); 463 System.out.println(messageIn); 464 } 465 466 }// TestDialog class