424 lines
18 KiB
Java
424 lines
18 KiB
Java
/*
|
|
* Copyright (c) 2015, 2017, 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 8071474
|
|
* @summary Better failure atomicity for default read object.
|
|
* @modules jdk.compiler
|
|
* @library /test/lib
|
|
* @build jdk.test.lib.Platform
|
|
* jdk.test.lib.util.FileUtils
|
|
* @compile FailureAtomicity.java SerialRef.java
|
|
* @run main failureAtomicity.FailureAtomicity
|
|
*/
|
|
|
|
package failureAtomicity;
|
|
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.ObjectInputStream;
|
|
import java.io.ObjectOutputStream;
|
|
import java.io.ObjectStreamClass;
|
|
import java.io.UncheckedIOException;
|
|
import java.lang.reflect.Constructor;
|
|
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.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.List;
|
|
import java.util.function.BiConsumer;
|
|
import java.util.stream.Collectors;
|
|
import javax.tools.JavaCompiler;
|
|
import javax.tools.JavaFileObject;
|
|
import javax.tools.StandardJavaFileManager;
|
|
import javax.tools.StandardLocation;
|
|
import javax.tools.ToolProvider;
|
|
import jdk.test.lib.util.FileUtils;
|
|
|
|
@SuppressWarnings("unchecked")
|
|
public class FailureAtomicity {
|
|
static final Path TEST_SRC = Paths.get(System.getProperty("test.src", "."));
|
|
static final Path TEST_CLASSES = Paths.get(System.getProperty("test.classes", "."));
|
|
static final Path fooTemplate = TEST_SRC.resolve("Foo.template");
|
|
static final Path barTemplate = TEST_SRC.resolve("Bar.template");
|
|
|
|
static final String[] PKGS = { "a.b.c", "x.y.z" };
|
|
|
|
public static void main(String[] args) throws Exception {
|
|
test_Foo();
|
|
test_BadFoo(); // 'Bad' => incompatible type; cannot be "fully" deserialized
|
|
test_FooWithReadObject();
|
|
test_BadFooWithReadObject();
|
|
|
|
test_Foo_Bar();
|
|
test_Foo_BadBar();
|
|
test_BadFoo_Bar();
|
|
test_BadFoo_BadBar();
|
|
test_Foo_BarWithReadObject();
|
|
test_Foo_BadBarWithReadObject();
|
|
test_BadFoo_BarWithReadObject();
|
|
test_BadFoo_BadBarWithReadObject();
|
|
test_FooWithReadObject_Bar();
|
|
test_FooWithReadObject_BadBar();
|
|
test_BadFooWithReadObject_Bar();
|
|
test_BadFooWithReadObject_BadBar();
|
|
}
|
|
|
|
static final BiConsumer<Object,Object> FOO_FIELDS_EQUAL = (a,b) -> {
|
|
try {
|
|
int aPrim = a.getClass().getField("fooPrim").getInt(a);
|
|
int bPrim = b.getClass().getField("fooPrim").getInt(b);
|
|
if (aPrim != bPrim)
|
|
throw new AssertionError("Not equal: (" + aPrim + "!=" + bPrim
|
|
+ "), in [" + a + "] [" + b + "]");
|
|
Object aRef = a.getClass().getField("fooRef").get(a);
|
|
Object bRef = b.getClass().getField("fooRef").get(b);
|
|
if (!aRef.equals(bRef))
|
|
throw new RuntimeException("Not equal: (" + aRef + "!=" + bRef
|
|
+ "), in [" + a + "] [" + b + "]");
|
|
} catch (NoSuchFieldException | IllegalAccessException x) {
|
|
throw new InternalError(x);
|
|
}
|
|
};
|
|
static final BiConsumer<Object,Object> FOO_FIELDS_DEFAULT = (ignore,b) -> {
|
|
try {
|
|
int aPrim = b.getClass().getField("fooPrim").getInt(b);
|
|
if (aPrim != 0)
|
|
throw new AssertionError("Expected 0, got:" + aPrim
|
|
+ ", in [" + b + "]");
|
|
Object aRef = b.getClass().getField("fooRef").get(b);
|
|
if (aRef != null)
|
|
throw new RuntimeException("Expected null, got:" + aRef
|
|
+ ", in [" + b + "]");
|
|
} catch (NoSuchFieldException | IllegalAccessException x) {
|
|
throw new InternalError(x);
|
|
}
|
|
};
|
|
static final BiConsumer<Object,Object> BAR_FIELDS_EQUAL = (a,b) -> {
|
|
try {
|
|
long aPrim = a.getClass().getField("barPrim").getLong(a);
|
|
long bPrim = b.getClass().getField("barPrim").getLong(b);
|
|
if (aPrim != bPrim)
|
|
throw new AssertionError("Not equal: (" + aPrim + "!=" + bPrim
|
|
+ "), in [" + a + "] [" + b + "]");
|
|
Object aRef = a.getClass().getField("barRef").get(a);
|
|
Object bRef = b.getClass().getField("barRef").get(b);
|
|
if (!aRef.equals(bRef))
|
|
throw new RuntimeException("Not equal: (" + aRef + "!=" + bRef
|
|
+ "), in [" + a + "] [" + b + "]");
|
|
} catch (NoSuchFieldException | IllegalAccessException x) {
|
|
throw new InternalError(x);
|
|
}
|
|
};
|
|
static final BiConsumer<Object,Object> BAR_FIELDS_DEFAULT = (ignore,b) -> {
|
|
try {
|
|
long aPrim = b.getClass().getField("barPrim").getLong(b);
|
|
if (aPrim != 0L)
|
|
throw new AssertionError("Expected 0, got:" + aPrim
|
|
+ ", in [" + b + "]");
|
|
Object aRef = b.getClass().getField("barRef").get(b);
|
|
if (aRef != null)
|
|
throw new RuntimeException("Expected null, got:" + aRef
|
|
+ ", in [" + b + "]");
|
|
} catch (NoSuchFieldException | IllegalAccessException x) {
|
|
throw new InternalError(x);
|
|
}
|
|
};
|
|
|
|
static void test_Foo() {
|
|
testFoo("Foo", "String", false, false, FOO_FIELDS_EQUAL); }
|
|
static void test_BadFoo() {
|
|
testFoo("BadFoo", "byte[]", true, false, FOO_FIELDS_DEFAULT); }
|
|
static void test_FooWithReadObject() {
|
|
testFoo("FooWithReadObject", "String", false, true, FOO_FIELDS_EQUAL); }
|
|
static void test_BadFooWithReadObject() {
|
|
testFoo("BadFooWithReadObject", "byte[]", true, true, FOO_FIELDS_DEFAULT); }
|
|
|
|
static void testFoo(String testName, String xyzZebraType,
|
|
boolean expectCCE, boolean withReadObject,
|
|
BiConsumer<Object,Object>... resultCheckers) {
|
|
System.out.println("\nTesting " + testName);
|
|
try {
|
|
Path testRoot = testDir(testName);
|
|
Path srcRoot = Files.createDirectory(testRoot.resolve("src"));
|
|
List<Path> srcFiles = new ArrayList<>();
|
|
srcFiles.add(createSrc(PKGS[0], fooTemplate, srcRoot, "String", withReadObject));
|
|
srcFiles.add(createSrc(PKGS[1], fooTemplate, srcRoot, xyzZebraType, withReadObject));
|
|
|
|
Path build = Files.createDirectory(testRoot.resolve("build"));
|
|
javac(build, srcFiles);
|
|
|
|
URLClassLoader loader = new URLClassLoader(new URL[]{ build.toUri().toURL() },
|
|
FailureAtomicity.class.getClassLoader());
|
|
Class<?> fooClass = Class.forName(PKGS[0] + ".Foo", true, loader);
|
|
Constructor<?> ctr = fooClass.getConstructor(
|
|
new Class<?>[]{int.class, String.class, String.class});
|
|
Object abcFoo = ctr.newInstance(5, "chegar", "zebra");
|
|
|
|
try {
|
|
toOtherPkgInstance(abcFoo, loader);
|
|
if (expectCCE)
|
|
throw new AssertionError("Expected CCE not thrown");
|
|
} catch (ClassCastException e) {
|
|
if (!expectCCE)
|
|
throw new AssertionError("UnExpected CCE: " + e);
|
|
}
|
|
|
|
Object deserialInstance = failureAtomicity.SerialRef.obj;
|
|
|
|
System.out.println("abcFoo: " + abcFoo);
|
|
System.out.println("deserialInstance: " + deserialInstance);
|
|
|
|
for (BiConsumer<Object, Object> rc : resultCheckers)
|
|
rc.accept(abcFoo, deserialInstance);
|
|
} catch (IOException x) {
|
|
throw new UncheckedIOException(x);
|
|
} catch (ReflectiveOperationException x) {
|
|
throw new InternalError(x);
|
|
}
|
|
}
|
|
|
|
static void test_Foo_Bar() {
|
|
testFooBar("Foo_Bar", "String", "String", false, false, false,
|
|
FOO_FIELDS_EQUAL, BAR_FIELDS_EQUAL);
|
|
}
|
|
static void test_Foo_BadBar() {
|
|
testFooBar("Foo_BadBar", "String", "byte[]", true, false, false,
|
|
FOO_FIELDS_DEFAULT, BAR_FIELDS_DEFAULT);
|
|
}
|
|
static void test_BadFoo_Bar() {
|
|
testFooBar("BadFoo_Bar", "byte[]", "String", true, false, false,
|
|
FOO_FIELDS_DEFAULT, BAR_FIELDS_DEFAULT);
|
|
}
|
|
static void test_BadFoo_BadBar() {
|
|
testFooBar("BadFoo_BadBar", "byte[]", "byte[]", true, false, false,
|
|
FOO_FIELDS_DEFAULT, BAR_FIELDS_DEFAULT);
|
|
}
|
|
static void test_Foo_BarWithReadObject() {
|
|
testFooBar("Foo_BarWithReadObject", "String", "String", false, false, true,
|
|
FOO_FIELDS_EQUAL, BAR_FIELDS_EQUAL);
|
|
}
|
|
static void test_Foo_BadBarWithReadObject() {
|
|
testFooBar("Foo_BadBarWithReadObject", "String", "byte[]", true, false, true,
|
|
FOO_FIELDS_EQUAL, BAR_FIELDS_DEFAULT);
|
|
}
|
|
static void test_BadFoo_BarWithReadObject() {
|
|
testFooBar("BadFoo_BarWithReadObject", "byte[]", "String", true, false, true,
|
|
FOO_FIELDS_DEFAULT, BAR_FIELDS_DEFAULT);
|
|
}
|
|
static void test_BadFoo_BadBarWithReadObject() {
|
|
testFooBar("BadFoo_BadBarWithReadObject", "byte[]", "byte[]", true, false, true,
|
|
FOO_FIELDS_DEFAULT, BAR_FIELDS_DEFAULT);
|
|
}
|
|
|
|
static void test_FooWithReadObject_Bar() {
|
|
testFooBar("FooWithReadObject_Bar", "String", "String", false, true, false,
|
|
FOO_FIELDS_EQUAL, BAR_FIELDS_EQUAL);
|
|
}
|
|
static void test_FooWithReadObject_BadBar() {
|
|
testFooBar("FooWithReadObject_BadBar", "String", "byte[]", true, true, false,
|
|
FOO_FIELDS_EQUAL, BAR_FIELDS_DEFAULT);
|
|
}
|
|
static void test_BadFooWithReadObject_Bar() {
|
|
testFooBar("BadFooWithReadObject_Bar", "byte[]", "String", true, true, false,
|
|
FOO_FIELDS_DEFAULT, BAR_FIELDS_DEFAULT);
|
|
}
|
|
static void test_BadFooWithReadObject_BadBar() {
|
|
testFooBar("BadFooWithReadObject_BadBar", "byte[]", "byte[]", true, true, false,
|
|
FOO_FIELDS_DEFAULT, BAR_FIELDS_DEFAULT);
|
|
}
|
|
|
|
static void testFooBar(String testName, String xyzFooZebraType,
|
|
String xyzBarZebraType, boolean expectCCE,
|
|
boolean fooWithReadObject, boolean barWithReadObject,
|
|
BiConsumer<Object,Object>... resultCheckers) {
|
|
System.out.println("\nTesting " + testName);
|
|
try {
|
|
Path testRoot = testDir(testName);
|
|
Path srcRoot = Files.createDirectory(testRoot.resolve("src"));
|
|
List<Path> srcFiles = new ArrayList<>();
|
|
srcFiles.add(createSrc(PKGS[0], fooTemplate, srcRoot, "String",
|
|
fooWithReadObject, "String"));
|
|
srcFiles.add(createSrc(PKGS[1], fooTemplate, srcRoot, xyzFooZebraType,
|
|
fooWithReadObject, xyzFooZebraType));
|
|
srcFiles.add(createSrc(PKGS[0], barTemplate, srcRoot, "String",
|
|
barWithReadObject, "String"));
|
|
srcFiles.add(createSrc(PKGS[1], barTemplate, srcRoot, xyzBarZebraType,
|
|
barWithReadObject, xyzFooZebraType));
|
|
|
|
Path build = Files.createDirectory(testRoot.resolve("build"));
|
|
javac(build, srcFiles);
|
|
|
|
URLClassLoader loader = new URLClassLoader(new URL[]{ build.toUri().toURL() },
|
|
FailureAtomicity.class.getClassLoader());
|
|
Class<?> fooClass = Class.forName(PKGS[0] + ".Bar", true, loader);
|
|
Constructor<?> ctr = fooClass.getConstructor(
|
|
new Class<?>[]{int.class, String.class, String.class,
|
|
long.class, String.class, String.class});
|
|
Object abcBar = ctr.newInstance( 5, "chegar", "zebraFoo", 111L, "aBar", "zebraBar");
|
|
|
|
try {
|
|
toOtherPkgInstance(abcBar, loader);
|
|
if (expectCCE)
|
|
throw new AssertionError("Expected CCE not thrown");
|
|
} catch (ClassCastException e) {
|
|
if (!expectCCE)
|
|
throw new AssertionError("UnExpected CCE: " + e);
|
|
}
|
|
|
|
Object deserialInstance = failureAtomicity.SerialRef.obj;
|
|
|
|
System.out.println("abcBar: " + abcBar);
|
|
System.out.println("deserialInstance: " + deserialInstance);
|
|
|
|
for (BiConsumer<Object, Object> rc : resultCheckers)
|
|
rc.accept(abcBar, deserialInstance);
|
|
} catch (IOException x) {
|
|
throw new UncheckedIOException(x);
|
|
} catch (ReflectiveOperationException x) {
|
|
throw new InternalError(x);
|
|
}
|
|
}
|
|
|
|
static Path testDir(String name) throws IOException {
|
|
Path testRoot = Paths.get("FailureAtomicity-" + name);
|
|
if (Files.exists(testRoot))
|
|
FileUtils.deleteFileTreeWithRetry(testRoot);
|
|
Files.createDirectory(testRoot);
|
|
return testRoot;
|
|
}
|
|
|
|
static String platformPath(String p) { return p.replace("/", File.separator); }
|
|
static String binaryName(String name) { return name.replace(".", "/"); }
|
|
static String condRemove(String line, String pattern, boolean hasReadObject) {
|
|
if (hasReadObject) { return line.replaceAll(pattern, ""); }
|
|
else { return line; }
|
|
}
|
|
static String condReplace(String line, String... zebraFooType) {
|
|
if (zebraFooType.length == 1) {
|
|
return line.replaceAll("\\$foo_zebra_type", zebraFooType[0]);
|
|
} else { return line; }
|
|
}
|
|
static String nameFromTemplate(Path template) {
|
|
return template.getFileName().toString().replaceAll(".template", "");
|
|
}
|
|
|
|
static Path createSrc(String pkg, Path srcTemplate, Path srcRoot,
|
|
String zebraType, boolean hasReadObject,
|
|
String... zebraFooType)
|
|
throws IOException
|
|
{
|
|
Path srcDst = srcRoot.resolve(platformPath(binaryName(pkg)));
|
|
Files.createDirectories(srcDst);
|
|
Path srcFile = srcDst.resolve(nameFromTemplate(srcTemplate) + ".java");
|
|
|
|
List<String> lines = Files.lines(srcTemplate)
|
|
.map(s -> s.replaceAll("\\$package", pkg))
|
|
.map(s -> s.replaceAll("\\$zebra_type", zebraType))
|
|
.map(s -> condReplace(s, zebraFooType))
|
|
.map(s -> condRemove(s, "//\\$has_readObject", hasReadObject))
|
|
.collect(Collectors.toList());
|
|
Files.write(srcFile, lines);
|
|
return srcFile;
|
|
}
|
|
|
|
static void javac(Path dest, List<Path> sourceFiles) throws IOException {
|
|
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
|
|
try (StandardJavaFileManager fileManager =
|
|
compiler.getStandardFileManager(null, null, null)) {
|
|
List<File> files = sourceFiles.stream()
|
|
.map(p -> p.toFile())
|
|
.collect(Collectors.toList());
|
|
Iterable<? extends JavaFileObject> compilationUnits =
|
|
fileManager.getJavaFileObjectsFromFiles(files);
|
|
fileManager.setLocation(StandardLocation.CLASS_OUTPUT,
|
|
Arrays.asList(dest.toFile()));
|
|
fileManager.setLocation(StandardLocation.CLASS_PATH,
|
|
Arrays.asList(TEST_CLASSES.toFile()));
|
|
JavaCompiler.CompilationTask task = compiler
|
|
.getTask(null, fileManager, null, null, null, compilationUnits);
|
|
boolean passed = task.call();
|
|
if (!passed)
|
|
throw new RuntimeException("Error compiling " + files);
|
|
}
|
|
}
|
|
|
|
static Object toOtherPkgInstance(Object obj, ClassLoader loader)
|
|
throws IOException, ClassNotFoundException
|
|
{
|
|
byte[] bytes = serialize(obj);
|
|
bytes = replacePkg(bytes);
|
|
return deserialize(bytes, loader);
|
|
}
|
|
|
|
@SuppressWarnings("deprecation")
|
|
static byte[] replacePkg(byte[] bytes) {
|
|
String str = new String(bytes, 0);
|
|
str = str.replaceAll(PKGS[0], PKGS[1]);
|
|
str.getBytes(0, bytes.length, bytes, 0);
|
|
return bytes;
|
|
}
|
|
|
|
static byte[] serialize(Object obj) throws IOException {
|
|
try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
|
|
ObjectOutputStream out = new ObjectOutputStream(baos);) {
|
|
out.writeObject(obj);
|
|
return baos.toByteArray();
|
|
}
|
|
}
|
|
|
|
static Object deserialize(byte[] data, ClassLoader l)
|
|
throws IOException, ClassNotFoundException
|
|
{
|
|
return new WithLoaderObjectInputStream(new ByteArrayInputStream(data), l)
|
|
.readObject();
|
|
}
|
|
|
|
static class WithLoaderObjectInputStream extends ObjectInputStream {
|
|
final ClassLoader loader;
|
|
WithLoaderObjectInputStream(InputStream is, ClassLoader loader)
|
|
throws IOException
|
|
{
|
|
super(is);
|
|
this.loader = loader;
|
|
}
|
|
@Override
|
|
protected Class<?> resolveClass(ObjectStreamClass desc)
|
|
throws IOException, ClassNotFoundException {
|
|
try {
|
|
return super.resolveClass(desc);
|
|
} catch (ClassNotFoundException x) {
|
|
String name = desc.getName();
|
|
return Class.forName(name, false, loader);
|
|
}
|
|
}
|
|
}
|
|
}
|