You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@harmony.apache.org by te...@apache.org on 2006/03/15 12:47:39 UTC
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/...
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;
+ }
+ }
+}