lang/reflect/MethodTest.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 tests.api.java.lang.reflect;

import java.lang.annotation.Annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.HashSet;
import java.util.Set;

import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargetNew;

@TestTargetClass(Method.class)
public class MethodTest extends junit.framework.TestCase {

    static class TestMethod {
        public TestMethod() {
        }

        public void voidMethod() throws IllegalArgumentException {
        }

        public void parmTest(int x, short y, String s, boolean bool, Object o,
                long l, byte b, char c, double d, float f) {
        }

        public int intMethod() {
            return 1;
        }

        public static final void printTest(int x, short y, String s,
                boolean bool, Object o, long l, byte b, char c, double d,
                float f) {
        }

        public double doubleMethod() {
            return 1.0;
        }

        public short shortMethod() {
            return (short) 1;
        }

        public byte byteMethod() {
            return (byte) 1;
        }

        public float floatMethod() {
            return 1.0f;
        }

        public long longMethod() {
            return 1l;
        }

        public char charMethod() {
            return 'T';
        }

        public Object objectMethod() {
            return new Object();
        }

        private static void prstatic() {
        }

        public static void pustatic() {
        }

        public static synchronized void pustatsynch() {
        }

        public static int invokeStaticTest() {
            return 1;
        }

        public int invokeInstanceTest() {
            return 1;
        }

        private int privateInvokeTest() {
            return 1;
        }

        public int invokeExceptionTest() throws NullPointerException {
            throw new NullPointerException();
        }

        public static synchronized native void pustatsynchnat();

        public void publicVoidVarargs(Object... param){}
        public void publicVoidArray(Object[] param){}

        public void annotatedParameter(@TestAnno @Deprecated int a,
                @Deprecated int b, int c) {
        }

        @Deprecated
        @TestAnno
        public void annotatedMethod(){}

        public void hashCodeTest(int i){}
        public void hashCodeTest(String s){}

        public void invokeCastTest1(byte param) {
        }

        public void invokeCastTest1(short param) {
        }

        public void invokeCastTest1(int param) {
        }

        public void invokeCastTest1(long param) {
        }

        public void invokeCastTest1(float param) {
        }

        public void invokeCastTest1(double param) {
        }

        public void invokeCastTest1(char param) {
        }

        public void invokeCastTest1(boolean param) {
        }
    }

    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.PARAMETER, ElementType.METHOD})
    public static @interface TestAnno{
        public static final String DEFAULT_VALUE = "DEFAULT_VALUE";

        String value() default DEFAULT_VALUE;
    }

    abstract class AbstractTestMethod {
        public abstract void puabs();
    }

    class TestMethodSub extends TestMethod {
        public int invokeInstanceTest() {
            return 0;
        }
    }

    static interface IBrigeTest<T>{
        T m();
    }

    static class BrigeTest implements IBrigeTest<String> {
        public String m(){ return null; }
    }

    static class ExceptionTest<T extends Exception>{
        @SuppressWarnings("unused")
        void exceptionTest() throws T{}
    }

    static class GenericReturnType<T> {
        T returnGeneric(){return null;}
    }

    static class GenericString<T> {
      public static final String GENERIC =
      "T tests.api.java.lang.reflect.MethodTest$GenericString.genericString(T)";
        T genericString(T t) {
            return null;
        }
    }

    /**
     * @tests java.lang.reflect.Method#equals(java.lang.Object)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "equals",
        args = {java.lang.Object.class}
    )
    public void test_equalsLjava_lang_Object() {
        // Test for method boolean
        // java.lang.reflect.Method.equals(java.lang.Object)

        Method m1 = null, m2 = null;
        try {
            m1 = TestMethod.class.getMethod("invokeInstanceTest", new Class[0]);
            m2 = TestMethodSub.class.getMethod("invokeInstanceTest",
                    new Class[0]);
        } catch (Exception e) {
            fail("Exception during equals test : " + e.getMessage());
        }
        assertTrue("Overriden method returned equal", !m1.equals(m2));
        assertTrue("Same method returned not-equal", m1.equals(m1));
        try {
            m1 = TestMethod.class.getMethod("invokeStaticTest", new Class[0]);
            m2 = TestMethodSub.class
                    .getMethod("invokeStaticTest", new Class[0]);
        } catch (Exception e) {
            fail("Exception during equals test : " + e.getMessage());
        }
        assertTrue("Inherited method returned not-equal", m1.equals(m2));
    }

    /**
     * @tests java.lang.reflect.Method#getDeclaringClass()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getDeclaringClass",
        args = {}
    )
    public void test_getDeclaringClass() {
        // Test for method java.lang.Class
        // java.lang.reflect.Method.getDeclaringClass()

        Method[] mths;

        try {
            mths = TestMethod.class.getDeclaredMethods();
            assertTrue("Returned incorrect declaring class: "
                    + mths[0].getDeclaringClass().toString(), mths[0]
                    .getDeclaringClass().equals(TestMethod.class));
        } catch (Exception e) {
            fail("Exception during getDeclaringClass test: "
                    + e.toString());
        }
    }

    /**
     * @tests java.lang.reflect.Method#getExceptionTypes()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getExceptionTypes",
        args = {}
    )
    public void test_getExceptionTypes() {
        // Test for method java.lang.Class []
        // java.lang.reflect.Method.getExceptionTypes()

        try {
            Method mth = TestMethod.class.getMethod("voidMethod", new Class[0]);
            Class[] ex = mth.getExceptionTypes();
            assertEquals("Returned incorrect number of exceptions",
                    1, ex.length);
            assertTrue("Returned incorrect exception type", ex[0]
                    .equals(IllegalArgumentException.class));
            mth = TestMethod.class.getMethod("intMethod", new Class[0]);
            ex = mth.getExceptionTypes();
            assertEquals("Returned incorrect number of exceptions",
                    0, ex.length);
        } catch (Exception e) {
            fail("Exception during getExceptionTypes: " + e.toString());
        }

    }

    /**
     * @tests java.lang.reflect.Method#getModifiers()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getModifiers",
        args = {}
    )
    public void test_getModifiers() {
        // Test for method int java.lang.reflect.Method.getModifiers()

        Class cl = TestMethod.class;
        int mods = 0;
        Method mth = null;
        int mask = 0;
        try {
            mth = cl.getMethod("pustatic", new Class[0]);
            mods = mth.getModifiers();
        } catch (Exception e) {
            fail("Exception during getModfiers test: " + e.toString());
        }
        mask = Modifier.PUBLIC | Modifier.STATIC;
        assertTrue("Incorrect modifiers returned", (mods | mask) == mask);
        try {
            mth = cl.getDeclaredMethod("prstatic", new Class[0]);
            mods = mth.getModifiers();
        } catch (Exception e) {
            fail("Exception during getModfiers test: " + e.toString());
        }
        mask = Modifier.PRIVATE | Modifier.STATIC;
        assertTrue("Incorrect modifiers returned", (mods | mask) == mask);
        try {
            mth = cl.getDeclaredMethod("pustatsynch", new Class[0]);
            mods = mth.getModifiers();
        } catch (Exception e) {
            fail("Exception during getModfiers test: " + e.toString());
        }
        mask = (Modifier.PUBLIC | Modifier.STATIC) | Modifier.SYNCHRONIZED;
        assertTrue("Incorrect modifiers returned", (mods | mask) == mask);
        try {
            mth = cl.getDeclaredMethod("pustatsynchnat", new Class[0]);
            mods = mth.getModifiers();
        } catch (Exception e) {
            fail("Exception during getModfiers test: " + e.toString());
        }
        mask = ((Modifier.PUBLIC | Modifier.STATIC) | Modifier.SYNCHRONIZED)
                | Modifier.NATIVE;
        assertTrue("Incorrect modifiers returned", (mods | mask) == mask);
        cl = AbstractTestMethod.class;
        try {
            mth = cl.getDeclaredMethod("puabs", new Class[0]);
            mods = mth.getModifiers();
        } catch (Exception e) {
            fail("Exception during getModfiers test: " + e.toString());
        }
        mask = Modifier.PUBLIC | Modifier.ABSTRACT;
        assertTrue("Incorrect modifiers returned", (mods | mask) == mask);
    }

    /**
     * @tests java.lang.reflect.Method#getName()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getName",
        args = {}
    )
    public void test_getName() {
        // Test for method java.lang.String java.lang.reflect.Method.getName()
        Method mth = null;
        try {
            mth = TestMethod.class.getMethod("voidMethod", new Class[0]);
        } catch (Exception e) {
            fail("Exception during getMethodName(): " + e.toString());
        }
        assertEquals("Returned incorrect method name",
                "voidMethod", mth.getName());
    }

    /**
     * @tests java.lang.reflect.Method#isVarArgs()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "isVarArgs",
        args = {}
    )
    public void test_isVarArgs() throws Exception {
        Method mth = TestMethod.class.getMethod("publicVoidVarargs",
                Object[].class);
        assertTrue("Varargs method stated as non vararg.", mth.isVarArgs());

        mth = TestMethod.class.getDeclaredMethod("publicVoidArray",
                Object[].class);
        assertFalse("Non varargs method stated as vararg.", mth.isVarArgs());
    }

    /**
     * @tests java.lang.reflect.Method#isBridge()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "isBridge",
        args = {}
    )
    public void test_isBridge() throws Exception {
        Method[] declaredMethods = BrigeTest.class.getDeclaredMethods();
        assertEquals("Bridge method not generated.", 2, declaredMethods.length);
        boolean foundBridgeMethod = false;
        for (Method method : declaredMethods) {
            if (method.getReturnType().equals(Object.class)) {
                assertTrue("Bridge method not stated as bridge.", method
                        .isBridge());
                foundBridgeMethod = true;
            }
        }
        assertTrue("Bridge method not found.", foundBridgeMethod);
    }

    /**
     * @tests java.lang.reflect.Method#isSynthetic()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "isSynthetic",
        args = {}
    )
    public void test_isSynthetic() throws Exception {
        Method[] declaredMethods = BrigeTest.class.getDeclaredMethods();
        assertEquals("Synthetic method not generated.", 2,
                declaredMethods.length);
        boolean foundSyntheticMethod = false;
        for (Method method : declaredMethods) {
            if (method.getReturnType().equals(Object.class)) {
                assertTrue("Synthetic method not stated as synthetic.", method
                        .isSynthetic());
                foundSyntheticMethod = true;
            }
        }
        assertTrue("Synthetic method not found.", foundSyntheticMethod);
    }
    /**
     * @tests java.lang.reflect.Method#getParameterAnnotations()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getParameterAnnotations",
        args = {}
    )
    public void test_getParameterAnnotations() throws Exception {
        Method method = TestMethod.class.getDeclaredMethod(
                "annotatedParameter", new Class[] {
                        int.class, int.class, int.class});
        Annotation[][] annotations = method.getParameterAnnotations();
        assertEquals(3, annotations.length);
        assertEquals(
                "Wrong number of annotations returned for first parameter", 2,
                annotations[0].length);
        Set<Class<?>> annotationSet = new HashSet<Class<?>>();
        annotationSet.add(annotations[0][0].annotationType());
        annotationSet.add(annotations[0][1].annotationType());
        assertTrue("Missing TestAnno annotation", annotationSet
                .contains(TestAnno.class));
        assertTrue("Missing Deprecated annotation", annotationSet
                .contains(Deprecated.class));

        assertEquals(
                "Wrong number of annotations returned for second parameter",
                1, annotations[1].length);
        annotationSet = new HashSet<Class<?>>();
        annotationSet.add(annotations[1][0].annotationType());
        assertTrue("Missing Deprecated annotation", annotationSet
                .contains(Deprecated.class));
        assertEquals(
                "Wrong number of annotations returned for third parameter", 0,
                annotations[2].length);
    }

    /**
     * @tests java.lang.reflect.Method#getDeclaredAnnotations()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getDeclaredAnnotations",
        args = {}
    )
    public void test_getDeclaredAnnotations() throws Exception {
        Method method = TestMethod.class.getDeclaredMethod("annotatedMethod");
        Annotation[] declaredAnnotations = method.getDeclaredAnnotations();
        assertEquals(2, declaredAnnotations.length);

        Set<Class<?>> annotationSet = new HashSet<Class<?>>();
        annotationSet.add(declaredAnnotations[0].annotationType());
        annotationSet.add(declaredAnnotations[1].annotationType());
        assertTrue("Missing TestAnno annotation", annotationSet
                .contains(TestAnno.class));
        assertTrue("Missing Deprecated annotation", annotationSet
                .contains(Deprecated.class));
    }

    /**
     * @tests java.lang.reflect.Method#getDefaultValue()
     */
    @TestTargetNew(
        level = TestLevel.SUFFICIENT,
        notes = "Missing tests for TypeNotPresentException",
        method = "getDefaultValue",
        args = {}
    )
    public void test_getDefaultValue() throws Exception {
        Method method = TestAnno.class.getDeclaredMethod("value");
        assertEquals("Wrong default value returned", TestAnno.DEFAULT_VALUE,
                method.getDefaultValue());
    }

    /**
     * @tests java.lang.reflect.Method#getDefaultValue()
     */
    @TestTargetNew(
        level = TestLevel.SUFFICIENT,
        notes = "Missing tests for GenericSignatureFormatError,TypeNotPresentException, MalformedParameterizedTypeException",
        method = "getGenericExceptionTypes",
        args = {}
    )
    public void test_getGenericExceptionTypes() throws Exception {
        Method method = ExceptionTest.class.getDeclaredMethod("exceptionTest");
        Type[] genericExceptionTypes = method.getGenericExceptionTypes();
        assertEquals(1, genericExceptionTypes.length);
        assertTrue(genericExceptionTypes[0] instanceof TypeVariable<?>);
        @SuppressWarnings("unchecked")
        TypeVariable<Class<ExceptionTest<?>>> tv =
            (TypeVariable<Class<ExceptionTest<?>>>) genericExceptionTypes[0];
        assertEquals("T", tv.getName());
    }

    /**
     * @tests java.lang.reflect.Method#getGenericReturnType()
     */
    @TestTargetNew(
        level = TestLevel.SUFFICIENT,
        notes = "Missing tests for GenericSignatureFormatError,TypeNotPresentException, MalformedParameterizedTypeException",
        method = "getGenericReturnType",
        args = {}
    )
    public void test_getGenericReturnType() throws Exception {
        Method method = GenericReturnType.class
                .getDeclaredMethod("returnGeneric");
        Type returnType = method.getGenericReturnType();
        assertNotNull("getGenericReturnType returned null", returnType);
        assertTrue(returnType instanceof TypeVariable<?>);
        @SuppressWarnings("unchecked")
        TypeVariable<Class<ExceptionTest<?>>> tv =
            (TypeVariable<Class<ExceptionTest<?>>>) returnType;
        assertEquals("T", tv.getName());
    }


    /**
     * @tests java.lang.reflect.Method#toGenericString()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "toGenericString",
        args = {}
    )
    public void test_toGenericString() throws Exception {
        Method method = GenericString.class.getDeclaredMethod("genericString",
                Object.class);
        assertEquals("Wrong generic String returned", GenericString.GENERIC,
                method.toGenericString());
    }


    /**
     * @tests java.lang.reflect.Method#hashCode()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "hashCode",
        args = {}
    )
    public void test_hashCode() throws Exception {
        Method mth0 = TestMethod.class.getMethod("hashCodeTest", String.class);
        Method mth1 = TestMethod.class.getDeclaredMethod("hashCodeTest",
                int.class);
        assertEquals("Methods with same name did not return same hashCode.",
                mth0.hashCode(), mth1.hashCode());
    }

    /**
     * @tests java.lang.reflect.Method#getParameterTypes()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getParameterTypes",
        args = {}
    )
    public void test_getParameterTypes() {
        // Test for method java.lang.Class []
        // java.lang.reflect.Method.getParameterTypes()
        Class cl = TestMethod.class;
        Method mth = null;
        Class[] parms = null;
        Method[] methods = null;
        Class[] plist = { int.class, short.class, String.class, boolean.class,
                Object.class, long.class, byte.class, char.class, double.class,
                float.class };
        try {
            mth = cl.getMethod("voidMethod", new Class[0]);
            parms = mth.getParameterTypes();
        } catch (Exception e) {
            fail("Exception during getParameterTypes test: "
                    + e.toString());
        }
        assertEquals("Returned incorrect parameterTypes", 0, parms.length);
        try {
            mth = cl.getMethod("parmTest", plist);
            parms = mth.getParameterTypes();
        } catch (Exception e) {
            fail("Exception during getParameterTypes test: "
                    + e.toString());
        }
        assertTrue("Invalid number of parameters returned",
                plist.length == parms.length);
        for (int i = 0; i < plist.length; i++)
            assertTrue("Incorrect parameter returned", plist[i]
                    .equals(parms[i]));

        // Test same method. but this time pull it from the list of methods
        // rather than asking for it explicitly
        methods = cl.getDeclaredMethods();

        int i;
        for (i = 0; i < methods.length; i++)
            if (methods[i].getName().equals("parmTest")) {
                mth = methods[i];
                i = methods.length + 1;
            }
        if (i < methods.length) {
            parms = mth.getParameterTypes();
            assertTrue("Incorrect number of parameters returned",
                    parms.length == plist.length);
            for (i = 0; i < plist.length; i++)
                assertTrue("Incorrect parameter returned", plist[i]
                        .equals(parms[i]));
        }
    }

    /**
     * @tests java.lang.reflect.Method#getReturnType()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getReturnType",
        args = {}
    )
    public void test_getReturnType() {
        // Test for method java.lang.Class
        // java.lang.reflect.Method.getReturnType()
        Class cl = TestMethod.class;
        Method mth = null;
        try {
            mth = cl.getMethod("charMethod", new Class[0]);
        } catch (Exception e) {
            fail("Exception during getReturnType test : " + e.getMessage());
        }
        assertTrue("Gave incorrect returne type, wanted char", mth
                .getReturnType().equals(char.class));
        try {
            mth = cl.getMethod("longMethod", new Class[0]);
        } catch (Exception e) {
            fail("Exception during getReturnType test : " + e.getMessage());
        }
        assertTrue("Gave incorrect returne type, wanted long", mth
                .getReturnType().equals(long.class));
        try {
            mth = cl.getMethod("shortMethod", new Class[0]);
        } catch (Exception e) {
            fail("Exception during getReturnType test : " + e.getMessage());
        }
        assertTrue("Gave incorrect returne type, wanted short", mth
                .getReturnType().equals(short.class));
        try {
            mth = cl.getMethod("intMethod", new Class[0]);
        } catch (Exception e) {
            fail("Exception during getReturnType test : " + e.getMessage());
        }
        assertTrue("Gave incorrect returne type, wanted int: "
                + mth.getReturnType(), mth.getReturnType().equals(int.class));
        try {
            mth = cl.getMethod("doubleMethod", new Class[0]);
        } catch (Exception e) {
            fail("Exception during getReturnType test : " + e.getMessage());
        }
        assertTrue("Gave incorrect returne type, wanted double", mth
                .getReturnType().equals(double.class));
        try {
            mth = cl.getMethod("byteMethod", new Class[0]);
        } catch (Exception e) {
            fail("Exception during getReturnType test : " + e.getMessage());
        }
        assertTrue("Gave incorrect returne type, wanted byte", mth
                .getReturnType().equals(byte.class));
        try {
            mth = cl.getMethod("byteMethod", new Class[0]);
        } catch (Exception e) {
            fail("Exception during getReturnType test:" + e.toString());
        }
        assertTrue("Gave incorrect returne type, wanted byte", mth
                .getReturnType().equals(byte.class));
        try {
            mth = cl.getMethod("objectMethod", new Class[0]);
        } catch (Exception e) {
            fail("Exception during getReturnType test : " + e.getMessage());
        }
        assertTrue("Gave incorrect returne type, wanted Object", mth
                .getReturnType().equals(Object.class));

        try {
            mth = cl.getMethod("voidMethod", new Class[0]);
        } catch (Exception e) {
            fail("Exception during getReturnType test : " + e.getMessage());
        }
        assertTrue("Gave incorrect returne type, wanted void", mth
                .getReturnType().equals(void.class));
    }

    /**
     * @tests java.lang.reflect.Method#invoke(java.lang.Object,
     *        java.lang.Object[])
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "invoke",
        args = {java.lang.Object.class, java.lang.Object[].class}
    )
    public void test_invokeLjava_lang_Object$Ljava_lang_Object() throws Exception{
        // Test for method java.lang.Object
        // java.lang.reflect.Method.invoke(java.lang.Object, java.lang.Object
        // [])
        Class cl = TestMethod.class;
        Class[] dcl = new Class[0];

        // Get and invoke a static method
        Method mth = cl.getDeclaredMethod("invokeStaticTest", dcl);
        Object ret = mth.invoke(null, new Object[0]);
        assertEquals("Invoke returned incorrect value", 1, ((Integer) ret)
                .intValue());

        // Get and invoke an instance method
        mth = cl.getDeclaredMethod("invokeInstanceTest", dcl);
        ret = mth.invoke(new TestMethod(), new Object[0]);
        assertEquals("Invoke returned incorrect value", 1, ((Integer) ret)
                .intValue());

        // Get and attempt to invoke a private method
        mth = cl.getDeclaredMethod("privateInvokeTest", dcl);
        try {
            ret = mth.invoke(new TestMethod(), new Object[0]);
        } catch (IllegalAccessException e) {
            // Correct behaviour
        } catch (Exception e) {
            fail("Exception during invoke test : " + e.getMessage());
        }
        // Generate an IllegalArgumentException
        mth = cl.getDeclaredMethod("invokeInstanceTest", dcl);

        try {
            Object[] args = { Object.class };
            ret = mth.invoke(new TestMethod(), args);
        } catch (IllegalArgumentException e) {
            // Correct behaviour
        } catch (Exception e) {
            fail("Exception during invoke test : " + e.getMessage());
        }

        // Generate a NullPointerException
        mth = cl.getDeclaredMethod("invokeInstanceTest", dcl);

        try {
            ret = mth.invoke(null, new Object[0]);
        } catch (NullPointerException e) {
            // Correct behaviour
        } catch (Exception e) {
            fail("Exception during invoke test : " + e.getMessage());
        }

        // Generate an InvocationTargetException
        mth = cl.getDeclaredMethod("invokeExceptionTest", dcl);
        try {
            ret = mth.invoke(new TestMethod(), new Object[0]);
        } catch (InvocationTargetException e) {
            // Correct behaviour
        } catch (Exception e) {
            fail("Exception during invoke test : " + e.getMessage());
        }

        TestMethod testMethod = new TestMethod();
        Method methods[] = cl.getMethods();
        for (int i = 0; i < methods.length; i++) {
            if (methods[i].getName().startsWith("invokeCastTest1")) {
                Class param = methods[i].getParameterTypes()[0];

                try {
                    methods[i].invoke(testMethod, new Object[] { new Byte(
                            (byte) 1) });
                    assertTrue("invalid invoke with Byte: " + methods[i],
                            param == Byte.TYPE || param == Short.TYPE
                                    || param == Integer.TYPE
                                    || param == Long.TYPE
                                    || param == Float.TYPE
                                    || param == Double.TYPE);
                } catch (Exception e) {
                    assertTrue("Byte invalid exception: " + e,
                            e instanceof IllegalArgumentException);
                    assertTrue("Byte invalid failure: " + methods[i],
                            param == Boolean.TYPE || param == Character.TYPE);
                }

                try {
                    methods[i].invoke(testMethod, new Object[] { new Short(
                            (short) 1) });
                    assertTrue("invalid invoke with Short: " + methods[i],
                            param == Short.TYPE || param == Integer.TYPE
                                    || param == Long.TYPE
                                    || param == Float.TYPE
                                    || param == Double.TYPE);
                } catch (Exception e) {
                    assertTrue("Short invalid exception: " + e,
                            e instanceof IllegalArgumentException);
                    assertTrue("Short invalid failure: " + methods[i],
                            param == Byte.TYPE || param == Boolean.TYPE
                                    || param == Character.TYPE);
                }

                try {
                    methods[i].invoke(testMethod,
                            new Object[] { new Integer(1) });
                    assertTrue("invalid invoke with Integer: " + methods[i],
                            param == Integer.TYPE || param == Long.TYPE
                                    || param == Float.TYPE
                                    || param == Double.TYPE);
                } catch (Exception e) {
                    assertTrue("Integer invalid exception: " + e,
                            e instanceof IllegalArgumentException);
                    assertTrue("Integer invalid failure: " + methods[i],
                            param == Byte.TYPE || param == Short.TYPE
                                    || param == Boolean.TYPE
                                    || param == Character.TYPE);
                }

                try {
                    methods[i].invoke(testMethod, new Object[] { new Long(1) });
                    assertTrue("invalid invoke with Long: " + methods[i],
                            param == Long.TYPE || param == Float.TYPE
                                    || param == Double.TYPE);
                } catch (Exception e) {
                    assertTrue("Long invalid exception: " + e,
                            e instanceof IllegalArgumentException);
                    assertTrue("Long invalid failure: " + methods[i],
                            param == Byte.TYPE || param == Short.TYPE
                                    || param == Integer.TYPE
                                    || param == Boolean.TYPE
                                    || param == Character.TYPE);
                }

                try {
                    methods[i].invoke(testMethod, new Object[] { new Character(
                            'a') });
                    assertTrue("invalid invoke with Character: " + methods[i],
                            param == Character.TYPE || param == Integer.TYPE
                                    || param == Long.TYPE
                                    || param == Float.TYPE
                                    || param == Double.TYPE);
                } catch (Exception e) {
                    assertTrue("Character invalid exception: " + e,
                            e instanceof IllegalArgumentException);
                    assertTrue("Character invalid failure: " + methods[i],
                            param == Byte.TYPE || param == Short.TYPE
                                    || param == Boolean.TYPE);
                }

                try {
                    methods[i]
                            .invoke(testMethod, new Object[] { new Float(1) });
                    assertTrue("invalid invoke with Float: " + methods[i],
                            param == Float.TYPE || param == Double.TYPE);
                } catch (Exception e) {
                    assertTrue("Float invalid exception: " + e,
                            e instanceof IllegalArgumentException);
                    assertTrue("Float invalid failure: " + methods[i],
                            param == Byte.TYPE || param == Short.TYPE
                                    || param == Integer.TYPE
                                    || param == Long.TYPE
                                    || param == Boolean.TYPE
                                    || param == Character.TYPE);
                }

                try {
                    methods[i].invoke(testMethod,
                            new Object[] { new Double(1) });
                    assertTrue("invalid invoke with Double: " + methods[i],
                            param == Double.TYPE);
                } catch (Exception e) {
                    assertTrue("Double invalid exception: " + e,
                            e instanceof IllegalArgumentException);
                    assertTrue("Double invalid failure: " + methods[i],
                            param == Byte.TYPE || param == Short.TYPE
                                    || param == Integer.TYPE
                                    || param == Long.TYPE
                                    || param == Boolean.TYPE
                                    || param == Character.TYPE
                                    || param == Float.TYPE);
                }

                try {
                    methods[i].invoke(testMethod, new Object[] { new Boolean(
                            true) });
                    assertTrue("invalid invoke with Boolean: " + methods[i],
                            param == Boolean.TYPE);
                } catch (Exception e) {
                    assertTrue("Boolean invalid exception: " + e,
                            e instanceof IllegalArgumentException);
                    assertTrue("Boolean invalid failure: " + methods[i],
                            param == Byte.TYPE || param == Short.TYPE
                                    || param == Integer.TYPE
                                    || param == Long.TYPE
                                    || param == Character.TYPE
                                    || param == Float.TYPE
                                    || param == Double.TYPE);
                }
            }
        }
    }

    /**
     * @tests java.lang.reflect.Method#toString()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "toString",
        args = {}
    )
    public void test_toString() {
        // Test for method java.lang.String java.lang.reflect.Method.toString()
        Method mth = null;
        Class[] parms = { int.class, short.class, String.class, boolean.class,
                Object.class, long.class, byte.class, char.class, double.class,
                float.class };
        try {

            mth = TestMethod.class.getDeclaredMethod("printTest", parms);
        } catch (Exception e) {
            fail("Exception during toString test : " + e.getMessage());
        }

        assertTrue(
                "Returned incorrect string for method: " + mth.toString(),
                mth
                        .toString()
                        .equals(
                                "public static final void tests.api.java.lang.reflect.MethodTest$TestMethod.printTest(int,short,java.lang.String,boolean,java.lang.Object,long,byte,char,double,float)"));
    }

    /**
     * Sets up the fixture, for example, open a network connection. This method
     * is called before a test is executed.
     */
    protected void setUp() {
    }

    /**
     * Tears down the fixture, for example, close a network connection. This
     * method is called after a test is executed.
     */
    protected void tearDown() {
    }
}