/atlassian-plugins-core/src/test/java/com/atlassian/plugin/util/TestClassUtils.java

package com.atlassian.plugin.util;

import junit.framework.TestCase;

import java.io.IOException;
import java.io.Serializable;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.AbstractCollection;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.List;
import java.util.RandomAccess;

import static com.google.common.collect.Sets.newHashSet;
import static java.util.Arrays.asList;
import static java.util.Collections.singletonList;

/**
 *
 */
public class TestClassUtils extends TestCase {
    public void testFindAllTypes() {
        assertEquals(newHashSet(
                List.class,
                AbstractList.class,
                Cloneable.class,
                RandomAccess.class,
                AbstractCollection.class,
                Iterable.class,
                Collection.class,
                ArrayList.class,
                Object.class,
                Serializable.class
        ), ClassUtils.findAllTypes(ArrayList.class));
    }

    public void testGetTypeArguments() {
        assertEquals(asList(String.class), ClassUtils.getTypeArguments(BaseClass.class, Child.class));

        assertEquals(asList(String.class), ClassUtils.getTypeArguments(BaseClass.class, Baby.class));

        assertEquals(singletonList(null), ClassUtils.getTypeArguments(BaseClass.class, ForgotType.class));
    }

    public void testGetTypeArgumentsDifferentClassloader() throws Exception {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        try {
            URL log4jUrl = getClass().getClassLoader().getResource("log4j.properties");
            URL root = new URL(new URL(log4jUrl.toExternalForm()), ".");

            URLClassLoader urlCl = new URLClassLoader(new URL[]{root}, new FilteredClassLoader(MySuperClass.class));
            ClosableClassLoader wrapCl = new ClosableClassLoader(getClass().getClassLoader());

            Thread.currentThread().setContextClassLoader(null);
            Class<?> module = ClassUtils.getTypeArguments((Class<Object>) urlCl.loadClass(MySuperClass.class.getName()),
                    (Class<? extends MySuperClass>) urlCl.loadClass(MySubClass.class.getName())).get(0);
            assertEquals(MyModule.class.getName(), module.getName());

            ClassLoader urlCl2 = new URLClassLoader(new URL[]{root}, new FilteredClassLoader(MySuperClass.class));
            assertTrue(wrapCl.loadClass(MySuperClass.class.getName()) == urlCl2.loadClass(MySuperClass.class.getName()));
            assertTrue(wrapCl.loadClass(MySubClass.class.getName()) != urlCl2.loadClass(MySubClass.class.getName()));
            assertTrue(wrapCl.loadClass(MySubClass.class.getName()).getSuperclass() == urlCl2.loadClass(MySubClass.class.getName()).getSuperclass());

            wrapCl.setClosed(true);
            //Thread.currentThread().setContextClassLoader(urlCl2);
            Class<?> module2 = ClassUtils.getTypeArguments((Class<Object>) urlCl2.loadClass(MySuperClass.class.getName()),
                    (Class<? extends MySuperClass>) urlCl2.loadClass(MySubClass.class.getName())).get(0);
            assertEquals(MyModule.class.getName(), module2.getName());
            assertTrue(module != module2);
            assertTrue(module != MyModule.class);
            assertTrue(module2 != MyModule.class);
        } finally {
            Thread.currentThread().setContextClassLoader(cl);
        }
    }

    public void testGetTypeArgumentsChildNotSubclass() {
        Class fakeChild = BaseClass.class;
        try {
            assertEquals(singletonList(null), ClassUtils.getTypeArguments(Baby.class, (Class<? extends Baby>) fakeChild));
            fail("Should have failed");
        } catch (IllegalArgumentException ex) {
            // this is good
        }
    }

    private static class BaseClass<T> {
    }

    private static class Child extends BaseClass<String> {
    }

    private static class ForgotType extends BaseClass {
    }

    private static class Mom<T> extends BaseClass<T> {
    }

    private static class Baby extends Mom<String> {
    }

    private static class ClosableClassLoader extends ClassLoader {
        private final ClassLoader delegate;
        private volatile boolean closed;

        public ClosableClassLoader(ClassLoader delegate) {
            super(null);
            this.delegate = delegate;
        }

        @Override
        public Class<?> loadClass(String name)
                throws ClassNotFoundException {
            checkClosed();
            return delegate.loadClass(name);
        }

        @Override
        public Class<?> loadClass(String name, boolean resolve)
                throws ClassNotFoundException {
            checkClosed();
            return delegate.loadClass(name);
        }

        private void checkClosed() {
            if (closed) {
                throw new IllegalStateException("Closed");
            }
        }

        @Override
        public URL getResource(String name) {
            checkClosed();
            return delegate.getResource(name);
        }

        @Override
        public Enumeration<URL> getResources(String name)
                throws IOException {
            checkClosed();
            return delegate.getResources(name);
        }

        public void setClosed(boolean closed) {
            this.closed = closed;
        }
    }

    private static class FilteredClassLoader extends ClassLoader {
        private final Collection<Class> classes;

        public FilteredClassLoader(Class... classes) {
            super(null);
            this.classes = asList(classes);
        }

        @Override
        public Class<?> loadClass(String name, boolean resolve)
                throws ClassNotFoundException {
            for (Class cls : classes) {
                if (cls.getName().equals(name)) {
                    return cls;
                }
            }
            if (name.startsWith("java.")) {
                return ClassLoader.getSystemClassLoader().loadClass(name);
            }
            throw new ClassNotFoundException(name);
        }
    }
}