View Javadoc
1   package fileWriter;
2   
3   import java.io.IOException;
4   import java.util.Vector;
5   
6   import org.junit.BeforeClass;
7   import org.junit.Ignore;
8   import org.junit.Test;
9   
10  import common.CommonTest;
11  
12  import de.fhdw.wtf.file.FileUtils;
13  import de.fhdw.wtf.generator.java.generatorModel.GenAnyType;
14  import de.fhdw.wtf.generator.java.generatorModel.GenAttributeModifier;
15  import de.fhdw.wtf.generator.java.generatorModel.GenClassClass;
16  import de.fhdw.wtf.generator.java.generatorModel.GenClassModifier;
17  import de.fhdw.wtf.generator.java.generatorModel.GenComment;
18  import de.fhdw.wtf.generator.java.generatorModel.GenException;
19  import de.fhdw.wtf.generator.java.generatorModel.GenFullParsedOperationState;
20  import de.fhdw.wtf.generator.java.generatorModel.GenIntegerType;
21  import de.fhdw.wtf.generator.java.generatorModel.GenInterfaceClass;
22  import de.fhdw.wtf.generator.java.generatorModel.GenJavaAttribute;
23  import de.fhdw.wtf.generator.java.generatorModel.GenJavaOperation;
24  import de.fhdw.wtf.generator.java.generatorModel.GenMutableList;
25  import de.fhdw.wtf.generator.java.generatorModel.GenOperationModifier;
26  import de.fhdw.wtf.generator.java.generatorModel.GenPackage;
27  import de.fhdw.wtf.generator.java.generatorModel.GenParameter;
28  import de.fhdw.wtf.generator.java.generatorModel.GenStringType;
29  import de.fhdw.wtf.generator.java.generatorModel.GenUnqualifiedPackage;
30  import de.fhdw.wtf.generator.java.generatorModel.GenVisibility;
31  import de.fhdw.wtf.generator.java.generatorModel.GenVoidType;
32  
33  @SuppressWarnings("javadoc")
34  public class JavaClassFileWriterTest extends CommonTest {
35  	
36  	private static final String compareRoot = "src/test/resources/fileWriter/javaClassFileWriter/compareFiles/";
37  	private static final String rootDir = "target/generated-test-sources/fileWriter/javaClassFileWriter/gen/";
38  	
39  	/**
40  	 * Before the test cases are executed, the root-Directory is deleted.
41  	 * 
42  	 * @throws Exception
43  	 */
44  	@BeforeClass
45  	public static void setUp() throws Exception {
46  		FileUtils.deleteDirectory(rootDir);
47  	}
48  	
49  	@Test
50  	public void classWithoutAttAndOp() throws IOException {
51  		// Define values
52  		final String className = "ClName_classWithoutAttAndOp";
53  		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
54  		// Setup ClassClass
55  		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
56  		// Do Test
57  		this.doTest(className, packag, c);
58  	}
59  	
60  	@Test
61  	public void classWithoutAttAndOpAndInnerClass() throws IOException {
62  		// Define values
63  		final String className = "ClName_classWithoutAttAndOpAndInnerClass";
64  		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
65  		// Setup ClassClass
66  		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
67  		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
68  		c.addInnerClass(cInner);
69  		// Do Test
70  		this.doTest(className, packag, c);
71  	}
72  	
73  	@Test
74  	public void classWithoutAttAndOpAndInnerClassOneRecursive() throws IOException {
75  		// Define values
76  		final String className = "ClName_classWithoutAttAndOpAndInnerClassOneRecursive";
77  		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
78  		// Setup ClassClass
79  		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
80  		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
81  		final GenClassClass cInnerInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS_INNERCLASS", packag);
82  		cInner.addInnerClass(cInnerInner);
83  		c.addInnerClass(cInner);
84  		// Do Test
85  		this.doTest(className, packag, c);
86  	}
87  	
88  	@Test
89  	public void classWithoutAttAndOpAndInnerClassTwoRecursive() throws IOException {
90  		// Define values
91  		final String className = "ClName_classWithoutAttAndOpAndInnerClassTwoRecursive";
92  		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
93  		final GenUnqualifiedPackage diffpackag = GenUnqualifiedPackage.create("differentPackage");
94  		// Setup ClassClass
95  		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
96  		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
97  		final GenClassClass cInnerInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS_INNERCLASS", packag);
98  		final GenClassClass cInnerInnerInner =
99  				this.getEmptyDefaultClassClass(className + "_INNERCLASS_INNERCLASS_INNERCLASS", packag);
100 		cInnerInner.addInnerClass(cInnerInnerInner);
101 		cInner.addInnerClass(cInnerInner);
102 		c.addInnerClass(cInner);
103 		// Do Test
104 		this.doTest(className, packag, c);
105 	}
106 	
107 	@Test
108 	public void classWithAbstractModifier() throws IOException {
109 		// Define values
110 		final String className = "ClName_classWithAbstractModifier";
111 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
112 		// Setup ClassClass
113 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
114 		// Set Abstract Modifier
115 		c.getModifieres().add(GenClassModifier.ABSTRACT);
116 		// Do Test
117 		this.doTest(className, packag, c);
118 	}
119 	
120 	@Test
121 	public void innerClassWithAbstractModifier() throws IOException {
122 		// Define values
123 		final String className = "ClName_innerClassWithAbstractModifier";
124 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
125 		// Setup ClassClass
126 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
127 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
128 		c.addInnerClass(cInner);
129 		// Set Abstract Modifier
130 		cInner.getModifieres().add(GenClassModifier.ABSTRACT);
131 		// Do Test
132 		this.doTest(className, packag, c);
133 	}
134 	
135 	@Test
136 	public void classWithPublicStringAttribute() throws IOException {
137 		// Define values
138 		final String className = "ClName_classWithPublicStringAttribute";
139 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
140 		final GenJavaAttribute stringAttr =
141 				GenJavaAttribute.create(
142 						"attr",
143 						GenVisibility.PUBLIC,
144 						GenStringType.getInstance(),
145 						new Vector<GenAttributeModifier>());
146 		// Setup ClassClass
147 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
148 		// Set String Attribute
149 		c.getAttributes().add(stringAttr);
150 		// Do Test
151 		this.doTest(className, packag, c);
152 	}
153 	
154 	@Test
155 	public void innerClassWithPublicStringAttribute() throws IOException {
156 		// Define values
157 		final String className = "ClName_innerClassWithPublicStringAttribute";
158 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
159 		final GenJavaAttribute stringAttr =
160 				GenJavaAttribute.create(
161 						"attr",
162 						GenVisibility.PUBLIC,
163 						GenStringType.getInstance(),
164 						new Vector<GenAttributeModifier>());
165 		// Setup ClassClass
166 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
167 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
168 		c.addInnerClass(cInner);
169 		// Set String Attribute
170 		cInner.getAttributes().add(stringAttr);
171 		// Do Test
172 		this.doTest(className, packag, c);
173 	}
174 	
175 	@Test
176 	public void classWithPublicStringAttributeAndInnerClass() throws IOException {
177 		// Define values
178 		final String className = "ClName_classWithPublicStringAttributeAndInnerClass";
179 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
180 		final GenJavaAttribute stringAttr =
181 				GenJavaAttribute.create(
182 						"attr",
183 						GenVisibility.PUBLIC,
184 						GenStringType.getInstance(),
185 						new Vector<GenAttributeModifier>());
186 		// Setup ClassClass
187 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
188 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
189 		// Set String Attribute
190 		c.getAttributes().add(stringAttr);
191 		c.addInnerClass(cInner);
192 		// Do Test
193 		this.doTest(className, packag, c);
194 	}
195 	
196 	@Test
197 	public void classWithFinalStaticTransStringAttr() throws IOException {
198 		// Define values
199 		final String className = "ClName_classWithFinalStaticTransStringAttr";
200 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
201 		final GenJavaAttribute stringAttr =
202 				GenJavaAttribute.create(
203 						"ATTR",
204 						GenVisibility.PUBLIC,
205 						GenStringType.getInstance(),
206 						new Vector<GenAttributeModifier>());
207 		stringAttr.getModifiers().add(GenAttributeModifier.FINAL);
208 		stringAttr.getModifiers().add(GenAttributeModifier.STATIC);
209 		stringAttr.getModifiers().add(GenAttributeModifier.TRANSIENT);
210 		// Setup ClassClass
211 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
212 		// Set String Attribute
213 		c.getAttributes().add(stringAttr);
214 		// Do Test
215 		this.doTest(className, packag, c);
216 	}
217 	
218 	@Test
219 	public void innerClassWithFinalStaticTransStringAttr() throws IOException {
220 		// Define values
221 		final String className = "ClName_innerClassWithFinalStaticTransStringAttr";
222 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
223 		final GenJavaAttribute stringAttr =
224 				GenJavaAttribute.create(
225 						"ATTR",
226 						GenVisibility.PUBLIC,
227 						GenStringType.getInstance(),
228 						new Vector<GenAttributeModifier>());
229 		stringAttr.getModifiers().add(GenAttributeModifier.FINAL);
230 		stringAttr.getModifiers().add(GenAttributeModifier.STATIC);
231 		stringAttr.getModifiers().add(GenAttributeModifier.TRANSIENT);
232 		// Setup ClassClass
233 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
234 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
235 		c.addInnerClass(cInner);
236 		// Set String Attribute
237 		cInner.getAttributes().add(stringAttr);
238 		// Do Test
239 		this.doTest(className, packag, c);
240 	}
241 	
242 	@Test
243 	public void classWithPrivateStringAttribute() throws IOException {
244 		// Define values
245 		final String className = "ClName_classWithPrivateStringAttribute";
246 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
247 		final GenJavaAttribute stringAttr =
248 				GenJavaAttribute.create(
249 						"attr",
250 						GenVisibility.PRIVATE,
251 						GenStringType.getInstance(),
252 						new Vector<GenAttributeModifier>());
253 		// Setup ClassClass
254 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
255 		// Set String Attribute
256 		c.getAttributes().add(stringAttr);
257 		// Do Test
258 		this.doTest(className, packag, c);
259 	}
260 	
261 	@Test
262 	public void innerClassWithPrivateStringAttribute() throws IOException {
263 		// Define values
264 		final String className = "ClName_innerClassWithPrivateStringAttribute";
265 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
266 		final GenJavaAttribute stringAttr =
267 				GenJavaAttribute.create(
268 						"attr",
269 						GenVisibility.PRIVATE,
270 						GenStringType.getInstance(),
271 						new Vector<GenAttributeModifier>());
272 		// Setup ClassClass
273 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
274 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
275 		c.addInnerClass(cInner);
276 		// Set String Attribute
277 		cInner.getAttributes().add(stringAttr);
278 		// Do Test
279 		this.doTest(className, packag, c);
280 	}
281 	
282 	@Test
283 	public void classWithProtectedStringAttribute() throws IOException {
284 		// Define values
285 		final String className = "ClName_classWithProtectedStringAttribute";
286 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
287 		final GenJavaAttribute stringAttr =
288 				GenJavaAttribute.create(
289 						"attr",
290 						GenVisibility.PROTECTED,
291 						GenStringType.getInstance(),
292 						new Vector<GenAttributeModifier>());
293 		// Setup ClassClass
294 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
295 		// Set String Attribute
296 		c.getAttributes().add(stringAttr);
297 		// Do Test
298 		this.doTest(className, packag, c);
299 	}
300 	
301 	@Test
302 	public void innerClassWithProtectedStringAttribute() throws IOException {
303 		// Define values
304 		final String className = "ClName_innerClassWithProtectedStringAttribute";
305 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
306 		final GenJavaAttribute stringAttr =
307 				GenJavaAttribute.create(
308 						"attr",
309 						GenVisibility.PROTECTED,
310 						GenStringType.getInstance(),
311 						new Vector<GenAttributeModifier>());
312 		// Setup ClassClass
313 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
314 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
315 		c.addInnerClass(cInner);
316 		// Set String Attribute
317 		cInner.getAttributes().add(stringAttr);
318 		// Do Test
319 		this.doTest(className, packag, c);
320 	}
321 	
322 	@Test
323 	public void classWithDefaultStringAttribute() throws IOException {
324 		// Define values
325 		final String className = "ClName_classWithDefaultStringAttribute";
326 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
327 		final GenJavaAttribute stringAttr =
328 				GenJavaAttribute.create(
329 						"attr",
330 						GenVisibility.PROTECTED,
331 						GenStringType.getInstance(),
332 						new Vector<GenAttributeModifier>());
333 		// Setup ClassClass
334 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
335 		// Set String Attribute
336 		c.getAttributes().add(stringAttr);
337 		// Do Test
338 		this.doTest(className, packag, c);
339 	}
340 	
341 	@Test
342 	public void innerClassWithDefaultStringAttribute() throws IOException {
343 		// Define values
344 		final String className = "ClName_innerClassWithDefaultStringAttribute";
345 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
346 		final GenJavaAttribute stringAttr =
347 				GenJavaAttribute.create(
348 						"attr",
349 						GenVisibility.PROTECTED,
350 						GenStringType.getInstance(),
351 						new Vector<GenAttributeModifier>());
352 		// Setup ClassClass
353 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
354 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
355 		c.addInnerClass(cInner);
356 		// Set String Attribute
357 		cInner.getAttributes().add(stringAttr);
358 		// Do Test
359 		this.doTest(className, packag, c);
360 	}
361 	
362 	@Test
363 	public void classWithIntegerAttribute() throws IOException {
364 		// Define values
365 		final String className = "ClName_classWithIntegerAttribute";
366 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
367 		final GenJavaAttribute stringAttr =
368 				GenJavaAttribute.create(
369 						"attr",
370 						GenVisibility.PROTECTED,
371 						GenIntegerType.getInstance(),
372 						new Vector<GenAttributeModifier>());
373 		// Setup ClassClass
374 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
375 		// Set String Attribute
376 		c.getAttributes().add(stringAttr);
377 		// Do Test
378 		this.doTest(className, packag, c);
379 	}
380 	
381 	@Test
382 	public void innerClassWithIntegerAttribute() throws IOException {
383 		// Define values
384 		final String className = "ClName_innerClassWithIntegerAttribute";
385 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
386 		final GenJavaAttribute stringAttr =
387 				GenJavaAttribute.create(
388 						"attr",
389 						GenVisibility.PROTECTED,
390 						GenIntegerType.getInstance(),
391 						new Vector<GenAttributeModifier>());
392 		// Setup ClassClass
393 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
394 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
395 		c.addInnerClass(cInner);
396 		// Set String Attribute
397 		cInner.getAttributes().add(stringAttr);
398 		// Do Test
399 		this.doTest(className, packag, c);
400 	}
401 	
402 	@Test
403 	public void classWithStringCollectionAttribute() throws IOException {
404 		// Define values
405 		final String className = "ClName_classWithStringCollectionAttribute";
406 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
407 		final GenJavaAttribute stringCollAttr =
408 				GenJavaAttribute.create(
409 						"attr",
410 						GenVisibility.PROTECTED,
411 						GenMutableList.create(GenStringType.getInstance()),
412 						new Vector<GenAttributeModifier>());
413 		// Setup ClassClass
414 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
415 		// Set
416 		c.getAttributes().add(stringCollAttr);
417 		// Do Test
418 		this.doTest(className, packag, c);
419 	}
420 	
421 	@Test
422 	public void innerClassWithStringCollectionAttribute() throws IOException {
423 		// Define values
424 		final String className = "ClName_innerClassWithStringCollectionAttribute";
425 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
426 		final GenJavaAttribute stringCollAttr =
427 				GenJavaAttribute.create(
428 						"attr",
429 						GenVisibility.PROTECTED,
430 						GenMutableList.create(GenStringType.getInstance()),
431 						new Vector<GenAttributeModifier>());
432 		// Setup ClassClass
433 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
434 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
435 		c.addInnerClass(cInner);
436 		// Set
437 		cInner.getAttributes().add(stringCollAttr);
438 		// Do Test
439 		this.doTest(className, packag, c);
440 	}
441 	
442 	@Test
443 	public void classWithClassTypeAttribute() throws IOException {
444 		// Define values
445 		final String className = "ClName_classWithClassTypeAttribute";
446 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
447 		final GenPackage package2 = packag.addName("attrPackag");
448 		
449 		final GenClassClass attrClass = this.getEmptyDefaultClassClass("AttrClass", package2);
450 		final GenJavaAttribute classAttr =
451 				GenJavaAttribute.create("attr", GenVisibility.PROTECTED, attrClass, new Vector<GenAttributeModifier>());
452 		// Setup ClassClass
453 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
454 		// Set
455 		c.getAttributes().add(classAttr);
456 		// Do Test
457 		this.doTest(className, packag, c);
458 	}
459 	
460 	@Test
461 	public void innerClassWithClassTypeAttribute() throws IOException {
462 		// Define values
463 		final String className = "ClName_innerClassWithClassTypeAttribute";
464 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
465 		final GenPackage package2 = packag.addName("attrPackag");
466 		
467 		final GenClassClass attrClass = this.getEmptyDefaultClassClass("AttrClass", package2);
468 		final GenJavaAttribute classAttr =
469 				GenJavaAttribute.create("attr", GenVisibility.PROTECTED, attrClass, new Vector<GenAttributeModifier>());
470 		// Setup ClassClass
471 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
472 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
473 		c.addInnerClass(cInner);
474 		// Set
475 		cInner.getAttributes().add(classAttr);
476 		// Do Test
477 		this.doTest(className, packag, c);
478 	}
479 	
480 	@Test
481 	public void classWithOperationWithoutParam() throws IOException {
482 		// Define values
483 		final String className = "ClName_classWithOperationWithoutParam";
484 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
485 		final String method = "// TODO implement";
486 		final GenJavaOperation op =
487 				GenJavaOperation.create(
488 						"opName",
489 						GenVisibility.PUBLIC,
490 						new Vector<GenParameter>(),
491 						new Vector<GenException>(),
492 						method,
493 						GenVoidType.getInstance(),
494 						new Vector<GenOperationModifier>(),
495 						GenComment.create(defaultComment));
496 		// Setup ClassClass
497 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
498 		// Set
499 		c.addOperation(op);
500 		// Do Test
501 		this.doTest(className, packag, c);
502 	}
503 	
504 	@Test
505 	public void innerClassWithOperationWithoutParam() throws IOException {
506 		// Define values
507 		final String className = "ClName_innerClassWithOperationWithoutParam";
508 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
509 		final String method = "// TODO implement";
510 		final GenJavaOperation op =
511 				GenJavaOperation.create(
512 						"opName",
513 						GenVisibility.PUBLIC,
514 						new Vector<GenParameter>(),
515 						new Vector<GenException>(),
516 						method,
517 						GenVoidType.getInstance(),
518 						new Vector<GenOperationModifier>(),
519 						GenComment.create(defaultComment));
520 		// Setup ClassClass
521 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
522 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
523 		c.addInnerClass(cInner);
524 		// Set
525 		cInner.addOperation(op);
526 		// Do Test
527 		this.doTest(className, packag, c);
528 	}
529 	
530 	@Test
531 	public void classWithOperationWithExceptions() throws IOException {
532 		// Define values
533 		final String className = "ClName_classWithOperationWithException";
534 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
535 		final String excName1 = "Exc1_classWithOperationWithException";
536 		final String excName2 = "Exc2_classWithOperationWithException";
537 		final GenPackage excPackag = packag.addName("exc");
538 		final String method = "// TODO IMPL";
539 		final String comment = defaultComment;
540 		final Vector<GenException> excColl = new Vector<>();
541 		excColl.add(this.getEmptyDefaultException(excName1, excPackag));
542 		excColl.add(this.getEmptyDefaultException(excName2, excPackag));
543 		final GenJavaOperation op =
544 				GenJavaOperation.create(
545 						"opName",
546 						GenVisibility.PUBLIC,
547 						new Vector<GenParameter>(),
548 						excColl,
549 						method,
550 						GenVoidType.getInstance(),
551 						new Vector<GenOperationModifier>(),
552 						GenComment.create(comment));
553 		// Setup ClassClass
554 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
555 		// Set
556 		c.addOperation(op);
557 		// Do Test
558 		this.doTest(className, packag, c);
559 	}
560 	
561 	@Test
562 	public void innerClassWithOperationWithExceptions() throws IOException {
563 		// Define values
564 		final String className = "ClName_innerClassWithOperationWithException";
565 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
566 		final String excName1 = "Exc1_classWithOperationWithException";
567 		final String excName2 = "Exc2_classWithOperationWithException";
568 		final GenPackage excPackag = packag.addName("exc");
569 		final String method = "// TODO IMPL";
570 		final String comment = defaultComment;
571 		final Vector<GenException> excColl = new Vector<>();
572 		excColl.add(this.getEmptyDefaultException(excName1, excPackag));
573 		excColl.add(this.getEmptyDefaultException(excName2, excPackag));
574 		final GenJavaOperation op =
575 				GenJavaOperation.create(
576 						"opName",
577 						GenVisibility.PUBLIC,
578 						new Vector<GenParameter>(),
579 						excColl,
580 						method,
581 						GenVoidType.getInstance(),
582 						new Vector<GenOperationModifier>(),
583 						GenComment.create(comment));
584 		// Setup ClassClass
585 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
586 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
587 		c.addInnerClass(cInner);
588 		// Set
589 		cInner.addOperation(op);
590 		// Do Test
591 		this.doTest(className, packag, c);
592 	}
593 	
594 	@Test
595 	@Ignore("Neu überdenken, da Imports und Inheritance-Generierung verändert wurden")
596 	public void classWithOperationWithStringParam() throws IOException {
597 		// Define values
598 		final String className = "ClName_classWithOperationWithStringParam";
599 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
600 		final String method = "// TODO IMPL";
601 		final String comment = defaultComment;
602 		final Vector<GenParameter> paramColl = new Vector<>();
603 		paramColl.add(GenParameter.create("p1", GenStringType.getInstance()));
604 		final GenJavaOperation op =
605 				GenJavaOperation.create(
606 						"opName",
607 						GenVisibility.PUBLIC,
608 						paramColl,
609 						new Vector<GenException>(),
610 						method,
611 						GenVoidType.getInstance(),
612 						new Vector<GenOperationModifier>(),
613 						GenComment.create(comment));
614 		// Setup ClassClass
615 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
616 		// Set
617 		c.addOperation(op);
618 		// Do Test
619 		System.out.println(c);
620 		this.doTest(className, packag, c);
621 	}
622 	
623 	@Test
624 	@Ignore("Neu überdenken, da Imports und Inheritance-Generierung verändert wurden")
625 	public void classWithOperationMultiParam() throws IOException {
626 		// Define values
627 		final String className = "ClName_classWithOperationMultiParam";
628 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
629 		final String method = "// TODO IMPL";
630 		final String comment = defaultComment;
631 		final Vector<GenParameter> paramColl = new Vector<>();
632 		paramColl.add(GenParameter.create("p1", GenStringType.getInstance()));
633 		paramColl.add(GenParameter.create("p2", GenStringType.getInstance()));
634 		paramColl.add(GenParameter.create("p3", GenIntegerType.getInstance()));
635 		final GenJavaOperation op =
636 				GenJavaOperation.create(
637 						"opName",
638 						GenVisibility.PUBLIC,
639 						paramColl,
640 						new Vector<GenException>(),
641 						method,
642 						GenVoidType.getInstance(),
643 						new Vector<GenOperationModifier>(),
644 						GenComment.create(comment));
645 		// Setup ClassClass
646 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
647 		// Set
648 		c.addOperation(op);
649 		// Do Test
650 		this.doTest(className, packag, c);
651 	}
652 	
653 	@Test
654 	public void classWithVoidOperation() throws IOException {
655 		// Define values
656 		final String className = "ClName_classWithVoidOperation";
657 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
658 		final String method = "// TODO IMPL";
659 		final String comment = defaultComment;
660 		final GenJavaOperation op =
661 				GenJavaOperation.create(
662 						"opName",
663 						GenVisibility.PUBLIC,
664 						new Vector<GenParameter>(),
665 						new Vector<GenException>(),
666 						method,
667 						GenVoidType.getInstance(),
668 						new Vector<GenOperationModifier>(),
669 						GenComment.create(comment));
670 		// Setup ClassClass
671 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
672 		// Set
673 		c.addOperation(op);
674 		// Do Test
675 		this.doTest(className, packag, c);
676 	}
677 	
678 	@Test
679 	public void innerClassWithVoidOperation() throws IOException {
680 		// Define values
681 		final String className = "ClName_innerClassWithVoidOperation";
682 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
683 		final String method = "// TODO IMPL";
684 		final String comment = defaultComment;
685 		final GenJavaOperation op =
686 				GenJavaOperation.create(
687 						"opName",
688 						GenVisibility.PUBLIC,
689 						new Vector<GenParameter>(),
690 						new Vector<GenException>(),
691 						method,
692 						GenVoidType.getInstance(),
693 						new Vector<GenOperationModifier>(),
694 						GenComment.create(comment));
695 		// Setup ClassClass
696 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
697 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
698 		c.addInnerClass(cInner);
699 		// Set
700 		cInner.addOperation(op);
701 		// Do Test
702 		this.doTest(className, packag, c);
703 	}
704 	
705 	@Test
706 	public void classWithOperationReturnTypCollection() throws IOException {
707 		// Define values
708 		final String className = "ClName_classWithOperationReturnTypCollection";
709 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
710 		final String method = "// TODO IMPL";
711 		final String comment = defaultComment;
712 		final GenJavaOperation op =
713 				GenJavaOperation.create(
714 						"opName",
715 						GenVisibility.PUBLIC,
716 						new Vector<GenParameter>(),
717 						new Vector<GenException>(),
718 						method,
719 						GenMutableList.create(GenStringType.getInstance()),
720 						new Vector<GenOperationModifier>(),
721 						GenComment.create(comment));
722 		// Setup ClassClass
723 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
724 		// Set
725 		c.addOperation(op);
726 		// Do Test
727 		this.doTest(className, packag, c);
728 	}
729 	
730 	@Test
731 	public void innerClassWithOperationReturnTypCollection() throws IOException {
732 		// Define values
733 		final String className = "ClName_innerClassWithOperationReturnTypCollection";
734 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
735 		final String method = "// TODO IMPL";
736 		final String comment = defaultComment;
737 		final GenJavaOperation op =
738 				GenJavaOperation.create(
739 						"opName",
740 						GenVisibility.PUBLIC,
741 						new Vector<GenParameter>(),
742 						new Vector<GenException>(),
743 						method,
744 						GenMutableList.create(GenStringType.getInstance()),
745 						new Vector<GenOperationModifier>(),
746 						GenComment.create(comment));
747 		// Setup ClassClass
748 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
749 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
750 		c.addInnerClass(cInner);
751 		// Set
752 		cInner.addOperation(op);
753 		// Do Test
754 		this.doTest(className, packag, c);
755 	}
756 	
757 	@Test
758 	public void classWithOperationReturnTypBaseType() throws IOException {
759 		// Define values
760 		final String className = "ClName_classWithOperationReturnTypBaseType";
761 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
762 		final String method = "// TODO IMPL";
763 		final String comment = defaultComment;
764 		final GenJavaOperation op =
765 				GenJavaOperation.create(
766 						"opName",
767 						GenVisibility.PUBLIC,
768 						new Vector<GenParameter>(),
769 						new Vector<GenException>(),
770 						method,
771 						GenStringType.getInstance(),
772 						new Vector<GenOperationModifier>(),
773 						GenComment.create(comment));
774 		// Setup ClassClass
775 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
776 		// Set
777 		c.addOperation(op);
778 		// Do Test
779 		this.doTest(className, packag, c);
780 	}
781 	
782 	@Test
783 	public void innerClassWithOperationReturnTypBaseType() throws IOException {
784 		// Define values
785 		final String className = "ClName_innerClassWithOperationReturnTypBaseType";
786 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
787 		final String method = "// TODO IMPL";
788 		final String comment = defaultComment;
789 		final GenJavaOperation op =
790 				GenJavaOperation.create(
791 						"opName",
792 						GenVisibility.PUBLIC,
793 						new Vector<GenParameter>(),
794 						new Vector<GenException>(),
795 						method,
796 						GenStringType.getInstance(),
797 						new Vector<GenOperationModifier>(),
798 						GenComment.create(comment));
799 		// Setup ClassClass
800 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
801 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
802 		c.addInnerClass(cInner);
803 		// Set
804 		cInner.addOperation(op);
805 		// Do Test
806 		this.doTest(className, packag, c);
807 	}
808 	
809 	@Test
810 	public void classWithOperationReturnTypClassType() throws IOException {
811 		// Define values
812 		final String className = "ClName_classWithOperationReturnTypClassType";
813 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
814 		final String method = "// TODO IMPL";
815 		final String comment = defaultComment;
816 		final String returnTypeName = "MyReturnType";
817 		final GenClassClass returnType = this.getEmptyDefaultClassClass(returnTypeName, packag);
818 		final GenJavaOperation op =
819 				GenJavaOperation.create(
820 						"opName",
821 						GenVisibility.PUBLIC,
822 						new Vector<GenParameter>(),
823 						new Vector<GenException>(),
824 						method,
825 						returnType,
826 						new Vector<GenOperationModifier>(),
827 						GenComment.create(comment));
828 		// Setup ClassClass
829 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
830 		// Set
831 		c.addOperation(op);
832 		// Do Test
833 		this.doTest(className, packag, c);
834 	}
835 	
836 	@Test
837 	public void innerClassWithOperationReturnTypClassType() throws IOException {
838 		// Define values
839 		final String className = "ClName_innerClassWithOperationReturnTypClassType";
840 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
841 		final String method = "// TODO IMPL";
842 		final String comment = defaultComment;
843 		final String returnTypeName = "MyReturnType";
844 		final GenClassClass returnType = this.getEmptyDefaultClassClass(returnTypeName, packag);
845 		final GenJavaOperation op =
846 				GenJavaOperation.create(
847 						"opName",
848 						GenVisibility.PUBLIC,
849 						new Vector<GenParameter>(),
850 						new Vector<GenException>(),
851 						method,
852 						returnType,
853 						new Vector<GenOperationModifier>(),
854 						GenComment.create(comment));
855 		// Setup ClassClass
856 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
857 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
858 		c.addInnerClass(cInner);
859 		// Set
860 		cInner.addOperation(op);
861 		// Do Test
862 		this.doTest(className, packag, c);
863 	}
864 	
865 	@Test
866 	public void classWithOperationAndAttribute() throws IOException {
867 		// Define values
868 		final String className = "ClName_classWithOperationAndAttribute";
869 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
870 		final String method = "// TODO IMPL";
871 		final String comment = defaultComment;
872 		final GenJavaAttribute stringAttr =
873 				GenJavaAttribute.create(
874 						"attr",
875 						GenVisibility.PROTECTED,
876 						GenStringType.getInstance(),
877 						new Vector<GenAttributeModifier>());
878 		final GenJavaOperation op =
879 				GenJavaOperation.create(
880 						"opName",
881 						GenVisibility.PUBLIC,
882 						new Vector<GenParameter>(),
883 						new Vector<GenException>(),
884 						method,
885 						GenVoidType.getInstance(),
886 						new Vector<GenOperationModifier>(),
887 						GenComment.create(comment));
888 		// Setup ClassClass
889 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
890 		// Set
891 		c.addOperation(op);
892 		c.getAttributes().add(stringAttr);
893 		// Do Test
894 		this.doTest(className, packag, c);
895 	}
896 	
897 	@Test
898 	public void innerClassWithOperationAndAttribute() throws IOException {
899 		// Define values
900 		final String className = "ClName_innerClassWithOperationAndAttribute";
901 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
902 		final String method = "// TODO IMPL";
903 		final String comment = defaultComment;
904 		final GenJavaAttribute stringAttr =
905 				GenJavaAttribute.create(
906 						"attr",
907 						GenVisibility.PROTECTED,
908 						GenStringType.getInstance(),
909 						new Vector<GenAttributeModifier>());
910 		final GenJavaOperation op =
911 				GenJavaOperation.create(
912 						"opName",
913 						GenVisibility.PUBLIC,
914 						new Vector<GenParameter>(),
915 						new Vector<GenException>(),
916 						method,
917 						GenVoidType.getInstance(),
918 						new Vector<GenOperationModifier>(),
919 						GenComment.create(comment));
920 		// Setup ClassClass
921 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
922 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
923 		c.addInnerClass(cInner);
924 		// Set
925 		cInner.addOperation(op);
926 		cInner.getAttributes().add(stringAttr);
927 		// Do Test
928 		this.doTest(className, packag, c);
929 	}
930 	
931 	@Test
932 	public void classWithSuperClass() throws IOException {
933 		// Define values
934 		final String className = "ClName_classWithSuperClass";
935 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
936 		final GenClassClass superC = this.getEmptyDefaultClassClass("SuperClass", packag);
937 		// Setup ClassClass
938 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
939 		// Set
940 		c.setExtend(superC);
941 		// TODO change to delegation
942 		// Do Test
943 		this.doTest(className, packag, c);
944 	}
945 	
946 	@Test
947 	public void innerClassWithSuperClass() throws IOException {
948 		// Define values
949 		final String className = "ClName_innerClassWithSuperClass";
950 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
951 		final GenClassClass superC = this.getEmptyDefaultClassClass("SuperClass", packag);
952 		// Setup ClassClass
953 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
954 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
955 		c.addInnerClass(cInner);
956 		// Set
957 		cInner.setExtend(superC);
958 		// TODO change to delegation
959 		// Do Test
960 		this.doTest(className, packag, c);
961 	}
962 	
963 	@Test
964 	public void classWithSingleImplemnts() throws IOException {
965 		// Define values
966 		final String className = "ClName_classWithSingleImplemnts";
967 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
968 		final GenInterfaceClass interaf = this.getEmptyDefaultInterfaceClass("InterfaceClass", packag);
969 		// Setup ClassClass
970 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
971 		// Set
972 		c.getImplement().add(interaf);
973 		// Do Test
974 		this.doTest(className, packag, c);
975 	}
976 	
977 	@Test
978 	public void innerClassWithSingleImplemnts() throws IOException {
979 		// Define values
980 		final String className = "ClName_innerClassWithSingleImplemnts";
981 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
982 		final GenInterfaceClass interaf = this.getEmptyDefaultInterfaceClass("InterfaceClass", packag);
983 		// Setup ClassClass
984 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
985 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
986 		c.addInnerClass(cInner);
987 		// Set
988 		cInner.getImplement().add(interaf);
989 		// Do Test
990 		this.doTest(className, packag, c);
991 	}
992 	
993 	@Test
994 	public void classWithMultiImplemnts() throws IOException {
995 		// Define values
996 		final String className = "ClName_classWithMultiImplemnts";
997 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
998 		final GenInterfaceClass interaf1 = this.getEmptyDefaultInterfaceClass("InterfaceClass1", packag);
999 		final GenInterfaceClass interaf2 = this.getEmptyDefaultInterfaceClass("InterfaceClass2", packag);
1000 		final GenInterfaceClass interaf3 = this.getEmptyDefaultInterfaceClass("InterfaceClass3", packag);
1001 		// Setup ClassClass
1002 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
1003 		// Set
1004 		c.getImplement().add(interaf1);
1005 		c.getImplement().add(interaf2);
1006 		c.getImplement().add(interaf3);
1007 		// Do Test
1008 		this.doTest(className, packag, c);
1009 	}
1010 	
1011 	@Test
1012 	public void innerClassWithMultiImplemnts() throws IOException {
1013 		// Define values
1014 		final String className = "ClName_innerClassWithMultiImplemnts";
1015 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
1016 		final GenInterfaceClass interaf1 = this.getEmptyDefaultInterfaceClass("InterfaceClass1", packag);
1017 		final GenInterfaceClass interaf2 = this.getEmptyDefaultInterfaceClass("InterfaceClass2", packag);
1018 		final GenInterfaceClass interaf3 = this.getEmptyDefaultInterfaceClass("InterfaceClass3", packag);
1019 		// Setup ClassClass
1020 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
1021 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
1022 		c.addInnerClass(cInner);
1023 		// Set
1024 		cInner.getImplement().add(interaf1);
1025 		cInner.getImplement().add(interaf2);
1026 		cInner.getImplement().add(interaf3);
1027 		// Do Test
1028 		this.doTest(className, packag, c);
1029 	}
1030 	
1031 	@Test
1032 	public void classWithMultiImplemntsAndSuperClass() throws IOException {
1033 		// Define values
1034 		final String className = "ClName_classWithMultiImplemntsAndSuperClass";
1035 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
1036 		final GenClassClass superC = this.getEmptyDefaultClassClass("SuperClass", packag);
1037 		final GenInterfaceClass interaf1 = this.getEmptyDefaultInterfaceClass("InterfaceClass1", packag);
1038 		final GenInterfaceClass interaf2 = this.getEmptyDefaultInterfaceClass("InterfaceClass2", packag);
1039 		final GenInterfaceClass interaf3 = this.getEmptyDefaultInterfaceClass("InterfaceClass3", packag);
1040 		// Setup ClassClass
1041 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
1042 		// Set
1043 		c.setExtend(superC);
1044 		// TODO change to delegation
1045 		c.getImplement().add(interaf1);
1046 		c.getImplement().add(interaf2);
1047 		c.getImplement().add(interaf3);
1048 		// Do Test
1049 		this.doTest(className, packag, c);
1050 	}
1051 	
1052 	@Test
1053 	public void innerClassWithMultiImplemntsAndSuperClass() throws IOException {
1054 		// Define values
1055 		final String className = "ClName_innerClassWithMultiImplemntsAndSuperClass";
1056 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
1057 		final GenClassClass superC = this.getEmptyDefaultClassClass("SuperClass", packag);
1058 		final GenInterfaceClass interaf1 = this.getEmptyDefaultInterfaceClass("InterfaceClass1", packag);
1059 		final GenInterfaceClass interaf2 = this.getEmptyDefaultInterfaceClass("InterfaceClass2", packag);
1060 		final GenInterfaceClass interaf3 = this.getEmptyDefaultInterfaceClass("InterfaceClass3", packag);
1061 		// Setup ClassClass
1062 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
1063 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
1064 		c.addInnerClass(cInner);
1065 		// Set
1066 		cInner.setExtend(superC);
1067 		// TODO change to delegation
1068 		cInner.getImplement().add(interaf1);
1069 		cInner.getImplement().add(interaf2);
1070 		cInner.getImplement().add(interaf3);
1071 		// Do Test
1072 		this.doTest(className, packag, c);
1073 	}
1074 	
1075 	@Test
1076 	public void classWithConstructorWithoutParam() throws IOException {
1077 		// Define values
1078 		final String className = "ClName_classWithConstructorWithoutParam";
1079 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
1080 		// Setup ClassClass
1081 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
1082 		final GenJavaOperation cons =
1083 				GenJavaOperation.createConstructor(
1084 						c,
1085 						GenVisibility.PUBLIC,
1086 						new Vector<GenParameter>(),
1087 						new Vector<GenException>(),
1088 						"// TODO impl Constructor",
1089 						GenComment.create(defaultComment));
1090 		c.getConstructors().add(cons);
1091 		// Do Test
1092 		this.doTest(className, packag, c);
1093 	}
1094 	
1095 	@Test
1096 	public void innerClassWithConstructorWithoutParam() throws IOException {
1097 		// Define values
1098 		final String className = "ClName_innerClassWithConstructorWithoutParam";
1099 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
1100 		// Setup ClassClass
1101 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
1102 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
1103 		c.addInnerClass(cInner);
1104 		final GenJavaOperation cons =
1105 				GenJavaOperation.createConstructor(
1106 						cInner,
1107 						GenVisibility.PUBLIC,
1108 						new Vector<GenParameter>(),
1109 						new Vector<GenException>(),
1110 						"// TODO impl Constructor",
1111 						GenComment.create(defaultComment));
1112 		cInner.getConstructors().add(cons);
1113 		// Do Test
1114 		this.doTest(className, packag, c);
1115 	}
1116 	
1117 	@Test
1118 	public void classWithConstructorWithParam() throws IOException {
1119 		// Define values
1120 		final String className = "ClName_classWithConstructorWithParam";
1121 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
1122 		// Setup ClassClass
1123 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
1124 		final GenJavaOperation cons =
1125 				GenJavaOperation.createConstructor(
1126 						c,
1127 						GenVisibility.PUBLIC,
1128 						new Vector<GenParameter>(),
1129 						new Vector<GenException>(),
1130 						"// TODO impl Constructor",
1131 						GenComment.create(defaultComment));
1132 		cons.getParameters().add(GenParameter.create("p1", GenStringType.getInstance()));
1133 		cons.getParameters().add(GenParameter.create("p2", GenIntegerType.getInstance()));
1134 		
1135 		c.getConstructors().add(cons);
1136 		// Do Test
1137 		this.doTest(className, packag, c);
1138 	}
1139 	
1140 	@Test
1141 	public void innerClassWithConstructorWithParam() throws IOException {
1142 		// Define values
1143 		final String className = "ClName_innerClassWithConstructorWithParam";
1144 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
1145 		// Setup ClassClass
1146 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
1147 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
1148 		c.addInnerClass(cInner);
1149 		final GenJavaOperation cons =
1150 				GenJavaOperation.createConstructor(
1151 						cInner,
1152 						GenVisibility.PUBLIC,
1153 						new Vector<GenParameter>(),
1154 						new Vector<GenException>(),
1155 						"// TODO impl Constructor",
1156 						GenComment.create(defaultComment));
1157 		cons.getParameters().add(GenParameter.create("p1", GenStringType.getInstance()));
1158 		cons.getParameters().add(GenParameter.create("p2", GenIntegerType.getInstance()));
1159 		
1160 		cInner.getConstructors().add(cons);
1161 		// Do Test
1162 		this.doTest(className, packag, c);
1163 	}
1164 	
1165 	@Test
1166 	public void classWithMultiConstructorWithParam() throws IOException {
1167 		// Define values
1168 		final String className = "ClName_classWithMultiConstructorWithParam";
1169 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
1170 		// Setup ClassClass
1171 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
1172 		final GenJavaOperation cons1 =
1173 				GenJavaOperation.createConstructor(
1174 						c,
1175 						GenVisibility.PUBLIC,
1176 						new Vector<GenParameter>(),
1177 						new Vector<GenException>(),
1178 						"// TODO impl Constructor",
1179 						GenComment.create(defaultComment));
1180 		cons1.getParameters().add(GenParameter.create("p1", GenStringType.getInstance()));
1181 		
1182 		final GenJavaOperation cons2 =
1183 				GenJavaOperation.createConstructor(
1184 						c,
1185 						GenVisibility.PRIVATE,
1186 						new Vector<GenParameter>(),
1187 						new Vector<GenException>(),
1188 						"// TODO impl Constructor",
1189 						GenComment.create(defaultComment));
1190 		cons2.getParameters().add(GenParameter.create("p1", GenStringType.getInstance()));
1191 		cons2.getParameters().add(GenParameter.create("p2", GenIntegerType.getInstance()));
1192 		cons2.getParameters().add(GenParameter.create("p3", GenIntegerType.getInstance()));
1193 		
1194 		final GenJavaOperation cons3 =
1195 				GenJavaOperation.createConstructor(
1196 						c,
1197 						GenVisibility.PROTECTED,
1198 						new Vector<GenParameter>(),
1199 						new Vector<GenException>(),
1200 						"// TODO impl Constructor",
1201 						GenComment.create(defaultComment));
1202 		
1203 		c.getConstructors().add(cons1);
1204 		c.getConstructors().add(cons2);
1205 		c.getConstructors().add(cons3);
1206 		// Do Test
1207 		this.doTest(className, packag, c);
1208 	}
1209 	
1210 	@Test
1211 	public void innerClassWithMultiConstructorWithParam() throws IOException {
1212 		// Define values
1213 		final String className = "ClName_innerClassWithMultiConstructorWithParam";
1214 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
1215 		// Setup ClassClass
1216 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
1217 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
1218 		c.addInnerClass(cInner);
1219 		final GenJavaOperation cons1 =
1220 				GenJavaOperation.createConstructor(
1221 						cInner,
1222 						GenVisibility.PUBLIC,
1223 						new Vector<GenParameter>(),
1224 						new Vector<GenException>(),
1225 						"// TODO impl Constructor",
1226 						GenComment.create(defaultComment));
1227 		cons1.getParameters().add(GenParameter.create("p1", GenStringType.getInstance()));
1228 		
1229 		final GenJavaOperation cons2 =
1230 				GenJavaOperation.createConstructor(
1231 						cInner,
1232 						GenVisibility.PRIVATE,
1233 						new Vector<GenParameter>(),
1234 						new Vector<GenException>(),
1235 						"// TODO impl Constructor",
1236 						GenComment.create(defaultComment));
1237 		cons2.getParameters().add(GenParameter.create("p1", GenStringType.getInstance()));
1238 		cons2.getParameters().add(GenParameter.create("p2", GenIntegerType.getInstance()));
1239 		cons2.getParameters().add(GenParameter.create("p3", GenIntegerType.getInstance()));
1240 		
1241 		final GenJavaOperation cons3 =
1242 				GenJavaOperation.createConstructor(
1243 						cInner,
1244 						GenVisibility.PROTECTED,
1245 						new Vector<GenParameter>(),
1246 						new Vector<GenException>(),
1247 						"// TODO impl Constructor",
1248 						GenComment.create(defaultComment));
1249 		
1250 		cInner.getConstructors().add(cons1);
1251 		cInner.getConstructors().add(cons2);
1252 		cInner.getConstructors().add(cons3);
1253 		// Do Test
1254 		this.doTest(className, packag, c);
1255 	}
1256 	
1257 	@Test
1258 	public void classWithConstructorWithException() throws IOException {
1259 		// Define values
1260 		final String className = "ClName_classWithConstructorWithException";
1261 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
1262 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
1263 		final GenJavaOperation cons =
1264 				GenJavaOperation.createConstructor(
1265 						c,
1266 						GenVisibility.PUBLIC,
1267 						new Vector<GenParameter>(),
1268 						new Vector<GenException>(),
1269 						"// TODO impl Constructor",
1270 						GenComment.create(defaultComment));
1271 		((GenFullParsedOperationState) cons.getState()).getExceptions().add(
1272 				this.getEmptyDefaultException("ExcptionExc", packag));
1273 		// Setup ClassClass
1274 		
1275 		c.getConstructors().add(cons);
1276 		// Do Test
1277 		this.doTest(className, packag, c);
1278 	}
1279 	
1280 	@Test
1281 	public void innerClassWithConstructorWithException() throws IOException {
1282 		// Define values
1283 		final String className = "ClName_innerClassWithConstructorWithException";
1284 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
1285 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
1286 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
1287 		c.addInnerClass(cInner);
1288 		final GenJavaOperation cons =
1289 				GenJavaOperation.createConstructor(
1290 						cInner,
1291 						GenVisibility.PUBLIC,
1292 						new Vector<GenParameter>(),
1293 						new Vector<GenException>(),
1294 						"// TODO impl Constructor",
1295 						GenComment.create(defaultComment));
1296 		((GenFullParsedOperationState) cons.getState()).getExceptions().add(
1297 				this.getEmptyDefaultException("ExcptionExc", packag));
1298 		// Setup ClassClass
1299 		
1300 		cInner.getConstructors().add(cons);
1301 		// Do Test
1302 		this.doTest(className, packag, c);
1303 	}
1304 	
1305 	@Test
1306 	public void classExtendsAnyType() throws IOException {
1307 		// Define values
1308 		final String className = "ClName_classExtendsAnyType";
1309 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
1310 		// Setup ClassClass
1311 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
1312 		c.setExtend(GenAnyType.getInstance());
1313 		// TODO change to delegation
1314 		// Do Test
1315 		this.doTest(className, packag, c);
1316 	}
1317 	
1318 	@Test
1319 	public void innerClassExtendsAnyType() throws IOException {
1320 		// Define values
1321 		final String className = "ClName_innerClassExtendsAnyType";
1322 		final GenUnqualifiedPackage packag = GenUnqualifiedPackage.create("packageName");
1323 		// Setup ClassClass
1324 		final GenClassClass cInner = this.getEmptyDefaultClassClass(className + "_INNERCLASS", packag);
1325 		final GenClassClass c = this.getEmptyDefaultClassClass(className, packag);
1326 		c.addInnerClass(cInner);
1327 		cInner.setExtend(GenAnyType.getInstance());
1328 		// TODO change to delegation
1329 		// Do Test
1330 		this.doTest(className, packag, c);
1331 	}
1332 	
1333 	@Override
1334 	public String getRootDir() {
1335 		return rootDir;
1336 	}
1337 	
1338 	@Override
1339 	public String getCompareDir() {
1340 		return compareRoot;
1341 	}
1342 	
1343 }