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