test-modules/base-test-infrastructure/src/test/java/org/apache/myfaces/extensions/validator/test/base/util/ClassLoaderTestSuite.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.myfaces.extensions.validator.test.base.util;

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.MalformedURLException;
import java.util.StringTokenizer;
import java.util.Vector;
import java.util.jar.Attributes;
import java.util.jar.Manifest;
import java.util.logging.Logger;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import junit.runner.TestCaseClassLoader;

/**
 * Allows the execution of each test of a TestCase into a different classloader.
 * Specify the class of the test case in the constructor and return the instance
 * of the ClassLoaderTestSuite as the result of the suite method.
 * 
 * Most of the code is borrowed from junit.framework.TestSuite.
 * 
 * @author Rudy De Busscher
 * 
 */
@SuppressWarnings("unchecked")
public class ClassLoaderTestSuite extends TestSuite
{
    private static final Logger LOGGER = Logger.getLogger(ClassLoaderTestSuite.class.getName());
    
    // The classpath is needed because the custom class loader looks their to find the classes.
    private static String classPath;
    private static boolean classPathDetermined = false;

    public ClassLoaderTestSuite(Class theClass)
    {
        identifyTestMethods(theClass);

    }

    /**
     * Identify test methods.
     * 
     * @param theClass
     *            the class
     */
    private void identifyTestMethods(Class theClass)
    {
        Class superClass = theClass;
        Vector names = new Vector();
        while (Test.class.isAssignableFrom(superClass))
        {
            Method[] methods = superClass.getDeclaredMethods();
            for (int i = 0; i < methods.length; i++)
            {
                addTestMethod(methods[i], names, theClass);
            }
            superClass = superClass.getSuperclass();
        }
    }

    /**
     * Adds the method as a test method when it fulfill all requirements.
     * 
     * @param method
     *            the method that is maybe a test method
     * @param names
     *            the names with all the discovered test methods
     * @param theClass
     *            the class
     */
    private void addTestMethod(Method method, Vector names, Class theClass)
    {
        String name = method.getName();
        if (names.contains(name))
        {
            return;
        }
        if (!isPublicTestMethod(method))
        {
            if (isTestMethod(method))
            {
                addTest(warning("Test method isn't public: " + method.getName()));
            }
            return;
        }
        names.addElement(name);
        addTest(createTestWithCustomClassLoader(theClass, name));
    }

    /**
     * The method creates a Test using a custom classloader for each test.
     * 
     * @param theOriginalClass
     *            The class
     * @param name
     *            The test method name
     * @return The test where class is now loaded from a custom class loader.
     */
    static public Test createTestWithCustomClassLoader(Class theOriginalClass, String name)
    {
        
        ClassLoader classLoader;

        String surefireTestPath = getClassPath();
        if (surefireTestPath != null)
        {
            classLoader = new TestCaseClassLoader(surefireTestPath);
        }

        else
        {
            classLoader = new TestCaseClassLoader();

        }

        Class theClass = null;
        try
        {
            // Use the custom classloader to load the test. The complete
            // execution of the test will then be done using this new
            // classloader.
            theClass = classLoader.loadClass(theOriginalClass.getName());
        } catch (ClassNotFoundException e)
        {
            return warning("Cannot custom load test case: " + name + " (" + exceptionToString(e) + ")");
        }

        Constructor constructor;
        try
        {
            constructor = getTestConstructor(theClass);
        } catch (NoSuchMethodException e)
        {
            return warning("Class " + theClass.getName()
                    + " has no public constructor TestCase(String name) or TestCase()");
        }
        Object test;
        try
        {
            if (constructor.getParameterTypes().length == 0)
            {
                test = constructor.newInstance(new Object[0]);
                if (test instanceof TestCase)
                    ((TestCase) test).setName(name);
            } else
            {
                test = constructor.newInstance(new Object[] { name });
            }
        } catch (InstantiationException e)
        {
            return (warning("Cannot instantiate test case: " + name + " (" + exceptionToString(e) + ")"));
        } catch (InvocationTargetException e)
        {
            return (warning("Exception in constructor: " + name + " (" + exceptionToString(e.getTargetException())
                    + ")"));
        } catch (IllegalAccessException e)
        {
            return (warning("Cannot access test case: " + name + " (" + exceptionToString(e) + ")"));
        }
        return (Test) test;
    }

    /**
     * Gets the class path.This value is cached in a static variable for performance reasons.
     * 
     * @return the class path
     */
    private static String getClassPath()
    {
        if (classPathDetermined) {
            return classPath;
        }
        
        classPathDetermined = true;
        // running from maven, we have the classpath in this property.
        classPath = System.getProperty("surefire.test.class.path");
        if (classPath != null) {
            return classPath;
        }
        
        // For a multi module project, running it from the top we have to find it using another way.
        // We also need to set useSystemClassLoader=true in the POM so that we gets a jar with the classpath in it.
        String booterClassPath = System.getProperty("java.class.path");
        Vector pathItems = null;
        if (booterClassPath != null)
        {
            pathItems = scanPath(booterClassPath);
        }
        // Do we have just 1 entry as classpath which is a jar?
        if (pathItems != null && pathItems.size() == 1 && isJar((String) pathItems.get(0)))
        {
            classPath = loadJarManifestClassPath((String) pathItems.get(0), "META-INF/MANIFEST.MF");
        }
        return classPath;

    }

    /**
     * Load jar manifest class path.
     * 
     * @param path the path
     * @param fileName the file name
     * 
     * @return the string
     */
    private static String loadJarManifestClassPath(String path, String fileName)
    {
        File archive = new File(path);
        if (!archive.exists()) {
            return null;
        }
        ZipFile zipFile= null;

        try {
            zipFile= new ZipFile(archive);
        } catch(IOException io) {
            return null;
        }

        ZipEntry entry= zipFile.getEntry(fileName);
        if (entry == null)  {
            return null;     
        }
        try
        {
            Manifest mf = new Manifest();
            mf.read(zipFile.getInputStream(entry));

            return mf.getMainAttributes().getValue(
                    Attributes.Name.CLASS_PATH).replaceAll(" ", System.getProperty("path.separator")).replaceAll("file:/", "");
        } catch (MalformedURLException e)
        {
            LOGGER.throwing("ClassLoaderTestSuite", "loadJarManifestClassPath", e);
        } catch (IOException e)
        {
            LOGGER.throwing("ClassLoaderTestSuite", "loadJarManifestClassPath", e);
        }
        return null;
    }

    private static boolean isJar(String pathEntry)
    {
        return pathEntry.endsWith(".jar") || pathEntry.endsWith(".zip");
    }

    private static Vector scanPath(String classPath)
    {
        String separator = System.getProperty("path.separator");
        Vector pathItems = new Vector(10);
        StringTokenizer st = new StringTokenizer(classPath, separator);
        while (st.hasMoreTokens())
        {
            pathItems.addElement(st.nextToken());
        }
        return pathItems;
    }

    /**
     * Checks if is public test method.
     * 
     * @param method
     *            the method
     * 
     * @return true, if is public test method
     */
    private boolean isPublicTestMethod(Method method)
    {
        return isTestMethod(method) && Modifier.isPublic(method.getModifiers());
    }

    /**
     * Checks if is test method.
     * 
     * @param method
     *            the method
     * 
     * @return true, if is test method
     */
    private boolean isTestMethod(Method method)
    {
        String name = method.getName();
        Class[] parameters = method.getParameterTypes();
        Class returnType = method.getReturnType();
        return parameters.length == 0 && name.startsWith("test") && returnType.equals(Void.TYPE);
    }

    /**
     * Creates a Test that generates a failure with the supplied message.
     * 
     * @param message
     *            the message
     * 
     * @return the test
     */
    private static Test warning(final String message)
    {
        return new TestCase("warning")
        {
            protected void runTest()
            {
                fail(message);
            }
        };
    }

    /**
     * Exception to string.
     * 
     * @param t
     *            the t
     * 
     * @return the string
     */
    private static String exceptionToString(Throwable t)
    {
        StringWriter stringWriter = new StringWriter();
        PrintWriter writer = new PrintWriter(stringWriter);
        t.printStackTrace(writer);
        return stringWriter.toString();

    }

}