| /* |
| * 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.Inherited; |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.RetentionPolicy; |
| import java.lang.annotation.Target; |
| import java.lang.reflect.AccessibleObject; |
| import java.lang.reflect.Modifier; |
| import java.util.HashSet; |
| import java.util.Set; |
| |
| public class AccessibleObjectTest extends junit.framework.TestCase { |
| |
| public class TestClass { |
| public Object aField; |
| |
| @InheritedRuntime |
| public void annotatedMethod(){} |
| } |
| |
| public class SubTestClass extends TestClass{ |
| @AnnotationRuntime0 |
| @AnnotationRuntime1 |
| @AnnotationClass0 |
| @AnnotationSource0 |
| public void annotatedMethod(){} |
| } |
| |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Target( {ElementType.METHOD}) |
| static @interface AnnotationRuntime0 { |
| } |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Target( { ElementType.METHOD}) |
| static @interface AnnotationRuntime1 { |
| } |
| |
| @Retention(RetentionPolicy.CLASS) |
| @Target( { ElementType.METHOD}) |
| static @interface AnnotationClass0 { |
| } |
| |
| @Retention(RetentionPolicy.SOURCE) |
| @Target( {ElementType.METHOD}) |
| static @interface AnnotationSource0 { |
| } |
| |
| @Inherited |
| @Retention(RetentionPolicy.RUNTIME) |
| @Target( {ElementType.METHOD}) |
| static @interface InheritedRuntime { |
| } |
| |
| //used for constructor test |
| private static class MyAccessibleObject extends AccessibleObject{ |
| public MyAccessibleObject() { |
| super(); |
| } |
| } |
| |
| /** |
| * java.lang.reflect.AccessibleObject#AccessibleObject() |
| */ |
| public void test_Constructor() { |
| assertNotNull(new MyAccessibleObject()); |
| } |
| |
| /** |
| * java.lang.reflect.AccessibleObject#isAccessible() |
| */ |
| public void test_isAccessible() { |
| // Test for method boolean |
| // java.lang.reflect.AccessibleObject.isAccessible() |
| try { |
| AccessibleObject ao = TestClass.class.getField("aField"); |
| ao.setAccessible(true); |
| assertTrue("Returned false to isAccessible", ao.isAccessible()); |
| ao.setAccessible(false); |
| assertTrue("Returned true to isAccessible", !ao.isAccessible()); |
| } catch (Exception e) { |
| fail("Exception during test : " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * java.lang.reflect.AccessibleObject#setAccessible(java.lang.reflect.AccessibleObject[], |
| * boolean) |
| */ |
| public void test_setAccessible$Ljava_lang_reflect_AccessibleObjectZ() { |
| try { |
| AccessibleObject ao = TestClass.class.getField("aField"); |
| AccessibleObject[] aoa = new AccessibleObject[] { ao }; |
| AccessibleObject.setAccessible(aoa, true); |
| assertTrue("Returned false to isAccessible", ao.isAccessible()); |
| AccessibleObject.setAccessible(aoa, false); |
| assertTrue("Returned true to isAccessible", !ao.isAccessible()); |
| } catch (Exception e) { |
| fail("Exception during test : " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * java.lang.reflect.AccessibleObject#setAccessible(boolean) |
| */ |
| public void test_setAccessible() throws Exception { |
| AccessibleObject ao = TestClass.class.getField("aField"); |
| ao.setAccessible(true); |
| assertTrue("Returned false to isAccessible", ao.isAccessible()); |
| ao.setAccessible(false); |
| assertFalse("Returned true to isAccessible", ao.isAccessible()); |
| } |
| |
| public void test_getAnnotation() throws Exception{ |
| AccessibleObject ao = SubTestClass.class.getMethod("annotatedMethod"); |
| //test error case |
| boolean npeThrown = false; |
| try { |
| ao.getAnnotation(null); |
| fail("NPE expected"); |
| } catch (NullPointerException e) { |
| npeThrown = true; |
| } |
| assertTrue("NPE expected", npeThrown); |
| |
| //test inherited on method has no effect |
| InheritedRuntime ir = ao.getAnnotation(InheritedRuntime.class); |
| assertNull("Inherited Annotations should have no effect", ir); |
| |
| //test ordinary runtime annotation |
| AnnotationRuntime0 rt0 = ao.getAnnotation(AnnotationRuntime0.class); |
| assertNotNull("AnnotationRuntime0 instance expected", rt0); |
| } |
| |
| public void test_getAnnotations() throws Exception { |
| AccessibleObject ao = SubTestClass.class.getMethod("annotatedMethod"); |
| Annotation[] annotations = ao.getAnnotations(); |
| assertEquals(2, annotations.length); |
| |
| Set<Class<?>> ignoreOrder = new HashSet<Class<?>>(); |
| ignoreOrder.add(annotations[0].annotationType()); |
| ignoreOrder.add(annotations[1].annotationType()); |
| |
| assertTrue("Missing @AnnotationRuntime0", |
| ignoreOrder.contains(AnnotationRuntime0.class)); |
| assertTrue("Missing @AnnotationRuntime1", |
| ignoreOrder.contains(AnnotationRuntime1.class)); |
| } |
| |
| public void test_getDeclaredAnnotations() throws Exception { |
| AccessibleObject ao = SubTestClass.class.getMethod("annotatedMethod"); |
| Annotation[] annotations = ao.getDeclaredAnnotations(); |
| assertEquals(2, annotations.length); |
| |
| Set<Class<?>> ignoreOrder = new HashSet<Class<?>>(); |
| ignoreOrder.add(annotations[0].annotationType()); |
| ignoreOrder.add(annotations[1].annotationType()); |
| |
| assertTrue("Missing @AnnotationRuntime0", |
| ignoreOrder.contains(AnnotationRuntime0.class)); |
| assertTrue("Missing @AnnotationRuntime1", |
| ignoreOrder.contains(AnnotationRuntime1.class)); |
| } |
| |
| public void test_isAnnotationPresent() throws Exception { |
| AccessibleObject ao = SubTestClass.class.getMethod("annotatedMethod"); |
| assertTrue("Missing @AnnotationRuntime0", |
| ao.isAnnotationPresent(AnnotationRuntime0.class)); |
| assertFalse("AnnotationSource0 should not be visible at runtime", |
| ao.isAnnotationPresent(AnnotationSource0.class)); |
| boolean npeThrown = false; |
| try { |
| ao.isAnnotationPresent(null); |
| fail("NPE expected"); |
| } catch (NullPointerException e) { |
| npeThrown = true; |
| } |
| assertTrue("NPE expected", npeThrown); |
| } |
| |
| |
| /** |
| * 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() { |
| } |
| } |