mirror of
https://gitee.com/chinabugotech/hutool.git
synced 2025-07-21 15:09:48 +08:00
!803 【6.x】添加AnnotatedElementUtil工具类
Merge pull request !803 from Createsequence/feat-annotation
This commit is contained in:
Looly
Gitee
@@ -0,0 +1,480 @@
|
||||
package cn.hutool.core.annotation;
|
||||
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.lang.annotation.*;
|
||||
import java.lang.reflect.AnnotatedElement;
|
||||
import java.util.Map;
|
||||
import java.util.function.Function;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
/**
|
||||
* test for {@link AnnotatedElementUtil}
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class AnnotatedElementUtilTest {
|
||||
|
||||
private final static Annotation3 ANNOTATION3 = Foo.class.getAnnotation(Annotation3.class); // Foo.class's annotations
|
||||
private final static Annotation2 ANNOTATION2 = Annotation3.class.getAnnotation(Annotation2.class);
|
||||
private final static Annotation1 ANNOTATION1 = Annotation2.class.getAnnotation(Annotation1.class);
|
||||
|
||||
private final static Annotation4 ANNOTATION4 = Super.class.getAnnotation(Annotation4.class); // Super.class's annotations
|
||||
|
||||
private final static Annotation6 ANNOTATION6 = Interface.class.getAnnotation(Annotation6.class); // Interface.class's annotations
|
||||
private final static Annotation5 ANNOTATION5 = Annotation6.class.getAnnotation(Annotation5.class);
|
||||
|
||||
private final static Annotation[] DECLARED_ANNOTATIONS = new Annotation[]{
|
||||
ANNOTATION3, // Foo.class's annotations
|
||||
ANNOTATION4, // Super.class's annotations
|
||||
ANNOTATION6 // Interface.class's annotations
|
||||
};
|
||||
private final static Annotation[] ANNOTATIONS = new Annotation[]{
|
||||
ANNOTATION3, ANNOTATION2, ANNOTATION1, // Foo.class's annotations
|
||||
ANNOTATION4, // Super.class's annotations
|
||||
ANNOTATION6, ANNOTATION5 // Interface.class's annotations
|
||||
};
|
||||
|
||||
@Test
|
||||
public void testIsAnnotated() {
|
||||
Assert.assertTrue(AnnotatedElementUtil.isAnnotated(Foo.class, Annotation1.class));
|
||||
Assert.assertTrue(AnnotatedElementUtil.isAnnotated(Foo.class, Annotation2.class));
|
||||
Assert.assertTrue(AnnotatedElementUtil.isAnnotated(Foo.class, Annotation3.class));
|
||||
Assert.assertTrue(AnnotatedElementUtil.isAnnotated(Foo.class, Annotation4.class));
|
||||
Assert.assertTrue(AnnotatedElementUtil.isAnnotated(Foo.class, Annotation5.class));
|
||||
Assert.assertTrue(AnnotatedElementUtil.isAnnotated(Foo.class, Annotation6.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindAnnotation() {
|
||||
Assert.assertEquals(ANNOTATION1, AnnotatedElementUtil.findAnnotation(Foo.class, Annotation1.class));
|
||||
Assert.assertEquals(ANNOTATION2, AnnotatedElementUtil.findAnnotation(Foo.class, Annotation2.class));
|
||||
Assert.assertEquals(ANNOTATION3, AnnotatedElementUtil.findAnnotation(Foo.class, Annotation3.class));
|
||||
Assert.assertEquals(ANNOTATION4, AnnotatedElementUtil.findAnnotation(Foo.class, Annotation4.class));
|
||||
Assert.assertEquals(ANNOTATION5, AnnotatedElementUtil.findAnnotation(Foo.class, Annotation5.class));
|
||||
Assert.assertEquals(ANNOTATION6, AnnotatedElementUtil.findAnnotation(Foo.class, Annotation6.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindAllAnnotations() {
|
||||
Assert.assertArrayEquals(new Annotation[]{ANNOTATION1}, AnnotatedElementUtil.findAllAnnotations(Foo.class, Annotation1.class));
|
||||
Assert.assertArrayEquals(new Annotation[]{ANNOTATION2}, AnnotatedElementUtil.findAllAnnotations(Foo.class, Annotation2.class));
|
||||
Assert.assertArrayEquals(new Annotation[]{ANNOTATION3}, AnnotatedElementUtil.findAllAnnotations(Foo.class, Annotation3.class));
|
||||
Assert.assertArrayEquals(new Annotation[]{ANNOTATION4}, AnnotatedElementUtil.findAllAnnotations(Foo.class, Annotation4.class));
|
||||
Assert.assertArrayEquals(new Annotation[]{ANNOTATION5}, AnnotatedElementUtil.findAllAnnotations(Foo.class, Annotation5.class));
|
||||
Assert.assertArrayEquals(new Annotation[]{ANNOTATION6}, AnnotatedElementUtil.findAllAnnotations(Foo.class, Annotation6.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindAnnotations() {
|
||||
Annotation[] annotations = AnnotatedElementUtil.findAnnotations(Foo.class);
|
||||
Assert.assertArrayEquals(ANNOTATIONS, annotations);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindResolvedAnnotation() {
|
||||
Annotation3 resolvedAnnotation3 = AnnotatedElementUtil.findResolvedAnnotation(Foo.class, Annotation3.class);
|
||||
Assert.assertNotNull(resolvedAnnotation3);
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), ANNOTATION3.value());
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), resolvedAnnotation3.value()); // value与alias互为别名
|
||||
|
||||
Annotation2 resolvedAnnotation2 = AnnotatedElementUtil.findResolvedAnnotation(Foo.class, Annotation2.class);
|
||||
Assert.assertNotNull(resolvedAnnotation2);
|
||||
Assert.assertEquals(resolvedAnnotation2.num(), ANNOTATION3.num()); // num属性被Annotation3.num覆盖
|
||||
|
||||
Annotation1 resolvedAnnotation1 = AnnotatedElementUtil.findResolvedAnnotation(Foo.class, Annotation1.class);
|
||||
Assert.assertNotNull(resolvedAnnotation1);
|
||||
Assert.assertEquals(ANNOTATION3.value(), resolvedAnnotation1.value()); // value属性被Annotation3.value覆盖
|
||||
Assert.assertEquals(resolvedAnnotation1.value(), resolvedAnnotation1.alias()); // value与alias互为别名
|
||||
|
||||
Assert.assertEquals(ANNOTATION4, AnnotatedElementUtil.findResolvedAnnotation(Foo.class, Annotation4.class));
|
||||
Assert.assertEquals(ANNOTATION6, AnnotatedElementUtil.findResolvedAnnotation(Foo.class, Annotation6.class));
|
||||
Assert.assertEquals(ANNOTATION5, AnnotatedElementUtil.findResolvedAnnotation(Foo.class, Annotation5.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindResolvedAnnotations() {
|
||||
Annotation[] resolvedAnnotations = AnnotatedElementUtil.findResolvedAnnotations(Foo.class);
|
||||
Map<Class<?>, Annotation> annotationMap = Stream.of(resolvedAnnotations).collect(Collectors.toMap(Annotation::annotationType, Function.identity()));
|
||||
|
||||
Annotation3 resolvedAnnotation3 = (Annotation3)annotationMap.get(Annotation3.class);
|
||||
Assert.assertNotNull(resolvedAnnotation3);
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), ANNOTATION3.value());
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), resolvedAnnotation3.value()); // value与alias互为别名
|
||||
|
||||
Annotation2 resolvedAnnotation2 = (Annotation2)annotationMap.get(Annotation2.class);
|
||||
Assert.assertNotNull(resolvedAnnotation2);
|
||||
Assert.assertEquals(resolvedAnnotation2.num(), ANNOTATION3.num()); // num属性被Annotation3.num覆盖
|
||||
|
||||
Annotation1 resolvedAnnotation1 = (Annotation1)annotationMap.get(Annotation1.class);
|
||||
Assert.assertNotNull(resolvedAnnotation1);
|
||||
Assert.assertEquals(ANNOTATION3.value(), resolvedAnnotation1.value()); // value属性被Annotation3.value覆盖
|
||||
Assert.assertEquals(resolvedAnnotation1.value(), resolvedAnnotation1.alias()); // value与alias互为别名
|
||||
|
||||
Assert.assertEquals(ANNOTATION4, annotationMap.get(Annotation4.class));
|
||||
Assert.assertEquals(ANNOTATION6, annotationMap.get(Annotation6.class));
|
||||
Assert.assertEquals(ANNOTATION5, annotationMap.get(Annotation5.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindAllResolvedAnnotations() {
|
||||
Annotation3 resolvedAnnotation3 = AnnotatedElementUtil.findAllResolvedAnnotations(Foo.class, Annotation3.class)[0];
|
||||
Assert.assertNotNull(resolvedAnnotation3);
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), ANNOTATION3.value());
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), resolvedAnnotation3.value()); // value与alias互为别名
|
||||
|
||||
Annotation2 resolvedAnnotation2 = AnnotatedElementUtil.findAllResolvedAnnotations(Foo.class, Annotation2.class)[0];
|
||||
Assert.assertNotNull(resolvedAnnotation2);
|
||||
Assert.assertEquals(resolvedAnnotation2.num(), ANNOTATION3.num()); // num属性被Annotation3.num覆盖
|
||||
|
||||
Annotation1 resolvedAnnotation1 = AnnotatedElementUtil.findAllResolvedAnnotations(Foo.class, Annotation1.class)[0];
|
||||
Assert.assertNotNull(resolvedAnnotation1);
|
||||
Assert.assertEquals(ANNOTATION3.value(), resolvedAnnotation1.value()); // value属性被Annotation3.value覆盖
|
||||
Assert.assertEquals(resolvedAnnotation1.value(), resolvedAnnotation1.alias()); // value与alias互为别名
|
||||
|
||||
Assert.assertEquals(ANNOTATION4, AnnotatedElementUtil.findAllResolvedAnnotations(Foo.class, Annotation4.class)[0]);
|
||||
Assert.assertEquals(ANNOTATION6, AnnotatedElementUtil.findAllResolvedAnnotations(Foo.class, Annotation6.class)[0]);
|
||||
Assert.assertEquals(ANNOTATION5, AnnotatedElementUtil.findAllResolvedAnnotations(Foo.class, Annotation5.class)[0]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindDirectlyAnnotation() {
|
||||
Assert.assertNull(AnnotatedElementUtil.findDirectlyAnnotation(Foo.class, Annotation1.class));
|
||||
Assert.assertNull(AnnotatedElementUtil.findDirectlyAnnotation(Foo.class, Annotation2.class));
|
||||
Assert.assertEquals(ANNOTATION3, AnnotatedElementUtil.findDirectlyAnnotation(Foo.class, Annotation3.class));
|
||||
Assert.assertEquals(ANNOTATION4, AnnotatedElementUtil.findDirectlyAnnotation(Foo.class, Annotation4.class));
|
||||
Assert.assertNull(AnnotatedElementUtil.findDirectlyAnnotation(Foo.class, Annotation5.class));
|
||||
Assert.assertEquals(ANNOTATION6, AnnotatedElementUtil.findDirectlyAnnotation(Foo.class, Annotation6.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindAllDirectlyAnnotations() {
|
||||
Assert.assertEquals(0, AnnotatedElementUtil.findAllDirectlyAnnotations(Foo.class, Annotation1.class).length);
|
||||
Assert.assertEquals(0, AnnotatedElementUtil.findAllDirectlyAnnotations(Foo.class, Annotation2.class).length);
|
||||
Assert.assertArrayEquals(new Annotation[]{ANNOTATION3}, AnnotatedElementUtil.findAllDirectlyAnnotations(Foo.class, Annotation3.class));
|
||||
Assert.assertArrayEquals(new Annotation[]{ANNOTATION4}, AnnotatedElementUtil.findAllDirectlyAnnotations(Foo.class, Annotation4.class));
|
||||
Assert.assertEquals(0, AnnotatedElementUtil.findAllDirectlyAnnotations(Foo.class, Annotation5.class).length);
|
||||
Assert.assertArrayEquals(new Annotation[]{ANNOTATION6}, AnnotatedElementUtil.findAllDirectlyAnnotations(Foo.class, Annotation6.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindDirectlyAnnotations() {
|
||||
Assert.assertArrayEquals(
|
||||
DECLARED_ANNOTATIONS, AnnotatedElementUtil.findDirectlyAnnotations(Foo.class)
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindDirectlyResolvedAnnotation() {
|
||||
Assert.assertEquals(ANNOTATION4, AnnotatedElementUtil.findDirectlyResolvedAnnotation(Foo.class, Annotation4.class));
|
||||
Assert.assertEquals(ANNOTATION6, AnnotatedElementUtil.findDirectlyResolvedAnnotation(Foo.class, Annotation6.class));
|
||||
Annotation3 resolvedAnnotation3 = AnnotatedElementUtil.findDirectlyResolvedAnnotation(Foo.class, Annotation3.class);
|
||||
Assert.assertNotNull(resolvedAnnotation3);
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), ANNOTATION3.value());
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), resolvedAnnotation3.value()); // value与alias互为别名
|
||||
|
||||
Assert.assertNull(AnnotatedElementUtil.findDirectlyResolvedAnnotation(Foo.class, Annotation1.class));
|
||||
Assert.assertNull(AnnotatedElementUtil.findDirectlyResolvedAnnotation(Foo.class, Annotation2.class));
|
||||
Assert.assertNull(AnnotatedElementUtil.findDirectlyResolvedAnnotation(Foo.class, Annotation5.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindDirectlyResolvedAnnotations() {
|
||||
Annotation[] resolvedAnnotations = AnnotatedElementUtil.findDirectlyResolvedAnnotations(Foo.class);
|
||||
Map<Class<?>, Annotation> annotationMap = Stream.of(resolvedAnnotations).collect(Collectors.toMap(Annotation::annotationType, Function.identity()));
|
||||
|
||||
Assert.assertEquals(ANNOTATION4, annotationMap.get(Annotation4.class));
|
||||
Assert.assertEquals(ANNOTATION6, annotationMap.get(Annotation6.class));
|
||||
Annotation3 resolvedAnnotation3 = (Annotation3)annotationMap.get(Annotation3.class);
|
||||
Assert.assertNotNull(resolvedAnnotation3);
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), ANNOTATION3.value());
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), resolvedAnnotation3.value()); // value与alias互为别名
|
||||
|
||||
Assert.assertNull(annotationMap.get(Annotation1.class));
|
||||
Assert.assertNull(annotationMap.get(Annotation2.class));
|
||||
Assert.assertNull(annotationMap.get(Annotation5.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindAllDirectlyResolvedAnnotations() {
|
||||
|
||||
Assert.assertEquals(ANNOTATION4, AnnotatedElementUtil.findAllDirectlyResolvedAnnotations(Foo.class, Annotation4.class)[0]);
|
||||
Assert.assertEquals(ANNOTATION6, AnnotatedElementUtil.findAllDirectlyResolvedAnnotations(Foo.class, Annotation6.class)[0]);
|
||||
Annotation3 resolvedAnnotation3 = AnnotatedElementUtil.findAllDirectlyResolvedAnnotations(Foo.class, Annotation3.class)[0];
|
||||
Assert.assertNotNull(resolvedAnnotation3);
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), ANNOTATION3.value());
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), resolvedAnnotation3.value()); // value与alias互为别名
|
||||
|
||||
Assert.assertEquals(0, AnnotatedElementUtil.findAllDirectlyResolvedAnnotations(Foo.class, Annotation1.class).length);
|
||||
Assert.assertEquals(0, AnnotatedElementUtil.findAllDirectlyResolvedAnnotations(Foo.class, Annotation2.class).length);
|
||||
Assert.assertEquals(0, AnnotatedElementUtil.findAllDirectlyResolvedAnnotations(Foo.class, Annotation5.class).length);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsAnnotationPresent() {
|
||||
Assert.assertTrue(AnnotatedElementUtil.isAnnotationPresent(Foo.class, Annotation1.class));
|
||||
Assert.assertTrue(AnnotatedElementUtil.isAnnotationPresent(Foo.class, Annotation2.class));
|
||||
Assert.assertTrue(AnnotatedElementUtil.isAnnotationPresent(Foo.class, Annotation3.class));
|
||||
|
||||
Assert.assertFalse(AnnotatedElementUtil.isAnnotationPresent(Foo.class, Annotation4.class));
|
||||
Assert.assertFalse(AnnotatedElementUtil.isAnnotationPresent(Foo.class, Annotation5.class));
|
||||
Assert.assertFalse(AnnotatedElementUtil.isAnnotationPresent(Foo.class, Annotation6.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetAnnotation() {
|
||||
Assert.assertEquals(ANNOTATION1, AnnotatedElementUtil.getAnnotation(Foo.class, Annotation1.class));
|
||||
Assert.assertEquals(ANNOTATION2, AnnotatedElementUtil.getAnnotation(Foo.class, Annotation2.class));
|
||||
Assert.assertEquals(ANNOTATION3, AnnotatedElementUtil.getAnnotation(Foo.class, Annotation3.class));
|
||||
|
||||
Assert.assertNull(AnnotatedElementUtil.getAnnotation(Foo.class, Annotation4.class));
|
||||
Assert.assertNull(AnnotatedElementUtil.getAnnotation(Foo.class, Annotation5.class));
|
||||
Assert.assertNull(AnnotatedElementUtil.getAnnotation(Foo.class, Annotation6.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetAnnotations() {
|
||||
Annotation[] annotations = AnnotatedElementUtil.getAnnotations(Foo.class);
|
||||
Assert.assertArrayEquals(
|
||||
new Annotation[]{ ANNOTATION3, ANNOTATION2, ANNOTATION1 },
|
||||
annotations
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetResolvedAnnotation() {
|
||||
Annotation3 resolvedAnnotation3 = AnnotatedElementUtil.getResolvedAnnotation(Foo.class, Annotation3.class);
|
||||
Assert.assertNotNull(resolvedAnnotation3);
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), ANNOTATION3.value());
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), resolvedAnnotation3.value()); // value与alias互为别名
|
||||
|
||||
Annotation2 resolvedAnnotation2 = AnnotatedElementUtil.getResolvedAnnotation(Foo.class, Annotation2.class);
|
||||
Assert.assertNotNull(resolvedAnnotation2);
|
||||
Assert.assertEquals(resolvedAnnotation2.num(), ANNOTATION3.num()); // num属性被Annotation3.num覆盖
|
||||
|
||||
Annotation1 resolvedAnnotation1 = AnnotatedElementUtil.getResolvedAnnotation(Foo.class, Annotation1.class);
|
||||
Assert.assertNotNull(resolvedAnnotation1);
|
||||
Assert.assertEquals(ANNOTATION3.value(), resolvedAnnotation1.value()); // value属性被Annotation3.value覆盖
|
||||
Assert.assertEquals(resolvedAnnotation1.value(), resolvedAnnotation1.alias()); // value与alias互为别名
|
||||
|
||||
Assert.assertNull(AnnotatedElementUtil.getResolvedAnnotation(Foo.class, Annotation4.class));
|
||||
Assert.assertNull(AnnotatedElementUtil.getResolvedAnnotation(Foo.class, Annotation5.class));
|
||||
Assert.assertNull(AnnotatedElementUtil.getResolvedAnnotation(Foo.class, Annotation6.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetResolvedAnnotations() {
|
||||
Map<Class<?>, Annotation> annotationMap = Stream.of(AnnotatedElementUtil.getResolvedAnnotations(Foo.class))
|
||||
.collect(Collectors.toMap(Annotation::annotationType, Function.identity()));
|
||||
|
||||
Annotation3 resolvedAnnotation3 = (Annotation3)annotationMap.get(Annotation3.class);
|
||||
Assert.assertNotNull(resolvedAnnotation3);
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), ANNOTATION3.value());
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), resolvedAnnotation3.value()); // value与alias互为别名
|
||||
|
||||
Annotation2 resolvedAnnotation2 = (Annotation2)annotationMap.get(Annotation2.class);
|
||||
Assert.assertNotNull(resolvedAnnotation2);
|
||||
Assert.assertEquals(resolvedAnnotation2.num(), ANNOTATION3.num()); // num属性被Annotation3.num覆盖
|
||||
|
||||
Annotation1 resolvedAnnotation1 = (Annotation1)annotationMap.get(Annotation1.class);
|
||||
Assert.assertNotNull(resolvedAnnotation1);
|
||||
Assert.assertEquals(ANNOTATION3.value(), resolvedAnnotation1.value()); // value属性被Annotation3.value覆盖
|
||||
Assert.assertEquals(resolvedAnnotation1.value(), resolvedAnnotation1.alias()); // value与alias互为别名
|
||||
|
||||
Assert.assertFalse(annotationMap.containsKey(Annotation4.class));
|
||||
Assert.assertFalse(annotationMap.containsKey(Annotation5.class));
|
||||
Assert.assertFalse(annotationMap.containsKey(Annotation6.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetDirectlyAnnotation() {
|
||||
Assert.assertEquals(ANNOTATION3, AnnotatedElementUtil.getDirectlyAnnotation(Foo.class, Annotation3.class));
|
||||
|
||||
Assert.assertNull(AnnotatedElementUtil.getDirectlyAnnotation(Foo.class, Annotation2.class));
|
||||
Assert.assertNull(AnnotatedElementUtil.getDirectlyAnnotation(Foo.class, Annotation1.class));
|
||||
Assert.assertNull(AnnotatedElementUtil.getDirectlyAnnotation(Foo.class, Annotation4.class));
|
||||
Assert.assertNull(AnnotatedElementUtil.getDirectlyAnnotation(Foo.class, Annotation5.class));
|
||||
Assert.assertNull(AnnotatedElementUtil.getDirectlyAnnotation(Foo.class, Annotation6.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetDirectlyAnnotations() {
|
||||
Annotation[] annotations = AnnotatedElementUtil.getDirectlyAnnotations(Foo.class);
|
||||
Assert.assertEquals(1, annotations.length);
|
||||
Assert.assertEquals(ANNOTATION3, annotations[0]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetDirectlyResolvedAnnotation() {
|
||||
Annotation3 resolvedAnnotation3 = AnnotatedElementUtil.getDirectlyResolvedAnnotation(Foo.class, Annotation3.class);
|
||||
Assert.assertNotNull(resolvedAnnotation3);
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), ANNOTATION3.value());
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), resolvedAnnotation3.value()); // value与alias互为别名
|
||||
|
||||
Assert.assertNull(AnnotatedElementUtil.getDirectlyResolvedAnnotation(Foo.class, Annotation2.class));
|
||||
Assert.assertNull(AnnotatedElementUtil.getDirectlyResolvedAnnotation(Foo.class, Annotation1.class));
|
||||
Assert.assertNull(AnnotatedElementUtil.getDirectlyResolvedAnnotation(Foo.class, Annotation4.class));
|
||||
Assert.assertNull(AnnotatedElementUtil.getDirectlyResolvedAnnotation(Foo.class, Annotation5.class));
|
||||
Assert.assertNull(AnnotatedElementUtil.getDirectlyResolvedAnnotation(Foo.class, Annotation6.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetDirectlyResolvedAnnotations() {
|
||||
Annotation[] annotations = AnnotatedElementUtil.getDirectlyResolvedAnnotations(Foo.class);
|
||||
Assert.assertEquals(1, annotations.length);
|
||||
|
||||
Annotation3 resolvedAnnotation3 = (Annotation3)annotations[0];
|
||||
Assert.assertNotNull(resolvedAnnotation3);
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), ANNOTATION3.value());
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), resolvedAnnotation3.value()); // value与alias互为别名
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToHierarchyMetaElement() {
|
||||
Assert.assertNotNull(AnnotatedElementUtil.toHierarchyMetaElement(null, false));
|
||||
Assert.assertNotNull(AnnotatedElementUtil.toHierarchyMetaElement(null, true));
|
||||
AnnotatedElement element = AnnotatedElementUtil.toHierarchyMetaElement(Foo.class, false);
|
||||
|
||||
// 带有元注解
|
||||
Assert.assertArrayEquals(ANNOTATIONS, element.getAnnotations());
|
||||
|
||||
// 不带元注解
|
||||
Assert.assertArrayEquals(DECLARED_ANNOTATIONS, element.getDeclaredAnnotations());
|
||||
|
||||
// 解析注解属性
|
||||
AnnotatedElement resolvedElement = AnnotatedElementUtil.toHierarchyMetaElement(Foo.class, true);
|
||||
Annotation3 resolvedAnnotation3 = resolvedElement.getAnnotation(Annotation3.class);
|
||||
Assert.assertNotNull(resolvedAnnotation3);
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), ANNOTATION3.value());
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), resolvedAnnotation3.value()); // value与alias互为别名
|
||||
|
||||
Annotation2 resolvedAnnotation2 = resolvedElement.getAnnotation(Annotation2.class);
|
||||
Assert.assertNotNull(resolvedAnnotation2);
|
||||
Assert.assertEquals(resolvedAnnotation2.num(), ANNOTATION3.num()); // num属性被Annotation3.num覆盖
|
||||
|
||||
Annotation1 resolvedAnnotation1 = resolvedElement.getAnnotation(Annotation1.class);
|
||||
Assert.assertNotNull(resolvedAnnotation1);
|
||||
Assert.assertEquals(ANNOTATION3.value(), resolvedAnnotation1.value()); // value属性被Annotation3.value覆盖
|
||||
Assert.assertEquals(resolvedAnnotation1.value(), resolvedAnnotation1.alias()); // value与alias互为别名
|
||||
|
||||
Assert.assertEquals(ANNOTATION4, resolvedElement.getAnnotation(Annotation4.class));
|
||||
Assert.assertEquals(ANNOTATION6, resolvedElement.getAnnotation(Annotation6.class));
|
||||
Assert.assertEquals(ANNOTATION5, resolvedElement.getAnnotation(Annotation5.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToHierarchyElement() {
|
||||
Assert.assertNotNull(AnnotatedElementUtil.toHierarchyElement(Foo.class));
|
||||
AnnotatedElement element = AnnotatedElementUtil.toHierarchyElement(Foo.class);
|
||||
Assert.assertArrayEquals(new Annotation[]{ANNOTATION3, ANNOTATION4, ANNOTATION6}, element.getAnnotations());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToMetaElement() {
|
||||
Assert.assertNotNull(AnnotatedElementUtil.toMetaElement(null, false));
|
||||
Assert.assertNotNull(AnnotatedElementUtil.toMetaElement(null, true));
|
||||
|
||||
// 不解析注解属性
|
||||
AnnotatedElement element = AnnotatedElementUtil.toMetaElement(Foo.class, false);
|
||||
Assert.assertSame(element, AnnotatedElementUtil.toMetaElement(Foo.class, false)); // 第二次获取时从缓存中获取
|
||||
Assert.assertArrayEquals(new Annotation[]{ANNOTATION3, ANNOTATION2, ANNOTATION1}, element.getAnnotations());
|
||||
|
||||
// 解析注解属性
|
||||
element = AnnotatedElementUtil.toMetaElement(Foo.class, true);
|
||||
Assert.assertSame(element, AnnotatedElementUtil.toMetaElement(Foo.class, true)); // 第二次获取时从缓存中获取
|
||||
Assert.assertEquals(3, element.getAnnotations().length);
|
||||
|
||||
Annotation3 resolvedAnnotation3 = element.getAnnotation(Annotation3.class);
|
||||
Assert.assertNotNull(resolvedAnnotation3);
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), ANNOTATION3.value());
|
||||
Assert.assertEquals(resolvedAnnotation3.alias(), resolvedAnnotation3.value()); // value与alias互为别名
|
||||
|
||||
Annotation2 resolvedAnnotation2 = element.getAnnotation(Annotation2.class);
|
||||
Assert.assertNotNull(resolvedAnnotation2);
|
||||
Assert.assertEquals(resolvedAnnotation2.num(), ANNOTATION3.num()); // num属性被Annotation3.num覆盖
|
||||
|
||||
Annotation1 resolvedAnnotation1 = element.getAnnotation(Annotation1.class);
|
||||
Assert.assertNotNull(resolvedAnnotation1);
|
||||
Assert.assertEquals(ANNOTATION3.value(), resolvedAnnotation1.value()); // value属性被Annotation3.value覆盖
|
||||
Assert.assertEquals(resolvedAnnotation1.value(), resolvedAnnotation1.alias()); // value与alias互为别名
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAsElement() {
|
||||
Annotation[] annotations = new Annotation[]{ANNOTATION1, ANNOTATION2};
|
||||
Assert.assertNotNull(AnnotatedElementUtil.asElement());
|
||||
|
||||
AnnotatedElement element = AnnotatedElementUtil.asElement(ANNOTATION1, null, ANNOTATION2);
|
||||
Assert.assertArrayEquals(annotations, element.getAnnotations());
|
||||
Assert.assertArrayEquals(annotations, element.getDeclaredAnnotations());
|
||||
Assert.assertEquals(ANNOTATION1, element.getAnnotation(Annotation1.class));
|
||||
Assert.assertNull(element.getAnnotation(Annotation3.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEmptyElement() {
|
||||
AnnotatedElement element = AnnotatedElementUtil.emptyElement();
|
||||
Assert.assertSame(element, AnnotatedElementUtil.emptyElement());
|
||||
Assert.assertNull(element.getAnnotation(Annotation1.class));
|
||||
Assert.assertEquals(0, element.getAnnotations().length);
|
||||
Assert.assertEquals(0, element.getDeclaredAnnotations().length);
|
||||
}
|
||||
|
||||
// ================= super =================
|
||||
|
||||
@Target(ElementType.TYPE_USE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
private @interface Annotation4 {}
|
||||
|
||||
@Annotation4
|
||||
private static class Super {};
|
||||
|
||||
// ================= interface =================
|
||||
|
||||
@Target(ElementType.TYPE_USE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
private @interface Annotation5 {}
|
||||
|
||||
@Annotation5
|
||||
@Target(ElementType.TYPE_USE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
private @interface Annotation6 {}
|
||||
|
||||
@Annotation6
|
||||
private interface Interface {};
|
||||
|
||||
// ================= foo =================
|
||||
|
||||
@Target(ElementType.TYPE_USE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
private @interface Annotation1 {
|
||||
@Alias("alias")
|
||||
String value() default "";
|
||||
@Alias("value")
|
||||
String alias() default "";
|
||||
}
|
||||
|
||||
@Annotation1
|
||||
@Target(ElementType.TYPE_USE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
private @interface Annotation2 {
|
||||
int num() default Integer.MIN_VALUE;
|
||||
}
|
||||
|
||||
@Annotation2
|
||||
@Target(ElementType.TYPE_USE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
private @interface Annotation3 {
|
||||
@Alias("alias")
|
||||
String value() default "";
|
||||
@Alias("value")
|
||||
String alias() default "";
|
||||
int num() default Integer.MIN_VALUE;
|
||||
}
|
||||
|
||||
@Annotation3(value = "foo", num = Integer.MAX_VALUE)
|
||||
private static class Foo extends Super implements Interface {}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,120 @@
|
||||
package cn.hutool.core.annotation;
|
||||
|
||||
import lombok.SneakyThrows;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
import java.lang.reflect.Method;
|
||||
|
||||
/**
|
||||
* test for {@link GenericAnnotationMapping}
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class GenericAnnotationMappingTest {
|
||||
|
||||
@Test
|
||||
public void testEquals() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
GenericAnnotationMapping mapping = GenericAnnotationMapping.create(annotation, false);
|
||||
Assert.assertEquals(mapping, mapping);
|
||||
Assert.assertNotEquals(mapping, null);
|
||||
Assert.assertEquals(mapping, GenericAnnotationMapping.create(annotation, false));
|
||||
Assert.assertNotEquals(mapping, GenericAnnotationMapping.create(annotation, true));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testHashCode() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
int hashCode = GenericAnnotationMapping.create(annotation, false).hashCode();
|
||||
Assert.assertEquals(hashCode, GenericAnnotationMapping.create(annotation, false).hashCode());
|
||||
Assert.assertNotEquals(hashCode, GenericAnnotationMapping.create(annotation, true).hashCode());
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testCreate() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
GenericAnnotationMapping mapping = GenericAnnotationMapping.create(annotation, false);
|
||||
Assert.assertNotNull(mapping);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsRoot() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
GenericAnnotationMapping mapping = GenericAnnotationMapping.create(annotation, true);
|
||||
Assert.assertTrue(mapping.isRoot());
|
||||
|
||||
mapping = GenericAnnotationMapping.create(annotation, false);
|
||||
Assert.assertFalse(mapping.isRoot());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetAnnotation() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
GenericAnnotationMapping mapping = GenericAnnotationMapping.create(annotation, false);
|
||||
Assert.assertSame(annotation, mapping.getAnnotation());
|
||||
}
|
||||
|
||||
@SneakyThrows
|
||||
@Test
|
||||
public void testGetAttributes() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
GenericAnnotationMapping mapping = GenericAnnotationMapping.create(annotation, false);
|
||||
for (int i = 0; i < mapping.getAttributes().length; i++) {
|
||||
Method method = mapping.getAttributes()[i];
|
||||
Assert.assertEquals(Annotation1.class.getDeclaredMethod(method.getName()), method);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAnnotationType() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
GenericAnnotationMapping mapping = GenericAnnotationMapping.create(annotation, false);
|
||||
Assert.assertEquals(annotation.annotationType(), mapping.annotationType());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsResolved() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
GenericAnnotationMapping mapping = GenericAnnotationMapping.create(annotation, false);
|
||||
Assert.assertFalse(mapping.isResolved());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetAttributeValue() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
GenericAnnotationMapping mapping = GenericAnnotationMapping.create(annotation, false);
|
||||
Assert.assertEquals(annotation.value(), mapping.getAttributeValue("value", String.class));
|
||||
Assert.assertNull(mapping.getAttributeValue("value", Integer.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetResolvedAnnotation() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
GenericAnnotationMapping mapping = GenericAnnotationMapping.create(annotation, false);
|
||||
Assert.assertSame(annotation, mapping.getResolvedAnnotation());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetResolvedAttributeValue() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
GenericAnnotationMapping mapping = GenericAnnotationMapping.create(annotation, false);
|
||||
Assert.assertEquals(annotation.value(), mapping.getResolvedAttributeValue("value", String.class));
|
||||
Assert.assertNull(mapping.getResolvedAttributeValue("value", Integer.class));
|
||||
}
|
||||
|
||||
@Target(ElementType.TYPE_USE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
private @interface Annotation1 {
|
||||
String value() default "";
|
||||
}
|
||||
|
||||
@Annotation1("foo")
|
||||
private static class Foo {};
|
||||
|
||||
}
|
||||
@@ -0,0 +1,208 @@
|
||||
package cn.hutool.core.annotation;
|
||||
|
||||
import lombok.SneakyThrows;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.lang.annotation.*;
|
||||
import java.lang.reflect.AnnotatedElement;
|
||||
import java.lang.reflect.Method;
|
||||
import java.util.*;
|
||||
import java.util.function.BiFunction;
|
||||
|
||||
/**
|
||||
* test for {@link HierarchicalAnnotatedElements}
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class HierarchicalAnnotatedElementTest {
|
||||
|
||||
private static final BiFunction<Set<AnnotatedElement>, AnnotatedElement, AnnotatedElement> ELEMENT_MAPPING_FACTORY = (es, e) -> e;
|
||||
|
||||
@SneakyThrows
|
||||
@Test
|
||||
public void testCreateFromMethod() {
|
||||
Method method1 = Foo.class.getDeclaredMethod("method");
|
||||
HierarchicalAnnotatedElements elements = HierarchicalAnnotatedElements.create(method1);
|
||||
Assert.assertEquals(3, elements.getElementMappings().size());
|
||||
|
||||
Method method2 = Foo.class.getDeclaredMethod("method2");
|
||||
elements = HierarchicalAnnotatedElements.create(method2);
|
||||
Assert.assertEquals(1, elements.getElementMappings().size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCreate() {
|
||||
HierarchicalAnnotatedElements elements = HierarchicalAnnotatedElements.create(Foo.class);
|
||||
Assert.assertNotNull(elements);
|
||||
Assert.assertEquals(3, elements.getElementMappings().size());
|
||||
|
||||
elements = HierarchicalAnnotatedElements.create(Foo.class, ELEMENT_MAPPING_FACTORY);
|
||||
Assert.assertNotNull(elements);
|
||||
Assert.assertEquals(3, elements.getElementMappings().size());
|
||||
|
||||
Assert.assertEquals(elements, HierarchicalAnnotatedElements.create(elements, ELEMENT_MAPPING_FACTORY));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEquals() {
|
||||
HierarchicalAnnotatedElements elements = HierarchicalAnnotatedElements.create(Foo.class, ELEMENT_MAPPING_FACTORY);
|
||||
Assert.assertEquals(elements, elements);
|
||||
Assert.assertEquals(elements, HierarchicalAnnotatedElements.create(Foo.class, ELEMENT_MAPPING_FACTORY));
|
||||
Assert.assertNotEquals(elements, HierarchicalAnnotatedElements.create(Super.class, ELEMENT_MAPPING_FACTORY));
|
||||
Assert.assertNotEquals(elements, HierarchicalAnnotatedElements.create(Foo.class, (es, e) -> e));
|
||||
Assert.assertNotEquals(elements, null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testHashCode() {
|
||||
int hashCode = HierarchicalAnnotatedElements.create(Foo.class, ELEMENT_MAPPING_FACTORY).hashCode();
|
||||
Assert.assertEquals(hashCode, HierarchicalAnnotatedElements.create(Foo.class, ELEMENT_MAPPING_FACTORY).hashCode());
|
||||
Assert.assertNotEquals(hashCode, HierarchicalAnnotatedElements.create(Super.class, ELEMENT_MAPPING_FACTORY).hashCode());
|
||||
Assert.assertNotEquals(hashCode, HierarchicalAnnotatedElements.create(Foo.class, (es, e) -> e).hashCode());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetElement() {
|
||||
AnnotatedElement element = Foo.class;
|
||||
HierarchicalAnnotatedElements elements = HierarchicalAnnotatedElements.create(element, ELEMENT_MAPPING_FACTORY);
|
||||
Assert.assertSame(element, elements.getElement());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsAnnotationPresent() {
|
||||
HierarchicalAnnotatedElements elements = HierarchicalAnnotatedElements.create(Foo.class);
|
||||
Assert.assertTrue(elements.isAnnotationPresent(Annotation1.class));
|
||||
Assert.assertTrue(elements.isAnnotationPresent(Annotation2.class));
|
||||
Assert.assertTrue(elements.isAnnotationPresent(Annotation3.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetAnnotations() {
|
||||
HierarchicalAnnotatedElements elements = HierarchicalAnnotatedElements.create(Foo.class);
|
||||
|
||||
Annotation1 annotation1 = Foo.class.getAnnotation(Annotation1.class);
|
||||
Annotation2 annotation2 = Super.class.getAnnotation(Annotation2.class);
|
||||
Annotation3 annotation3 = Interface.class.getAnnotation(Annotation3.class);
|
||||
Annotation[] annotations = new Annotation[]{ annotation1, annotation2, annotation3 };
|
||||
|
||||
Assert.assertArrayEquals(annotations, elements.getAnnotations());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetAnnotation() {
|
||||
HierarchicalAnnotatedElements elements = HierarchicalAnnotatedElements.create(Foo.class);
|
||||
|
||||
Annotation1 annotation1 = Foo.class.getAnnotation(Annotation1.class);
|
||||
Assert.assertEquals(annotation1, elements.getAnnotation(Annotation1.class));
|
||||
|
||||
Annotation2 annotation2 = Super.class.getAnnotation(Annotation2.class);
|
||||
Assert.assertEquals(annotation2, elements.getAnnotation(Annotation2.class));
|
||||
|
||||
Annotation3 annotation3 = Interface.class.getAnnotation(Annotation3.class);
|
||||
Assert.assertEquals(annotation3, elements.getAnnotation(Annotation3.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetAnnotationsByType() {
|
||||
HierarchicalAnnotatedElements elements = HierarchicalAnnotatedElements.create(Foo.class);
|
||||
|
||||
Annotation1 annotation1 = Foo.class.getAnnotation(Annotation1.class);
|
||||
Assert.assertArrayEquals(new Annotation[]{ annotation1 }, elements.getAnnotationsByType(Annotation1.class));
|
||||
|
||||
Annotation2 annotation2 = Super.class.getAnnotation(Annotation2.class);
|
||||
Assert.assertArrayEquals(new Annotation[]{ annotation2 }, elements.getAnnotationsByType(Annotation2.class));
|
||||
|
||||
Annotation3 annotation3 = Interface.class.getAnnotation(Annotation3.class);
|
||||
Assert.assertArrayEquals(new Annotation[]{ annotation3 }, elements.getAnnotationsByType(Annotation3.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetDeclaredAnnotationsByType() {
|
||||
HierarchicalAnnotatedElements elements = HierarchicalAnnotatedElements.create(Foo.class);
|
||||
|
||||
Annotation1 annotation1 = Foo.class.getAnnotation(Annotation1.class);
|
||||
Assert.assertArrayEquals(new Annotation[]{ annotation1 }, elements.getDeclaredAnnotationsByType(Annotation1.class));
|
||||
|
||||
Annotation2 annotation2 = Super.class.getAnnotation(Annotation2.class);
|
||||
Assert.assertArrayEquals(new Annotation[]{ annotation2 }, elements.getDeclaredAnnotationsByType(Annotation2.class));
|
||||
|
||||
Annotation3 annotation3 = Interface.class.getAnnotation(Annotation3.class);
|
||||
Assert.assertArrayEquals(new Annotation[]{ annotation3 }, elements.getDeclaredAnnotationsByType(Annotation3.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetDeclaredAnnotation() {
|
||||
HierarchicalAnnotatedElements elements = HierarchicalAnnotatedElements.create(Foo.class);
|
||||
|
||||
Annotation1 annotation1 = Foo.class.getAnnotation(Annotation1.class);
|
||||
Assert.assertEquals(annotation1, elements.getDeclaredAnnotation(Annotation1.class));
|
||||
|
||||
Annotation2 annotation2 = Super.class.getAnnotation(Annotation2.class);
|
||||
Assert.assertEquals(annotation2, elements.getDeclaredAnnotation(Annotation2.class));
|
||||
|
||||
Annotation3 annotation3 = Interface.class.getAnnotation(Annotation3.class);
|
||||
Assert.assertEquals(annotation3, elements.getDeclaredAnnotation(Annotation3.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetDeclaredAnnotations() {
|
||||
HierarchicalAnnotatedElements elements = HierarchicalAnnotatedElements.create(Foo.class);
|
||||
|
||||
Annotation1 annotation1 = Foo.class.getAnnotation(Annotation1.class);
|
||||
Annotation2 annotation2 = Super.class.getAnnotation(Annotation2.class);
|
||||
Annotation3 annotation3 = Interface.class.getAnnotation(Annotation3.class);
|
||||
Annotation[] annotations = new Annotation[]{ annotation1, annotation2, annotation3 };
|
||||
|
||||
Assert.assertArrayEquals(annotations, elements.getDeclaredAnnotations());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIterator() {
|
||||
HierarchicalAnnotatedElements elements = HierarchicalAnnotatedElements.create(Foo.class);
|
||||
Iterator<AnnotatedElement> iterator = elements.iterator();
|
||||
Assert.assertNotNull(iterator);
|
||||
|
||||
List<AnnotatedElement> elementList = new ArrayList<>();
|
||||
iterator.forEachRemaining(elementList::add);
|
||||
Assert.assertEquals(Arrays.asList(Foo.class, Super.class, Interface.class), elementList);
|
||||
}
|
||||
|
||||
@Target({ElementType.TYPE_USE, ElementType.METHOD})
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
private @interface Annotation3 { }
|
||||
|
||||
@Target({ElementType.TYPE_USE, ElementType.METHOD})
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
private @interface Annotation2 { }
|
||||
|
||||
@Target({ElementType.TYPE_USE, ElementType.METHOD})
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
private @interface Annotation1 { }
|
||||
|
||||
@Annotation3
|
||||
private interface Interface {
|
||||
@Annotation3
|
||||
String method();
|
||||
@Annotation3
|
||||
static String method2() { return null; }
|
||||
}
|
||||
|
||||
@Annotation2
|
||||
private static class Super {
|
||||
@Annotation2
|
||||
public String method() { return null; }
|
||||
@Annotation2
|
||||
public static String method2() { return null; }
|
||||
}
|
||||
|
||||
@Annotation1
|
||||
private static class Foo extends Super implements Interface {
|
||||
@Annotation1
|
||||
@Override
|
||||
public String method() { return null; }
|
||||
@Annotation1
|
||||
public static String method2() { return null; }
|
||||
};
|
||||
|
||||
}
|
||||
@@ -0,0 +1,208 @@
|
||||
package cn.hutool.core.annotation;
|
||||
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.lang.annotation.*;
|
||||
import java.lang.reflect.AnnotatedElement;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.function.BiFunction;
|
||||
|
||||
/**
|
||||
* test for {@link MetaAnnotatedElement}
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class MetaAnnotatedElementTest {
|
||||
|
||||
private static final BiFunction<ResolvedAnnotationMapping, Annotation, ResolvedAnnotationMapping> RESOLVED_MAPPING_FACTORY =
|
||||
(source, annotation) -> new ResolvedAnnotationMapping(source, annotation, true);
|
||||
|
||||
private static final BiFunction<ResolvedAnnotationMapping, Annotation, ResolvedAnnotationMapping> MAPPING_FACTORY =
|
||||
(source, annotation) -> new ResolvedAnnotationMapping(source, annotation, false);
|
||||
|
||||
@Test
|
||||
public void testEquals() {
|
||||
AnnotatedElement element = new MetaAnnotatedElement<>(Foo.class, RESOLVED_MAPPING_FACTORY);
|
||||
Assert.assertEquals(element, element);
|
||||
Assert.assertNotEquals(element, null);
|
||||
Assert.assertEquals(element, new MetaAnnotatedElement<>(Foo.class, RESOLVED_MAPPING_FACTORY));
|
||||
Assert.assertNotEquals(element, new MetaAnnotatedElement<>(Foo.class, MAPPING_FACTORY));
|
||||
Assert.assertNotEquals(element, new MetaAnnotatedElement<>(Annotation1.class, MAPPING_FACTORY));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testHashCode() {
|
||||
int hashCode = new MetaAnnotatedElement<>(Foo.class, RESOLVED_MAPPING_FACTORY).hashCode();
|
||||
Assert.assertEquals(hashCode, new MetaAnnotatedElement<>(Foo.class, RESOLVED_MAPPING_FACTORY).hashCode());
|
||||
Assert.assertNotEquals(hashCode, new MetaAnnotatedElement<>(Foo.class, MAPPING_FACTORY).hashCode());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCreate() {
|
||||
// 第二次创建时优先从缓存中获取
|
||||
AnnotatedElement resolvedElement = MetaAnnotatedElement.create(Foo.class, RESOLVED_MAPPING_FACTORY);
|
||||
Assert.assertEquals(resolvedElement, MetaAnnotatedElement.create(Foo.class, RESOLVED_MAPPING_FACTORY));
|
||||
AnnotatedElement element = MetaAnnotatedElement.create(Foo.class, MAPPING_FACTORY);
|
||||
Assert.assertEquals(element, MetaAnnotatedElement.create(Foo.class, MAPPING_FACTORY));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetMapping() {
|
||||
MetaAnnotatedElement<ResolvedAnnotationMapping> element = MetaAnnotatedElement.create(Foo.class, MAPPING_FACTORY);
|
||||
Assert.assertTrue(element.getMapping(Annotation1.class).isPresent());
|
||||
Assert.assertTrue(element.getMapping(Annotation2.class).isPresent());
|
||||
Assert.assertTrue(element.getMapping(Annotation3.class).isPresent());
|
||||
Assert.assertTrue(element.getMapping(Annotation4.class).isPresent());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetDeclaredMapping() {
|
||||
MetaAnnotatedElement<ResolvedAnnotationMapping> element = MetaAnnotatedElement.create(Foo.class, MAPPING_FACTORY);
|
||||
Assert.assertFalse(element.getDeclaredMapping(Annotation1.class).isPresent());
|
||||
Assert.assertFalse(element.getDeclaredMapping(Annotation2.class).isPresent());
|
||||
Assert.assertTrue(element.getDeclaredMapping(Annotation3.class).isPresent());
|
||||
Assert.assertTrue(element.getDeclaredMapping(Annotation4.class).isPresent());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsAnnotationPresent() {
|
||||
MetaAnnotatedElement<ResolvedAnnotationMapping> element = MetaAnnotatedElement.create(Foo.class, MAPPING_FACTORY);
|
||||
Assert.assertTrue(element.isAnnotationPresent(Annotation1.class));
|
||||
Assert.assertTrue(element.isAnnotationPresent(Annotation2.class));
|
||||
Assert.assertTrue(element.isAnnotationPresent(Annotation3.class));
|
||||
Assert.assertTrue(element.isAnnotationPresent(Annotation4.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetAnnotation() {
|
||||
MetaAnnotatedElement<ResolvedAnnotationMapping> element = MetaAnnotatedElement.create(Foo.class, MAPPING_FACTORY);
|
||||
Annotation4 annotation4 = Foo.class.getAnnotation(Annotation4.class);
|
||||
Annotation3 annotation3 = Foo.class.getAnnotation(Annotation3.class);
|
||||
Annotation2 annotation2 = Annotation3.class.getAnnotation(Annotation2.class);
|
||||
Annotation1 annotation1 = Annotation2.class.getAnnotation(Annotation1.class);
|
||||
|
||||
Assert.assertEquals(annotation1, element.getAnnotation(Annotation1.class));
|
||||
Assert.assertEquals(annotation2, element.getAnnotation(Annotation2.class));
|
||||
Assert.assertEquals(annotation3, element.getAnnotation(Annotation3.class));
|
||||
Assert.assertEquals(annotation4, element.getAnnotation(Annotation4.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetDeclaredAnnotation() {
|
||||
MetaAnnotatedElement<ResolvedAnnotationMapping> element = MetaAnnotatedElement.create(Foo.class, MAPPING_FACTORY);
|
||||
Annotation4 annotation4 = Foo.class.getAnnotation(Annotation4.class);
|
||||
Annotation3 annotation3 = Foo.class.getAnnotation(Annotation3.class);
|
||||
|
||||
Assert.assertNull(element.getDeclaredAnnotation(Annotation1.class));
|
||||
Assert.assertNull(element.getDeclaredAnnotation(Annotation2.class));
|
||||
Assert.assertEquals(annotation3, element.getDeclaredAnnotation(Annotation3.class));
|
||||
Assert.assertEquals(annotation4, element.getDeclaredAnnotation(Annotation4.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetAnnotationByType() {
|
||||
MetaAnnotatedElement<ResolvedAnnotationMapping> element = MetaAnnotatedElement.create(Foo.class, MAPPING_FACTORY);
|
||||
Annotation4 annotation4 = Foo.class.getAnnotation(Annotation4.class);
|
||||
Assert.assertArrayEquals(
|
||||
new Annotation[]{ annotation4 },
|
||||
element.getAnnotationsByType(Annotation4.class)
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetDeclaredAnnotationByType() {
|
||||
MetaAnnotatedElement<ResolvedAnnotationMapping> element = MetaAnnotatedElement.create(Foo.class, MAPPING_FACTORY);
|
||||
Annotation4 annotation4 = Foo.class.getAnnotation(Annotation4.class);
|
||||
Assert.assertArrayEquals(
|
||||
new Annotation[]{ annotation4 },
|
||||
element.getDeclaredAnnotationsByType(Annotation4.class)
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetAnnotations() {
|
||||
MetaAnnotatedElement<ResolvedAnnotationMapping> element = MetaAnnotatedElement.create(Foo.class, MAPPING_FACTORY);
|
||||
Annotation4 annotation4 = Foo.class.getAnnotation(Annotation4.class);
|
||||
Annotation3 annotation3 = Foo.class.getAnnotation(Annotation3.class);
|
||||
Annotation2 annotation2 = Annotation3.class.getAnnotation(Annotation2.class);
|
||||
Annotation1 annotation1 = Annotation2.class.getAnnotation(Annotation1.class);
|
||||
Annotation[] annotations = new Annotation[]{ annotation3, annotation4, annotation2, annotation1 };
|
||||
|
||||
Assert.assertArrayEquals(annotations, element.getAnnotations());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetDeclaredAnnotations() {
|
||||
MetaAnnotatedElement<ResolvedAnnotationMapping> element = MetaAnnotatedElement.create(Foo.class, MAPPING_FACTORY);
|
||||
Annotation4 annotation4 = Foo.class.getAnnotation(Annotation4.class);
|
||||
Annotation3 annotation3 = Foo.class.getAnnotation(Annotation3.class);
|
||||
Annotation[] annotations = new Annotation[]{ annotation3, annotation4 };
|
||||
|
||||
Assert.assertArrayEquals(annotations, element.getDeclaredAnnotations());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIterator() {
|
||||
MetaAnnotatedElement<ResolvedAnnotationMapping> element = MetaAnnotatedElement.create(Foo.class, MAPPING_FACTORY);
|
||||
Annotation4 annotation4 = Foo.class.getAnnotation(Annotation4.class);
|
||||
Annotation3 annotation3 = Foo.class.getAnnotation(Annotation3.class);
|
||||
Annotation2 annotation2 = Annotation3.class.getAnnotation(Annotation2.class);
|
||||
Annotation1 annotation1 = Annotation2.class.getAnnotation(Annotation1.class);
|
||||
Annotation[] annotations = new Annotation[]{ annotation3, annotation4, annotation2, annotation1 };
|
||||
|
||||
Iterator<ResolvedAnnotationMapping> iterator = element.iterator();
|
||||
List<Annotation> mappingList = new ArrayList<>();
|
||||
iterator.forEachRemaining(mapping -> mappingList.add(mapping.getAnnotation()));
|
||||
|
||||
Assert.assertEquals(Arrays.asList(annotations), mappingList);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetElement() {
|
||||
AnnotatedElement source = Foo.class;
|
||||
MetaAnnotatedElement<ResolvedAnnotationMapping> element = MetaAnnotatedElement.create(source, MAPPING_FACTORY);
|
||||
Assert.assertSame(source, element.getElement());
|
||||
}
|
||||
|
||||
@Target(ElementType.TYPE_USE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
private @interface Annotation1 {
|
||||
@Alias("name")
|
||||
String value() default "";
|
||||
@Alias("value")
|
||||
String name() default "";
|
||||
}
|
||||
|
||||
@Annotation1("Annotation2")
|
||||
@Target(ElementType.TYPE_USE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
private @interface Annotation2 {
|
||||
@Alias("name")
|
||||
String value() default "";
|
||||
@Alias("value")
|
||||
String name() default "";
|
||||
}
|
||||
|
||||
@Annotation2("Annotation3")
|
||||
@Target(ElementType.TYPE_USE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
private @interface Annotation3 {
|
||||
String name() default "";
|
||||
}
|
||||
|
||||
@Annotation2("Annotation4")
|
||||
@Target(ElementType.TYPE_USE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
private @interface Annotation4 {
|
||||
String value() default "";
|
||||
}
|
||||
|
||||
@Annotation3(name = "foo")
|
||||
@Annotation4("foo")
|
||||
private static class Foo {};
|
||||
|
||||
}
|
||||
@@ -0,0 +1,300 @@
|
||||
package cn.hutool.core.annotation;
|
||||
|
||||
import lombok.SneakyThrows;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
import java.lang.reflect.Method;
|
||||
|
||||
/**
|
||||
* test for {@link ResolvedAnnotationMapping}
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class ResolvedAnnotationMappingTest {
|
||||
|
||||
@Test
|
||||
public void testEquals() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
ResolvedAnnotationMapping mapping = ResolvedAnnotationMapping.create(annotation, false);
|
||||
Assert.assertEquals(mapping, mapping);
|
||||
Assert.assertNotEquals(null, mapping);
|
||||
Assert.assertEquals(mapping, ResolvedAnnotationMapping.create(annotation, false));
|
||||
Assert.assertNotEquals(mapping, ResolvedAnnotationMapping.create(annotation, true));
|
||||
|
||||
// Annotation3没有需要解析的属性，因此即使在构造函数指定false也一样
|
||||
Annotation3 annotation3 = Foo.class.getAnnotation(Annotation3.class);
|
||||
Assert.assertEquals(
|
||||
ResolvedAnnotationMapping.create(annotation3, false),
|
||||
ResolvedAnnotationMapping.create(annotation3, true)
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testHashCode() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
int hashCode = ResolvedAnnotationMapping.create(annotation, false).hashCode();
|
||||
Assert.assertEquals(hashCode, ResolvedAnnotationMapping.create(annotation, false).hashCode());
|
||||
Assert.assertNotEquals(hashCode, ResolvedAnnotationMapping.create(annotation, true).hashCode());
|
||||
|
||||
// Annotation3没有需要解析的属性，因此即使在构造函数指定false也一样
|
||||
Annotation3 annotation3 = Foo.class.getAnnotation(Annotation3.class);
|
||||
Assert.assertEquals(
|
||||
ResolvedAnnotationMapping.create(annotation3, false).hashCode(),
|
||||
ResolvedAnnotationMapping.create(annotation3, true).hashCode()
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testCreate() {
|
||||
Annotation3 annotation3 = Foo.class.getAnnotation(Annotation3.class);
|
||||
ResolvedAnnotationMapping mapping3 = ResolvedAnnotationMapping.create(annotation3, false);
|
||||
Assert.assertNotNull(mapping3);
|
||||
|
||||
Annotation2 annotation2 = Foo.class.getAnnotation(Annotation2.class);
|
||||
ResolvedAnnotationMapping mapping2 = ResolvedAnnotationMapping.create(mapping3, annotation2, false);
|
||||
Assert.assertNotNull(mapping2);
|
||||
|
||||
Annotation1 annotation1 = Foo.class.getAnnotation(Annotation1.class);
|
||||
ResolvedAnnotationMapping mapping1 = ResolvedAnnotationMapping.create(mapping2, annotation1, false);
|
||||
Assert.assertNotNull(mapping1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsRoot() {
|
||||
Annotation3 annotation3 = Foo.class.getAnnotation(Annotation3.class);
|
||||
ResolvedAnnotationMapping mapping3 = ResolvedAnnotationMapping.create(annotation3, false);
|
||||
Assert.assertTrue(mapping3.isRoot());
|
||||
|
||||
Annotation2 annotation2 = Foo.class.getAnnotation(Annotation2.class);
|
||||
ResolvedAnnotationMapping mapping2 = ResolvedAnnotationMapping.create(mapping3, annotation2, false);
|
||||
Assert.assertFalse(mapping2.isRoot());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetRoot() {
|
||||
Annotation3 annotation3 = Foo.class.getAnnotation(Annotation3.class);
|
||||
ResolvedAnnotationMapping mapping3 = ResolvedAnnotationMapping.create(annotation3, false);
|
||||
Assert.assertSame(mapping3, mapping3.getRoot());
|
||||
|
||||
Annotation2 annotation2 = Foo.class.getAnnotation(Annotation2.class);
|
||||
ResolvedAnnotationMapping mapping2 = ResolvedAnnotationMapping.create(mapping3, annotation2, false);
|
||||
Assert.assertSame(mapping3, mapping2.getRoot());
|
||||
|
||||
Annotation1 annotation1 = Foo.class.getAnnotation(Annotation1.class);
|
||||
ResolvedAnnotationMapping mapping1 = ResolvedAnnotationMapping.create(mapping2, annotation1, false);
|
||||
Assert.assertSame(mapping3, mapping1.getRoot());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetAnnotation() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
ResolvedAnnotationMapping mapping = ResolvedAnnotationMapping.create(annotation, false);
|
||||
Assert.assertSame(annotation, mapping.getAnnotation());
|
||||
}
|
||||
|
||||
@SneakyThrows
|
||||
@Test
|
||||
public void testGetAttributes() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
ResolvedAnnotationMapping mapping = ResolvedAnnotationMapping.create(annotation, false);
|
||||
for (int i = 0; i < mapping.getAttributes().length; i++) {
|
||||
Method method = mapping.getAttributes()[i];
|
||||
Assert.assertEquals(Annotation1.class.getDeclaredMethod(method.getName()), method);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testHasAttribute() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
ResolvedAnnotationMapping mapping = ResolvedAnnotationMapping.create(annotation, false);
|
||||
|
||||
Assert.assertTrue(mapping.hasAttribute("value", String.class));
|
||||
Assert.assertFalse(mapping.hasAttribute("value", Integer.class));
|
||||
|
||||
int index = mapping.getAttributeIndex("value", String.class);
|
||||
Assert.assertTrue(mapping.hasAttribute(index));
|
||||
Assert.assertFalse(mapping.hasAttribute(Integer.MIN_VALUE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAnnotationType() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
ResolvedAnnotationMapping mapping = ResolvedAnnotationMapping.create(annotation, false);
|
||||
Assert.assertEquals(annotation.annotationType(), mapping.annotationType());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsResolved() {
|
||||
Annotation1 annotation1 = Foo.class.getAnnotation(Annotation1.class);
|
||||
|
||||
ResolvedAnnotationMapping mapping1 = ResolvedAnnotationMapping.create(annotation1, true);
|
||||
Assert.assertTrue(mapping1.isResolved());
|
||||
Assert.assertFalse(ResolvedAnnotationMapping.create(annotation1, false).isResolved());
|
||||
|
||||
Annotation2 annotation2 = Foo.class.getAnnotation(Annotation2.class);
|
||||
ResolvedAnnotationMapping mapping2 = ResolvedAnnotationMapping.create(annotation2, true);
|
||||
Assert.assertFalse(mapping2.isResolved());
|
||||
|
||||
mapping2 = ResolvedAnnotationMapping.create(mapping1, annotation2, true);
|
||||
Assert.assertTrue(mapping2.isResolved());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetAttributeIndex() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
ResolvedAnnotationMapping mapping = ResolvedAnnotationMapping.create(annotation, false);
|
||||
for (int i = 0; i < mapping.getAttributes().length; i++) {
|
||||
Method method = mapping.getAttributes()[i];
|
||||
Assert.assertEquals(i, mapping.getAttributeIndex(method.getName(), method.getReturnType()));
|
||||
}
|
||||
Assert.assertEquals(ResolvedAnnotationMapping.NOT_FOUND_INDEX, mapping.getAttributeIndex("value", Void.class));
|
||||
Assert.assertEquals(ResolvedAnnotationMapping.NOT_FOUND_INDEX, mapping.getAttributeIndex("nonexistent", Void.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetAttributeValue() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
ResolvedAnnotationMapping mapping = ResolvedAnnotationMapping.create(annotation, false);
|
||||
|
||||
Assert.assertNull(mapping.getAttribute(Integer.MAX_VALUE));
|
||||
|
||||
int valueIdx = mapping.getAttributeIndex("value", String.class);
|
||||
Assert.assertEquals(annotation.value(), mapping.getAttributeValue(valueIdx));
|
||||
Assert.assertEquals(annotation.value(), mapping.getAttributeValue("value", String.class));
|
||||
|
||||
int name1Idx = mapping.getAttributeIndex("value1", String.class);
|
||||
Assert.assertEquals(annotation.value1(), mapping.getAttributeValue(name1Idx));
|
||||
Assert.assertEquals(annotation.value1(), mapping.getAttributeValue("value1", String.class));
|
||||
|
||||
int name2Idx = mapping.getAttributeIndex("value2", String.class);
|
||||
Assert.assertEquals(annotation.value2(), mapping.getAttributeValue(name2Idx));
|
||||
Assert.assertEquals(annotation.value2(), mapping.getAttributeValue("value2", String.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetResolvedAnnotation() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
ResolvedAnnotationMapping mapping = ResolvedAnnotationMapping.create(annotation, true);
|
||||
Annotation1 synthesis = (Annotation1)mapping.getResolvedAnnotation();
|
||||
|
||||
Assert.assertEquals(annotation.annotationType(), synthesis.annotationType());
|
||||
Assert.assertEquals(annotation.value(), synthesis.value());
|
||||
Assert.assertEquals(annotation.value(), synthesis.value1());
|
||||
Assert.assertEquals(annotation.value(), synthesis.value2());
|
||||
|
||||
Assert.assertTrue(AnnotationMappingProxy.isProxied(synthesis));
|
||||
Assert.assertSame(mapping, ((AnnotationMappingProxy.Proxied)synthesis).getMapping());
|
||||
|
||||
Assert.assertNotEquals(synthesis, annotation);
|
||||
Assert.assertNotEquals(synthesis.hashCode(), annotation.hashCode());
|
||||
Assert.assertNotEquals(synthesis.toString(), annotation.toString());
|
||||
|
||||
Annotation3 annotation3 = Foo.class.getAnnotation(Annotation3.class);
|
||||
Assert.assertSame(annotation3, ResolvedAnnotationMapping.create(annotation3, true).getResolvedAnnotation());
|
||||
}
|
||||
|
||||
// ======================= resolved attribute value =======================
|
||||
|
||||
@Test
|
||||
public void testGetResolvedAttributeValueWhenAliased() {
|
||||
Annotation1 annotation = Foo.class.getAnnotation(Annotation1.class);
|
||||
ResolvedAnnotationMapping mapping = ResolvedAnnotationMapping.create(annotation, true);
|
||||
Assert.assertNull(mapping.getResolvedAttributeValue(Integer.MIN_VALUE));
|
||||
|
||||
// value = value1 = value2
|
||||
Assert.assertEquals(annotation.value(), mapping.getResolvedAttributeValue("value", String.class));
|
||||
Assert.assertEquals(annotation.value(), mapping.getResolvedAttributeValue("value1", String.class));
|
||||
Assert.assertEquals(annotation.value(), mapping.getResolvedAttributeValue("value2", String.class));
|
||||
|
||||
// alias == alias1 == alias2
|
||||
Assert.assertEquals(annotation.alias(), mapping.getResolvedAttributeValue("alias", String.class));
|
||||
Assert.assertEquals(annotation.alias(), mapping.getResolvedAttributeValue("alias1", String.class));
|
||||
Assert.assertEquals(annotation.alias(), mapping.getResolvedAttributeValue("alias2", String.class));
|
||||
|
||||
// defVal1 == defVal2
|
||||
Assert.assertEquals(
|
||||
mapping.getResolvedAttributeValue("defVal", String.class),
|
||||
mapping.getResolvedAttributeValue("defVal2", String.class)
|
||||
);
|
||||
|
||||
// unDefVal1 == unDefVal2
|
||||
Assert.assertEquals(
|
||||
mapping.getResolvedAttributeValue("unDefVal", String.class),
|
||||
mapping.getResolvedAttributeValue("unDefVal2", String.class)
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetResolvedAttributeWhenOverwritten() {
|
||||
Annotation3 annotation3 = Foo.class.getAnnotation(Annotation3.class);
|
||||
ResolvedAnnotationMapping mapping3 = ResolvedAnnotationMapping.create(annotation3, true);
|
||||
Assert.assertEquals(annotation3.value(), mapping3.getResolvedAttributeValue("value", String.class));
|
||||
Assert.assertEquals((Integer)annotation3.alias(), mapping3.getResolvedAttributeValue("alias", Integer.class));
|
||||
|
||||
// annotation2中与annotation3同名同类型的属性value、alias被覆写
|
||||
Annotation2 annotation2 = Foo.class.getAnnotation(Annotation2.class);
|
||||
ResolvedAnnotationMapping mapping2 = ResolvedAnnotationMapping.create(mapping3, annotation2, true);
|
||||
Assert.assertEquals(annotation3.value(), mapping2.getResolvedAttributeValue("value", String.class));
|
||||
Assert.assertEquals((Integer)annotation3.alias(), mapping2.getResolvedAttributeValue("alias", Integer.class));
|
||||
|
||||
// annotation1中与annotation3同名同类型的属性value被覆写，由于value存在别名value1，value2因此也一并被覆写
|
||||
Annotation1 annotation1 = Foo.class.getAnnotation(Annotation1.class);
|
||||
ResolvedAnnotationMapping mapping1 = ResolvedAnnotationMapping.create(mapping2, annotation1, true);
|
||||
Assert.assertEquals(annotation3.value(), mapping1.getResolvedAttributeValue("value", String.class));
|
||||
Assert.assertEquals(annotation3.value(), mapping1.getResolvedAttributeValue("value1", String.class));
|
||||
Assert.assertEquals(annotation3.value(), mapping1.getResolvedAttributeValue("value2", String.class));
|
||||
// 而alias由于类型不同不会被覆写
|
||||
Assert.assertEquals(annotation1.alias(), mapping1.getResolvedAttributeValue("alias", String.class));
|
||||
}
|
||||
|
||||
@Target(ElementType.TYPE_USE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
private @interface Annotation1 {
|
||||
@Alias("value1")
|
||||
String value() default "";
|
||||
String value1() default "";
|
||||
@Alias("value")
|
||||
String value2() default "";
|
||||
|
||||
@Alias("alias2")
|
||||
String alias() default "";
|
||||
@Alias("alias2")
|
||||
String alias1() default "";
|
||||
@Alias("alias1")
|
||||
String alias2() default "";
|
||||
|
||||
@Alias("defVal2")
|
||||
String defVal() default "";
|
||||
String defVal2() default "";
|
||||
|
||||
@Alias("unDefVal2")
|
||||
String unDefVal() default "";
|
||||
String unDefVal2() default "";
|
||||
}
|
||||
|
||||
@Target(ElementType.TYPE_USE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
private @interface Annotation2 {
|
||||
String value() default "";
|
||||
int alias() default 123;
|
||||
}
|
||||
|
||||
@Target(ElementType.TYPE_USE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
private @interface Annotation3 {
|
||||
String value() default "";
|
||||
int alias() default 123;
|
||||
}
|
||||
|
||||
@Annotation3(value = "Annotation3", alias = 312)
|
||||
@Annotation2(value = "Annotation2")
|
||||
@Annotation1(value = "Annotation1", alias = "goo", unDefVal = "foo", unDefVal2 = "foo")
|
||||
private static class Foo {};
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user