/* | |
* Licensed to the Apache Software Foundation (ASF) under one | |
* or more contributor license agreements. See the NOTICE file | |
* distributed with this work for additional information | |
* regarding copyright ownership. The ASF licenses this file | |
* to you under the Apache License, Version 2.0 (the | |
* "License"); you may not use this file except in compliance | |
* with the License. You may obtain a copy of the License at | |
* | |
* http://www.apache.org/licenses/LICENSE-2.0 | |
* | |
* Unless required by applicable law or agreed to in writing, | |
* software distributed under the License is distributed on an | |
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
* KIND, either express or implied. See the License for the | |
* specific language governing permissions and limitations | |
* under the License. | |
*/ | |
package org.apache.axis2.engine; | |
import junit.framework.TestCase; | |
import org.apache.axis2.context.externalize.SafeObjectInputStream; | |
import org.apache.axis2.context.externalize.SafeObjectOutputStream; | |
import org.apache.axis2.util.MetaDataEntry; | |
import org.apache.commons.logging.Log; | |
import org.apache.commons.logging.LogFactory; | |
import java.io.Externalizable; | |
import java.io.File; | |
import java.io.FileInputStream; | |
import java.io.FileOutputStream; | |
import java.io.IOException; | |
import java.io.NotSerializableException; | |
import java.io.ObjectInputStream; | |
import java.io.ObjectOutputStream; | |
import java.io.PrintStream; | |
import java.util.ArrayList; | |
import java.util.HashMap; | |
import java.util.LinkedList; | |
public class ObjectSave2Test extends TestCase { | |
protected static final Log log = LogFactory.getLog(ObjectSave2Test.class); | |
private String testArg = null; | |
// simple constructor needed for nested class Externalizable interface | |
public ObjectSave2Test() { | |
} | |
public ObjectSave2Test(String arg0) { | |
super(arg0); | |
testArg = new String(arg0); | |
} | |
protected void setUp() throws Exception { | |
// org.apache.log4j.BasicConfigurator.configure(); | |
} | |
public void testObjectSerializable() throws Exception { | |
File theFile = null; | |
String theFilename = null; | |
boolean saved = false; | |
boolean restored = false; | |
boolean done = false; | |
log.debug("ObjectSaveTest:testObjectSerializable(): BEGIN ---------------"); | |
// --------------------------------------------------------- | |
// setup an object to use | |
// --------------------------------------------------------- | |
MetaDataEntry obj = new MetaDataEntry("object_1", "object_1"); | |
// --------------------------------------------------------- | |
// setup a temporary file to use | |
// --------------------------------------------------------- | |
try { | |
theFile = File.createTempFile("objectTest", null); | |
theFilename = theFile.getName(); | |
log.debug("ObjectSaveTest:testObjectSerializable(): temp file = [" | |
+ theFilename + "]"); | |
} catch (Exception ex) { | |
log.debug("ObjectSaveTest:testObjectSerializable(): error creating temp file = [" | |
+ ex.getMessage() + "]"); | |
theFile = null; | |
} | |
if (theFile != null) { | |
// --------------------------------------------------------- | |
// save to the temporary file | |
// --------------------------------------------------------- | |
try { | |
// setup an output stream to a physical file | |
FileOutputStream outStream = new FileOutputStream(theFile); | |
// attach a stream capable of writing objects to the | |
// stream connected to the file | |
ObjectOutputStream outObjStream = new ObjectOutputStream( | |
outStream); | |
SafeObjectOutputStream out = | |
SafeObjectOutputStream.install(outObjStream); | |
// try to save | |
log.debug("ObjectSaveTest:testObjectSerializable(): saving ....."); | |
saved = false; | |
out.writeObject(obj); | |
// close out the streams | |
outObjStream.flush(); | |
outObjStream.close(); | |
outStream.flush(); | |
outStream.close(); | |
saved = true; | |
log.debug( | |
"ObjectSaveTest:testObjectSerializable(): " + | |
"....save operation completed....."); | |
long filesize = theFile.length(); | |
log.debug("ObjectSaveTest:testObjectSerializable(): file size after save [" | |
+ filesize | |
+ "] temp file = [" | |
+ theFilename | |
+ "]"); | |
} catch (Exception ex2) { | |
log.debug("ObjectSaveTest:testObjectSerializable(): error during save [" | |
+ ex2.getClass().getName() | |
+ " : " | |
+ ex2.getMessage() + "]"); | |
ex2.printStackTrace(); | |
} | |
assertTrue(saved); | |
// --------------------------------------------------------- | |
// restore from the temporary file | |
// --------------------------------------------------------- | |
try { | |
// setup an input stream to the file | |
FileInputStream inStream = new FileInputStream(theFile); | |
// attach a stream capable of reading objects from the | |
// stream connected to the file | |
ObjectInputStream inObjStream = new ObjectInputStream(inStream); | |
SafeObjectInputStream in = | |
SafeObjectInputStream.install(inObjStream); | |
// try to restore the options | |
log.debug("ObjectSaveTest:testObjectSerializable(): restoring ....."); | |
restored = false; | |
MetaDataEntry restored_obj = (MetaDataEntry) in.readObject(); | |
inObjStream.close(); | |
inStream.close(); | |
restored = true; | |
log.debug( | |
"ObjectSaveTest:testObjectSerializable(): ....restored operation completed....."); | |
} catch (Exception ex2) { | |
log.debug("ObjectSaveTest:testObjectSerializable(): error during restore [" | |
+ ex2.getClass().getName() | |
+ " : " | |
+ ex2.getMessage() + "]"); | |
ex2.printStackTrace(); | |
} | |
assertTrue(restored); | |
// if the save/restore of the object succeeded, | |
// then don't keep the temporary file around | |
boolean removeTmpFile = saved && restored; | |
if (removeTmpFile) { | |
try { | |
theFile.delete(); | |
} catch (Exception e) { | |
// just absorb it | |
} | |
} | |
// indicate that the temp file was created ok | |
done = true; | |
} | |
// this is false when there are problems with the temporary file | |
assertTrue(done); | |
log.debug("ObjectSaveTest:testObjectSerializable(): END ---------------"); | |
} | |
public void testObjectNotSerializable() throws Exception { | |
File theFile = null; | |
String theFilename = null; | |
boolean saved = false; | |
boolean restored = false; | |
boolean expected_exception = false; | |
boolean done = false; | |
log.debug("ObjectSaveTest:testObjectNotSerializable(): BEGIN ---------------"); | |
// --------------------------------------------------------- | |
// setup an object to use | |
// --------------------------------------------------------- | |
NotSerializableObject obj = new NotSerializableObject("nso_1"); | |
// --------------------------------------------------------- | |
// setup a temporary file to use | |
// --------------------------------------------------------- | |
try { | |
theFile = File.createTempFile("objectTest", null); | |
theFilename = theFile.getName(); | |
log.debug("ObjectSaveTest:testObjectNotSerializable(): temp file = [" | |
+ theFilename + "]"); | |
} catch (Exception ex) { | |
log.debug("ObjectSaveTest:testObjectNotSerializable(): error creating temp file = [" | |
+ ex.getMessage() + "]"); | |
theFile = null; | |
} | |
if (theFile != null) { | |
// --------------------------------------------------------- | |
// save to the temporary file | |
// --------------------------------------------------------- | |
FileOutputStream outStream = null; | |
ObjectOutputStream outObjStream = null; | |
try { | |
// setup an output stream to a physical file | |
outStream = new FileOutputStream(theFile); | |
// attach a stream capable of writing objects to the | |
// stream connected to the file | |
outObjStream = new ObjectOutputStream(outStream); | |
SafeObjectOutputStream out = | |
SafeObjectOutputStream.install(outObjStream); | |
// try to save | |
log.debug("ObjectSaveTest:testObjectNotSerializable(): saving ....."); | |
saved = false; | |
out.writeObject(obj); | |
saved = true; | |
log.debug( | |
"ObjectSaveTest:testObjectNotSerializable(): " + | |
"....save operation completed....."); | |
long filesize = theFile.length(); | |
log.debug("ObjectSaveTest:testObjectNotSerializable(): file size after save [" | |
+ filesize | |
+ "] temp file = [" | |
+ theFilename | |
+ "]"); | |
} catch (Exception ex2) { | |
// expect an error here | |
// ObjectStateUtils catches the NotSerializableException and | |
// logs it | |
if (ex2 instanceof NotSerializableException) { | |
expected_exception = true; | |
} else { | |
log.debug("ObjectSaveTest:testObjectNotSerializable(): save [" | |
+ ex2.getClass().getName() | |
+ " : " | |
+ ex2.getMessage() + "]"); | |
} | |
} | |
// close out the streams | |
if (outObjStream != null) | |
outObjStream.close(); | |
if (outStream != null) | |
outStream.close(); | |
// --------------------------------------------------------- | |
// restore from the temporary file | |
// --------------------------------------------------------- | |
try { | |
// setup an input stream to the file | |
FileInputStream inStream = new FileInputStream(theFile); | |
// attach a stream capable of reading objects from the | |
// stream connected to the file | |
ObjectInputStream inObjStream = new ObjectInputStream(inStream); | |
SafeObjectInputStream in = | |
SafeObjectInputStream.install(inObjStream); | |
// try to restore the options | |
log.debug("ObjectSaveTest:testObjectSerializable(): restoring ....."); | |
restored = false; | |
Object restored_obj = in.readObject(); | |
inObjStream.close(); | |
inStream.close(); | |
restored = true; | |
log.debug( | |
"ObjectSaveTest:testObjectNotSerializable(): " + | |
"....restored operation completed....."); | |
} catch (Exception ex) { | |
log.debug("ObjectSaveTest:testObjectNotSerializable(): error during restore [" | |
+ ex.getClass().getName() | |
+ " : " | |
+ ex.getMessage() + "]"); | |
ex.printStackTrace(); | |
} | |
assertTrue(restored); | |
// if the save/restore of the object succeeded, | |
// then don't keep the temporary file around | |
boolean removeTmpFile = saved && restored; | |
if (removeTmpFile) { | |
try { | |
theFile.delete(); | |
} catch (Exception e) { | |
// just absorb it | |
} | |
} | |
assertTrue(expected_exception); | |
} | |
log.debug("ObjectSaveTest:testObjectNotSerializable(): END ---------------"); | |
} | |
public void testArrayList() throws Exception { | |
File theFile = null; | |
String theFilename = null; | |
boolean saved = false; | |
boolean restored = false; | |
boolean done = false; | |
boolean comparesOK = false; | |
log.debug("ObjectSaveTest:testArrayList(): BEGIN ---------------"); | |
// --------------------------------------------------------- | |
// setup the object to use | |
// --------------------------------------------------------- | |
ArrayList obj = new ArrayList(); | |
obj.add(new Integer(1)); | |
obj.add(new Integer(2)); | |
obj.add(new Integer(3)); | |
obj.add(new String("string1")); | |
obj.add(new String("string2")); | |
obj.add(System.out); | |
obj.add(new Integer(4)); | |
obj.add(new Integer(5)); | |
obj.add(new Integer(6)); | |
int initial_size = obj.size(); | |
// --------------------------------------------------------- | |
// setup a temporary file to use | |
// --------------------------------------------------------- | |
try { | |
theFile = File.createTempFile("arraylistTest", null); | |
theFilename = theFile.getName(); | |
log.debug("ObjectSaveTest:testArrayList(): temp file = [" | |
+ theFilename + "]"); | |
} catch (Exception ex) { | |
log.debug("ObjectSaveTest:testArrayList(): error creating temp file = [" | |
+ ex.getMessage() + "]"); | |
theFile = null; | |
} | |
if (theFile != null) { | |
// --------------------------------------------------------- | |
// save to the temporary file | |
// --------------------------------------------------------- | |
try { | |
// setup an output stream to a physical file | |
FileOutputStream outStream = new FileOutputStream(theFile); | |
// attach a stream capable of writing objects to the | |
// stream connected to the file | |
ObjectOutputStream outObjStream = new ObjectOutputStream( | |
outStream); | |
SafeObjectOutputStream out = | |
SafeObjectOutputStream.install(outObjStream); | |
// try to save | |
log.debug("ObjectSaveTest:testArrayList(): saving ....."); | |
saved = false; | |
out.writeList(obj); | |
// close out the streams | |
outObjStream.flush(); | |
outObjStream.close(); | |
outStream.flush(); | |
outStream.close(); | |
saved = true; | |
log.debug("ObjectSaveTest:testArrayList(): ....save operation completed....."); | |
long filesize = theFile.length(); | |
log.debug("ObjectSaveTest:testArrayList(): file size after save [" | |
+ filesize | |
+ "] temp file = [" | |
+ theFilename | |
+ "]"); | |
} catch (Exception ex2) { | |
log.debug("ObjectSaveTest:testArrayList(): error during save [" | |
+ ex2.getClass().getName() | |
+ " : " | |
+ ex2.getMessage() + "]"); | |
ex2.printStackTrace(); | |
} | |
assertTrue(saved); | |
// --------------------------------------------------------- | |
// restore from the temporary file | |
// --------------------------------------------------------- | |
ArrayList restored_obj = null; | |
try { | |
// setup an input stream to the file | |
FileInputStream inStream = new FileInputStream(theFile); | |
// attach a stream capable of reading objects from the | |
// stream connected to the file | |
ObjectInputStream inObjStream = new ObjectInputStream(inStream); | |
SafeObjectInputStream in = | |
SafeObjectInputStream.install(inObjStream); | |
// try to restore the options | |
log.debug("ObjectSaveTest:testArrayList(): restoring ....."); | |
restored = false; | |
restored_obj = in.readArrayList(); | |
inObjStream.close(); | |
inStream.close(); | |
restored = true; | |
log.debug("ObjectSaveTest:testArrayList(): ....restored operation completed....."); | |
} catch (Exception ex2) { | |
log.debug("ObjectSaveTest:testArrayList(): error during restore [" | |
+ ex2.getClass().getName() | |
+ " : " | |
+ ex2.getMessage() + "]"); | |
ex2.printStackTrace(); | |
} | |
// if the save/restore of the object succeeded, | |
// then don't keep the temporary file around | |
boolean removeTmpFile = saved && restored; | |
if (removeTmpFile) { | |
try { | |
theFile.delete(); | |
} catch (Exception e) { | |
// just absorb it | |
} | |
} | |
assertTrue(restored); | |
if (restored_obj != null) { | |
int restored_size = restored_obj.size(); | |
if (restored_size == (initial_size - 1)) { | |
comparesOK = true; | |
} | |
} | |
// TODO: check for exact entries | |
assertTrue(comparesOK); | |
// indicate that the temp file was created ok | |
done = true; | |
} | |
// this is false when there are problems with the temporary file | |
assertTrue(done); | |
log.debug("ObjectSaveTest:testArrayList(): END ---------------"); | |
} | |
public void testHashMap() throws Exception { | |
File theFile = null; | |
String theFilename = null; | |
boolean saved = false; | |
boolean restored = false; | |
boolean done = false; | |
boolean comparesOK = false; | |
log.debug("ObjectSaveTest:testHashMap(): BEGIN ---------------"); | |
// --------------------------------------------------------- | |
// setup the object to use | |
// --------------------------------------------------------- | |
HashMap obj = new HashMap(); | |
obj.put(new String("key1"), new Integer(1)); | |
obj.put(new String("key2"), new Integer(2)); | |
obj.put(new String("key3"), new String("value1")); | |
obj.put(new String("key4"), System.out); | |
obj.put(new String("key5"), new Integer(3)); | |
obj.put(new String("key6"), new Integer(4)); | |
obj.put(new String("key7"), System.err); | |
obj.put(new String("key8"), new Integer(5)); | |
obj.put(new String("key9"), new Integer(6)); | |
obj.put(new NotSerializableObject("TestForHashMapKey"), new Integer(7)); | |
obj.put(new String("key10"), new Integer(8)); | |
int initial_size = obj.size(); | |
// --------------------------------------------------------- | |
// setup a temporary file to use | |
// --------------------------------------------------------- | |
try { | |
theFile = File.createTempFile("hashmapTest", null); | |
theFilename = theFile.getName(); | |
log.debug("ObjectSaveTest:testHashMap(): temp file = [" | |
+ theFilename + "]"); | |
} catch (Exception ex) { | |
log.debug("ObjectSaveTest:testHashMap(): error creating temp file = [" | |
+ ex.getMessage() + "]"); | |
theFile = null; | |
} | |
if (theFile != null) { | |
// --------------------------------------------------------- | |
// save to the temporary file | |
// --------------------------------------------------------- | |
try { | |
// setup an output stream to a physical file | |
FileOutputStream outStream = new FileOutputStream(theFile); | |
// attach a stream capable of writing objects to the | |
// stream connected to the file | |
ObjectOutputStream outObjStream = new ObjectOutputStream( | |
outStream); | |
SafeObjectOutputStream out = | |
SafeObjectOutputStream.install(outObjStream); | |
// try to save | |
log.debug("ObjectSaveTest:testHashMap(): saving ....."); | |
saved = false; | |
out.writeMap(obj); | |
// close out the streams | |
outObjStream.flush(); | |
outObjStream.close(); | |
outStream.flush(); | |
outStream.close(); | |
saved = true; | |
log.debug("ObjectSaveTest:testHashMap(): ....save operation completed....."); | |
long filesize = theFile.length(); | |
log.debug("ObjectSaveTest:testHashMap(): file size after save [" | |
+ filesize | |
+ "] temp file = [" | |
+ theFilename | |
+ "]"); | |
} catch (Exception ex2) { | |
log.debug("ObjectSaveTest:testHashMap(): error during save [" | |
+ ex2.getClass().getName() | |
+ " : " | |
+ ex2.getMessage() + "]"); | |
ex2.printStackTrace(); | |
} | |
assertTrue(saved); | |
// --------------------------------------------------------- | |
// restore from the temporary file | |
// --------------------------------------------------------- | |
HashMap restored_obj = null; | |
try { | |
// setup an input stream to the file | |
FileInputStream inStream = new FileInputStream(theFile); | |
// attach a stream capable of reading objects from the | |
// stream connected to the file | |
ObjectInputStream inObjStream = new ObjectInputStream(inStream); | |
SafeObjectInputStream in = | |
SafeObjectInputStream.install(inObjStream); | |
// try to restore the options | |
log.debug("ObjectSaveTest:testHashMap(): restoring ....."); | |
restored = false; | |
restored_obj = in.readHashMap(); | |
inObjStream.close(); | |
inStream.close(); | |
restored = true; | |
log.debug("ObjectSaveTest:testHashMap(): ....restored operation completed....."); | |
} catch (Exception ex2) { | |
log.debug("ObjectSaveTest:testHashMap(): error during restore [" | |
+ ex2.getClass().getName() | |
+ " : " | |
+ ex2.getMessage() + "]"); | |
ex2.printStackTrace(); | |
} | |
// if the save/restore of the object succeeded, | |
// then don't keep the temporary file around | |
boolean removeTmpFile = saved && restored; | |
if (removeTmpFile) { | |
try { | |
theFile.delete(); | |
} catch (Exception e) { | |
// just absorb it | |
} | |
} | |
assertTrue(restored); | |
if (restored_obj != null) { | |
int restored_size = restored_obj.size(); | |
if (restored_size == (initial_size - 3)) { | |
// there are entries in the map that are not serializable | |
comparesOK = true; | |
} | |
} | |
// TODO: check for exact entries | |
assertTrue(comparesOK); | |
// indicate that the temp file was created ok | |
done = true; | |
} | |
// this is false when there are problems with the temporary file | |
assertTrue(done); | |
log.debug("ObjectSaveTest:testHashMap(): END ---------------"); | |
} | |
public void testLinkedList() throws Exception { | |
File theFile = null; | |
String theFilename = null; | |
boolean saved = false; | |
boolean restored = false; | |
boolean done = false; | |
boolean comparesOK = false; | |
log.debug("ObjectSaveTest:testLinkedList(): BEGIN ---------------"); | |
// --------------------------------------------------------- | |
// setup the object to use | |
// --------------------------------------------------------- | |
LinkedList obj = new LinkedList(); | |
obj.add(new Integer(1)); | |
obj.add(new Integer(2)); | |
obj.add(new Integer(3)); | |
obj.add(new String("string1")); | |
obj.add(new String("string2")); | |
obj.add(System.in); | |
obj.add(new Integer(4)); | |
obj.add(new Integer(5)); | |
obj.add(new Integer(6)); | |
int initial_size = obj.size(); | |
// --------------------------------------------------------- | |
// setup a temporary file to use | |
// --------------------------------------------------------- | |
try { | |
theFile = File.createTempFile("linkedlistTest", null); | |
theFilename = theFile.getName(); | |
log.debug("ObjectSaveTest:testLinkedList(): temp file = [" | |
+ theFilename + "]"); | |
} catch (Exception ex) { | |
log.debug("ObjectSaveTest:testLinkedList(): error creating temp file = [" | |
+ ex.getMessage() + "]"); | |
theFile = null; | |
} | |
if (theFile != null) { | |
// --------------------------------------------------------- | |
// save to the temporary file | |
// --------------------------------------------------------- | |
try { | |
// setup an output stream to a physical file | |
FileOutputStream outStream = new FileOutputStream(theFile); | |
// attach a stream capable of writing objects to the | |
// stream connected to the file | |
ObjectOutputStream outObjStream = new ObjectOutputStream( | |
outStream); | |
SafeObjectOutputStream out = | |
SafeObjectOutputStream.install(outObjStream); | |
// try to save | |
log.debug("ObjectSaveTest:testLinkedList(): saving ....."); | |
saved = false; | |
out.writeList(obj); | |
// close out the streams | |
outObjStream.flush(); | |
outObjStream.close(); | |
outStream.flush(); | |
outStream.close(); | |
saved = true; | |
log.debug("ObjectSaveTest:testLinkedList(): ....save operation completed....."); | |
long filesize = theFile.length(); | |
log.debug("ObjectSaveTest:testLinkedList(): file size after save [" | |
+ filesize | |
+ "] temp file = [" | |
+ theFilename | |
+ "]"); | |
} catch (Exception ex2) { | |
log.debug("ObjectSaveTest:testLinkedList(): error during save [" | |
+ ex2.getClass().getName() | |
+ " : " | |
+ ex2.getMessage() + "]"); | |
ex2.printStackTrace(); | |
} | |
assertTrue(saved); | |
// --------------------------------------------------------- | |
// restore from the temporary file | |
// --------------------------------------------------------- | |
LinkedList restored_obj = null; | |
try { | |
// setup an input stream to the file | |
FileInputStream inStream = new FileInputStream(theFile); | |
// attach a stream capable of reading objects from the | |
// stream connected to the file | |
ObjectInputStream inObjStream = new ObjectInputStream(inStream); | |
SafeObjectInputStream in = | |
SafeObjectInputStream.install(inObjStream); | |
// try to restore the options | |
log.debug("ObjectSaveTest:testLinkedList(): restoring ....."); | |
restored = false; | |
restored_obj = in.readLinkedList(); | |
inObjStream.close(); | |
inStream.close(); | |
restored = true; | |
log.debug("ObjectSaveTest:testLinkedList(): ....restored operation completed....."); | |
} catch (Exception ex2) { | |
log.debug("ObjectSaveTest:testLinkedList(): error during restore [" | |
+ ex2.getClass().getName() | |
+ " : " | |
+ ex2.getMessage() + "]"); | |
ex2.printStackTrace(); | |
} | |
// if the save/restore of the object succeeded, | |
// then don't keep the temporary file around | |
boolean removeTmpFile = saved && restored; | |
if (removeTmpFile) { | |
try { | |
theFile.delete(); | |
} catch (Exception e) { | |
// just absorb it | |
} | |
} | |
assertTrue(restored); | |
if (restored_obj != null) { | |
int restored_size = restored_obj.size(); | |
if (restored_size == (initial_size - 1)) { | |
comparesOK = true; | |
} | |
} | |
// TODO: check for exact entries | |
assertTrue(comparesOK); | |
// indicate that the temp file was created ok | |
done = true; | |
} | |
// this is false when there are problems with the temporary file | |
assertTrue(done); | |
log.debug("ObjectSaveTest:testLinkedList(): END ---------------"); | |
} | |
public class NotSerializableObject implements Externalizable { | |
private String label = "TestObject"; | |
private String ID = null; | |
// make sure we have some objects that don't serialize | |
private PrintStream ps = System.out; | |
// default constructor needed for Externalizable interface | |
public NotSerializableObject() { | |
} | |
public NotSerializableObject(String identifier) { | |
ID = identifier; | |
ps = System.out; | |
} | |
public void setID(String s) { | |
ID = s; | |
} | |
public String getID() { | |
return ID; | |
} | |
public void writeExternal(java.io.ObjectOutput out) throws IOException { | |
throw new NotSerializableException( | |
"Test Object is not serializable"); | |
} | |
public void readExternal(java.io.ObjectInput in) throws IOException, | |
ClassNotFoundException { | |
throw new IOException("Test object is not serializable"); | |
} | |
} | |
} |