xref: /external/apache-harmony/luni/src/test/api/common/org/apache/harmony/luni/tests/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 org.apache.harmony.luni.tests.java.io;

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;

@SuppressWarnings( { "serial", "unused" })
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<Class> missedV = new Vector<Class>();

	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) }, {} };

	public SerializationStressTest5(String name) {
		super(name);
	}

	public void test_writeObject_Throwables() {
		try {
			oos.close();
		} catch (IOException e) {
		}

		File javaDir = findJavaDir();

		Vector<File> classFilesVector = new Vector<File>();
		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");
		int instanceOfSep = -1;
		int nextInstance = classPath.indexOf(File.pathSeparatorChar,
				instanceOfSep + 1);
		Vector<File> elms = new Vector<File>();
		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<File> 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<Throwable> thrClass = Throwable.class;
		Vector<Class> resultVector = new Vector<Class>();
		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<File> 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);
				}
			}
		}
	}
}