org.apache.axis2.engine.ObjectSave2Test.java Source code

Java tutorial

Introduction

Here is the source code for org.apache.axis2.engine.ObjectSave2Test.java

Source

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

    }

}