← Back to branch summary

~ubuntu-branches/ubuntu/karmic/qdox/karmic

« back to all changes in this revision

Viewing changes to src/test/com/thoughtworks/qdox/model/ModelBuilderTest.java

  • Committer: Bazaar Package Importer
  • Author(s): Arnaud Vandyck
  • Date: 2007-04-11 13:51:08 UTC
  • Revision ID: james.westby@ubuntu.com-20070411135108-uplum1t13cbjsriw
Tags: upstream-1.6.1
Import upstream version 1.6.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/test/com/thoughtworks/qdox/model/ModelBuilderTest.java
 
1
package com.thoughtworks.qdox.model;
 
2
 
 
3
import com.thoughtworks.qdox.parser.structs.ClassDef;
 
4
import com.thoughtworks.qdox.parser.structs.FieldDef;
 
5
import com.thoughtworks.qdox.parser.structs.MethodDef;
 
6
import com.thoughtworks.qdox.parser.structs.TagDef;
 
7
import java.util.Arrays;
 
8
import junit.framework.TestCase;
 
9
 
 
10
public class ModelBuilderTest extends TestCase {
 
11
 
 
12
    private ModelBuilder builder;
 
13
 
 
14
    public ModelBuilderTest(String s) {
 
15
        super(s);
 
16
    }
 
17
 
 
18
    protected void setUp() throws Exception {
 
19
        super.setUp();
 
20
        builder = new ModelBuilder();
 
21
    }
 
22
 
 
23
    public void testNumberOfClassesGrows() throws Exception {
 
24
        assertEquals(0, builder.getSource().getClasses().length);
 
25
        builder.beginClass(new ClassDef());
 
26
        builder.endClass();
 
27
        assertEquals(1, builder.getSource().getClasses().length);
 
28
        builder.beginClass(new ClassDef());
 
29
        builder.endClass();
 
30
        assertEquals(2, builder.getSource().getClasses().length);
 
31
    }
 
32
 
 
33
    public void testSimpleClass() throws Exception {
 
34
        ClassDef cls = new ClassDef();
 
35
        cls.name = "Thingy";
 
36
        builder.beginClass(cls);
 
37
        builder.endClass();
 
38
 
 
39
        ClassDef cls2 = new ClassDef();
 
40
        cls2.name = "ThingyThing";
 
41
        builder.beginClass(cls2);
 
42
        builder.endClass();
 
43
 
 
44
        JavaSource source = builder.getSource();
 
45
 
 
46
        assertEquals("Thingy", source.getClasses()[0].getName());
 
47
        assertEquals("ThingyThing", source.getClasses()[1].getName());
 
48
        assertEquals(source, source.getClasses()[0].getParentSource());
 
49
    }
 
50
 
 
51
    public void testInterface() throws Exception {
 
52
        ClassDef cls = new ClassDef();
 
53
        builder.beginClass(cls);
 
54
        builder.endClass();
 
55
 
 
56
        ClassDef cls2 = new ClassDef();
 
57
        cls2.type = ClassDef.INTERFACE;
 
58
        builder.beginClass(cls2);
 
59
        builder.endClass();
 
60
 
 
61
        JavaSource source = builder.getSource();
 
62
 
 
63
        assertEquals(false, source.getClasses()[0].isInterface());
 
64
        assertEquals(true, source.getClasses()[1].isInterface());
 
65
    }
 
66
 
 
67
    public void testEnum() throws Exception {
 
68
        ClassDef cls = new ClassDef();
 
69
        builder.beginClass(cls);
 
70
        builder.endClass();
 
71
 
 
72
        ClassDef cls2 = new ClassDef();
 
73
        cls2.type = ClassDef.ENUM;
 
74
        builder.beginClass(cls2);
 
75
        builder.endClass();
 
76
 
 
77
        JavaSource source = builder.getSource();
 
78
 
 
79
        assertEquals(false, source.getClasses()[0].isEnum());
 
80
        assertEquals(true, source.getClasses()[1].isEnum());
 
81
    }
 
82
 
 
83
    public void testAnnotationType() throws Exception {
 
84
        ClassDef cls = new ClassDef();
 
85
        cls.type = ClassDef.ANNOTATION_TYPE;
 
86
        builder.beginClass(cls);
 
87
        builder.endClass();
 
88
 
 
89
        JavaSource source = builder.getSource();
 
90
        
 
91
        assertEquals(0, source.getClasses().length);
 
92
    }
 
93
 
 
94
    public void testClassExtends() throws Exception {
 
95
        ClassDef cls = new ClassDef();
 
96
        builder.beginClass(cls);
 
97
        builder.endClass();
 
98
 
 
99
        ClassDef cls2 = new ClassDef();
 
100
        cls2.extendz.add("Another");
 
101
        builder.beginClass(cls2);
 
102
        builder.endClass();
 
103
        builder.addImport("com.thoughtworks.*");
 
104
 
 
105
        JavaSource source = builder.getSource();
 
106
 
 
107
        assertEquals("java.lang.Object", source.getClasses()[0].getSuperClass().getValue());
 
108
        assertEquals("Another", source.getClasses()[1].getSuperClass().getValue());
 
109
 
 
110
        assertEquals(0, source.getClasses()[0].getImplements().length);
 
111
        assertEquals(0, source.getClasses()[1].getImplements().length);
 
112
 
 
113
        //Add another class and see if Another gets resolved
 
114
        builder.addPackage("com.thoughtworks");
 
115
        ClassDef anotherCls = new ClassDef();
 
116
        anotherCls.name = "Another";
 
117
        builder.beginClass(anotherCls);
 
118
        builder.endClass();
 
119
 
 
120
        assertEquals("com.thoughtworks.Another", source.getClasses()[1].getSuperClass().getValue());
 
121
    }
 
122
 
 
123
    public void testInterfaceExtends() throws Exception {
 
124
        ClassDef cls = new ClassDef();
 
125
        cls.type = ClassDef.INTERFACE;
 
126
        builder.beginClass(cls);
 
127
        builder.endClass();
 
128
 
 
129
        ClassDef cls2 = new ClassDef();
 
130
        cls2.type = ClassDef.INTERFACE;
 
131
        cls2.extendz.add("Another");
 
132
        builder.beginClass(cls2);
 
133
        builder.endClass();
 
134
 
 
135
        JavaSource source = builder.getSource();
 
136
 
 
137
        assertEquals(0, source.getClasses()[0].getImplements().length);
 
138
        assertEquals(1, source.getClasses()[1].getImplements().length);
 
139
        assertEquals("Another", source.getClasses()[1].getImplements()[0].getValue());
 
140
 
 
141
        assertNull(source.getClasses()[0].getSuperClass());
 
142
        assertNull(source.getClasses()[1].getSuperClass());
 
143
    }
 
144
 
 
145
    public void testInterfaceExtendsMultiple() throws Exception {
 
146
        ClassDef cls = new ClassDef();
 
147
        cls.type = ClassDef.INTERFACE;
 
148
        cls.extendz.add("Another");
 
149
        cls.extendz.add("java.io.Serializable");
 
150
        cls.extendz.add("BottleOpener");
 
151
        builder.beginClass(cls);
 
152
        builder.endClass();
 
153
 
 
154
        JavaSource source = builder.getSource();
 
155
 
 
156
        // sorted
 
157
        Arrays.sort(source.getClasses()[0].getImplements());
 
158
        assertEquals(3, source.getClasses()[0].getImplements().length);
 
159
        assertEquals("Another", source.getClasses()[0].getImplements()[0].getValue());
 
160
        assertEquals("BottleOpener", source.getClasses()[0].getImplements()[1].getValue());
 
161
        assertEquals("java.io.Serializable", source.getClasses()[0].getImplements()[2].getValue());
 
162
 
 
163
        assertNull(source.getClasses()[0].getSuperClass());
 
164
    }
 
165
 
 
166
    public void testClassImplements() throws Exception {
 
167
        ClassDef cls = new ClassDef();
 
168
        builder.beginClass(cls);
 
169
        builder.endClass();
 
170
 
 
171
        ClassDef cls2 = new ClassDef();
 
172
        cls2.implementz.add("SomeInterface");
 
173
        builder.beginClass(cls2);
 
174
        builder.endClass();
 
175
 
 
176
        JavaSource source = builder.getSource();
 
177
 
 
178
        assertEquals(0, source.getClasses()[0].getImplements().length);
 
179
        assertEquals(1, source.getClasses()[1].getImplements().length);
 
180
 
 
181
        assertEquals("SomeInterface", source.getClasses()[1].getImplements()[0].getValue());
 
182
 
 
183
        assertEquals("java.lang.Object", source.getClasses()[0].getSuperClass().getValue());
 
184
        assertEquals("java.lang.Object", source.getClasses()[1].getSuperClass().getValue());
 
185
    }
 
186
 
 
187
    public void testClassImplementsMultiple() throws Exception {
 
188
        ClassDef cls = new ClassDef();
 
189
        cls.implementz.add("SomeInterface");
 
190
        cls.implementz.add("XX");
 
191
        builder.beginClass(cls);
 
192
        builder.endClass();
 
193
 
 
194
        JavaSource source = builder.getSource();
 
195
 
 
196
        assertEquals(2, source.getClasses()[0].getImplements().length);
 
197
 
 
198
        Arrays.sort(source.getClasses()[0].getImplements());
 
199
        assertEquals("SomeInterface", source.getClasses()[0].getImplements()[0].getValue());
 
200
        assertEquals("XX", source.getClasses()[0].getImplements()[1].getValue());
 
201
    }
 
202
 
 
203
    public void testClassExtendsAndImplements() throws Exception {
 
204
        ClassDef cls = new ClassDef();
 
205
        cls.extendz.add("SubClass");
 
206
        cls.implementz.add("SomeInterface");
 
207
        cls.implementz.add("XX");
 
208
        builder.beginClass(cls);
 
209
        builder.endClass();
 
210
 
 
211
        JavaSource source = builder.getSource();
 
212
 
 
213
        assertEquals(2, source.getClasses()[0].getImplements().length);
 
214
 
 
215
        Arrays.sort(source.getClasses()[0].getImplements());
 
216
        assertEquals("SomeInterface", source.getClasses()[0].getImplements()[0].getValue());
 
217
        assertEquals("XX", source.getClasses()[0].getImplements()[1].getValue());
 
218
 
 
219
        assertEquals("SubClass", source.getClasses()[0].getSuperClass().getValue());
 
220
    }
 
221
 
 
222
    public void testClassModifiers() throws Exception {
 
223
        builder.beginClass(new ClassDef());
 
224
        builder.endClass();
 
225
 
 
226
        ClassDef cls2 = new ClassDef();
 
227
        cls2.modifiers.add("public");
 
228
        cls2.modifiers.add("final");
 
229
        builder.beginClass(cls2);
 
230
        builder.endClass();
 
231
 
 
232
        JavaSource source = builder.getSource();
 
233
 
 
234
        assertEquals(0, source.getClasses()[0].getModifiers().length);
 
235
        assertEquals(2, source.getClasses()[1].getModifiers().length);
 
236
 
 
237
        // sorted
 
238
        String[] modifiers = source.getClasses()[1].getModifiers();
 
239
        Arrays.sort(modifiers);
 
240
        assertEquals("final", modifiers[0]);
 
241
        assertEquals("public", modifiers[1]);
 
242
    }
 
243
 
 
244
    public void testAddMethodsToCorrectClass() throws Exception {
 
245
        builder.beginClass(new ClassDef());
 
246
        builder.addMethod(new MethodDef());
 
247
        builder.endClass();
 
248
 
 
249
        builder.beginClass(new ClassDef());
 
250
        builder.addMethod(new MethodDef());
 
251
        builder.addMethod(new MethodDef());
 
252
        builder.addMethod(new MethodDef());
 
253
        builder.endClass();
 
254
 
 
255
        builder.beginClass(new ClassDef());
 
256
        builder.addMethod(new MethodDef());
 
257
        builder.addMethod(new MethodDef());
 
258
        builder.endClass();
 
259
 
 
260
        JavaSource source = builder.getSource();
 
261
        assertEquals(1, source.getClasses()[0].getMethods().length);
 
262
        assertEquals(3, source.getClasses()[1].getMethods().length);
 
263
        assertEquals(2, source.getClasses()[2].getMethods().length);
 
264
    }
 
265
 
 
266
    public void testInnerClass() throws Exception {
 
267
        builder.addPackage("xyz");
 
268
 
 
269
        ClassDef outerDef = new ClassDef();
 
270
        outerDef.name = "Outer";
 
271
        builder.beginClass(outerDef);
 
272
 
 
273
        ClassDef innerDef = new ClassDef();
 
274
        innerDef.name = "Inner";
 
275
        builder.beginClass(innerDef);
 
276
 
 
277
        MethodDef fooDef = new MethodDef();
 
278
        fooDef.name = "foo";
 
279
        builder.addMethod(fooDef);
 
280
        builder.endClass();
 
281
 
 
282
        MethodDef barDef = new MethodDef();
 
283
        barDef.name = "bar";
 
284
        builder.addMethod(barDef);
 
285
        builder.endClass();
 
286
 
 
287
        JavaSource source = builder.getSource();
 
288
        assertEquals(1, source.getClasses().length);
 
289
        JavaClass outerClass = source.getClasses()[0];
 
290
        assertEquals("xyz.Outer", outerClass.getFullyQualifiedName());
 
291
        assertEquals(1, outerClass.getMethods().length);
 
292
        assertEquals("bar", outerClass.getMethods()[0].getName());
 
293
        assertEquals(1, outerClass.getNestedClasses().length);
 
294
        JavaClass innerClass = outerClass.getNestedClasses()[0];
 
295
        assertEquals("xyz.Outer$Inner", innerClass.getFullyQualifiedName());
 
296
        assertEquals(1, innerClass.getMethods().length);
 
297
        assertEquals("foo", innerClass.getMethods()[0].getName());
 
298
    }
 
299
 
 
300
    public void testSimpleMethod() throws Exception {
 
301
        builder.beginClass(new ClassDef());
 
302
        MethodDef mth = new MethodDef();
 
303
        mth.name = "doSomething";
 
304
        mth.returns = "void";
 
305
        builder.addMethod(mth);
 
306
        builder.endClass();
 
307
 
 
308
        JavaSource source = builder.getSource();
 
309
        JavaMethod doSomething = source.getClasses()[0].getMethods()[0];
 
310
        assertEquals("doSomething", doSomething.getName());
 
311
        assertEquals("void", doSomething.getReturns().getValue());
 
312
        JavaSource parentSource = doSomething.getReturns().getJavaClassParent().getParentSource();
 
313
        assertSame(source, parentSource);
 
314
        assertEquals(0, doSomething.getModifiers().length);
 
315
        assertEquals(0, doSomething.getParameters().length);
 
316
        assertEquals(0, doSomething.getExceptions().length);
 
317
    }
 
318
 
 
319
    public void testMethodNoArray() throws Exception {
 
320
        builder.beginClass(new ClassDef());
 
321
        MethodDef mth = new MethodDef();
 
322
        mth.name = "doSomething";
 
323
        mth.returns = "void";
 
324
        mth.dimensions = 0;
 
325
        builder.addMethod(mth);
 
326
        builder.endClass();
 
327
 
 
328
        JavaSource source = builder.getSource();
 
329
        JavaMethod result = source.getClasses()[0].getMethods()[0];
 
330
        assertEquals(0, result.getReturns().getDimensions());
 
331
    }
 
332
 
 
333
    public void testMethod1dArray() throws Exception {
 
334
        builder.beginClass(new ClassDef());
 
335
        MethodDef mth = new MethodDef();
 
336
        mth.name = "doSomething";
 
337
        mth.returns = "void";
 
338
        mth.dimensions = 1;
 
339
        builder.addMethod(mth);
 
340
        builder.endClass();
 
341
 
 
342
        JavaSource source = builder.getSource();
 
343
        JavaMethod result = source.getClasses()[0].getMethods()[0];
 
344
        assertEquals(1, result.getReturns().getDimensions());
 
345
    }
 
346
 
 
347
    public void testMethod2dArray() throws Exception {
 
348
        builder.beginClass(new ClassDef());
 
349
        MethodDef mth = new MethodDef();
 
350
        mth.name = "doSomething";
 
351
        mth.returns = "void";
 
352
        mth.dimensions = 2;
 
353
        builder.addMethod(mth);
 
354
        builder.endClass();
 
355
 
 
356
        JavaSource source = builder.getSource();
 
357
        JavaMethod result = source.getClasses()[0].getMethods()[0];
 
358
        assertEquals(2, result.getReturns().getDimensions());
 
359
    }
 
360
 
 
361
    public void testMethodParameters() throws Exception {
 
362
        builder.beginClass(new ClassDef());
 
363
        MethodDef mth = new MethodDef();
 
364
 
 
365
        FieldDef f1 = new FieldDef();
 
366
        f1.name = "count";
 
367
        f1.type = "int";
 
368
        f1.modifiers.add("final");
 
369
        mth.params.add(f1);
 
370
 
 
371
        FieldDef f2 = new FieldDef();
 
372
        f2.name = "name";
 
373
        f2.type = "String";
 
374
        mth.params.add(f2);
 
375
 
 
376
        builder.addMethod(mth);
 
377
        builder.endClass();
 
378
 
 
379
        JavaSource source = builder.getSource();
 
380
        JavaMethod result = source.getClasses()[0].getMethods()[0];
 
381
        assertEquals(2, result.getParameters().length);
 
382
        assertEquals("count", result.getParameters()[0].getName());
 
383
        assertEquals("int", result.getParameters()[0].getType().getValue());
 
384
        assertEquals("name", result.getParameters()[1].getName());
 
385
        assertEquals("String", result.getParameters()[1].getType().getValue());
 
386
    }
 
387
 
 
388
    public void testMethodParametersWithArrays() throws Exception {
 
389
        builder.beginClass(new ClassDef());
 
390
        MethodDef mth = new MethodDef();
 
391
 
 
392
        FieldDef f1 = new FieldDef();
 
393
        f1.name = "count";
 
394
        f1.type = "int";
 
395
        f1.modifiers.add("final");
 
396
        f1.dimensions = 1;
 
397
        mth.params.add(f1);
 
398
 
 
399
        FieldDef f2 = new FieldDef();
 
400
        f2.name = "name";
 
401
        f2.type = "String";
 
402
        f2.dimensions = 2;
 
403
        mth.params.add(f2);
 
404
 
 
405
        builder.addMethod(mth);
 
406
        builder.endClass();
 
407
 
 
408
        JavaSource source = builder.getSource();
 
409
        JavaMethod result = source.getClasses()[0].getMethods()[0];
 
410
        assertEquals(1, result.getParameters()[0].getType().getDimensions());
 
411
        assertEquals(2, result.getParameters()[1].getType().getDimensions());
 
412
    }
 
413
 
 
414
    public void testMethodExceptions() throws Exception {
 
415
        builder.beginClass(new ClassDef());
 
416
        MethodDef mth = new MethodDef();
 
417
 
 
418
        mth.exceptions.add("RuntimeException");
 
419
        mth.exceptions.add("java.io.IOException");
 
420
 
 
421
        builder.addMethod(mth);
 
422
        builder.endClass();
 
423
 
 
424
        JavaSource source = builder.getSource();
 
425
        JavaMethod result = source.getClasses()[0].getMethods()[0];
 
426
        assertEquals(2, result.getExceptions().length);
 
427
        // sorted
 
428
        Arrays.sort(result.getExceptions());
 
429
        assertEquals("RuntimeException", result.getExceptions()[0].getValue());
 
430
        assertEquals("java.io.IOException", result.getExceptions()[1].getValue());
 
431
    }
 
432
 
 
433
    public void testMethodModifiers() throws Exception {
 
434
        builder.beginClass(new ClassDef());
 
435
        MethodDef mth = new MethodDef();
 
436
 
 
437
        mth.modifiers.add("public");
 
438
        mth.modifiers.add("final");
 
439
        mth.modifiers.add("synchronized");
 
440
 
 
441
        builder.addMethod(mth);
 
442
        builder.endClass();
 
443
 
 
444
        JavaSource source = builder.getSource();
 
445
        JavaMethod result = source.getClasses()[0].getMethods()[0];
 
446
        assertEquals(3, result.getModifiers().length);
 
447
        // sorted
 
448
        String[] modifiers = result.getModifiers();
 
449
        Arrays.sort(modifiers);
 
450
        assertEquals("final", modifiers[0]);
 
451
        assertEquals("public", modifiers[1]);
 
452
        assertEquals("synchronized", modifiers[2]);
 
453
    }
 
454
 
 
455
    public void testSimpleField() throws Exception {
 
456
        builder.beginClass(new ClassDef());
 
457
 
 
458
        FieldDef fld = new FieldDef();
 
459
        fld.name = "count";
 
460
        fld.type = "int";
 
461
        builder.addField(fld);
 
462
        builder.endClass();
 
463
 
 
464
        JavaSource source = builder.getSource();
 
465
 
 
466
        JavaField result = source.getClasses()[0].getFields()[0];
 
467
        assertNotNull(result);
 
468
        assertEquals("count", result.getName());
 
469
        assertEquals("int", result.getType().getValue());
 
470
 
 
471
    }
 
472
 
 
473
    public void testFieldWithModifiers() throws Exception {
 
474
        builder.beginClass(new ClassDef());
 
475
 
 
476
        FieldDef fld = new FieldDef();
 
477
        fld.modifiers.add("blah");
 
478
        fld.modifiers.add("blah2");
 
479
        builder.addField(fld);
 
480
        builder.endClass();
 
481
 
 
482
        JavaSource source = builder.getSource();
 
483
 
 
484
        JavaField result = source.getClasses()[0].getFields()[0];
 
485
        assertNotNull(result);
 
486
        assertNotNull(result.getModifiers());
 
487
        Arrays.sort(result.getModifiers());
 
488
        assertEquals("blah2", result.getModifiers()[0]);
 
489
        assertEquals("blah", result.getModifiers()[1]);
 
490
    }
 
491
 
 
492
    public void testFieldNoArray() throws Exception {
 
493
        builder.beginClass(new ClassDef());
 
494
 
 
495
        FieldDef fld = new FieldDef();
 
496
        fld.name = "count";
 
497
        fld.type = "int";
 
498
        fld.dimensions = 0;
 
499
        builder.addField(fld);
 
500
        builder.endClass();
 
501
 
 
502
        JavaSource source = builder.getSource();
 
503
 
 
504
        JavaField result = source.getClasses()[0].getFields()[0];
 
505
        assertEquals(0, result.getType().getDimensions());
 
506
 
 
507
    }
 
508
 
 
509
    public void testField1dArray() throws Exception {
 
510
        builder.beginClass(new ClassDef());
 
511
 
 
512
        FieldDef fld = new FieldDef();
 
513
        fld.name = "count";
 
514
        fld.type = "int";
 
515
        fld.dimensions = 1;
 
516
        builder.addField(fld);
 
517
        builder.endClass();
 
518
 
 
519
        JavaSource source = builder.getSource();
 
520
 
 
521
        JavaField result = source.getClasses()[0].getFields()[0];
 
522
        assertEquals(1, result.getType().getDimensions());
 
523
 
 
524
    }
 
525
 
 
526
    public void testField2dArray() throws Exception {
 
527
        builder.beginClass(new ClassDef());
 
528
 
 
529
        FieldDef fld = new FieldDef();
 
530
        fld.name = "count";
 
531
        fld.type = "int";
 
532
        fld.dimensions = 2;
 
533
        builder.addField(fld);
 
534
        builder.endClass();
 
535
 
 
536
        JavaSource source = builder.getSource();
 
537
 
 
538
        JavaField result = source.getClasses()[0].getFields()[0];
 
539
        assertEquals(2, result.getType().getDimensions());
 
540
    }
 
541
 
 
542
    public void testSimpleConstructor() throws Exception {
 
543
        builder.beginClass(new ClassDef());
 
544
 
 
545
        MethodDef mth = new MethodDef();
 
546
        mth.name = "MyClass";
 
547
        mth.constructor = true;
 
548
        builder.addMethod(mth);
 
549
 
 
550
        MethodDef mth2 = new MethodDef();
 
551
        mth2.name = "method";
 
552
        mth2.returns = "void";
 
553
        builder.addMethod(mth2);
 
554
        builder.endClass();
 
555
 
 
556
        JavaSource source = builder.getSource();
 
557
 
 
558
        JavaMethod result1 = source.getClasses()[0].getMethods()[0];
 
559
        JavaMethod result2 = source.getClasses()[0].getMethods()[1];
 
560
 
 
561
        assertTrue(result1.isConstructor());
 
562
        assertNull(result1.getReturns());
 
563
        assertTrue(!result2.isConstructor());
 
564
        assertNotNull(result2.getReturns());
 
565
    }
 
566
 
 
567
    public void testJavaDocOnClass() throws Exception {
 
568
        builder.addJavaDoc("Hello");
 
569
        builder.beginClass(new ClassDef());
 
570
        builder.endClass();
 
571
 
 
572
        JavaSource source = builder.getSource();
 
573
        assertEquals("Hello", source.getClasses()[0].getComment());
 
574
    }
 
575
 
 
576
    public void testJavaDocSpiradiclyOnManyClasses() throws Exception {
 
577
 
 
578
        builder.addJavaDoc("Hello");
 
579
        builder.beginClass(new ClassDef());
 
580
        builder.endClass();
 
581
 
 
582
        builder.beginClass(new ClassDef());
 
583
        builder.endClass();
 
584
 
 
585
        builder.addJavaDoc("World");
 
586
        builder.beginClass(new ClassDef());
 
587
        builder.endClass();
 
588
 
 
589
        JavaSource source = builder.getSource();
 
590
 
 
591
        assertEquals("Hello", source.getClasses()[0].getComment());
 
592
        assertNull(source.getClasses()[1].getComment());
 
593
        assertEquals("World", source.getClasses()[2].getComment());
 
594
    }
 
595
 
 
596
    public void testJavaDocOnMethod() throws Exception {
 
597
        builder.beginClass(new ClassDef());
 
598
 
 
599
        builder.addJavaDoc("Hello");
 
600
        builder.addMethod(new MethodDef());
 
601
        builder.endClass();
 
602
 
 
603
        JavaSource source = builder.getSource();
 
604
 
 
605
        assertNull(source.getClasses()[0].getComment());
 
606
        assertEquals("Hello", source.getClasses()[0].getMethods()[0].getComment());
 
607
    }
 
608
 
 
609
    public void testJavaDocOnField() throws Exception {
 
610
        builder.beginClass(new ClassDef());
 
611
 
 
612
        builder.addJavaDoc("Hello");
 
613
        builder.addField(new FieldDef());
 
614
        builder.endClass();
 
615
 
 
616
        JavaSource source = builder.getSource();
 
617
 
 
618
        assertNull(source.getClasses()[0].getComment());
 
619
        assertEquals("Hello", source.getClasses()[0].getFields()[0].getComment());
 
620
    }
 
621
 
 
622
    public void testJavaDocOnMethodsAndFields() throws Exception {
 
623
        builder.addJavaDoc("Thing");
 
624
        builder.beginClass(new ClassDef());
 
625
 
 
626
        builder.addField(new FieldDef());// f0
 
627
 
 
628
        builder.addJavaDoc("Hello");
 
629
        builder.addMethod(new MethodDef());//m0
 
630
 
 
631
        builder.addJavaDoc("Hello field");
 
632
        builder.addField(new FieldDef());//f1
 
633
 
 
634
        builder.addMethod(new MethodDef());//m1
 
635
 
 
636
        builder.addJavaDoc("World");
 
637
        builder.addMethod(new MethodDef());//m2
 
638
 
 
639
        builder.endClass();
 
640
 
 
641
        JavaSource source = builder.getSource();
 
642
 
 
643
        assertEquals("Thing", source.getClasses()[0].getComment());
 
644
        assertNull(source.getClasses()[0].getFields()[0].getComment());
 
645
        assertEquals("Hello field", source.getClasses()[0].getFields()[1].getComment());
 
646
        assertEquals("Hello", source.getClasses()[0].getMethods()[0].getComment());
 
647
        assertNull(source.getClasses()[0].getMethods()[1].getComment());
 
648
        assertEquals("World", source.getClasses()[0].getMethods()[2].getComment());
 
649
    }
 
650
 
 
651
    public void testDocletTag() throws Exception {
 
652
        builder.addJavaDoc("Hello");
 
653
        builder.addJavaDocTag(new TagDef("cheese", "is good"));
 
654
        builder.beginClass(new ClassDef());
 
655
 
 
656
        builder.endClass();
 
657
 
 
658
        JavaSource source = builder.getSource();
 
659
 
 
660
        assertEquals("Hello", source.getClasses()[0].getComment());
 
661
        assertEquals(1, source.getClasses()[0].getTags().length);
 
662
        assertEquals("cheese", source.getClasses()[0].getTags()[0].getName());
 
663
        assertEquals("is good", source.getClasses()[0].getTags()[0].getValue());
 
664
    }
 
665
 
 
666
    public void testDocletTagWithNoComment() throws Exception {
 
667
        builder.addJavaDoc(""); // parser will always call this method to signify start of javadoc
 
668
        builder.addJavaDocTag(new TagDef("cheese", "is good"));
 
669
        builder.beginClass(new ClassDef());
 
670
 
 
671
        builder.endClass();
 
672
 
 
673
        JavaSource source = builder.getSource();
 
674
 
 
675
        assertEquals("", source.getClasses()[0].getComment());
 
676
        assertEquals(1, source.getClasses()[0].getTags().length);
 
677
        assertEquals("cheese", source.getClasses()[0].getTags()[0].getName());
 
678
        assertEquals("is good", source.getClasses()[0].getTags()[0].getValue());
 
679
    }
 
680
 
 
681
    public void testMultipleDocletTags() throws Exception {
 
682
        builder.addJavaDoc("Hello");
 
683
        builder.addJavaDocTag(new TagDef("cheese", "is good"));
 
684
        builder.addJavaDocTag(new TagDef("food", "is great"));
 
685
        builder.addJavaDocTag(new TagDef("chairs", "are boring"));
 
686
        builder.beginClass(new ClassDef());
 
687
 
 
688
        builder.endClass();
 
689
 
 
690
        JavaSource source = builder.getSource();
 
691
 
 
692
        assertEquals("Hello", source.getClasses()[0].getComment());
 
693
        assertEquals(3, source.getClasses()[0].getTags().length);
 
694
        assertEquals("cheese", source.getClasses()[0].getTags()[0].getName());
 
695
        assertEquals("is good", source.getClasses()[0].getTags()[0].getValue());
 
696
        assertEquals("food", source.getClasses()[0].getTags()[1].getName());
 
697
        assertEquals("is great", source.getClasses()[0].getTags()[1].getValue());
 
698
        assertEquals("chairs", source.getClasses()[0].getTags()[2].getName());
 
699
        assertEquals("are boring", source.getClasses()[0].getTags()[2].getValue());
 
700
    }
 
701
 
 
702
    public void testDocletTagsOnMethodsAndFields() throws Exception {
 
703
        builder.addJavaDoc("");
 
704
        builder.addJavaDocTag(new TagDef("cheese", "is good"));
 
705
        builder.beginClass(new ClassDef());
 
706
 
 
707
        builder.addJavaDoc("");
 
708
        builder.addJavaDocTag(new TagDef("food", "is great"));
 
709
        builder.addMethod(new MethodDef());
 
710
 
 
711
        builder.addJavaDoc("");
 
712
        builder.addJavaDocTag(new TagDef("chairs", "are boring"));
 
713
        builder.addField(new FieldDef());
 
714
        builder.endClass();
 
715
 
 
716
        JavaSource source = builder.getSource();
 
717
 
 
718
        assertEquals("cheese", source.getClasses()[0].getTags()[0].getName());
 
719
        assertEquals("is good", source.getClasses()[0].getTags()[0].getValue());
 
720
        assertEquals("food", source.getClasses()[0].getMethods()[0].getTags()[0].getName());
 
721
        assertEquals("is great", source.getClasses()[0].getMethods()[0].getTags()[0].getValue());
 
722
        assertEquals("chairs", source.getClasses()[0].getFields()[0].getTags()[0].getName());
 
723
        assertEquals("are boring", source.getClasses()[0].getFields()[0].getTags()[0].getValue());
 
724
    }
 
725
 
 
726
    public void testRetrieveJavaSource() throws Exception {
 
727
        builder.beginClass(new ClassDef());
 
728
        builder.endClass();
 
729
 
 
730
        JavaSource source = builder.getSource();
 
731
        assertNotNull(source);
 
732
    }
 
733
 
 
734
    public void testJavaSourceClassCount() throws Exception {
 
735
        builder.beginClass(new ClassDef());
 
736
        builder.endClass();
 
737
        builder.beginClass(new ClassDef());
 
738
        builder.endClass();
 
739
        builder.beginClass(new ClassDef());
 
740
        builder.endClass();
 
741
        JavaSource result = builder.getSource();
 
742
        assertEquals(3, result.getClasses().length);
 
743
    }
 
744
 
 
745
    public void testJavaSourceNoPackage() throws Exception {
 
746
        JavaSource result = builder.getSource();
 
747
        assertNull(result.getPackage());
 
748
    }
 
749
 
 
750
    public void testJavaSourceWithPackage() throws Exception {
 
751
        builder.addPackage("com.blah.thing");
 
752
        JavaSource result = builder.getSource();
 
753
        assertEquals("com.blah.thing", result.getPackage());
 
754
    }
 
755
 
 
756
    public void testJavaSourceNoImports() throws Exception {
 
757
        JavaSource result = builder.getSource();
 
758
        assertEquals(0, result.getImports().length);
 
759
    }
 
760
 
 
761
    public void testJavaSourceOneImport() throws Exception {
 
762
        builder.addImport("com.blah.Thing");
 
763
        JavaSource result = builder.getSource();
 
764
        assertEquals(1, result.getImports().length);
 
765
        assertEquals("com.blah.Thing", result.getImports()[0]);
 
766
    }
 
767
 
 
768
    public void testJavaSourceMultipleImports() throws Exception {
 
769
        builder.addImport("com.blah.Thing");
 
770
        builder.addImport("java.util.List");
 
771
        builder.addImport("org.apache.*");
 
772
        JavaSource result = builder.getSource();
 
773
        assertEquals(3, result.getImports().length);
 
774
        assertEquals("com.blah.Thing", result.getImports()[0]);
 
775
        assertEquals("java.util.List", result.getImports()[1]);
 
776
        assertEquals("org.apache.*", result.getImports()[2]);
 
777
    }
 
778
 
 
779
    public void testModelHashCodes() {
 
780
 
 
781
        ClassDef classDef = new ClassDef();
 
782
        classDef.name = "hello";
 
783
        assertTrue(classDef.hashCode() > 0);
 
784
 
 
785
        MethodDef methodDef = new MethodDef();
 
786
        methodDef.name = "hello";
 
787
        assertTrue(methodDef.hashCode() > 0);
 
788
 
 
789
        FieldDef fieldDef = new FieldDef();
 
790
        fieldDef.name = "hello";
 
791
        assertTrue(fieldDef.hashCode() > 0);
 
792
 
 
793
        JavaParameter javaParameter = new JavaParameter(new Type("q"), "w");
 
794
        assertTrue(javaParameter.hashCode() > 0);
 
795
 
 
796
    }
 
797
 
 
798
 
 
799
    public void testType() {
 
800
 
 
801
        Type type1 = new Type("fred", 1);
 
802
        Type type2 = new Type("fred", 1);
 
803
        Type type3 = new Type("wilma", 2);
 
804
        assertTrue(type1.compareTo(type2) == 0);
 
805
        assertFalse(type1.compareTo(type3) == 0);
 
806
        assertTrue(type1.compareTo("barney") == 0);
 
807
    }
 
808
 
 
809
 
 
810
}