1   /*
2    * Copyright (C) The MetaClass Group. All rights reserved.
3    *
4    * This software is published under the terms of the Spice
5    * Software License version 1.1, a copy of which has been included
6    * with this distribution in the LICENSE.txt file.
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 }