/*
* 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.
*
* 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.
*/
/*
* @test
* @bug 6479237
* @summary Test the format of StackTraceElement::toString and its serial form
* @modules java.logging
* java.xml.bind
* @run main SerialTest
*/
import javax.xml.bind.JAXBElement;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.UncheckedIOException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.logging.Logger;
public class SerialTest {
private static final Path SER_DIR = Paths.get("sers");
private static final String JAVA_BASE = "java.base";
private static final String JAVA_LOGGING = "java.logging";
private static final String JAVA_XML_BIND = "java.xml.bind";
private static boolean isImage;
public static void main(String... args) throws Exception {
Files.createDirectories(SER_DIR);
// detect if exploded image build
Path home = Paths.get(System.getProperty("java.home"));
isImage = Files.exists(home.resolve("lib").resolve("modules"));
// test stack trace from built-in loaders
try {
Logger.getLogger(null);
} catch (NullPointerException e) {
Arrays.stream(e.getStackTrace())
.filter(ste -> ste.getClassName().startsWith("java.util.logging.") ||
ste.getClassName().equals("SerialTest"))
.forEach(SerialTest::test);
}
// test stack trace with upgradeable module
try {
new JAXBElement(null, null, null);
} catch (IllegalArgumentException e) {
Arrays.stream(e.getStackTrace())
.filter(ste -> ste.getModuleName() != null)
.forEach(SerialTest::test);
}
// test stack trace with class loader name from other class loader
Loader loader = new Loader("myloader");
Class<?> cls = Class.forName("SerialTest", true, loader);
Method method = cls.getMethod("throwException");
StackTraceElement ste = (StackTraceElement)method.invoke(null);
test(ste, loader);
// verify the class loader name and in the stack trace
if (!cls.getClassLoader().getName().equals("myloader.hacked")) {
throw new RuntimeException("Unexpected loader name: " +
cls.getClassLoader().getName());
}
if (!ste.getClassLoaderName().equals("myloader")) {
throw new RuntimeException("Unexpected loader name: " +
ste.getClassLoaderName());
}
}
private static void test(StackTraceElement ste) {
test(ste, null);
}
private static void test(StackTraceElement ste, ClassLoader loader) {
try {
SerialTest serialTest = new SerialTest(ste);
StackTraceElement ste2 = serialTest.serialize().deserialize();
System.out.println(ste2);
// verify StackTraceElement::toString returns the same string
if (!ste.equals(ste2) || !ste.toString().equals(ste2.toString())) {
throw new RuntimeException(ste + " != " + ste2);
}
String mn = ste.getModuleName();
if (mn != null) {
switch (mn) {
case JAVA_BASE:
case JAVA_LOGGING:
checkNamedModule(ste, loader, false);
break;
case JAVA_XML_BIND:
// for exploded build, no version is shown
checkNamedModule(ste, loader, isImage);
break;
default: // ignore
}
} else {
checkUnnamedModule(ste, loader);
}
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}
private static void checkUnnamedModule(StackTraceElement ste, ClassLoader loader) {
String mn = ste.getModuleName();
String s = ste.toString();
int i = s.indexOf('/');
if (mn != null) {
throw new RuntimeException("expected null but got " + mn);
}
if (loader != null) {
// Expect <loader>//<classname>.<method>(<src>:<ln>)
if (i <= 0) {
throw new RuntimeException("loader name missing: " + s);
}
if (!getLoaderName(loader).equals(s.substring(0, i))) {
throw new RuntimeException("unexpected loader name: " + s);
}
int j = s.substring(i+1).indexOf('/');
if (j != 0) {
throw new RuntimeException("unexpected element for unnamed module: " + s);
}
}
}
/*
* Loader::getName is overridden to return some other name
*/
private static String getLoaderName(ClassLoader loader) {
if (loader == null)
return "";
if (loader instanceof Loader) {
return ((Loader) loader).name;
} else {
return loader.getName();
}
}
private static void checkNamedModule(StackTraceElement ste,
ClassLoader loader,
boolean showVersion) {
String loaderName = getLoaderName(loader);
String mn = ste.getModuleName();
String s = ste.toString();
int i = s.indexOf('/');
if (mn == null) {
throw new RuntimeException("expected module name: " + s);
}
if (i <= 0) {
throw new RuntimeException("module name missing: " + s);
}
// Expect <module>/<classname>.<method>(<src>:<ln>)
if (!loaderName.isEmpty()) {
throw new IllegalArgumentException(loaderName);
}
// <module>: name@version
int j = s.indexOf('@');
if ((showVersion && j <= 0) || (!showVersion && j >= 0)) {
throw new RuntimeException("unexpected version: " + s);
}
String name = j < 0 ? s.substring(0, i) : s.substring(0, j);
if (!name.equals(mn)) {
throw new RuntimeException("unexpected module name: " + s);
}
}
private final Path ser;
private final StackTraceElement ste;
SerialTest(StackTraceElement ste) throws IOException {
this.ser = Files.createTempFile(SER_DIR, "SerialTest", ".ser");
this.ste = ste;
}
private StackTraceElement deserialize() throws IOException {
try (InputStream in = Files.newInputStream(ser);
BufferedInputStream bis = new BufferedInputStream(in);
ObjectInputStream ois = new ObjectInputStream(bis)) {
return (StackTraceElement)ois.readObject();
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
private SerialTest serialize() throws IOException {
try (OutputStream out = Files.newOutputStream(ser);
BufferedOutputStream bos = new BufferedOutputStream(out);
ObjectOutputStream oos = new ObjectOutputStream(bos)) {
oos.writeObject(ste);
}
return this;
}
public static StackTraceElement throwException() {
try {
Integer.parseInt(null);
} catch (NumberFormatException e) {
return Arrays.stream(e.getStackTrace())
.filter(ste -> ste.getMethodName().equals("throwException"))
.findFirst().get();
}
return null;
}
public static class Loader extends URLClassLoader {
final String name;
Loader(String name) throws MalformedURLException {
super(name, new URL[] { testClassesURL() } , null);
this.name = name;
}
private static URL testClassesURL() throws MalformedURLException {
Path path = Paths.get(System.getProperty("test.classes"));
return path.toUri().toURL();
}
public String getName() {
return name + ".hacked";
}
}
}