1
2
3
4
5
6
7
8 package org.codehaus.metaclass;
9
10 import java.lang.reflect.Constructor;
11 import java.lang.reflect.Field;
12 import java.lang.reflect.Method;
13 import junit.framework.TestCase;
14 import org.codehaus.metaclass.introspector.MetaClassException;
15 import org.codehaus.metaclass.introspector.MetaClassIntrospector;
16 import org.codehaus.metaclass.model.Attribute;
17 import org.codehaus.metaclass.model.ClassDescriptor;
18 import org.codehaus.metaclass.model.FieldDescriptor;
19 import org.codehaus.metaclass.model.MethodDescriptor;
20 import org.codehaus.metaclass.model.ParameterDescriptor;
21
22 /***
23 * @author Peter Donald
24 * @version $Revision: 1.19 $ $Date: 2003/11/28 11:14:54 $
25 */
26 public class AttributesTestCase
27 extends TestCase
28 {
29 /*** Leave this fied in as it is used in unit tests. */
30 protected int m_testField = 1;
31
32 /***
33 * Leave this constructor in as it is used by unit tests.
34 */
35 public AttributesTestCase( final String name )
36 {
37 super( name );
38 }
39
40 public AttributesTestCase()
41 {
42 }
43
44 public void testInstantiateAttributesClass()
45 {
46 assertNotNull( "attributes", new Attributes() );
47 }
48
49 public void testGetAttributeByNameWithZeroAttributes()
50 {
51 final Attribute attribute =
52 Attributes.getAttributeByName( Attribute.EMPTY_SET, "name" );
53 assertNull( "attribute", attribute );
54 }
55
56 public void testGetAttributeByNameWithNoMatchingAttributes()
57 {
58 final String name = "name";
59 final Attribute attribute1 = new Attribute( "foo" );
60 final Attribute attribute2 = new Attribute( "baz" );
61 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
62 final Attribute attribute =
63 Attributes.getAttributeByName( attributes, name );
64 assertNull( "attribute", attribute );
65 }
66
67 public void testGetAttributeByNameWithOneMatchingAttribute()
68 {
69 final String name = "name";
70 final Attribute attribute1 = new Attribute( name );
71 final Attribute attribute2 = new Attribute( "baz" );
72 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
73 final Attribute attribute =
74 Attributes.getAttributeByName( attributes, name );
75 assertNotNull( "attribute", attribute );
76 assertEquals( "attribute", attribute1, attribute );
77 }
78
79 public void testGetAttributeByNameWithOneMatchingAttributes()
80 {
81 final String name = "name";
82 final Attribute attribute1 = new Attribute( name );
83 final Attribute attribute2 = new Attribute( name );
84 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
85 final Attribute attribute =
86 Attributes.getAttributeByName( attributes, name );
87 assertNotNull( "attribute", attribute );
88 assertEquals( "attribute", attribute1, attribute );
89 }
90
91 public void testGetAttributesByNameWithZeroAttributes()
92 {
93 final String name = "name";
94 final Attribute[] results =
95 Attributes.getAttributesByName( Attribute.EMPTY_SET, name );
96 assertEquals( "attributes.length", 0, results.length );
97 }
98
99 public void testGetAttributesByNameWithNoMatchingAttributes()
100 {
101 final String name = "name";
102 final Attribute attribute1 = new Attribute( "foo" );
103 final Attribute attribute2 = new Attribute( "baz" );
104 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
105 final Attribute[] results =
106 Attributes.getAttributesByName( attributes, name );
107 assertEquals( "attributes.length", 0, results.length );
108 }
109
110 public void testGetAttributesByNameWithOneMatchingAttribute()
111 {
112 final String name = "name";
113 final Attribute attribute1 = new Attribute( name );
114 final Attribute attribute2 = new Attribute( "baz" );
115 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
116 final Attribute[] results =
117 Attributes.getAttributesByName( attributes, name );
118 assertEquals( "attributes.length", 1, results.length );
119 assertEquals( "attribute[ 0 ]", attribute1, results[ 0 ] );
120 }
121
122 public void testGetAttributesByNameWithOneMatchingAttributes()
123 {
124 final String name = "name";
125 final Attribute attribute1 = new Attribute( name );
126 final Attribute attribute2 = new Attribute( name );
127 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
128 final Attribute[] results =
129 Attributes.getAttributesByName( attributes, name );
130 assertEquals( "attributes.length", 2, results.length );
131 assertEquals( "attributes[ 0 ]", attribute1, results[ 0 ] );
132 assertEquals( "attributes[ 1 ]", attribute2, results[ 1 ] );
133 }
134
135 public void testGetAttributesForClass()
136 {
137 final String name = "name";
138 final Attribute attribute1 = new Attribute( name );
139 final Attribute attribute2 = new Attribute( name );
140 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
141
142 final ClassDescriptor descriptor =
143 new ClassDescriptor( AttributesTestCase.class.getName(),
144 attributes, attributes,
145 FieldDescriptor.EMPTY_SET,
146 MethodDescriptor.EMPTY_SET );
147 MetaClassIntrospector.setAccessor( new MockAccessor( descriptor ) );
148 MetaClassIntrospector.clearCompleteCache();
149 final Attribute[] results =
150 Attributes.getAttributes( AttributesTestCase.class );
151 assertEquals( "attributes.length", 2, results.length );
152 assertEquals( "attributes[ 0 ]", attribute1, results[ 0 ] );
153 assertEquals( "attributes[ 1 ]", attribute2, results[ 1 ] );
154 }
155
156 public void testGetAttributesForClassSansMetaData()
157 {
158 MetaClassIntrospector.setAccessor( new MockAccessor( null ) );
159 MetaClassIntrospector.clearCompleteCache();
160 final Attribute[] results =
161 Attributes.getAttributes( AttributesTestCase.class );
162 assertEquals( "attributes.length", 0, results.length );
163 }
164
165 public void testGetAttributesForClassWithNameSansMetaData()
166 {
167 MetaClassIntrospector.setAccessor( new MockAccessor( null ) );
168 MetaClassIntrospector.clearCompleteCache();
169
170 final Attribute[] results =
171 Attributes.getAttributes( AttributesTestCase.class, "aName" );
172 assertEquals( "attributes.length", 0, results.length );
173 }
174
175 public void testGetAttributesForClassWithName()
176 {
177 final String name = "name";
178 final Attribute attribute1 = new Attribute( name );
179 final Attribute attribute2 = new Attribute( "bleh" );
180 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
181
182 final ClassDescriptor descriptor =
183 new ClassDescriptor( AttributesTestCase.class.getName(),
184 attributes, attributes,
185 FieldDescriptor.EMPTY_SET,
186 MethodDescriptor.EMPTY_SET );
187 MetaClassIntrospector.setAccessor( new MockAccessor( descriptor ) );
188 MetaClassIntrospector.clearCompleteCache();
189
190 final Attribute[] results =
191 Attributes.getAttributes( AttributesTestCase.class, name );
192 assertEquals( "attributes.length", 1, results.length );
193 assertEquals( "attributes[ 0 ]", attribute1, results[ 0 ] );
194 }
195
196 public void testGetAttributeForClassWithNameSansMetaData()
197 {
198 MetaClassIntrospector.setAccessor( new MockAccessor( null ) );
199 MetaClassIntrospector.clearCompleteCache();
200
201 final Attribute result =
202 Attributes.getAttribute( AttributesTestCase.class, "name" );
203 assertEquals( "attribute", null, result );
204 }
205
206 public void testGetAttributeForClassWithName()
207 {
208 final String name = "name";
209 final Attribute attribute1 = new Attribute( name );
210 final Attribute attribute2 = new Attribute( "bleh" );
211 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
212
213 final ClassDescriptor descriptor =
214 new ClassDescriptor( AttributesTestCase.class.getName(),
215 attributes, attributes,
216 FieldDescriptor.EMPTY_SET,
217 MethodDescriptor.EMPTY_SET );
218 MetaClassIntrospector.setAccessor( new MockAccessor( descriptor ) );
219 MetaClassIntrospector.clearCompleteCache();
220
221 final Attribute result =
222 Attributes.getAttribute( AttributesTestCase.class, name );
223 assertEquals( "attribute", attribute1, result );
224 }
225
226 public void testGetAttributesForField()
227 {
228 final String name = "name";
229 final Attribute attribute1 = new Attribute( name );
230 final Attribute attribute2 = new Attribute( name );
231 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
232 final Field field = AttributesTestCase.class.getDeclaredFields()[ 0 ];
233 final FieldDescriptor fieldDescriptor =
234 new FieldDescriptor( field.getName(),
235 field.getType().getName(),
236 attributes,
237 attributes );
238 final ClassDescriptor descriptor =
239 new ClassDescriptor( AttributesTestCase.class.getName(),
240 Attribute.EMPTY_SET, Attribute.EMPTY_SET,
241 new FieldDescriptor[]{fieldDescriptor},
242 MethodDescriptor.EMPTY_SET );
243 MetaClassIntrospector.setAccessor( new MockAccessor( descriptor ) );
244 MetaClassIntrospector.clearCompleteCache();
245 final Attribute[] results = Attributes.getAttributes( field );
246 assertEquals( "attributes.length", 2, results.length );
247 assertEquals( "attributes[ 0 ]", attribute1, results[ 0 ] );
248 assertEquals( "attributes[ 1 ]", attribute2, results[ 1 ] );
249 }
250
251 public void testGetAttributesForFieldSansMetaData()
252 {
253 final Field field = AttributesTestCase.class.getDeclaredFields()[ 0 ];
254 MetaClassIntrospector.setAccessor( new MockAccessor( null ) );
255 MetaClassIntrospector.clearCompleteCache();
256 final Attribute[] results = Attributes.getAttributes( field );
257 assertEquals( "attributes.length", 0, results.length );
258 }
259
260 public void testGetAttributesForFieldWithNameSansMetaData()
261 {
262 final Field field = AttributesTestCase.class.getDeclaredFields()[ 0 ];
263 MetaClassIntrospector.setAccessor( new MockAccessor( null ) );
264 MetaClassIntrospector.clearCompleteCache();
265 final Attribute[] results =
266 Attributes.getAttributes( field, "name" );
267 assertEquals( "attributes.length", 0, results.length );
268 }
269
270 public void testGetAttributesForFieldWithName()
271 {
272 final String name = "name";
273 final Attribute attribute1 = new Attribute( name );
274 final Attribute attribute2 = new Attribute( "bleh" );
275 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
276
277 final Field field = AttributesTestCase.class.getDeclaredFields()[ 0 ];
278 final FieldDescriptor fieldDescriptor =
279 new FieldDescriptor( field.getName(),
280 field.getType().getName(),
281 attributes,
282 attributes );
283 final ClassDescriptor descriptor =
284 new ClassDescriptor( AttributesTestCase.class.getName(),
285 Attribute.EMPTY_SET, Attribute.EMPTY_SET,
286 new FieldDescriptor[]{fieldDescriptor},
287 MethodDescriptor.EMPTY_SET );
288 MetaClassIntrospector.setAccessor( new MockAccessor( descriptor ) );
289 MetaClassIntrospector.clearCompleteCache();
290 final Attribute[] results =
291 Attributes.getAttributes( field, name );
292 assertEquals( "attributes.length", 1, results.length );
293 assertEquals( "attributes[ 0 ]", attribute1, results[ 0 ] );
294 }
295
296 public void testGetAttributeForFieldWithNameSansMetaData()
297 {
298 final Field field = AttributesTestCase.class.getDeclaredFields()[ 0 ];
299 MetaClassIntrospector.setAccessor( new MockAccessor( null ) );
300 MetaClassIntrospector.clearCompleteCache();
301
302 final Attribute result =
303 Attributes.getAttribute( field, "name" );
304 assertEquals( "attribute", null, result );
305 }
306
307 public void testGetAttributeForFieldWithName()
308 {
309 final String name = "name";
310 final Attribute attribute1 = new Attribute( name );
311 final Attribute attribute2 = new Attribute( "bleh" );
312 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
313
314 final Field field = AttributesTestCase.class.getDeclaredFields()[ 0 ];
315 final FieldDescriptor fieldDescriptor =
316 new FieldDescriptor( field.getName(),
317 field.getType().getName(),
318 attributes,
319 attributes );
320 final ClassDescriptor descriptor =
321 new ClassDescriptor( AttributesTestCase.class.getName(),
322 Attribute.EMPTY_SET, Attribute.EMPTY_SET,
323 new FieldDescriptor[]{fieldDescriptor},
324 MethodDescriptor.EMPTY_SET );
325 MetaClassIntrospector.setAccessor( new MockAccessor( descriptor ) );
326 MetaClassIntrospector.clearCompleteCache();
327
328 final Attribute result =
329 Attributes.getAttribute( field, name );
330 assertEquals( "attribute", attribute1, result );
331 }
332
333 public void testGetAttributesForMethodSansMetaData()
334 {
335 final Method method = AttributesTestCase.class.getDeclaredMethods()[ 0 ];
336 MetaClassIntrospector.setAccessor( new MockAccessor( null ) );
337 MetaClassIntrospector.clearCompleteCache();
338 final Attribute[] results = Attributes.getAttributes( method );
339 assertEquals( "attributes.length", 0, results.length );
340 }
341
342 public void testGetAttributesForMethod()
343 {
344 final String name = "name";
345 final Attribute attribute1 = new Attribute( name );
346 final Attribute attribute2 = new Attribute( name );
347 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
348 final Method method = AttributesTestCase.class.getDeclaredMethods()[ 0 ];
349 final Class[] types = method.getParameterTypes();
350 final ParameterDescriptor[] parameters = new ParameterDescriptor[ types.length ];
351 for( int i = 0; i < types.length; i++ )
352 {
353 parameters[ i ] =
354 new ParameterDescriptor( "", types[ i ].getName() );
355 }
356 final MethodDescriptor methodDescriptor =
357 new MethodDescriptor( method.getName(),
358 method.getReturnType().getName(),
359 parameters,
360 attributes,
361 attributes );
362 final ClassDescriptor descriptor =
363 new ClassDescriptor( AttributesTestCase.class.getName(),
364 Attribute.EMPTY_SET, Attribute.EMPTY_SET,
365 FieldDescriptor.EMPTY_SET,
366 new MethodDescriptor[]{methodDescriptor} );
367 MetaClassIntrospector.setAccessor( new MockAccessor( descriptor ) );
368 MetaClassIntrospector.clearCompleteCache();
369 final Attribute[] results = Attributes.getAttributes( method );
370 assertEquals( "attributes.length", 2, results.length );
371 assertEquals( "attributes[ 0 ]", attribute1, results[ 0 ] );
372 assertEquals( "attributes[ 1 ]", attribute2, results[ 1 ] );
373 }
374
375 public void testGetAttributesForMethodWithNameSansMetaData()
376 {
377 final Method method = AttributesTestCase.class.getDeclaredMethods()[ 0 ];
378 MetaClassIntrospector.setAccessor( new MockAccessor( null ) );
379 MetaClassIntrospector.clearCompleteCache();
380 final Attribute[] results =
381 Attributes.getAttributes( method, "name" );
382 assertEquals( "attributes.length", 0, results.length );
383 }
384
385 public void testGetAttributesForMethodWithName()
386 {
387 final String name = "name";
388 final Attribute attribute1 = new Attribute( name );
389 final Attribute attribute2 = new Attribute( "bleh" );
390 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
391
392 final Method method = AttributesTestCase.class.getDeclaredMethods()[ 0 ];
393 final Class[] types = method.getParameterTypes();
394 final ParameterDescriptor[] parameters = new ParameterDescriptor[ types.length ];
395 for( int i = 0; i < types.length; i++ )
396 {
397 parameters[ i ] =
398 new ParameterDescriptor( "", types[ i ].getName() );
399 }
400
401 final MethodDescriptor methodDescriptor =
402 new MethodDescriptor( method.getName(),
403 method.getReturnType().getName(),
404 parameters,
405 attributes, attributes );
406 final ClassDescriptor descriptor =
407 new ClassDescriptor( AttributesTestCase.class.getName(),
408 Attribute.EMPTY_SET, Attribute.EMPTY_SET,
409 FieldDescriptor.EMPTY_SET,
410 new MethodDescriptor[]{methodDescriptor} );
411 MetaClassIntrospector.setAccessor( new MockAccessor( descriptor ) );
412 MetaClassIntrospector.clearCompleteCache();
413 final Attribute[] results =
414 Attributes.getAttributes( method, name );
415 assertEquals( "attributes.length", 1, results.length );
416 assertEquals( "attributes[ 0 ]", attribute1, results[ 0 ] );
417 }
418
419 public void testGetAttributeForMethodWithNameSansMetaData()
420 {
421 final Method method = AttributesTestCase.class.getDeclaredMethods()[ 0 ];
422 MetaClassIntrospector.setAccessor( new MockAccessor( null ) );
423 MetaClassIntrospector.clearCompleteCache();
424
425 final Attribute result =
426 Attributes.getAttribute( method, "name" );
427 assertEquals( "attribute", null, result );
428 }
429
430 public void testGetAttributeForMethodWithName()
431 {
432 final String name = "name";
433 final Attribute attribute1 = new Attribute( name );
434 final Attribute attribute2 = new Attribute( "bleh" );
435 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
436
437 final Method method = AttributesTestCase.class.getDeclaredMethods()[ 0 ];
438 final Class[] types = method.getParameterTypes();
439 final ParameterDescriptor[] parameters = new ParameterDescriptor[ types.length ];
440 for( int i = 0; i < types.length; i++ )
441 {
442 parameters[ i ] =
443 new ParameterDescriptor( "", types[ i ].getName() );
444 }
445 final MethodDescriptor methodDescriptor =
446 new MethodDescriptor( method.getName(),
447 method.getReturnType().getName(),
448 parameters,
449 attributes, attributes );
450 final ClassDescriptor descriptor =
451 new ClassDescriptor( AttributesTestCase.class.getName(),
452 Attribute.EMPTY_SET, Attribute.EMPTY_SET,
453 FieldDescriptor.EMPTY_SET,
454 new MethodDescriptor[]{methodDescriptor} );
455 MetaClassIntrospector.setAccessor( new MockAccessor( descriptor ) );
456 MetaClassIntrospector.clearCompleteCache();
457
458 final Attribute result =
459 Attributes.getAttribute( method, name );
460 assertEquals( "attribute", attribute1, result );
461 }
462
463 public void testGetNonExistentField()
464 {
465 final FieldDescriptor fieldDescriptor =
466 new FieldDescriptor( "ignoreMe",
467 "java.lang.String",
468 Attribute.EMPTY_SET,
469 Attribute.EMPTY_SET );
470 final ClassDescriptor descriptor =
471 new ClassDescriptor( AttributesTestCase.class.getName(),
472 Attribute.EMPTY_SET, Attribute.EMPTY_SET,
473 new FieldDescriptor[]{fieldDescriptor},
474 MethodDescriptor.EMPTY_SET );
475 final Field field = AttributesTestCase.class.getDeclaredFields()[ 0 ];
476
477 MetaClassIntrospector.setAccessor( new MockAccessor( descriptor ) );
478 MetaClassIntrospector.clearCompleteCache();
479
480 try
481 {
482 Attributes.getField( field );
483 }
484 catch( MetaClassException e )
485 {
486 return;
487 }
488 fail( "Expected to fail accessing non-existent field" );
489 }
490
491 public void testGetNonExistentMethod()
492 {
493 final MethodDescriptor methodDescriptor =
494 new MethodDescriptor( "ignoreMe",
495 "",
496 ParameterDescriptor.EMPTY_SET,
497 Attribute.EMPTY_SET, Attribute.EMPTY_SET );
498 final ClassDescriptor descriptor =
499 new ClassDescriptor( AttributesTestCase.class.getName(),
500 Attribute.EMPTY_SET, Attribute.EMPTY_SET,
501 FieldDescriptor.EMPTY_SET,
502 new MethodDescriptor[]{methodDescriptor} );
503 final Method method = AttributesTestCase.class.getDeclaredMethods()[ 0 ];
504
505 MetaClassIntrospector.setAccessor( new MockAccessor( descriptor ) );
506 MetaClassIntrospector.clearCompleteCache();
507
508 try
509 {
510 Attributes.getMethod( method );
511 }
512 catch( MetaClassException e )
513 {
514 return;
515 }
516 fail( "Expected to fail accessing non-existent method" );
517 }
518
519 public void testGetNonExistentConstructor()
520 {
521 final MethodDescriptor methodDescriptor =
522 new MethodDescriptor( "ignoreMe",
523 "",
524 ParameterDescriptor.EMPTY_SET,
525 Attribute.EMPTY_SET, Attribute.EMPTY_SET );
526 final ClassDescriptor descriptor =
527 new ClassDescriptor( AttributesTestCase.class.getName(),
528 Attribute.EMPTY_SET, Attribute.EMPTY_SET,
529 FieldDescriptor.EMPTY_SET,
530 new MethodDescriptor[]{methodDescriptor} );
531 final Constructor constructor = AttributesTestCase.class.getDeclaredConstructors()[ 0 ];
532
533 MetaClassIntrospector.setAccessor( new MockAccessor( descriptor ) );
534 MetaClassIntrospector.clearCompleteCache();
535
536 try
537 {
538 Attributes.getConstructor( constructor );
539 }
540 catch( MetaClassException e )
541 {
542 return;
543 }
544 fail( "Expected to fail accessing non-existent constructor" );
545 }
546
547 public void testGetAttributesForConstructorSansMetaData()
548 {
549 final Constructor constructor =
550 AttributesTestCase.class.getDeclaredConstructors()[ 0 ];
551 MetaClassIntrospector.setAccessor( new MockAccessor( null ) );
552 MetaClassIntrospector.clearCompleteCache();
553 final Attribute[] results = Attributes.getAttributes( constructor );
554 assertEquals( "attributes.length", 0, results.length );
555 }
556
557 public void testGetAttributesForConstructor()
558 {
559 final String name = "name";
560 final Attribute attribute1 = new Attribute( name );
561 final Attribute attribute2 = new Attribute( name );
562 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
563 final Constructor constructor =
564 AttributesTestCase.class.getDeclaredConstructors()[ 0 ];
565 final Class[] types = constructor.getParameterTypes();
566 final ParameterDescriptor[] parameters = new ParameterDescriptor[ types.length ];
567 for( int i = 0; i < types.length; i++ )
568 {
569 parameters[ i ] =
570 new ParameterDescriptor( "", types[ i ].getName() );
571 }
572 final MethodDescriptor methodDescriptor =
573 new MethodDescriptor( getConstructorName( constructor ),
574 "",
575 parameters,
576 attributes, attributes );
577 final ClassDescriptor descriptor =
578 new ClassDescriptor( AttributesTestCase.class.getName(),
579 Attribute.EMPTY_SET, Attribute.EMPTY_SET,
580 FieldDescriptor.EMPTY_SET,
581 new MethodDescriptor[]{methodDescriptor} );
582 MetaClassIntrospector.setAccessor( new MockAccessor( descriptor ) );
583 MetaClassIntrospector.clearCompleteCache();
584 final Attribute[] results = Attributes.getAttributes( constructor );
585 assertEquals( "attributes.length", 2, results.length );
586 assertEquals( "attributes[ 0 ]", attribute1, results[ 0 ] );
587 assertEquals( "attributes[ 1 ]", attribute2, results[ 1 ] );
588 }
589
590 public void testGetAttributesForConstructorWithNameSansMetaData()
591 {
592 final Constructor constructor =
593 AttributesTestCase.class.getDeclaredConstructors()[ 0 ];
594
595 MetaClassIntrospector.setAccessor( new MockAccessor( null ) );
596 MetaClassIntrospector.clearCompleteCache();
597 final Attribute[] results =
598 Attributes.getAttributes( constructor, "name" );
599 assertEquals( "attributes.length", 0, results.length );
600 }
601
602 public void testGetAttributesForConstructorWithName()
603 {
604 final String name = "name";
605 final Attribute attribute1 = new Attribute( name );
606 final Attribute attribute2 = new Attribute( "bleh" );
607 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
608
609 final Constructor constructor =
610 AttributesTestCase.class.getDeclaredConstructors()[ 0 ];
611
612 final Class[] types = constructor.getParameterTypes();
613 final ParameterDescriptor[] parameters = new ParameterDescriptor[ types.length ];
614 for( int i = 0; i < types.length; i++ )
615 {
616 parameters[ i ] =
617 new ParameterDescriptor( "", types[ i ].getName() );
618 }
619
620 final MethodDescriptor methodDescriptor =
621 new MethodDescriptor( getConstructorName( constructor ),
622 "",
623 parameters,
624 attributes, attributes );
625 final ClassDescriptor descriptor =
626 new ClassDescriptor( AttributesTestCase.class.getName(),
627 Attribute.EMPTY_SET, Attribute.EMPTY_SET,
628 FieldDescriptor.EMPTY_SET,
629 new MethodDescriptor[]{methodDescriptor} );
630 MetaClassIntrospector.setAccessor( new MockAccessor( descriptor ) );
631 MetaClassIntrospector.clearCompleteCache();
632 final Attribute[] results =
633 Attributes.getAttributes( constructor, name );
634 assertEquals( "attributes.length", 1, results.length );
635 assertEquals( "attributes[ 0 ]", attribute1, results[ 0 ] );
636 }
637
638 public void testGetAttributeForConstructorWithNameSansMetaData()
639 {
640 final Constructor constructor =
641 AttributesTestCase.class.getDeclaredConstructors()[ 0 ];
642 MetaClassIntrospector.setAccessor( new MockAccessor( null ) );
643 MetaClassIntrospector.clearCompleteCache();
644
645 final Attribute result =
646 Attributes.getAttribute( constructor, "name" );
647 assertEquals( "attribute", null, result );
648 }
649
650 public void testGetAttributeForConstructorWithName()
651 {
652 final String name = "name";
653 final Attribute attribute1 = new Attribute( name );
654 final Attribute attribute2 = new Attribute( "bleh" );
655 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
656
657 final Constructor constructor =
658 AttributesTestCase.class.getDeclaredConstructors()[ 0 ];
659 final Class[] types = constructor.getParameterTypes();
660 final ParameterDescriptor[] parameters = new ParameterDescriptor[ types.length ];
661 for( int i = 0; i < types.length; i++ )
662 {
663 parameters[ i ] =
664 new ParameterDescriptor( "", types[ i ].getName() );
665 }
666 final MethodDescriptor methodDescriptor =
667 new MethodDescriptor( getConstructorName( constructor ),
668 "",
669 parameters,
670 attributes, attributes );
671 final ClassDescriptor descriptor =
672 new ClassDescriptor( AttributesTestCase.class.getName(),
673 Attribute.EMPTY_SET, Attribute.EMPTY_SET,
674 FieldDescriptor.EMPTY_SET,
675 new MethodDescriptor[]{methodDescriptor} );
676 MetaClassIntrospector.setAccessor( new MockAccessor( descriptor ) );
677 MetaClassIntrospector.clearCompleteCache();
678
679 final Attribute result =
680 Attributes.getAttribute( constructor, name );
681 assertEquals( "attribute", attribute1, result );
682 }
683
684 private String getConstructorName( final Constructor constructor )
685 {
686 String name = constructor.getName();
687 final int index = name.lastIndexOf( "." );
688 if( -1 != index )
689 {
690 name = name.substring( index + 1 );
691 }
692 return name;
693 }
694
695 public void testGetAttributeForConstructorWithMatchingNamedCtorButDifferentParameters()
696 {
697 final String name = "name";
698 final Attribute attribute1 = new Attribute( name );
699 final Attribute attribute2 = new Attribute( "bleh" );
700 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
701
702 final Constructor constructor =
703 AttributesTestCase.class.getDeclaredConstructors()[ 0 ];
704 final ParameterDescriptor[] parameters = new ParameterDescriptor[]
705 {
706 new ParameterDescriptor( "notExist", "java.lang.Integer" )
707 };
708 final MethodDescriptor methodDescriptor =
709 new MethodDescriptor( getConstructorName( constructor ),
710 "",
711 parameters,
712 attributes, attributes );
713 final ClassDescriptor descriptor =
714 new ClassDescriptor( AttributesTestCase.class.getName(),
715 Attribute.EMPTY_SET, Attribute.EMPTY_SET,
716 FieldDescriptor.EMPTY_SET,
717 new MethodDescriptor[]{methodDescriptor} );
718 MetaClassIntrospector.setAccessor( new MockAccessor( descriptor ) );
719 MetaClassIntrospector.clearCompleteCache();
720
721 final Attribute[] results = Attributes.getAttributes( constructor );
722 assertEquals( "attributes.length", 0, results.length );
723 }
724
725 public void testGetAttributeForMethodWithMatchingNamedMethodButDifferentParameters()
726 {
727 final String name = "name";
728 final Attribute attribute1 = new Attribute( name );
729 final Attribute attribute2 = new Attribute( "bleh" );
730 final Attribute[] attributes = new Attribute[]{attribute1, attribute2};
731
732 final Method method =
733 AttributesTestCase.class.getDeclaredMethods()[ 0 ];
734 final ParameterDescriptor[] parameters = new ParameterDescriptor[]
735 {
736 new ParameterDescriptor( "notExist", "java.lang.Integer" )
737 };
738 final MethodDescriptor methodDescriptor =
739 new MethodDescriptor( method.getName(),
740 "",
741 parameters,
742 attributes, attributes );
743 final ClassDescriptor descriptor =
744 new ClassDescriptor( AttributesTestCase.class.getName(),
745 Attribute.EMPTY_SET, Attribute.EMPTY_SET,
746 FieldDescriptor.EMPTY_SET,
747 new MethodDescriptor[]{methodDescriptor} );
748 MetaClassIntrospector.setAccessor( new MockAccessor( descriptor ) );
749 MetaClassIntrospector.clearCompleteCache();
750
751 final Attribute[] results = Attributes.getAttributes( method );
752 assertEquals( "attributes.length", 0, results.length );
753 }
754
755 public void testGetConstructorOnDefaultPackageClass()
756 throws Exception
757 {
758 final Class clazz = Class.forName( "DefaultPackageClass" );
759 final Constructor constructor =
760 clazz.getDeclaredConstructors()[ 0 ];
761 final MethodDescriptor methodDescriptor =
762 new MethodDescriptor( constructor.getName(),
763 "",
764 ParameterDescriptor.EMPTY_SET,
765 Attribute.EMPTY_SET, Attribute.EMPTY_SET );
766 final ClassDescriptor descriptor =
767 new ClassDescriptor( AttributesTestCase.class.getName(),
768 Attribute.EMPTY_SET, Attribute.EMPTY_SET,
769 FieldDescriptor.EMPTY_SET,
770 new MethodDescriptor[]{methodDescriptor} );
771 MetaClassIntrospector.setAccessor( new MockAccessor( descriptor ) );
772 MetaClassIntrospector.clearCompleteCache();
773
774 final Attribute[] results = Attributes.getAttributes( constructor );
775 assertEquals( "attributes.length", 0, results.length );
776 }
777 }