KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > codehaus > dna > tools > verifier > ComponentVerifierTestCase


1 /*
2  * Copyright (C) The Spice 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.dna.tools.verifier;
9
10 import junit.framework.TestCase;
11 import java.util.ArrayList JavaDoc;
12 import java.util.List JavaDoc;
13 import java.util.Properties JavaDoc;
14 import java.util.Arrays JavaDoc;
15 import java.awt.event.ActionListener JavaDoc;
16
17 import org.codehaus.dna.Configurable;
18 import org.codehaus.dna.Configuration;
19 import org.codehaus.dna.tools.verifier.ComponentVerifier;
20 import org.codehaus.dna.tools.verifier.VerifyIssue;
21 import org.codehaus.metaclass.introspector.MetaClassIntrospector;
22 import org.codehaus.metaclass.model.Attribute;
23 import org.codehaus.metaclass.model.ClassDescriptor;
24 import org.codehaus.metaclass.model.FieldDescriptor;
25 import org.codehaus.metaclass.model.MethodDescriptor;
26 import org.codehaus.metaclass.model.ParameterDescriptor;
27 import org.codehaus.metaclass.Attributes;
28
29 /**
30  *
31  * @author Peter Donald
32  * @version $Revision: 1.1 $ $Date: 2004/04/18 20:13:44 $
33  */

34 public class ComponentVerifierTestCase
35     extends TestCase
36 {
37     public void testVerifyNonArrayWithNonArray()
38         throws Exception JavaDoc
39     {
40         final ComponentVerifier verifier = new ComponentVerifier();
41         final List JavaDoc issues = new ArrayList JavaDoc();
42         verifier.verifyNonArray( Object JavaDoc.class, issues );
43         assertNoIssues( issues );
44     }
45
46     public void testVerifyNonArrayWithArray()
47         throws Exception JavaDoc
48     {
49         final ComponentVerifier verifier = new ComponentVerifier();
50         final List JavaDoc issues = new ArrayList JavaDoc();
51         verifier.verifyNonArray( Object JavaDoc[].class, issues );
52         assertSingleIssue( issues, "The class is an array.", true, false );
53     }
54
55     public void testVerifyNonInterfaceWithNonInterface()
56         throws Exception JavaDoc
57     {
58         final ComponentVerifier verifier = new ComponentVerifier();
59         final List JavaDoc issues = new ArrayList JavaDoc();
60         verifier.verifyNonInterface( Object JavaDoc.class, issues );
61         assertNoIssues( issues );
62     }
63
64     public void testVerifyNonInterfaceWithInterface()
65         throws Exception JavaDoc
66     {
67         final ComponentVerifier verifier = new ComponentVerifier();
68         final List JavaDoc issues = new ArrayList JavaDoc();
69         verifier.verifyNonInterface( ActionListener JavaDoc.class, issues );
70         assertSingleIssue( issues, "The class is an interface.", true, false );
71     }
72
73     public void testVerifyNonPrimitiveWithNonInterface()
74         throws Exception JavaDoc
75     {
76         final ComponentVerifier verifier = new ComponentVerifier();
77         final List JavaDoc issues = new ArrayList JavaDoc();
78         verifier.verifyNonPrimitive( Object JavaDoc.class, issues );
79         assertNoIssues( issues );
80     }
81
82     public void testVerifyNonPrimitiveWithPrimitive()
83         throws Exception JavaDoc
84     {
85         final ComponentVerifier verifier = new ComponentVerifier();
86         final List JavaDoc issues = new ArrayList JavaDoc();
87         verifier.verifyNonPrimitive( Integer.TYPE, issues );
88         assertSingleIssue( issues, "The class represents a primitive type.", true, false );
89     }
90
91     public void testVerifyPublicThatPasses()
92         throws Exception JavaDoc
93     {
94         final ComponentVerifier verifier = new ComponentVerifier();
95         final List JavaDoc issues = new ArrayList JavaDoc();
96         verifier.verifyPublic( Object JavaDoc.class, issues );
97         assertNoIssues( issues );
98     }
99
100     public void testVerifyPublicThatNoPasses()
101         throws Exception JavaDoc
102     {
103         final ComponentVerifier verifier = new ComponentVerifier();
104         final List JavaDoc issues = new ArrayList JavaDoc();
105         verifier.verifyPublic( AbstractNonPublicClassWithNonPublicCtor.class, issues );
106         assertSingleIssue( issues, "The class is not public.", true, false );
107     }
108
109     public void testVerifyNonAbstractThatPasses()
110         throws Exception JavaDoc
111     {
112         final ComponentVerifier verifier = new ComponentVerifier();
113         final List JavaDoc issues = new ArrayList JavaDoc();
114         verifier.verifyNonAbstract( Object JavaDoc.class, issues );
115         assertNoIssues( issues );
116     }
117
118     public void testVerifyNonAbstractThatNoPasses()
119         throws Exception JavaDoc
120     {
121         final ComponentVerifier verifier = new ComponentVerifier();
122         final List JavaDoc issues = new ArrayList JavaDoc();
123         verifier.verifyNonAbstract( AbstractNonPublicClassWithNonPublicCtor.class, issues );
124         assertSingleIssue( issues, "The class is abstract.", true, false );
125     }
126
127     public void testVerifyNoArgConstructorThatPasses()
128         throws Exception JavaDoc
129     {
130         final ComponentVerifier verifier = new ComponentVerifier();
131         final List JavaDoc issues = new ArrayList JavaDoc();
132         verifier.verifyNoArgConstructor( Object JavaDoc.class, issues );
133         assertNoIssues( issues );
134     }
135
136     public void testVerifyNoArgConstructorThatNoPasses()
137         throws Exception JavaDoc
138     {
139         final ComponentVerifier verifier = new ComponentVerifier();
140         final List JavaDoc issues = new ArrayList JavaDoc();
141         verifier.verifyNoArgConstructor( AbstractNonPublicClassWithNonPublicCtor.class, issues );
142         assertSingleIssue( issues, "The class does not have a public default constructor.", true, false );
143     }
144
145     public void testVerifyServiceNotALifecycleThatPasses()
146         throws Exception JavaDoc
147     {
148         final ComponentVerifier verifier = new ComponentVerifier();
149         final List JavaDoc issues = new ArrayList JavaDoc();
150         verifier.verifyServiceNotALifecycle( Object JavaDoc.class, issues );
151         assertNoIssues( issues );
152     }
153
154     public void testVerifyServiceNotALifecycleThatNoPasses()
155         throws Exception JavaDoc
156     {
157         final ComponentVerifier verifier = new ComponentVerifier();
158         final List JavaDoc issues = new ArrayList JavaDoc();
159         verifier.verifyServiceNotALifecycle( LifecycleExtendingService.class, issues );
160         assertSingleIssue( issues, "Service " + LifecycleExtendingService.class.getName() +
161                                    " extends lifecycle interface " +
162                                    Configurable.class.getName() + ".", true, false );
163     }
164
165     public void testVerifyServiceIsPublicThatPasses()
166         throws Exception JavaDoc
167     {
168         final ComponentVerifier verifier = new ComponentVerifier();
169         final List JavaDoc issues = new ArrayList JavaDoc();
170         verifier.verifyServiceIsPublic( Object JavaDoc.class, issues );
171         assertNoIssues( issues );
172     }
173
174     public void testVerifyServiceIsPublicThatNoPasses()
175         throws Exception JavaDoc
176     {
177         final ComponentVerifier verifier = new ComponentVerifier();
178         final List JavaDoc issues = new ArrayList JavaDoc();
179         verifier.verifyServiceIsPublic( LifecycleExtendingService.class, issues );
180         assertSingleIssue( issues, "Service " + LifecycleExtendingService.class.getName() +
181                                    " must be public.", true, false );
182     }
183
184     public void testVerifyServiceIsaInterfaceThatPasses()
185         throws Exception JavaDoc
186     {
187         final ComponentVerifier verifier = new ComponentVerifier();
188         final List JavaDoc issues = new ArrayList JavaDoc();
189         verifier.verifyServiceIsaInterface( ActionListener JavaDoc.class, issues );
190         assertNoIssues( issues );
191     }
192
193     public void testVerifyServiceIsaInterfaceThatNoPasses()
194         throws Exception JavaDoc
195     {
196         final ComponentVerifier verifier = new ComponentVerifier();
197         final List JavaDoc issues = new ArrayList JavaDoc();
198         verifier.verifyServiceIsaInterface( Object JavaDoc.class, issues );
199         assertSingleIssue( issues, "Service " + Object JavaDoc.class.getName() +
200                                    " must be an interface.", true, false );
201     }
202
203     public void testVerifyClass()
204         throws Exception JavaDoc
205     {
206         final ComponentVerifier verifier = new ComponentVerifier();
207         final List JavaDoc issues = new ArrayList JavaDoc();
208         verifier.verifyClass( Object JavaDoc.class, issues );
209         assertNoIssues( issues );
210     }
211
212     public void testVerifyService()
213         throws Exception JavaDoc
214     {
215         final ComponentVerifier verifier = new ComponentVerifier();
216         final List JavaDoc issues = new ArrayList JavaDoc();
217         verifier.verifyService( ActionListener JavaDoc.class, issues );
218         assertNoIssues( issues );
219     }
220
221     public void testVerifyImplementsServicesThatPasses()
222         throws Exception JavaDoc
223     {
224         final ComponentVerifier verifier = new ComponentVerifier();
225         final List JavaDoc issues = new ArrayList JavaDoc();
226         final Class JavaDoc[] services = new Class JavaDoc[]{ActionListener JavaDoc.class};
227         verifier.verifyImplementsServices( ActionListenerComponent.class, services, issues );
228         assertNoIssues( issues );
229     }
230
231     public void testVerifyImplementsServicesThatNoPasses()
232         throws Exception JavaDoc
233     {
234         final ComponentVerifier verifier = new ComponentVerifier();
235         final List JavaDoc issues = new ArrayList JavaDoc();
236         final Class JavaDoc[] services = new Class JavaDoc[]{ActionListener JavaDoc.class};
237         verifier.verifyImplementsServices( Object JavaDoc.class, services, issues );
238         assertSingleIssue( issues, "The metadata declares that the class " +
239                                    "supports the service " +
240                                    ActionListener JavaDoc.class.getName() +
241                                    " but the class does not implement the " +
242                                    "service interface.", true, false );
243     }
244
245     public void testVerifyMetaDataThatPasses()
246         throws Exception JavaDoc
247     {
248         final ComponentVerifier verifier = new ComponentVerifier();
249         MetaClassIntrospector.setAccessor( new SimpleAccessor() );
250         MetaClassIntrospector.clearCompleteCache();
251         final List JavaDoc issues = new ArrayList JavaDoc();
252         verifier.verifyMetaData( ComponentVerifierTestCase.class, issues );
253         assertNoIssues( issues );
254     }
255
256     public void testVerifyMetaDataThatNoPasses()
257         throws Exception JavaDoc
258     {
259         final ComponentVerifier verifier = new ComponentVerifier();
260         final List JavaDoc issues = new ArrayList JavaDoc();
261         MetaClassIntrospector.setAccessor( new NullAccessor() );
262         MetaClassIntrospector.clearCompleteCache();
263         verifier.verifyMetaData( Object JavaDoc.class, issues );
264         assertSingleIssue( issues,
265                            "The class does not specify correct " +
266                            "metadata. Missing expected dna.component " +
267                            "attribute in the class attributes.",
268                            true, false );
269     }
270
271     public void testGetServiceClasses()
272         throws Exception JavaDoc
273     {
274         final ComponentVerifier verifier = new ComponentVerifier();
275         MetaClassIntrospector.setAccessor( new BadServiceAccessor() );
276         MetaClassIntrospector.clearCompleteCache();
277         final List JavaDoc issues = new ArrayList JavaDoc();
278         verifier.getServiceClasses( ComponentVerifier.class, issues );
279         assertSingleIssue( issues,
280                            "Unable to load service interface " +
281                            BadServiceAccessor.BAD_SERVICE +
282                            " for class. Reason: " +
283                            "java.lang.ClassNotFoundException: I-No-Exist!.",
284                            true, false );
285     }
286
287     public void testVerifyType()
288         throws Exception JavaDoc
289     {
290         final Properties JavaDoc parameters = new Properties JavaDoc();
291         parameters.setProperty( "type", ActionListener JavaDoc.class.getName() );
292         final Attribute[] attributes = new Attribute[]
293         {
294             new Attribute( "dna.component" ),
295             new Attribute( "dna.service", parameters )
296         };
297         final ClassDescriptor descriptor =
298             new ClassDescriptor( BasicComponent.class.getName(),
299                                  attributes,
300                                  attributes,
301                                  FieldDescriptor.EMPTY_SET,
302                                  MethodDescriptor.EMPTY_SET );
303         final ComponentVerifier verifier = new ComponentVerifier();
304         final RegistrationMetaClassAccessor accessor = new RegistrationMetaClassAccessor();
305         accessor.registerDescriptor( descriptor );
306         MetaClassIntrospector.setAccessor( accessor );
307         MetaClassIntrospector.clearCompleteCache();
308         final VerifyIssue[] issues = verifier.verifyType( BasicComponent.class );
309         assertEquals( "issues.length", 0, issues.length );
310     }
311
312     public void testVerifyDependencyOptionalValidThatPasses()
313         throws Exception JavaDoc
314     {
315         final ComponentVerifier verifier = new ComponentVerifier();
316         final List JavaDoc issues = new ArrayList JavaDoc();
317         verifier.verifyDependencyOptionalValid( "true", issues );
318         assertNoIssues( issues );
319     }
320
321     public void testVerifyDependencyOptionalValidThatNoPasses()
322         throws Exception JavaDoc
323     {
324         final ComponentVerifier verifier = new ComponentVerifier();
325         final List JavaDoc issues = new ArrayList JavaDoc();
326         verifier.verifyDependencyOptionalValid( "blah", issues );
327         assertSingleIssue( issues,
328                            "The dna.dependency attribute specifies " +
329                            "optional parameter as \"blah\" that is not one " +
330                            "of true or false.",
331                            true, false );
332     }
333
334     public void testVerifyDependencyKeyConformsThatPassesWithQualifier()
335         throws Exception JavaDoc
336     {
337         final ComponentVerifier verifier = new ComponentVerifier();
338         final List JavaDoc issues = new ArrayList JavaDoc();
339         verifier.verifyDependencyKeyConforms( "X", "X/X", issues );
340         assertNoIssues( issues );
341     }
342
343     public void testVerifyDependencyKeyConformsThatPassesWithoutQualifier()
344         throws Exception JavaDoc
345     {
346         final ComponentVerifier verifier = new ComponentVerifier();
347         final List JavaDoc issues = new ArrayList JavaDoc();
348         verifier.verifyDependencyKeyConforms( "X", "X", issues );
349         assertNoIssues( issues );
350     }
351
352     public void testVerifyDependencyKeyConformsThatNoPasses()
353         throws Exception JavaDoc
354     {
355         final ComponentVerifier verifier = new ComponentVerifier();
356         final List JavaDoc issues = new ArrayList JavaDoc();
357         verifier.verifyDependencyKeyConforms( "X", "blah", issues );
358         assertSingleIssue( issues,
359                            "The dna.dependency attribute specifies the key " +
360                            "blah which does not conform to recomendation of " +
361                            "(type)[/(qualifier)].",
362                            false, false );
363     }
364
365     public void testVerifyDependencyTypeThatPasses()
366         throws Exception JavaDoc
367     {
368         final ComponentVerifier verifier = new ComponentVerifier();
369         final List JavaDoc issues = new ArrayList JavaDoc();
370         verifier.verifyDependencyType( LifecycleExtendingService.class,
371                                        ActionListener JavaDoc.class.getName(),
372                                        issues );
373         assertNoIssues( issues );
374     }
375
376     public void testVerifyDependencyTypeThatNoPasses()
377         throws Exception JavaDoc
378     {
379         final ComponentVerifier verifier = new ComponentVerifier();
380         final List JavaDoc issues = new ArrayList JavaDoc();
381         verifier.verifyDependencyType( LifecycleExtendingService.class,
382                                        "INoExist!",
383                                        issues );
384         assertSingleIssue( issues,
385                            "Unable to load dependency with type INoExist! " +
386                            "for class. Reason: " +
387                            "java.lang.ClassNotFoundException: INoExist!.",
388                            true, false );
389     }
390
391     public void testVerifyOptionalParameterThatPasses()
392         throws Exception JavaDoc
393     {
394         final ComponentVerifier verifier = new ComponentVerifier();
395         final List JavaDoc issues = new ArrayList JavaDoc();
396         verifier.verifyOptionalParameter( "true", issues );
397         assertNoIssues( issues );
398     }
399
400     public void testVerifyOptionalParameterThatNoPasses()
401         throws Exception JavaDoc
402     {
403         final ComponentVerifier verifier = new ComponentVerifier();
404         final List JavaDoc issues = new ArrayList JavaDoc();
405         verifier.verifyOptionalParameter( null, issues );
406         assertSingleIssue( issues,
407                            "The dna.dependency attribute does not " +
408                            "specify the parameter optional.",
409                            true, false );
410     }
411
412     public void testVerifyDependencyMetaDataThatPasses()
413         throws Exception JavaDoc
414     {
415         final ComponentVerifier verifier = new ComponentVerifier();
416         final List JavaDoc issues = new ArrayList JavaDoc();
417         final Properties JavaDoc parameters = new Properties JavaDoc();
418         parameters.setProperty( "optional", "false" );
419         parameters.setProperty( "type", ActionListener JavaDoc.class.getName() );
420         parameters.setProperty( "key", ActionListener JavaDoc.class.getName() );
421         verifier.verifyDependencyMetaData( LifecycleExtendingService.class,
422                                            new Attribute( "dna.dependency", parameters ),
423                                            issues );
424         assertNoIssues( issues );
425     }
426
427     public void testVerifyDependencyMetaDataThatNoPassesDueToMissingType()
428         throws Exception JavaDoc
429     {
430         final ComponentVerifier verifier = new ComponentVerifier();
431         final List JavaDoc issues = new ArrayList JavaDoc();
432         final Properties JavaDoc parameters = new Properties JavaDoc();
433         parameters.setProperty( "optional", "false" );
434         verifier.verifyDependencyMetaData( LifecycleExtendingService.class,
435                                            new Attribute( "dna.dependency", parameters ),
436                                            issues );
437         assertSingleIssue( issues,
438                            "The dna.dependency attribute does not specify the parameter type.",
439                            true, false );
440     }
441
442     public void testVerifyDependencyMetaDataThatNoPassesDueToMissingKey()
443         throws Exception JavaDoc
444     {
445         final ComponentVerifier verifier = new ComponentVerifier();
446         final List JavaDoc issues = new ArrayList JavaDoc();
447         final Properties JavaDoc parameters = new Properties JavaDoc();
448         parameters.setProperty( "optional", "false" );
449         parameters.setProperty( "type", ActionListener JavaDoc.class.getName() );
450         final Attribute attribute = new Attribute( "dna.dependency", parameters );
451         verifier.verifyDependencyMetaData( LifecycleExtendingService.class,
452                                            attribute,
453                                            issues );
454         assertSingleIssue( issues,
455                            "The dna.dependency attribute does not specify the parameter key.",
456                            true, false );
457     }
458
459     public void testVerifyDependencyMetaDataThatPassesDueToNotImplementingComposable()
460         throws Exception JavaDoc
461     {
462         final ComponentVerifier verifier = new ComponentVerifier();
463         final List JavaDoc issues = new ArrayList JavaDoc();
464         verifier.verifyDependencyMetaData( Object JavaDoc.class, issues );
465         assertNoIssues( issues );
466     }
467
468     public void testVerifyDependencyMetaDataThatPassesDueToNoMetaData()
469         throws Exception JavaDoc
470     {
471         final ComponentVerifier verifier = new ComponentVerifier();
472         final List JavaDoc issues = new ArrayList JavaDoc();
473         MetaClassIntrospector.setAccessor( new SimpleAccessor() );
474         MetaClassIntrospector.clearCompleteCache();
475         verifier.verifyDependencyMetaData( BasicComponent.class, issues );
476         assertNoIssues( issues );
477     }
478
479     public void testVerifyDependencyMetaDataThatPassesWithMetaData()
480         throws Exception JavaDoc
481     {
482         final ComponentVerifier verifier = new ComponentVerifier();
483         final List JavaDoc issues = new ArrayList JavaDoc();
484         MetaClassIntrospector.setAccessor( new AccessorWithDependencyMetaData() );
485         MetaClassIntrospector.clearCompleteCache();
486         verifier.verifyDependencyMetaData( BasicComponent.class, issues );
487         assertNoIssues( issues );
488     }
489
490     public void testVerifyConfigurationMetaDataThatPassesAsNotConfigurable()
491         throws Exception JavaDoc
492     {
493         final ComponentVerifier verifier = new ComponentVerifier();
494         final List JavaDoc issues = new ArrayList JavaDoc();
495         MetaClassIntrospector.setAccessor( new AccessorWithDependencyMetaData() );
496         MetaClassIntrospector.clearCompleteCache();
497         verifier.verifyConfigurationMetaData( Object JavaDoc.class, issues );
498         assertNoIssues( issues );
499     }
500
501     public void testVerifyConfigurationMetaDataThatPassesAsNoMetaData()
502         throws Exception JavaDoc
503     {
504         final ComponentVerifier verifier = new ComponentVerifier();
505         final List JavaDoc issues = new ArrayList JavaDoc();
506         MetaClassIntrospector.setAccessor( new SimpleAccessor() );
507         MetaClassIntrospector.clearCompleteCache();
508         verifier.verifyConfigurationMetaData( BasicComponent.class, issues );
509         assertNoIssues( issues );
510     }
511
512     public void testVerifyConfigurationMetaDataThatPassesAsValidMetaData()
513         throws Exception JavaDoc
514     {
515         final ComponentVerifier verifier = new ComponentVerifier();
516         final List JavaDoc issues = new ArrayList JavaDoc();
517
518         final Properties JavaDoc parameters = new Properties JavaDoc();
519         parameters.setProperty( "location", "BasicComponent-schema.xml" );
520         final Attribute[] attributes = new Attribute[]
521         {
522             new Attribute( "dna.configuration", parameters )
523         };
524         final ParameterDescriptor param =
525             new ParameterDescriptor( "X", Configuration.class.getName() );
526         final ParameterDescriptor[] params = new ParameterDescriptor[]{param};
527         final MethodDescriptor method =
528             new MethodDescriptor( "configure", "", params, attributes, attributes );
529         final ClassDescriptor descriptor =
530             new ClassDescriptor( BasicComponent.class.getName(),
531                                  Attribute.EMPTY_SET,
532                                  Attribute.EMPTY_SET,
533                                  FieldDescriptor.EMPTY_SET,
534                                  new MethodDescriptor[]{method} );
535         final RegistrationMetaClassAccessor accessor = new RegistrationMetaClassAccessor();
536         accessor.registerDescriptor( descriptor );
537         MetaClassIntrospector.setAccessor( accessor );
538         MetaClassIntrospector.clearCompleteCache();
539         verifier.verifyConfigurationMetaData( BasicComponent.class, issues );
540         assertNoIssues( issues );
541     }
542
543     public void testVerifyConfigurationMetaDataThatNoPassesAsInvalidMetaData()
544         throws Exception JavaDoc
545     {
546         final ComponentVerifier verifier = new ComponentVerifier();
547         final List JavaDoc issues = new ArrayList JavaDoc();
548
549         final Properties JavaDoc parameters = new Properties JavaDoc();
550         final Attribute[] attributes = new Attribute[]
551         {
552             new Attribute( "dna.configuration", parameters )
553         };
554         final ParameterDescriptor param =
555             new ParameterDescriptor( "X", Configuration.class.getName() );
556         final ParameterDescriptor[] params = new ParameterDescriptor[]{param};
557         final MethodDescriptor method =
558             new MethodDescriptor( "configure", "", params, attributes, attributes );
559         final ClassDescriptor descriptor =
560             new ClassDescriptor( BasicComponent.class.getName(),
561                                  Attribute.EMPTY_SET,
562                                  Attribute.EMPTY_SET,
563                                  FieldDescriptor.EMPTY_SET,
564                                  new MethodDescriptor[]{method} );
565         final RegistrationMetaClassAccessor accessor = new RegistrationMetaClassAccessor();
566         accessor.registerDescriptor( descriptor );
567         MetaClassIntrospector.setAccessor( accessor );
568         MetaClassIntrospector.clearCompleteCache();
569         verifier.verifyConfigurationMetaData( BasicComponent.class, issues );
570
571         assertSingleIssue( issues,
572                            "The dna.configuration attribute is missing the " +
573                            "location parameter.",
574                            true, false );
575     }
576
577     public void testverifyLocationThatPasses()
578         throws Exception JavaDoc
579     {
580         final ComponentVerifier verifier = new ComponentVerifier();
581         final List JavaDoc issues = new ArrayList JavaDoc();
582         MetaClassIntrospector.setAccessor( new AccessorWithDependencyMetaData() );
583         MetaClassIntrospector.clearCompleteCache();
584         verifier.verifyLocation( BasicComponent.class,
585                                  "BasicComponent-schema.xml",
586                                  issues );
587         assertNoIssues( issues );
588     }
589
590     public void testverifyLocationThatNoPasses()
591         throws Exception JavaDoc
592     {
593         final ComponentVerifier verifier = new ComponentVerifier();
594         final List JavaDoc issues = new ArrayList JavaDoc();
595         MetaClassIntrospector.setAccessor( new AccessorWithDependencyMetaData() );
596         MetaClassIntrospector.clearCompleteCache();
597         verifier.verifyLocation( BasicComponent.class,
598                                  "NoExist",
599                                  issues );
600         assertSingleIssue( issues,
601                            "Unable to load configuration schema from location " +
602                            "NoExist.",
603                            true, false );
604     }
605
606     private void assertNoIssues( final List JavaDoc issues )
607     {
608         if( 0 != issues.size() )
609         {
610             final int count = issues.size();
611             for( int i = 0; i < count; i++ )
612             {
613                 final VerifyIssue issue = (VerifyIssue)issues.get( i );
614                 System.out.println(
615                     "issue.getDescription() = " + issue.getDescription() );
616             }
617         }
618         assertEquals( "issues.length", 0, issues.size() );
619     }
620
621     private void assertSingleIssue( final List JavaDoc issues,
622                                     final String JavaDoc message,
623                                     final boolean error,
624                                     final boolean warning )
625     {
626         assertEquals( "issues.length", 1, issues.size() );
627         final VerifyIssue issue = (VerifyIssue)issues.get( 0 );
628         assertEquals( "issues[0].isWarning", warning, issue.isWarning() );
629         assertEquals( "issues[0].isError", error, issue.isError() );
630         assertEquals( "issues[0].description", message, issue.getDescription() );
631     }
632 }
633
Popular Tags