1 package org.apache.commons.javaflow.bytecode.transformation.tests; 2 3 import java.io.File; 4 import java.io.FileInputStream; 5 import java.io.FileOutputStream; 6 import java.io.IOException; 7 import java.io.InputStream; 8 import java.io.ObjectInputStream; 9 import java.io.ObjectOutputStream; 10 import java.io.ObjectStreamClass; 11 import java.lang.reflect.Proxy; 12 13 import junitx.util.PrivateAccessor; 14 15 import org.apache.commons.javaflow.Continuation; 16 import org.apache.commons.javaflow.bytecode.StackRecorder; 17 import org.apache.commons.javaflow.bytecode.transformation.AbstractTransformerTestCase; 18 import org.apache.commons.javaflow.bytecode.transformation.Invoker; 19 import org.apache.commons.javaflow.bytecode.transformation.rewrite.Simple; 20 import org.apache.commons.javaflow.bytecode.transformation.rewrite.SimpleSerializable; 21 22 public abstract class AbstractSerializationTestCase extends AbstractTransformerTestCase { 23 24 private File output; 25 26 27 public void testSuspend() throws Exception { 28 final SimpleSerializable r = new SimpleSerializable(); 29 assertTrue(r.g == -1); 30 assertTrue(r.l == -1); 31 Continuation c1 = Continuation.startWith(r); 32 assertTrue(r.g == 0); 33 assertTrue(r.l == 0); 34 35 output = File.createTempFile("continuation", "xml"); 36 output.deleteOnExit(); 37 38 saveJDK(c1, output); 39 40 } 41 42 public class ObjectInputStreamExt extends ObjectInputStream { 43 44 private ClassLoader classloader; 45 46 public ObjectInputStreamExt(InputStream in, ClassLoader loader) throws IOException { 47 super(in); 48 this.classloader = loader; 49 } 50 51 protected Class resolveClass(ObjectStreamClass classDesc) throws IOException, ClassNotFoundException { 52 53 return Class.forName(classDesc.getName(), true, classloader); 54 } 55 56 protected Class resolveProxyClass(String[] interfaces) throws IOException, ClassNotFoundException { 57 Class[] cinterfaces = new Class[interfaces.length]; 58 for (int i = 0; i < interfaces.length; i++) { 59 cinterfaces[i] = Class.forName(interfaces[i], true, classloader); 60 } 61 62 try { 63 return Proxy.getProxyClass(classloader, cinterfaces); 64 } catch (IllegalArgumentException e) { 65 throw new ClassNotFoundException(null, e); 66 } 67 } 68 } 69 70 71 private void saveJDK(final Object c1, final File output) throws IOException { 72 final ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(output)); 73 oos.writeObject(c1); 74 oos.close(); 75 } 76 77 private Object loadJDK(final File input) throws IOException, ClassNotFoundException { 78 final ObjectInputStream ois = new ObjectInputStreamExt(new FileInputStream(input), this.getClass().getClassLoader()); 79 final Object o = ois.readObject(); 80 ois.close(); 81 return o; 82 } 83 84 public void testResume() throws Exception { 85 testSuspend(); 86 assertTrue("suspend must succeed to create the output first", output != null); 87 88 assertEquals(output.length(), 586); 89 90 final Object o = loadJDK(output); 91 92 assertTrue(o instanceof Continuation); 93 final Continuation c1 = (Continuation) o; 94 final StackRecorder sr1 = (StackRecorder) PrivateAccessor.getField(c1,"stackRecorder"); 95 final Runnable r1 = (Runnable) PrivateAccessor.getField(sr1, "runnable"); 96 assertEquals(SimpleSerializable.class.getName(), r1.getClass().getName()); 97 98 final SimpleSerializable ss1 = (SimpleSerializable)r1; 99 assertTrue(ss1.g == 0); 100 assertTrue(ss1.l == 0); 101 final Continuation c2 = Continuation.continueWith(c1); 102 final StackRecorder sr2 = (StackRecorder) PrivateAccessor.getField(c2,"stackRecorder"); 103 final Runnable r2 = (Runnable) PrivateAccessor.getField(sr2, "runnable"); 104 assertEquals(SimpleSerializable.class.getName(), r2.getClass().getName()); 105 final SimpleSerializable ss2 = (SimpleSerializable)r2; 106 assertTrue(ss2.g == 1); 107 assertTrue(ss2.l == 1); 108 assertTrue(r1 == r2); 109 } 110 111 112 public void testSerializableCheck() throws Exception { 113 final Runnable r1 = new Simple(); 114 Continuation c1 = Continuation.startWith(r1); 115 assertTrue(c1 != null); 116 assertTrue(!c1.isSerializable()); 117 118 final Runnable r2 = new SimpleSerializable(); 119 Continuation c2 = Continuation.startWith(r2); 120 assertTrue(c2 != null); 121 assertTrue(c2.isSerializable()); 122 123 final Runnable r3 = new SimpleSerializable(); 124 Continuation c3 = Continuation.startWith(new Invoker(r3)); 125 assertTrue(c3 != null); 126 assertTrue(c3.isSerializable()); 127 } 128 }