|
/*
* Copyright (c) 2016, 2019, 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.Utils
* jdk.test.lib.Asserts
* jdk.test.lib.JDKToolFinder
* jdk.test.lib.JDKToolLauncher
* jdk.test.lib.Platform
* jdk.test.lib.process.*
* @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},
{"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[][] posixNonOSXSignals = {
{"BUS", IsSupported.YES, CanRegister.YES, CanRaise.YES, invokedXrs},
{"INFO", IsSupported.NO, CanRegister.NO, CanRaise.NO, Invoked.NO},
};
Object[][] posixOSXSignals = {
{"BUS", IsSupported.YES, CanRegister.NO, CanRaise.NO, Invoked.NO},
{"INFO", 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},
};
Object[][] combinedPosixSignals = concatArrays(posixSignals,
(Platform.isOSX() ? posixOSXSignals : posixNonOSXSignals));
return concatArrays(commonSignals, (Platform.isWindows() ? windowsSignals : combinedPosixSignals));
}
// 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();
}
}
¤ Dauer der Verarbeitung: 1.199 Sekunden
(vorverarbeitet)
¤
|
Haftungshinweis
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
|
