test/jdk/java/io/Serializable/failureAtomicity/FailureAtomicity.java - platform/libcore - Git at Google

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