Java example source code file (TestProvider.java)

This example Java source code file (TestProvider.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

class, classloader, classnotfoundexception, failed, invocation, list, malformedurlexception, method, net, network, object, reflection, runtimeexception, string, test, testprovider, url, util

The TestProvider.java Java example source code

/*
 * Copyright (c) 2001, 2004, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 *
 */

import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import java.rmi.server.RMIClassLoader;
import java.rmi.server.RMIClassLoaderSpi;

public class TestProvider extends RMIClassLoaderSpi {

    public static final Method loadClassMethod;
    public static final Method loadProxyClassMethod;
    public static final Method getClassLoaderMethod;
    public static final Method getClassAnnotationMethod;
    static {
        try {
            loadClassMethod = RMIClassLoaderSpi.class.getMethod(
                "loadClass", new Class[] {
                    String.class, String.class, ClassLoader.class
                });
            loadProxyClassMethod = RMIClassLoaderSpi.class.getMethod(
                "loadProxyClass", new Class[] {
                    String.class, String[].class, ClassLoader.class
                });
            getClassLoaderMethod = RMIClassLoaderSpi.class.getMethod(
                "getClassLoader", new Class[] { String.class });
            getClassAnnotationMethod = RMIClassLoaderSpi.class.getMethod(
                "getClassAnnotation", new Class[] { Class.class });
        } catch (NoSuchMethodException e) {
            Error error = new NoSuchMethodError();
            error.initCause(e);
            throw error;
        }
    }

    public static final Class loadClassReturn =
        (new Object() { }).getClass();
    public static final Class loadProxyClassReturn =
        (new Object() { }).getClass();
    public static final ClassLoader getClassLoaderReturn =
        URLClassLoader.newInstance(new URL[0]);
    public static final String getClassAnnotationReturn = new String();

    public static List invocations =
        Collections.synchronizedList(new ArrayList(1));

    public TestProvider() {
        System.err.println("TestProvider()");
    }

    public Class loadClass(String codebase, String name,
                           ClassLoader defaultLoader)
        throws MalformedURLException, ClassNotFoundException
    {
        invocations.add(new Invocation(loadClassMethod,
            new Object[] { codebase, name, defaultLoader }));

        return loadClassReturn;
    }

    public Class loadProxyClass(String codebase, String[] interfaces,
                                ClassLoader defaultLoader)
        throws MalformedURLException, ClassNotFoundException
    {
        invocations.add(new Invocation(loadProxyClassMethod,
            new Object[] { codebase, interfaces, defaultLoader }));

        return loadProxyClassReturn;
    }

    public ClassLoader getClassLoader(String codebase)
        throws MalformedURLException
    {
        invocations.add(new Invocation(
            getClassLoaderMethod, new Object[] { codebase }));

        return getClassLoaderReturn;
    }

    public String getClassAnnotation(Class<?> cl) {
        invocations.add(new Invocation(
            getClassAnnotationMethod, new Object[] { cl }));

        return getClassAnnotationReturn;
    }

    public static class Invocation {
        public Method method;
        public Object[] args;

        public Invocation(Method method, Object[] args) {
            this.method = method;
            this.args = (Object[]) args.clone();
        }
    }

    public static void exerciseTestProvider(Object loadClassReturn,
                                            Object loadProxyClassReturn,
                                            Object getClassLoaderReturn,
                                            Object getClassAnnotationReturn,
                                            List invocationQueue)
        throws MalformedURLException, ClassNotFoundException
    {
        URL codebaseURL = new URL("http://the-black-lodge/dale-cooper/");
        String codebase = codebaseURL.toString();
        String classname = "Foo";
        ClassLoader defaultLoader = URLClassLoader.newInstance(new URL[0]);
        String[] interfaces = new String[] { "Bar", "Baz" };
        Class dummyClass = (new Object() { }).getClass();

        TestLibrary.suggestSecurityManager(null);

        String testcase;
        Object ret;

        /*
         *
         */
        testcase = "RMIClassLoader.loadClass(String)";
        System.err.println("testing " + testcase);

        ret = RMIClassLoader.loadClass(classname);
        if (ret != loadClassReturn) {
             throw new RuntimeException("TEST FAILED: " +
                testcase + " returned " + ret);
        }
        verifyOneInvocation(TestProvider.loadClassMethod,
            new Object[] { null, classname, null }, invocationQueue);

        /*
         *
         */
        testcase = "RMIClassLoader.loadClass(URL,String)";
        System.err.println("testing " + testcase);

        ret = RMIClassLoader.loadClass(codebaseURL, classname);
        if (ret != loadClassReturn) {
             throw new RuntimeException("TEST FAILED: " +
                testcase + " returned " + ret);
        }
        verifyOneInvocation(TestProvider.loadClassMethod,
            new Object[] { codebase, classname, null }, invocationQueue);

        /*
         *
         */
        testcase = "RMIClassLoader.loadClass(String,String)";
        System.err.println("testing " + testcase);

        ret = RMIClassLoader.loadClass(codebase, classname);
        if (ret != loadClassReturn) {
             throw new RuntimeException("TEST FAILED: " +
                testcase + " returned " + ret);
        }
        verifyOneInvocation(TestProvider.loadClassMethod,
            new Object[] { codebase, classname, null }, invocationQueue);

        /*
         *
         */
        testcase = "RMIClassLoader.loadClass(String,String,ClassLoader";
        System.err.println("testing " + testcase);

        ret = RMIClassLoader.loadClass(codebase, classname, defaultLoader);
        if (ret != loadClassReturn) {
             throw new RuntimeException("TEST FAILED: " +
                testcase + " returned " + ret);
        }
        verifyOneInvocation(TestProvider.loadClassMethod,
            new Object[] { codebase, classname, defaultLoader },
            invocationQueue);

        /*
         *
         */
        testcase =
            "RMIClassLoader.loadProxyClass(String,String[],ClassLoader)";
        System.err.println("testing " + testcase);

        ret = RMIClassLoader.loadProxyClass(codebase, interfaces,
                                            defaultLoader);
        if (ret != loadProxyClassReturn) {
            throw new RuntimeException("TEST FAILED: " +
                testcase + " returned " + ret);
        }
        verifyOneInvocation(TestProvider.loadProxyClassMethod,
            new Object[] { codebase, interfaces, defaultLoader },
            invocationQueue);

        /*
         *
         */
        testcase = "RMIClassLoader.getClassLoader(String)";
        System.err.println("testing " + testcase);

        ret = RMIClassLoader.getClassLoader(codebase);
        if (ret != getClassLoaderReturn) {
            throw new RuntimeException("TEST FAILED: " +
                testcase + " returned " + ret);
        }
        verifyOneInvocation(TestProvider.getClassLoaderMethod,
            new Object[] { codebase }, invocationQueue);

        /*
         *
         */
        testcase = "RMIClassLoader.getClassAnnotation(Class)";
        System.err.println("testing " + testcase);

        ret = RMIClassLoader.getClassAnnotation(dummyClass);
        if (ret != getClassAnnotationReturn) {
            throw new RuntimeException("TEST FAILED: " +
                testcase + " returned " + ret);
        }
        verifyOneInvocation(TestProvider.getClassAnnotationMethod,
            new Object[] { dummyClass }, invocationQueue);

        System.err.println("TEST PASSED");
    }

    private static void verifyOneInvocation(Method method, Object[] args,
                                            List invocationQueue)
    {
        TestProvider.Invocation inv =
            (TestProvider.Invocation) invocationQueue.remove(0);

        if (!method.equals(inv.method)) {
            throw new RuntimeException(
                "unexpected provider method invoked: expected " + method +
                ", detected " + inv.method);
        }

        List expectedArgs = Arrays.asList(args);
        List detectedArgs = Arrays.asList(inv.args);
        if (!expectedArgs.equals(detectedArgs)) {
            throw new RuntimeException("TEST FAILED: " +
                "unexpected provider method invocation arguments: " +
                "expected " + expectedArgs + ", detected " + detectedArgs);
        }

        if (!invocationQueue.isEmpty()) {
            inv = (TestProvider.Invocation)
                invocationQueue.remove(0);
            throw new RuntimeException("TEST FAILED: " +
                "unexpected provider invocation: " + inv.method + " " +
                Arrays.asList(inv.args));
        }
    }
}