| /* |
| * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Objects; |
| import java.util.concurrent.Semaphore; |
| import java.util.concurrent.TimeUnit; |
| |
| import org.testng.Assert; |
| import org.testng.TestNG; |
| import org.testng.annotations.Test; |
| import org.testng.annotations.BeforeSuite; |
| import org.testng.annotations.DataProvider; |
| |
| import jdk.test.lib.Platform; |
| import jdk.test.lib.Utils; |
| |
| import sun.misc.Signal; |
| import sun.misc.SignalHandler; |
| |
| /* |
| * @test |
| * @library /test/lib |
| * @modules jdk.unsupported |
| * java.base/jdk.internal.misc |
| * @build jdk.test.lib.Platform jdk.test.lib.Utils |
| * @run testng/othervm -Xrs -DXrs=true SunMiscSignalTest |
| * @run testng/othervm SunMiscSignalTest |
| * @summary sun.misc.Signal test |
| */ |
| |
| @Test |
| public class SunMiscSignalTest { |
| |
| // Set to true to enable additional debug output |
| static boolean debug = true; |
| |
| // True to test while running with -Xrs |
| static boolean RUNNING_WITH_Xrs = Boolean.getBoolean("Xrs"); |
| |
| /** |
| * Print a debug message if enabled. |
| * |
| * @param format the format |
| * @param args the arguments |
| */ |
| static void printf(String format, Object... args) { |
| if (debug) { |
| System.out.printf(" " + format, args); |
| } |
| } |
| |
| enum IsSupported {NO, YES} |
| |
| enum CanRegister {NO, YES} |
| |
| enum CanRaise {NO, YES} |
| |
| enum Invoked {NO, YES} |
| |
| enum RestrictedSignals {NORMAL, XRS} |
| |
| @BeforeSuite |
| static void setup() { |
| System.out.printf("-Xrs: %s%n", RUNNING_WITH_Xrs); |
| } |
| |
| // Provider of signals to be tested with variations for -Xrs and |
| // platform dependencies |
| // -Xrs restricted signals signals the VM will not handle SIGINT, SIGTERM, SIGHUP and others |
| @DataProvider(name = "supportedSignals") |
| static Object[][] supportedSignals() { |
| RestrictedSignals rs = RUNNING_WITH_Xrs ? RestrictedSignals.XRS : RestrictedSignals.NORMAL; |
| CanRegister registerXrs = RUNNING_WITH_Xrs ? CanRegister.NO : CanRegister.YES; |
| CanRaise raiseXrs = RUNNING_WITH_Xrs ? CanRaise.NO : CanRaise.YES; |
| Invoked invokedXrs = RUNNING_WITH_Xrs ? Invoked.NO : Invoked.YES; |
| |
| Object[][] commonSignals = new Object[][]{ |
| {"INT", IsSupported.YES, registerXrs, raiseXrs, invokedXrs}, |
| {"TERM", IsSupported.YES, registerXrs, raiseXrs, invokedXrs}, |
| {"ABRT", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs}, |
| }; |
| |
| Object[][] posixSignals = { |
| {"HUP", IsSupported.YES, registerXrs, raiseXrs, invokedXrs}, |
| {"QUIT", IsSupported.YES, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"BUS", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs}, |
| {"USR1", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs}, |
| {"USR2", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs}, |
| {"PIPE", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs}, |
| {"ALRM", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs}, |
| {"CHLD", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs}, |
| {"CONT", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs}, |
| {"TSTP", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs}, |
| {"TTIN", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs}, |
| {"TTOU", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs}, |
| {"URG", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs}, |
| {"XCPU", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs}, |
| {"XFSZ", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs}, |
| {"VTALRM", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs}, |
| {"PROF", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs}, |
| {"WINCH", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs}, |
| {"IO", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs}, |
| {"SYS", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs}, |
| }; |
| |
| Object[][] windowsSignals = { |
| {"HUP", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"QUIT", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"BUS", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"USR1", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"USR2", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"PIPE", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"ALRM", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"CHLD", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"CONT", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"TSTP", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"TTIN", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"TTOU", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"URG", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"XCPU", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"XFSZ", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"VTALRM", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"PROF", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"WINCH", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"IO", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| {"SYS", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO}, |
| }; |
| |
| return concatArrays(commonSignals, (Platform.isWindows() ? windowsSignals : posixSignals)); |
| } |
| |
| // Provider of invalid signal names |
| @DataProvider(name = "invalidSunMiscSignalNames") |
| Object[][] invalidSunMiscSignalNames() { |
| return new Object[][]{ |
| {""}, |
| {"I"}, |
| {"SIG"}, |
| {"SIGabc"}, |
| {"SIGINT"}, // prefix not allowed |
| {"abc"}, |
| }; |
| } |
| |
| static Object[][] concatArrays(Object[][]... arrays) { |
| int l = 0; |
| for (Object[][] a : arrays) { |
| l += a.length; |
| } |
| |
| Object[][] newArray = new Object[l][]; |
| l = 0; |
| for (int i = 0; i < arrays.length; i++) { |
| System.arraycopy(arrays[i], 0, newArray, l, arrays[i].length); |
| l += arrays[i].length; |
| } |
| |
| return newArray; |
| } |
| |
| // Return true if the signal is one of the shutdown signals known to the VM |
| private static boolean isShutdownSignal(Signal signal) { |
| String name = signal.getName(); |
| return name.equals("INT") || name.equals("HUP") || name.equals("TERM"); |
| } |
| |
| /** |
| * Quick verification of supported signals using sun.misc.Signal. |
| * |
| * @param name the signal name |
| * @throws InterruptedException would be an error if thrown |
| */ |
| @Test(dataProvider = "supportedSignals") |
| static void testSunMisc(String name, IsSupported supported, CanRegister register, |
| CanRaise raise, Invoked invoked) throws InterruptedException { |
| Handler h = new Handler(); |
| SignalHandler orig = null; |
| Signal signal = null; |
| try { |
| signal = new Signal(name); |
| Assert.assertEquals(supported, IsSupported.YES, "Unexpected support for " + name); |
| |
| Assert.assertEquals(signal.getName(), name, "getName() mismatch, "); |
| |
| Assert.assertEquals(signal.toString(), "SIG" + name, "toString() mismatch, "); |
| |
| try { |
| orig = Signal.handle(signal, h); |
| printf("oldHandler: %s%n", orig); |
| Assert.assertEquals(CanRegister.YES, register, "Unexpected handle succeeded " + name); |
| try { |
| Signal.raise(signal); |
| Assert.assertEquals(CanRaise.YES, raise, "Unexpected raise success for " + name); |
| Invoked inv = h.semaphore().tryAcquire(Utils.adjustTimeout(100L), |
| TimeUnit.MILLISECONDS) ? Invoked.YES : Invoked.NO; |
| if (!isShutdownSignal(signal)) { |
| // Normal case |
| Assert.assertEquals(inv, invoked, "handler not invoked;"); |
| } else { |
| if (orig == SignalHandler.SIG_IGN) { |
| Assert.assertEquals(inv, Invoked.NO, "handler should not be invoked"); |
| } else { |
| Assert.assertEquals(inv, invoked, "handler not invoked;"); |
| } |
| } |
| } catch (IllegalArgumentException uoe3) { |
| Assert.assertNotEquals(CanRaise.YES, raise, "raise failed for " + name + |
| ": " + uoe3.getMessage()); |
| } |
| } catch (IllegalArgumentException uoe2) { |
| Assert.assertNotEquals(CanRegister.YES, register, "handle failed for: " + name + |
| ": " + uoe2.getMessage()); |
| } |
| } catch (IllegalArgumentException uoe) { |
| Assert.assertNotEquals(IsSupported.YES, supported, "Support missing for " + name + |
| ": " + uoe.getMessage()); |
| return; |
| } finally { |
| // Restore original signal handler |
| if (orig != null && signal != null) { |
| Signal.handle(signal, orig); |
| } |
| } |
| } |
| |
| // Test Signal is equal to itself and not equals to others |
| @Test(dataProvider = "supportedSignals") |
| static void testEquals(String name, IsSupported supported, CanRegister register, |
| CanRaise raise, Invoked invoked) { |
| Object[][] data = supportedSignals(); |
| for (int i = 0; i < data.length; i++) { |
| IsSupported otherSupported = (IsSupported) data[i][1]; |
| if (supported == IsSupported.NO || otherSupported == IsSupported.NO) { |
| continue; |
| } |
| String otherName = (String) data[i][0]; |
| |
| Signal sig1 = new Signal(name); |
| Signal sig2 = new Signal(otherName); |
| if (name.equals(otherName)) { |
| Assert.assertEquals(sig1, sig2, "Equals failed; "); |
| Assert.assertEquals(sig1.hashCode(), sig2.hashCode(), "HashCode wrong; "); |
| } else { |
| Assert.assertNotEquals(sig1, sig2, "NotEquals failed; "); |
| Assert.assertNotEquals(sig1.hashCode(), sig2.hashCode(), "HashCode wrong; "); |
| } |
| } |
| } |
| |
| @Test(dataProvider = "invalidSunMiscSignalNames") |
| static void testSunMiscIAE(String name) { |
| try { |
| new Signal(name); |
| Assert.fail("Should have thrown IAE for signal: " + name); |
| } catch (IllegalArgumentException iae) { |
| Assert.assertEquals(iae.getMessage(), "Unknown signal: " + name, "getMessage() incorrect; "); |
| } |
| } |
| |
| // Note: JDK 8 did not check/throw NPE, passing null resulted in a segv |
| @Test(expectedExceptions = NullPointerException.class) |
| static void nullSignal() { |
| new Signal(null); |
| } |
| |
| // Test expected exception when raising a signal when no handler defined |
| @Test |
| static void testRaiseNoConsumer() { |
| Signal signal = new Signal("INT"); |
| SignalHandler orig = null; |
| try { |
| orig = Signal.handle(signal, SignalHandler.SIG_DFL); |
| printf("oldHandler: %s%n", orig); |
| if (orig == SignalHandler.SIG_IGN) { |
| // SIG_IGN for TERM means it cannot be handled |
| return; |
| } |
| Signal.raise(signal); |
| Assert.fail("Should have thrown IllegalArgumentException"); |
| } catch (IllegalArgumentException iae) { |
| printf("IAE message: %s%n", iae.getMessage()); |
| } finally { |
| // Restore original signal handler |
| if (orig != null && signal != null) { |
| Signal.handle(signal, orig); |
| } |
| } |
| } |
| |
| /** |
| * The thread that runs the handler for sun.misc.Signal should be a |
| * Daemon thread. |
| */ |
| @Test |
| static void isDaemonThread() throws InterruptedException { |
| if (RUNNING_WITH_Xrs) { |
| return; |
| } |
| Handler handler = new Handler(); |
| Signal signal = new Signal("INT"); |
| SignalHandler orig = Signal.handle(signal, handler); |
| printf("oldHandler: %s%n", orig); |
| if (orig == SignalHandler.SIG_IGN) { |
| // SIG_IGN for INT means it cannot be handled |
| return; |
| } |
| |
| Signal.raise(signal); |
| boolean handled = handler.semaphore() |
| .tryAcquire(Utils.adjustTimeout(100L), TimeUnit.MILLISECONDS); |
| if (!handled) { |
| // For debug try again |
| printf("Second try to see signal"); |
| handled = handler.semaphore() |
| .tryAcquire(Utils.adjustTimeout(2L), TimeUnit.SECONDS); |
| } |
| Assert.assertEquals(handled, !RUNNING_WITH_Xrs, |
| "raising s.m.Signal did not get a callback;"); |
| |
| Assert.assertTrue(handler.wasDaemon(), "Thread.isDaemon running the handler; "); |
| } |
| |
| // Check that trying to invoke SIG_DFL.handle throws UnsupportedOperationException. |
| @Test(expectedExceptions = UnsupportedOperationException.class) |
| static void cannotHandleSIGDFL() { |
| Signal signal = new Signal("INT"); |
| Assert.assertNotNull(SignalHandler.SIG_DFL, "SIG_DFL null; "); |
| SignalHandler.SIG_DFL.handle(signal); |
| } |
| |
| // Check that trying to invoke SIG_IGN.handle throws UnsupportedOperationException. |
| @Test(expectedExceptions = UnsupportedOperationException.class) |
| static void cannotHandleSIGIGN() { |
| Signal signal = new Signal("INT"); |
| Assert.assertNotNull(SignalHandler.SIG_IGN, "SIG_IGN null; "); |
| SignalHandler.SIG_IGN.handle(signal); |
| } |
| |
| // Check that setting a Signal handler returns the previous handler. |
| @Test() |
| static void checkLastHandler() { |
| if (RUNNING_WITH_Xrs) { |
| return; |
| } |
| Signal signal = new Signal("TERM"); |
| Handler h1 = new Handler(); |
| Handler h2 = new Handler(); |
| SignalHandler orig = Signal.handle(signal, h1); |
| if (orig == SignalHandler.SIG_IGN) { |
| // SIG_IGN for TERM means it cannot be handled |
| return; |
| } |
| |
| try { |
| SignalHandler prev = Signal.handle(signal, h2); |
| Assert.assertSame(prev, h1, "prev handler mismatch"); |
| |
| prev = Signal.handle(signal, h1); |
| Assert.assertSame(prev, h2, "prev handler mismatch"); |
| } finally { |
| if (orig != null && signal != null) { |
| Signal.handle(signal, orig); |
| } |
| } |
| } |
| |
| /** |
| * Test Handler, a SignalHandler for Signal notifications. |
| * Signals a semaphore when invoked and records whether |
| * the thread calling the Handler was a daemon. |
| */ |
| static class Handler implements SignalHandler { |
| // A semaphore to check for accept being called |
| Semaphore sema = new Semaphore(0); |
| |
| Boolean wasDaemon = null; |
| |
| Semaphore semaphore() { |
| return sema; |
| } |
| |
| synchronized Boolean wasDaemon() { |
| return wasDaemon; |
| } |
| |
| /** |
| * Releases the semaphore when called as SignalHandler.handle. |
| * |
| * @param signal the Signal that occurred |
| */ |
| @Override |
| public void handle(Signal signal) { |
| synchronized (this) { |
| wasDaemon = Thread.currentThread().isDaemon(); |
| } |
| sema.release(); |
| printf("sun.misc.handle sig: %s, num: %d%n", signal.getName(), signal.getNumber()); |
| } |
| |
| public String toString() { |
| return "Handler: sem: " + sema.getQueueLength() + |
| ", wasDaemon: " + Objects.toString(wasDaemon()); |
| } |
| } |
| |
| // Main can be used to run the tests from the command line with only testng.jar. |
| @SuppressWarnings("raw_types") |
| @Test(enabled = false) |
| public static void main(String[] args) { |
| Class<?>[] testclass = {SunMiscSignalTest.class}; |
| TestNG testng = new TestNG(); |
| testng.setTestClasses(testclass); |
| testng.run(); |
| } |
| |
| } |
