harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From telli...@apache.org
Subject svn commit: r386058 [12/49] - in /incubator/harmony/enhanced/classlib/trunk: make/ modules/archive/make/common/ modules/archive/src/test/java/tests/ modules/archive/src/test/java/tests/api/ modules/archive/src/test/java/tests/api/java/ modules/archive/...
Date Wed, 15 Mar 2006 11:47:39 GMT
Added: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/io/SerializationStressTest1.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/io/SerializationStressTest1.java?rev=386058&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/io/SerializationStressTest1.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/tests/api/java/io/SerializationStressTest1.java Wed Mar 15 03:46:17 2006
@@ -0,0 +1,1644 @@
+/* Copyright 1998, 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed 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 java.io.IOException;
+import java.io.NotSerializableException;
+import java.io.Serializable;
+import java.util.Arrays;
+
+public class SerializationStressTest1 extends SerializationStressTest {
+
+	// The purpose of these two classes is to test if serialization, when
+	// loading, runs the object's constructor (wrong) or the constructor defined
+	// at the topmost Serializable superclass(correct).
+	static final int INIT_INT_VALUE = 7;
+
+	// HAS to be static class so that our constructor signature will remain
+	// untouched (no synthetic param)
+	private static class SerializationTest implements java.io.Serializable {
+		int anInt = INIT_INT_VALUE;
+
+		public SerializationTest() {
+			super();
+		}
+	}
+
+	static final String INIT_STR_VALUE = "a string that is blortz";
+
+	// HAS to be static class so that our constructor signature will remain
+	// untouched (no synthetic param)
+	private static class SerializationTestSubclass1 extends SerializationTest {
+		String aString = INIT_STR_VALUE;
+
+		public SerializationTestSubclass1() {
+			super();
+			// Just to change default superclass init value
+			anInt = INIT_INT_VALUE / 2;
+		}
+	}
+
+	// -----------------------------------------------------------------------------------
+
+	private static class SpecTestSuperClass implements Runnable {
+		protected java.lang.String instVar;
+
+		public void run() {
+		}
+	}
+
+	private static class SpecTest extends SpecTestSuperClass implements
+			Cloneable, Serializable {
+		public java.lang.String instVar1;
+
+		public static java.lang.String staticVar1;
+
+		public static java.lang.String staticVar2;
+		{
+			instVar1 = "NonStaticInitialValue";
+		}
+		static {
+			staticVar1 = "StaticInitialValue";
+			staticVar1 = new String(staticVar1);
+		}
+
+		public Object method(Object objParam, Object objParam2) {
+			return new Object();
+		}
+
+		public boolean method(boolean bParam, Object objParam) {
+			return true;
+		}
+
+		public boolean method(boolean bParam, Object objParam, Object objParam2) {
+			return true;
+		}
+
+	}
+
+	private static class SpecTestSubclass extends SpecTest {
+		public transient java.lang.String transientInstVar = "transientValue";
+	}
+
+	// -----------------------------------------------------------------------------------
+
+	// This one tests what happens if the read/writeObject methods are defined
+	// Serialization should work fine.
+	private static class ReadWriteObject implements java.io.Serializable {
+		public boolean calledWriteObject = false;
+
+		public boolean calledReadObject = false;
+
+		public ReadWriteObject() {
+			super();
+		}
+
+		private void readObject(java.io.ObjectInputStream in)
+				throws java.io.IOException, ClassNotFoundException {
+			calledReadObject = true;
+			String s = ((String) in.readObject());
+		}
+
+		private void writeObject(java.io.ObjectOutputStream out)
+				throws java.io.IOException {
+			calledWriteObject = true;
+			out.writeObject(FOO);
+		}
+	}
+
+	// This one tests what happens if the read/writeObject methods are not
+	// private.
+	// Serialization should fail.
+	private static class PublicReadWriteObject implements java.io.Serializable {
+		public boolean calledWriteObject = false;
+
+		public boolean calledReadObject = false;
+
+		public PublicReadWriteObject() {
+			super();
+		}
+
+		public void readObject(java.io.ObjectInputStream in)
+				throws java.io.IOException, ClassNotFoundException {
+			calledReadObject = true;
+			String s = ((String) in.readObject());
+		}
+
+		public void writeObject(java.io.ObjectOutputStream out)
+				throws java.io.IOException {
+			calledWriteObject = true;
+			out.writeObject(FOO);
+		}
+	}
+
+	// This one tests if field names are serialized in the same way (sorting)
+	// across different VMs
+	private static class FieldOrder implements Serializable {
+		String aaa1NonPrimitive = "aaa1";
+
+		int bbb1PrimitiveInt = 5;
+
+		boolean aaa2PrimitiveBoolean = true;
+
+		String bbb2NonPrimitive = "bbb2";
+	}
+
+	// This one tests what happens if you define just readObject, but not
+	// writeObject.
+	// Does it run or not ?
+	private static class JustReadObject implements java.io.Serializable {
+		public boolean calledReadObject = false;
+
+		public JustReadObject() {
+			super();
+		}
+
+		private void readObject(java.io.ObjectInputStream in)
+				throws java.io.IOException, ClassNotFoundException {
+			calledReadObject = true;
+			in.defaultReadObject();
+		}
+	}
+
+	// This one tests what happens if you define just writeObject, but not
+	// readObject.
+	// Does it run or not ?
+	private static class JustWriteObject implements java.io.Serializable {
+		public boolean calledWriteObject = false;
+
+		public JustWriteObject() {
+			super();
+		}
+
+		private void writeObject(java.io.ObjectOutputStream out)
+				throws java.io.IOException, ClassNotFoundException {
+			calledWriteObject = true;
+			out.defaultWriteObject();
+		}
+	}
+
+	// This one tests class-based replacement when dumping
+	private static class ClassBasedReplacementWhenDumping implements
+			java.io.Serializable {
+		public boolean calledReplacement = false;
+
+		public ClassBasedReplacementWhenDumping() {
+			super();
+		}
+
+		private Object writeReplace() {
+			calledReplacement = true;
+			return FOO; // Replacement is a String
+		}
+	}
+
+	// This one tests whether class-based replacement supports multiple levels.
+	// MultipleClassBasedReplacementWhenDumping -> C1 -> C2 -> C3 -> FOO
+	private static class MultipleClassBasedReplacementWhenDumping implements
+			java.io.Serializable {
+		private static class C1 implements java.io.Serializable {
+			private Object writeReplace() {
+				return new C2();
+			}
+		}
+
+		private static class C2 implements java.io.Serializable {
+			private Object writeReplace() {
+				return new C3();
+			}
+		}
+
+		private static class C3 implements java.io.Serializable {
+			private Object writeReplace() {
+				return FOO;
+			}
+		}
+
+		public MultipleClassBasedReplacementWhenDumping() {
+			super();
+		}
+
+		private Object writeReplace() {
+			return new C1();
+		}
+	}
+
+	// This one tests class-based replacement when loading
+	private static class ClassBasedReplacementWhenLoading implements
+			java.io.Serializable {
+		public ClassBasedReplacementWhenLoading() {
+			super();
+		}
+
+		private Object readResolve() {
+			return FOO; // Replacement is a String
+		}
+	}
+
+	// This one tests what happens if a loading-replacement is not
+	// type-compatible with the original object
+	private static class ClassBasedReplacementWhenLoadingViolatesFieldType
+			implements java.io.Serializable {
+		public ClassBasedReplacementWhenLoading classBasedReplacementWhenLoading = new ClassBasedReplacementWhenLoading();
+
+		public ClassBasedReplacementWhenLoadingViolatesFieldType() {
+			super();
+		}
+	}
+
+	// What happens if dumping causes an error and you try to reload ?
+	// Should the load throw the same exception ?
+	private static class MyExceptionWhenDumping1 implements
+			java.io.Serializable {
+		private static class MyException extends java.io.IOException {
+		};
+
+		// A primitive instance variable exposes a bug in the serialization
+		// spec.
+		// Primitive instance variables are written without primitive data tags
+		// and so are read without checking for tags. If an exception is
+		// written, reading primitive data will just read bytes from the stream
+		// which may be tags
+		public boolean anInstanceVar = false;
+
+		public MyExceptionWhenDumping1() {
+			super();
+		}
+
+		private void readObject(java.io.ObjectInputStream in)
+				throws java.io.IOException, ClassNotFoundException {
+			in.defaultReadObject();
+		}
+
+		private void writeObject(java.io.ObjectOutputStream out)
+				throws java.io.IOException, ClassNotFoundException {
+			throw new MyException();
+		}
+	}
+
+	// What happens if dumping causes an error and you try to reload ?
+	// Should the load throw the same exception ?
+	private static class MyExceptionWhenDumping2 implements
+			java.io.Serializable {
+		private static class MyException extends java.io.IOException {
+		};
+
+		public Integer anInstanceVar = new Integer(0xA1);
+
+		public MyExceptionWhenDumping2() {
+			super();
+		}
+
+		private void readObject(java.io.ObjectInputStream in)
+				throws java.io.IOException, ClassNotFoundException {
+			in.defaultReadObject();
+		}
+
+		private void writeObject(java.io.ObjectOutputStream out)
+				throws java.io.IOException, ClassNotFoundException {
+			throw new MyException();
+		}
+	}
+
+	// What happens if dumping causes an error (NonSerializable inst var) and
+	// you try to reload ?
+	// Should the load throw the same exception ?
+	private static class NonSerializableExceptionWhenDumping implements
+			java.io.Serializable {
+		public Object anInstanceVar = new Object();
+
+		public NonSerializableExceptionWhenDumping() {
+			super();
+		}
+	}
+
+	// What happens if dumping causes an error (which is not serializable) and
+	// you try to reload ?
+	// Should the load throw the same exception ?
+	private static class MyUnserializableExceptionWhenDumping implements
+			java.io.Serializable {
+		private static class MyException extends java.io.IOException {
+			private Object notSerializable = new Object();
+		};
+
+		public boolean anInstanceVar = false;
+
+		public MyUnserializableExceptionWhenDumping() {
+			super();
+		}
+
+		private void readObject(java.io.ObjectInputStream in)
+				throws java.io.IOException, ClassNotFoundException {
+			in.defaultReadObject();
+		}
+
+		private void writeObject(java.io.ObjectOutputStream out)
+				throws java.io.IOException, ClassNotFoundException {
+			throw new MyException();
+		}
+	}
+
+	public SerializationStressTest1(String name) {
+		super(name);
+	}
+
+	public void test_18_1_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			objToSave = "HelloWorld";
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			assertTrue(MSG_TEST_FAILED + objToSave, (((String) objLoaded)
+					.equals((String) objToSave)));
+
+		} catch (IOException e) {
+			fail("IOException serializing data : " + e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type: "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_2_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			objToSave = null;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			assertTrue(MSG_TEST_FAILED + objToSave, objLoaded == objToSave);
+
+		} catch (IOException e) {
+			fail("IOException serializing data : " + e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_3_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			byte[] bytes = { 0, 1, 2, 3 };
+			objToSave = bytes;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			assertTrue(MSG_TEST_FAILED + objToSave, Arrays.equals(
+					(byte[]) objLoaded, (byte[]) objToSave));
+
+		} catch (IOException e) {
+			fail("IOException serializing data : " + e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_4_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			int[] ints = { 0, 1, 2, 3 };
+			objToSave = ints;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			assertTrue(MSG_TEST_FAILED + objToSave, Arrays.equals(
+					(int[]) objLoaded, (int[]) objToSave));
+
+		} catch (IOException e) {
+			fail("IOException serializing data : " + e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			throw err;
+		}
+	}
+
+	public void test_18_5_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+
+			short[] shorts = { 0, 1, 2, 3 };
+			objToSave = shorts;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			assertTrue(MSG_TEST_FAILED + objToSave, Arrays.equals(
+					(short[]) objLoaded, (short[]) objToSave));
+
+		} catch (IOException e) {
+			fail("IOException serializing data : " + e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_6_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			long[] longs = { 0, 1, 2, 3 };
+			objToSave = longs;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			assertTrue(MSG_TEST_FAILED + objToSave, Arrays.equals(
+					(long[]) objLoaded, (long[]) objToSave));
+
+		} catch (IOException e) {
+			fail("IOException serializing data : " + e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_7_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			float[] floats = { 0.0f, 1.1f, 2.2f, 3.3f };
+			objToSave = floats;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			assertTrue(MSG_TEST_FAILED + objToSave, Arrays.equals(
+					(float[]) objLoaded, (float[]) objToSave));
+
+		} catch (IOException e) {
+			fail("IOException serializing data: " + e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_8_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			double[] doubles = { 0.0, 1.1, 2.2, 3.3 };
+			objToSave = doubles;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			assertTrue(MSG_TEST_FAILED + objToSave, Arrays.equals(
+					(double[]) objLoaded, (double[]) objToSave));
+
+		} catch (IOException e) {
+			fail("IOException serializing data : " + e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_9_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			boolean[] booleans = { true, false, false, true };
+			objToSave = booleans;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			assertTrue(MSG_TEST_FAILED + objToSave, Arrays.equals(
+					(boolean[]) objLoaded, (boolean[]) objToSave));
+
+		} catch (IOException e) {
+			fail("IOException serializing data : " + e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : " + e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_10_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+
+			String[] strings = { "foo", "bar", "java" };
+			objToSave = strings;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			assertTrue(MSG_TEST_FAILED + objToSave, Arrays.equals(
+					(Object[]) objLoaded, (Object[]) objToSave));
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("Unable to read Object type: " + e.toString());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_11_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+
+			objToSave = new Object(); // Not serializable
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			boolean passed = false;
+			Throwable t = null;
+			try {
+				objLoaded = dumpAndReload(objToSave);
+			} catch (NotSerializableException ns) {
+				passed = true;
+				t = ns;
+			} catch (Exception wrongExc) {
+				passed = false;
+				t = wrongExc;
+			}
+			assertTrue(
+					"Failed to throw NotSerializableException when serializing "
+							+ objToSave + " Threw(if non-null) this: " + t,
+					passed);
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_12_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		try {
+			if (DEBUG)
+				System.out.println("Obj = <mixed>");
+			t_MixPrimitivesAndObjects();
+		} catch (IOException e) {
+			fail("IOException serializing data : " + e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when dumping mixed types");
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_13_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			SerializationTestSubclass1 st = new SerializationTestSubclass1();
+			// Just change the default ivar values
+			st.anInt = Integer.MAX_VALUE;
+			st.aString = FOO;
+			objToSave = st;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// non-serializable inst var has to be initialized from top
+			// constructor
+			assertTrue(
+					MSG_TEST_FAILED + objToSave,
+					((SerializationTestSubclass1) objLoaded).anInt == Integer.MAX_VALUE);
+			// but serialized var has to be restored as it was in the object
+			// when dumped
+			assertTrue(MSG_TEST_FAILED + objToSave,
+					((SerializationTestSubclass1) objLoaded).aString
+							.equals(FOO));
+		} catch (IOException e) {
+			fail("Exception serializing " + objToSave + "\t->"
+					+ e.toString());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_14_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			SpecTest specTest = new SpecTest();
+			// Just change the default ivar values
+			specTest.instVar = FOO;
+			specTest.instVar1 = specTest.instVar;
+			objToSave = specTest;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// non-serializable inst var has to be initialized from top
+			// constructor
+			assertTrue(MSG_TEST_FAILED + objToSave,
+					((SpecTest) objLoaded).instVar == null); 
+			// instVar from non-serialized class, cant  be  saved/restored
+			// by serialization but serialized ivar has to be restored as it
+			// was in the object when dumped
+			assertTrue(MSG_TEST_FAILED + objToSave,
+					((SpecTest) objLoaded).instVar1.equals(FOO));
+
+		} catch (IOException e) {
+			fail("Exception serializing " + objToSave + "\t->"
+					+ e.toString());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_15_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			SpecTestSubclass specTestSubclass = new SpecTestSubclass();
+			// Just change the default ivar values
+			specTestSubclass.transientInstVar = FOO;
+			objToSave = specTestSubclass;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// non-serializable inst var cant be saved, and it is not init'ed
+			// from top constructor in this case
+			assertTrue(MSG_TEST_FAILED + objToSave,
+					((SpecTestSubclass) objLoaded).transientInstVar == null);
+			// transient slot, cant be saved/restored by serialization 
+		} catch (IOException e) {
+			fail("Exception serializing " + objToSave + "\t->"
+					+ e.toString());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_16_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+
+			String[] strings = new String[2];
+			strings[0] = FOO;
+			strings[1] = (" " + FOO + " ").trim(); // Safe way to get a copy
+			// that is not ==
+			objToSave = strings;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			String[] stringsLoaded = (String[]) objLoaded;
+			// Serialization has to use identity-based table for assigning IDs
+			assertTrue(MSG_TEST_FAILED + objToSave,
+					!(stringsLoaded[0] == stringsLoaded[1]));
+		} catch (IOException e) {
+			fail("Exception serializing " + objToSave + "\t->"
+					+ e.toString());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_17_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+
+			ReadWriteObject readWrite = new ReadWriteObject();
+			objToSave = readWrite;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// has to have called the writeObject on the instance to dump
+			assertTrue(MSG_TEST_FAILED + objToSave, readWrite.calledWriteObject);
+			// has to have called the readObject on the instance loaded
+			assertTrue(MSG_TEST_FAILED + objToSave,
+					((ReadWriteObject) objLoaded).calledReadObject);
+
+		} catch (IOException e) {
+			fail("Exception serializing " + objToSave + "\t->"
+					+ e.toString());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_18_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			PublicReadWriteObject publicReadWrite = new PublicReadWriteObject();
+			objToSave = publicReadWrite;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// Can't have called the writeObject on the instance to dump
+			assertTrue(MSG_TEST_FAILED + objToSave,
+					!publicReadWrite.calledWriteObject);
+			// Can't have called the readObject on the instance loaded
+			assertTrue(MSG_TEST_FAILED + objToSave,
+					!((PublicReadWriteObject) objLoaded).calledReadObject);
+
+		} catch (IOException e) {
+			fail("Exception serializing " + objToSave + "\t->"
+					+ e.toString());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_19_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			FieldOrder fieldOrder = new FieldOrder();
+			objToSave = fieldOrder;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// This test is only useful for X-loading, so if it managed to
+			// dump&load, we passed the test
+			assertTrue(MSG_TEST_FAILED + objToSave, true);
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_20_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			objToSave = Class.forName("java.lang.Integer");
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// Classes with the same name are unique, so test for ==
+			assertTrue(MSG_TEST_FAILED + objToSave, objLoaded == objToSave);
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_21_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			// Even though instances of java.lang.Object are not Serializable,
+			// instances of java.lang.Class are. So, the object
+			// java.lang.Object.class
+			// should be serializable
+			objToSave = Class.forName("java.lang.Object");
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// Classes with the same name are unique, so test for ==
+			assertTrue(MSG_TEST_FAILED + objToSave, objLoaded == objToSave);
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_22_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			java.net.URL url = new java.net.URL("http://localhost/a.txt");
+			objToSave = url;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			assertTrue("URLs are not the same: " + url + "\t,\t" + objLoaded,
+					url.equals(objLoaded));
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_23_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+
+			JustReadObject justReadObject = new JustReadObject();
+			objToSave = justReadObject;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// Only calls readObject on the instance loaded if writeObject was
+			// also defined
+			assertTrue("Called readObject on an object without a writeObject",
+					!((JustReadObject) objLoaded).calledReadObject);
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_24_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+
+			JustWriteObject justWriteObject = new JustWriteObject();
+			objToSave = justWriteObject;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// Call writeObject on the instance even if it does not define
+			// readObject
+			assertTrue(MSG_TEST_FAILED + objToSave,
+					justWriteObject.calledWriteObject);
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type: "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_25_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			java.util.Vector vector = new java.util.Vector(1);
+			vector.add(FOO);
+			objToSave = vector;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// Has to have the string there
+			assertTrue(MSG_TEST_FAILED + objToSave, FOO
+					.equals(((java.util.Vector) objLoaded).elementAt(0)));
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			throw err;
+		}
+	}
+
+	public void test_18_26_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			java.util.Hashtable hashTable = new java.util.Hashtable(5);
+			hashTable.put(FOO, FOO);
+			objToSave = hashTable;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			java.util.Hashtable loadedHashTable = (java.util.Hashtable) objLoaded;
+			// Has to have the key/value there (FOO -> FOO)
+			assertTrue(MSG_TEST_FAILED + objToSave, FOO.equals(loadedHashTable
+					.get(FOO)));
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			throw err;
+		}
+	}
+
+	public void test_18_27_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			ClassBasedReplacementWhenDumping classBasedReplacementWhenDumping = new ClassBasedReplacementWhenDumping();
+			objToSave = classBasedReplacementWhenDumping;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// Has to have run the replacement method
+			assertTrue("Did not run writeReplace",
+					classBasedReplacementWhenDumping.calledReplacement);
+
+			// Has to have loaded a String (replacement object)
+			assertTrue("Did not replace properly", FOO.equals(objLoaded));
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_28_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			MultipleClassBasedReplacementWhenDumping multipleClassBasedReplacementWhenDumping = new MultipleClassBasedReplacementWhenDumping();
+			objToSave = multipleClassBasedReplacementWhenDumping;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// Has to have loaded a String (replacement object)
+			assertTrue(
+					"Executed multiple levels of replacement (see PR 1F9RNT1), loaded= "
+							+ objLoaded,
+					objLoaded instanceof MultipleClassBasedReplacementWhenDumping.C1);
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.toString());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_29_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			ClassBasedReplacementWhenLoading classBasedReplacementWhenLoading = new ClassBasedReplacementWhenLoading();
+			objToSave = classBasedReplacementWhenLoading;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// Has to have loaded a String (replacement object)
+			assertTrue("Did not run readResolve", FOO.equals(objLoaded));
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_30_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			ClassBasedReplacementWhenLoadingViolatesFieldType classBasedReplacementWhenLoadingViolatesFieldType = new ClassBasedReplacementWhenLoadingViolatesFieldType();
+			objToSave = classBasedReplacementWhenLoadingViolatesFieldType;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// We cannot gere here, the load replacement must have caused a
+			// field type violation
+			fail(
+					"Loading replacements can cause field type violation in this implementation");
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (ClassCastException e) {
+			assertTrue(
+					"Loading replacements can NOT cause field type violation in this implementation",
+					true);
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_31_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			MyExceptionWhenDumping1 exceptionWhenDumping = new MyExceptionWhenDumping1();
+			objToSave = exceptionWhenDumping;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			boolean causedException = false;
+			try {
+				dump(objToSave);
+			} catch (MyExceptionWhenDumping1.MyException e) {
+				causedException = true;
+			}
+			;
+			assertTrue("Should have caused an exception when dumping",
+					causedException);
+			causedException = false;
+			try {
+				objLoaded = reload();
+				// Although the spec says we should get a WriteAbortedException,
+				// the serialization format handle an Exception when reading
+				// primitive data so we get ClassCastException instead
+			} catch (ClassCastException e) {
+				causedException = true;
+			}
+			;
+			assertTrue("Should have caused a ClassCastException when loading",
+					causedException);
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_32_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			MyExceptionWhenDumping2 exceptionWhenDumping = new MyExceptionWhenDumping2();
+			objToSave = exceptionWhenDumping;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			boolean causedException = false;
+			try {
+				dump(objToSave);
+			} catch (MyExceptionWhenDumping2.MyException e) {
+				causedException = true;
+			}
+			;
+			assertTrue("Should have caused an exception when dumping",
+					causedException);
+			causedException = false;
+			try {
+				objLoaded = reload();
+			} catch (java.io.WriteAbortedException e) {
+				causedException = true;
+			}
+			;
+			assertTrue(
+					"Should have caused a java.io.WriteAbortedException when loading",
+					causedException);
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (ClassCastException e) {
+			fail("ClassCastException : " + e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			throw err;
+		}
+	}
+
+	public void test_NonSerializableExceptionWhenDumping() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			NonSerializableExceptionWhenDumping nonSerializableExceptionWhenDumping = new NonSerializableExceptionWhenDumping();
+			objToSave = nonSerializableExceptionWhenDumping;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			boolean causedException = false;
+			try {
+				dump(objToSave);
+			} catch (java.io.NotSerializableException e) {
+				causedException = true;
+			}
+			;
+			assertTrue("Should have caused an exception when dumping",
+					causedException);
+			causedException = false;
+			try {
+				objLoaded = reload();
+			} catch (java.io.WriteAbortedException e) {
+				causedException = true;
+			}
+			;
+			assertTrue(
+					"Should have caused a java.io.WriteAbortedException when loading",
+					causedException);
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_33_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			MyUnserializableExceptionWhenDumping exceptionWhenDumping = new MyUnserializableExceptionWhenDumping();
+			objToSave = exceptionWhenDumping;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			boolean causedException = false;
+			try {
+				dump(objToSave);
+			} catch (java.io.StreamCorruptedException e) {
+				causedException = true;
+			}
+			;
+			assertTrue("Should have caused an exception when dumping",
+					causedException);
+			// As the stream is corrupted, reading the stream will have
+			// undefined results
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_34_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			java.io.IOException ioe = new java.io.IOException();
+			objToSave = ioe;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// Has to be able to save/load an exception
+			assertTrue(MSG_TEST_FAILED + objToSave, true);
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_35_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			objToSave = Class.forName("java.util.Hashtable");
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// Classes with the same name are unique, so test for ==
+			assertTrue(MSG_TEST_FAILED + objToSave, objLoaded == objToSave);
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_36_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			java.io.IOException ex = new java.io.InvalidClassException(FOO);
+			objToSave = ex;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// Has to be able to save/load an exception
+			assertTrue(MSG_TEST_FAILED + objToSave, true);
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_37_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			java.io.IOException ex = new java.io.InvalidObjectException(FOO);
+			objToSave = ex;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// Has to be able to save/load an exception
+			assertTrue(MSG_TEST_FAILED + objToSave, true);
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_38_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			java.io.IOException ex = new java.io.NotActiveException(FOO);
+			objToSave = ex;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// Has to be able to save/load an exception
+			assertTrue(MSG_TEST_FAILED + objToSave, true);
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_39_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			java.io.IOException ex = new java.io.NotSerializableException(FOO);
+			objToSave = ex;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// Has to be able to save/load an exception
+			assertTrue(MSG_TEST_FAILED + objToSave, true);
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+
+	public void test_18_40_writeObject() {
+		// Test for method void
+		// java.io.ObjectOutputStream.writeObject(java.lang.Object)
+
+		Object objToSave = null;
+		Object objLoaded;
+
+		try {
+			java.io.IOException ex = new java.io.StreamCorruptedException(FOO);
+			objToSave = ex;
+			if (DEBUG)
+				System.out.println("Obj = " + objToSave);
+			objLoaded = dumpAndReload(objToSave);
+			// Has to be able to save/load an exception
+			assertTrue(MSG_TEST_FAILED + objToSave, true);
+
+		} catch (IOException e) {
+			fail("IOException serializing " + objToSave + " : "
+					+ e.getMessage());
+		} catch (ClassNotFoundException e) {
+			fail("ClassNotFoundException reading Object type : "
+					+ e.getMessage());
+		} catch (Error err) {
+			System.out.println("Error when obj = " + objToSave);
+			// err.printStackTrace();
+			throw err;
+		}
+	}
+}



Mime
View raw message