drlvm/vm/tests/kernel/java/lang/reflect/Method5Test.java - harmony - Git at Google

 /*
  *  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 java.lang.reflect;

 import java.lang.annotation.Annotation;
 import java.lang.annotation.Inherited;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;

 import org.apache.harmony.lang.AnnotatedElementTestFrame;
 import org.apache.harmony.lang.AnnotatedElementTestFrame.MissingClassValAntn;
 import org.apache.harmony.lang.AnnotatedElementTestFrame.MissingTypeAntn;
 import org.apache.harmony.lang.AnnotatedElementTestFrame.TagAntn;
 import org.apache.harmony.lang.AnnotatedElementTestFrame.ValAntn;

 /**
  * @author Alexey V. Varlamov
  */
 public class Method5Test extends AnnotatedElementTestFrame {

     protected @Override AnnotatedElement getElement1() throws Throwable {
         return AnnotatedMethod.class.getMethod("foo");
     }

     protected @Override AnnotatedElement getElement2() throws Throwable {
         return AnnotatedMethod.class.getMethod("bar");
     }

     protected @Override AnnotatedElement getElement3() throws Throwable {
         return AnnotatedMethod.class.getMethod("buz", String.class);
     }

     /**
      * Provides an instance to be tested. The instance must be annotated
      * by the notfound.MissingAntn.
      */
     protected @Override AnnotatedElement getElement4() throws Throwable {
         return AnnotatedMethod.class.getMethod("i", int.class);
     }

     /**
      * Provides an instance to be tested. The instance must be annotated
      * by the MissingClassValAntn.
      */
     protected @Override AnnotatedElement getElement5() throws Throwable {
         return AnnotatedMethod.class.getMethod("l", long.class);
     }

     /**
      * Provides an instance to be tested. The instance must be annotated
      * by the MissingTypeAntn.
      */
     protected @Override AnnotatedElement getElement6() throws Throwable {
         return AnnotatedMethod.class.getMethod("ch", char.class);
     }


     public static void main(String[] args) {
         junit.textui.TestRunner.run(Method5Test.class);
     }

     protected final Annotation[][] getParamAnnotations(Member obj) throws Throwable {
         assertTrue("illegal argument: " + obj,
                 (obj instanceof Method) || (obj instanceof Constructor));
         Method m = obj.getClass().getMethod("getParameterAnnotations");
         return (Annotation[][])m.invoke(obj);
     }

     protected Member getParamElement1() throws Throwable {
         return AnnotatedParamMethod.class.getMethod("foo");
     }

     protected Member getParamElement2() throws Throwable {
         return AnnotatedParamMethod.class.getMethod("bar",
                 Object.class, Class.class, boolean.class);
     }

     protected Member getParamElement3() throws Throwable {
         return AnnotatedParamMethod.class.getMethod("buz",
                 String.class, int.class);
     }

     /**
      * getParameterAnnotations() should return empty array
      * if member has no parameters.
      */
     public void testGetParameterAnnotations1() throws Throwable {
         Annotation[][] an = getParamAnnotations(getParamElement1());
         assertNotNull(an);
         assertEquals(0, an.length);
     }

     /**
      * getParameterAnnotations() should return array of annotation
      * arrays for member parameters, in declaration order.
      */
     public void testGetParameterAnnotations2() throws Throwable {
         Annotation[][] an = getParamAnnotations(getParamElement2());
         assertNotNull(an);
         assertEquals("param num", 3, an.length);

         assertEquals("1st param annotation num", 1, an[0].length);
         assertSame("1st param annotation type", P1Antn.class,
                 an[0][0].annotationType());

         assertEquals("2nd param annotation num", 1, an[1].length);
         assertSame("2nd param annotation type", P2Antn.class,
                 an[1][0].annotationType());
         assertEquals("2nd param annotation value", 123, ((P2Antn)an[1][0]).value());

         assertEquals("3rd param annotation num", 2, an[2].length);
         assertSame("3rd param annotation 1 type", P3Antn.class,
                 an[2][0].annotationType());
         assertSame("3rd param annotation 2 type", ValAntn.class,
                 an[2][1].annotationType());
         assertEquals("3rd param annotation 2 value", "xyz", ((ValAntn)an[2][1]).value());
     }

     /**
      * For each parameter having no annotations,
      * getParameterAnnotations() should return corresponding
      * nested arrays with zero size.
      */
     public void testGetParameterAnnotations3() throws Throwable {
         Annotation[][] an = getParamAnnotations(getParamElement3());
         assertNotNull(an);
         assertEquals("param num", 2, an.length);

         assertEquals("1st param annotation num", 0, an[0].length);

         assertEquals("2nd param annotation num", 1, an[1].length);
         assertSame("2nd param annotation type", TagAntn.class,
                 an[1][0].annotationType());
     }

     /**
      * getParameterAnnotations() should return cloned arrays
      * which can be safely modified by a caller.
      */
     public void testGetParameterAnnotationsImmutable() throws Throwable {
         Member m = getParamElement2();
         Annotation[][] an0 = getParamAnnotations(m);
         assertNotNull(an0);
         assertEquals("param num", 3, an0.length);
         an0[1] = an0[2];
         an0[1][1] = null;
         an0[2] = new Annotation[0];

         Annotation[][] an = getParamAnnotations(m);

         assertEquals("1st param annotation num", 1, an[0].length);
         assertSame("1st param annotation type", P1Antn.class,
                 an[0][0].annotationType());

         assertEquals("2nd param annotation num", 1, an[1].length);
         assertSame("2nd param annotation type", P2Antn.class,
                 an[1][0].annotationType());
         assertEquals("2nd param annotation value", 123, ((P2Antn)an[1][0]).value());

         assertEquals("3rd param annotation num", 2, an[2].length);
         assertSame("3rd param annotation 1 type", P3Antn.class,
                 an[2][0].annotationType());
         assertSame("3rd param annotation 2 type", ValAntn.class,
                 an[2][1].annotationType());
         assertEquals("3rd param annotation 2 value", "xyz", ((ValAntn)an[2][1]).value());
     }

     static class A {
         private Object obj;
         class InA {
             Object o = obj;
         }
     }

     enum E { E1, E2, E3}

     static class B1 {
         public Object foo() { return null;}
         public Object bar(int i, Object... o) { return null;}
         public static void main1(String... s){}
         public static void main2(String[] s){}
     }

     static class B2 extends B1 {
         public String foo() { return "";}
         public String bar(int i, Object... o) { return "";}
     }

     /**
      * isSynthetic() should return true if and only if
      * the target method does not appear in the source code.
      */
     public void testIsSynthetic() throws Exception {
         assertFalse("case1.1: ordinary method",
                 AnnotatedMethod.class.getMethod("foo").isSynthetic());
         assertFalse("case1.2: ordinary vararg method",
                 B1.class.getMethod("main1", String[].class).isSynthetic());

         Method[] ms = A.class.getDeclaredMethods();
         assertTrue(ms != null && ms.length > 0);
         for (Method m : ms){
             assertTrue("case2: " + m, m.isSynthetic());
         }

         // XXX bug in compiler?
         //assertTrue("case3: EnumType.values()",
           //      E.class.getMethod("values").isSynthetic());
     }

     /**
      * isBridge() should return true if and only if
      * the target method does not appear in the source code
      * and overrides covariant return type method.
      */
     public void testIsBridge() throws Exception {
         assertFalse("case1.1: ordinary method",
                 AnnotatedMethod.class.getMethod("foo").isBridge());
         assertFalse("case1.2: ordinary vararg method",
                 B1.class.getMethod("main1", String[].class).isBridge());

         Method[] ms = B1.class.getMethods();
         assertTrue(ms != null && ms.length > 0);
         for (Method m : ms){
             assertFalse("case2.1: " + m, m.isBridge());
         }

         ms = B2.class.getDeclaredMethods();
         assertTrue(ms != null && ms.length > 0);
         for (Method m : ms){
             //System.out.println("case2.2 " + m);
             assertTrue("case2.2: " + m,
                     m.getReturnType() != Object.class ^ m.isBridge());
         }

         assertFalse("case3: EnumType.values()",
                 E.class.getMethod("values").isBridge());
     }

     /**
      * isVarArgs() should return true if and only if
      * the target method is declared with varargs.
      */
     public void testIsVarargs() throws Exception {
         assertFalse("case1: ordinary method",
                 AnnotatedMethod.class.getMethod("foo").isVarArgs());

         assertTrue("case2: varargs method",
                 B1.class.getMethod("main1", String[].class).isVarArgs());

         assertFalse("case3: ordinary method",
                 B1.class.getMethod("main2", String[].class).isVarArgs());
     }

     static abstract class C {
         protected abstract <T extends Throwable>
         OneParamType<? extends T> go(T t) throws T, Error;
     }

     /**
      * toGenericString() should return a string exactly matching
      * the API specification.
      */
     public void testToGenericString() throws Exception {
         String s = C.class.getDeclaredMethod("go",
                 Throwable.class).toGenericString();
         System.out.println(s);
         assertEquals(
                 // Should method type parameter be followed by a type bound? It is unspecified.
                 // The known reference implementation doesn't do it as well:
                 //"protected abstract <T extends java.lang.Throwable>"
                 "protected abstract <T>"
                 + " java.lang.reflect.OneParamType<? extends T>"
                 + " java.lang.reflect.Method5Test$C.go(T)"
                 + " throws T,java.lang.Error",
                 s);
     }

     /**
      * toGenericString() should return a string exactly matching
      * the API specification.
      */
     public void testToGenericString2() throws Exception {
         String s = B2.class.getDeclaredMethod("bar",
                 int.class, Object[].class).toGenericString();
         // it is unspecified which method should be returned:
         // original (overriden with covariant return) or
         // compiler-generated bridge.
         // different implementations behave differently,
         // so relaxed this check to allow both variants.
         assertTrue("start: " + s, s.startsWith("public java.lang.")); // String or Object
         assertTrue("end: " + s,
                 s.endsWith(" java.lang.reflect.Method5Test$B2."
                         + "bar(int,java.lang.Object[])"));
     }
 }

 abstract class AnnotatedMethod {
     @TagAntn public abstract void foo();
     @TagAntn @ValAntn public Object[] bar() {return null;}
     public String buz(String s){return s;}
     @notfound.MissingAntn public void i(int i) {}
     @MissingClassValAntn public void l(long l){}
     @MissingTypeAntn public void ch(char ch){}
 }

 @Inherited
 @Retention(RetentionPolicy.RUNTIME)
 @interface P1Antn {}

 @Retention(RetentionPolicy.RUNTIME)
 @interface P2Antn {
     int value();
 }

 @Inherited
 @Retention(RetentionPolicy.RUNTIME)
 @interface P3Antn {
     String[] meta1() default {};
     P1Antn meta2() default @P1Antn;
 }

 class AnnotatedParamMethod {
     @TagAntn public void foo(){}
     @ValAntn("abc") public void bar(@P1Antn Object p1,
             @P2Antn(123) Class p2, @P3Antn @ValAntn("xyz") boolean p3){}
     public void buz(String s, @TagAntn int i){}
 }
	/*
	* 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 java.lang.reflect;

	import java.lang.annotation.Annotation;
	import java.lang.annotation.Inherited;
	import java.lang.annotation.Retention;
	import java.lang.annotation.RetentionPolicy;

	import org.apache.harmony.lang.AnnotatedElementTestFrame;
	import org.apache.harmony.lang.AnnotatedElementTestFrame.MissingClassValAntn;
	import org.apache.harmony.lang.AnnotatedElementTestFrame.MissingTypeAntn;
	import org.apache.harmony.lang.AnnotatedElementTestFrame.TagAntn;
	import org.apache.harmony.lang.AnnotatedElementTestFrame.ValAntn;

	/**
	* @author Alexey V. Varlamov
	*/
	public class Method5Test extends AnnotatedElementTestFrame {

	protected @Override AnnotatedElement getElement1() throws Throwable {
	return AnnotatedMethod.class.getMethod("foo");
	}

	protected @Override AnnotatedElement getElement2() throws Throwable {
	return AnnotatedMethod.class.getMethod("bar");
	}

	protected @Override AnnotatedElement getElement3() throws Throwable {
	return AnnotatedMethod.class.getMethod("buz", String.class);
	}

	/**
	* Provides an instance to be tested. The instance must be annotated
	* by the notfound.MissingAntn.
	*/
	protected @Override AnnotatedElement getElement4() throws Throwable {
	return AnnotatedMethod.class.getMethod("i", int.class);
	}

	/**
	* Provides an instance to be tested. The instance must be annotated
	* by the MissingClassValAntn.
	*/
	protected @Override AnnotatedElement getElement5() throws Throwable {
	return AnnotatedMethod.class.getMethod("l", long.class);
	}

	/**
	* Provides an instance to be tested. The instance must be annotated
	* by the MissingTypeAntn.
	*/
	protected @Override AnnotatedElement getElement6() throws Throwable {
	return AnnotatedMethod.class.getMethod("ch", char.class);
	}


	public static void main(String[] args) {
	junit.textui.TestRunner.run(Method5Test.class);
	}

	protected final Annotation[][] getParamAnnotations(Member obj) throws Throwable {
	assertTrue("illegal argument: " + obj,
	(obj instanceof Method) \|\| (obj instanceof Constructor));
	Method m = obj.getClass().getMethod("getParameterAnnotations");
	return (Annotation[][])m.invoke(obj);
	}

	protected Member getParamElement1() throws Throwable {
	return AnnotatedParamMethod.class.getMethod("foo");
	}

	protected Member getParamElement2() throws Throwable {
	return AnnotatedParamMethod.class.getMethod("bar",
	Object.class, Class.class, boolean.class);
	}

	protected Member getParamElement3() throws Throwable {
	return AnnotatedParamMethod.class.getMethod("buz",
	String.class, int.class);
	}

	/**
	* getParameterAnnotations() should return empty array
	* if member has no parameters.
	*/
	public void testGetParameterAnnotations1() throws Throwable {
	Annotation[][] an = getParamAnnotations(getParamElement1());
	assertNotNull(an);
	assertEquals(0, an.length);
	}

	/**
	* getParameterAnnotations() should return array of annotation
	* arrays for member parameters, in declaration order.
	*/
	public void testGetParameterAnnotations2() throws Throwable {
	Annotation[][] an = getParamAnnotations(getParamElement2());
	assertNotNull(an);
	assertEquals("param num", 3, an.length);

	assertEquals("1st param annotation num", 1, an[0].length);
	assertSame("1st param annotation type", P1Antn.class,
	an[0][0].annotationType());

	assertEquals("2nd param annotation num", 1, an[1].length);
	assertSame("2nd param annotation type", P2Antn.class,
	an[1][0].annotationType());
	assertEquals("2nd param annotation value", 123, ((P2Antn)an[1][0]).value());

	assertEquals("3rd param annotation num", 2, an[2].length);
	assertSame("3rd param annotation 1 type", P3Antn.class,
	an[2][0].annotationType());
	assertSame("3rd param annotation 2 type", ValAntn.class,
	an[2][1].annotationType());
	assertEquals("3rd param annotation 2 value", "xyz", ((ValAntn)an[2][1]).value());
	}

	/**
	* For each parameter having no annotations,
	* getParameterAnnotations() should return corresponding
	* nested arrays with zero size.
	*/
	public void testGetParameterAnnotations3() throws Throwable {
	Annotation[][] an = getParamAnnotations(getParamElement3());
	assertNotNull(an);
	assertEquals("param num", 2, an.length);

	assertEquals("1st param annotation num", 0, an[0].length);

	assertEquals("2nd param annotation num", 1, an[1].length);
	assertSame("2nd param annotation type", TagAntn.class,
	an[1][0].annotationType());
	}

	/**
	* getParameterAnnotations() should return cloned arrays
	* which can be safely modified by a caller.
	*/
	public void testGetParameterAnnotationsImmutable() throws Throwable {
	Member m = getParamElement2();
	Annotation[][] an0 = getParamAnnotations(m);
	assertNotNull(an0);
	assertEquals("param num", 3, an0.length);
	an0[1] = an0[2];
	an0[1][1] = null;
	an0[2] = new Annotation[0];

	Annotation[][] an = getParamAnnotations(m);

	assertEquals("1st param annotation num", 1, an[0].length);
	assertSame("1st param annotation type", P1Antn.class,
	an[0][0].annotationType());

	assertEquals("2nd param annotation num", 1, an[1].length);
	assertSame("2nd param annotation type", P2Antn.class,
	an[1][0].annotationType());
	assertEquals("2nd param annotation value", 123, ((P2Antn)an[1][0]).value());

	assertEquals("3rd param annotation num", 2, an[2].length);
	assertSame("3rd param annotation 1 type", P3Antn.class,
	an[2][0].annotationType());
	assertSame("3rd param annotation 2 type", ValAntn.class,
	an[2][1].annotationType());
	assertEquals("3rd param annotation 2 value", "xyz", ((ValAntn)an[2][1]).value());
	}

	static class A {
	private Object obj;
	class InA {
	Object o = obj;
	}
	}

	enum E { E1, E2, E3}

	static class B1 {
	public Object foo() { return null;}
	public Object bar(int i, Object... o) { return null;}
	public static void main1(String... s){}
	public static void main2(String[] s){}
	}

	static class B2 extends B1 {
	public String foo() { return "";}
	public String bar(int i, Object... o) { return "";}
	}

	/**
	* isSynthetic() should return true if and only if
	* the target method does not appear in the source code.
	*/
	public void testIsSynthetic() throws Exception {
	assertFalse("case1.1: ordinary method",
	AnnotatedMethod.class.getMethod("foo").isSynthetic());
	assertFalse("case1.2: ordinary vararg method",
	B1.class.getMethod("main1", String[].class).isSynthetic());

	Method[] ms = A.class.getDeclaredMethods();
	assertTrue(ms != null && ms.length > 0);
	for (Method m : ms){
	assertTrue("case2: " + m, m.isSynthetic());
	}

	// XXX bug in compiler?
	//assertTrue("case3: EnumType.values()",
	// E.class.getMethod("values").isSynthetic());
	}

	/**
	* isBridge() should return true if and only if
	* the target method does not appear in the source code
	* and overrides covariant return type method.
	*/
	public void testIsBridge() throws Exception {
	assertFalse("case1.1: ordinary method",
	AnnotatedMethod.class.getMethod("foo").isBridge());
	assertFalse("case1.2: ordinary vararg method",
	B1.class.getMethod("main1", String[].class).isBridge());

	Method[] ms = B1.class.getMethods();
	assertTrue(ms != null && ms.length > 0);
	for (Method m : ms){
	assertFalse("case2.1: " + m, m.isBridge());
	}

	ms = B2.class.getDeclaredMethods();
	assertTrue(ms != null && ms.length > 0);
	for (Method m : ms){
	//System.out.println("case2.2 " + m);
	assertTrue("case2.2: " + m,
	m.getReturnType() != Object.class ^ m.isBridge());
	}

	assertFalse("case3: EnumType.values()",
	E.class.getMethod("values").isBridge());
	}

	/**
	* isVarArgs() should return true if and only if
	* the target method is declared with varargs.
	*/
	public void testIsVarargs() throws Exception {
	assertFalse("case1: ordinary method",
	AnnotatedMethod.class.getMethod("foo").isVarArgs());

	assertTrue("case2: varargs method",
	B1.class.getMethod("main1", String[].class).isVarArgs());

	assertFalse("case3: ordinary method",
	B1.class.getMethod("main2", String[].class).isVarArgs());
	}

	static abstract class C {
	protected abstract <T extends Throwable>
	OneParamType<? extends T> go(T t) throws T, Error;
	}

	/**
	* toGenericString() should return a string exactly matching
	* the API specification.
	*/
	public void testToGenericString() throws Exception {
	String s = C.class.getDeclaredMethod("go",
	Throwable.class).toGenericString();
	System.out.println(s);
	assertEquals(
	// Should method type parameter be followed by a type bound? It is unspecified.
	// The known reference implementation doesn't do it as well:
	//"protected abstract <T extends java.lang.Throwable>"
	"protected abstract <T>"
	+ " java.lang.reflect.OneParamType<? extends T>"
	+ " java.lang.reflect.Method5Test$C.go(T)"
	+ " throws T,java.lang.Error",
	s);
	}

	/**
	* toGenericString() should return a string exactly matching
	* the API specification.
	*/
	public void testToGenericString2() throws Exception {
	String s = B2.class.getDeclaredMethod("bar",
	int.class, Object[].class).toGenericString();
	// it is unspecified which method should be returned:
	// original (overriden with covariant return) or
	// compiler-generated bridge.
	// different implementations behave differently,
	// so relaxed this check to allow both variants.
	assertTrue("start: " + s, s.startsWith("public java.lang.")); // String or Object
	assertTrue("end: " + s,
	s.endsWith(" java.lang.reflect.Method5Test$B2."
	+ "bar(int,java.lang.Object[])"));
	}
	}

	abstract class AnnotatedMethod {
	@TagAntn public abstract void foo();
	@TagAntn @ValAntn public Object[] bar() {return null;}
	public String buz(String s){return s;}
	@notfound.MissingAntn public void i(int i) {}
	@MissingClassValAntn public void l(long l){}
	@MissingTypeAntn public void ch(char ch){}
	}

	@Inherited
	@Retention(RetentionPolicy.RUNTIME)
	@interface P1Antn {}

	@Retention(RetentionPolicy.RUNTIME)
	@interface P2Antn {
	int value();
	}

	@Inherited
	@Retention(RetentionPolicy.RUNTIME)
	@interface P3Antn {
	String[] meta1() default {};
	P1Antn meta2() default @P1Antn;
	}

	class AnnotatedParamMethod {
	@TagAntn public void foo(){}
	@ValAntn("abc") public void bar(@P1Antn Object p1,
	@P2Antn(123) Class p2, @P3Antn @ValAntn("xyz") boolean p3){}
	public void buz(String s, @TagAntn int i){}
	}