1
2
3
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
95 Collection fields = clazz.getFields( true );
96
97
98 assertEquals( 3, fields.size() );
99
100 for( Iterator i = fields.iterator(); i.hasNext(); )
101 {
102 XField field = ( XField ) i.next();
103
104
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
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
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
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
374 XClass unicode = _xJavaDoc.getXClass( "Unicode" );
375 }
376
377 public void testOldFashioned() throws Exception
378 {
379
380
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
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
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 }