1   package xjavadoc;
2   
3   import junit.framework.*;
4   import xjavadoc.*;
5   import xjavadoc.filesystem.*;
6   import java.io.File;
7   import java.util.Collection;
8   import java.util.Collections;
9   import java.util.List;
10  import java.util.ArrayList;
11  import java.util.Iterator;
12  import java.util.StringTokenizer;
13  
14  /***
15   * Automatically generated JUnit test for xjavadoc
16   *
17   * @author xjavadoc/xdoclet
18   * @created 8. januar 2002
19   * @todo-javadoc Write javadocs
20   */
21  public class XJavaDoc__GENERATED__Test extends TestCase {
22  
23  	private XClass _testedClass;
24  	private final XJavaDoc _xJavaDoc = new XJavaDoc();
25  
26  	private static final String tokenizeAndTrim( final String s ) {
27  		StringBuffer sb = new StringBuffer();
28  		StringTokenizer st = new StringTokenizer(s);
29  		while( st.hasMoreTokens() ) {
30  			sb.append( st.nextToken() ).append(" ");
31  		}
32  		return sb.toString().trim();
33  	}
34  
35  	public XJavaDoc__GENERATED__Test( String name ) {
36  		super( name );
37  	}
38  
39  	public void setUp() throws Exception {
40  		// hardcoded to xjavadoc's own sources
41  		File dir = new File(System.getProperty("basedir"),"src");
42  		_xJavaDoc.reset(true);
43  		_xJavaDoc.addSourceSet(new FileSourceSet(dir, null));
44  		_testedClass = _xJavaDoc.getXClass( "xjavadoc.XJavaDoc" );
45  	}
46  
47  	public void tearDown() {
48  	}
49  
50  	public void testPackage() {
51  		assertEquals( "xjavadoc", _testedClass.getContainingPackage().getName() );
52  	}
53  
54  	public void testSuperclass() {
55  		XClass superclass = _testedClass.getSuperclass();
56  		String superclassName;
57  		if( superclass == null ) {
58  			superclassName = "java.lang.Object";
59  		} else {
60  			superclassName = superclass.getQualifiedName();
61  		}
62  
63  		assertEquals( "java.lang.Object", superclassName );
64  	}
65  
66  	public void testInterfaces() {
67  		// not implemented in xdoclet yet
68  	}
69  
70  	public void testFields() {
71  
72  		// Sort the fields
73  		Collection fields = _testedClass.getFields();
74  		ArrayList sortedFields = new ArrayList();
75  		sortedFields.addAll(fields);
76  		Collections.sort(sortedFields);
77  		Iterator fieldIterator = sortedFields.iterator();
78  
79  		XField field = null;
80  		// test if field type is the same
81  		field = (XField) fieldIterator.next();
82  		assertEquals( "java.lang.String", field.getType().getQualifiedName() + field.getDimensionAsString());
83  		// test if field name is the same
84  		assertEquals( "IS_UNICODE", field.getName() );
85  		// test if field type is the same
86  		field = (XField) fieldIterator.next();
87  		assertEquals( "int", field.getType().getQualifiedName() + field.getDimensionAsString());
88  		// test if field name is the same
89  		assertEquals( "NO_IMPORTED_PACKAGES", field.getName() );
90  		// test if field type is the same
91  		field = (XField) fieldIterator.next();
92  		assertEquals( "int", field.getType().getQualifiedName() + field.getDimensionAsString());
93  		// test if field name is the same
94  		assertEquals( "ONE_OR_MORE_IMPORTED_PACKAGES", field.getName() );
95  		// test if field type is the same
96  		field = (XField) fieldIterator.next();
97  		assertEquals( "java.util.List", field.getType().getQualifiedName() + field.getDimensionAsString());
98  		// test if field name is the same
99  		assertEquals( "PRIMITIVES", field.getName() );
100 		// test if field type is the same
101 		field = (XField) fieldIterator.next();
102 		assertEquals( "java.util.Map", field.getType().getQualifiedName() + field.getDimensionAsString());
103 		// test if field name is the same
104 		assertEquals( "_abstractFileClasses", field.getName() );
105 		// test if field type is the same
106 		field = (XField) fieldIterator.next();
107 		assertEquals( "java.util.Map", field.getType().getQualifiedName() + field.getDimensionAsString());
108 		// test if field name is the same
109 		assertEquals( "_allSourceClasses", field.getName() );
110 		// test if field type is the same
111 		field = (XField) fieldIterator.next();
112 		assertEquals( "java.util.Map", field.getType().getQualifiedName() + field.getDimensionAsString());
113 		// test if field name is the same
114 		assertEquals( "_binaryClasses", field.getName() );
115 		// test if field type is the same
116 		field = (XField) fieldIterator.next();
117 		assertEquals( "long", field.getType().getQualifiedName() + field.getDimensionAsString());
118 		// test if field name is the same
119 		assertEquals( "_birthday", field.getName() );
120 		// test if field type is the same
121 		field = (XField) fieldIterator.next();
122 		assertEquals( "java.lang.String", field.getType().getQualifiedName() + field.getDimensionAsString());
123 		// test if field name is the same
124 		assertEquals( "_docEncoding", field.getName() );
125 		// test if field type is the same
126 		field = (XField) fieldIterator.next();
127 		assertEquals( "java.lang.String", field.getType().getQualifiedName() + field.getDimensionAsString());
128 		// test if field name is the same
129 		assertEquals( "_encoding", field.getName() );
130 		// test if field type is the same
131 		field = (XField) fieldIterator.next();
132 		assertEquals( "java.util.List", field.getType().getQualifiedName() + field.getDimensionAsString());
133 		// test if field name is the same
134 		assertEquals( "_logMessages", field.getName() );
135 		// test if field type is the same
136 		field = (XField) fieldIterator.next();
137 		assertEquals( "java.util.Map", field.getType().getQualifiedName() + field.getDimensionAsString());
138 		// test if field name is the same
139 		assertEquals( "_packages", field.getName() );
140 		// test if field type is the same
141 		field = (XField) fieldIterator.next();
142 		assertEquals( "java.util.HashMap", field.getType().getQualifiedName() + field.getDimensionAsString());
143 		// test if field name is the same
144 		assertEquals( "_primitiveClasses", field.getName() );
145 		// test if field type is the same
146 		field = (XField) fieldIterator.next();
147 		assertEquals( "java.util.Map", field.getType().getQualifiedName() + field.getDimensionAsString());
148 		// test if field name is the same
149 		assertEquals( "_properties", field.getName() );
150 		// test if field type is the same
151 		field = (XField) fieldIterator.next();
152 		assertEquals( "java.util.Set", field.getType().getQualifiedName() + field.getDimensionAsString());
153 		// test if field name is the same
154 		assertEquals( "_sourceSetClassNames", field.getName() );
155 		// test if field type is the same
156 		field = (XField) fieldIterator.next();
157 		assertEquals( "java.util.Map", field.getType().getQualifiedName() + field.getDimensionAsString());
158 		// test if field name is the same
159 		assertEquals( "_sourceSetSourceClasses", field.getName() );
160 		// test if field type is the same
161 		field = (XField) fieldIterator.next();
162 		assertEquals( "java.util.Collection", field.getType().getQualifiedName() + field.getDimensionAsString());
163 		// test if field name is the same
164 		assertEquals( "_sourceSetSourceClassesWithInnerClasses", field.getName() );
165 		// test if field type is the same
166 		field = (XField) fieldIterator.next();
167 		assertEquals( "java.util.Set", field.getType().getQualifiedName() + field.getDimensionAsString());
168 		// test if field name is the same
169 		assertEquals( "_sourceSets", field.getName() );
170 		// test if field type is the same
171 		field = (XField) fieldIterator.next();
172 		assertEquals( "xjavadoc.XTagFactory", field.getType().getQualifiedName() + field.getDimensionAsString());
173 		// test if field name is the same
174 		assertEquals( "_tagFactory", field.getName() );
175 		// test if field type is the same
176 		field = (XField) fieldIterator.next();
177 		assertEquals( "java.util.Map", field.getType().getQualifiedName() + field.getDimensionAsString());
178 		// test if field name is the same
179 		assertEquals( "_unknownClasses", field.getName() );
180 		// test if field type is the same
181 		field = (XField) fieldIterator.next();
182 		assertEquals( "boolean", field.getType().getQualifiedName() + field.getDimensionAsString());
183 		// test if field name is the same
184 		assertEquals( "_useNodeParser", field.getName() );
185 	}
186 
187 	public void testMethods() {
188 
189 		// Sort the methods
190 		Collection methods = _testedClass.getMethods();
191 		ArrayList sortedMethods = new ArrayList();
192 		sortedMethods.addAll(methods);
193 		Collections.sort(sortedMethods);
194 		Iterator methodIterator = sortedMethods.iterator();
195 		XMethod method = null;
196 
197 		Iterator parameters = null;
198 		XParameter parameter = null;
199 
200 		Iterator paramTags = null;
201 		XTag paramTag = null;
202 
203 	    	method = (XMethod) methodIterator.next();
204 		// test if return type is the same
205 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
206 
207 		// test if method name is the same
208 		assertEquals( "addAbstractFile", method.getName() );
209 
210 		// test if parameters are the same
211 		parameters = method.getParameters().iterator();
212 	        parameter = (XParameter) parameters.next();
213 		assertEquals( "qualifiedName", parameter.getName() );
214 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
215 	        parameter = (XParameter) parameters.next();
216 		assertEquals( "file", parameter.getName() );
217 		assertEquals( "xjavadoc.filesystem.AbstractFile", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
218 
219 		// test if doc is the same
220 		paramTags = method.getDoc().getTags("param",true).iterator();
221 
222 	    	method = (XMethod) methodIterator.next();
223 		// test if return type is the same
224 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
225 
226 		// test if method name is the same
227 		assertEquals( "addInnerClassRecursive", method.getName() );
228 
229 		// test if parameters are the same
230 		parameters = method.getParameters().iterator();
231 	        parameter = (XParameter) parameters.next();
232 		assertEquals( "outer", parameter.getName() );
233 		assertEquals( "xjavadoc.XClass", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
234 	        parameter = (XParameter) parameters.next();
235 		assertEquals( "c", parameter.getName() );
236 		assertEquals( "java.util.Collection", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
237 
238 		// test if doc is the same
239 		paramTags = method.getDoc().getTags("param",true).iterator();
240 	        paramTag = (XTag) paramTags.next();
241 		assertEquals( tokenizeAndTrim("outer  The feature to be added to the InnerClassRecursive attribute"), paramTag.getValue() );
242 	        paramTag = (XTag) paramTags.next();
243 		assertEquals( tokenizeAndTrim("c      The feature to be added to the InnerClassRecursive attribute"), paramTag.getValue() );
244 
245 	    	method = (XMethod) methodIterator.next();
246 		// test if return type is the same
247 		assertEquals( "xjavadoc.XPackage", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
248 
249 		// test if method name is the same
250 		assertEquals( "addPackageMaybe", method.getName() );
251 
252 		// test if parameters are the same
253 		parameters = method.getParameters().iterator();
254 	        parameter = (XParameter) parameters.next();
255 		assertEquals( "packageName", parameter.getName() );
256 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
257 
258 		// test if doc is the same
259 		paramTags = method.getDoc().getTags("param",true).iterator();
260 	        paramTag = (XTag) paramTags.next();
261 		assertEquals( tokenizeAndTrim("packageName  Describe the method parameter"), paramTag.getValue() );
262 
263 	    	method = (XMethod) methodIterator.next();
264 		// test if return type is the same
265 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
266 
267 		// test if method name is the same
268 		assertEquals( "addPrimitive", method.getName() );
269 
270 		// test if parameters are the same
271 		parameters = method.getParameters().iterator();
272 	        parameter = (XParameter) parameters.next();
273 		assertEquals( "name", parameter.getName() );
274 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
275 	        parameter = (XParameter) parameters.next();
276 		assertEquals( "type", parameter.getName() );
277 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
278 
279 		// test if doc is the same
280 		paramTags = method.getDoc().getTags("param",true).iterator();
281 	        paramTag = (XTag) paramTags.next();
282 		assertEquals( tokenizeAndTrim("name  Describe the method parameter"), paramTag.getValue() );
283 	        paramTag = (XTag) paramTags.next();
284 		assertEquals( tokenizeAndTrim("type  The feature to be added to the Primitive attribute"), paramTag.getValue() );
285 
286 	    	method = (XMethod) methodIterator.next();
287 		// test if return type is the same
288 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
289 
290 		// test if method name is the same
291 		assertEquals( "addSourceClass", method.getName() );
292 
293 		// test if parameters are the same
294 		parameters = method.getParameters().iterator();
295 	        parameter = (XParameter) parameters.next();
296 		assertEquals( "sourceClass", parameter.getName() );
297 		assertEquals( "xjavadoc.SourceClass", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
298 
299 		// test if doc is the same
300 		paramTags = method.getDoc().getTags("param",true).iterator();
301 	        paramTag = (XTag) paramTags.next();
302 		assertEquals( tokenizeAndTrim("sourceClass  Describe the method parameter"), paramTag.getValue() );
303 
304 	    	method = (XMethod) methodIterator.next();
305 		// test if return type is the same
306 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
307 
308 		// test if method name is the same
309 		assertEquals( "addSourceSet", method.getName() );
310 
311 		// test if parameters are the same
312 		parameters = method.getParameters().iterator();
313 	        parameter = (XParameter) parameters.next();
314 		assertEquals( "sourceSet", parameter.getName() );
315 		assertEquals( "xjavadoc.SourceSet", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
316 
317 		// test if doc is the same
318 		paramTags = method.getDoc().getTags("param",true).iterator();
319 	        paramTag = (XTag) paramTags.next();
320 		assertEquals( tokenizeAndTrim("sourceSet  a set of java sources."), paramTag.getValue() );
321 
322 	    	method = (XMethod) methodIterator.next();
323 		// test if return type is the same
324 		assertEquals( "boolean", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
325 
326 		// test if method name is the same
327 		assertEquals( "classExists", method.getName() );
328 
329 		// test if parameters are the same
330 		parameters = method.getParameters().iterator();
331 	        parameter = (XParameter) parameters.next();
332 		assertEquals( "qualifiedClassName", parameter.getName() );
333 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
334 
335 		// test if doc is the same
336 		paramTags = method.getDoc().getTags("param",true).iterator();
337 	        paramTag = (XTag) paramTags.next();
338 		assertEquals( tokenizeAndTrim("qualifiedClassName"), paramTag.getValue() );
339 
340 	    	method = (XMethod) methodIterator.next();
341 		// test if return type is the same
342 		assertEquals( "java.lang.String", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
343 
344 		// test if method name is the same
345 		assertEquals( "dereferenceProperties", method.getName() );
346 
347 		// test if parameters are the same
348 		parameters = method.getParameters().iterator();
349 	        parameter = (XParameter) parameters.next();
350 		assertEquals( "value", parameter.getName() );
351 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
352 
353 		// test if doc is the same
354 		paramTags = method.getDoc().getTags("param",true).iterator();
355 
356 	    	method = (XMethod) methodIterator.next();
357 		// test if return type is the same
358 		assertEquals( "java.lang.Class", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
359 
360 		// test if method name is the same
361 		assertEquals( "getClass", method.getName() );
362 
363 		// test if parameters are the same
364 		parameters = method.getParameters().iterator();
365 	        parameter = (XParameter) parameters.next();
366 		assertEquals( "qualifiedName", parameter.getName() );
367 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
368 
369 		// test if doc is the same
370 		paramTags = method.getDoc().getTags("param",true).iterator();
371 	        paramTag = (XTag) paramTags.next();
372 		assertEquals( tokenizeAndTrim("qualifiedName  Describe what the parameter does"), paramTag.getValue() );
373 
374 	    	method = (XMethod) methodIterator.next();
375 		// test if return type is the same
376 		assertEquals( "java.lang.String", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
377 
378 		// test if method name is the same
379 		assertEquals( "getDocEncoding", method.getName() );
380 
381 		// test if parameters are the same
382 		parameters = method.getParameters().iterator();
383 
384 		// test if doc is the same
385 		paramTags = method.getDoc().getTags("param",true).iterator();
386 
387 	    	method = (XMethod) methodIterator.next();
388 		// test if return type is the same
389 		assertEquals( "java.lang.String", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
390 
391 		// test if method name is the same
392 		assertEquals( "getEncoding", method.getName() );
393 
394 		// test if parameters are the same
395 		parameters = method.getParameters().iterator();
396 
397 		// test if doc is the same
398 		paramTags = method.getDoc().getTags("param",true).iterator();
399 
400 	    	method = (XMethod) methodIterator.next();
401 		// test if return type is the same
402 		assertEquals( "java.util.Collection", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
403 
404 		// test if method name is the same
405 		assertEquals( "getOuterSourceClasses", method.getName() );
406 
407 		// test if parameters are the same
408 		parameters = method.getParameters().iterator();
409 
410 		// test if doc is the same
411 		paramTags = method.getDoc().getTags("param",true).iterator();
412 
413 	    	method = (XMethod) methodIterator.next();
414 		// test if return type is the same
415 		assertEquals( "xjavadoc.Primitive", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
416 
417 		// test if method name is the same
418 		assertEquals( "getPrimitive", method.getName() );
419 
420 		// test if parameters are the same
421 		parameters = method.getParameters().iterator();
422 	        parameter = (XParameter) parameters.next();
423 		assertEquals( "name", parameter.getName() );
424 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
425 
426 		// test if doc is the same
427 		paramTags = method.getDoc().getTags("param",true).iterator();
428 	        paramTag = (XTag) paramTags.next();
429 		assertEquals( tokenizeAndTrim("name  Describe what the parameter does"), paramTag.getValue() );
430 
431 	    	method = (XMethod) methodIterator.next();
432 		// test if return type is the same
433 		assertEquals( "java.util.Map", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
434 
435 		// test if method name is the same
436 		assertEquals( "getPropertyMap", method.getName() );
437 
438 		// test if parameters are the same
439 		parameters = method.getParameters().iterator();
440 
441 		// test if doc is the same
442 		paramTags = method.getDoc().getTags("param",true).iterator();
443 
444 	    	method = (XMethod) methodIterator.next();
445 		// test if return type is the same
446 		assertEquals( "java.util.Collection", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
447 
448 		// test if method name is the same
449 		assertEquals( "getSourceClasses", method.getName() );
450 
451 		// test if parameters are the same
452 		parameters = method.getParameters().iterator();
453 	        parameter = (XParameter) parameters.next();
454 		assertEquals( "predicate", parameter.getName() );
455 		assertEquals( "org.apache.commons.collections.Predicate", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
456 
457 		// test if doc is the same
458 		paramTags = method.getDoc().getTags("param",true).iterator();
459 
460 	    	method = (XMethod) methodIterator.next();
461 		// test if return type is the same
462 		assertEquals( "java.util.Collection", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
463 
464 		// test if method name is the same
465 		assertEquals( "getSourceClasses", method.getName() );
466 
467 		// test if parameters are the same
468 		parameters = method.getParameters().iterator();
469 
470 		// test if doc is the same
471 		paramTags = method.getDoc().getTags("param",true).iterator();
472 
473 	    	method = (XMethod) methodIterator.next();
474 		// test if return type is the same
475 		assertEquals( "xjavadoc.filesystem.AbstractFile", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
476 
477 		// test if method name is the same
478 		assertEquals( "getSourceFile", method.getName() );
479 
480 		// test if parameters are the same
481 		parameters = method.getParameters().iterator();
482 	        parameter = (XParameter) parameters.next();
483 		assertEquals( "qualifiedName", parameter.getName() );
484 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
485 
486 		// test if doc is the same
487 		paramTags = method.getDoc().getTags("param",true).iterator();
488 	        paramTag = (XTag) paramTags.next();
489 		assertEquals( tokenizeAndTrim("qualifiedName  Describe what the parameter does"), paramTag.getValue() );
490 
491 	    	method = (XMethod) methodIterator.next();
492 		// test if return type is the same
493 		assertEquals( "xjavadoc.filesystem.AbstractFile", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
494 
495 		// test if method name is the same
496 		assertEquals( "getSourceFileFor", method.getName() );
497 
498 		// test if parameters are the same
499 		parameters = method.getParameters().iterator();
500 	        parameter = (XParameter) parameters.next();
501 		assertEquals( "pe", parameter.getName() );
502 		assertEquals( "xjavadoc.XProgramElement", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
503 
504 		// test if doc is the same
505 		paramTags = method.getDoc().getTags("param",true).iterator();
506 	        paramTag = (XTag) paramTags.next();
507 		assertEquals( tokenizeAndTrim("pe  the program element we want the source for."), paramTag.getValue() );
508 
509 	    	method = (XMethod) methodIterator.next();
510 		// test if return type is the same
511 		assertEquals( "xjavadoc.XPackage", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
512 
513 		// test if method name is the same
514 		assertEquals( "getSourcePackage", method.getName() );
515 
516 		// test if parameters are the same
517 		parameters = method.getParameters().iterator();
518 	        parameter = (XParameter) parameters.next();
519 		assertEquals( "packageName", parameter.getName() );
520 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
521 
522 		// test if doc is the same
523 		paramTags = method.getDoc().getTags("param",true).iterator();
524 	        paramTag = (XTag) paramTags.next();
525 		assertEquals( tokenizeAndTrim("packageName"), paramTag.getValue() );
526 
527 	    	method = (XMethod) methodIterator.next();
528 		// test if return type is the same
529 		assertEquals( "java.util.Collection", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
530 
531 		// test if method name is the same
532 		assertEquals( "getSourcePackages", method.getName() );
533 
534 		// test if parameters are the same
535 		parameters = method.getParameters().iterator();
536 
537 		// test if doc is the same
538 		paramTags = method.getDoc().getTags("param",true).iterator();
539 
540 	    	method = (XMethod) methodIterator.next();
541 		// test if return type is the same
542 		assertEquals( "xjavadoc.XTagFactory", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
543 
544 		// test if method name is the same
545 		assertEquals( "getTagFactory", method.getName() );
546 
547 		// test if parameters are the same
548 		parameters = method.getParameters().iterator();
549 
550 		// test if doc is the same
551 		paramTags = method.getDoc().getTags("param",true).iterator();
552 
553 	    	method = (XMethod) methodIterator.next();
554 		// test if return type is the same
555 		assertEquals( "xjavadoc.XClass", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
556 
557 		// test if method name is the same
558 		assertEquals( "getXClass", method.getName() );
559 
560 		// test if parameters are the same
561 		parameters = method.getParameters().iterator();
562 	        parameter = (XParameter) parameters.next();
563 		assertEquals( "qualifiedName", parameter.getName() );
564 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
565 
566 		// test if doc is the same
567 		paramTags = method.getDoc().getTags("param",true).iterator();
568 	        paramTag = (XTag) paramTags.next();
569 		assertEquals( tokenizeAndTrim("qualifiedName  Fully qualified class name"), paramTag.getValue() );
570 
571 	    	method = (XMethod) methodIterator.next();
572 		// test if return type is the same
573 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
574 
575 		// test if method name is the same
576 		assertEquals( "logMessage", method.getName() );
577 
578 		// test if parameters are the same
579 		parameters = method.getParameters().iterator();
580 	        parameter = (XParameter) parameters.next();
581 		assertEquals( "clazz", parameter.getName() );
582 		assertEquals( "xjavadoc.SourceClass", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
583 	        parameter = (XParameter) parameters.next();
584 		assertEquals( "unknownClass", parameter.getName() );
585 		assertEquals( "xjavadoc.UnknownClass", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
586 	        parameter = (XParameter) parameters.next();
587 		assertEquals( "unqualifiedClassName", parameter.getName() );
588 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
589 	        parameter = (XParameter) parameters.next();
590 		assertEquals( "level", parameter.getName() );
591 		assertEquals( "int", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
592 
593 		// test if doc is the same
594 		paramTags = method.getDoc().getTags("param",true).iterator();
595 
596 	    	method = (XMethod) methodIterator.next();
597 		// test if return type is the same
598 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
599 
600 		// test if method name is the same
601 		assertEquals( "parsePropertyString", method.getName() );
602 
603 		// test if parameters are the same
604 		parameters = method.getParameters().iterator();
605 	        parameter = (XParameter) parameters.next();
606 		assertEquals( "value", parameter.getName() );
607 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
608 	        parameter = (XParameter) parameters.next();
609 		assertEquals( "fragments", parameter.getName() );
610 		assertEquals( "java.util.List", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
611 	        parameter = (XParameter) parameters.next();
612 		assertEquals( "propertyRefs", parameter.getName() );
613 		assertEquals( "java.util.List", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
614 
615 		// test if doc is the same
616 		paramTags = method.getDoc().getTags("param",true).iterator();
617 	        paramTag = (XTag) paramTags.next();
618 		assertEquals( tokenizeAndTrim("value         Text to parse. Must not be <code>null</code>."), paramTag.getValue() );
619 	        paramTag = (XTag) paramTags.next();
620 		assertEquals( tokenizeAndTrim("fragments     List to add text fragments to. Must not be <code>null</code>."), paramTag.getValue() );
621 	        paramTag = (XTag) paramTags.next();
622 		assertEquals( tokenizeAndTrim("propertyRefs  List to add property names to. Must not be <code>null</code>."), paramTag.getValue() );
623 
624 	    	method = (XMethod) methodIterator.next();
625 		// test if return type is the same
626 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
627 
628 		// test if method name is the same
629 		assertEquals( "printLogMessages", method.getName() );
630 
631 		// test if parameters are the same
632 		parameters = method.getParameters().iterator();
633 	        parameter = (XParameter) parameters.next();
634 		assertEquals( "out", parameter.getName() );
635 		assertEquals( "java.io.PrintStream", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
636 	        parameter = (XParameter) parameters.next();
637 		assertEquals( "level", parameter.getName() );
638 		assertEquals( "int", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
639 
640 		// test if doc is the same
641 		paramTags = method.getDoc().getTags("param",true).iterator();
642 	        paramTag = (XTag) paramTags.next();
643 		assertEquals( tokenizeAndTrim("out"), paramTag.getValue() );
644 	        paramTag = (XTag) paramTags.next();
645 		assertEquals( tokenizeAndTrim("level"), paramTag.getValue() );
646 
647 	    	method = (XMethod) methodIterator.next();
648 		// test if return type is the same
649 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
650 
651 		// test if method name is the same
652 		assertEquals( "printMemoryStatus", method.getName() );
653 
654 		// test if parameters are the same
655 		parameters = method.getParameters().iterator();
656 
657 		// test if doc is the same
658 		paramTags = method.getDoc().getTags("param",true).iterator();
659 
660 	    	method = (XMethod) methodIterator.next();
661 		// test if return type is the same
662 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
663 
664 		// test if method name is the same
665 		assertEquals( "registerTags", method.getName() );
666 
667 		// test if parameters are the same
668 		parameters = method.getParameters().iterator();
669 	        parameter = (XParameter) parameters.next();
670 		assertEquals( "classpath", parameter.getName() );
671 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
672 
673 		// test if doc is the same
674 		paramTags = method.getDoc().getTags("param",true).iterator();
675 	        paramTag = (XTag) paramTags.next();
676 		assertEquals( tokenizeAndTrim("classpath where tags are found."), paramTag.getValue() );
677 
678 	    	method = (XMethod) methodIterator.next();
679 		// test if return type is the same
680 		assertEquals( "java.lang.String", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
681 
682 		// test if method name is the same
683 		assertEquals( "replaceProperties", method.getName() );
684 
685 		// test if parameters are the same
686 		parameters = method.getParameters().iterator();
687 	        parameter = (XParameter) parameters.next();
688 		assertEquals( "value", parameter.getName() );
689 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
690 	        parameter = (XParameter) parameters.next();
691 		assertEquals( "keys", parameter.getName() );
692 		assertEquals( "java.util.Map", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
693 
694 		// test if doc is the same
695 		paramTags = method.getDoc().getTags("param",true).iterator();
696 	        paramTag = (XTag) paramTags.next();
697 		assertEquals( tokenizeAndTrim("value  The string to be scanned for property references. May be       <code>null</code> , in which case this method returns immediately with       no effect."), paramTag.getValue() );
698 	        paramTag = (XTag) paramTags.next();
699 		assertEquals( tokenizeAndTrim("keys   Mapping (String to String) of property names to their values.       Must not be <code>null</code>."), paramTag.getValue() );
700 
701 	    	method = (XMethod) methodIterator.next();
702 		// test if return type is the same
703 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
704 
705 		// test if method name is the same
706 		assertEquals( "reset", method.getName() );
707 
708 		// test if parameters are the same
709 		parameters = method.getParameters().iterator();
710 	        parameter = (XParameter) parameters.next();
711 		assertEquals( "resetTimeStamp", parameter.getName() );
712 		assertEquals( "boolean", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
713 
714 		// test if doc is the same
715 		paramTags = method.getDoc().getTags("param",true).iterator();
716 	        paramTag = (XTag) paramTags.next();
717 		assertEquals( tokenizeAndTrim("resetTimeStamp  true if timestamps should be reset too."), paramTag.getValue() );
718 
719 	    	method = (XMethod) methodIterator.next();
720 		// test if return type is the same
721 		assertEquals( "xjavadoc.SourceClass", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
722 
723 		// test if method name is the same
724 		assertEquals( "scanAndPut", method.getName() );
725 
726 		// test if parameters are the same
727 		parameters = method.getParameters().iterator();
728 	        parameter = (XParameter) parameters.next();
729 		assertEquals( "qualifiedName", parameter.getName() );
730 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
731 
732 		// test if doc is the same
733 		paramTags = method.getDoc().getTags("param",true).iterator();
734 	        paramTag = (XTag) paramTags.next();
735 		assertEquals( tokenizeAndTrim("qualifiedName  Describe what the parameter does"), paramTag.getValue() );
736 
737 	    	method = (XMethod) methodIterator.next();
738 		// test if return type is the same
739 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
740 
741 		// test if method name is the same
742 		assertEquals( "setDocEncoding", method.getName() );
743 
744 		// test if parameters are the same
745 		parameters = method.getParameters().iterator();
746 	        parameter = (XParameter) parameters.next();
747 		assertEquals( "docencoding", parameter.getName() );
748 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
749 
750 		// test if doc is the same
751 		paramTags = method.getDoc().getTags("param",true).iterator();
752 	        paramTag = (XTag) paramTags.next();
753 		assertEquals( tokenizeAndTrim("string encoding"), paramTag.getValue() );
754 
755 	    	method = (XMethod) methodIterator.next();
756 		// test if return type is the same
757 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
758 
759 		// test if method name is the same
760 		assertEquals( "setEncoding", method.getName() );
761 
762 		// test if parameters are the same
763 		parameters = method.getParameters().iterator();
764 	        parameter = (XParameter) parameters.next();
765 		assertEquals( "encoding", parameter.getName() );
766 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
767 
768 		// test if doc is the same
769 		paramTags = method.getDoc().getTags("param",true).iterator();
770 	        paramTag = (XTag) paramTags.next();
771 		assertEquals( tokenizeAndTrim("string encoding"), paramTag.getValue() );
772 
773 	    	method = (XMethod) methodIterator.next();
774 		// test if return type is the same
775 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
776 
777 		// test if method name is the same
778 		assertEquals( "setPropertyMap", method.getName() );
779 
780 		// test if parameters are the same
781 		parameters = method.getParameters().iterator();
782 	        parameter = (XParameter) parameters.next();
783 		assertEquals( "properties", parameter.getName() );
784 		assertEquals( "java.util.Map", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
785 
786 		// test if doc is the same
787 		paramTags = method.getDoc().getTags("param",true).iterator();
788 
789 	    	method = (XMethod) methodIterator.next();
790 		// test if return type is the same
791 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
792 
793 		// test if method name is the same
794 		assertEquals( "setUseNodeParser", method.getName() );
795 
796 		// test if parameters are the same
797 		parameters = method.getParameters().iterator();
798 	        parameter = (XParameter) parameters.next();
799 		assertEquals( "useNodeParser", parameter.getName() );
800 		assertEquals( "boolean", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
801 
802 		// test if doc is the same
803 		paramTags = method.getDoc().getTags("param",true).iterator();
804 	        paramTag = (XTag) paramTags.next();
805 		assertEquals( tokenizeAndTrim("useNodeParser"), paramTag.getValue() );
806 
807 	    	method = (XMethod) methodIterator.next();
808 		// test if return type is the same
809 		assertEquals( "boolean", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
810 
811 		// test if method name is the same
812 		assertEquals( "sourceExists", method.getName() );
813 
814 		// test if parameters are the same
815 		parameters = method.getParameters().iterator();
816 	        parameter = (XParameter) parameters.next();
817 		assertEquals( "qualifiedName", parameter.getName() );
818 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
819 
820 		// test if doc is the same
821 		paramTags = method.getDoc().getTags("param",true).iterator();
822 	        paramTag = (XTag) paramTags.next();
823 		assertEquals( tokenizeAndTrim("qualifiedName  the class to check for"), paramTag.getValue() );
824 
825 	    	method = (XMethod) methodIterator.next();
826 		// test if return type is the same
827 		assertEquals( "xjavadoc.XClass", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
828 
829 		// test if method name is the same
830 		assertEquals( "updateClassTag", method.getName() );
831 
832 		// test if parameters are the same
833 		parameters = method.getParameters().iterator();
834 	        parameter = (XParameter) parameters.next();
835 		assertEquals( "className", parameter.getName() );
836 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
837 	        parameter = (XParameter) parameters.next();
838 		assertEquals( "tagName", parameter.getName() );
839 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
840 	        parameter = (XParameter) parameters.next();
841 		assertEquals( "parameterName", parameter.getName() );
842 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
843 	        parameter = (XParameter) parameters.next();
844 		assertEquals( "parameterValue", parameter.getName() );
845 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
846 	        parameter = (XParameter) parameters.next();
847 		assertEquals( "tagIndex", parameter.getName() );
848 		assertEquals( "int", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
849 
850 		// test if doc is the same
851 		paramTags = method.getDoc().getTags("param",true).iterator();
852 	        paramTag = (XTag) paramTags.next();
853 		assertEquals( tokenizeAndTrim("className              Describe what the parameter does"), paramTag.getValue() );
854 	        paramTag = (XTag) paramTags.next();
855 		assertEquals( tokenizeAndTrim("tagName                Describe what the parameter does"), paramTag.getValue() );
856 	        paramTag = (XTag) paramTags.next();
857 		assertEquals( tokenizeAndTrim("parameterName          Describe what the parameter does"), paramTag.getValue() );
858 	        paramTag = (XTag) paramTags.next();
859 		assertEquals( tokenizeAndTrim("parameterValue         Describe what the parameter does"), paramTag.getValue() );
860 	        paramTag = (XTag) paramTags.next();
861 		assertEquals( tokenizeAndTrim("tagIndex               Describe what the parameter does"), paramTag.getValue() );
862 
863 	    	method = (XMethod) methodIterator.next();
864 		// test if return type is the same
865 		assertEquals( "xjavadoc.XClass", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
866 
867 		// test if method name is the same
868 		assertEquals( "updateMethodTag", method.getName() );
869 
870 		// test if parameters are the same
871 		parameters = method.getParameters().iterator();
872 	        parameter = (XParameter) parameters.next();
873 		assertEquals( "className", parameter.getName() );
874 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
875 	        parameter = (XParameter) parameters.next();
876 		assertEquals( "methodNameWithSignature", parameter.getName() );
877 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
878 	        parameter = (XParameter) parameters.next();
879 		assertEquals( "tagName", parameter.getName() );
880 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
881 	        parameter = (XParameter) parameters.next();
882 		assertEquals( "parameterName", parameter.getName() );
883 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
884 	        parameter = (XParameter) parameters.next();
885 		assertEquals( "parameterValue", parameter.getName() );
886 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
887 	        parameter = (XParameter) parameters.next();
888 		assertEquals( "tagIndex", parameter.getName() );
889 		assertEquals( "int", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
890 
891 		// test if doc is the same
892 		paramTags = method.getDoc().getTags("param",true).iterator();
893 	        paramTag = (XTag) paramTags.next();
894 		assertEquals( tokenizeAndTrim("className                qualified name of class"), paramTag.getValue() );
895 	        paramTag = (XTag) paramTags.next();
896 		assertEquals( tokenizeAndTrim("tagName                  tag name"), paramTag.getValue() );
897 	        paramTag = (XTag) paramTags.next();
898 		assertEquals( tokenizeAndTrim("parameterName            parameter name"), paramTag.getValue() );
899 	        paramTag = (XTag) paramTags.next();
900 		assertEquals( tokenizeAndTrim("parameterValue           new parameter value"), paramTag.getValue() );
901 	        paramTag = (XTag) paramTags.next();
902 		assertEquals( tokenizeAndTrim("tagIndex                 index of tag (??)"), paramTag.getValue() );
903 	        paramTag = (XTag) paramTags.next();
904 		assertEquals( tokenizeAndTrim("methodNameWithSignature  method name followed by signature. no       spaces. Ex:<br>       <code>doIt(java.lang.String,int)</code>"), paramTag.getValue() );
905 
906 	}
907 }