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 AbstractClass__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 AbstractClass__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.AbstractClass" );
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( "xjavadoc.AbstractProgramElement", 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.util.List", field.getType().getQualifiedName() + field.getDimensionAsString());
83  		// test if field name is the same
84  		assertEquals( "_allInterfaces", field.getName() );
85  		// test if field type is the same
86  		field = (XField) fieldIterator.next();
87  		assertEquals( "java.util.List", field.getType().getQualifiedName() + field.getDimensionAsString());
88  		// test if field name is the same
89  		assertEquals( "_allSubclasses", field.getName() );
90  		// test if field type is the same
91  		field = (XField) fieldIterator.next();
92  		assertEquals( "java.util.List", field.getType().getQualifiedName() + field.getDimensionAsString());
93  		// test if field name is the same
94  		assertEquals( "_constructors", field.getName() );
95  		// test if field type is the same
96  		field = (XField) fieldIterator.next();
97  		assertEquals( "xjavadoc.XPackage", field.getType().getQualifiedName() + field.getDimensionAsString());
98  		// test if field name is the same
99  		assertEquals( "_containingPackage", field.getName() );
100 		// test if field type is the same
101 		field = (XField) fieldIterator.next();
102 		assertEquals( "java.util.List", field.getType().getQualifiedName() + field.getDimensionAsString());
103 		// test if field name is the same
104 		assertEquals( "_declaredInterfaces", field.getName() );
105 		// test if field type is the same
106 		field = (XField) fieldIterator.next();
107 		assertEquals( "java.util.List", field.getType().getQualifiedName() + field.getDimensionAsString());
108 		// test if field name is the same
109 		assertEquals( "_directSubclasses", field.getName() );
110 		// test if field type is the same
111 		field = (XField) fieldIterator.next();
112 		assertEquals( "java.util.List", field.getType().getQualifiedName() + field.getDimensionAsString());
113 		// test if field name is the same
114 		assertEquals( "_extendingInterfaces", field.getName() );
115 		// test if field type is the same
116 		field = (XField) fieldIterator.next();
117 		assertEquals( "java.util.List", field.getType().getQualifiedName() + field.getDimensionAsString());
118 		// test if field name is the same
119 		assertEquals( "_fields", field.getName() );
120 		// test if field type is the same
121 		field = (XField) fieldIterator.next();
122 		assertEquals( "int", field.getType().getQualifiedName() + field.getDimensionAsString());
123 		// test if field name is the same
124 		assertEquals( "_hash", field.getName() );
125 		// test if field type is the same
126 		field = (XField) fieldIterator.next();
127 		assertEquals( "java.util.List", field.getType().getQualifiedName() + field.getDimensionAsString());
128 		// test if field name is the same
129 		assertEquals( "_implementingClasses", 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( "_importedClassNames", field.getName() );
135 		// test if field type is the same
136 		field = (XField) fieldIterator.next();
137 		assertEquals( "java.util.List", field.getType().getQualifiedName() + field.getDimensionAsString());
138 		// test if field name is the same
139 		assertEquals( "_importedClasses", field.getName() );
140 		// test if field type is the same
141 		field = (XField) fieldIterator.next();
142 		assertEquals( "java.util.List", field.getType().getQualifiedName() + field.getDimensionAsString());
143 		// test if field name is the same
144 		assertEquals( "_importedPackages", field.getName() );
145 		// test if field type is the same
146 		field = (XField) fieldIterator.next();
147 		assertEquals( "java.util.List", field.getType().getQualifiedName() + field.getDimensionAsString());
148 		// test if field name is the same
149 		assertEquals( "_innerClasses", field.getName() );
150 		// test if field type is the same
151 		field = (XField) fieldIterator.next();
152 		assertEquals( "boolean", field.getType().getQualifiedName() + field.getDimensionAsString());
153 		// test if field name is the same
154 		assertEquals( "_isAnonymous", field.getName() );
155 		// test if field type is the same
156 		field = (XField) fieldIterator.next();
157 		assertEquals( "boolean", field.getType().getQualifiedName() + field.getDimensionAsString());
158 		// test if field name is the same
159 		assertEquals( "_isInterface", field.getName() );
160 		// test if field type is the same
161 		field = (XField) fieldIterator.next();
162 		assertEquals( "java.util.List", field.getType().getQualifiedName() + field.getDimensionAsString());
163 		// test if field name is the same
164 		assertEquals( "_methods", field.getName() );
165 		// test if field type is the same
166 		field = (XField) fieldIterator.next();
167 		assertEquals( "java.lang.String", field.getType().getQualifiedName() + field.getDimensionAsString());
168 		// test if field name is the same
169 		assertEquals( "_name", field.getName() );
170 		// test if field type is the same
171 		field = (XField) fieldIterator.next();
172 		assertEquals( "java.util.Map", field.getType().getQualifiedName() + field.getDimensionAsString());
173 		// test if field name is the same
174 		assertEquals( "_namedConstructors", field.getName() );
175 		// test if field type is the same
176 		field = (XField) fieldIterator.next();
177 		assertEquals( "java.util.HashMap", field.getType().getQualifiedName() + field.getDimensionAsString());
178 		// test if field name is the same
179 		assertEquals( "_namedMethods", field.getName() );
180 		// test if field type is the same
181 		field = (XField) fieldIterator.next();
182 		assertEquals( "java.lang.String", field.getType().getQualifiedName() + field.getDimensionAsString());
183 		// test if field name is the same
184 		assertEquals( "_qualifiedName", field.getName() );
185 		// test if field type is the same
186 		field = (XField) fieldIterator.next();
187 		assertEquals( "xjavadoc.XClass", field.getType().getQualifiedName() + field.getDimensionAsString());
188 		// test if field name is the same
189 		assertEquals( "_superclass", field.getName() );
190 		// test if field type is the same
191 		field = (XField) fieldIterator.next();
192 		assertEquals( "java.lang.String", field.getType().getQualifiedName() + field.getDimensionAsString());
193 		// test if field name is the same
194 		assertEquals( "_transformedName", field.getName() );
195 		// test if field type is the same
196 		field = (XField) fieldIterator.next();
197 		assertEquals( "java.lang.String", field.getType().getQualifiedName() + field.getDimensionAsString());
198 		// test if field name is the same
199 		assertEquals( "_transformedQualifiedName", field.getName() );
200 	}
201 
202 	public void testMethods() {
203 
204 		// Sort the methods
205 		Collection methods = _testedClass.getMethods();
206 		ArrayList sortedMethods = new ArrayList();
207 		sortedMethods.addAll(methods);
208 		Collections.sort(sortedMethods);
209 		Iterator methodIterator = sortedMethods.iterator();
210 		XMethod method = null;
211 
212 		Iterator parameters = null;
213 		XParameter parameter = null;
214 
215 		Iterator paramTags = null;
216 		XTag paramTag = null;
217 
218 	    	method = (XMethod) methodIterator.next();
219 		// test if return type is the same
220 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
221 
222 		// test if method name is the same
223 		assertEquals( "addConstructor", method.getName() );
224 
225 		// test if parameters are the same
226 		parameters = method.getParameters().iterator();
227 	        parameter = (XParameter) parameters.next();
228 		assertEquals( "constructor", parameter.getName() );
229 		assertEquals( "xjavadoc.XConstructor", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
230 
231 		// test if doc is the same
232 		paramTags = method.getDoc().getTags("param",true).iterator();
233 	        paramTag = (XTag) paramTags.next();
234 		assertEquals( tokenizeAndTrim("constructor  Describe the method parameter"), paramTag.getValue() );
235 
236 	    	method = (XMethod) methodIterator.next();
237 		// test if return type is the same
238 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
239 
240 		// test if method name is the same
241 		assertEquals( "addField", method.getName() );
242 
243 		// test if parameters are the same
244 		parameters = method.getParameters().iterator();
245 	        parameter = (XParameter) parameters.next();
246 		assertEquals( "field", parameter.getName() );
247 		assertEquals( "xjavadoc.XField", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
248 
249 		// test if doc is the same
250 		paramTags = method.getDoc().getTags("param",true).iterator();
251 	        paramTag = (XTag) paramTags.next();
252 		assertEquals( tokenizeAndTrim("field  Describe the method parameter"), paramTag.getValue() );
253 
254 	    	method = (XMethod) methodIterator.next();
255 		// test if return type is the same
256 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
257 
258 		// test if method name is the same
259 		assertEquals( "addImportedClass", method.getName() );
260 
261 		// test if parameters are the same
262 		parameters = method.getParameters().iterator();
263 	        parameter = (XParameter) parameters.next();
264 		assertEquals( "importedClass", parameter.getName() );
265 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
266 
267 		// test if doc is the same
268 		paramTags = method.getDoc().getTags("param",true).iterator();
269 	        paramTag = (XTag) paramTags.next();
270 		assertEquals( tokenizeAndTrim("importedClass  Describe the method parameter"), paramTag.getValue() );
271 
272 	    	method = (XMethod) methodIterator.next();
273 		// test if return type is the same
274 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
275 
276 		// test if method name is the same
277 		assertEquals( "addImportedPackage", method.getName() );
278 
279 		// test if parameters are the same
280 		parameters = method.getParameters().iterator();
281 	        parameter = (XParameter) parameters.next();
282 		assertEquals( "importedPackage", parameter.getName() );
283 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
284 
285 		// test if doc is the same
286 		paramTags = method.getDoc().getTags("param",true).iterator();
287 	        paramTag = (XTag) paramTags.next();
288 		assertEquals( tokenizeAndTrim("importedPackage  Describe the method parameter"), paramTag.getValue() );
289 
290 	    	method = (XMethod) methodIterator.next();
291 		// test if return type is the same
292 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
293 
294 		// test if method name is the same
295 		assertEquals( "addInnerClass", method.getName() );
296 
297 		// test if parameters are the same
298 		parameters = method.getParameters().iterator();
299 	        parameter = (XParameter) parameters.next();
300 		assertEquals( "clazz", parameter.getName() );
301 		assertEquals( "xjavadoc.XClass", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
302 
303 		// test if doc is the same
304 		paramTags = method.getDoc().getTags("param",true).iterator();
305 
306 	    	method = (XMethod) methodIterator.next();
307 		// test if return type is the same
308 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
309 
310 		// test if method name is the same
311 		assertEquals( "addInterface", method.getName() );
312 
313 		// test if parameters are the same
314 		parameters = method.getParameters().iterator();
315 	        parameter = (XParameter) parameters.next();
316 		assertEquals( "interfaceName", parameter.getName() );
317 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
318 
319 		// test if doc is the same
320 		paramTags = method.getDoc().getTags("param",true).iterator();
321 	        paramTag = (XTag) paramTags.next();
322 		assertEquals( tokenizeAndTrim("interfaceName  Describe the method parameter"), paramTag.getValue() );
323 
324 	    	method = (XMethod) methodIterator.next();
325 		// test if return type is the same
326 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
327 
328 		// test if method name is the same
329 		assertEquals( "addMethod", method.getName() );
330 
331 		// test if parameters are the same
332 		parameters = method.getParameters().iterator();
333 	        parameter = (XParameter) parameters.next();
334 		assertEquals( "method", parameter.getName() );
335 		assertEquals( "xjavadoc.XMethod", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
336 
337 		// test if doc is the same
338 		paramTags = method.getDoc().getTags("param",true).iterator();
339 	        paramTag = (XTag) paramTags.next();
340 		assertEquals( tokenizeAndTrim("method  Describe the method parameter"), paramTag.getValue() );
341 
342 	    	method = (XMethod) methodIterator.next();
343 		// test if return type is the same
344 		assertEquals( "int", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
345 
346 		// test if method name is the same
347 		assertEquals( "compareTo", method.getName() );
348 
349 		// test if parameters are the same
350 		parameters = method.getParameters().iterator();
351 	        parameter = (XParameter) parameters.next();
352 		assertEquals( "o", parameter.getName() );
353 		assertEquals( "java.lang.Object", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
354 
355 		// test if doc is the same
356 		paramTags = method.getDoc().getTags("param",true).iterator();
357 
358 	    	method = (XMethod) methodIterator.next();
359 		// test if return type is the same
360 		assertEquals( "boolean", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
361 
362 		// test if method name is the same
363 		assertEquals( "equals", method.getName() );
364 
365 		// test if parameters are the same
366 		parameters = method.getParameters().iterator();
367 	        parameter = (XParameter) parameters.next();
368 		assertEquals( "obj", parameter.getName() );
369 		assertEquals( "java.lang.Object", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
370 
371 		// test if doc is the same
372 		paramTags = method.getDoc().getTags("param",true).iterator();
373 
374 	    	method = (XMethod) methodIterator.next();
375 		// test if return type is the same
376 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
377 
378 		// test if method name is the same
379 		assertEquals( "getAllSubclasses", 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( "xjavadoc.XConstructor", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
390 
391 		// test if method name is the same
392 		assertEquals( "getConstructor", method.getName() );
393 
394 		// test if parameters are the same
395 		parameters = method.getParameters().iterator();
396 	        parameter = (XParameter) parameters.next();
397 		assertEquals( "constructorNameWithSignature", parameter.getName() );
398 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
399 
400 		// test if doc is the same
401 		paramTags = method.getDoc().getTags("param",true).iterator();
402 	        paramTag = (XTag) paramTags.next();
403 		assertEquals( tokenizeAndTrim("constructorNameWithSignature  Describe what the parameter does"), paramTag.getValue() );
404 
405 	    	method = (XMethod) methodIterator.next();
406 		// test if return type is the same
407 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
408 
409 		// test if method name is the same
410 		assertEquals( "getConstructors", method.getName() );
411 
412 		// test if parameters are the same
413 		parameters = method.getParameters().iterator();
414 
415 		// test if doc is the same
416 		paramTags = method.getDoc().getTags("param",true).iterator();
417 
418 	    	method = (XMethod) methodIterator.next();
419 		// test if return type is the same
420 		assertEquals( "xjavadoc.XPackage", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
421 
422 		// test if method name is the same
423 		assertEquals( "getContainingPackage", method.getName() );
424 
425 		// test if parameters are the same
426 		parameters = method.getParameters().iterator();
427 
428 		// test if doc is the same
429 		paramTags = method.getDoc().getTags("param",true).iterator();
430 
431 	    	method = (XMethod) methodIterator.next();
432 		// test if return type is the same
433 		assertEquals( "java.util.Collection", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
434 
435 		// test if method name is the same
436 		assertEquals( "getDeclaredInterfaces", 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.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
447 
448 		// test if method name is the same
449 		assertEquals( "getDirectSubclasses", method.getName() );
450 
451 		// test if parameters are the same
452 		parameters = method.getParameters().iterator();
453 
454 		// test if doc is the same
455 		paramTags = method.getDoc().getTags("param",true).iterator();
456 
457 	    	method = (XMethod) methodIterator.next();
458 		// test if return type is the same
459 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
460 
461 		// test if method name is the same
462 		assertEquals( "getExtendingInterfaces", method.getName() );
463 
464 		// test if parameters are the same
465 		parameters = method.getParameters().iterator();
466 
467 		// test if doc is the same
468 		paramTags = method.getDoc().getTags("param",true).iterator();
469 
470 	    	method = (XMethod) methodIterator.next();
471 		// test if return type is the same
472 		assertEquals( "xjavadoc.XField", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
473 
474 		// test if method name is the same
475 		assertEquals( "getField", method.getName() );
476 
477 		// test if parameters are the same
478 		parameters = method.getParameters().iterator();
479 	        parameter = (XParameter) parameters.next();
480 		assertEquals( "fieldName", parameter.getName() );
481 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
482 
483 		// test if doc is the same
484 		paramTags = method.getDoc().getTags("param",true).iterator();
485 	        paramTag = (XTag) paramTags.next();
486 		assertEquals( tokenizeAndTrim("fieldName  Describe what the parameter does"), paramTag.getValue() );
487 
488 	    	method = (XMethod) methodIterator.next();
489 		// test if return type is the same
490 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
491 
492 		// test if method name is the same
493 		assertEquals( "getFields", method.getName() );
494 
495 		// test if parameters are the same
496 		parameters = method.getParameters().iterator();
497 	        parameter = (XParameter) parameters.next();
498 		assertEquals( "predicate", parameter.getName() );
499 		assertEquals( "org.apache.commons.collections.Predicate", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
500 	        parameter = (XParameter) parameters.next();
501 		assertEquals( "superclasses", parameter.getName() );
502 		assertEquals( "boolean", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
503 
504 		// test if doc is the same
505 		paramTags = method.getDoc().getTags("param",true).iterator();
506 
507 	    	method = (XMethod) methodIterator.next();
508 		// test if return type is the same
509 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
510 
511 		// test if method name is the same
512 		assertEquals( "getFields", method.getName() );
513 
514 		// test if parameters are the same
515 		parameters = method.getParameters().iterator();
516 	        parameter = (XParameter) parameters.next();
517 		assertEquals( "superclasses", parameter.getName() );
518 		assertEquals( "boolean", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
519 
520 		// test if doc is the same
521 		paramTags = method.getDoc().getTags("param",true).iterator();
522 
523 	    	method = (XMethod) methodIterator.next();
524 		// test if return type is the same
525 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
526 
527 		// test if method name is the same
528 		assertEquals( "getFields", method.getName() );
529 
530 		// test if parameters are the same
531 		parameters = method.getParameters().iterator();
532 
533 		// test if doc is the same
534 		paramTags = method.getDoc().getTags("param",true).iterator();
535 
536 	    	method = (XMethod) methodIterator.next();
537 		// test if return type is the same
538 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
539 
540 		// test if method name is the same
541 		assertEquals( "getImplementingClasses", method.getName() );
542 
543 		// test if parameters are the same
544 		parameters = method.getParameters().iterator();
545 
546 		// test if doc is the same
547 		paramTags = method.getDoc().getTags("param",true).iterator();
548 
549 	    	method = (XMethod) methodIterator.next();
550 		// test if return type is the same
551 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
552 
553 		// test if method name is the same
554 		assertEquals( "getImportedClasses", method.getName() );
555 
556 		// test if parameters are the same
557 		parameters = method.getParameters().iterator();
558 
559 		// test if doc is the same
560 		paramTags = method.getDoc().getTags("param",true).iterator();
561 
562 	    	method = (XMethod) methodIterator.next();
563 		// test if return type is the same
564 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
565 
566 		// test if method name is the same
567 		assertEquals( "getImportedPackages", method.getName() );
568 
569 		// test if parameters are the same
570 		parameters = method.getParameters().iterator();
571 
572 		// test if doc is the same
573 		paramTags = method.getDoc().getTags("param",true).iterator();
574 
575 	    	method = (XMethod) methodIterator.next();
576 		// test if return type is the same
577 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
578 
579 		// test if method name is the same
580 		assertEquals( "getInnerClasses", method.getName() );
581 
582 		// test if parameters are the same
583 		parameters = method.getParameters().iterator();
584 
585 		// test if doc is the same
586 		paramTags = method.getDoc().getTags("param",true).iterator();
587 
588 	    	method = (XMethod) methodIterator.next();
589 		// test if return type is the same
590 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
591 
592 		// test if method name is the same
593 		assertEquals( "getInterfaces", method.getName() );
594 
595 		// test if parameters are the same
596 		parameters = method.getParameters().iterator();
597 
598 		// test if doc is the same
599 		paramTags = method.getDoc().getTags("param",true).iterator();
600 
601 	    	method = (XMethod) methodIterator.next();
602 		// test if return type is the same
603 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
604 
605 		// test if method name is the same
606 		assertEquals( "getMembers", method.getName() );
607 
608 		// test if parameters are the same
609 		parameters = method.getParameters().iterator();
610 	        parameter = (XParameter) parameters.next();
611 		assertEquals( "superclasses", parameter.getName() );
612 		assertEquals( "boolean", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
613 	        parameter = (XParameter) parameters.next();
614 		assertEquals( "forFields", parameter.getName() );
615 		assertEquals( "boolean", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
616 
617 		// test if doc is the same
618 		paramTags = method.getDoc().getTags("param",true).iterator();
619 	        paramTag = (XTag) paramTags.next();
620 		assertEquals( tokenizeAndTrim("forFields     true if you want the fields, false if you want methods"), paramTag.getValue() );
621 	        paramTag = (XTag) paramTags.next();
622 		assertEquals( tokenizeAndTrim("superclasses"), paramTag.getValue() );
623 
624 	    	method = (XMethod) methodIterator.next();
625 		// test if return type is the same
626 		assertEquals( "xjavadoc.XMethod", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
627 
628 		// test if method name is the same
629 		assertEquals( "getMethod", method.getName() );
630 
631 		// test if parameters are the same
632 		parameters = method.getParameters().iterator();
633 	        parameter = (XParameter) parameters.next();
634 		assertEquals( "methodNameWithSignature", parameter.getName() );
635 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
636 
637 		// test if doc is the same
638 		paramTags = method.getDoc().getTags("param",true).iterator();
639 
640 	    	method = (XMethod) methodIterator.next();
641 		// test if return type is the same
642 		assertEquals( "xjavadoc.XMethod", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
643 
644 		// test if method name is the same
645 		assertEquals( "getMethod", method.getName() );
646 
647 		// test if parameters are the same
648 		parameters = method.getParameters().iterator();
649 	        parameter = (XParameter) parameters.next();
650 		assertEquals( "methodNameWithSignature", parameter.getName() );
651 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
652 	        parameter = (XParameter) parameters.next();
653 		assertEquals( "superclasses", parameter.getName() );
654 		assertEquals( "boolean", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
655 
656 		// test if doc is the same
657 		paramTags = method.getDoc().getTags("param",true).iterator();
658 
659 	    	method = (XMethod) methodIterator.next();
660 		// test if return type is the same
661 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
662 
663 		// test if method name is the same
664 		assertEquals( "getMethodTags", method.getName() );
665 
666 		// test if parameters are the same
667 		parameters = method.getParameters().iterator();
668 	        parameter = (XParameter) parameters.next();
669 		assertEquals( "tagName", parameter.getName() );
670 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
671 	        parameter = (XParameter) parameters.next();
672 		assertEquals( "superclasses", parameter.getName() );
673 		assertEquals( "boolean", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
674 
675 		// test if doc is the same
676 		paramTags = method.getDoc().getTags("param",true).iterator();
677 
678 	    	method = (XMethod) methodIterator.next();
679 		// test if return type is the same
680 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
681 
682 		// test if method name is the same
683 		assertEquals( "getMethods", method.getName() );
684 
685 		// test if parameters are the same
686 		parameters = method.getParameters().iterator();
687 
688 		// test if doc is the same
689 		paramTags = method.getDoc().getTags("param",true).iterator();
690 
691 	    	method = (XMethod) methodIterator.next();
692 		// test if return type is the same
693 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
694 
695 		// test if method name is the same
696 		assertEquals( "getMethods", method.getName() );
697 
698 		// test if parameters are the same
699 		parameters = method.getParameters().iterator();
700 	        parameter = (XParameter) parameters.next();
701 		assertEquals( "predicate", parameter.getName() );
702 		assertEquals( "org.apache.commons.collections.Predicate", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
703 	        parameter = (XParameter) parameters.next();
704 		assertEquals( "superclasses", parameter.getName() );
705 		assertEquals( "boolean", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
706 
707 		// test if doc is the same
708 		paramTags = method.getDoc().getTags("param",true).iterator();
709 
710 	    	method = (XMethod) methodIterator.next();
711 		// test if return type is the same
712 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
713 
714 		// test if method name is the same
715 		assertEquals( "getMethods", method.getName() );
716 
717 		// test if parameters are the same
718 		parameters = method.getParameters().iterator();
719 	        parameter = (XParameter) parameters.next();
720 		assertEquals( "superclasses", parameter.getName() );
721 		assertEquals( "boolean", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
722 
723 		// test if doc is the same
724 		paramTags = method.getDoc().getTags("param",true).iterator();
725 
726 	    	method = (XMethod) methodIterator.next();
727 		// test if return type is the same
728 		assertEquals( "java.lang.String", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
729 
730 		// test if method name is the same
731 		assertEquals( "getName", method.getName() );
732 
733 		// test if parameters are the same
734 		parameters = method.getParameters().iterator();
735 
736 		// test if doc is the same
737 		paramTags = method.getDoc().getTags("param",true).iterator();
738 
739 	    	method = (XMethod) methodIterator.next();
740 		// test if return type is the same
741 		assertEquals( "java.lang.String", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
742 
743 		// test if method name is the same
744 		assertEquals( "getQualifiedName", method.getName() );
745 
746 		// test if parameters are the same
747 		parameters = method.getParameters().iterator();
748 
749 		// test if doc is the same
750 		paramTags = method.getDoc().getTags("param",true).iterator();
751 
752 	    	method = (XMethod) methodIterator.next();
753 		// test if return type is the same
754 		assertEquals( "xjavadoc.XProgramElement", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
755 
756 		// test if method name is the same
757 		assertEquals( "getSuperElement", method.getName() );
758 
759 		// test if parameters are the same
760 		parameters = method.getParameters().iterator();
761 
762 		// test if doc is the same
763 		paramTags = method.getDoc().getTags("param",true).iterator();
764 
765 	    	method = (XMethod) methodIterator.next();
766 		// test if return type is the same
767 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
768 
769 		// test if method name is the same
770 		assertEquals( "getSuperInterfaceElements", method.getName() );
771 
772 		// test if parameters are the same
773 		parameters = method.getParameters().iterator();
774 
775 		// test if doc is the same
776 		paramTags = method.getDoc().getTags("param",true).iterator();
777 
778 	    	method = (XMethod) methodIterator.next();
779 		// test if return type is the same
780 		assertEquals( "xjavadoc.XClass", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
781 
782 		// test if method name is the same
783 		assertEquals( "getSuperclass", method.getName() );
784 
785 		// test if parameters are the same
786 		parameters = method.getParameters().iterator();
787 
788 		// test if doc is the same
789 		paramTags = method.getDoc().getTags("param",true).iterator();
790 
791 	    	method = (XMethod) methodIterator.next();
792 		// test if return type is the same
793 		assertEquals( "java.lang.String", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
794 
795 		// test if method name is the same
796 		assertEquals( "getTransformedName", method.getName() );
797 
798 		// test if parameters are the same
799 		parameters = method.getParameters().iterator();
800 
801 		// test if doc is the same
802 		paramTags = method.getDoc().getTags("param",true).iterator();
803 
804 	    	method = (XMethod) methodIterator.next();
805 		// test if return type is the same
806 		assertEquals( "java.lang.String", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
807 
808 		// test if method name is the same
809 		assertEquals( "getTransformedQualifiedName", method.getName() );
810 
811 		// test if parameters are the same
812 		parameters = method.getParameters().iterator();
813 
814 		// test if doc is the same
815 		paramTags = method.getDoc().getTags("param",true).iterator();
816 
817 	    	method = (XMethod) methodIterator.next();
818 		// test if return type is the same
819 		assertEquals( "java.lang.String", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
820 
821 		// test if method name is the same
822 		assertEquals( "getType", method.getName() );
823 
824 		// test if parameters are the same
825 		parameters = method.getParameters().iterator();
826 
827 		// test if doc is the same
828 		paramTags = method.getDoc().getTags("param",true).iterator();
829 
830 	    	method = (XMethod) methodIterator.next();
831 		// test if return type is the same
832 		assertEquals( "boolean", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
833 
834 		// test if method name is the same
835 		assertEquals( "hasImportedClasses", method.getName() );
836 
837 		// test if parameters are the same
838 		parameters = method.getParameters().iterator();
839 
840 		// test if doc is the same
841 		paramTags = method.getDoc().getTags("param",true).iterator();
842 
843 	    	method = (XMethod) methodIterator.next();
844 		// test if return type is the same
845 		assertEquals( "boolean", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
846 
847 		// test if method name is the same
848 		assertEquals( "hasImportedPackages", method.getName() );
849 
850 		// test if parameters are the same
851 		parameters = method.getParameters().iterator();
852 
853 		// test if doc is the same
854 		paramTags = method.getDoc().getTags("param",true).iterator();
855 
856 	    	method = (XMethod) methodIterator.next();
857 		// test if return type is the same
858 		assertEquals( "boolean", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
859 
860 		// test if method name is the same
861 		assertEquals( "hasInnerClasses", method.getName() );
862 
863 		// test if parameters are the same
864 		parameters = method.getParameters().iterator();
865 
866 		// test if doc is the same
867 		paramTags = method.getDoc().getTags("param",true).iterator();
868 
869 	    	method = (XMethod) methodIterator.next();
870 		// test if return type is the same
871 		assertEquals( "int", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
872 
873 		// test if method name is the same
874 		assertEquals( "hashCode", method.getName() );
875 
876 		// test if parameters are the same
877 		parameters = method.getParameters().iterator();
878 
879 		// test if doc is the same
880 		paramTags = method.getDoc().getTags("param",true).iterator();
881 
882 	    	method = (XMethod) methodIterator.next();
883 		// test if return type is the same
884 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
885 
886 		// test if method name is the same
887 		assertEquals( "initializeNamedConstructorsHashMap", method.getName() );
888 
889 		// test if parameters are the same
890 		parameters = method.getParameters().iterator();
891 
892 		// test if doc is the same
893 		paramTags = method.getDoc().getTags("param",true).iterator();
894 
895 	    	method = (XMethod) methodIterator.next();
896 		// test if return type is the same
897 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
898 
899 		// test if method name is the same
900 		assertEquals( "initializeNamedMethodsHashMap", method.getName() );
901 
902 		// test if parameters are the same
903 		parameters = method.getParameters().iterator();
904 
905 		// test if doc is the same
906 		paramTags = method.getDoc().getTags("param",true).iterator();
907 
908 	    	method = (XMethod) methodIterator.next();
909 		// test if return type is the same
910 		assertEquals( "boolean", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
911 
912 		// test if method name is the same
913 		assertEquals( "isA", method.getName() );
914 
915 		// test if parameters are the same
916 		parameters = method.getParameters().iterator();
917 	        parameter = (XParameter) parameters.next();
918 		assertEquals( "full_qualified_type_name", parameter.getName() );
919 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
920 
921 		// test if doc is the same
922 		paramTags = method.getDoc().getTags("param",true).iterator();
923 
924 	    	method = (XMethod) methodIterator.next();
925 		// test if return type is the same
926 		assertEquals( "boolean", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
927 
928 		// test if method name is the same
929 		assertEquals( "isA", method.getName() );
930 
931 		// test if parameters are the same
932 		parameters = method.getParameters().iterator();
933 	        parameter = (XParameter) parameters.next();
934 		assertEquals( "full_qualified_type_name", parameter.getName() );
935 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
936 	        parameter = (XParameter) parameters.next();
937 		assertEquals( "superclasses", parameter.getName() );
938 		assertEquals( "boolean", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
939 
940 		// test if doc is the same
941 		paramTags = method.getDoc().getTags("param",true).iterator();
942 
943 	    	method = (XMethod) methodIterator.next();
944 		// test if return type is the same
945 		assertEquals( "boolean", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
946 
947 		// test if method name is the same
948 		assertEquals( "isAnonymous", method.getName() );
949 
950 		// test if parameters are the same
951 		parameters = method.getParameters().iterator();
952 
953 		// test if doc is the same
954 		paramTags = method.getDoc().getTags("param",true).iterator();
955 
956 	    	method = (XMethod) methodIterator.next();
957 		// test if return type is the same
958 		assertEquals( "boolean", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
959 
960 		// test if method name is the same
961 		assertEquals( "isImplementingInterface", method.getName() );
962 
963 		// test if parameters are the same
964 		parameters = method.getParameters().iterator();
965 	        parameter = (XParameter) parameters.next();
966 		assertEquals( "full_qualified_type_name", parameter.getName() );
967 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
968 
969 		// test if doc is the same
970 		paramTags = method.getDoc().getTags("param",true).iterator();
971 
972 	    	method = (XMethod) methodIterator.next();
973 		// test if return type is the same
974 		assertEquals( "boolean", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
975 
976 		// test if method name is the same
977 		assertEquals( "isImplementingInterface", method.getName() );
978 
979 		// test if parameters are the same
980 		parameters = method.getParameters().iterator();
981 	        parameter = (XParameter) parameters.next();
982 		assertEquals( "full_qualified_type_name", parameter.getName() );
983 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
984 	        parameter = (XParameter) parameters.next();
985 		assertEquals( "superclasses", parameter.getName() );
986 		assertEquals( "boolean", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
987 
988 		// test if doc is the same
989 		paramTags = method.getDoc().getTags("param",true).iterator();
990 
991 	    	method = (XMethod) methodIterator.next();
992 		// test if return type is the same
993 		assertEquals( "boolean", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
994 
995 		// test if method name is the same
996 		assertEquals( "isInner", method.getName() );
997 
998 		// test if parameters are the same
999 		parameters = method.getParameters().iterator();
1000 
1001 		// test if doc is the same
1002 		paramTags = method.getDoc().getTags("param",true).iterator();
1003 
1004 	    	method = (XMethod) methodIterator.next();
1005 		// test if return type is the same
1006 		assertEquals( "boolean", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
1007 
1008 		// test if method name is the same
1009 		assertEquals( "isInterface", method.getName() );
1010 
1011 		// test if parameters are the same
1012 		parameters = method.getParameters().iterator();
1013 
1014 		// test if doc is the same
1015 		paramTags = method.getDoc().getTags("param",true).iterator();
1016 
1017 	    	method = (XMethod) methodIterator.next();
1018 		// test if return type is the same
1019 		assertEquals( "boolean", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
1020 
1021 		// test if method name is the same
1022 		assertEquals( "isSubclassOf", method.getName() );
1023 
1024 		// test if parameters are the same
1025 		parameters = method.getParameters().iterator();
1026 	        parameter = (XParameter) parameters.next();
1027 		assertEquals( "full_qualified_type_name", parameter.getName() );
1028 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
1029 
1030 		// test if doc is the same
1031 		paramTags = method.getDoc().getTags("param",true).iterator();
1032 
1033 	    	method = (XMethod) methodIterator.next();
1034 		// test if return type is the same
1035 		assertEquals( "boolean", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
1036 
1037 		// test if method name is the same
1038 		assertEquals( "isSubclassOf", method.getName() );
1039 
1040 		// test if parameters are the same
1041 		parameters = method.getParameters().iterator();
1042 	        parameter = (XParameter) parameters.next();
1043 		assertEquals( "full_qualified_type_name", parameter.getName() );
1044 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
1045 	        parameter = (XParameter) parameters.next();
1046 		assertEquals( "superclasses", parameter.getName() );
1047 		assertEquals( "boolean", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
1048 
1049 		// test if doc is the same
1050 		paramTags = method.getDoc().getTags("param",true).iterator();
1051 
1052 	    	method = (XMethod) methodIterator.next();
1053 		// test if return type is the same
1054 		assertEquals( "long", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
1055 
1056 		// test if method name is the same
1057 		assertEquals( "lastModified", method.getName() );
1058 
1059 		// test if parameters are the same
1060 		parameters = method.getParameters().iterator();
1061 
1062 		// test if doc is the same
1063 		paramTags = method.getDoc().getTags("param",true).iterator();
1064 
1065 	    	method = (XMethod) methodIterator.next();
1066 		// test if return type is the same
1067 		assertEquals( "xjavadoc.XClass", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
1068 
1069 		// test if method name is the same
1070 		assertEquals( "qualify", method.getName() );
1071 
1072 		// test if parameters are the same
1073 		parameters = method.getParameters().iterator();
1074 	        parameter = (XParameter) parameters.next();
1075 		assertEquals( "unqualifiedClassName", parameter.getName() );
1076 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
1077 
1078 		// test if doc is the same
1079 		paramTags = method.getDoc().getTags("param",true).iterator();
1080 
1081 	    	method = (XMethod) methodIterator.next();
1082 		// test if return type is the same
1083 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
1084 
1085 		// test if method name is the same
1086 		assertEquals( "reset", method.getName() );
1087 
1088 		// test if parameters are the same
1089 		parameters = method.getParameters().iterator();
1090 
1091 		// test if doc is the same
1092 		paramTags = method.getDoc().getTags("param",true).iterator();
1093 
1094 	    	method = (XMethod) methodIterator.next();
1095 		// test if return type is the same
1096 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
1097 
1098 		// test if method name is the same
1099 		assertEquals( "resolveImportedClasses", method.getName() );
1100 
1101 		// test if parameters are the same
1102 		parameters = method.getParameters().iterator();
1103 
1104 		// test if doc is the same
1105 		paramTags = method.getDoc().getTags("param",true).iterator();
1106 
1107 	    	method = (XMethod) methodIterator.next();
1108 		// test if return type is the same
1109 		assertEquals( "java.lang.String", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
1110 
1111 		// test if method name is the same
1112 		assertEquals( "save", method.getName() );
1113 
1114 		// test if parameters are the same
1115 		parameters = method.getParameters().iterator();
1116 	        parameter = (XParameter) parameters.next();
1117 		assertEquals( "rootDir", parameter.getName() );
1118 		assertEquals( "java.io.File", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
1119 
1120 		// test if doc is the same
1121 		paramTags = method.getDoc().getTags("param",true).iterator();
1122 
1123 	    	method = (XMethod) methodIterator.next();
1124 		// test if return type is the same
1125 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
1126 
1127 		// test if method name is the same
1128 		assertEquals( "setContainingPackage", method.getName() );
1129 
1130 		// test if parameters are the same
1131 		parameters = method.getParameters().iterator();
1132 	        parameter = (XParameter) parameters.next();
1133 		assertEquals( "containingPackage", parameter.getName() );
1134 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
1135 
1136 		// test if doc is the same
1137 		paramTags = method.getDoc().getTags("param",true).iterator();
1138 	        paramTag = (XTag) paramTags.next();
1139 		assertEquals( tokenizeAndTrim("containingPackage  The new ContainingPackage value"), paramTag.getValue() );
1140 
1141 	    	method = (XMethod) methodIterator.next();
1142 		// test if return type is the same
1143 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
1144 
1145 		// test if method name is the same
1146 		assertEquals( "setInterface", method.getName() );
1147 
1148 		// test if parameters are the same
1149 		parameters = method.getParameters().iterator();
1150 	        parameter = (XParameter) parameters.next();
1151 		assertEquals( "flag", parameter.getName() );
1152 		assertEquals( "boolean", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
1153 
1154 		// test if doc is the same
1155 		paramTags = method.getDoc().getTags("param",true).iterator();
1156 	        paramTag = (XTag) paramTags.next();
1157 		assertEquals( tokenizeAndTrim("flag  The new Interface value"), paramTag.getValue() );
1158 
1159 	    	method = (XMethod) methodIterator.next();
1160 		// test if return type is the same
1161 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
1162 
1163 		// test if method name is the same
1164 		assertEquals( "setName", method.getName() );
1165 
1166 		// test if parameters are the same
1167 		parameters = method.getParameters().iterator();
1168 	        parameter = (XParameter) parameters.next();
1169 		assertEquals( "name", parameter.getName() );
1170 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
1171 
1172 		// test if doc is the same
1173 		paramTags = method.getDoc().getTags("param",true).iterator();
1174 	        paramTag = (XTag) paramTags.next();
1175 		assertEquals( tokenizeAndTrim("name  The new Name value"), paramTag.getValue() );
1176 
1177 	    	method = (XMethod) methodIterator.next();
1178 		// test if return type is the same
1179 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
1180 
1181 		// test if method name is the same
1182 		assertEquals( "setQualifiedName", method.getName() );
1183 
1184 		// test if parameters are the same
1185 		parameters = method.getParameters().iterator();
1186 	        parameter = (XParameter) parameters.next();
1187 		assertEquals( "qualifiedName", parameter.getName() );
1188 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
1189 
1190 		// test if doc is the same
1191 		paramTags = method.getDoc().getTags("param",true).iterator();
1192 	        paramTag = (XTag) paramTags.next();
1193 		assertEquals( tokenizeAndTrim("qualifiedName  The new QualifiedName value"), paramTag.getValue() );
1194 
1195 	    	method = (XMethod) methodIterator.next();
1196 		// test if return type is the same
1197 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
1198 
1199 		// test if method name is the same
1200 		assertEquals( "setRealised", method.getName() );
1201 
1202 		// test if parameters are the same
1203 		parameters = method.getParameters().iterator();
1204 	        parameter = (XParameter) parameters.next();
1205 		assertEquals( "clazz", parameter.getName() );
1206 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
1207 
1208 		// test if doc is the same
1209 		paramTags = method.getDoc().getTags("param",true).iterator();
1210 	        paramTag = (XTag) paramTags.next();
1211 		assertEquals( tokenizeAndTrim("clazz"), paramTag.getValue() );
1212 
1213 	    	method = (XMethod) methodIterator.next();
1214 		// test if return type is the same
1215 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
1216 
1217 		// test if method name is the same
1218 		assertEquals( "setSuperclass", method.getName() );
1219 
1220 		// test if parameters are the same
1221 		parameters = method.getParameters().iterator();
1222 	        parameter = (XParameter) parameters.next();
1223 		assertEquals( "superclass", parameter.getName() );
1224 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
1225 
1226 		// test if doc is the same
1227 		paramTags = method.getDoc().getTags("param",true).iterator();
1228 	        paramTag = (XTag) paramTags.next();
1229 		assertEquals( tokenizeAndTrim("superclass  The new Superclass value"), paramTag.getValue() );
1230 
1231 	    	method = (XMethod) methodIterator.next();
1232 		// test if return type is the same
1233 		assertEquals( "java.lang.String", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
1234 
1235 		// test if method name is the same
1236 		assertEquals( "toString", method.getName() );
1237 
1238 		// test if parameters are the same
1239 		parameters = method.getParameters().iterator();
1240 
1241 		// test if doc is the same
1242 		paramTags = method.getDoc().getTags("param",true).iterator();
1243 
1244 	    	method = (XMethod) methodIterator.next();
1245 		// test if return type is the same
1246 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
1247 
1248 		// test if method name is the same
1249 		assertEquals( "updateDoc", method.getName() );
1250 
1251 		// test if parameters are the same
1252 		parameters = method.getParameters().iterator();
1253 
1254 		// test if doc is the same
1255 		paramTags = method.getDoc().getTags("param",true).iterator();
1256 
1257 	    	method = (XMethod) methodIterator.next();
1258 		// test if return type is the same
1259 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
1260 
1261 		// test if method name is the same
1262 		assertEquals( "validate", method.getName() );
1263 
1264 		// test if parameters are the same
1265 		parameters = method.getParameters().iterator();
1266 	        parameter = (XParameter) parameters.next();
1267 		assertEquals( "member", parameter.getName() );
1268 		assertEquals( "xjavadoc.XMember", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
1269 
1270 		// test if doc is the same
1271 		paramTags = method.getDoc().getTags("param",true).iterator();
1272 
1273 	}
1274 }