| /* |
| * 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); |
| } |
| } |
| } |
| } |