1   /*
2    * Copyright (c) 2001-2003 The XDoclet team
3    * All rights reserved.
4    */
5   package xjavadoc;
6   
7   import junit.framework.*;
8   import java.io.File;
9   import java.util.Collection;
10  import java.util.Iterator;
11  import java.util.HashMap;
12  
13  import xjavadoc.filesystem.FileSourceSet;
14  
15  /***
16   * @created   25. mars 2003
17   */
18  public class XJavaDocTest extends TestCase
19  {
20      private final XJavaDoc _xJavaDoc = new XJavaDoc();
21  
22  	public void setUp() throws Exception
23  	{
24  		File dir = new File( System.getProperty( "basedir" ) + File.separator + "test" );
25  		HashMap propertyMap = new HashMap();
26  
27  		propertyMap.put( "name", "xjavadoc" );
28  		propertyMap.put( "version", "1.0" );
29  
30  		_xJavaDoc.reset(true);
31  		_xJavaDoc.setPropertyMap( propertyMap );
32  		_xJavaDoc.addSourceSet( new FileSourceSet( dir ) );
33  	}
34  
35  	/***
36  	 * A unit test for JUnit
37  	 */
38  	public void testReadHello()
39  	{
40  		XClass clazz = _xJavaDoc.getXClass( "Hello" );
41  
42  		XDoc doc = clazz.getDoc();
43  
44  		assertEquals( "Bla bla yadda yadda", doc.getFirstSentence() );
45  
46  		XTag tag = (XTag) doc.getTags().get(0);
47  
48  		assertEquals( "foo.bar", tag.getName() );
49  		assertEquals( "beer=\"good\" tea=\"bad\"", tag.getValue() );
50  
51  		doc = clazz.getMethod( "getNonsense()" ).getDoc();
52  		tag = (XTag) doc.getTags().get(0);
53  		assertEquals( "This is getNonsense.", doc.getFirstSentence() );
54  		assertEquals( "star.wars", tag.getName() );
55  		assertEquals( "is=\"a crappy movie\" but=\"I went to see it anyway\"", tag.getValue() );
56  
57  		tag = (XTag) doc.getTags().get(1);
58  		assertEquals( "empty.tag", tag.getName() );
59  		assertEquals( "", tag.getValue() );
60  
61  		doc = clazz.getMethod( "whatever(java.lang.String[][],int)" ).getDoc();
62  		tag = (XTag) doc.getTags().get(0);
63  		assertEquals( "Mr.", doc.getFirstSentence() );
64  		assertEquals( "more", tag.getName() );
65  		assertEquals( "testdata, bla bla", tag.getValue() );
66  
67  		tag = (XTag) doc.getTags().get(1);
68  		assertEquals( "maybe", tag.getName() );
69  		assertEquals( "this=\"is\" only=\"testdata\"", tag.getValue() );
70  	}
71  
72  	/***
73  	 * A unit test for JUnit
74  	 */
75  	public void testPrivateField()
76  	{
77  
78  		XClass clazz = _xJavaDoc.getXClass( "Hello" );
79  		XField privateField = clazz.getField( "privateField" );
80  		XDoc doc = privateField.getDoc();
81  
82  		assertEquals( "Braba papa, barba mama, baraba brother, barba sister", doc.getFirstSentence() );
83  		assertEquals( "privateField", privateField.getName() );
84  		assertEquals( 0, privateField.getDimension() );
85  		assertEquals( "java.lang.String", privateField.getType().getQualifiedName() );
86  		assertEquals( "java.lang.String", privateField.getType().getTransformedQualifiedName() );
87  		assertEquals( "String", privateField.getType().getTransformedName() );
88  		assertTrue( privateField.isPrivate() );
89  	}
90  
91  	public void testInheritedFields()
92  	{
93  		XClass clazz = _xJavaDoc.getXClass( "Goodbye" );
94  		// get fields from superclass too
95  		Collection fields = clazz.getFields( true );
96  
97  		// one from Goodbye and two from Hello
98  		assertEquals( 3, fields.size() );
99  
100 		for( Iterator i = fields.iterator(); i.hasNext();  )
101 		{
102 			XField field = ( XField ) i.next();
103 
104 			// The field name should not be "privateField"
105 			assertTrue( !"privateField".equals( field.getName() ) );
106 		}
107 	}
108 
109 	public void testFirstSentence()
110 	{
111 		XClass clazz = _xJavaDoc.getXClass( "Hello" );
112 		XMethod method = clazz.getMethod( "firstMethod()" );
113 		XDoc doc = method.getDoc();
114 
115 		assertEquals( "This shouldn't be the first sentence.This one should be.", doc.getFirstSentence() );
116 	}
117 
118 	/***
119 	 * Read a class, get a method, modify a tag parameter, reread it and see if
120 	 * change was successful.
121 	 *
122 	 * @exception Exception
123 	 */
124 	public void testGetMethodParameterValue() throws Exception
125 	{
126 		_xJavaDoc.setUseNodeParser( true );
127 
128 		XClass clazz = _xJavaDoc.getXClass( "Hello" );
129 		XMethod method = clazz.getMethod( "whatever(java.lang.String[][],int)" );
130 		XDoc doc = method.getDoc();
131 
132 		assertEquals( "is", doc.getTagAttributeValue( "maybe", "this", true ) );
133 
134 		File testDir = new File( "target/saved/testGetMethodParameterValue" );
135 		String fileName = clazz.save( testDir );
136 	}
137 
138 	public void testModifyMethodParameterValue() throws Exception
139 	{
140 		_xJavaDoc.setUseNodeParser( true );
141 
142 		XClass clazz = _xJavaDoc.updateMethodTag(
143 			"Hello",
144 			"whatever(java.lang.String[],int)",
145 			"numbers",
146 			"three",
147 			"trois",
148 			0
149 			 );
150 		File testDir = new File( "target/saved/testModifyMethodParameterValue" );
151 		String fileName = clazz.save( testDir );
152 	}
153 
154 	public void testAddCommentToCommentedClass() throws Exception
155 	{
156 		_xJavaDoc.setUseNodeParser( true );
157 
158 		XClass clazz = _xJavaDoc.updateClassTag( "Hello", "here", "is", "a tag for ya", 0 );
159 		File testDir = new File( "target/saved/testAddCommentToCommentedClass" );
160 		String fileName = clazz.save( testDir );
161 	}
162 
163 	public void testInnerClass() throws Exception
164 	{
165 		XClass clazz = _xJavaDoc.getXClass( "Hello" );
166 		Collection innerClasses = clazz.getInnerClasses();
167 
168 		assertEquals( 2, innerClasses.size() );
169 
170 		Iterator i = innerClasses.iterator();
171 
172 		XClass innerClass = ( XClass ) i.next();
173 
174 		assertEquals( "Hello.InnerClass", innerClass.getQualifiedName() );
175                 assertEquals( "Hello$InnerClass", innerClass.getTransformedName() );
176                 assertEquals( "Hello$InnerClass", innerClass.getTransformedQualifiedName() );
177 
178 		XClass methodInnerClass = ( XClass ) i.next();
179 
180 		assertEquals( "Hello.MethodInnerClass", methodInnerClass.getQualifiedName() );
181                 assertEquals( "Hello$MethodInnerClass", methodInnerClass.getTransformedName() );
182                 assertEquals( "Hello$MethodInnerClass", methodInnerClass.getTransformedQualifiedName() );
183 	}
184 
185 	public void testIsA() throws Exception
186 	{
187 		XClass clazz = _xJavaDoc.getXClass( "Hello" );
188 
189 		assertTrue( "Hello is Serializable", clazz.isImplementingInterface( "java.io.Serializable" ) );
190 		assertTrue( "Hello is MouseListener", clazz.isA( "java.awt.event.MouseListener" ) );
191 		assertTrue( "Hello is Action", clazz.isA( "javax.swing.Action" ) );
192 		assertTrue( "Hello is AbstractAction", clazz.isA( "javax.swing.AbstractAction" ) );
193 		assertTrue( "Hello is TextAction", clazz.isA( "javax.swing.text.TextAction" ) );
194 	}
195 
196 	public void testDereferenceProperty() throws Exception
197 	{
198 		XClass clazz = _xJavaDoc.getXClass( "Hello" );
199 
200 		String tagValue = clazz.getDoc().getTag( "my:name" ).getValue();
201 		String attributeValue = clazz.getDoc().getTag( "my:version" ).getAttributeValue( "version" );
202 
203 		assertTrue( "Tag Value dereferencing Failed: " + tagValue, "this program is called xjavadoc guess why".equals( tagValue ) );
204 		assertTrue( "Tag Attribute Value dereferencing Failed: " + attributeValue, "xjavadoc version is 1.0".equals( attributeValue ) );
205 	}
206 
207 	public void testSupertags() throws Exception
208 	{
209 		XClass clazz = _xJavaDoc.getXClass( "Goodbye" );
210 
211 		assertEquals( "xjavadoc.SourceClass", clazz.getClass().getName() );
212 
213 		XMethod getNonsense = clazz.getMethod( "getNonsense()" );
214 		Collection tags = getNonsense.getDoc().getTags( true );
215 
216 		assertEquals( 3, tags.size() );
217 	}
218 
219 	public void testSupermethodsInSource() throws Exception
220 	{
221 		XClass clazz = _xJavaDoc.getXClass( "Goodbye" );
222 		XMethod whatever = clazz.getMethod( "whatever(java.lang.String[],int)", false );
223 
224 		assertEquals( null, whatever );
225 		whatever = clazz.getMethod( "whatever(java.lang.String[],int)", true );
226 		assertNotNull( whatever );
227 	}
228 
229 	public void testSupermethodsInBinary() throws Exception
230 	{
231 		// Turn on super methods
232 		System.setProperty( "xjavadoc.compiledmethods", "true" );
233 
234 		XClass clazz = _xJavaDoc.getXClass( "Goodbye" );
235 		XMethod getClass = clazz.getMethod( "getClass()", true );
236 
237 		System.setProperty( "xjavadoc.compiledmethods", "false" );
238 
239 		assertNotNull( getClass );
240 	}
241 
242 	public void testNumberOfMethodsInSource() throws Exception
243 	{
244 		XClass hello = _xJavaDoc.getXClass( "Hello" );
245 		XClass goodbye = _xJavaDoc.getXClass( "Goodbye" );
246 
247 		Collection helloMethods = hello.getMethods();
248 		Collection goodbyeMethods = goodbye.getMethods();
249 		Collection helloAndGoodbyeMethods = goodbye.getMethods( true );
250 
251 		assertEquals( 7, helloMethods.size() );
252 		assertEquals( 3, goodbyeMethods.size() );
253 		// we don't inherit the one private method, and one is overridden.
254 		assertEquals( 8, helloAndGoodbyeMethods.size() );
255 	}
256 
257 	public void testSupermethods2() throws Exception
258 	{
259 		XClass hello = _xJavaDoc.getXClass( "Hello" );
260 		XClass goodbye = _xJavaDoc.getXClass( "Goodbye" );
261 
262 		Collection methods = goodbye.getMethods( true );
263 		int helloCount = 0;
264 		int goodbyeCount = 0;
265 
266 		for( Iterator m = methods.iterator(); m.hasNext();  )
267 		{
268 			XMethod method = (XMethod) m.next();
269 
270 			if( method.getContainingClass() == hello )
271 			{
272 				helloCount++;
273 				if( method.getName().equals( "getNonsense" ) )
274 				{
275 					fail( "getNonsense is overridden in Goodbye. Shouldn't get it from Hello too." );
276 				}
277 			}
278 			else if( method.getContainingClass() == goodbye )
279 			{
280 				goodbyeCount++;
281 			}
282 			else
283 			{
284 				String message = "The method " + method.toString() + " was declared in the class " +
285 					method.getContainingClass().getName() + " " +
286 					"which is an instance of " + method.getContainingClass().getClass().getName() +
287 					"@" + method.getContainingClass().hashCode() + ". " +
288 					"The method should either come from Hello or Goodbye. " +
289 					"Hello : " + hello.getClass().getName() + "@" + hello.hashCode() + " " +
290 					"Goodbye : " + goodbye.getClass().getName() + "@" + goodbye.hashCode();
291 
292 				fail( message );
293 
294 			}
295 		}
296 		assertEquals( 3, goodbyeCount );
297 		// We inherit 6, but one is overridden, so that makes 5 from hello
298 		assertEquals( 5, helloCount );
299 	}
300 
301 	public void testAddCommentToUncommentedMethod() throws Exception
302 	{
303 		_xJavaDoc.setUseNodeParser( true );
304 
305 		XClass clazz = _xJavaDoc.updateMethodTag(
306 			"Hello",
307 			"noComment()",
308 			"here",
309 			"is",
310 			"a tag for ya",
311 			0 );
312 
313 		File testDir = new File( "target/saved/testAddCommentToUncommentedMethod" );
314 		String fileName = clazz.save( testDir );
315 	}
316 
317 	public void testBinaryClassHasNoMembersBecauseOfSpeedOptimisation() throws Exception
318 	{
319 		XClass collection = _xJavaDoc.getXClass( "java.util.Collection" );
320 
321 		assertEquals( 0, collection.getFields().size() );
322 		assertEquals( 0, collection.getConstructors().size() );
323 		assertEquals( 0, collection.getMethods().size() );
324 	}
325 
326 	public void testInnerInterface() throws Exception
327 	{
328 		XClass processor = _xJavaDoc.getXClass( "hanoi.Processor" );
329 		Iterator innerClasses = processor.getInnerClasses().iterator();
330 		XClass next = ( XClass ) innerClasses.next();
331 
332 		assertEquals( "hanoi.Processor.Next", next.getQualifiedName() );
333 		assertEquals( "hanoi.Processor$Next", next.getTransformedQualifiedName() );
334 		assertEquals( "Processor$Next", next.getTransformedName() );
335 		assertTrue( next.isA( "java.io.Serializable" ) );
336 
337 		XClass anonClassImplements = ( XClass ) innerClasses.next();
338 
339 		assertEquals( "java.lang.Object", anonClassImplements.getSuperclass().getQualifiedName() );
340 		assertEquals( "java.lang.Object", anonClassImplements.getSuperclass().getTransformedQualifiedName() );
341 		assertEquals( "Object", anonClassImplements.getSuperclass().getTransformedName() );
342 		assertTrue( anonClassImplements.isA( "hanoi.Processor.Next" ) );
343 
344 		XClass anonClassExtends = ( XClass ) innerClasses.next();
345 
346 		assertEquals( "java.lang.Exception", anonClassExtends.getSuperclass().getQualifiedName() );
347 		assertEquals( "java.lang.Exception", anonClassExtends.getSuperclass().getTransformedQualifiedName() );
348 		assertEquals( "Exception", anonClassExtends.getSuperclass().getTransformedName() );
349 		assertTrue( anonClassExtends.isA( "java.io.Serializable" ) );
350 	}
351 
352 	public void testNoNeedToImportInnerClass() throws Exception
353 	{
354 		XClass processor = _xJavaDoc.getXClass( "Goodbye" );
355 		XMethod gotThis = processor.getMethod( "gotThis()" );
356 		XClass processorNext = gotThis.getReturnType().getType();
357 
358 		assertEquals( "hanoi.Processor.Next", processorNext.getQualifiedName() );
359 		assertEquals( "hanoi.Processor$Next", processorNext.getTransformedQualifiedName() );
360 		assertEquals( "Processor$Next", processorNext.getTransformedName() );
361 	}
362 
363 	public void testPackageHasInnerClasses() throws Exception
364 	{
365 		XPackage pakkage = _xJavaDoc.getSourcePackage( "hanoi" );
366 
367 		assertNotNull( pakkage );
368 		assertEquals( 8, pakkage.getClasses().size() );
369 	}
370 
371 	public void testUnicode() throws Exception
372 	{
373         // Should be able to parse a unicode file
374         XClass unicode = _xJavaDoc.getXClass( "Unicode" );
375 	}
376 
377 	public void testOldFashioned() throws Exception
378 	{
379 		// We have to tell xjavadoc to get all source classes. otherwise it will think
380 		// OldFashioned doesn't exist and return an UnknownClass
381 		_xJavaDoc.getSourceClasses();
382 
383 		XClass oldFashioned = _xJavaDoc.getXClass( "OldFashioned" );
384 		XClass hello = _xJavaDoc.getXClass( "Hello" );
385 
386 		assertEquals( SourceClass.class, oldFashioned.getClass() );
387 		assertTrue( "OldFashioned isn't an inner class", !oldFashioned.isInner() );
388 
389 		assertEquals( hello.lastModified(), oldFashioned.lastModified() );
390 	}
391 
392 	public void testPropertyMethods1() throws Exception
393 	{
394 		XClass hello = _xJavaDoc.getXClass( "Hello" );
395 
396 		XMethod getNonsense = hello.getMethod( "getNonsense()" );
397 
398 		assertEquals( "nonsense", getNonsense.getPropertyName() );
399 		assertTrue( getNonsense.isPropertyAccessor() );
400 		assertTrue( !getNonsense.isPropertyMutator() );
401 
402 		XMethod setInner = hello.getMethod( "setInner(Hello.InnerClass)" );
403 
404 		assertEquals( "inner", setInner.getPropertyName() );
405 		assertTrue( !setInner.isPropertyAccessor() );
406 		assertTrue( setInner.isPropertyMutator() );
407 
408 		XMethod whatever = hello.getMethod( "whatever(java.lang.String[][],int)" );
409 
410 		assertNull( whatever.getPropertyName() );
411 		assertTrue( !whatever.isPropertyAccessor() );
412 		assertTrue( !whatever.isPropertyMutator() );
413 	}
414 
415 	public void testPropertyMethods2()
416 	{
417 		// Get the enclosing class first, just to resolve the rest.
418         XClass abAB = _xJavaDoc.getXClass( "ab.AB" );
419 		XClass abABC = _xJavaDoc.getXClass( "ab.AB.C" );
420 
421 		XMethod getFoo = abABC.getMethod( "getFoo()" );
422 
423 		assertTrue( getFoo.isPropertyAccessor() );
424 
425 		XMethod setFoo = abABC.getMethod( "setFoo(java.lang.String)" );
426 
427 		assertTrue( setFoo.isPropertyMutator() );
428 
429 		assertSame( getFoo, setFoo.getAccessor() );
430 		assertSame( setFoo, getFoo.getMutator() );
431 
432 		XMethod getBar = abABC.getMethod( "getBar()" );
433 
434 		assertTrue( getBar.isPropertyAccessor() );
435 
436 		XMethod setBar = abABC.getMethod( "setBar(int)" );
437 
438 		assertTrue( setBar.isPropertyMutator() );
439 
440 		assertNull( getBar.getMutator() );
441 		assertNull( setBar.getAccessor() );
442 
443 		XMethod isThisIsNotAnAccessor = abABC.getMethod( "isThisIsNotAnAccessor()" );
444 
445 		assertTrue( !isThisIsNotAnAccessor.isPropertyAccessor() );
446 
447 		XMethod setThisIsAMutator = abABC.getMethod( "setThisIsAMutator(boolean[])" );
448 
449 		assertTrue( setThisIsAMutator.isPropertyMutator() );
450 
451 	}
452 
453 	/***
454 	 * Test for bugfix for XJD-17
455 	 */
456 	public void testXJD17()
457 	{
458 		XClass abAB = _xJavaDoc.getXClass( "ab.AB" );
459 		XClass abB = _xJavaDoc.getXClass( "ab.B" );
460 
461 		assertEquals( xjavadoc.SourceClass.class, abAB.getClass() );
462 		assertEquals( xjavadoc.SourceClass.class, abB.getClass() );
463 		assertTrue( !abAB.isInterface() );
464 		assertTrue( abB.isInterface() );
465 		assertTrue( !abAB.isInner() );
466 		assertTrue( !abB.isInner() );
467 		assertTrue( !abAB.isAnonymous() );
468 		assertTrue( !abB.isAnonymous() );
469 		assertEquals( "ab", abAB.getContainingPackage().getName() );
470 		assertEquals( "ab", abB.getContainingPackage().getName() );
471 
472 		// Do some more funny far fetched checking
473 		XClass abABC = _xJavaDoc.getXClass( "ab.AB.C" );
474 		XClass abBD = _xJavaDoc.getXClass( "ab.B.D" );
475 
476 		assertEquals( xjavadoc.SourceClass.class, abABC.getClass() );
477 		assertEquals( xjavadoc.SourceClass.class, abBD.getClass() );
478 		assertTrue( abABC.isInterface() );
479 		assertTrue( !abBD.isInterface() );
480 		assertTrue( abABC.isInner() );
481 		assertTrue( abBD.isInner() );
482 		assertTrue( !abABC.isAnonymous() );
483 		assertTrue( !abBD.isAnonymous() );
484 		assertEquals( "ab", abABC.getContainingPackage().getName() );
485 		assertEquals( "ab", abBD.getContainingPackage().getName() );
486 	}
487 
488 }