1 /*
2 * Copyright (c) 2018, 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
26 * @bug 4227137
27 * @summary Basic functional test for virtual-machine shutdown hooks
28 * @modules java.desktop
29 * @library /test/lib
30 * @build jdk.test.lib.process.*
31 * @run testng Basic
32 */
33
34 import java.lang.reflect.Method;
35 import java.lang.reflect.InvocationTargetException;
36 import java.io.PrintStream;
37 import java.io.FileOutputStream;
38 import java.awt.Frame;
39 import java.awt.TextArea;
40 import java.awt.event.WindowEvent;
41 import java.awt.event.WindowAdapter;
42
43 import org.testng.annotations.DataProvider;
44 import org.testng.annotations.Test;
45 import jdk.test.lib.process.ProcessTools;
46
47 public class Basic {
48
49 static Runtime rt = Runtime.getRuntime();
50 static PrintStream out = System.out;
51
52 @DataProvider(name = "testcase")
53 public Object[][] getTestCase() {
54 return new Object[][] {
55 { "fallThrough", 0, "h1", "f1" },
56 { "exit0", 0, "h1", "f1" },
57 { "exit0NoHook", 0, "", "f1" },
58 { "exit1", 1, "h1", "" },
59 { "exit1NoHook", 1, "", "" },
60 { "halt", 0, "", "" },
61 { "haltNoHook", 0, "", "" },
62 { "haltInHook", 0, "h1", "" },
63 { "addLate", 0, "h1",
64 "Caught as expected: java.lang.IllegalStateException: Shutdown in progress" },
65 { "removeLate", 0, "h2",
66 "Caught as expected: java.lang.IllegalStateException: Shutdown in progress" }
67 };
68 }
69
70 @Test(dataProvider = "testcase")
71 public void test(String testcase, int exitValue, String hook, String finalizer)
72 throws Exception {
73 System.out.println("Test " + testcase);
74 ProcessTools.executeTestJava("Basic", testcase)
75 .shouldHaveExitValue(exitValue)
76 .stdoutShouldMatch(
77 hook + (hook.isEmpty() ? "" : System.lineSeparator()) + finalizer);
78 System.out.println("Passed");
79 }
80
81 public static class Fin {
82 String name;
83
84 public Fin(String name) {
85 this.name = name;
86 }
87
88 public void go() { }
89
90 protected void finalize() {
91 out.println(name);
92 go();
93 }
94 }
95
96
97 public static class Hook extends Thread {
98 String name;
99
100 public Hook(String name) {
101 this.name = name;
102 }
103
104 public void go() { }
105
106 public void run() {
107 out.println(name);
108 go();
109 }
110 }
111
112 public static void fallThrough() throws Exception {
113 rt.addShutdownHook(new Hook("h1"));
114 Fin f = new Fin("f1");
115 rt.runFinalizersOnExit(true);
116 }
117
118 public static void exit0() throws Exception {
119 rt.addShutdownHook(new Hook("h1"));
120 Fin f = new Fin("f1");
121 rt.runFinalizersOnExit(true);
122 rt.exit(0);
123 }
124
125 public static void exit0NoHook() throws Exception {
126 Fin f = new Fin("f1");
127 rt.runFinalizersOnExit(true);
128 rt.exit(0);
129 }
130
131 /* Finalizer should not run */
132 public static void exit1() throws Exception {
133 rt.addShutdownHook(new Hook("h1"));
134 Fin f = new Fin("f1");
135 rt.runFinalizersOnExit(true);
136 rt.exit(1);
137 }
138
139 public static void exit1NoHook() throws Exception {
140 Fin f = new Fin("f1");
141 rt.runFinalizersOnExit(true);
142 rt.exit(1);
143 }
144
145 public static void halt() throws Exception {
146 rt.addShutdownHook(new Hook("h1") {
147 public void go() { rt.halt(1); }});
148 Fin f = new Fin("f1") { public void go() { rt.halt(1); }};
149 rt.runFinalizersOnExit(true);
150 rt.halt(0);
151 }
152
153 public static void haltNoHook() throws Exception {
154 Fin f = new Fin("f1") { public void go() { rt.halt(1); }};
155 rt.runFinalizersOnExit(true);
156 rt.halt(0);
157 }
158
159 public static void haltInHook() throws Exception {
160 rt.addShutdownHook(new Hook("h1") {
161 public void go() { rt.halt(0); }});
162 Fin f = new Fin("f1");
163 rt.runFinalizersOnExit(true);
164 rt.exit(1);
165 }
166
167 public static void addLate() throws Exception {
168 rt.addShutdownHook(new Hook("h1") {
169 public void go() {
170 try {
171 rt.addShutdownHook(new Hook("h2"));
172 } catch (IllegalStateException x) {
173 out.println("Caught as expected: " + x);
174 rt.halt(0);
175 }
176 }});
177 rt.exit(1);
178 }
179
180 public static void removeLate() throws Exception {
181 final Hook h1 = new Hook("h1");
182 rt.addShutdownHook(new Hook("h2") {
183 public void go() {
184 try {
185 rt.removeShutdownHook(h1);
186 } catch (IllegalStateException x) {
187 out.println("Caught as expected: " + x);
188 rt.halt(0);
189 }
190 }});
191 rt.exit(1);
192 }
193
194
195 /* The following two methods are provided for manual testing only.
196 * Neither test is suitable for being run from within the harness.
197 */
198
199 public static void awt() throws Exception {
200 final Frame f = new Frame();
201 final TextArea ta = new TextArea();
202 Fin fx = new Fin("f1");
203 rt.runFinalizersOnExit(true);
204 rt.addShutdownHook(new Hook("h1") {
205 public void go() {
206 ta.setText("Hooked!");
207 out.println("Hooked!");
208 try {
209 Thread.sleep(1000);
210 } catch (InterruptedException x) { }
211 ta.append("\nSleep 1");
212 out.println("Sleep 1");
213 try {
214 Thread.sleep(1000);
215 } catch (InterruptedException x) { }
216 ta.append("\nSleep 2");
217 out.println("Sleep 2");
218 }});
219 f.addWindowListener(new WindowAdapter() {
220 public void windowClosing(WindowEvent e) {
221 out.println("Closing...");
222 ta.setText("Closing...");
223 try {
224 Thread.sleep(1000);
225 } catch (InterruptedException x) { }
226 f.dispose();
227 rt.exit(42);
228 }});
229 ta.setText("Terminate me!");
230 f.add(ta);
231 f.pack();
232 f.show();
233 Thread.sleep(10000);
234 }
235
236 /* For INT, HUP, TERM */
237 public static void stall() throws Exception {
238 Fin f = new Fin("f1");
239 rt.runFinalizersOnExit(true);
240 rt.addShutdownHook(new Hook("h1"));
241 out.print("Type ^C now: ");
242 out.flush();
243 Thread.sleep(100000);
244 }
245
246
247 public static void main(String[] args) throws Throwable {
248 Method m = Basic.class.getMethod(args[0], new Class[] { });
249 String log = null;
250 try {
251 log = System.getProperty("log");
252 } catch (SecurityException x) { }
253 if (log != null) {
254 out = new PrintStream(new FileOutputStream(log), true);
255 }
256 try {
257 m.invoke(null, new Object[] { });
258 } catch (InvocationTargetException x) {
259 throw x.getTargetException();
260 }
261 }
262
263 }