libcore/luni/src/test/java/tests/api/java/io/SerializationStressTest0.java

/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package tests.api.java.io;

import dalvik.annotation.AndroidOnly;
import dalvik.annotation.BrokenTest;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargetNew;

import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InvalidObjectException;
import java.io.NotActiveException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamClass;
import java.io.ObjectStreamException;
import java.io.Serializable;
import java.io.StreamCorruptedException;
import java.io.WriteAbortedException;
import java.util.Arrays;
import java.util.Hashtable;
import java.util.Vector;

/**
 * Automated Test Suite for class java.io.ObjectOutputStream
 * 
 */
@TestTargetClass(Serializable.class) 
public class SerializationStressTest0 extends SerializationStressTest {

    private static class ObjectInputStreamSubclass extends ObjectInputStream {
        private Vector resolvedClasses = new Vector();

        public ObjectInputStreamSubclass(InputStream in) throws IOException,
                StreamCorruptedException {
            super(in);
        }

        public Class resolveClass(ObjectStreamClass osClass)
                throws IOException, ClassNotFoundException {
            Class result = super.resolveClass(osClass);
            resolvedClasses.addElement(result);
            return result;
        }

        public Class[] resolvedClasses() {
            return (Class[]) resolvedClasses.toArray(new Class[resolvedClasses
                    .size()]);
        }
    }

    @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_1_Constructor() {
            // Test for method java.io.ObjectOutputStream(java.io.OutputStream)

            try {
                oos.close();
                oos = new ObjectOutputStream(new ByteArrayOutputStream());
                oos.close();
            } catch (Exception e) {
                fail("Failed to create ObjectOutputStream : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_2_close() {
            // Test for method void java.io.ObjectOutputStream.close()
            try {
                oos.close();
                oos = new ObjectOutputStream(bao = new ByteArrayOutputStream());
                oos.close();
                oos.writeChar('T');
                oos.writeObject(FOO);
                // Writing to a closed stream does not cause problems. This is
                // the expected behavior
            } catch (IOException e) {
                fail("Operation on closed stream threw IOException : "
                        + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_3_defaultWriteObject() {
            // Test for method void java.io.ObjectOutputStream.defaultWriteObject()

            try {
                oos.defaultWriteObject();
            } catch (NotActiveException e) {
                // Correct
                return;
            } catch (IOException e) {
            }
            fail(
                    "Failed to throw NotActiveException when invoked outside readObject");
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_4_flush() {
            // Test for method void java.io.ObjectOutputStream.flush()
            try {
                oos.close();
                oos = new ObjectOutputStream(bao = new ByteArrayOutputStream());
                int size = bao.size();
                oos.writeByte(127);
                assertTrue("Data flushed already", bao.size() == size);
                oos.flush();
                assertTrue("Failed to flush data", bao.size() > size);
                // we don't know how many bytes are actually written for 1 byte,
                // so we test > <before>
                oos.close();
                oos = null;
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_5_reset() {
            // Test for method void java.io.ObjectOutputStream.reset()
            try {
                String o = "HelloWorld";
                oos.writeObject(o);
                oos.writeObject(o);
                oos.reset();
                oos.writeObject(o);
                ois = new ObjectInputStream(loadStream());
                ois.close();
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_6_write() {
            // Test for method void java.io.ObjectOutputStream.write(byte [], int,
            // int)
            try {
                byte[] buf = new byte[255];
                byte[] output = new byte[255];
                for (int i = 0; i < output.length; i++)
                    output[i] = (byte) i;
                oos.write(output, 0, output.length);
                oos.close();
                ois = new ObjectInputStream(loadStream());
                ois.readFully(buf);
                ois.close();
                for (int i = 0; i < output.length; i++)
                    if (buf[i] != output[i])
                        fail("Read incorrect byte: " + i);
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_6a_write() {
            // Test for method void java.io.ObjectOutputStream.write(byte [], int,
            // int)
            try {
                byte[] buf = new byte[256];
                byte[] output = new byte[256];
                for (int i = 0; i < output.length; i++)
                    output[i] = (byte) (i & 0xff);
                oos.write(output, 0, output.length);
                oos.close();
                ois = new ObjectInputStream(loadStream());
                ois.readFully(buf);
                ois.close();
                for (int i = 0; i < output.length; i++)
                    if (buf[i] != output[i])
                        fail("Read incorrect byte: " + i);
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_7_write() {
            // Test for method void java.io.ObjectOutputStream.write(int)
            try {
                byte[] buf = new byte[10];
                oos.write('T');
                oos.close();
                ois = new ObjectInputStream(loadStream());
                assertEquals("Read incorrect byte", 'T', ois.read());
                ois.close();
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_8_write() {
            // Test for method void java.io.ObjectOutputStream.write(byte [])
            try {
                byte[] buf = new byte[10];
                oos.write("HelloWorld".getBytes());
                oos.close();
                ois = new ObjectInputStream(loadStream());
                ois.read(buf, 0, 10);
                ois.close();
                assertEquals("Read incorrect bytes", "HelloWorld", new String(buf, 0, 10)
                        );
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_9_writeBoolean() {
            // Test for method void java.io.ObjectOutputStream.writeBoolean(boolean)
            try {
                oos.writeBoolean(true);
                oos.close();
                ois = new ObjectInputStream(loadStream());
                assertTrue("Wrote incorrect byte value", ois.readBoolean());
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_10_writeByte() {
            // Test for method void java.io.ObjectOutputStream.writeByte(int)
            try {
                oos.writeByte(127);
                oos.close();
                ois = new ObjectInputStream(loadStream());
                assertEquals("Wrote incorrect byte value", 127, ois.readByte());
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_11_writeBytes() {
            // Test for method void
            // java.io.ObjectOutputStream.writeBytes(java.lang.String)
            try {
                byte[] buf = new byte[10];
                oos.writeBytes("HelloWorld");
                oos.close();
                ois = new ObjectInputStream(loadStream());
                ois.readFully(buf);
                ois.close();
                assertEquals("Wrote incorrect bytes value", "HelloWorld", new String(buf, 0, 10)
                        );
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_12_writeChar() {
            // Test for method void java.io.ObjectOutputStream.writeChar(int)
            try {
                oos.writeChar('T');
                oos.close();
                ois = new ObjectInputStream(loadStream());
                assertEquals("Wrote incorrect char value", 'T', ois.readChar());
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_13_writeChars() {
            // Test for method void
            // java.io.ObjectOutputStream.writeChars(java.lang.String)
            try {
                int avail = 0;
                char[] buf = new char[10];
                oos.writeChars("HelloWorld");
                oos.close();
                ois = new ObjectInputStream(loadStream());
                // Number of prim data bytes in stream / 2 to give char index
                avail = ois.available() / 2;
                for (int i = 0; i < avail; ++i)
                    buf[i] = ois.readChar();
                ois.close();
                assertEquals("Wrote incorrect chars", "HelloWorld", new String(buf, 0, 10)
                        );
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_14_writeDouble() {
            // Test for method void java.io.ObjectOutputStream.writeDouble(double)
            try {
                oos.writeDouble(Double.MAX_VALUE);
                oos.close();
                ois = new ObjectInputStream(loadStream());
                assertTrue("Wrote incorrect double value",
                        ois.readDouble() == Double.MAX_VALUE);
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_15_writeFloat() {
            // Test for method void java.io.ObjectOutputStream.writeFloat(float)
            try {
                oos.writeFloat(Float.MAX_VALUE);
                oos.close();
                ois = new ObjectInputStream(loadStream());
                assertTrue("Wrote incorrect double value",
                        ois.readFloat() == Float.MAX_VALUE);
                ois.close();
                ois = null;
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_16_writeInt() {
            // Test for method void java.io.ObjectOutputStream.writeInt(int)
            try {
                oos.writeInt(Integer.MAX_VALUE);
                oos.close();
                ois = new ObjectInputStream(loadStream());
                assertTrue("Wrote incorrect double value",
                        ois.readInt() == Integer.MAX_VALUE);
                ois.close();
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_17_writeLong() {
            // Test for method void java.io.ObjectOutputStream.writeLong(long)
            try {
                oos.writeLong(Long.MAX_VALUE);
                oos.close();
                ois = new ObjectInputStream(loadStream());
                assertTrue("Wrote incorrect double value",
                        ois.readLong() == Long.MAX_VALUE);
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_19_writeShort() {
            // Test for method void java.io.ObjectOutputStream.writeShort(int)
            try {
                oos.writeShort(127);
                oos.close();
                ois = new ObjectInputStream(loadStream());
                assertEquals("Wrote incorrect short value", 127, ois.readShort());
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_20_writeUTF() {
            // Test for method void
            // java.io.ObjectOutputStream.writeUTF(java.lang.String)
            try {
                oos.writeUTF("HelloWorld");
                oos.close();
                ois = new ObjectInputStream(loadStream());
                assertEquals("Wrote incorrect UTF value", 
                        "HelloWorld", ois.readUTF());
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_25_available() {
            try {
                oos.writeObject(FOO);
                oos.writeObject(FOO);
                oos.flush();
                int available1 = 0;
                int available2 = 0;
                Object obj1 = null;
                Object obj2 = null;
                ObjectInputStream ois = new ObjectInputStream(loadStream());
                available1 = ois.available();
                obj1 = ois.readObject();
                available2 = ois.available();
                obj2 = ois.readObject();

                assertEquals("available returned incorrect value", 0, available1);
                assertEquals("available returned incorrect value", 0, available2);

                assertTrue("available caused incorrect reading", FOO.equals(obj1));
                assertTrue("available returned incorrect value", FOO.equals(obj2));

            } catch (IOException e) {
                fail("IOException serializing object : " + e.getMessage());
            } catch (ClassNotFoundException e) {
                fail("Unable to read Object type : " + e.toString());
            } catch (Error err) {
                System.out.println("Error " + err);
                throw err;
            }

        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_resolveClass() {
            try {
                oos.writeObject(new Object[] { Integer.class, new Integer(1) });
                oos.close();

                ois = new ObjectInputStreamSubclass(loadStream());
                ois.readObject();
                ois.close();
            } catch (IOException e1) {
                fail("IOException : " + e1.getMessage());
            } catch (ClassNotFoundException e2) {
                fail("ClassNotFoundException : " + e2.getMessage());
            }

            Class[] resolvedClasses = ((ObjectInputStreamSubclass) ois)
                    .resolvedClasses();
            assertEquals("missing resolved", 3, resolvedClasses.length);
            assertTrue("resolved class 1", resolvedClasses[0] == Object[].class);
            assertTrue("resolved class 2", resolvedClasses[1] == Integer.class);
            assertTrue("resolved class 3", resolvedClasses[2] == Number.class);
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_reset() {
            try {
                oos.reset();
                oos.writeObject("R");
                oos.reset();
                oos.writeByte(24);
                oos.close();

                DataInputStream dis = new DataInputStream(loadStream());
                byte[] input = new byte[dis.available()];
                dis.readFully(input);
                byte[] result = new byte[] { (byte) 0xac, (byte) 0xed, (byte) 0,
                        (byte) 5, (byte) 0x79, (byte) 0x74, (byte) 0, (byte) 1,
                        (byte) 'R', (byte) 0x79, (byte) 0x77, (byte) 1, (byte) 24 };
                assertTrue("incorrect output", Arrays.equals(input, result));

                ois = new ObjectInputStreamSubclass(loadStream());
                assertEquals("Wrong result from readObject()", "R", ois.readObject()
                        );
                assertEquals("Wrong result from readByte()", 24, ois.readByte());
                ois.close();
            } catch (IOException e1) {
                fail("IOException : " + e1.getMessage());
            } catch (ClassNotFoundException e2) {
                fail("ClassNotFoundException : " + e2.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_serialVersionUID(Class clazz, long svUID) {
            final String idWrong = "serialVersionUID is wrong for: ";
            long reflectedSvUID = 0L;
            try {
                reflectedSvUID = clazz.getField("serialVersionUID").getLong(null);
            } catch (Exception e) {
                fail("Unable to determine serialVersionUID of " + clazz);
            }
            assertTrue(idWrong + clazz + ": " + reflectedSvUID + " does not equal "
                    + svUID, reflectedSvUID == svUID);
        }

        private static class ResolveObjectTest implements Serializable {
            Object field1, field2;
        }

        private static class ResolveObjectInputStream extends ObjectInputStream {
            ResolveObjectInputStream(InputStream in)
                    throws StreamCorruptedException, IOException {
                super(in);
            }

            public void enableResolve() {
                enableResolveObject(true);
            }

            public Object resolveObject(Object obj) {
                if (obj instanceof Vector) // test_1_resolveObject()
                    return new Hashtable();
                else if ("abc".equals(obj)) // test_2_resolveObject()
                    return "ABC";
                else if (obj instanceof String) // test_3_resolveObject()
                    return String.valueOf(((String) obj).length());
                else if (obj instanceof int[]) // test_4_resolveObject()
                    return new Object[1];
                else if (obj instanceof Object[] && ((Object[]) obj).length == 2) // test_5_resolveObject()
                    return new char[1];
                return obj;
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_1_resolveObject() {
            try {
                ResolveObjectTest obj = new ResolveObjectTest();
                obj.field1 = new Vector();
                obj.field2 = obj.field1;
                oos.writeObject(obj);
                oos.close();
                ois = new ResolveObjectInputStream(loadStream());
                ((ResolveObjectInputStream) ois).enableResolve();
                ResolveObjectTest result = null;
                try {
                    result = (ResolveObjectTest) ois.readObject();
                } catch (ClassNotFoundException e) {
                    fail(e.toString());
                }
                assertTrue("Object not resolved",
                        result.field1 instanceof Hashtable);
                assertTrue("Second reference not resolved",
                        result.field1 == result.field2);
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_2_resolveObject() {
            try {
                ResolveObjectTest obj = new ResolveObjectTest();
                obj.field1 = "abc";
                obj.field2 = obj.field1;
                oos.writeObject(obj);
                oos.close();
                ois = new ResolveObjectInputStream(loadStream());
                ((ResolveObjectInputStream) ois).enableResolve();
                ResolveObjectTest result = null;
                try {
                    result = (ResolveObjectTest) ois.readObject();
                } catch (ClassNotFoundException e) {
                    fail(e.toString());
                }
                assertEquals("String not resolved", "ABC", result.field1);
                assertTrue("Second reference not resolved",
                        result.field1 == result.field2);
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_3_resolveObject() {
            try {
                ResolveObjectTest obj = new ResolveObjectTest();
                char[] lchars = new char[70000];
                obj.field1 = new String(lchars);
                obj.field2 = obj.field1;
                oos.writeObject(obj);
                oos.close();
                ois = new ResolveObjectInputStream(loadStream());
                ((ResolveObjectInputStream) ois).enableResolve();
                ResolveObjectTest result = null;
                try {
                    result = (ResolveObjectTest) ois.readObject();
                } catch (ClassNotFoundException e) {
                    fail(e.toString());
                }
                assertTrue("Long String not resolved", "70000"
                        .equals(result.field1));
                assertTrue("Second reference not resolved",
                        result.field1 == result.field2);
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_4_resolveObject() {
            try {
                ResolveObjectTest obj = new ResolveObjectTest();
                obj.field1 = new int[5];
                obj.field2 = obj.field1;
                oos.writeObject(obj);
                oos.close();
                ois = new ResolveObjectInputStream(loadStream());
                ((ResolveObjectInputStream) ois).enableResolve();
                ResolveObjectTest result = null;
                try {
                    result = (ResolveObjectTest) ois.readObject();
                } catch (ClassNotFoundException e) {
                    fail(e.toString());
                }
                Class cl = new Object[0].getClass();
                assertTrue("int[] not resolved", result.field1.getClass() == cl);
                assertTrue("Second reference not resolved",
                        result.field1 == result.field2);
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_5_resolveObject() {
            try {
                ResolveObjectTest obj = new ResolveObjectTest();
                obj.field1 = new Object[2];
                obj.field2 = obj.field1;
                oos.writeObject(obj);
                oos.close();
                ois = new ResolveObjectInputStream(loadStream());
                ((ResolveObjectInputStream) ois).enableResolve();
                ResolveObjectTest result = null;
                try {
                    result = (ResolveObjectTest) ois.readObject();
                } catch (ClassNotFoundException e) {
                    fail(e.toString());
                }
                Class cl = new char[0].getClass();
                assertTrue("int[] not resolved", result.field1.getClass() == cl);
                assertTrue("Second reference not resolved",
                        result.field1 == result.field2);
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            }
        }

        static class WriteReplaceTestA implements Serializable {
            public Object writeReplace() throws ObjectStreamException {
                return new ReadResolveTestB();
            }
        }

        static class WriteReplaceTestB extends WriteReplaceTestA {
        }

        static class WriteReplaceTestC extends WriteReplaceTestA {
            public Object writeReplace() throws ObjectStreamException {
                return new ReadResolveTestC();
            }
        }

        static class WriteReplaceTestD implements Serializable {
            private Object writeReplace() throws ObjectStreamException {
                return new ReadResolveTestD();
            }
        }

        static class WriteReplaceTestE extends WriteReplaceTestD {
        }

        static class WriteReplaceTestF implements Serializable {
            int type, readType;

            public WriteReplaceTestF(int type, int readType) {
                this.type = type;
                this.readType = readType;
            }

            public Object writeReplace() throws ObjectStreamException {
                switch (type) {
                case 0:
                    throw new InvalidObjectException("invalid");
                case 1:
                    throw new RuntimeException("runtime");
                case 2:
                    throw new Error("error");
                default:
                    return new ReadResolveTestE(readType);
                }
            }
        }

        static class ReadResolveTestA implements Serializable {
            public Object readResolve() throws ObjectStreamException {
                return new ReadResolveTestA();
            }
        }

        static class ReadResolveTestB extends ReadResolveTestA {
        }

        static class ReadResolveTestC implements Serializable {
            private Object readResolve() throws ObjectStreamException {
                return new ReadResolveTestB();
            }
        }

        static class ReadResolveTestD extends ReadResolveTestC {
        }

        static class ReadResolveTestE implements Serializable {
            int type;

            public ReadResolveTestE(int type) {
                this.type = type;
            }

            public Object readResolve() throws ObjectStreamException {
                switch (type) {
                case 0:
                    throw new InvalidObjectException("invalid");
                case 1:
                    throw new RuntimeException("runtime");
                case 2:
                    throw new Error("error");
                case 3:
                    return this;
                default:
                    return new ReadResolveTestF();
                }
            }
        }

        static class ReadResolveTestF implements Serializable {
        }

        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_1_writeReplace() {
            try {
                Vector v = new Vector();
                v.addElement(new WriteReplaceTestA());
                v.addElement(new WriteReplaceTestB());
                v.addElement(new WriteReplaceTestB());
                v.addElement(new WriteReplaceTestC());
                v.addElement(new WriteReplaceTestD());
                v.addElement(new WriteReplaceTestE());
                oos.writeObject(v);
                oos.close();
                ois = new ObjectInputStream(loadStream());
                Vector result = (Vector) ois.readObject();
                assertTrue("invalid 0 : " + result.elementAt(0), result
                        .elementAt(0).getClass() == ReadResolveTestA.class);
                assertTrue("invalid 1 : " + result.elementAt(1), result
                        .elementAt(1).getClass() == ReadResolveTestA.class);
                assertTrue("invalid 2 : " + result.elementAt(2), result
                        .elementAt(2).getClass() == ReadResolveTestA.class);
                assertTrue("invalid 3 : " + result.elementAt(3), result
                        .elementAt(3).getClass() == ReadResolveTestB.class);
                assertTrue("invalid 4 : " + result.elementAt(4), result
                        .elementAt(4).getClass() == ReadResolveTestD.class);
                assertTrue("invalid 5 : " + result.elementAt(5), result
                        .elementAt(5).getClass() == WriteReplaceTestE.class);
            } catch (IOException e) {
                fail("IOException serializing data : " + e.getMessage());
            } catch (ClassNotFoundException e) {
                fail("ClassNotFoundException serializing data : " + e.getMessage());
            }
        }
        
        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Verifies serialization.",
            method = "!Serialization",
            args = {}
        )
        public void test_2_writeReplace_01() throws IOException {
            try {
                oos.writeObject(new WriteReplaceTestF(0, -1));
                fail("Should throw ObjectStreamException");
            } catch (ObjectStreamException e) {
                // expected
            }
        }
        
        @TestTargetNew(
                level = TestLevel.COMPLETE,
                notes = "Verifies serialization.",
                method = "!Serialization",
                args = {}
            )
        public void test_2_writeReplace_02() throws IOException {
            try {
                oos.writeObject(new WriteReplaceTestF(1, -1));
                fail("Should throw RuntimeException");
            } catch (RuntimeException e) {
                // expected
            }
        }
        
        @TestTargetNew(
                level = TestLevel.COMPLETE,
                notes = "Verifies serialization.",
                method = "!Serialization",
                args = {}
            )
        public void test_2_writeReplace_03() throws IOException {
            try {
                oos.writeObject(new WriteReplaceTestF(2, -1));
                fail("Should throw Error");
            } catch (Error e) {
                // expected
            }
        }
        
        @TestTargetNew(
                level = TestLevel.COMPLETE,
                notes = "Verifies serialization.",
                method = "!Serialization",
                args = {}
            )
        public void test_2_writeReplace_04() throws IOException,
                ClassNotFoundException {
            oos.writeObject(new WriteReplaceTestF(3, 0));
            oos.writeObject(new WriteReplaceTestF(3, 1));
            oos.writeObject(new WriteReplaceTestF(3, 2));
            WriteReplaceTestF test = new WriteReplaceTestF(3, 3);
            oos.writeObject(test);
            oos.writeObject(test);
            WriteReplaceTestF test2 = new WriteReplaceTestF(3, 4);
            oos.writeObject(test2);
            oos.writeObject(test2);
            oos.close();
            ois = new ObjectInputStream(loadStream());
            try {
                ois.readObject();
                fail("Expected InvalidObjectException");
            } catch (InvalidObjectException e) {
                // expected
            }

            try {
                ois.readObject();
                fail("Expected RuntimeException");
            } catch (RuntimeException e) {
                // expected
            }

            try {
                ois.readObject();
                fail("Expected Error");
            } catch (Error e) {
                // expected
            }

            Object readE1 = ois.readObject();
            Object readE2 = ois.readObject();
            assertTrue("Replaced objects should be identical", readE1 == readE2);
            Object readF1 = ois.readObject();
            Object readF2 = ois.readObject();
            assertTrue("Replaced resolved objects should be identical: "
                    + readF1 + " " + readF2, readF1 == readF2);
        }
}