| /* |
| * 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)); |
| } |
| } |
| } |