1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.commons.weaver;
20
21 import static org.apache.commons.weaver.test.beans.ComplexAnnotations.Stooge.CURLY;
22 import static org.apache.commons.weaver.test.beans.ComplexAnnotations.Stooge.LARRY;
23 import static org.apache.commons.weaver.test.beans.ComplexAnnotations.Stooge.MOE;
24 import static org.apache.commons.weaver.test.beans.ComplexAnnotations.Stooge.SHEMP;
25 import static org.junit.Assert.assertArrayEquals;
26 import static org.junit.Assert.assertEquals;
27 import static org.junit.Assert.assertFalse;
28 import static org.junit.Assert.assertSame;
29 import static org.junit.Assert.assertThat;
30 import static org.junit.Assert.assertTrue;
31
32 import java.io.IOException;
33 import java.lang.reflect.Field;
34 import java.net.URLClassLoader;
35 import java.util.ArrayList;
36 import java.util.Arrays;
37 import java.util.Collections;
38 import java.util.HashMap;
39 import java.util.HashSet;
40 import java.util.List;
41 import java.util.Map;
42 import java.util.Set;
43
44 import org.apache.commons.lang3.Validate;
45 import org.apache.commons.weaver.test.WeaverTestBase;
46 import org.apache.commons.weaver.test.beans.AbstractTestBean;
47 import org.apache.commons.weaver.test.beans.ComplexAnnotations;
48 import org.apache.commons.weaver.test.beans.ComplexAnnotations.NestAnnotation;
49 import org.apache.commons.weaver.test.beans.ComplexAnnotations.Stooge;
50 import org.apache.commons.weaver.test.beans.ComplexAnnotations.TestAnnotation;
51 import org.apache.commons.weaver.test.beans.TestBeanInterface;
52 import org.apache.commons.weaver.test.beans.TestBeanWithClassAnnotation;
53 import org.apache.commons.weaver.test.beans.TestBeanWithMethodAnnotation;
54 import org.apache.commons.weaver.utils.URLArray;
55 import org.apache.xbean.finder.Annotated;
56 import org.apache.xbean.finder.archive.FileArchive;
57 import org.hamcrest.Matchers;
58 import org.junit.Test;
59
60 public class FinderTest extends WeaverTestBase {
61
62 private Finder finder() {
63 final ClassLoader classLoader = new URLClassLoader(URLArray.fromPaths(getClassPathEntries()));
64 return new Finder(new FileArchive(classLoader, getTargetFolder()));
65 }
66
67
68
69
70
71
72
73 @Test
74 public void testElements() throws IOException {
75 addClassForScanning(ComplexAnnotations.class);
76 Map<String, Annotated<Field>> fields = new HashMap<String, Annotated<Field>>();
77 for (Annotated<Field> annotated : finder().withAnnotations().findAnnotatedFields(
78 ComplexAnnotations.TestAnnotation.class)) {
79 fields.put(annotated.get().getName(), annotated);
80 }
81 assertEquals(2, fields.size());
82
83 TestAnnotation anno1 = fields.get("dummy1").getAnnotation(TestAnnotation.class);
84
85 assertFalse(anno1.booleanValue());
86 assertTrue(Arrays.equals(new boolean[] { false }, anno1.booleanValues()));
87 assertEquals((byte) 0, anno1.byteValue());
88 assertArrayEquals(new byte[] { 0 }, anno1.byteValues());
89 assertEquals((char) 0, anno1.charValue());
90 assertArrayEquals(new char[] { 0 }, anno1.charValues());
91 assertEquals(Double.valueOf(0.0), Double.valueOf(anno1.doubleValue()));
92 assertTrue(Arrays.equals(new double[] { 0.0 }, anno1.doubleValues()));
93 assertEquals(Float.valueOf(0.0f), Float.valueOf(anno1.floatValue()));
94 assertTrue(Arrays.equals(new float[] { 0.0f }, anno1.floatValues()));
95 assertEquals(0, anno1.intValue());
96 assertArrayEquals(new int[] { 0 }, anno1.intValues());
97 assertEquals(0L, anno1.longValue());
98 assertArrayEquals(new long[] { 0L }, anno1.longValues());
99
100 NestAnnotation nest1 = anno1.nest();
101 assertFalse(nest1.booleanValue());
102 assertTrue(Arrays.equals(new boolean[] { false }, nest1.booleanValues()));
103 assertEquals((byte) 0, nest1.byteValue());
104 assertArrayEquals(new byte[] { 0 }, nest1.byteValues());
105 assertEquals((char) 0, nest1.charValue());
106 assertArrayEquals(new char[] { 0 }, nest1.charValues());
107 assertEquals(Double.valueOf(0.0), Double.valueOf(nest1.doubleValue()));
108 assertTrue(Arrays.equals(new double[] { 0.0 }, nest1.doubleValues()));
109 assertEquals(Float.valueOf(0.0f), Float.valueOf(nest1.floatValue()));
110 assertTrue(Arrays.equals(new float[] { 0.0f }, nest1.floatValues()));
111 assertEquals(0, nest1.intValue());
112 assertArrayEquals(new int[] { 0 }, nest1.intValues());
113 assertEquals(0L, nest1.longValue());
114 assertArrayEquals(new long[] { 0L }, nest1.longValues());
115 assertEquals((short) 0, nest1.shortValue());
116 assertArrayEquals(new short[] { 0 }, nest1.shortValues());
117 assertSame(CURLY, nest1.stooge());
118 assertArrayEquals(new Stooge[] { MOE, LARRY, SHEMP }, nest1.stooges());
119 assertEquals("", nest1.string());
120 assertArrayEquals(new String[] { "" }, nest1.strings());
121 assertEquals(Object.class, nest1.type());
122 assertArrayEquals(new Class[] { Object.class }, nest1.types());
123
124 assertEquals(1, anno1.nests().length);
125 NestAnnotation nest1_0 = anno1.nests()[0];
126 assertFalse(nest1_0.booleanValue());
127 assertTrue(Arrays.equals(new boolean[] { false }, nest1_0.booleanValues()));
128 assertEquals((byte) 0, nest1_0.byteValue());
129 assertArrayEquals(new byte[] { 0 }, nest1_0.byteValues());
130 assertEquals((char) 0, nest1_0.charValue());
131 assertArrayEquals(new char[] { 0 }, nest1_0.charValues());
132 assertEquals(Double.valueOf(0.0), Double.valueOf(nest1_0.doubleValue()));
133 assertTrue(Arrays.equals(new double[] { 0.0 }, nest1_0.doubleValues()));
134 assertEquals(Float.valueOf(0.0f), Float.valueOf(nest1_0.floatValue()));
135 assertTrue(Arrays.equals(new float[] { 0.0f }, nest1_0.floatValues()));
136 assertEquals(0, nest1_0.intValue());
137 assertArrayEquals(new int[] { 0 }, nest1_0.intValues());
138 assertEquals(0L, nest1_0.longValue());
139 assertArrayEquals(new long[] { 0L }, nest1_0.longValues());
140 assertEquals((short) 0, nest1_0.shortValue());
141 assertArrayEquals(new short[] { 0 }, nest1_0.shortValues());
142 assertSame(CURLY, nest1_0.stooge());
143 assertArrayEquals(new Stooge[] { MOE, LARRY, SHEMP }, nest1_0.stooges());
144 assertEquals("", nest1_0.string());
145 assertArrayEquals(new String[] { "" }, nest1_0.strings());
146 assertEquals(Object[].class, nest1_0.type());
147 assertArrayEquals(new Class[] { Object[].class }, nest1_0.types());
148
149 assertEquals((short) 0, anno1.shortValue());
150 assertArrayEquals(new short[] { 0 }, anno1.shortValues());
151 assertSame(SHEMP, anno1.stooge());
152 assertArrayEquals(new Stooge[] { MOE, LARRY, CURLY }, anno1.stooges());
153 assertEquals("", anno1.string());
154 assertArrayEquals(new String[] { "" }, anno1.strings());
155 assertEquals(Object.class, anno1.type());
156 assertArrayEquals(new Class[] { Object.class }, anno1.types());
157
158 TestAnnotation anno2 = fields.get("dummy2").getAnnotation(TestAnnotation.class);
159 assertFalse(anno2.booleanValue());
160 assertTrue(Arrays.equals(new boolean[] { false }, anno2.booleanValues()));
161 assertEquals((byte) 0, anno2.byteValue());
162 assertArrayEquals(new byte[] { 0 }, anno2.byteValues());
163 assertEquals((char) 0, anno2.charValue());
164 assertArrayEquals(new char[] { 0 }, anno2.charValues());
165 assertEquals(Double.valueOf(0.0), Double.valueOf(anno2.doubleValue()));
166 assertTrue(Arrays.equals(new double[] { 0.0 }, anno2.doubleValues()));
167 assertEquals(Float.valueOf(0.0f), Float.valueOf(anno2.floatValue()));
168 assertTrue(Arrays.equals(new float[] { 0.0f }, anno2.floatValues()));
169 assertEquals(0, anno2.intValue());
170 assertArrayEquals(new int[] { 0 }, anno2.intValues());
171 assertEquals(0L, anno2.longValue());
172 assertArrayEquals(new long[] { 0L }, anno2.longValues());
173
174 NestAnnotation nest2 = anno2.nest();
175 assertFalse(nest2.booleanValue());
176 assertTrue(Arrays.equals(new boolean[] { false }, nest2.booleanValues()));
177 assertEquals((byte) 0, nest2.byteValue());
178 assertArrayEquals(new byte[] { 0 }, nest2.byteValues());
179 assertEquals((char) 0, nest2.charValue());
180 assertArrayEquals(new char[] { 0 }, nest2.charValues());
181 assertEquals(Double.valueOf(0.0), Double.valueOf(nest2.doubleValue()));
182 assertTrue(Arrays.equals(new double[] { 0.0 }, nest2.doubleValues()));
183 assertEquals(Float.valueOf(0.0f), Float.valueOf(nest2.floatValue()));
184 assertTrue(Arrays.equals(new float[] { 0.0f }, nest2.floatValues()));
185 assertEquals(0, nest2.intValue());
186 assertArrayEquals(new int[] { 0 }, nest2.intValues());
187 assertEquals(0L, nest2.longValue());
188 assertArrayEquals(new long[] { 0L }, nest2.longValues());
189 assertEquals((short) 0, nest2.shortValue());
190 assertArrayEquals(new short[] { 0 }, nest2.shortValues());
191 assertSame(CURLY, nest2.stooge());
192 assertArrayEquals(new Stooge[] { MOE, LARRY, SHEMP }, nest2.stooges());
193 assertEquals("", nest2.string());
194 assertArrayEquals(new String[] { "" }, nest2.strings());
195 assertEquals(Object.class, nest2.type());
196 assertArrayEquals(new Class[] { Object.class }, nest2.types());
197
198 assertEquals(2, anno2.nests().length);
199 NestAnnotation nest2_0 = anno2.nests()[0];
200 assertFalse(nest2_0.booleanValue());
201 assertTrue(Arrays.equals(new boolean[] { false }, nest2_0.booleanValues()));
202 assertEquals((byte) 0, nest2_0.byteValue());
203 assertArrayEquals(new byte[] { 0 }, nest2_0.byteValues());
204 assertEquals((char) 0, nest2_0.charValue());
205 assertArrayEquals(new char[] { 0 }, nest2_0.charValues());
206 assertEquals(Double.valueOf(0.0), Double.valueOf(nest2_0.doubleValue()));
207 assertTrue(Arrays.equals(new double[] { 0.0 }, nest2_0.doubleValues()));
208 assertEquals(Float.valueOf(0.0f), Float.valueOf(nest2_0.floatValue()));
209 assertTrue(Arrays.equals(new float[] { 0.0f }, nest2_0.floatValues()));
210 assertEquals(0, nest2_0.intValue());
211 assertArrayEquals(new int[] { 0 }, nest2_0.intValues());
212 assertEquals(0L, nest2_0.longValue());
213 assertArrayEquals(new long[] { 0L }, nest2_0.longValues());
214 assertEquals((short) 0, nest2_0.shortValue());
215 assertArrayEquals(new short[] { 0 }, nest2_0.shortValues());
216 assertSame(CURLY, nest2_0.stooge());
217 assertArrayEquals(new Stooge[] { MOE, LARRY, SHEMP }, nest2_0.stooges());
218 assertEquals("", nest2_0.string());
219 assertArrayEquals(new String[] { "" }, nest2_0.strings());
220 assertEquals(Object[].class, nest2_0.type());
221 assertArrayEquals(new Class[] { Object[].class }, nest2_0.types());
222
223 NestAnnotation nest2_1 = anno2.nests()[1];
224 assertFalse(nest2_1.booleanValue());
225 assertTrue(Arrays.equals(new boolean[] { false }, nest2_1.booleanValues()));
226 assertEquals((byte) 0, nest2_1.byteValue());
227 assertArrayEquals(new byte[] { 0 }, nest2_1.byteValues());
228 assertEquals((char) 0, nest2_1.charValue());
229 assertArrayEquals(new char[] { 0 }, nest2_1.charValues());
230 assertEquals(Double.valueOf(0.0), Double.valueOf(nest2_1.doubleValue()));
231 assertTrue(Arrays.equals(new double[] { 0.0 }, nest2_1.doubleValues()));
232 assertEquals(Float.valueOf(0.0f), Float.valueOf(nest2_1.floatValue()));
233 assertTrue(Arrays.equals(new float[] { 0.0f }, nest2_1.floatValues()));
234 assertEquals(0, nest2_1.intValue());
235 assertArrayEquals(new int[] { 0 }, nest2_1.intValues());
236 assertEquals(0L, nest2_1.longValue());
237 assertArrayEquals(new long[] { 0L }, nest2_1.longValues());
238 assertEquals((short) 0, nest2_1.shortValue());
239 assertArrayEquals(new short[] { 0 }, nest2_1.shortValues());
240 assertSame(CURLY, nest2_1.stooge());
241 assertArrayEquals(new Stooge[] { MOE, LARRY, SHEMP }, nest2_1.stooges());
242 assertEquals("", nest2_1.string());
243 assertArrayEquals(new String[] { "" }, nest2_1.strings());
244 assertEquals(Object[].class, nest2_1.type());
245 assertArrayEquals(new Class[] { Object[].class }, nest2_1.types());
246
247 assertEquals((short) 0, anno2.shortValue());
248 assertArrayEquals(new short[] { 0 }, anno2.shortValues());
249 assertSame(SHEMP, anno2.stooge());
250 assertArrayEquals(new Stooge[] { MOE, LARRY, CURLY }, anno2.stooges());
251 assertEquals("", anno2.string());
252 assertArrayEquals(new String[] { "" }, anno2.strings());
253 assertEquals(Object.class, anno2.type());
254 assertArrayEquals(new Class[] { Object.class }, anno2.types());
255 }
256
257 @Test
258 public void testObjectMethods() throws IOException {
259 addClassForScanning(ComplexAnnotations.class);
260 for (Annotated<Field> annotated : finder().withAnnotations().findAnnotatedFields(
261 ComplexAnnotations.TestAnnotation.class)) {
262 TestAnnotation anno = annotated.getAnnotation(TestAnnotation.class);
263 assertFalse(anno.toString().isEmpty());
264 assertFalse(anno.hashCode() == 0);
265 assertTrue(anno.equals(anno));
266 }
267 }
268
269 @Test
270 public void testFindAssignableTypes() throws IOException {
271 addClassForScanning(TestBeanInterface.class);
272 addClassForScanning(AbstractTestBean.class);
273 addClassForScanning(TestBeanWithClassAnnotation.class);
274 addClassForScanning(TestBeanWithMethodAnnotation.class);
275
276 final Set<Class<?>> implementors = new HashSet<Class<?>>();
277 for (Annotated<Class<?>> annotated : finder().withAnnotations().findAssignableTypes(TestBeanInterface.class)) {
278 implementors.add(annotated.get());
279 }
280 assertEquals(1, implementors.size());
281 assertTrue(implementors.contains(TestBeanWithClassAnnotation.class));
282
283 final Set<Class<?>> subclasses = new HashSet<Class<?>>();
284 for (Annotated<Class<?>> annotated : finder().withAnnotations().findAssignableTypes(AbstractTestBean.class)) {
285 subclasses.add(annotated.get());
286 }
287 assertEquals(2, subclasses.size());
288 assertTrue(subclasses.contains(TestBeanWithClassAnnotation.class));
289 assertTrue(subclasses.contains(TestBeanWithMethodAnnotation.class));
290 }
291
292 @Test
293 public void testFindAllTypes() throws IOException {
294 addClassForScanning(TestBeanInterface.class);
295 addClassForScanning(AbstractTestBean.class);
296 addClassForScanning(TestBeanWithClassAnnotation.class);
297 addClassForScanning(TestBeanWithMethodAnnotation.class);
298
299 List<Annotated<Class<?>>> allClasses = finder().withAnnotations().getAllClasses();
300 assertThat(extract(allClasses), Matchers.<Class<?>> containsInAnyOrder(TestBeanInterface.class,
301 AbstractTestBean.class, TestBeanWithClassAnnotation.class, TestBeanWithMethodAnnotation.class));
302 }
303
304 private List<Class<?>> extract(List<Annotated<Class<?>>> input) {
305 Validate.noNullElements(input);
306 if (input.isEmpty()) {
307 return Collections.emptyList();
308 }
309 final List<Class<?>> result = new ArrayList<Class<?>>(input.size());
310 for (Annotated<Class<?>> c : input) {
311 result.add(c.get());
312 }
313 return result;
314 }
315 }