axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sc...@apache.org
Subject svn commit: r577367 [5/5] - in /webservices/axis2/trunk/java/modules: jaxws/src/org/apache/axis2/jaxws/client/ jaxws/src/org/apache/axis2/jaxws/message/util/ kernel/src/org/apache/axis2/addressing/ kernel/src/org/apache/axis2/client/ kernel/src/org/apa...
Date Wed, 19 Sep 2007 16:56:49 GMT
Added: webservices/axis2/trunk/java/modules/kernel/test/org/apache/axis2/engine/ObjectSave2Test.java
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/java/modules/kernel/test/org/apache/axis2/engine/ObjectSave2Test.java?rev=577367&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/kernel/test/org/apache/axis2/engine/ObjectSave2Test.java
(added)
+++ webservices/axis2/trunk/java/modules/kernel/test/org/apache/axis2/engine/ObjectSave2Test.java
Wed Sep 19 09:56:47 2007
@@ -0,0 +1,818 @@
+/*
+ * 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 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;
+
+import junit.framework.TestCase;
+
+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");
+		}
+
+	}
+
+}



---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org


Mime
View raw message