Java tutorial
/* * 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.util.MetaDataEntry; import org.apache.axis2.util.ObjectStateUtils; 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 ObjectSaveTest extends TestCase { protected static final Log log = LogFactory.getLog(ObjectSaveTest.class); private String testArg = null; // simple constructor needed for nested class Externalizable interface public ObjectSaveTest() { } public ObjectSaveTest(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); // try to save log.debug("ObjectSaveTest:testObjectSerializable(): saving ....."); saved = false; ObjectStateUtils.writeObject(outObjStream, obj, "testObject:Serializable"); // 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); // try to restore the options log.debug("ObjectSaveTest:testObjectSerializable(): restoring ....."); restored = false; MetaDataEntry restored_obj = (MetaDataEntry) ObjectStateUtils.readObject(inObjStream, "testObject:serializable"); 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); // try to save log.debug("ObjectSaveTest:testObjectNotSerializable(): saving ....."); saved = false; ObjectStateUtils.writeObject(outObjStream, obj, "testObject:NotSerializable"); 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); // try to restore the options log.debug("ObjectSaveTest:testObjectSerializable(): restoring ....."); restored = false; Object restored_obj = ObjectStateUtils.readObject(inObjStream, "testObject:NotSerializable"); 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); // try to save log.debug("ObjectSaveTest:testArrayList(): saving ....."); saved = false; ObjectStateUtils.writeArrayList(outObjStream, obj, "testObject:ArrayList"); // 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); // try to restore the options log.debug("ObjectSaveTest:testArrayList(): restoring ....."); restored = false; restored_obj = ObjectStateUtils.readArrayList(inObjStream, "testObject:ArrayList"); 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); // try to save log.debug("ObjectSaveTest:testHashMap(): saving ....."); saved = false; ObjectStateUtils.writeHashMap(outObjStream, obj, "testObject:HashMap"); // 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); // try to restore the options log.debug("ObjectSaveTest:testHashMap(): restoring ....."); restored = false; restored_obj = ObjectStateUtils.readHashMap(inObjStream, "testObject:HashMap"); 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); // try to save log.debug("ObjectSaveTest:testLinkedList(): saving ....."); saved = false; ObjectStateUtils.writeLinkedList(outObjStream, obj, "testObject:LinkedList"); // 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); // try to restore the options log.debug("ObjectSaveTest:testLinkedList(): restoring ....."); restored = false; restored_obj = ObjectStateUtils.readLinkedList(inObjStream, "testObject:LinkedList"); 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"); } } }