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 XDoc__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 XDoc__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.XDoc" );
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( "EMPTY_COMMENT", field.getName() );
85  		// test if field type is the same
86  		field = (XField) fieldIterator.next();
87  		assertEquals( "java.lang.String", field.getType().getQualifiedName() + field.getDimensionAsString());
88  		// test if field name is the same
89  		assertEquals( "NEWLINE", field.getName() );
90  		// test if field type is the same
91  		field = (XField) fieldIterator.next();
92  		assertEquals( "java.lang.String", field.getType().getQualifiedName() + field.getDimensionAsString());
93  		// test if field name is the same
94  		assertEquals( "_commentText", field.getName() );
95  		// test if field type is the same
96  		field = (XField) fieldIterator.next();
97  		assertEquals( "boolean", field.getType().getQualifiedName() + field.getDimensionAsString());
98  		// test if field name is the same
99  		assertEquals( "_dirty", field.getName() );
100 		// test if field type is the same
101 		field = (XField) fieldIterator.next();
102 		assertEquals( "java.util.Set", field.getType().getQualifiedName() + field.getDimensionAsString());
103 		// test if field name is the same
104 		assertEquals( "_docListeners", field.getName() );
105 		// test if field type is the same
106 		field = (XField) fieldIterator.next();
107 		assertEquals( "java.lang.String", field.getType().getQualifiedName() + field.getDimensionAsString());
108 		// test if field name is the same
109 		assertEquals( "_firstSentence", field.getName() );
110 		// test if field type is the same
111 		field = (XField) fieldIterator.next();
112 		assertEquals( "xjavadoc.Token", field.getType().getQualifiedName() + field.getDimensionAsString());
113 		// test if field name is the same
114 		assertEquals( "_javadocToken", field.getName() );
115 		// test if field type is the same
116 		field = (XField) fieldIterator.next();
117 		assertEquals( "xjavadoc.XProgramElement", field.getType().getQualifiedName() + field.getDimensionAsString());
118 		// test if field name is the same
119 		assertEquals( "_owner", field.getName() );
120 		// test if field type is the same
121 		field = (XField) fieldIterator.next();
122 		assertEquals( "xjavadoc.XTagFactory", field.getType().getQualifiedName() + field.getDimensionAsString());
123 		// test if field name is the same
124 		assertEquals( "_tagFactory", field.getName() );
125 		// test if field type is the same
126 		field = (XField) fieldIterator.next();
127 		assertEquals( "java.util.Map", field.getType().getQualifiedName() + field.getDimensionAsString());
128 		// test if field name is the same
129 		assertEquals( "_tagMap", 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( "_tags", field.getName() );
135 		// test if field type is the same
136 		field = (XField) fieldIterator.next();
137 		assertEquals( "int", field.getType().getQualifiedName() + field.getDimensionAsString());
138 		// test if field name is the same
139 		assertEquals( "instanceCount", field.getName() );
140 	}
141 
142 	public void testMethods() {
143 
144 		// Sort the methods
145 		Collection methods = _testedClass.getMethods();
146 		ArrayList sortedMethods = new ArrayList();
147 		sortedMethods.addAll(methods);
148 		Collections.sort(sortedMethods);
149 		Iterator methodIterator = sortedMethods.iterator();
150 		XMethod method = null;
151 
152 		Iterator parameters = null;
153 		XParameter parameter = null;
154 
155 		Iterator paramTags = null;
156 		XTag paramTag = null;
157 
158 	    	method = (XMethod) methodIterator.next();
159 		// test if return type is the same
160 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
161 
162 		// test if method name is the same
163 		assertEquals( "addDocListener", method.getName() );
164 
165 		// test if parameters are the same
166 		parameters = method.getParameters().iterator();
167 	        parameter = (XParameter) parameters.next();
168 		assertEquals( "docListener", parameter.getName() );
169 		assertEquals( "xjavadoc.event.XDocListener", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
170 
171 		// test if doc is the same
172 		paramTags = method.getDoc().getTags("param",true).iterator();
173 	        paramTag = (XTag) paramTags.next();
174 		assertEquals( tokenizeAndTrim("docListener  doc listener to register"), paramTag.getValue() );
175 
176 	    	method = (XMethod) methodIterator.next();
177 		// test if return type is the same
178 		assertEquals( "xjavadoc.XTag", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
179 
180 		// test if method name is the same
181 		assertEquals( "addTag", method.getName() );
182 
183 		// test if parameters are the same
184 		parameters = method.getParameters().iterator();
185 	        parameter = (XParameter) parameters.next();
186 		assertEquals( "tagName", parameter.getName() );
187 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
188 	        parameter = (XParameter) parameters.next();
189 		assertEquals( "text", parameter.getName() );
190 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
191 
192 		// test if doc is the same
193 		paramTags = method.getDoc().getTags("param",true).iterator();
194 	        paramTag = (XTag) paramTags.next();
195 		assertEquals( tokenizeAndTrim("tagName                  The name of the tag to add"), paramTag.getValue() );
196 	        paramTag = (XTag) paramTags.next();
197 		assertEquals( tokenizeAndTrim("text                     The value of the tag"), paramTag.getValue() );
198 
199 	    	method = (XMethod) methodIterator.next();
200 		// test if return type is the same
201 		assertEquals( "xjavadoc.XTag", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
202 
203 		// test if method name is the same
204 		assertEquals( "addTag_Impl", method.getName() );
205 
206 		// test if parameters are the same
207 		parameters = method.getParameters().iterator();
208 	        parameter = (XParameter) parameters.next();
209 		assertEquals( "tagName", parameter.getName() );
210 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
211 	        parameter = (XParameter) parameters.next();
212 		assertEquals( "text", parameter.getName() );
213 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
214 	        parameter = (XParameter) parameters.next();
215 		assertEquals( "lineNumber", parameter.getName() );
216 		assertEquals( "int", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
217 
218 		// test if doc is the same
219 		paramTags = method.getDoc().getTags("param",true).iterator();
220 	        paramTag = (XTag) paramTags.next();
221 		assertEquals( tokenizeAndTrim("tagName                     The name of the tag (without the 'at')"), paramTag.getValue() );
222 	        paramTag = (XTag) paramTags.next();
223 		assertEquals( tokenizeAndTrim("text                        The raw content of the tag"), paramTag.getValue() );
224 	        paramTag = (XTag) paramTags.next();
225 		assertEquals( tokenizeAndTrim("lineNumber                  The feature to be added to the Tag_Impl       attribute"), paramTag.getValue() );
226 
227 	    	method = (XMethod) methodIterator.next();
228 		// test if return type is the same
229 		assertEquals( "java.lang.StringBuffer", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
230 
231 		// test if method name is the same
232 		assertEquals( "appendWhiteSpaces", method.getName() );
233 
234 		// test if parameters are the same
235 		parameters = method.getParameters().iterator();
236 	        parameter = (XParameter) parameters.next();
237 		assertEquals( "sb", parameter.getName() );
238 		assertEquals( "java.lang.StringBuffer", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
239 
240 		// test if doc is the same
241 		paramTags = method.getDoc().getTags("param",true).iterator();
242 	        paramTag = (XTag) paramTags.next();
243 		assertEquals( tokenizeAndTrim("sb  StringBuffer that the text is being built in"), paramTag.getValue() );
244 
245 	    	method = (XMethod) methodIterator.next();
246 		// test if return type is the same
247 		assertEquals( "java.lang.String", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
248 
249 		// test if method name is the same
250 		assertEquals( "dotted", method.getName() );
251 
252 		// test if parameters are the same
253 		parameters = method.getParameters().iterator();
254 	        parameter = (XParameter) parameters.next();
255 		assertEquals( "tagName", 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("tagName  The name of the tag"), 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( "ensureTagMapInitialised", method.getName() );
269 
270 		// test if parameters are the same
271 		parameters = method.getParameters().iterator();
272 
273 		// test if doc is the same
274 		paramTags = method.getDoc().getTags("param",true).iterator();
275 
276 	    	method = (XMethod) methodIterator.next();
277 		// test if return type is the same
278 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
279 
280 		// test if method name is the same
281 		assertEquals( "fireDocChanged", method.getName() );
282 
283 		// test if parameters are the same
284 		parameters = method.getParameters().iterator();
285 
286 		// test if doc is the same
287 		paramTags = method.getDoc().getTags("param",true).iterator();
288 
289 	    	method = (XMethod) methodIterator.next();
290 		// test if return type is the same
291 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
292 
293 		// test if method name is the same
294 		assertEquals( "getAllSuperDocs", method.getName() );
295 
296 		// test if parameters are the same
297 		parameters = method.getParameters().iterator();
298 
299 		// test if doc is the same
300 		paramTags = method.getDoc().getTags("param",true).iterator();
301 
302 	    	method = (XMethod) methodIterator.next();
303 		// test if return type is the same
304 		assertEquals( "java.lang.String", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
305 
306 		// test if method name is the same
307 		assertEquals( "getCommentText", method.getName() );
308 
309 		// test if parameters are the same
310 		parameters = method.getParameters().iterator();
311 
312 		// test if doc is the same
313 		paramTags = method.getDoc().getTags("param",true).iterator();
314 
315 	    	method = (XMethod) methodIterator.next();
316 		// test if return type is the same
317 		assertEquals( "java.lang.String", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
318 
319 		// test if method name is the same
320 		assertEquals( "getFirstSentence", method.getName() );
321 
322 		// test if parameters are the same
323 		parameters = method.getParameters().iterator();
324 
325 		// test if doc is the same
326 		paramTags = method.getDoc().getTags("param",true).iterator();
327 
328 	    	method = (XMethod) methodIterator.next();
329 		// test if return type is the same
330 		assertEquals( "xjavadoc.XProgramElement", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
331 
332 		// test if method name is the same
333 		assertEquals( "getOwner", method.getName() );
334 
335 		// test if parameters are the same
336 		parameters = method.getParameters().iterator();
337 
338 		// test if doc is the same
339 		paramTags = method.getDoc().getTags("param",true).iterator();
340 
341 	    	method = (XMethod) methodIterator.next();
342 		// test if return type is the same
343 		assertEquals( "xjavadoc.XDoc", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
344 
345 		// test if method name is the same
346 		assertEquals( "getSuperDoc", method.getName() );
347 
348 		// test if parameters are the same
349 		parameters = method.getParameters().iterator();
350 
351 		// test if doc is the same
352 		paramTags = method.getDoc().getTags("param",true).iterator();
353 
354 	    	method = (XMethod) methodIterator.next();
355 		// test if return type is the same
356 		assertEquals( "xjavadoc.XTag", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
357 
358 		// test if method name is the same
359 		assertEquals( "getTag", method.getName() );
360 
361 		// test if parameters are the same
362 		parameters = method.getParameters().iterator();
363 	        parameter = (XParameter) parameters.next();
364 		assertEquals( "tagName", parameter.getName() );
365 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
366 
367 		// test if doc is the same
368 		paramTags = method.getDoc().getTags("param",true).iterator();
369 	        paramTag = (XTag) paramTags.next();
370 		assertEquals( tokenizeAndTrim("tagName  the name of the tag"), paramTag.getValue() );
371 
372 	    	method = (XMethod) methodIterator.next();
373 		// test if return type is the same
374 		assertEquals( "xjavadoc.XTag", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
375 
376 		// test if method name is the same
377 		assertEquals( "getTag", method.getName() );
378 
379 		// test if parameters are the same
380 		parameters = method.getParameters().iterator();
381 	        parameter = (XParameter) parameters.next();
382 		assertEquals( "tagName", parameter.getName() );
383 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
384 	        parameter = (XParameter) parameters.next();
385 		assertEquals( "superclasses", parameter.getName() );
386 		assertEquals( "boolean", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
387 
388 		// test if doc is the same
389 		paramTags = method.getDoc().getTags("param",true).iterator();
390 	        paramTag = (XTag) paramTags.next();
391 		assertEquals( tokenizeAndTrim("tagName       the name of the tag to get (without the 'at')"), paramTag.getValue() );
392 	        paramTag = (XTag) paramTags.next();
393 		assertEquals( tokenizeAndTrim("superclasses  if this is true, return tags from superclasses too."), paramTag.getValue() );
394 
395 	    	method = (XMethod) methodIterator.next();
396 		// test if return type is the same
397 		assertEquals( "java.lang.String", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
398 
399 		// test if method name is the same
400 		assertEquals( "getTagAttributeValue", method.getName() );
401 
402 		// test if parameters are the same
403 		parameters = method.getParameters().iterator();
404 	        parameter = (XParameter) parameters.next();
405 		assertEquals( "tagName", parameter.getName() );
406 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
407 	        parameter = (XParameter) parameters.next();
408 		assertEquals( "attributeName", parameter.getName() );
409 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
410 
411 		// test if doc is the same
412 		paramTags = method.getDoc().getTags("param",true).iterator();
413 	        paramTag = (XTag) paramTags.next();
414 		assertEquals( tokenizeAndTrim("tagName        The name of the tag to look for (without the 'at')"), paramTag.getValue() );
415 	        paramTag = (XTag) paramTags.next();
416 		assertEquals( tokenizeAndTrim("attributeName  The name of the attribute to look for within the tag."), paramTag.getValue() );
417 
418 	    	method = (XMethod) methodIterator.next();
419 		// test if return type is the same
420 		assertEquals( "java.lang.String", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
421 
422 		// test if method name is the same
423 		assertEquals( "getTagAttributeValue", method.getName() );
424 
425 		// test if parameters are the same
426 		parameters = method.getParameters().iterator();
427 	        parameter = (XParameter) parameters.next();
428 		assertEquals( "tagName", parameter.getName() );
429 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
430 	        parameter = (XParameter) parameters.next();
431 		assertEquals( "attributeName", parameter.getName() );
432 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
433 	        parameter = (XParameter) parameters.next();
434 		assertEquals( "superclasses", parameter.getName() );
435 		assertEquals( "boolean", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
436 
437 		// test if doc is the same
438 		paramTags = method.getDoc().getTags("param",true).iterator();
439 	        paramTag = (XTag) paramTags.next();
440 		assertEquals( tokenizeAndTrim("tagName        The name of the tag to look for (without the 'at')"), paramTag.getValue() );
441 	        paramTag = (XTag) paramTags.next();
442 		assertEquals( tokenizeAndTrim("attributeName  The name of the attribute to look for within the tag."), paramTag.getValue() );
443 	        paramTag = (XTag) paramTags.next();
444 		assertEquals( tokenizeAndTrim("superclasses   Set it to true to look in superclasses too."), paramTag.getValue() );
445 
446 	    	method = (XMethod) methodIterator.next();
447 		// test if return type is the same
448 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
449 
450 		// test if method name is the same
451 		assertEquals( "getTags", method.getName() );
452 
453 		// test if parameters are the same
454 		parameters = method.getParameters().iterator();
455 	        parameter = (XParameter) parameters.next();
456 		assertEquals( "tagName", parameter.getName() );
457 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
458 
459 		// test if doc is the same
460 		paramTags = method.getDoc().getTags("param",true).iterator();
461 	        paramTag = (XTag) paramTags.next();
462 		assertEquals( tokenizeAndTrim("tagName  the name of the tags to return (without the 'at')"), paramTag.getValue() );
463 
464 	    	method = (XMethod) methodIterator.next();
465 		// test if return type is the same
466 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
467 
468 		// test if method name is the same
469 		assertEquals( "getTags", method.getName() );
470 
471 		// test if parameters are the same
472 		parameters = method.getParameters().iterator();
473 	        parameter = (XParameter) parameters.next();
474 		assertEquals( "tagName", parameter.getName() );
475 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
476 	        parameter = (XParameter) parameters.next();
477 		assertEquals( "superclasses", parameter.getName() );
478 		assertEquals( "boolean", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
479 
480 		// test if doc is the same
481 		paramTags = method.getDoc().getTags("param",true).iterator();
482 	        paramTag = (XTag) paramTags.next();
483 		assertEquals( tokenizeAndTrim("tagName       the name of the tags to return (without the 'at')"), paramTag.getValue() );
484 	        paramTag = (XTag) paramTags.next();
485 		assertEquals( tokenizeAndTrim("superclasses  if this is true, return tags from superclasses too."), paramTag.getValue() );
486 
487 	    	method = (XMethod) methodIterator.next();
488 		// test if return type is the same
489 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
490 
491 		// test if method name is the same
492 		assertEquals( "getTags", method.getName() );
493 
494 		// test if parameters are the same
495 		parameters = method.getParameters().iterator();
496 
497 		// test if doc is the same
498 		paramTags = method.getDoc().getTags("param",true).iterator();
499 
500 	    	method = (XMethod) methodIterator.next();
501 		// test if return type is the same
502 		assertEquals( "java.util.List", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
503 
504 		// test if method name is the same
505 		assertEquals( "getTags", method.getName() );
506 
507 		// test if parameters are the same
508 		parameters = method.getParameters().iterator();
509 	        parameter = (XParameter) parameters.next();
510 		assertEquals( "superclasses", parameter.getName() );
511 		assertEquals( "boolean", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
512 
513 		// test if doc is the same
514 		paramTags = method.getDoc().getTags("param",true).iterator();
515 	        paramTag = (XTag) paramTags.next();
516 		assertEquals( tokenizeAndTrim("superclasses  if this is true, return tags from superclasses too."), paramTag.getValue() );
517 
518 	    	method = (XMethod) methodIterator.next();
519 		// test if return type is the same
520 		assertEquals( "boolean", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
521 
522 		// test if method name is the same
523 		assertEquals( "hasTag", method.getName() );
524 
525 		// test if parameters are the same
526 		parameters = method.getParameters().iterator();
527 	        parameter = (XParameter) parameters.next();
528 		assertEquals( "tagName", parameter.getName() );
529 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
530 
531 		// test if doc is the same
532 		paramTags = method.getDoc().getTags("param",true).iterator();
533 	        paramTag = (XTag) paramTags.next();
534 		assertEquals( tokenizeAndTrim("tagName  The name of the tag to look for (without the 'at')"), paramTag.getValue() );
535 
536 	    	method = (XMethod) methodIterator.next();
537 		// test if return type is the same
538 		assertEquals( "boolean", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
539 
540 		// test if method name is the same
541 		assertEquals( "hasTag", method.getName() );
542 
543 		// test if parameters are the same
544 		parameters = method.getParameters().iterator();
545 	        parameter = (XParameter) parameters.next();
546 		assertEquals( "tagName", parameter.getName() );
547 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
548 	        parameter = (XParameter) parameters.next();
549 		assertEquals( "superclasses", parameter.getName() );
550 		assertEquals( "boolean", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
551 
552 		// test if doc is the same
553 		paramTags = method.getDoc().getTags("param",true).iterator();
554 	        paramTag = (XTag) paramTags.next();
555 		assertEquals( tokenizeAndTrim("tagName       The name of the tag to look for (without the 'at')"), paramTag.getValue() );
556 	        paramTag = (XTag) paramTags.next();
557 		assertEquals( tokenizeAndTrim("superclasses  If true, look in superclasses too."), paramTag.getValue() );
558 
559 	    	method = (XMethod) methodIterator.next();
560 		// test if return type is the same
561 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
562 
563 		// test if method name is the same
564 		assertEquals( "parse", method.getName() );
565 
566 		// test if parameters are the same
567 		parameters = method.getParameters().iterator();
568 
569 		// test if doc is the same
570 		paramTags = method.getDoc().getTags("param",true).iterator();
571 
572 	    	method = (XMethod) methodIterator.next();
573 		// test if return type is the same
574 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
575 
576 		// test if method name is the same
577 		assertEquals( "removeDocListener", method.getName() );
578 
579 		// test if parameters are the same
580 		parameters = method.getParameters().iterator();
581 	        parameter = (XParameter) parameters.next();
582 		assertEquals( "docListener", parameter.getName() );
583 		assertEquals( "xjavadoc.event.XDocListener", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
584 
585 		// test if doc is the same
586 		paramTags = method.getDoc().getTags("param",true).iterator();
587 	        paramTag = (XTag) paramTags.next();
588 		assertEquals( tokenizeAndTrim("docListener"), paramTag.getValue() );
589 
590 	    	method = (XMethod) methodIterator.next();
591 		// test if return type is the same
592 		assertEquals( "boolean", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
593 
594 		// test if method name is the same
595 		assertEquals( "removeTag", method.getName() );
596 
597 		// test if parameters are the same
598 		parameters = method.getParameters().iterator();
599 	        parameter = (XParameter) parameters.next();
600 		assertEquals( "tag", parameter.getName() );
601 		assertEquals( "xjavadoc.XTag", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
602 
603 		// test if doc is the same
604 		paramTags = method.getDoc().getTags("param",true).iterator();
605 	        paramTag = (XTag) paramTags.next();
606 		assertEquals( tokenizeAndTrim("tag  tag to be removed"), paramTag.getValue() );
607 
608 	    	method = (XMethod) methodIterator.next();
609 		// test if return type is the same
610 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
611 
612 		// test if method name is the same
613 		assertEquals( "setCommentText", method.getName() );
614 
615 		// test if parameters are the same
616 		parameters = method.getParameters().iterator();
617 	        parameter = (XParameter) parameters.next();
618 		assertEquals( "commentText", parameter.getName() );
619 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
620 
621 		// test if doc is the same
622 		paramTags = method.getDoc().getTags("param",true).iterator();
623 	        paramTag = (XTag) paramTags.next();
624 		assertEquals( tokenizeAndTrim("commentText  The new comment text"), paramTag.getValue() );
625 
626 	    	method = (XMethod) methodIterator.next();
627 		// test if return type is the same
628 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
629 
630 		// test if method name is the same
631 		assertEquals( "tagChanged", method.getName() );
632 
633 		// test if parameters are the same
634 		parameters = method.getParameters().iterator();
635 	        parameter = (XParameter) parameters.next();
636 		assertEquals( "event", parameter.getName() );
637 		assertEquals( "xjavadoc.event.XTagEvent", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
638 
639 		// test if doc is the same
640 		paramTags = method.getDoc().getTags("param",true).iterator();
641 	        paramTag = (XTag) paramTags.next();
642 		assertEquals( tokenizeAndTrim("event"), paramTag.getValue() );
643 
644 	    	method = (XMethod) methodIterator.next();
645 		// test if return type is the same
646 		assertEquals( "java.lang.String", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
647 
648 		// test if method name is the same
649 		assertEquals( "toString", method.getName() );
650 
651 		// test if parameters are the same
652 		parameters = method.getParameters().iterator();
653 
654 		// test if doc is the same
655 		paramTags = method.getDoc().getTags("param",true).iterator();
656 
657 	    	method = (XMethod) methodIterator.next();
658 		// test if return type is the same
659 		assertEquals( "java.lang.String", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
660 
661 		// test if method name is the same
662 		assertEquals( "tokenizeAndTrim", method.getName() );
663 
664 		// test if parameters are the same
665 		parameters = method.getParameters().iterator();
666 	        parameter = (XParameter) parameters.next();
667 		assertEquals( "s", parameter.getName() );
668 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
669 
670 		// test if doc is the same
671 		paramTags = method.getDoc().getTags("param",true).iterator();
672 
673 	    	method = (XMethod) methodIterator.next();
674 		// test if return type is the same
675 		assertEquals( "xjavadoc.XTag", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
676 
677 		// test if method name is the same
678 		assertEquals( "updateTagValue", method.getName() );
679 
680 		// test if parameters are the same
681 		parameters = method.getParameters().iterator();
682 	        parameter = (XParameter) parameters.next();
683 		assertEquals( "tagName", parameter.getName() );
684 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
685 	        parameter = (XParameter) parameters.next();
686 		assertEquals( "attributeName", parameter.getName() );
687 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
688 	        parameter = (XParameter) parameters.next();
689 		assertEquals( "attributeValue", parameter.getName() );
690 		assertEquals( "java.lang.String", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
691 	        parameter = (XParameter) parameters.next();
692 		assertEquals( "tagIndex", parameter.getName() );
693 		assertEquals( "int", parameter.getType().getQualifiedName() + parameter.getDimensionAsString());
694 
695 		// test if doc is the same
696 		paramTags = method.getDoc().getTags("param",true).iterator();
697 	        paramTag = (XTag) paramTags.next();
698 		assertEquals( tokenizeAndTrim("tagName                The new name of the tag to update (without the"), paramTag.getValue() );
699 	        paramTag = (XTag) paramTags.next();
700 		assertEquals( tokenizeAndTrim("tagIndex               The index of the tag to update, in case there       are several tags with the same name."), paramTag.getValue() );
701 	        paramTag = (XTag) paramTags.next();
702 		assertEquals( tokenizeAndTrim("attributeName          The attribute name"), paramTag.getValue() );
703 	        paramTag = (XTag) paramTags.next();
704 		assertEquals( tokenizeAndTrim("attributeValue         The new attribute value"), paramTag.getValue() );
705 
706 	    	method = (XMethod) methodIterator.next();
707 		// test if return type is the same
708 		assertEquals( "void", method.getReturnType().getType().getQualifiedName() + method.getReturnType().getDimensionAsString());
709 
710 		// test if method name is the same
711 		assertEquals( "updateToken", method.getName() );
712 
713 		// test if parameters are the same
714 		parameters = method.getParameters().iterator();
715 
716 		// test if doc is the same
717 		paramTags = method.getDoc().getTags("param",true).iterator();
718 
719 	}
720 }