1 /*
2 * Copyright (c) 2006, 2016, 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.Button;
25 import java.awt.Dialog;
26 import java.awt.Frame;
27 import java.awt.Panel;
28 import java.awt.TextArea;
29 import java.awt.event.ActionEvent;
30 import java.awt.event.ActionListener;
31
32 /**
33 * @test
34 * @bug 6411624
35 * @summary Tests that MidiSystem.getReceiver() & MidiSystem.getTransmitter
36 * doesn't return sequencer
37 * @build bug6411624
38 * @run main/manual Test6411624
39 */
40 public class Test6411624 {
41
42 private static void init() throws Exception {
43 //*** Create instructions for the user here ***
44
45 String[] instructions =
46 {
47 "This test should only be run on solaris or linux system",
48 "WITHOUT audio card installed (to test on SunRay set",
49 "incorrect $AUDIODEV value).",
50 "If you system does not meet this conditions, press PASS.",
51 "To run the test follow these instructions:",
52 "1. Open a terminal window.",
53 "2. Type \"cd " + System.getProperty("test.classes") + "\".",
54 "3. Type \"" + System.getProperty("java.home") + "/bin/java bug6411624\".",
55 "4. Follow the instructions shown in the terminal window.",
56 "If you see \"All tests sucessfully passed\", press PASS else press FAIL."
57 };
58
59 Sysout.createDialog( );
60 Sysout.printInstructions( instructions );
61
62 }
63
64 /*****************************************************
65 Standard Test Machinery Section
66 DO NOT modify anything in this section -- it's a
67 standard chunk of code which has all of the
68 synchronisation necessary for the test harness.
69 By keeping it the same in all tests, it is easier
70 to read and understand someone else's test, as
71 well as insuring that all tests behave correctly
72 with the test harness.
73 There is a section following this for test-defined
74 classes
75 ******************************************************/
76 private static boolean theTestPassed = false;
77 private static boolean testGeneratedInterrupt = false;
78 private static String failureMessage = "";
79
80 private static Thread mainThread = null;
81
82 private static int sleepTime = 300000;
83
84 public static void main( String args[] ) throws Exception
85 {
86 mainThread = Thread.currentThread();
87 try
88 {
89 init();
90 }
91 catch( TestPassedException e )
92 {
93 //The test passed, so just return from main and harness will
94 // interepret this return as a pass
95 return;
96 }
97 //At this point, neither test passed nor test failed has been
98 // called -- either would have thrown an exception and ended the
99 // test, so we know we have multiple threads.
100
101 //Test involves other threads, so sleep and wait for them to
102 // called pass() or fail()
103 try
104 {
105 Thread.sleep( sleepTime );
106 //Timed out, so fail the test
107 throw new RuntimeException( "Timed out after " + sleepTime/1000 + " seconds" );
108 }
109 catch (InterruptedException e)
110 {
111 if( ! testGeneratedInterrupt ) throw e;
112
113 //reset flag in case hit this code more than once for some reason (just safety)
114 testGeneratedInterrupt = false;
115 if ( theTestPassed == false )
116 {
117 throw new RuntimeException( failureMessage );
118 }
119 }
120
121 }//main
122
123 public static synchronized void setTimeoutTo( int seconds )
124 {
125 sleepTime = seconds * 1000;
126 }
127
128 public static synchronized void pass()
129 {
130 Sysout.println( "The test passed." );
131 Sysout.println( "The test is over, hit Ctl-C to stop Java VM" );
132 //first check if this is executing in main thread
133 if ( mainThread == Thread.currentThread() )
134 {
135 //Still in the main thread, so set the flag just for kicks,
136 // and throw a test passed exception which will be caught
137 // and end the test.
138 theTestPassed = true;
139 throw new TestPassedException();
140 }
141 //pass was called from a different thread, so set the flag and interrupt
142 // the main thead.
143 theTestPassed = true;
144 testGeneratedInterrupt = true;
145 mainThread.interrupt();
146 }//pass()
147
148 public static synchronized void fail()
149 {
150 //test writer didn't specify why test failed, so give generic
151 fail( "it just plain failed! :-)" );
152 }
153
154 public static synchronized void fail( String whyFailed )
155 {
156 Sysout.println( "The test failed: " + whyFailed );
157 Sysout.println( "The test is over, hit Ctl-C to stop Java VM" );
158 //check if this called from main thread
159 if ( mainThread == Thread.currentThread() )
160 {
161 //If main thread, fail now 'cause not sleeping
162 throw new RuntimeException( whyFailed );
163 }
164 theTestPassed = false;
165 testGeneratedInterrupt = true;
166 failureMessage = whyFailed;
167 mainThread.interrupt();
168 }//fail()
169
170 }// class Orient
171
172 //This exception is used to exit from any level of call nesting
173 // when it's determined that the test has passed, and immediately
174 // end the test.
175 class TestPassedException extends RuntimeException
176 {
177 }
178
179 //*********** End Standard Test Machinery Section **********
180
181
182 //************ Begin classes defined for the test ****************
183
184 // make listeners in a class defined here, and instantiate them in init()
185
186 /* Example of a class which may be written as part of a test
187 class NewClass implements anInterface
188 {
189 static int newVar = 0;
190
191 public void eventDispatched(AWTEvent e)
192 {
193 //Counting events to see if we get enough
194 eventCount++;
195
196 if( eventCount == 20 )
197 {
198 //got enough events, so pass
199
200 Orient.pass();
201 }
202 else if( tries == 20 )
203 {
204 //tried too many times without getting enough events so fail
205
206 Orient.fail();
207 }
208
209 }// eventDispatched()
210
211 }// NewClass class
212
213 */
214
215
216 //************** End classes defined for the test *******************
217
218
219
220
221 /****************************************************
222 Standard Test Machinery
223 DO NOT modify anything below -- it's a standard
224 chunk of code whose purpose is to make user
225 interaction uniform, and thereby make it simpler
226 to read and understand someone else's test.
227 ****************************************************/
228
229 /**
230 This is part of the standard test machinery.
231 It creates a dialog (with the instructions), and is the interface
232 for sending text messages to the user.
233 To print the instructions, send an array of strings to Sysout.createDialog
234 WithInstructions method. Put one line of instructions per array entry.
235 To display a message for the tester to see, simply call Sysout.println
236 with the string to be displayed.
237 This mimics System.out.println but works within the test harness as well
238 as standalone.
239 */
240
241 class Sysout
242 {
243 private static TestDialog dialog;
244
245 public static void createDialogWithInstructions( String[] instructions )
246 {
247 dialog = new TestDialog( new Frame(), "Instructions" );
248 dialog.printInstructions( instructions );
249 dialog.show();
250 println( "Any messages for the tester will display here." );
251 }
252
253 public static void createDialog( )
254 {
255 dialog = new TestDialog( new Frame(), "Instructions" );
256 String[] defInstr = { "Instructions will appear here. ", "" } ;
257 dialog.printInstructions( defInstr );
258 dialog.show();
259 println( "Any messages for the tester will display here." );
260 }
261
262
263 public static void printInstructions( String[] instructions )
264 {
265 dialog.printInstructions( instructions );
266 }
267
268
269 public static void println( String messageIn )
270 {
271 dialog.displayMessage( messageIn );
272 }
273
274 }// Sysout class
275
276 /**
277 This is part of the standard test machinery. It provides a place for the
278 test instructions to be displayed, and a place for interactive messages
279 to the user to be displayed.
280 To have the test instructions displayed, see Sysout.
281 To have a message to the user be displayed, see Sysout.
282 Do not call anything in this dialog directly.
283 */
284 class TestDialog extends Dialog implements ActionListener
285 {
286
287 TextArea instructionsText;
288 TextArea messageText;
289 int maxStringLength = 80;
290 Panel buttonP = new Panel();
291 Button passB = new Button( "pass" );
292 Button failB = new Button( "fail" );
293
294 //DO NOT call this directly, go through Sysout
295 public TestDialog( Frame frame, String name )
296 {
297 super( frame, name );
298 int scrollBoth = TextArea.SCROLLBARS_BOTH;
299 instructionsText = new TextArea( "", 15, maxStringLength, scrollBoth );
300 add( "North", instructionsText );
301
302 messageText = new TextArea( "", 5, maxStringLength, scrollBoth );
303 add("Center", messageText);
304
305 passB = new Button( "pass" );
306 passB.setActionCommand( "pass" );
307 passB.addActionListener( this );
308 buttonP.add( "East", passB );
309
310 failB = new Button( "fail" );
311 failB.setActionCommand( "fail" );
312 failB.addActionListener( this );
313 buttonP.add( "West", failB );
314
315 add( "South", buttonP );
316 pack();
317
318 show();
319 }// TestDialog()
320
321 //DO NOT call this directly, go through Sysout
322 public void printInstructions( String[] instructions )
323 {
324 //Clear out any current instructions
325 instructionsText.setText( "" );
326
327 //Go down array of instruction strings
328
329 String printStr, remainingStr;
330 for( int i=0; i < instructions.length; i++ )
331 {
332 //chop up each into pieces maxSringLength long
333 remainingStr = instructions[ i ];
334 while( remainingStr.length() > 0 )
335 {
336 //if longer than max then chop off first max chars to print
337 if( remainingStr.length() >= maxStringLength )
338 {
339 //Try to chop on a word boundary
340 int posOfSpace = remainingStr.
341 lastIndexOf( ' ', maxStringLength - 1 );
342
343 if( posOfSpace <= 0 ) posOfSpace = maxStringLength - 1;
344
345 printStr = remainingStr.substring( 0, posOfSpace + 1 );
346 remainingStr = remainingStr.substring( posOfSpace + 1 );
347 }
348 //else just print
349 else
350 {
351 printStr = remainingStr;
352 remainingStr = "";
353 }
354
355 instructionsText.append( printStr + "\n" );
356
357 }// while
358
359 }// for
360
361 }//printInstructions()
362
363 //DO NOT call this directly, go through Sysout
364 public void displayMessage( String messageIn )
365 {
366 messageText.append( messageIn + "\n" );
367 }
368
369 //catch presses of the passed and failed buttons.
370 //simply call the standard pass() or fail() static methods of
371 //DialogOrient
372 public void actionPerformed( ActionEvent e )
373 {
374 if( e.getActionCommand() == "pass" )
375 {
376 Test6411624.pass();
377 }
378 else
379 {
380 Test6411624.fail();
381 }
382 }
383
384 }// TestDialog class