| /* | |
| * 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"); | |
| } | |
| } | |
| } |