1 package transformers.test;
2
3 import static org.junit.Assert.assertEquals;
4 import static org.junit.Assert.fail;
5
6 import java.util.Collection;
7 import java.util.HashSet;
8 import java.util.Iterator;
9 import java.util.Set;
10
11 import org.junit.Assert;
12 import org.junit.Test;
13
14 import common.TestConstants;
15 import common.TestModels;
16 import common.TestUtil;
17
18 import de.fhdw.wtf.common.ast.Model;
19 import de.fhdw.wtf.common.task.TaskExecutorFixed;
20 import de.fhdw.wtf.facade.ModelManager;
21 import de.fhdw.wtf.facade.TypeNameGenerator;
22 import de.fhdw.wtf.generator.java.generatorModel.GenAnyType;
23 import de.fhdw.wtf.generator.java.generatorModel.GenAspect;
24 import de.fhdw.wtf.generator.java.generatorModel.GenClass;
25 import de.fhdw.wtf.generator.java.generatorModel.GenClassClass;
26 import de.fhdw.wtf.generator.java.generatorModel.GenException;
27 import de.fhdw.wtf.generator.java.generatorModel.GenExternalClassClass;
28 import de.fhdw.wtf.generator.java.generatorModel.GenExternalInterfaceClass;
29 import de.fhdw.wtf.generator.java.generatorModel.GenInterfaceClass;
30 import de.fhdw.wtf.generator.java.generatorModel.GenInterfaceWithClassImplClass;
31 import de.fhdw.wtf.generator.java.generatorModel.GenJavaException;
32 import de.fhdw.wtf.generator.java.generatorModel.GenPrimitiveClass;
33 import de.fhdw.wtf.generator.java.generatorModel.GenSimpleInterfaceClass;
34 import de.fhdw.wtf.generator.java.generatorModel.GenUserClass;
35 import de.fhdw.wtf.generator.java.generatorModel.GeneratorModel;
36 import de.fhdw.wtf.generator.java.visitor.GenClassClassVisitor;
37 import de.fhdw.wtf.generator.java.visitor.GenClassVisitor;
38 import de.fhdw.wtf.generator.java.visitor.GenInterfaceClassVisitor;
39 import de.fhdw.wtf.generator.transformer.transformers.classTransformer.TypeTransformer;
40
41
42
43
44
45 public class TestClassTransformer {
46
47 public static boolean controlImplClass(final GenInterfaceWithClassImplClass interfaceWithImplClass,
48 final String classname,
49 final String packagename,
50 final Collection<String> expectedOperations,
51 final Collection<String> expectedAttributes,
52 final Collection<String> expectedModifiers,
53 final Collection<String> expectedImplements) {
54 assertEquals(classname + "$Impl", interfaceWithImplClass.getClassRepresentation().getName());
55 assertEquals(packagename + "." + classname + "_InnerPackage", interfaceWithImplClass.getClassRepresentation()
56 .getPackag().toString());
57 TestUtil.assertEqualsForOperations(expectedOperations, interfaceWithImplClass.getClassRepresentation()
58 .getOperations());
59 TestUtil.assertEqualsForAttributes(expectedAttributes, interfaceWithImplClass.getClassRepresentation()
60 .getAttributes());
61 TestUtil.assertEqualsForClassModifiers(expectedModifiers, interfaceWithImplClass.getClassRepresentation()
62 .getModifieres());
63 TestUtil.assertEqualsForImplement(expectedImplements, interfaceWithImplClass.getClassRepresentation()
64 .getImplement());
65
66 return true;
67 }
68
69 private GeneratorModel generate(final String input) throws Exception {
70
71 final Model model = ModelManager.getInstance().getModelFromString(input);
72
73 final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
74 final GeneratorModel javaGeneratorModel = GeneratorModel.create();
75
76
77 new TypeTransformer(model, taskmanager, javaGeneratorModel);
78
79 taskmanager.startAllKnownTasks();
80 taskmanager.getResultsAndShutdown();
81
82 return javaGeneratorModel;
83 }
84
85
86
87 @Test
88 public void testAbstractClassWithStringAttribute() throws Exception {
89 final GeneratorModel javaGeneratorModel = this.generate(TestModels.abstractClassWithStringAttribute);
90
91 final Set<String> expectedClasses = new HashSet<>();
92 expectedClasses.add("generated.sums.Anything");
93 expectedClasses.add("generated.model.group1.class1");
94 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
95 expectedClasses.add(product0);
96 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
97
98 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
99 while (i.hasNext()) {
100 final GenClass genClass = i.next();
101 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
102 switch (genClass.getName()) {
103 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
104 break;
105 case "class1":
106 assertEquals("generated.model.group1", genClass.getPackag().toString());
107 genClass.accept(new GenClassVisitor() {
108
109 @Override
110 public void handle(final GenInterfaceClass interfaceClass) {
111 assertEquals(0, interfaceClass.getOperations().size());
112
113 interfaceClass.accept(new GenInterfaceClassVisitor() {
114
115 @Override
116 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
117 final Set<String> operations = new HashSet<>();
118 operations.add("private generated.model.group1.class1 $getThis()");
119 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
120 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
121 + " get$generatedObjects()");
122 final HashSet<String> attributes = new HashSet<>();
123 attributes.add("private generated.model.group1.class1 This");
124 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
125 final Set<String> modifiers = new HashSet<>();
126 final Set<String> implement = new HashSet<>();
127 implement.add("generated.model.group1.class1");
128 assertEquals(true, TestClassTransformer.controlImplClass(
129 interfaceWithImplClass,
130 "class1",
131 "generated.model.group1",
132 operations,
133 attributes,
134 modifiers,
135 implement));
136 }
137
138 @Override
139 public void handle(final GenSimpleInterfaceClass simpleInterface) {
140 fail();
141 }
142
143 @Override
144 public void handle(final GenExternalInterfaceClass iface) {
145 fail();
146 }
147 });
148 }
149
150 @Override
151 public void handle(final GenClassClass classClass) {
152 fail();
153 }
154
155 @Override
156 public void handle(final GenPrimitiveClass primitiveClass) {
157 fail();
158 }
159 });
160 break;
161 }
162
163 } else {
164 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getFullyQualifiedTypeName());
165 }
166 }
167
168 if (expectedClasses.size() != 0) {
169 fail("Klasse erwartet, aber nicht gefunden");
170 }
171 }
172
173 @Test
174 public void testClassWithStringAttributeAndOperationWithoutParameterAndStringReturntype() throws Exception {
175 final GeneratorModel javaGeneratorModel =
176 this.generate(TestModels.classWithStringAttributeAndOperationWithoutParameterAndStringReturntype);
177
178 final Set<String> expectedClasses = new HashSet<>();
179 expectedClasses.add("generated.sums.Anything");
180 expectedClasses.add("generated.model.group1.class1");
181 expectedClasses.add("generated.products.Product$0$0$");
182
183 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
184 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
185 while (i.hasNext()) {
186 final GenClass genClass = i.next();
187 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
188 switch (genClass.getName()) {
189 case "class1":
190 assertEquals("generated.model.group1", genClass.getPackag().toString());
191 genClass.accept(new GenClassVisitor() {
192
193 @Override
194 public void handle(final GenInterfaceClass interfaceClass) {
195 assertEquals(0, interfaceClass.getOperations().size());
196
197 interfaceClass.accept(new GenInterfaceClassVisitor() {
198
199 @Override
200 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
201 final Set<String> operations = new HashSet<>();
202 operations.add("private generated.model.group1.class1 $getThis()");
203 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
204 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
205 + " get$generatedObjects()");
206 final Set<String> attributes = new HashSet<>();
207 attributes.add("private generated.model.group1.class1 This");
208 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
209 final Set<String> modifiers = new HashSet<>();
210 final Set<String> implement = new HashSet<>();
211 implement.add("generated.model.group1.class1");
212 assertEquals(true, TestClassTransformer.controlImplClass(
213 interfaceWithImplClass,
214 "class1",
215 "generated.model.group1",
216 operations,
217 attributes,
218 modifiers,
219 implement));
220 }
221
222 @Override
223 public void handle(final GenSimpleInterfaceClass simpleInterface) {
224 fail();
225 }
226
227 @Override
228 public void handle(final GenExternalInterfaceClass iface) {
229 fail();
230 }
231 });
232 }
233
234 @Override
235 public void handle(final GenClassClass classClass) {
236 fail();
237 }
238
239 @Override
240 public void handle(final GenPrimitiveClass primitiveClass) {
241 fail();
242 }
243 });
244 break;
245 }
246
247 } else {
248 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getFullyQualifiedTypeName());
249 }
250
251 }
252 if (expectedClasses.size() != 0) {
253 fail("Klasse erwartet, aber nicht gefunden");
254 }
255 }
256
257 @Test
258 public void testClassWith3AttributesAndOperationWithParameterAndStringReturntype() throws Exception {
259 final GeneratorModel javaGeneratorModel =
260 this.generate(TestModels.classWith3AttributesAndOperationWithParameterAndStringReturntype);
261
262 final Set<String> expectedClasses = new HashSet<>();
263 expectedClasses.add("generated.sums.Anything");
264 expectedClasses.add("generated.model.group1.class1");
265 expectedClasses.add("generated.products.Product$0param1€0String€_param2€0Integer$0$");
266 expectedClasses.add("generated.products.Product$0p$1€0String€_p$2€0Integer$0$");
267 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
268 expectedClasses.add(product0);
269 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
270 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
271 while (i.hasNext()) {
272 final GenClass genClass = i.next();
273 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
274 switch (genClass.getName()) {
275 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
276 break;
277 case "class1":
278 assertEquals("generated.model.group1", genClass.getPackag().toString());
279 genClass.accept(new GenClassVisitor() {
280
281 @Override
282 public void handle(final GenInterfaceClass interfaceClass) {
283 assertEquals(0, interfaceClass.getOperations().size());
284
285 interfaceClass.accept(new GenInterfaceClassVisitor() {
286
287 @Override
288 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
289 final Set<String> operations = new HashSet<>();
290 operations.add("private generated.model.group1.class1 $getThis()");
291 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
292 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
293 + " get$generatedObjects()");
294 final Set<String> attributes = new HashSet<>();
295 attributes.add("private generated.model.group1.class1 This");
296 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
297 final Set<String> modifiers = new HashSet<>();
298 final Set<String> implement = new HashSet<>();
299 implement.add("generated.model.group1.class1");
300 assertEquals(true, TestClassTransformer.controlImplClass(
301 interfaceWithImplClass,
302 "class1",
303 "generated.model.group1",
304 operations,
305 attributes,
306 modifiers,
307 implement));
308 }
309
310 @Override
311 public void handle(final GenSimpleInterfaceClass simpleInterface) {
312 fail();
313 }
314
315 @Override
316 public void handle(final GenExternalInterfaceClass iface) {
317 fail();
318 }
319 });
320 }
321
322 @Override
323 public void handle(final GenClassClass classClass) {
324 fail();
325 }
326
327 @Override
328 public void handle(final GenPrimitiveClass primitiveClass) {
329 fail();
330 }
331 });
332 break;
333 }
334
335 } else {
336 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getFullyQualifiedTypeName());
337 }
338
339 }
340 if (expectedClasses.size() != 0) {
341 fail("Klasse erwartet, aber nicht gefunden");
342 }
343 }
344
345 @Test
346 public void testClassWithMapAttributeStringToInteger() throws Exception {
347 final GeneratorModel javaGeneratorModel = this.generate(TestModels.classWithMapAttributeStringToInteger);
348
349 final Set<String> expectedClasses = new HashSet<>();
350 expectedClasses.add("generated.sums.Anything");
351 expectedClasses.add("generated.model.group1.class1");
352 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
353 expectedClasses.add(product0);
354 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
355 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
356 while (i.hasNext()) {
357 final GenClass genClass = i.next();
358 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
359 switch (genClass.getName()) {
360
361 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
362 break;
363 case "class1":
364 assertEquals("generated.model.group1", genClass.getPackag().toString());
365 genClass.accept(new GenClassVisitor() {
366
367 @Override
368 public void handle(final GenInterfaceClass interfaceClass) {
369 assertEquals(0, interfaceClass.getOperations().size());
370
371 interfaceClass.accept(new GenInterfaceClassVisitor() {
372
373 @Override
374 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
375 final Set<String> operations = new HashSet<>();
376 operations.add("private generated.model.group1.class1 $getThis()");
377 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
378 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
379 + " get$generatedObjects()");
380 final Set<String> attributes = new HashSet<>();
381 attributes.add("private generated.model.group1.class1 This");
382 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
383 final Set<String> modifiers = new HashSet<>();
384 final Set<String> implement = new HashSet<>();
385 implement.add("generated.model.group1.class1");
386 assertEquals(true, TestClassTransformer.controlImplClass(
387 interfaceWithImplClass,
388 "class1",
389 "generated.model.group1",
390 operations,
391 attributes,
392 modifiers,
393 implement));
394 }
395
396 @Override
397 public void handle(final GenSimpleInterfaceClass simpleInterface) {
398 fail();
399 }
400
401 @Override
402 public void handle(final GenExternalInterfaceClass iface) {
403 fail();
404 }
405 });
406 }
407
408 @Override
409 public void handle(final GenClassClass classClass) {
410 fail();
411 }
412
413 @Override
414 public void handle(final GenPrimitiveClass primitiveClass) {
415 fail();
416 }
417 });
418 break;
419 }
420
421 } else {
422 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getFullyQualifiedTypeName());
423 }
424
425 }
426 if (expectedClasses.size() != 0) {
427 fail("Klasse erwartet, aber nicht gefunden");
428 }
429 }
430
431 @Test
432 public void testClassWithProductAttributeOnlyBasetypesInTheProduct() throws Exception {
433 final GeneratorModel javaGeneratorModel =
434 this.generate(TestModels.classWithProductAttributeOnlyBasetypesInTheProduct);
435
436 final Set<String> expectedClasses = new HashSet<>();
437 expectedClasses.add("generated.sums.Anything");
438 expectedClasses.add("generated.model.group1.class1");
439 expectedClasses.add("generated.products.Product$0param1€0Integer€_param2€0String€_param3€0Integer$0$");
440 expectedClasses.add("generated.products.Product$0p$1€0Integer€_p$2€0String€_p$3€0Integer$0$");
441 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
442 expectedClasses.add(product0);
443 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
444 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
445 while (i.hasNext()) {
446 final GenClass genClass = i.next();
447 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
448 switch (genClass.getName()) {
449 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
450 break;
451 case "class1":
452 assertEquals("generated.model.group1", genClass.getPackag().toString());
453 genClass.accept(new GenClassVisitor() {
454
455 @Override
456 public void handle(final GenInterfaceClass interfaceClass) {
457 assertEquals(0, interfaceClass.getOperations().size());
458
459 interfaceClass.accept(new GenInterfaceClassVisitor() {
460
461 @Override
462 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
463 final Set<String> operations = new HashSet<>();
464 operations.add("private generated.model.group1.class1 $getThis()");
465 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
466 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
467 + " get$generatedObjects()");
468 final Set<String> attributes = new HashSet<>();
469 attributes.add("private generated.model.group1.class1 This");
470 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
471 final Set<String> modifiers = new HashSet<>();
472 final Set<String> implement = new HashSet<>();
473 implement.add("generated.model.group1.class1");
474 assertEquals(true, TestClassTransformer.controlImplClass(
475 interfaceWithImplClass,
476 "class1",
477 "generated.model.group1",
478 operations,
479 attributes,
480 modifiers,
481 implement));
482 }
483
484 @Override
485 public void handle(final GenSimpleInterfaceClass simpleInterface) {
486 fail();
487 }
488
489 @Override
490 public void handle(final GenExternalInterfaceClass iface) {
491 fail();
492 }
493 });
494 }
495
496 @Override
497 public void handle(final GenClassClass classClass) {
498 fail();
499 }
500
501 @Override
502 public void handle(final GenPrimitiveClass primitiveClass) {
503 fail();
504 }
505 });
506 break;
507
508 }
509
510 } else {
511 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getFullyQualifiedTypeName());
512 }
513
514 }
515 if (expectedClasses.size() != 0) {
516 fail("Klasse erwartet, aber nicht gefunden");
517 }
518 }
519
520 @Test
521 public void testClassWithSumAttributeOnlyBasetypesInTheSum() throws Exception {
522 final GeneratorModel javaGeneratorModel = this.generate(TestModels.classWithSumAttributeOnlyBasetypesInTheSum);
523
524 final Set<String> expectedClasses = new HashSet<>();
525 expectedClasses.add("generated.sums.Anything");
526 expectedClasses.add("generated.model.group1.class1");
527 expectedClasses.add("generated.sums.Sum$0Integer€_String$0$");
528 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
529 expectedClasses.add(product0);
530 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
531 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
532 while (i.hasNext()) {
533 final GenClass genClass = i.next();
534 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
535 switch (genClass.getName()) {
536
537 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
538 break;
539 case "class1":
540 assertEquals("generated.model.group1", genClass.getPackag().toString());
541 genClass.accept(new GenClassVisitor() {
542
543 @Override
544 public void handle(final GenInterfaceClass interfaceClass) {
545 assertEquals(0, interfaceClass.getOperations().size());
546
547 interfaceClass.accept(new GenInterfaceClassVisitor() {
548
549 @Override
550 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
551 final Set<String> operations = new HashSet<>();
552 operations.add("private generated.model.group1.class1 $getThis()");
553 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
554 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
555 + " get$generatedObjects()");
556 final Set<String> attributes = new HashSet<>();
557 attributes.add("private generated.model.group1.class1 This");
558 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
559 final Set<String> modifiers = new HashSet<>();
560 final Set<String> implement = new HashSet<>();
561 implement.add("generated.model.group1.class1");
562 assertEquals(true, TestClassTransformer.controlImplClass(
563 interfaceWithImplClass,
564 "class1",
565 "generated.model.group1",
566 operations,
567 attributes,
568 modifiers,
569 implement));
570 }
571
572 @Override
573 public void handle(final GenSimpleInterfaceClass simpleInterface) {
574 fail();
575 }
576
577 @Override
578 public void handle(final GenExternalInterfaceClass iface) {
579 fail();
580 }
581 });
582 }
583
584 @Override
585 public void handle(final GenClassClass classClass) {
586 fail();
587 }
588
589 @Override
590 public void handle(final GenPrimitiveClass primitiveClass) {
591 fail();
592 }
593 });
594 break;
595 }
596
597 } else {
598 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getFullyQualifiedTypeName());
599 }
600
601 }
602 if (expectedClasses.size() != 0) {
603 fail("Klasse erwartet, aber nicht gefunden");
604 }
605 }
606
607 @Test
608 public void testClassWithVoidOperation() throws Exception {
609 final GeneratorModel javaGeneratorModel = this.generate(TestModels.classWithVoidOperation);
610
611 final Set<String> expectedClasses = new HashSet<>();
612 expectedClasses.add("generated.sums.Anything");
613 expectedClasses.add("generated.model.group1.class1");
614 expectedClasses.add("generated.products.Product$0$0$");
615
616 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
617 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
618 while (i.hasNext()) {
619 final GenClass genClass = i.next();
620 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
621 switch (genClass.getName()) {
622 case "class1":
623 assertEquals("generated.model.group1", genClass.getPackag().toString());
624 genClass.accept(new GenClassVisitor() {
625
626 @Override
627 public void handle(final GenInterfaceClass interfaceClass) {
628 assertEquals(0, interfaceClass.getOperations().size());
629
630 interfaceClass.accept(new GenInterfaceClassVisitor() {
631
632 @Override
633 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
634 final Set<String> operations = new HashSet<>();
635 operations.add("private generated.model.group1.class1 $getThis()");
636 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
637 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
638 + " get$generatedObjects()");
639 final Set<String> attributes = new HashSet<>();
640 attributes.add("private generated.model.group1.class1 This");
641 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
642 final Set<String> modifiers = new HashSet<>();
643 final Set<String> implement = new HashSet<>();
644 implement.add("generated.model.group1.class1");
645 assertEquals(true, TestClassTransformer.controlImplClass(
646 interfaceWithImplClass,
647 "class1",
648 "generated.model.group1",
649 operations,
650 attributes,
651 modifiers,
652 implement));
653 }
654
655 @Override
656 public void handle(final GenSimpleInterfaceClass simpleInterface) {
657 fail();
658 }
659
660 @Override
661 public void handle(final GenExternalInterfaceClass iface) {
662 fail();
663 }
664 });
665 }
666
667 @Override
668 public void handle(final GenClassClass classClass) {
669 fail();
670 }
671
672 @Override
673 public void handle(final GenPrimitiveClass primitiveClass) {
674 fail();
675 }
676 });
677 break;
678 }
679
680 } else {
681 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getFullyQualifiedTypeName());
682 }
683
684 }
685 if (expectedClasses.size() != 0) {
686 fail("Klasse erwartet, aber nicht gefunden");
687 }
688 }
689
690 @Test
691 public void testException() throws Exception {
692 final GeneratorModel javaGeneratorModel = this.generate(TestModels.exception);
693
694 final Set<String> expectedClasses = new HashSet<>();
695 expectedClasses.add("generated.sums.Anything");
696 expectedClasses.add("generated.model.group1.testException");
697 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
698 expectedClasses.add(product0);
699
700 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
701 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
702 while (i.hasNext()) {
703 final GenClass genClass = i.next();
704 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
705 switch (genClass.getName()) {
706 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
707 break;
708 case "testException":
709 assertEquals("generated.model.group1", genClass.getPackag().toString());
710 genClass.accept(new GenClassVisitor() {
711
712 @Override
713 public void handle(final GenInterfaceClass interfaceClass) {
714 fail();
715 }
716
717 @Override
718 public void handle(final GenClassClass classClass) {
719 classClass.accept(new GenClassClassVisitor() {
720
721 @Override
722 public void handle(final GenAspect aspect) {
723 fail();
724 }
725
726 @Override
727 public void handle(final GenUserClass userclass) {
728 fail();
729 }
730
731 @Override
732 public void handle(final GenJavaException javaE) {
733 fail();
734 }
735
736 @Override
737 public void handle(final GenAnyType anyType) {
738 fail();
739 }
740
741 @Override
742 public void handle(final GenException e) {
743 Assert.assertTrue(e.getOperations().isEmpty());
744 Assert.assertTrue(e.getAttributes().isEmpty());
745 Assert.assertTrue(e.getModifieres().isEmpty());
746 }
747
748 @Override
749 public void handle(final GenExternalClassClass externalClass) {
750 fail();
751 }
752 });
753
754 }
755
756 @Override
757 public void handle(final GenPrimitiveClass primitiveClass) {
758 fail();
759 }
760 });
761 break;
762 }
763
764 } else {
765 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getFullyQualifiedTypeName());
766 }
767
768 }
769 if (expectedClasses.size() > 0) {
770 String notFoundClasses = "";
771 for (final String classNotFound : expectedClasses) {
772 notFoundClasses += ", " + classNotFound;
773 }
774 fail("Klasse(n) erwartet, aber nicht gefunden: <" + notFoundClasses + ">");
775 }
776 }
777
778 @Test
779 public void testClassWithOperationWithSumAsReturnType() throws Exception {
780 final GeneratorModel javaGeneratorModel = this.generate(TestModels.classWithOperationWithSumAsReturnType);
781
782 final Set<String> expectedClasses = new HashSet<>();
783 expectedClasses.add("generated.sums.Anything");
784 expectedClasses.add("generated.model.de.fhdw.Person");
785 expectedClasses.add("generated.model.de.fhdw.SteuerID");
786 expectedClasses.add("generated.model.de.fhdw.StID");
787 expectedClasses.add("generated.products.Product$0name€0String$0$");
788 expectedClasses.add("generated.products.Product$0p$1€0String$0$");
789 expectedClasses.add("generated.sums.Sum$0StID€_SteuerID$0$");
790 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
791 expectedClasses.add(product0);
792 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
793 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
794 while (i.hasNext()) {
795 final GenClass genClass = i.next();
796 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
797 switch (genClass.getName()) {
798
799 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
800 break;
801 case "Person":
802 assertEquals("generated.model.de.fhdw", genClass.getPackag().toString());
803 genClass.accept(new GenClassVisitor() {
804
805 @Override
806 public void handle(final GenInterfaceClass interfaceClass) {
807 assertEquals(0, interfaceClass.getOperations().size());
808
809 interfaceClass.accept(new GenInterfaceClassVisitor() {
810
811 @Override
812 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
813 final Set<String> operations = new HashSet<>();
814 operations.add("private generated.model.de.fhdw.Person $getThis()");
815 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
816 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
817 + " get$generatedObjects()");
818 final Set<String> attributes = new HashSet<>();
819 attributes.add("private generated.model.de.fhdw.Person This");
820 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
821 final Set<String> modifiers = new HashSet<>();
822 final Set<String> implement = new HashSet<>();
823 implement.add("generated.model.de.fhdw.Person");
824 assertEquals(true, TestClassTransformer.controlImplClass(
825 interfaceWithImplClass,
826 "Person",
827 "generated.model.de.fhdw",
828 operations,
829 attributes,
830 modifiers,
831 implement));
832
833 }
834
835 @Override
836 public void handle(final GenSimpleInterfaceClass simpleInterface) {
837 fail();
838 }
839
840 @Override
841 public void handle(final GenExternalInterfaceClass iface) {
842 fail();
843 }
844 });
845 }
846
847 @Override
848 public void handle(final GenClassClass classClass) {
849 fail();
850 }
851
852 @Override
853 public void handle(final GenPrimitiveClass primitiveClass) {
854 fail();
855 }
856 });
857
858 break;
859 case "SteuerID":
860 assertEquals("generated.model.de.fhdw", genClass.getPackag().toString());
861 genClass.accept(new GenClassVisitor() {
862
863 @Override
864 public void handle(final GenInterfaceClass interfaceClass) {
865 assertEquals(0, interfaceClass.getOperations().size());
866
867 interfaceClass.accept(new GenInterfaceClassVisitor() {
868
869 @Override
870 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
871
872 final Set<String> operations = new HashSet<>();
873 operations.add("private generated.model.de.fhdw.SteuerID $getThis()");
874 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
875 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
876 + " get$generatedObjects()");
877 final Set<String> attributes = new HashSet<>();
878 attributes.add("private generated.model.de.fhdw.SteuerID This");
879 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
880 final Set<String> modifiers = new HashSet<>();
881 final Set<String> implement = new HashSet<>();
882 implement.add("generated.model.de.fhdw.SteuerID");
883 assertEquals(true, TestClassTransformer.controlImplClass(
884 interfaceWithImplClass,
885 "SteuerID",
886 "generated.model.de.fhdw",
887 operations,
888 attributes,
889 modifiers,
890 implement));
891
892 }
893
894 @Override
895 public void handle(final GenSimpleInterfaceClass simpleInterface) {
896 fail();
897 }
898
899 @Override
900 public void handle(final GenExternalInterfaceClass iface) {
901 fail();
902 }
903 });
904 }
905
906 @Override
907 public void handle(final GenClassClass classClass) {
908 fail();
909 }
910
911 @Override
912 public void handle(final GenPrimitiveClass primitiveClass) {
913 fail();
914 }
915 });
916 break;
917 case "StID":
918 assertEquals("generated.model.de.fhdw", genClass.getPackag().toString());
919 genClass.accept(new GenClassVisitor() {
920
921 @Override
922 public void handle(final GenInterfaceClass interfaceClass) {
923 assertEquals(0, interfaceClass.getOperations().size());
924
925 interfaceClass.accept(new GenInterfaceClassVisitor() {
926
927 @Override
928 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
929 final Set<String> operations = new HashSet<>();
930 operations.add("private generated.model.de.fhdw.StID $getThis()");
931 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
932 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
933 + " get$generatedObjects()");
934 final Set<String> attributes = new HashSet<>();
935 attributes.add("private generated.model.de.fhdw.StID This");
936 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
937 final Set<String> modifiers = new HashSet<>();
938 final Set<String> implement = new HashSet<>();
939 implement.add("generated.model.de.fhdw.StID");
940 assertEquals(true, TestClassTransformer.controlImplClass(
941 interfaceWithImplClass,
942 "StID",
943 "generated.model.de.fhdw",
944 operations,
945 attributes,
946 modifiers,
947 implement));
948
949 }
950
951 @Override
952 public void handle(final GenSimpleInterfaceClass simpleInterface) {
953 fail();
954 }
955
956 @Override
957 public void handle(final GenExternalInterfaceClass iface) {
958 fail();
959 }
960 });
961 }
962
963 @Override
964 public void handle(final GenClassClass classClass) {
965 fail();
966 }
967
968 @Override
969 public void handle(final GenPrimitiveClass primitiveClass) {
970 fail();
971 }
972 });
973 break;
974 }
975
976 } else {
977 fail("Klasse gefunden, die aber nicht erwartet wird.");
978 }
979 }
980 if (expectedClasses.size() != 0) {
981 fail("Klasse erwartet, aber nicht gefunden");
982 }
983
984 }
985
986 @Test
987 public void testClassAsInterface() throws Exception {
988 final GeneratorModel javaGeneratorModel = this.generate(TestModels.classAsInterface);
989
990 final Set<String> expectedClasses = new HashSet<>();
991 expectedClasses.add("generated.sums.Anything");
992 expectedClasses.add("generated.model.group1.TestInterface");
993 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
994 expectedClasses.add(product0);
995 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
996 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
997 while (i.hasNext()) {
998 final GenClass genClass = i.next();
999 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
1000 switch (genClass.getName()) {
1001 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
1002 break;
1003 case "TestInterface":
1004 assertEquals("generated.model.group1", genClass.getPackag().toString());
1005 genClass.accept(new GenClassVisitor() {
1006
1007 @Override
1008 public void handle(final GenInterfaceClass interfaceClass) {
1009 assertEquals(0, interfaceClass.getOperations().size());
1010 }
1011
1012 @Override
1013 public void handle(final GenClassClass classClass) {
1014 fail();
1015 }
1016
1017 @Override
1018 public void handle(final GenPrimitiveClass primitiveClass) {
1019 fail();
1020 }
1021 });
1022 break;
1023 }
1024
1025 } else {
1026 fail("Klasse gefunden, die aber nicht erwartet wird.");
1027 }
1028 }
1029 if (expectedClasses.size() != 0) {
1030 fail("Klasse erwartet, aber nicht gefunden");
1031 }
1032
1033 }
1034
1035 @Test
1036 public void testClassAsInterfaceWithAbstractOperations() throws Exception {
1037 final GeneratorModel javaGeneratorModel = this.generate(TestModels.classAsInterfaceWithAbstractOperations);
1038
1039 final Set<String> expectedClasses = new HashSet<>();
1040 expectedClasses.add("generated.sums.Anything");
1041 expectedClasses.add("generated.model.group1.TestInterface");
1042 expectedClasses.add("generated.products.Product$0name€0String$0$");
1043 expectedClasses.add("generated.products.Product$0p$1€0String$0$");
1044 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
1045 expectedClasses.add(product0);
1046 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
1047 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
1048 while (i.hasNext()) {
1049 final GenClass genClass = i.next();
1050 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
1051 switch (genClass.getName()) {
1052 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
1053 break;
1054 case "TestInterface":
1055 assertEquals("generated.model.group1", genClass.getPackag().toString());
1056 genClass.accept(new GenClassVisitor() {
1057
1058 @Override
1059 public void handle(final GenInterfaceClass interfaceClass) {
1060 assertEquals(0, interfaceClass.getOperations().size());
1061 }
1062
1063 @Override
1064 public void handle(final GenClassClass classClass) {
1065 fail();
1066 }
1067
1068 @Override
1069 public void handle(final GenPrimitiveClass primitiveClass) {
1070 fail();
1071 }
1072 });
1073 break;
1074 }
1075
1076 } else {
1077 fail("Klasse gefunden, die aber nicht erwartet wird.");
1078 }
1079 }
1080 if (expectedClasses.size() != 0) {
1081 fail("Klasse erwartet, aber nicht gefunden");
1082 }
1083
1084 }
1085
1086 @Test
1087 public void testClassAsInterfaceWithInterfaceSupertype() throws Exception {
1088 final GeneratorModel javaGeneratorModel = this.generate(TestModels.classAsInterfaceWithInterfaceSupertype);
1089
1090 final Set<String> expectedClasses = new HashSet<>();
1091 expectedClasses.add("generated.sums.Anything");
1092 expectedClasses.add("generated.model.group1.TestInterface");
1093 expectedClasses.add("generated.model.group1.TestInterfaceSuper");
1094 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
1095 expectedClasses.add(product0);
1096
1097 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
1098 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
1099 while (i.hasNext()) {
1100 final GenClass genClass = i.next();
1101 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
1102 switch (genClass.getName()) {
1103
1104 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
1105 break;
1106 case "TestInterface":
1107 assertEquals("generated.model.group1", genClass.getPackag().toString());
1108 genClass.accept(new GenClassVisitor() {
1109
1110 @Override
1111 public void handle(final GenInterfaceClass interfaceClass) {
1112 assertEquals(0, interfaceClass.getOperations().size());
1113 }
1114
1115 @Override
1116 public void handle(final GenClassClass classClass) {
1117 fail();
1118 }
1119
1120 @Override
1121 public void handle(final GenPrimitiveClass primitiveClass) {
1122 fail();
1123 }
1124 });
1125 break;
1126 case "TestInterfaceSuper":
1127 assertEquals("generated.model.group1", genClass.getPackag().toString());
1128 genClass.accept(new GenClassVisitor() {
1129
1130 @Override
1131 public void handle(final GenInterfaceClass interfaceClass) {
1132 assertEquals(0, interfaceClass.getOperations().size());
1133 }
1134
1135 @Override
1136 public void handle(final GenClassClass classClass) {
1137 fail();
1138 }
1139
1140 @Override
1141 public void handle(final GenPrimitiveClass primitiveClass) {
1142 fail();
1143 }
1144 });
1145 break;
1146 }
1147
1148 } else {
1149 fail("Klasse gefunden, die aber nicht erwartet wird.");
1150 }
1151 }
1152 if (expectedClasses.size() != 0) {
1153 fail("Klasse erwartet, aber nicht gefunden");
1154 }
1155
1156 }
1157
1158 @Test
1159 public void testClassNoInterfaceBecauseOfSupertype() throws Exception {
1160 final GeneratorModel javaGeneratorModel = this.generate(TestModels.classNoInterfaceBecauseOfSupertype);
1161
1162 final Set<String> expectedClasses = new HashSet<>();
1163 expectedClasses.add("generated.sums.Anything");
1164 expectedClasses.add("generated.model.group1.TestInterface");
1165 expectedClasses.add("generated.model.group1.TestInterfaceSuper");
1166 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
1167 expectedClasses.add(product0);
1168
1169 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
1170 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
1171 while (i.hasNext()) {
1172 final GenClass genClass = i.next();
1173 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
1174 switch (genClass.getName()) {
1175 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
1176 break;
1177 case "TestInterface":
1178 assertEquals("generated.model.group1", genClass.getPackag().toString());
1179 genClass.accept(new GenClassVisitor() {
1180
1181 @Override
1182 public void handle(final GenInterfaceClass interfaceClass) {
1183 assertEquals(0, interfaceClass.getOperations().size());
1184
1185 interfaceClass.accept(new GenInterfaceClassVisitor() {
1186
1187 @Override
1188 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
1189 final Set<String> operations = new HashSet<>();
1190 operations.add("private generated.model.group1.TestInterface $getThis()");
1191 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
1192 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
1193 + " get$generatedObjects()");
1194 final Set<String> attributes = new HashSet<>();
1195 attributes.add("private generated.model.group1.TestInterface This");
1196 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
1197 final Set<String> modifiers = new HashSet<>();
1198 final Set<String> implement = new HashSet<>();
1199 implement.add("generated.model.group1.TestInterface");
1200 assertEquals(true, TestClassTransformer.controlImplClass(
1201 interfaceWithImplClass,
1202 "TestInterface",
1203 "generated.model.group1",
1204 operations,
1205 attributes,
1206 modifiers,
1207 implement));
1208
1209 }
1210
1211 @Override
1212 public void handle(final GenSimpleInterfaceClass simpleInterface) {
1213 fail();
1214 }
1215
1216 @Override
1217 public void handle(final GenExternalInterfaceClass iface) {
1218 fail();
1219 }
1220 });
1221 }
1222
1223 @Override
1224 public void handle(final GenClassClass classClass) {
1225 fail();
1226 }
1227
1228 @Override
1229 public void handle(final GenPrimitiveClass primitiveClass) {
1230 fail();
1231 }
1232 });
1233 break;
1234 case "TestInterfaceSuper":
1235 assertEquals("generated.model.group1", genClass.getPackag().toString());
1236 genClass.accept(new GenClassVisitor() {
1237
1238 @Override
1239 public void handle(final GenInterfaceClass interfaceClass) {
1240 assertEquals(0, interfaceClass.getOperations().size());
1241
1242 interfaceClass.accept(new GenInterfaceClassVisitor() {
1243
1244 @Override
1245 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
1246 final Set<String> operations = new HashSet<>();
1247 operations.add("private generated.model.group1.TestInterfaceSuper $getThis()");
1248 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
1249 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
1250 + " get$generatedObjects()");
1251 final Set<String> attributes = new HashSet<>();
1252 attributes.add("private generated.model.group1.TestInterfaceSuper This");
1253 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
1254 final Set<String> modifiers = new HashSet<>();
1255 final Set<String> implement = new HashSet<>();
1256 implement.add("generated.model.group1.TestInterfaceSuper");
1257 assertEquals(true, TestClassTransformer.controlImplClass(
1258 interfaceWithImplClass,
1259 "TestInterfaceSuper",
1260 "generated.model.group1",
1261 operations,
1262 attributes,
1263 modifiers,
1264 implement));
1265
1266 }
1267
1268 @Override
1269 public void handle(final GenSimpleInterfaceClass simpleInterface) {
1270 fail();
1271 }
1272
1273 @Override
1274 public void handle(final GenExternalInterfaceClass iface) {
1275 fail();
1276 }
1277 });
1278 }
1279
1280 @Override
1281 public void handle(final GenClassClass classClass) {
1282 fail();
1283 }
1284
1285 @Override
1286 public void handle(final GenPrimitiveClass primitiveClass) {
1287 fail();
1288 }
1289 });
1290 break;
1291 }
1292
1293 } else {
1294 fail("Klasse gefunden, die aber nicht erwartet wird.");
1295 }
1296 }
1297 if (expectedClasses.size() != 0) {
1298 fail("Klasse erwartet, aber nicht gefunden");
1299 }
1300
1301 }
1302
1303 @Test
1304 public void testClassNoInterfaceBecauseOfNotAbstractOperation() throws Exception {
1305 final GeneratorModel javaGeneratorModel =
1306 this.generate(TestModels.classNoInterfaceBecauseOfNotAbstractOperation);
1307
1308 final Set<String> expectedClasses = new HashSet<>();
1309 expectedClasses.add("generated.sums.Anything");
1310 expectedClasses.add("generated.model.group1.TestInterface");
1311 expectedClasses.add("generated.products.Product$0name€0String$0$");
1312 expectedClasses.add("generated.products.Product$0p$1€0String$0$");
1313 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
1314 expectedClasses.add(product0);
1315
1316 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
1317 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
1318 while (i.hasNext()) {
1319 final GenClass genClass = i.next();
1320 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
1321 switch (genClass.getName()) {
1322
1323 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
1324 break;
1325
1326 case "TestInterface":
1327 assertEquals("generated.model.group1", genClass.getPackag().toString());
1328 genClass.accept(new GenClassVisitor() {
1329
1330 @Override
1331 public void handle(final GenInterfaceClass interfaceClass) {
1332 assertEquals(0, interfaceClass.getOperations().size());
1333
1334 interfaceClass.accept(new GenInterfaceClassVisitor() {
1335
1336 @Override
1337 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
1338 final Set<String> operations = new HashSet<>();
1339 operations.add("private generated.model.group1.TestInterface $getThis()");
1340 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
1341 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
1342 + " get$generatedObjects()");
1343 final HashSet<String> attributes = new HashSet<>();
1344 attributes.add("private generated.model.group1.TestInterface This");
1345 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
1346 final Set<String> modifiers = new HashSet<>();
1347 final Set<String> implement = new HashSet<>();
1348 implement.add("generated.model.group1.TestInterface");
1349 assertEquals(true, TestClassTransformer.controlImplClass(
1350 interfaceWithImplClass,
1351 "TestInterface",
1352 "generated.model.group1",
1353 operations,
1354 attributes,
1355 modifiers,
1356 implement));
1357
1358 }
1359
1360 @Override
1361 public void handle(final GenSimpleInterfaceClass simpleInterface) {
1362 fail();
1363 }
1364
1365 @Override
1366 public void handle(final GenExternalInterfaceClass iface) {
1367 fail();
1368 }
1369 });
1370 }
1371
1372 @Override
1373 public void handle(final GenClassClass classClass) {
1374 fail();
1375 }
1376
1377 @Override
1378 public void handle(final GenPrimitiveClass primitiveClass) {
1379 fail();
1380 }
1381 });
1382 break;
1383 }
1384
1385 } else {
1386 fail("Klasse gefunden, die aber nicht erwartet wird.");
1387 }
1388 }
1389 if (expectedClasses.size() != 0) {
1390 fail("Klasse erwartet, aber nicht gefunden");
1391 }
1392
1393 }
1394 }