java/io/SerializationStressTest5.java

/*
 *  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 tests.api.java.io;

import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargetNew;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.Vector;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

@TestTargetClass(java.io.Serializable.class)
public class SerializationStressTest5 extends SerializationStressTest {

    transient Throwable current;

    // Use this for retrieving a list of any Throwable Classes that did not get
    // tested.
    transient Vector missedV = new Vector();

    transient Class[][] params = new Class[][] { { String.class },
            { Throwable.class }, { Exception.class },
            { String.class, Exception.class }, { String.class, int.class },
            { String.class, String.class, String.class },
            { String.class, Error.class },
            { int.class, boolean.class, boolean.class, int.class, int.class },
            {} };

    transient Object[][] args = new Object[][] {
            { "message" },
            { new Throwable() },
            { new Exception("exception") },
            { "message", new Exception("exception") },
            { "message", new Integer(5) },
            { "message", "message", "message" },
            { "message", new Error("error") },
            { new Integer(5), new Boolean(false), new Boolean(false),
                    new Integer(5), new Integer(5) }, {} };

    @TestTargetNew(
        level = TestLevel.ADDITIONAL,
        notes = "",
        method = "!Serialization:test ThrowableClasses",
        args = {}
    )
    public void _test_writeObject_Throwables() {
        try {
            oos.close();
        } catch (IOException e) {
        }

        File javaDir = findJavaDir();

        Vector classFilesVector = new Vector();
        if (javaDir != null)
            findClassFiles(javaDir, classFilesVector);
        else
            findClassFilesFromZip(classFilesVector);

        if (classFilesVector.size() == 0) {
            fail("No Class Files Found.");
        }

        File[] classFilesArray = new File[classFilesVector.size()];
        classFilesVector.copyInto(classFilesArray);

        Class[] throwableClasses = findThrowableClasses(classFilesArray);
        findParam(throwableClasses);

        // Use this to print out the list of Throwable classes that weren't
        // tested.
        /*
         * System.out.println(); Class[] temp = new Class[missedV.size()];
         * missedV.copyInto(temp); for (int i = 0; i < temp.length; i++)
         * System.out.println(i+1 + ": " + temp[i].getName());
         */
    }

    private File[] makeClassPathArray() {
        String classPath;
        // if (System.getProperty("java.vendor").startsWith("IBM"))
        //     classPath = System.getProperty("org.apache.harmony.boot.class.path");
        // else
        //     classPath = System.getProperty("sun.boot.class.path");
        classPath = System.getProperty("java.boot.class.path");
        int instanceOfSep = -1;
        int nextInstance = classPath.indexOf(File.pathSeparatorChar,
                instanceOfSep + 1);
        Vector elms = new Vector();
        while (nextInstance != -1) {
            elms.add(new File(classPath.substring(instanceOfSep + 1,
                    nextInstance)));
            instanceOfSep = nextInstance;
            nextInstance = classPath.indexOf(File.pathSeparatorChar,
                    instanceOfSep + 1);
        }
        elms.add(new File(classPath.substring(instanceOfSep + 1)));
        File[] result = new File[elms.size()];
        elms.copyInto(result);
        return result;
    }

    private File findJavaDir() {
        File[] files = makeClassPathArray();
        for (int i = 0; i < files.length; i++) {
            if (files[i].isDirectory()) {
                String[] tempFileNames = files[i].list();
                for (int j = 0; j < tempFileNames.length; j++) {
                    File tempfile = new File(files[i], tempFileNames[j]);
                    if (tempfile.isDirectory()
                            && tempFileNames[j].equals("java")) {
                        String[] subdirNames = tempfile.list();
                        for (int k = 0; k < subdirNames.length; k++) {
                            File subdir = new File(tempfile, subdirNames[k]);
                            if (subdir.isDirectory()
                                    && subdirNames[k].equals("lang")) {
                                return tempfile;
                            }
                        }
                    }
                }
            }
        }
        return null;
    }

    private void findClassFiles(File dir, Vector v) {
        String[] classFileNames = dir.list();
        for (int i = 0; i < classFileNames.length; i++) {
            File file = new File(dir, classFileNames[i]);
            if (file.isDirectory())
                findClassFiles(file, v);
            else if (classFileNames[i].endsWith(".class"))
                v.add(file);
        }
    }

    private Class[] findThrowableClasses(File[] files) {
        Class thrClass = Throwable.class;
        Vector resultVector = new Vector();
        String slash = System.getProperty("file.separator");
        String begTarget = slash + "java" + slash;
        String endTarget = ".class";
        for (int i = 0; i < files.length; i++) {
            String fileName = files[i].getPath();
            int instOfBegTarget = fileName.indexOf(begTarget);
            int instOfEndTarget = fileName.indexOf(endTarget);
            fileName = fileName.substring(instOfBegTarget + 1, instOfEndTarget);
            fileName = fileName.replace(slash.charAt(0), '.');
            try {
                Class theClass = Class.forName(fileName, false, ClassLoader
                        .getSystemClassLoader());
                if (thrClass.isAssignableFrom(theClass)) {
                    // java.lang.VirtualMachineError is abstract.
                    // java.io.ObjectStreamException is abstract
                    // java.beans.PropertyVetoException needs a
                    // java.beans.PropertyChangeEvent as a parameter
                    if (!fileName.equals("java.lang.VirtualMachineError")
                            && !fileName
                                    .equals("java.io.ObjectStreamException")
                            && !fileName
                                    .equals("java.beans.PropertyVetoException"))
                        resultVector.add(theClass);
                }
            } catch (ClassNotFoundException e) {
                fail("ClassNotFoundException : " + fileName);
            }
        }
        Class[] result = new Class[resultVector.size()];
        resultVector.copyInto(result);
        return result;
    }

    private void initClass(Class thrC, int num) {
        Constructor[] cons = thrC.getConstructors();
        for (int i = 0; i < cons.length; i++) {
            try {
                Throwable obj = (Throwable) cons[i].newInstance(args[num]);
                t_Class(obj, num);
                break;
            } catch (IllegalArgumentException e) {
                // This error should be caught until the correct args is hit.
            } catch (IllegalAccessException e) {
                fail(
                        "IllegalAccessException while creating instance of: "
                                + thrC.getName());
            } catch (InstantiationException e) {
                fail(
                        "InstantiationException while creating instance of: "
                                + thrC.getName());
            } catch (InvocationTargetException e) {
                fail(
                        "InvocationTargetException while creating instance of: "
                                + thrC.getName());
            }
            if (i == cons.length - 1) {
                fail(
                        "Failed to create newInstance of: " + thrC.getName());
            }
        }
    }

    public String getDumpName() {
        if (current == null) {
            dumpCount++;
            return getName();
        }
        return getName() + "_" + current.getClass().getName();
    }

    private void t_Class(Throwable objToSave, int argsNum) {
        current = objToSave;
        Object objLoaded = null;
        try {
            if (DEBUG)
                System.out.println("Obj = " + objToSave);
            try {
                objLoaded = dumpAndReload(objToSave);
            } catch (FileNotFoundException e) {
                // Must be using xload, ignore missing Throwables
                System.out.println("Ignoring: "
                        + objToSave.getClass().getName());
                return;
            }

            // Has to have worked
            boolean equals;
            equals = objToSave.getClass().equals(objLoaded.getClass());
            assertTrue(MSG_TEST_FAILED + objToSave, equals);
            if (argsNum == 0 || (argsNum >= 3 && argsNum <= 7)) {
                equals = ((Throwable) objToSave).getMessage().equals(
                        ((Throwable) objLoaded).getMessage());
                assertTrue("Message Test: " + MSG_TEST_FAILED + objToSave,
                        equals);
            } else {
                // System.out.println(((Throwable)objToSave).getMessage());
                equals = ((Throwable) objToSave).getMessage() == null;
                assertTrue("Null Test 1: (args=" + argsNum + ") "
                        + MSG_TEST_FAILED + objToSave, equals);
                equals = ((Throwable) objLoaded).getMessage() == null;
                assertTrue("Null Test 2: (args=" + argsNum + ") "
                        + MSG_TEST_FAILED + objToSave, equals);
            }
        } catch (IOException e) {
            fail("Unexpected IOException in checkIt() : " + e.getMessage());
        } catch (ClassNotFoundException e) {
            fail(e.toString() + " - testing " + objToSave.getClass().getName());
        }
    }

    private void findParam(Class[] thrC) {
        for (int i = 0; i < thrC.length; i++) {
            Constructor con = null;
            for (int j = 0; j < params.length; j++) {
                try {
                    con = thrC[i].getConstructor(params[j]);
                } catch (NoSuchMethodException e) {
                    // This Error will be caught until the right param is found.
                }

                if (con != null) {
                    // If the param was found, initialize the Class
                    initClass(thrC[i], j);
                    break;
                }
                // If the param not found then add to missed Vector.
                if (j == params.length - 1)
                    missedV.add(thrC[i]);
            }
        }
    }

    private void findClassFilesFromZip(Vector v) {
        String slash = System.getProperty("file.separator");
        String javaHome = System.getProperty("java.home");
        if (!javaHome.endsWith(slash))
            javaHome += slash;

        String[] wanted = { "java" + slash + "io", "java" + slash + "lang",
                "java" + slash + "math", "java" + slash + "net",
                "java" + slash + "security", "java" + slash + "text",
                "java" + slash + "util", "java" + slash + "beans",
                "java" + slash + "rmi",
                // One or more class files in awt make the VM hang after being
                // loaded.
                // "java" + slash + "awt",
                "java" + slash + "sql",
        // These are (possibly) all of the throwable classes in awt
        /*
         * "java\\awt\\AWTError", "java\\awt\\AWTException",
         * "java\\awt\\color\\CMMException",
         * "java\\awt\\color\\ProfileDataException",
         * "java\\awt\\datatransfer\\MimeTypeParseException",
         * "java\\awt\\datatransfer\\UnsupportedFlavorException",
         * "java\\awt\\dnd\\InvalidDnDOperationException",
         * "java\\awt\\FontFormatException",
         * "java\\awt\\geom\\IllegalPathStateException",
         * "java\\awt\\geom\\NoninvertibleTransformException",
         * "java\\awt\\IllegalComponentStateException",
         * "java\\awt\\image\\ImagingOpException",
         * "java\\awt\\image\\RasterFormatException",
         * "java\\awt\\print\\PrinterAbortException",
         * "java\\awt\\print\\PrinterException",
         * "java\\awt\\print\\PrinterIOException"
         */
        };

        File[] files = makeClassPathArray();
        FileInputStream fis = null;
        ZipInputStream zis = null;
        ZipEntry ze = null;
        for (int i = 0; i < files.length; i++) {
            String fileName = files[i].getPath();
            if (files[i].exists() && files[i].isFile()
                    && fileName.endsWith(".jar") || fileName.endsWith(".zip")) {
                try {
                    fis = new FileInputStream(files[i].getPath());
                } catch (FileNotFoundException e) {
                    fail("FileNotFoundException trying to open "
                            + files[i].getPath());
                }
                zis = new ZipInputStream(fis);
                while (true) {
                    try {
                        ze = zis.getNextEntry();
                    } catch (IOException e) {
                        fail("IOException while getting next zip entry: "
                                + e);
                    }
                    if (ze == null)
                        break;
                    String zeName = ze.getName();
                    if (zeName.endsWith(".class")) {
                        zeName = zeName.replace('/', slash.charAt(0));
                        for (int j = 0; j < wanted.length; j++) {
                            if (zeName.startsWith(wanted[j])) {
                                // When finding class files from directories the
                                // program saves them as files.
                                // To stay consistent we will turn the ZipEntry
                                // classes into instances of files.
                                File tempF = new File(javaHome + zeName);
                                // Making sure that the same class is not added
                                // twice.
                                boolean duplicate = false;
                                for (int k = 0; k < v.size(); k++) {
                                    if (v.get(k).equals(tempF))
                                        duplicate = true;
                                }
                                if (!duplicate)
                                    v.add(tempF);
                                break;
                            }
                        }
                    }
                }
                ;
                try {
                    zis.close();
                    fis.close();
                } catch (IOException e) {
                    fail(
                            "IOException while trying to close InputStreams: "
                                    + e);
                }
            }
        }
    }
}