1 package transformers.test;
2
3 import static org.junit.Assert.assertEquals;
4 import static org.junit.Assert.fail;
5
6 import java.io.File;
7 import java.io.IOException;
8 import java.util.Collection;
9 import java.util.HashSet;
10 import java.util.Iterator;
11 import java.util.Set;
12 import java.util.Vector;
13 import java.util.concurrent.ExecutionException;
14
15 import org.junit.Ignore;
16 import org.junit.Test;
17
18 import common.TestConstants;
19 import common.TestModels;
20 import common.TestUtil;
21
22 import de.fhdw.wtf.common.ast.Model;
23 import de.fhdw.wtf.common.ast.type.ExceptionClassType;
24 import de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException;
25 import de.fhdw.wtf.common.exception.walker.CyclicDependencyException;
26 import de.fhdw.wtf.common.stream.FilteredTokenStream;
27 import de.fhdw.wtf.common.stream.ScannerInputStream;
28 import de.fhdw.wtf.common.task.DependencyTask;
29 import de.fhdw.wtf.common.task.TaskExecutorFixed;
30 import de.fhdw.wtf.dsl.scanner.common.Scanner;
31 import de.fhdw.wtf.dsl.scanner.modelScanner.ModelDslScanner;
32 import de.fhdw.wtf.facade.PackageConstants;
33 import de.fhdw.wtf.facade.TypeNameGenerator;
34 import de.fhdw.wtf.generator.java.generatorModel.GenAttributeModifier;
35 import de.fhdw.wtf.generator.java.generatorModel.GenClass;
36 import de.fhdw.wtf.generator.java.generatorModel.GenClassClass;
37 import de.fhdw.wtf.generator.java.generatorModel.GenCollectionType;
38 import de.fhdw.wtf.generator.java.generatorModel.GenDummyType;
39 import de.fhdw.wtf.generator.java.generatorModel.GenExternalInterfaceClass;
40 import de.fhdw.wtf.generator.java.generatorModel.GenImportType;
41 import de.fhdw.wtf.generator.java.generatorModel.GenInterfaceClass;
42 import de.fhdw.wtf.generator.java.generatorModel.GenInterfaceWithClassImplClass;
43 import de.fhdw.wtf.generator.java.generatorModel.GenJavaUtilCollection;
44 import de.fhdw.wtf.generator.java.generatorModel.GenMapType;
45 import de.fhdw.wtf.generator.java.generatorModel.GenMutableList;
46 import de.fhdw.wtf.generator.java.generatorModel.GenMutableMap;
47 import de.fhdw.wtf.generator.java.generatorModel.GenPrimitiveClass;
48 import de.fhdw.wtf.generator.java.generatorModel.GenPrimitiveType;
49 import de.fhdw.wtf.generator.java.generatorModel.GenSimpleInterfaceClass;
50 import de.fhdw.wtf.generator.java.generatorModel.GenType;
51 import de.fhdw.wtf.generator.java.generatorModel.GenUserClass;
52 import de.fhdw.wtf.generator.java.generatorModel.GeneratorModel;
53 import de.fhdw.wtf.generator.java.generatorModel.Generic;
54 import de.fhdw.wtf.generator.java.visitor.GenClassVisitor;
55 import de.fhdw.wtf.generator.java.visitor.GenCollectionTypeVisitor;
56 import de.fhdw.wtf.generator.java.visitor.GenInterfaceClassVisitor;
57 import de.fhdw.wtf.generator.java.visitor.GenTypeVisitor;
58 import de.fhdw.wtf.generator.transformer.transformers.classTransformer.OperationAttributeTransformer;
59 import de.fhdw.wtf.generator.transformer.transformers.classTransformer.TypeTransformer;
60 import de.fhdw.wtf.generator.transformer.util.Tuple;
61 import de.fhdw.wtf.generator.writer.writer.JavaClassFileWriter;
62 import de.fhdw.wtf.parser.Parser;
63 import de.fhdw.wtf.tooling.SyntaxCheck;
64 import de.fhdw.wtf.walker.tasks.TypeReferencer;
65
66
67
68
69
70
71 public class TestOperationAttributeTransformer {
72
73
74
75
76 private static final String ROOT_DIR = "src/fileWriter/javaClassFileWriterTest/gen/";
77
78 @Test
79 public void test() throws Exception {
80 Parser parser = null;
81 try {
82 final long start1 = System.currentTimeMillis();
83 final ScannerInputStream input = TestUtil.loadTestModel("Person");
84 final FilteredTokenStream output = FilteredTokenStream.create();
85 final Scanner scanner = ModelDslScanner.create();
86 scanner.scan(input, output);
87 final long start2 = System.currentTimeMillis();
88 parser = Parser.create(output);
89 final Model m = parser.parse();
90 SyntaxCheck.getInstance().checkModelGeneral(m);
91 final TaskExecutorFixed exec = TaskExecutorFixed.create();
92 final GeneratorModel f = new GeneratorModel();
93
94 final GeneratorModel javaGeneratorModel = GeneratorModel.create();
95 final TypeTransformer typeTransformer = new TypeTransformer(m, exec, javaGeneratorModel);
96 OperationAttributeTransformer.create(m, exec, javaGeneratorModel, typeTransformer);
97
98 final DependencyTask ref = TypeReferencer.create(m, exec);
99 typeTransformer.addDependency(ref);
100
101 final long start = System.currentTimeMillis();
102 exec.submit(ref);
103 exec.getResultsAndShutdown();
104 System.err.println("Dauer Scanner : " + (System.currentTimeMillis() - start1));
105 System.err.println("Dauer Parser : " + (System.currentTimeMillis() - start2));
106 System.err.println("Dauer Referencer + Generierung: " + (System.currentTimeMillis() - start));
107
108 final JavaClassFileWriter writer = new JavaClassFileWriter(true);
109
110 for (final GenClass c : f.getClassMapping().values()) {
111 writer.writeJavaClass((GenUserClass) c, new File(TestOperationAttributeTransformer.ROOT_DIR));
112 }
113
114 } catch (final IOException e) {
115 e.printStackTrace();
116 } catch (final NoValidTokenStreamException e) {
117 for (final Exception xe : parser.getExceptions()) {
118 xe.printStackTrace();
119 }
120 e.printStackTrace();
121 } catch (final InterruptedException e) {
122 e.printStackTrace();
123 } catch (final ExecutionException e) {
124 e.printStackTrace();
125 } catch (final CyclicDependencyException e) {
126 e.printStackTrace();
127 }
128
129 }
130
131
132
133
134
135
136 private GeneratorModel generate(final String input) throws Exception {
137
138 final Model model = SyntaxCheck.getInstance().getModelFromString(input);
139
140 final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
141 final GeneratorModel javaGeneratorModel = GeneratorModel.create();
142
143
144 final TypeTransformer typeTransformer = new TypeTransformer(model, taskmanager, javaGeneratorModel);
145 OperationAttributeTransformer.create(model, taskmanager, javaGeneratorModel, typeTransformer);
146
147 taskmanager.startAllKnownTasks();
148 taskmanager.getResultsAndShutdown();
149
150 return javaGeneratorModel;
151 }
152
153
154
155 @Test
156 @Ignore("doesnt work, anything type is not made")
157 public void testEmptyModel() throws Exception {
158 final GeneratorModel javaGeneratorModel = this.generate(TestModels.emptyModel);
159
160 final Collection<GenPrimitiveClass> baseClassesNotToGenerate =
161 javaGeneratorModel.getBaseClassMapping().values();
162 final Set<String> expectedBaseClassNames = new HashSet<>();
163 expectedBaseClassNames.addAll(TestUtil.getEverytimeExpectedClasses());
164 assertEquals(expectedBaseClassNames.size(), javaGeneratorModel.getClassMapping().size());
165 final Iterator<GenPrimitiveClass> iBaseClasses = baseClassesNotToGenerate.iterator();
166 while (iBaseClasses.hasNext()) {
167 final GenPrimitiveClass current = iBaseClasses.next();
168 expectedBaseClassNames.remove(current.getName());
169 }
170 assertEquals(0, expectedBaseClassNames.size());
171
172 final Collection<GenClass> classesToGenerate = javaGeneratorModel.getClassMapping().values();
173 final Set<String> expectedClassNames = TestUtil.getEverytimeExpectedClasses();
174 assertEquals(expectedClassNames.size(), javaGeneratorModel.getClassMapping().values().size());
175 final Iterator<GenClass> iClassesToGenerate = classesToGenerate.iterator();
176 while (iClassesToGenerate.hasNext()) {
177 final GenClass current = iClassesToGenerate.next();
178 expectedClassNames.remove(current.getName());
179 }
180 assertEquals(0, expectedClassNames.size());
181
182
183
184 }
185
186
187
188
189
190
191 @Test
192 public void testAbstractClassWithStringAttribute() throws Exception {
193 final GeneratorModel javaGeneratorModel = this.generate(TestModels.abstractClassWithStringAttribute);
194
195 final Set<String> expectedClasses = TestUtil.getEverytimeExpectedClasses();
196 expectedClasses.add("generated.model.group1.class1");
197 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
198 expectedClasses.add(product0);
199
200 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
201
202 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
203 while (i.hasNext()) {
204 final GenClass genClass = i.next();
205 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
206 switch (genClass.getName()) {
207 case "class1":
208 assertEquals("generated.model.group1", genClass.getPackag().toString());
209 genClass.accept(new GenClassVisitor() {
210
211 @Override
212 public void handle(final GenInterfaceClass interfaceClass) {
213 assertEquals(0, interfaceClass.getOperations().size());
214
215 interfaceClass.accept(new GenInterfaceClassVisitor() {
216
217 @Override
218 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
219
220 final Set<String> operations = new HashSet<>();
221 operations.add("private generated.model.group1.class1 $getThis()");
222 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
223 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
224 + " get$generatedObjects()");
225 final Set<String> attributes = new HashSet<>();
226 attributes.add("private de.fhdw.wtf.context.model.Str att1");
227 attributes.add("private generated.model.group1.class1 This");
228 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
229 final Set<String> modifiers = new HashSet<>();
230 final Set<String> implement = new HashSet<>();
231 implement.add("generated.model.group1.class1");
232 assertEquals(true, TestClassTransformer.controlImplClass(
233 interfaceWithImplClass,
234 "class1",
235 "generated.model.group1",
236 operations,
237 attributes,
238 modifiers,
239 implement));
240
241 }
242
243 @Override
244 public void handle(final GenSimpleInterfaceClass simpleInterface) {
245 fail();
246 }
247
248 @Override
249 public void handle(final GenExternalInterfaceClass iface) {
250 fail();
251 }
252 });
253 }
254
255 @Override
256 public void handle(final GenClassClass classClass) {
257 fail();
258 }
259
260 @Override
261 public void handle(final GenPrimitiveClass primitiveClass) {
262 fail();
263 }
264 });
265 break;
266 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
267 break;
268 case "Anything":
269 genClass.accept(new GenClassVisitor() {
270
271 @Override
272 public void handle(final GenInterfaceClass interfaceClass) {
273 assertEquals(0, interfaceClass.getOperations().size());
274 }
275
276 @Override
277 public void handle(final GenClassClass classClass) {
278 fail();
279 }
280
281 @Override
282 public void handle(final GenPrimitiveClass primitiveClass) {
283 fail();
284 }
285 });
286 break;
287 default:
288 fail("Klasse erwartet und gefunden, wird aber nicht überprüft " + genClass.getName());
289 break;
290 }
291
292 } else {
293 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getName());
294 }
295
296 }
297 if (expectedClasses.size() != 0) {
298 fail("Klasse erwartet, aber nicht gefunden");
299 }
300 final Set<String> expectedTypes = new HashSet<>();
301 expectedTypes.addAll(TestUtil.getEverytimeExpectedTypes());
302 expectedTypes.add("generated.model.group1.class1");
303 expectedTypes.add(product0);
304 assertEquals(expectedTypes.size(), javaGeneratorModel.getTypeMapping().size());
305
306 final Iterator<Tuple<GenType, Collection<ExceptionClassType>>> i2 =
307 javaGeneratorModel.getTypeMapping().values().iterator();
308 while (i2.hasNext()) {
309 final GenType genType = i2.next().getA();
310 if (expectedTypes.remove(genType.getFullyQualifiedTypeName())) {
311 switch (genType.getName()) {
312 case "class1":
313 genType.accept(new GenTypeVisitor() {
314
315 @Override
316 public void handle(final GenImportType importType) {
317 fail();
318 }
319
320 @Override
321 public void handle(final GenJavaUtilCollection javaUtilCollection) {
322 fail();
323 }
324
325 @Override
326 public void handle(final Generic generic) {
327 fail();
328 }
329
330 @Override
331 public void handle(final GenMapType mapType) {
332 fail();
333 }
334
335 @Override
336 public void handle(final GenPrimitiveType primitiveType) {
337 fail();
338 }
339
340 @Override
341 public void handle(final GenCollectionType collectionType) {
342 fail();
343 }
344
345 @Override
346 public void handle(final GenClass cla) {
347
348 }
349
350 @Override
351 public void handle(final GenDummyType dummy) {
352 fail();
353
354 }
355 });
356 break;
357 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
358 break;
359 case "Str":
360 genType.accept(new GenTypeVisitor() {
361
362 @Override
363 public void handle(final GenImportType importType) {
364 fail();
365 }
366
367 @Override
368 public void handle(final GenJavaUtilCollection javaUtilCollection) {
369 fail();
370 }
371
372 @Override
373 public void handle(final Generic generic) {
374 fail();
375 }
376
377 @Override
378 public void handle(final GenMapType mapType) {
379 fail();
380 }
381
382 @Override
383 public void handle(final GenPrimitiveType primitiveType) {
384
385 }
386
387 @Override
388 public void handle(final GenCollectionType collectionType) {
389 fail();
390 }
391
392 @Override
393 public void handle(final GenClass cla) {
394 fail();
395 }
396
397 @Override
398 public void handle(final GenDummyType dummy) {
399 fail();
400
401 }
402 });
403 break;
404 case "Int":
405 genType.accept(new GenTypeVisitor() {
406
407 @Override
408 public void handle(final GenImportType importType) {
409 fail();
410 }
411
412 @Override
413 public void handle(final GenJavaUtilCollection javaUtilCollection) {
414 fail();
415 }
416
417 @Override
418 public void handle(final Generic generic) {
419 fail();
420 }
421
422 @Override
423 public void handle(final GenMapType mapType) {
424 fail();
425 }
426
427 @Override
428 public void handle(final GenPrimitiveType primitiveType) {
429
430 }
431
432 @Override
433 public void handle(final GenCollectionType collectionType) {
434 fail();
435 }
436
437 @Override
438 public void handle(final GenClass cla) {
439 fail();
440 }
441
442 @Override
443 public void handle(final GenDummyType dummy) {
444 fail();
445
446 }
447 });
448 break;
449 case "Anything":
450 genType.accept(new GenTypeVisitor() {
451
452 @Override
453 public void handle(final GenImportType importType) {
454 fail();
455 }
456
457 @Override
458 public void handle(final GenJavaUtilCollection javaUtilCollection) {
459 fail();
460 }
461
462 @Override
463 public void handle(final Generic generic) {
464 fail();
465 }
466
467 @Override
468 public void handle(final GenMapType mapType) {
469 fail();
470 }
471
472 @Override
473 public void handle(final GenPrimitiveType primitiveType) {
474 fail();
475 }
476
477 @Override
478 public void handle(final GenCollectionType collectionType) {
479 fail();
480 }
481
482 @Override
483 public void handle(final GenClass cla) {
484
485 }
486
487 @Override
488 public void handle(final GenDummyType dummy) {
489 fail();
490
491 }
492 });
493 break;
494 default:
495 fail("Type erwartet und gefunden, wird aber nicht überprüft" + genType.getName());
496 break;
497 }
498
499 } else {
500 fail("Type gefunden, die aber nicht erwartet wird." + genType.getName());
501 }
502
503 }
504 if (expectedTypes.size() != 0) {
505 fail("Type erwartet, aber nicht gefunden");
506 }
507 }
508
509
510
511
512
513
514 @Test
515 public void testClassWithStringAttributeAndOperationWithoutParameterAndStringReturntype() throws Exception {
516 final GeneratorModel javaGeneratorModel =
517 this.generate(TestModels.classWithStringAttributeAndOperationWithoutParameterAndStringReturntype);
518
519 final Set<String> expectedClasses = TestUtil.getEverytimeExpectedClasses();
520 expectedClasses.addAll(TestUtil.getEverytimeExpectedClasses());
521 expectedClasses.add("generated.model.group1.class1");
522 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
523 expectedClasses.add(product0);
524 final String product = TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
525 expectedClasses.add("generated.products." + product);
526
527 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
528
529 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
530 while (i.hasNext()) {
531 final GenClass genClass = i.next();
532 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
533 switch (genClass.getName()) {
534
535 case "Anything":
536 genClass.accept(new GenClassVisitor() {
537
538 @Override
539 public void handle(final GenInterfaceClass interfaceClass) {
540 assertEquals(0, interfaceClass.getOperations().size());
541
542 }
543
544 @Override
545 public void handle(final GenClassClass classClass) {
546 fail();
547 }
548
549 @Override
550 public void handle(final GenPrimitiveClass primitiveClass) {
551 fail();
552 }
553 });
554 break;
555
556 case "class1":
557 assertEquals("generated.model.group1", genClass.getPackag().toString());
558 genClass.accept(new GenClassVisitor() {
559
560 @Override
561 public void handle(final GenInterfaceClass interfaceClass) {
562 assertEquals(1, interfaceClass.getOperations().size());
563 assertEquals("op1", interfaceClass.getOperations().iterator().next().getName());
564 interfaceClass.accept(new GenInterfaceClassVisitor() {
565
566 @Override
567 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
568 final Set<String> operations = new HashSet<>();
569 operations.add("public de.fhdw.wtf.context.model.Str op1()");
570 operations.add("private generated.model.group1.class1 $getThis()");
571 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
572 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
573 + " get$generatedObjects()");
574 final Set<String> attributes = new HashSet<>();
575 attributes.add("private de.fhdw.wtf.context.model.Str attr1");
576 attributes.add("private generated.model.group1.class1 This");
577 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
578 final Set<String> modifiers = new HashSet<>();
579 final Set<String> implement = new HashSet<>();
580 implement.add("generated.model.group1.class1");
581 assertEquals(true, TestClassTransformer.controlImplClass(
582 interfaceWithImplClass,
583 "class1",
584 "generated.model.group1",
585 operations,
586 attributes,
587 modifiers,
588 implement));
589
590 }
591
592 @Override
593 public void handle(final GenSimpleInterfaceClass simpleInterface) {
594 fail();
595 }
596
597 @Override
598 public void handle(final GenExternalInterfaceClass iface) {
599 fail();
600 }
601 });
602 }
603
604 @Override
605 public void handle(final GenClassClass classClass) {
606 fail();
607 }
608
609 @Override
610 public void handle(final GenPrimitiveClass primitiveClass) {
611 fail();
612 }
613 });
614 break;
615 case product:
616 genClass.accept(new GenClassVisitor() {
617
618 @Override
619 public void handle(final GenInterfaceClass interfaceClass) {
620 fail();
621 }
622
623 @Override
624 public void handle(final GenClassClass classClass) {
625 assertEquals(0, classClass.getOperations().size());
626 assertEquals(0, classClass.getAttributes().size());
627 assertEquals(0, classClass.getModifieres().size());
628 }
629
630 @Override
631 public void handle(final GenPrimitiveClass primitiveClass) {
632 fail();
633 }
634 });
635 break;
636 default:
637 fail("Klasse erwartet und gefunden, wird aber nicht überprüft " + genClass.getName());
638 break;
639 }
640
641 } else {
642 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getName());
643 }
644
645 }
646 if (expectedClasses.size() != 0) {
647 fail("Klasse erwartet, aber nicht gefunden");
648 }
649 final Set<String> expectedTypes = new HashSet<>();
650 expectedTypes.addAll(TestUtil.getEverytimeExpectedTypes());
651 expectedTypes.add("generated.model.group1.class1");
652 expectedTypes.add("generated.products." + product);
653 assertEquals(expectedTypes.size(), javaGeneratorModel.getTypeMapping().size());
654
655 final Iterator<Tuple<GenType, Collection<ExceptionClassType>>> i2 =
656 javaGeneratorModel.getTypeMapping().values().iterator();
657 while (i2.hasNext()) {
658 final GenType genType = i2.next().getA();
659 if (expectedTypes.remove(genType.getFullyQualifiedTypeName())) {
660 switch (genType.getName()) {
661 case "Anything":
662 genType.accept(new GenTypeVisitor() {
663
664 @Override
665 public void handle(final GenImportType importType) {
666 fail();
667 }
668
669 @Override
670 public void handle(final GenJavaUtilCollection javaUtilCollection) {
671 fail();
672 }
673
674 @Override
675 public void handle(final Generic generic) {
676 fail();
677 }
678
679 @Override
680 public void handle(final GenMapType mapType) {
681 fail();
682 }
683
684 @Override
685 public void handle(final GenPrimitiveType primitiveType) {
686 fail();
687 }
688
689 @Override
690 public void handle(final GenCollectionType collectionType) {
691 fail();
692 }
693
694 @Override
695 public void handle(final GenClass cla) {
696
697 }
698
699 @Override
700 public void handle(final GenDummyType dummy) {
701 fail();
702
703 }
704 });
705 break;
706 case "class1":
707 genType.accept(new GenTypeVisitor() {
708
709 @Override
710 public void handle(final GenImportType importType) {
711 fail();
712 }
713
714 @Override
715 public void handle(final GenJavaUtilCollection javaUtilCollection) {
716 fail();
717 }
718
719 @Override
720 public void handle(final Generic generic) {
721 fail();
722 }
723
724 @Override
725 public void handle(final GenMapType mapType) {
726 fail();
727 }
728
729 @Override
730 public void handle(final GenPrimitiveType primitiveType) {
731 fail();
732 }
733
734 @Override
735 public void handle(final GenCollectionType collectionType) {
736 fail();
737 }
738
739 @Override
740 public void handle(final GenClass cla) {
741
742 }
743
744 @Override
745 public void handle(final GenDummyType dummy) {
746 fail();
747
748 }
749 });
750 break;
751 case "Str":
752 genType.accept(new GenTypeVisitor() {
753
754 @Override
755 public void handle(final GenImportType importType) {
756 fail();
757 }
758
759 @Override
760 public void handle(final GenJavaUtilCollection javaUtilCollection) {
761 fail();
762 }
763
764 @Override
765 public void handle(final Generic generic) {
766 fail();
767 }
768
769 @Override
770 public void handle(final GenMapType mapType) {
771 fail();
772 }
773
774 @Override
775 public void handle(final GenPrimitiveType primitiveType) {
776
777 }
778
779 @Override
780 public void handle(final GenCollectionType collectionType) {
781 fail();
782 }
783
784 @Override
785 public void handle(final GenClass cla) {
786 fail();
787 }
788
789 @Override
790 public void handle(final GenDummyType dummy) {
791 fail();
792
793 }
794 });
795 break;
796 case "Int":
797 genType.accept(new GenTypeVisitor() {
798
799 @Override
800 public void handle(final GenImportType importType) {
801 fail();
802 }
803
804 @Override
805 public void handle(final GenJavaUtilCollection javaUtilCollection) {
806 fail();
807 }
808
809 @Override
810 public void handle(final Generic generic) {
811 fail();
812 }
813
814 @Override
815 public void handle(final GenMapType mapType) {
816 fail();
817 }
818
819 @Override
820 public void handle(final GenPrimitiveType primitiveType) {
821
822 }
823
824 @Override
825 public void handle(final GenCollectionType collectionType) {
826 fail();
827 }
828
829 @Override
830 public void handle(final GenClass cla) {
831 fail();
832 }
833
834 @Override
835 public void handle(final GenDummyType dummy) {
836 fail();
837
838 }
839 });
840 break;
841 case product:
842 genType.accept(new GenTypeVisitor() {
843
844 @Override
845 public void handle(final GenImportType importType) {
846 fail();
847 }
848
849 @Override
850 public void handle(final GenJavaUtilCollection javaUtilCollection) {
851 fail();
852 }
853
854 @Override
855 public void handle(final Generic generic) {
856 fail();
857 }
858
859 @Override
860 public void handle(final GenMapType mapType) {
861 fail();
862 }
863
864 @Override
865 public void handle(final GenPrimitiveType primitiveType) {
866 fail();
867 }
868
869 @Override
870 public void handle(final GenCollectionType collectionType) {
871 fail();
872 }
873
874 @Override
875 public void handle(final GenClass cla) {
876
877 }
878
879 @Override
880 public void handle(final GenDummyType dummy) {
881 fail();
882
883 }
884 });
885 break;
886 default:
887 fail("Type erwartet und gefunden, wird aber nicht überprüft: " + genType.getName());
888 break;
889 }
890
891 } else {
892 fail("Type gefunden, die aber nicht erwartet wird." + genType.getName());
893 }
894
895 }
896 if (expectedTypes.size() != 0) {
897 fail("Type erwartet, aber nicht gefunden");
898 }
899 }
900
901
902
903
904
905
906 @Test
907 public void testClassWithMapAttributeStringToInteger() throws Exception {
908 final GeneratorModel javaGeneratorModel = this.generate(TestModels.classWithMapAttributeStringToInteger);
909 final String map = "MutableMap";
910
911 final Set<String> expectedClasses = TestUtil.getEverytimeExpectedClasses();
912 expectedClasses.addAll(TestUtil.getEverytimeExpectedClasses());
913 expectedClasses.add("generated.model.group1.class1");
914 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
915 expectedClasses.add(product0);
916 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().values().size());
917 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
918 while (i.hasNext()) {
919 final GenClass genClass = i.next();
920 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
921 switch (genClass.getName()) {
922 case "Anything":
923 genClass.accept(new GenClassVisitor() {
924
925 @Override
926 public void handle(final GenInterfaceClass interfaceClass) {
927 assertEquals(0, interfaceClass.getOperations().size());
928 }
929
930 @Override
931 public void handle(final GenClassClass classClass) {
932 fail();
933 }
934
935 @Override
936 public void handle(final GenPrimitiveClass primitiveClass) {
937 fail();
938 }
939 });
940 break;
941 case "class1":
942 assertEquals("generated.model.group1", genClass.getPackag().toString());
943 genClass.accept(new GenClassVisitor() {
944
945 @Override
946 public void handle(final GenInterfaceClass interfaceClass) {
947 assertEquals(0, interfaceClass.getOperations().size());
948
949 interfaceClass.accept(new GenInterfaceClassVisitor() {
950
951 @Override
952 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
953 final Set<String> operations = new HashSet<>();
954 operations.add("private generated.model.group1.class1 $getThis()");
955
956 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
957 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
958 + " get$generatedObjects()");
959 final Set<String> attributes = new HashSet<>();
960 attributes.add("private de.fhdw.wtf.context.model.collections." + map
961 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.Int> attr1");
962 attributes.add("private generated.model.group1.class1 This");
963 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
964 final Set<String> modifiers = new HashSet<>();
965 final Set<String> implement = new HashSet<>();
966 implement.add("generated.model.group1.class1");
967 assertEquals(true, TestClassTransformer.controlImplClass(
968 interfaceWithImplClass,
969 "class1",
970 "generated.model.group1",
971 operations,
972 attributes,
973 modifiers,
974 implement));
975
976
977 }
978
979 @Override
980 public void handle(final GenSimpleInterfaceClass simpleInterface) {
981 fail();
982 }
983
984 @Override
985 public void handle(final GenExternalInterfaceClass iface) {
986 fail();
987 }
988 });
989 }
990
991 @Override
992 public void handle(final GenClassClass classClass) {
993 fail();
994 }
995
996 @Override
997 public void handle(final GenPrimitiveClass primitiveClass) {
998 fail();
999 }
1000 });
1001 break;
1002
1003 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
1004 break;
1005 default:
1006 fail("Klasse erwartet und gefunden, wird aber nicht überprüft " + genClass.getName());
1007 break;
1008 }
1009
1010 } else {
1011 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getName());
1012 }
1013
1014 }
1015 if (expectedClasses.size() != 0) {
1016 fail("Klasse erwartet, aber nicht gefunden");
1017 }
1018 final Set<String> expectedTypes = new HashSet<>();
1019 expectedTypes.addAll(TestUtil.getEverytimeExpectedTypes());
1020
1021 expectedTypes.add("de.fhdw.wtf.context.model.collections." + map);
1022 expectedTypes.add("generated.model.group1.class1");
1023 expectedTypes.add(product0);
1024 assertEquals(expectedTypes.size(), javaGeneratorModel.getTypeMapping().size());
1025
1026 final Iterator<Tuple<GenType, Collection<ExceptionClassType>>> i2 =
1027 javaGeneratorModel.getTypeMapping().values().iterator();
1028 while (i2.hasNext()) {
1029 final GenType genType = i2.next().getA();
1030 if (expectedTypes.remove(genType.getFullyQualifiedTypeName())) {
1031 switch (genType.getName()) {
1032
1033 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
1034 break;
1035 case "class1":
1036 genType.accept(new GenTypeVisitor() {
1037
1038 @Override
1039 public void handle(final GenImportType importType) {
1040 fail();
1041 }
1042
1043 @Override
1044 public void handle(final GenJavaUtilCollection javaUtilCollection) {
1045 fail();
1046 }
1047
1048 @Override
1049 public void handle(final Generic generic) {
1050 fail();
1051 }
1052
1053 @Override
1054 public void handle(final GenMapType mapType) {
1055 fail();
1056 }
1057
1058 @Override
1059 public void handle(final GenPrimitiveType primitiveType) {
1060 fail();
1061 }
1062
1063 @Override
1064 public void handle(final GenCollectionType collectionType) {
1065 fail();
1066 }
1067
1068 @Override
1069 public void handle(final GenClass cla) {
1070
1071 }
1072
1073 @Override
1074 public void handle(final GenDummyType dummy) {
1075 fail();
1076
1077 }
1078 });
1079 break;
1080 case "Str":
1081 genType.accept(new GenTypeVisitor() {
1082
1083 @Override
1084 public void handle(final GenImportType importType) {
1085 fail();
1086 }
1087
1088 @Override
1089 public void handle(final GenJavaUtilCollection javaUtilCollection) {
1090 fail();
1091 }
1092
1093 @Override
1094 public void handle(final Generic generic) {
1095 fail();
1096 }
1097
1098 @Override
1099 public void handle(final GenMapType mapType) {
1100 fail();
1101 }
1102
1103 @Override
1104 public void handle(final GenPrimitiveType primitiveType) {
1105
1106 }
1107
1108 @Override
1109 public void handle(final GenCollectionType collectionType) {
1110 fail();
1111 }
1112
1113 @Override
1114 public void handle(final GenClass cla) {
1115 fail();
1116 }
1117
1118 @Override
1119 public void handle(final GenDummyType dummy) {
1120 fail();
1121
1122 }
1123 });
1124 break;
1125 case "Int":
1126 genType.accept(new GenTypeVisitor() {
1127
1128 @Override
1129 public void handle(final GenImportType importType) {
1130 fail();
1131 }
1132
1133 @Override
1134 public void handle(final GenJavaUtilCollection javaUtilCollection) {
1135 fail();
1136 }
1137
1138 @Override
1139 public void handle(final Generic generic) {
1140 fail();
1141 }
1142
1143 @Override
1144 public void handle(final GenMapType mapType) {
1145 fail();
1146 }
1147
1148 @Override
1149 public void handle(final GenPrimitiveType primitiveType) {
1150
1151 }
1152
1153 @Override
1154 public void handle(final GenCollectionType collectionType) {
1155 fail();
1156 }
1157
1158 @Override
1159 public void handle(final GenClass cla) {
1160 fail();
1161 }
1162
1163 @Override
1164 public void handle(final GenDummyType dummy) {
1165 fail();
1166
1167 }
1168 });
1169 break;
1170 case map:
1171 genType.accept(new GenTypeVisitor() {
1172
1173 @Override
1174 public void handle(final GenImportType importType) {
1175 fail();
1176 }
1177
1178 @Override
1179 public void handle(final GenJavaUtilCollection javaUtilCollection) {
1180 fail();
1181 }
1182
1183 @Override
1184 public void handle(final Generic generic) {
1185 fail();
1186 }
1187
1188 @Override
1189 public void handle(final GenMapType mapType) {
1190 fail();
1191 }
1192
1193 @Override
1194 public void handle(final GenPrimitiveType primitiveType) {
1195 fail();
1196 }
1197
1198 @Override
1199 public void handle(final GenCollectionType collectionType) {
1200 collectionType.accept(new GenCollectionTypeVisitor() {
1201
1202 @Override
1203 public void handle(final GenMutableMap map) {
1204 assertEquals("Str", map.getKey().getName());
1205 assertEquals("Int", map.getType().getName());
1206 }
1207
1208 @Override
1209 public void handle(final GenMutableList list) {
1210 fail();
1211 }
1212 });
1213 }
1214
1215 @Override
1216 public void handle(final GenClass cla) {
1217 fail();
1218 }
1219
1220 @Override
1221 public void handle(final GenDummyType dummy) {
1222 fail();
1223
1224 }
1225 });
1226 break;
1227 case "Anything":
1228 genType.accept(new GenTypeVisitor() {
1229
1230 @Override
1231 public void handle(final GenImportType importType) {
1232 fail();
1233 }
1234
1235 @Override
1236 public void handle(final GenJavaUtilCollection javaUtilCollection) {
1237 fail();
1238 }
1239
1240 @Override
1241 public void handle(final Generic generic) {
1242 fail();
1243 }
1244
1245 @Override
1246 public void handle(final GenMapType mapType) {
1247 fail();
1248 }
1249
1250 @Override
1251 public void handle(final GenPrimitiveType primitiveType) {
1252 fail();
1253 }
1254
1255 @Override
1256 public void handle(final GenCollectionType collectionType) {
1257 fail();
1258 }
1259
1260 @Override
1261 public void handle(final GenClass cla) {
1262
1263 }
1264
1265 @Override
1266 public void handle(final GenDummyType dummy) {
1267 fail();
1268
1269 }
1270 });
1271 break;
1272 default:
1273 fail("Type erwartet und gefunden, wird aber nicht überprüft" + genType.getName());
1274 break;
1275 }
1276
1277 } else {
1278 fail("Type gefunden, die aber nicht erwartet wird." + genType.getName());
1279 }
1280
1281 }
1282 if (expectedTypes.size() != 0) {
1283 fail("Type erwartet, aber nicht gefunden");
1284 }
1285 }
1286
1287
1288
1289
1290
1291
1292 @Test
1293 public void testClassWithProductAttributeOnlyBasetypesInTheProduct() throws Exception {
1294 final GeneratorModel javaGeneratorModel =
1295 this.generate(TestModels.classWithProductAttributeOnlyBasetypesInTheProduct);
1296 final Set<String> expectedClasses = TestUtil.getEverytimeExpectedClasses();
1297 expectedClasses.addAll(TestUtil.getEverytimeExpectedClasses());
1298 expectedClasses.add("generated.model.group1.class1");
1299 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
1300 expectedClasses.add(product0);
1301 final String product =
1302 TypeNameGenerator.PRODUCT_BEGIN + "param1" + TypeNameGenerator.PRODUCT_SEPERATE_TYPE_AND_NAME
1303 + "Integer" + TypeNameGenerator.PRODUCT_SEPERATE_ATTRIBUTES + "param2"
1304 + TypeNameGenerator.PRODUCT_SEPERATE_TYPE_AND_NAME + "String"
1305 + TypeNameGenerator.PRODUCT_SEPERATE_ATTRIBUTES + "param3"
1306 + TypeNameGenerator.PRODUCT_SEPERATE_TYPE_AND_NAME + "Integer" + TypeNameGenerator.PRODUCT_END;
1307 expectedClasses.add("generated.products." + product);
1308 final String abstractProduct =
1309 TypeNameGenerator.PRODUCT_BEGIN + "p$1" + TypeNameGenerator.PRODUCT_SEPERATE_TYPE_AND_NAME + "Integer"
1310 + TypeNameGenerator.PRODUCT_SEPERATE_ATTRIBUTES + "p$2"
1311 + TypeNameGenerator.PRODUCT_SEPERATE_TYPE_AND_NAME + "String"
1312 + TypeNameGenerator.PRODUCT_SEPERATE_ATTRIBUTES + "p$3"
1313 + TypeNameGenerator.PRODUCT_SEPERATE_TYPE_AND_NAME + "Integer" + TypeNameGenerator.PRODUCT_END;
1314 expectedClasses.add("generated.products." + abstractProduct);
1315
1316 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
1317 while (i.hasNext()) {
1318 final GenClass genClass = i.next();
1319 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
1320 switch (genClass.getName()) {
1321 case "Anything":
1322 genClass.accept(new GenClassVisitor() {
1323
1324 @Override
1325 public void handle(final GenInterfaceClass interfaceClass) {
1326 assertEquals(0, interfaceClass.getOperations().size());
1327 }
1328
1329 @Override
1330 public void handle(final GenClassClass classClass) {
1331 fail();
1332 }
1333
1334 @Override
1335 public void handle(final GenPrimitiveClass primitiveClass) {
1336 fail();
1337 }
1338 });
1339 break;
1340 case "class1":
1341 assertEquals("generated.model.group1", genClass.getPackag().toString());
1342 genClass.accept(new GenClassVisitor() {
1343
1344 @Override
1345 public void handle(final GenInterfaceClass interfaceClass) {
1346 assertEquals(0, interfaceClass.getOperations().size());
1347
1348 interfaceClass.accept(new GenInterfaceClassVisitor() {
1349
1350 @Override
1351 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
1352 final Set<String> operations = new HashSet<>();
1353 operations.add("private generated.model.group1.class1 $getThis()");
1354
1355 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
1356 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
1357 + " get$generatedObjects()");
1358 final Set<String> attributes = new HashSet<>();
1359 attributes.add("private " + PackageConstants.PRODUCT_PACKAGE
1360 + ".Product$0param1€0Integer€_param2€0String€_param3€0Integer$0$ attr1");
1361 attributes.add("private generated.model.group1.class1 This");
1362 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
1363 final Set<String> modifiers = new HashSet<>();
1364 final Set<String> implement = new HashSet<>();
1365 implement.add("generated.model.group1.class1");
1366 assertEquals(true, TestClassTransformer.controlImplClass(
1367 interfaceWithImplClass,
1368 "class1",
1369 "generated.model.group1",
1370 operations,
1371 attributes,
1372 modifiers,
1373 implement));
1374
1375
1376 }
1377
1378 @Override
1379 public void handle(final GenSimpleInterfaceClass simpleInterface) {
1380 fail();
1381 }
1382
1383 @Override
1384 public void handle(final GenExternalInterfaceClass iface) {
1385 fail();
1386 }
1387 });
1388 }
1389
1390 @Override
1391 public void handle(final GenClassClass classClass) {
1392 fail();
1393 }
1394
1395 @Override
1396 public void handle(final GenPrimitiveClass primitiveClass) {
1397 fail();
1398 }
1399 });
1400 break;
1401 case product:
1402 genClass.accept(new GenClassVisitor() {
1403
1404 @Override
1405 public void handle(final GenInterfaceClass interfaceClass) {
1406 fail();
1407 }
1408
1409 @Override
1410 public void handle(final GenClassClass classClass) {
1411 final Collection<String> expectedOperations = new Vector<>();
1412 expectedOperations.add("public de.fhdw.wtf.context.model.Int getParam1()");
1413 expectedOperations.add("public void setParam1(de.fhdw.wtf.context.model.Int param1)");
1414 expectedOperations.add("public de.fhdw.wtf.context.model.Str getParam2()");
1415 expectedOperations.add("public void setParam2(de.fhdw.wtf.context.model.Str param2)");
1416 expectedOperations.add("public de.fhdw.wtf.context.model.Int getParam3()");
1417 expectedOperations.add("public void setParam3(de.fhdw.wtf.context.model.Int param3)");
1418 TestUtil.assertEqualsForOperations(expectedOperations, classClass.getOperations());
1419
1420 assertEquals(0, classClass.getAttributes().size());
1421 assertEquals(0, classClass.getModifieres().size());
1422 }
1423
1424 @Override
1425 public void handle(final GenPrimitiveClass primitiveClass) {
1426 fail();
1427 }
1428 });
1429 break;
1430 case abstractProduct:
1431 genClass.accept(new GenClassVisitor() {
1432
1433 @Override
1434 public void handle(final GenInterfaceClass interfaceClass) {
1435 fail();
1436 }
1437
1438 @Override
1439 public void handle(final GenClassClass classClass) {
1440 assertEquals(0, classClass.getOperations().size());
1441 assertEquals(3, classClass.getAttributes().size());
1442 assertEquals(0, classClass.getModifieres().size());
1443 }
1444
1445 @Override
1446 public void handle(final GenPrimitiveClass primitiveClass) {
1447 fail();
1448 }
1449 });
1450 break;
1451 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
1452 break;
1453 default:
1454 fail("Klasse erwartet und gefunden, wird aber nicht überprüft " + genClass.getName());
1455 break;
1456 }
1457
1458 } else {
1459 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getName());
1460 }
1461
1462 }
1463 if (expectedClasses.size() != 0) {
1464 fail("Klasse erwartet, aber nicht gefunden");
1465 }
1466
1467 final Set<String> expectedTypes = new HashSet<>();
1468 expectedTypes.addAll(TestUtil.getEverytimeExpectedTypes());
1469 expectedTypes.add("generated.model.group1.class1");
1470 expectedTypes.add(product0);
1471 expectedTypes.add("generated.products." + product);
1472 expectedTypes.add("generated.products." + abstractProduct);
1473 assertEquals(expectedTypes.size(), javaGeneratorModel.getTypeMapping().size());
1474
1475 final Iterator<Tuple<GenType, Collection<ExceptionClassType>>> i2 =
1476 javaGeneratorModel.getTypeMapping().values().iterator();
1477 while (i2.hasNext()) {
1478 final GenType genType = i2.next().getA();
1479 if (expectedTypes.remove(genType.getFullyQualifiedTypeName())) {
1480 switch (genType.getName()) {
1481 case "class1":
1482 genType.accept(new GenTypeVisitor() {
1483
1484 @Override
1485 public void handle(final GenImportType importType) {
1486 fail();
1487 }
1488
1489 @Override
1490 public void handle(final GenJavaUtilCollection javaUtilCollection) {
1491 fail();
1492 }
1493
1494 @Override
1495 public void handle(final Generic generic) {
1496 fail();
1497 }
1498
1499 @Override
1500 public void handle(final GenMapType mapType) {
1501 fail();
1502 }
1503
1504 @Override
1505 public void handle(final GenPrimitiveType primitiveType) {
1506 fail();
1507 }
1508
1509 @Override
1510 public void handle(final GenCollectionType collectionType) {
1511 fail();
1512 }
1513
1514 @Override
1515 public void handle(final GenClass cla) {
1516
1517 }
1518
1519 @Override
1520 public void handle(final GenDummyType dummy) {
1521 fail();
1522
1523 }
1524 });
1525 break;
1526 case "Str":
1527 genType.accept(new GenTypeVisitor() {
1528
1529 @Override
1530 public void handle(final GenImportType importType) {
1531 fail();
1532 }
1533
1534 @Override
1535 public void handle(final GenJavaUtilCollection javaUtilCollection) {
1536 fail();
1537 }
1538
1539 @Override
1540 public void handle(final Generic generic) {
1541 fail();
1542 }
1543
1544 @Override
1545 public void handle(final GenMapType mapType) {
1546 fail();
1547 }
1548
1549 @Override
1550 public void handle(final GenPrimitiveType primitiveType) {
1551
1552 }
1553
1554 @Override
1555 public void handle(final GenCollectionType collectionType) {
1556 fail();
1557 }
1558
1559 @Override
1560 public void handle(final GenClass cla) {
1561 fail();
1562 }
1563
1564 @Override
1565 public void handle(final GenDummyType dummy) {
1566 fail();
1567
1568 }
1569 });
1570 break;
1571 case "Int":
1572 genType.accept(new GenTypeVisitor() {
1573
1574 @Override
1575 public void handle(final GenImportType importType) {
1576 fail();
1577 }
1578
1579 @Override
1580 public void handle(final GenJavaUtilCollection javaUtilCollection) {
1581 fail();
1582 }
1583
1584 @Override
1585 public void handle(final Generic generic) {
1586 fail();
1587 }
1588
1589 @Override
1590 public void handle(final GenMapType mapType) {
1591 fail();
1592 }
1593
1594 @Override
1595 public void handle(final GenPrimitiveType primitiveType) {
1596
1597 }
1598
1599 @Override
1600 public void handle(final GenCollectionType collectionType) {
1601 fail();
1602 }
1603
1604 @Override
1605 public void handle(final GenClass cla) {
1606 fail();
1607 }
1608
1609 @Override
1610 public void handle(final GenDummyType dummy) {
1611 fail();
1612
1613 }
1614 });
1615 break;
1616 case product:
1617 genType.accept(new GenTypeVisitor() {
1618
1619 @Override
1620 public void handle(final GenImportType importType) {
1621 fail();
1622 }
1623
1624 @Override
1625 public void handle(final GenJavaUtilCollection javaUtilCollection) {
1626 fail();
1627 }
1628
1629 @Override
1630 public void handle(final Generic generic) {
1631 fail();
1632 }
1633
1634 @Override
1635 public void handle(final GenMapType mapType) {
1636 fail();
1637 }
1638
1639 @Override
1640 public void handle(final GenPrimitiveType primitiveType) {
1641 fail();
1642 }
1643
1644 @Override
1645 public void handle(final GenCollectionType collectionType) {
1646 fail();
1647 }
1648
1649 @Override
1650 public void handle(final GenClass cla) {
1651
1652 }
1653
1654 @Override
1655 public void handle(final GenDummyType dummy) {
1656 fail();
1657
1658 }
1659 });
1660 break;
1661 case abstractProduct:
1662 genType.accept(new GenTypeVisitor() {
1663
1664 @Override
1665 public void handle(final GenImportType importType) {
1666 fail();
1667 }
1668
1669 @Override
1670 public void handle(final GenJavaUtilCollection javaUtilCollection) {
1671 fail();
1672 }
1673
1674 @Override
1675 public void handle(final Generic generic) {
1676 fail();
1677 }
1678
1679 @Override
1680 public void handle(final GenMapType mapType) {
1681 fail();
1682 }
1683
1684 @Override
1685 public void handle(final GenPrimitiveType primitiveType) {
1686 fail();
1687 }
1688
1689 @Override
1690 public void handle(final GenCollectionType collectionType) {
1691 fail();
1692 }
1693
1694 @Override
1695 public void handle(final GenClass cla) {
1696
1697 }
1698
1699 @Override
1700 public void handle(final GenDummyType dummy) {
1701 fail();
1702
1703 }
1704 });
1705 break;
1706 case "Anything":
1707 genType.accept(new GenTypeVisitor() {
1708
1709 @Override
1710 public void handle(final GenImportType importType) {
1711 fail();
1712 }
1713
1714 @Override
1715 public void handle(final GenJavaUtilCollection javaUtilCollection) {
1716 fail();
1717 }
1718
1719 @Override
1720 public void handle(final Generic generic) {
1721 fail();
1722 }
1723
1724 @Override
1725 public void handle(final GenMapType mapType) {
1726 fail();
1727 }
1728
1729 @Override
1730 public void handle(final GenPrimitiveType primitiveType) {
1731 fail();
1732 }
1733
1734 @Override
1735 public void handle(final GenCollectionType collectionType) {
1736 fail();
1737 }
1738
1739 @Override
1740 public void handle(final GenClass cla) {
1741
1742 }
1743
1744 @Override
1745 public void handle(final GenDummyType dummy) {
1746 fail();
1747
1748 }
1749 });
1750 break;
1751 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
1752 break;
1753 default:
1754 fail("Type erwartet und gefunden, wird aber nicht überprüft " + genType.getName());
1755 break;
1756 }
1757
1758 } else {
1759 fail("Type gefunden, die aber nicht erwartet wird." + genType.getName());
1760 }
1761
1762 }
1763 if (expectedTypes.size() != 0) {
1764 fail("Type erwartet, aber nicht gefunden");
1765 }
1766 }
1767
1768
1769
1770
1771
1772
1773 @Test
1774 public void testClassWithOperationWithSumAsReturnType() throws Exception {
1775 final GeneratorModel javaGeneratorModel = this.generate(TestModels.classWithOperationWithSumAsReturnType);
1776
1777 final Set<String> expectedClasses = TestUtil.getEverytimeExpectedClasses();
1778 expectedClasses.addAll(TestUtil.getEverytimeExpectedClasses());
1779 expectedClasses.add("generated.model.de.fhdw.Person");
1780 expectedClasses.add("generated.model.de.fhdw.SteuerID");
1781 expectedClasses.add("generated.model.de.fhdw.StID");
1782 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
1783 expectedClasses.add(product0);
1784 final String sum =
1785 TypeNameGenerator.SUM_BEGIN + "StID" + TypeNameGenerator.SUM_SEPERATE_ELEMENT + "SteuerID"
1786 + TypeNameGenerator.SUM_END;
1787 expectedClasses.add("generated.sums." + sum);
1788 final String product =
1789 TypeNameGenerator.PRODUCT_BEGIN + "name" + TypeNameGenerator.PRODUCT_SEPERATE_TYPE_AND_NAME + "String"
1790 + TypeNameGenerator.PRODUCT_END;
1791 expectedClasses.add("generated.products." + product);
1792 final String abstractProduct =
1793 TypeNameGenerator.PRODUCT_BEGIN + "p$1" + TypeNameGenerator.PRODUCT_SEPERATE_TYPE_AND_NAME + "String"
1794 + TypeNameGenerator.PRODUCT_END;
1795 expectedClasses.add("generated.products." + abstractProduct);
1796
1797 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().values().size());
1798 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
1799 while (i.hasNext()) {
1800 final GenClass genClass = i.next();
1801 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
1802 switch (genClass.getName()) {
1803 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
1804 break;
1805 case "Person":
1806 assertEquals("generated.model.de.fhdw", genClass.getPackag().toString());
1807 genClass.accept(new GenClassVisitor() {
1808
1809 @Override
1810 public void handle(final GenInterfaceClass interfaceClass) {
1811 assertEquals(1, interfaceClass.getOperations().size());
1812 assertEquals("getSteuerID", interfaceClass.getOperations().iterator().next().getName());
1813 interfaceClass.accept(new GenInterfaceClassVisitor() {
1814
1815 @Override
1816 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
1817 final Set<String> operations = new HashSet<>();
1818 operations.add("public " + PackageConstants.SUM_PACKAGE + "." + sum
1819 + " getSteuerID(de.fhdw.wtf.context.model.Str name)");
1820 operations.add("private generated.model.de.fhdw.Person $getThis()");
1821 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
1822 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
1823 + " get$generatedObjects()");
1824 final Set<String> attributes = new HashSet<>();
1825 attributes.add("private de.fhdw.wtf.context.model.Str name");
1826 attributes.add("private generated.model.de.fhdw.Person This");
1827 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
1828 final Set<String> modifiers = new HashSet<>();
1829 final Set<String> implement = new HashSet<>();
1830 implement.add("generated.model.de.fhdw.Person");
1831 assertEquals(true, TestClassTransformer.controlImplClass(
1832 interfaceWithImplClass,
1833 "Person",
1834 "generated.model.de.fhdw",
1835 operations,
1836 attributes,
1837 modifiers,
1838 implement));
1839
1840
1841
1842 assertEquals(0, interfaceWithImplClass.getClassRepresentation().getModifieres()
1843 .size());
1844
1845 }
1846
1847 @Override
1848 public void handle(final GenSimpleInterfaceClass simpleInterface) {
1849 fail();
1850 }
1851
1852 @Override
1853 public void handle(final GenExternalInterfaceClass iface) {
1854 fail();
1855 }
1856 });
1857 }
1858
1859 @Override
1860 public void handle(final GenClassClass classClass) {
1861 fail();
1862 }
1863
1864 @Override
1865 public void handle(final GenPrimitiveClass primitiveClass) {
1866 fail();
1867 }
1868 });
1869
1870 break;
1871 case "SteuerID":
1872 genClass.accept(new GenClassVisitor() {
1873
1874 @Override
1875 public void handle(final GenInterfaceClass interfaceClass) {
1876 assertEquals(0, interfaceClass.getOperations().size());
1877 assertEquals("generated.model.de.fhdw", genClass.getPackag().toString());
1878 interfaceClass.accept(new GenInterfaceClassVisitor() {
1879
1880 @Override
1881 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
1882 final Set<String> operations = new HashSet<>();
1883 operations.add("private generated.model.de.fhdw.SteuerID $getThis()");
1884 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
1885 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
1886 + " get$generatedObjects()");
1887 final Set<String> attributes = new HashSet<>();
1888 attributes.add("private de.fhdw.wtf.context.model.Str id");
1889 attributes.add("private generated.model.de.fhdw.SteuerID This");
1890 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
1891 final Set<String> modifiers = new HashSet<>();
1892 final Set<String> implement = new HashSet<>();
1893 implement.add("generated.model.de.fhdw.SteuerID");
1894 assertEquals(true, TestClassTransformer.controlImplClass(
1895 interfaceWithImplClass,
1896 "SteuerID",
1897 "generated.model.de.fhdw",
1898 operations,
1899 attributes,
1900 modifiers,
1901 implement));
1902
1903 assertEquals(0, interfaceWithImplClass.getClassRepresentation().getModifieres()
1904 .size());
1905 }
1906
1907 @Override
1908 public void handle(final GenSimpleInterfaceClass simpleInterface) {
1909 fail();
1910 }
1911
1912 @Override
1913 public void handle(final GenExternalInterfaceClass iface) {
1914 fail();
1915 }
1916 });
1917 }
1918
1919 @Override
1920 public void handle(final GenClassClass classClass) {
1921 fail();
1922 }
1923
1924 @Override
1925 public void handle(final GenPrimitiveClass primitiveClass) {
1926 fail();
1927 }
1928 });
1929 break;
1930 case "StID":
1931 genClass.accept(new GenClassVisitor() {
1932
1933 @Override
1934 public void handle(final GenInterfaceClass interfaceClass) {
1935 assertEquals(0, interfaceClass.getOperations().size());
1936 assertEquals("generated.model.de.fhdw", genClass.getPackag().toString());
1937 interfaceClass.accept(new GenInterfaceClassVisitor() {
1938
1939 @Override
1940 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
1941 final Set<String> operations = new HashSet<>();
1942 operations.add("private generated.model.de.fhdw.StID $getThis()");
1943 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
1944 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
1945 + " get$generatedObjects()");
1946 final Set<String> attributes = new HashSet<>();
1947 attributes.add("private de.fhdw.wtf.context.model.Str stid");
1948 attributes.add("private generated.model.de.fhdw.StID This");
1949 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
1950 final Set<String> modifiers = new HashSet<>();
1951 final Set<String> implement = new HashSet<>();
1952 implement.add("generated.model.de.fhdw.StID");
1953 assertEquals(true, TestClassTransformer.controlImplClass(
1954 interfaceWithImplClass,
1955 "StID",
1956 "generated.model.de.fhdw",
1957 operations,
1958 attributes,
1959 modifiers,
1960 implement));
1961 assertEquals(0, interfaceWithImplClass.getClassRepresentation().getModifieres()
1962 .size());
1963
1964 }
1965
1966 @Override
1967 public void handle(final GenSimpleInterfaceClass simpleInterface) {
1968 fail();
1969 }
1970
1971 @Override
1972 public void handle(final GenExternalInterfaceClass iface) {
1973 fail();
1974 }
1975 });
1976 }
1977
1978 @Override
1979 public void handle(final GenClassClass classClass) {
1980 fail();
1981 }
1982
1983 @Override
1984 public void handle(final GenPrimitiveClass primitiveClass) {
1985 fail();
1986 }
1987 });
1988 break;
1989 case product:
1990 genClass.accept(new GenClassVisitor() {
1991
1992 @Override
1993 public void handle(final GenInterfaceClass interfaceClass) {
1994 fail();
1995 }
1996
1997 @Override
1998 public void handle(final GenClassClass classClass) {
1999 final Collection<String> expectedOperations = new Vector<>();
2000 expectedOperations.add("public de.fhdw.wtf.context.model.Str getName()");
2001 expectedOperations.add("public void setName(de.fhdw.wtf.context.model.Str name)");
2002 TestUtil.assertEqualsForOperations(expectedOperations, classClass.getOperations());
2003
2004 assertEquals(0, classClass.getAttributes().size());
2005 assertEquals(0, classClass.getModifieres().size());
2006 assertEquals(0, classClass.getImplement().size());
2007 }
2008
2009 @Override
2010 public void handle(final GenPrimitiveClass primitiveClass) {
2011 fail();
2012 }
2013 });
2014 break;
2015 case abstractProduct:
2016 genClass.accept(new GenClassVisitor() {
2017
2018 @Override
2019 public void handle(final GenInterfaceClass interfaceClass) {
2020 fail();
2021 }
2022
2023 @Override
2024 public void handle(final GenClassClass classClass) {
2025 assertEquals(0, classClass.getOperations().size());
2026 assertEquals(1, classClass.getAttributes().size());
2027 assertEquals("p$1", classClass.getAttributes().iterator().next().getName());
2028 assertEquals(0, classClass.getModifieres().size());
2029 assertEquals(0, classClass.getImplement().size());
2030 }
2031
2032 @Override
2033 public void handle(final GenPrimitiveClass primitiveClass) {
2034 fail();
2035 }
2036 });
2037 break;
2038 case sum:
2039 genClass.accept(new GenClassVisitor() {
2040
2041 @Override
2042 public void handle(final GenInterfaceClass interfaceClass) {
2043
2044 }
2045
2046 @Override
2047 public void handle(final GenClassClass classClass) {
2048 fail();
2049 }
2050
2051 @Override
2052 public void handle(final GenPrimitiveClass primitiveClass) {
2053 fail();
2054 }
2055 });
2056 break;
2057 case "Anything":
2058 genClass.accept(new GenClassVisitor() {
2059
2060 @Override
2061 public void handle(final GenInterfaceClass interfaceClass) {
2062 assertEquals(0, interfaceClass.getOperations().size());
2063 }
2064
2065 @Override
2066 public void handle(final GenClassClass classClass) {
2067 fail();
2068 }
2069
2070 @Override
2071 public void handle(final GenPrimitiveClass primitiveClass) {
2072 fail();
2073 }
2074 });
2075 break;
2076 default:
2077 fail("Klasse erwartet und gefunden, wird aber nicht überprüft " + genClass.getName());
2078 break;
2079 }
2080
2081 } else {
2082 fail(genClass.getName() + "-> Klasse gefunden, die aber nicht erwartet wird.");
2083 }
2084 }
2085 if (expectedClasses.size() != 0) {
2086 fail("Klasse erwartet, aber nicht gefunden");
2087 }
2088
2089 final Set<String> expectedTypes = new HashSet<>();
2090 expectedTypes.addAll(TestUtil.getEverytimeExpectedTypes());
2091 expectedTypes.add("generated.model.de.fhdw.StID");
2092 expectedTypes.add("generated.model.de.fhdw.SteuerID");
2093 expectedTypes.add("generated.model.de.fhdw.Person");
2094 expectedTypes.add("generated.products." + product);
2095 expectedTypes.add("generated.products." + abstractProduct);
2096 expectedTypes.add("generated.sums." + sum);
2097 expectedTypes.add(product0);
2098 assertEquals(expectedTypes.size(), javaGeneratorModel.getTypeMapping().size());
2099
2100 final Iterator<Tuple<GenType, Collection<ExceptionClassType>>> i2 =
2101 javaGeneratorModel.getTypeMapping().values().iterator();
2102 while (i2.hasNext()) {
2103 final GenType genType = i2.next().getA();
2104 if (expectedTypes.remove(genType.getFullyQualifiedTypeName())) {
2105 switch (genType.getName()) {
2106 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
2107 break;
2108 case "StID":
2109 genType.accept(new GenTypeVisitor() {
2110
2111 @Override
2112 public void handle(final GenImportType importType) {
2113 fail();
2114 }
2115
2116 @Override
2117 public void handle(final GenJavaUtilCollection javaUtilCollection) {
2118 fail();
2119 }
2120
2121 @Override
2122 public void handle(final Generic generic) {
2123 fail();
2124 }
2125
2126 @Override
2127 public void handle(final GenMapType mapType) {
2128 fail();
2129 }
2130
2131 @Override
2132 public void handle(final GenPrimitiveType primitiveType) {
2133 fail();
2134 }
2135
2136 @Override
2137 public void handle(final GenCollectionType collectionType) {
2138 fail();
2139 }
2140
2141 @Override
2142 public void handle(final GenClass cla) {
2143
2144 }
2145
2146 @Override
2147 public void handle(final GenDummyType dummy) {
2148 fail();
2149
2150 }
2151 });
2152 break;
2153 case "SteuerID":
2154 genType.accept(new GenTypeVisitor() {
2155
2156 @Override
2157 public void handle(final GenImportType importType) {
2158 fail();
2159 }
2160
2161 @Override
2162 public void handle(final GenJavaUtilCollection javaUtilCollection) {
2163 fail();
2164 }
2165
2166 @Override
2167 public void handle(final Generic generic) {
2168 fail();
2169 }
2170
2171 @Override
2172 public void handle(final GenMapType mapType) {
2173 fail();
2174 }
2175
2176 @Override
2177 public void handle(final GenPrimitiveType primitiveType) {
2178 fail();
2179 }
2180
2181 @Override
2182 public void handle(final GenCollectionType collectionType) {
2183 fail();
2184 }
2185
2186 @Override
2187 public void handle(final GenClass cla) {
2188
2189 }
2190
2191 @Override
2192 public void handle(final GenDummyType dummy) {
2193 fail();
2194
2195 }
2196 });
2197 break;
2198 case "Person":
2199 genType.accept(new GenTypeVisitor() {
2200
2201 @Override
2202 public void handle(final GenImportType importType) {
2203 fail();
2204 }
2205
2206 @Override
2207 public void handle(final GenJavaUtilCollection javaUtilCollection) {
2208 fail();
2209 }
2210
2211 @Override
2212 public void handle(final Generic generic) {
2213 fail();
2214 }
2215
2216 @Override
2217 public void handle(final GenMapType mapType) {
2218 fail();
2219 }
2220
2221 @Override
2222 public void handle(final GenPrimitiveType primitiveType) {
2223 fail();
2224 }
2225
2226 @Override
2227 public void handle(final GenCollectionType collectionType) {
2228 fail();
2229 }
2230
2231 @Override
2232 public void handle(final GenClass cla) {
2233
2234 }
2235
2236 @Override
2237 public void handle(final GenDummyType dummy) {
2238 fail();
2239
2240 }
2241 });
2242 break;
2243 case "Str":
2244 genType.accept(new GenTypeVisitor() {
2245
2246 @Override
2247 public void handle(final GenImportType importType) {
2248 fail();
2249 }
2250
2251 @Override
2252 public void handle(final GenJavaUtilCollection javaUtilCollection) {
2253 fail();
2254 }
2255
2256 @Override
2257 public void handle(final Generic generic) {
2258 fail();
2259 }
2260
2261 @Override
2262 public void handle(final GenMapType mapType) {
2263 fail();
2264 }
2265
2266 @Override
2267 public void handle(final GenPrimitiveType primitiveType) {
2268
2269 }
2270
2271 @Override
2272 public void handle(final GenCollectionType collectionType) {
2273 fail();
2274 }
2275
2276 @Override
2277 public void handle(final GenClass cla) {
2278 fail();
2279 }
2280
2281 @Override
2282 public void handle(final GenDummyType dummy) {
2283 fail();
2284
2285 }
2286 });
2287 break;
2288 case product:
2289 genType.accept(new GenTypeVisitor() {
2290
2291 @Override
2292 public void handle(final GenImportType importType) {
2293 fail();
2294 }
2295
2296 @Override
2297 public void handle(final GenJavaUtilCollection javaUtilCollection) {
2298 fail();
2299 }
2300
2301 @Override
2302 public void handle(final Generic generic) {
2303 fail();
2304 }
2305
2306 @Override
2307 public void handle(final GenMapType mapType) {
2308 fail();
2309 }
2310
2311 @Override
2312 public void handle(final GenPrimitiveType primitiveType) {
2313 fail();
2314 }
2315
2316 @Override
2317 public void handle(final GenCollectionType collectionType) {
2318 fail();
2319 }
2320
2321 @Override
2322 public void handle(final GenClass cla) {
2323
2324 }
2325
2326 @Override
2327 public void handle(final GenDummyType dummy) {
2328 fail();
2329
2330 }
2331 });
2332 break;
2333 case abstractProduct:
2334 genType.accept(new GenTypeVisitor() {
2335
2336 @Override
2337 public void handle(final GenImportType importType) {
2338 fail();
2339 }
2340
2341 @Override
2342 public void handle(final GenJavaUtilCollection javaUtilCollection) {
2343 fail();
2344 }
2345
2346 @Override
2347 public void handle(final Generic generic) {
2348 fail();
2349 }
2350
2351 @Override
2352 public void handle(final GenMapType mapType) {
2353 fail();
2354 }
2355
2356 @Override
2357 public void handle(final GenPrimitiveType primitiveType) {
2358 fail();
2359 }
2360
2361 @Override
2362 public void handle(final GenCollectionType collectionType) {
2363 fail();
2364 }
2365
2366 @Override
2367 public void handle(final GenClass cla) {
2368
2369 }
2370
2371 @Override
2372 public void handle(final GenDummyType dummy) {
2373 fail();
2374
2375 }
2376 });
2377 break;
2378 case sum:
2379 genType.accept(new GenTypeVisitor() {
2380
2381 @Override
2382 public void handle(final GenImportType importType) {
2383 fail();
2384 }
2385
2386 @Override
2387 public void handle(final GenJavaUtilCollection javaUtilCollection) {
2388 fail();
2389 }
2390
2391 @Override
2392 public void handle(final Generic generic) {
2393 fail();
2394 }
2395
2396 @Override
2397 public void handle(final GenMapType mapType) {
2398 fail();
2399 }
2400
2401 @Override
2402 public void handle(final GenPrimitiveType primitiveType) {
2403 fail();
2404 }
2405
2406 @Override
2407 public void handle(final GenCollectionType collectionType) {
2408 fail();
2409 }
2410
2411 @Override
2412 public void handle(final GenClass cla) {
2413
2414 }
2415
2416 @Override
2417 public void handle(final GenDummyType dummy) {
2418 fail();
2419
2420 }
2421 });
2422 break;
2423 case "Int":
2424 genType.accept(new GenTypeVisitor() {
2425
2426 @Override
2427 public void handle(final GenImportType importType) {
2428 fail();
2429 }
2430
2431 @Override
2432 public void handle(final GenJavaUtilCollection javaUtilCollection) {
2433 fail();
2434 }
2435
2436 @Override
2437 public void handle(final Generic generic) {
2438 fail();
2439 }
2440
2441 @Override
2442 public void handle(final GenMapType mapType) {
2443 fail();
2444 }
2445
2446 @Override
2447 public void handle(final GenPrimitiveType primitiveType) {
2448
2449 }
2450
2451 @Override
2452 public void handle(final GenCollectionType collectionType) {
2453 fail();
2454 }
2455
2456 @Override
2457 public void handle(final GenClass cla) {
2458 fail();
2459 }
2460
2461 @Override
2462 public void handle(final GenDummyType dummy) {
2463 fail();
2464
2465 }
2466 });
2467 break;
2468 case "Anything":
2469 genType.accept(new GenTypeVisitor() {
2470
2471 @Override
2472 public void handle(final GenImportType importType) {
2473 fail();
2474 }
2475
2476 @Override
2477 public void handle(final GenJavaUtilCollection javaUtilCollection) {
2478 fail();
2479 }
2480
2481 @Override
2482 public void handle(final Generic generic) {
2483 fail();
2484 }
2485
2486 @Override
2487 public void handle(final GenMapType mapType) {
2488 fail();
2489 }
2490
2491 @Override
2492 public void handle(final GenPrimitiveType primitiveType) {
2493 fail();
2494 }
2495
2496 @Override
2497 public void handle(final GenCollectionType collectionType) {
2498 fail();
2499 }
2500
2501 @Override
2502 public void handle(final GenClass cla) {
2503
2504 }
2505
2506 @Override
2507 public void handle(final GenDummyType dummy) {
2508 fail();
2509
2510 }
2511 });
2512 break;
2513 default:
2514 fail("Type erwartet und gefunden, wird aber nicht überprüft " + genType.getName());
2515 break;
2516 }
2517
2518 } else {
2519 fail("Type gefunden, die aber nicht erwartet wird. " + genType.getName());
2520 }
2521
2522 }
2523 if (expectedTypes.size() != 0) {
2524 fail("Type erwartet, aber nicht gefunden");
2525 }
2526 }
2527
2528
2529
2530
2531
2532
2533 @Test
2534 public void testClassWithTwoSumAttributesSumsPrototypesAreEqual() throws Exception {
2535 final GeneratorModel javaGeneratorModel =
2536 this.generate(TestModels.classWithTwoSumAttributesSumsPrototypesAreEqual);
2537
2538 final Set<String> expectedClasses = TestUtil.getEverytimeExpectedClasses();
2539 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
2540 expectedClasses.add(product0);
2541 expectedClasses.addAll(TestUtil.getEverytimeExpectedClasses());
2542 expectedClasses.add("generated.model.group1.class1");
2543 final String sum =
2544 TypeNameGenerator.SUM_BEGIN + "Integer" + TypeNameGenerator.SUM_SEPERATE_ELEMENT + "String"
2545 + TypeNameGenerator.SUM_END;
2546 expectedClasses.add("generated.sums." + sum);
2547
2548 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
2549
2550 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
2551 while (i.hasNext()) {
2552 final GenClass genClass = i.next();
2553 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
2554 switch (genClass.getName()) {
2555
2556 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
2557 break;
2558 case "class1":
2559 assertEquals("generated.model.group1", genClass.getPackag().toString());
2560 genClass.accept(new GenClassVisitor() {
2561
2562 @Override
2563 public void handle(final GenInterfaceClass interfaceClass) {
2564 assertEquals(0, interfaceClass.getOperations().size());
2565
2566 interfaceClass.accept(new GenInterfaceClassVisitor() {
2567
2568 @Override
2569 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
2570 final Set<String> operations = new HashSet<>();
2571 operations.add("private generated.model.group1.class1 $getThis()");
2572
2573 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
2574 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
2575 + " get$generatedObjects()");
2576 final Set<String> attributes = new HashSet<>();
2577 attributes.add("private " + PackageConstants.SUM_PACKAGE + "." + sum + " attr1");
2578 attributes.add("private " + PackageConstants.SUM_PACKAGE + "." + sum + " attr2");
2579 attributes.add("private generated.model.group1.class1 This");
2580 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
2581 final Set<String> modifiers = new HashSet<>();
2582 final Set<String> implement = new HashSet<>();
2583 implement.add("generated.model.group1.class1");
2584 assertEquals(true, TestClassTransformer.controlImplClass(
2585 interfaceWithImplClass,
2586 "class1",
2587 "generated.model.group1",
2588 operations,
2589 attributes,
2590 modifiers,
2591 implement));
2592
2593
2594 }
2595
2596 @Override
2597 public void handle(final GenSimpleInterfaceClass simpleInterface) {
2598 fail();
2599 }
2600
2601 @Override
2602 public void handle(final GenExternalInterfaceClass iface) {
2603 fail();
2604 }
2605 });
2606 }
2607
2608 @Override
2609 public void handle(final GenClassClass classClass) {
2610 fail();
2611 }
2612
2613 @Override
2614 public void handle(final GenPrimitiveClass primitiveClass) {
2615 fail();
2616 }
2617 });
2618 break;
2619 case sum:
2620 genClass.accept(new GenClassVisitor() {
2621
2622 @Override
2623 public void handle(final GenInterfaceClass interfaceClass) {
2624 assertEquals(0, interfaceClass.getOperations().size());
2625 }
2626
2627 @Override
2628 public void handle(final GenClassClass classClass) {
2629 fail();
2630 }
2631
2632 @Override
2633 public void handle(final GenPrimitiveClass primitiveClass) {
2634 fail();
2635 }
2636 });
2637 break;
2638 case "Anything":
2639 genClass.accept(new GenClassVisitor() {
2640
2641 @Override
2642 public void handle(final GenInterfaceClass interfaceClass) {
2643 assertEquals(0, interfaceClass.getOperations().size());
2644 }
2645
2646 @Override
2647 public void handle(final GenClassClass classClass) {
2648 fail();
2649 }
2650
2651 @Override
2652 public void handle(final GenPrimitiveClass primitiveClass) {
2653 fail();
2654 }
2655 });
2656 break;
2657 default:
2658 fail("Klasse erwartet und gefunden, wird aber nicht überprüft " + genClass.getName());
2659 break;
2660 }
2661
2662 } else {
2663 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getName());
2664 }
2665
2666 }
2667 if (expectedClasses.size() != 0) {
2668 fail("Klasse erwartet, aber nicht gefunden");
2669 }
2670 final Set<String> expectedTypes = new HashSet<>();
2671 expectedTypes.addAll(TestUtil.getEverytimeExpectedTypes());
2672 expectedTypes.add("generated.model.group1.class1");
2673 expectedTypes.add("generated.sums." + sum);
2674 expectedTypes.add(product0);
2675 assertEquals(expectedTypes.size(), javaGeneratorModel.getTypeMapping().size());
2676
2677 final Iterator<Tuple<GenType, Collection<ExceptionClassType>>> i2 =
2678 javaGeneratorModel.getTypeMapping().values().iterator();
2679 while (i2.hasNext()) {
2680 final GenType genType = i2.next().getA();
2681 if (expectedTypes.remove(genType.getFullyQualifiedTypeName())) {
2682 switch (genType.getName()) {
2683
2684 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
2685 break;
2686 case "class1":
2687 genType.accept(new GenTypeVisitor() {
2688
2689 @Override
2690 public void handle(final GenImportType importType) {
2691 fail();
2692 }
2693
2694 @Override
2695 public void handle(final GenJavaUtilCollection javaUtilCollection) {
2696 fail();
2697 }
2698
2699 @Override
2700 public void handle(final Generic generic) {
2701 fail();
2702 }
2703
2704 @Override
2705 public void handle(final GenMapType mapType) {
2706 fail();
2707 }
2708
2709 @Override
2710 public void handle(final GenPrimitiveType primitiveType) {
2711 fail();
2712 }
2713
2714 @Override
2715 public void handle(final GenCollectionType collectionType) {
2716 fail();
2717 }
2718
2719 @Override
2720 public void handle(final GenClass cla) {
2721
2722 }
2723
2724 @Override
2725 public void handle(final GenDummyType dummy) {
2726 fail();
2727
2728 }
2729 });
2730 break;
2731 case "Str":
2732 genType.accept(new GenTypeVisitor() {
2733
2734 @Override
2735 public void handle(final GenImportType importType) {
2736 fail();
2737 }
2738
2739 @Override
2740 public void handle(final GenJavaUtilCollection javaUtilCollection) {
2741 fail();
2742 }
2743
2744 @Override
2745 public void handle(final Generic generic) {
2746 fail();
2747 }
2748
2749 @Override
2750 public void handle(final GenMapType mapType) {
2751 fail();
2752 }
2753
2754 @Override
2755 public void handle(final GenPrimitiveType primitiveType) {
2756
2757 }
2758
2759 @Override
2760 public void handle(final GenCollectionType collectionType) {
2761 fail();
2762 }
2763
2764 @Override
2765 public void handle(final GenClass cla) {
2766 fail();
2767 }
2768
2769 @Override
2770 public void handle(final GenDummyType dummy) {
2771 fail();
2772
2773 }
2774 });
2775 break;
2776 case "Int":
2777 genType.accept(new GenTypeVisitor() {
2778
2779 @Override
2780 public void handle(final GenImportType importType) {
2781 fail();
2782 }
2783
2784 @Override
2785 public void handle(final GenJavaUtilCollection javaUtilCollection) {
2786 fail();
2787 }
2788
2789 @Override
2790 public void handle(final Generic generic) {
2791 fail();
2792 }
2793
2794 @Override
2795 public void handle(final GenMapType mapType) {
2796 fail();
2797 }
2798
2799 @Override
2800 public void handle(final GenPrimitiveType primitiveType) {
2801
2802 }
2803
2804 @Override
2805 public void handle(final GenCollectionType collectionType) {
2806 fail();
2807 }
2808
2809 @Override
2810 public void handle(final GenClass cla) {
2811 fail();
2812 }
2813
2814 @Override
2815 public void handle(final GenDummyType dummy) {
2816 fail();
2817
2818 }
2819 });
2820 break;
2821 case sum:
2822 genType.accept(new GenTypeVisitor() {
2823
2824 @Override
2825 public void handle(final GenImportType importType) {
2826 fail();
2827 }
2828
2829 @Override
2830 public void handle(final GenJavaUtilCollection javaUtilCollection) {
2831 fail();
2832 }
2833
2834 @Override
2835 public void handle(final Generic generic) {
2836 fail();
2837 }
2838
2839 @Override
2840 public void handle(final GenMapType mapType) {
2841 fail();
2842 }
2843
2844 @Override
2845 public void handle(final GenPrimitiveType primitiveType) {
2846 fail();
2847 }
2848
2849 @Override
2850 public void handle(final GenCollectionType collectionType) {
2851 fail();
2852 }
2853
2854 @Override
2855 public void handle(final GenClass cla) {
2856
2857 }
2858
2859 @Override
2860 public void handle(final GenDummyType dummy) {
2861 fail();
2862
2863 }
2864 });
2865 break;
2866 case "Anything":
2867 genType.accept(new GenTypeVisitor() {
2868
2869 @Override
2870 public void handle(final GenImportType importType) {
2871 fail();
2872 }
2873
2874 @Override
2875 public void handle(final GenJavaUtilCollection javaUtilCollection) {
2876 fail();
2877 }
2878
2879 @Override
2880 public void handle(final Generic generic) {
2881 fail();
2882 }
2883
2884 @Override
2885 public void handle(final GenMapType mapType) {
2886 fail();
2887 }
2888
2889 @Override
2890 public void handle(final GenPrimitiveType primitiveType) {
2891 fail();
2892 }
2893
2894 @Override
2895 public void handle(final GenCollectionType collectionType) {
2896 fail();
2897 }
2898
2899 @Override
2900 public void handle(final GenClass cla) {
2901
2902 }
2903
2904 @Override
2905 public void handle(final GenDummyType dummy) {
2906 fail();
2907
2908 }
2909 });
2910 break;
2911 default:
2912 fail("Type erwartet und gefunden, wird aber nicht überprüft" + genType.getName());
2913 break;
2914 }
2915
2916 } else {
2917 fail("Type gefunden, die aber nicht erwartet wird." + genType.getName());
2918 }
2919
2920 }
2921 if (expectedTypes.size() != 0) {
2922 fail("Type erwartet, aber nicht gefunden");
2923 }
2924 }
2925
2926
2927
2928
2929
2930
2931 @Test
2932 public void testClassWithListAttribute() throws Exception {
2933 final GeneratorModel javaGeneratorModel = this.generate(TestModels.classWithListAttribute);
2934
2935 final Set<String> expectedClasses = TestUtil.getEverytimeExpectedClasses();
2936 expectedClasses.addAll(TestUtil.getEverytimeExpectedClasses());
2937 expectedClasses.add("generated.model.group1.class1");
2938 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
2939 expectedClasses.add(product0);
2940
2941 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
2942
2943 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
2944 while (i.hasNext()) {
2945 final GenClass genClass = i.next();
2946 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
2947 switch (genClass.getName()) {
2948 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
2949 break;
2950 case "class1":
2951 assertEquals("generated.model.group1", genClass.getPackag().toString());
2952 genClass.accept(new GenClassVisitor() {
2953
2954 @Override
2955 public void handle(final GenInterfaceClass interfaceClass) {
2956 assertEquals(0, interfaceClass.getOperations().size());
2957
2958 interfaceClass.accept(new GenInterfaceClassVisitor() {
2959
2960 @Override
2961 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
2962 final Set<String> operations = new HashSet<>();
2963 operations.add("private generated.model.group1.class1 $getThis()");
2964 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
2965 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
2966 + " get$generatedObjects()");
2967 final Set<String> attributes = new HashSet<>();
2968 attributes
2969 .add("private de.fhdw.wtf.context.model.collections.MutableList<de.fhdw.wtf.context.model.Str> attr1");
2970 attributes.add("private generated.model.group1.class1 This");
2971 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
2972 final Set<String> modifiers = new HashSet<>();
2973 final Set<String> implement = new HashSet<>();
2974 implement.add("generated.model.group1.class1");
2975 assertEquals(true, TestClassTransformer.controlImplClass(
2976 interfaceWithImplClass,
2977 "class1",
2978 "generated.model.group1",
2979 operations,
2980 attributes,
2981 modifiers,
2982 implement));
2983
2984
2985
2986 }
2987
2988 @Override
2989 public void handle(final GenSimpleInterfaceClass simpleInterface) {
2990 fail();
2991 }
2992
2993 @Override
2994 public void handle(final GenExternalInterfaceClass iface) {
2995 fail();
2996 }
2997 });
2998 }
2999
3000 @Override
3001 public void handle(final GenClassClass classClass) {
3002 fail();
3003 }
3004
3005 @Override
3006 public void handle(final GenPrimitiveClass primitiveClass) {
3007 fail();
3008 }
3009 });
3010 break;
3011 case "Anything":
3012 genClass.accept(new GenClassVisitor() {
3013
3014 @Override
3015 public void handle(final GenInterfaceClass interfaceClass) {
3016 assertEquals(0, interfaceClass.getOperations().size());
3017 }
3018
3019 @Override
3020 public void handle(final GenClassClass classClass) {
3021 fail();
3022 }
3023
3024 @Override
3025 public void handle(final GenPrimitiveClass primitiveClass) {
3026 fail();
3027 }
3028 });
3029 break;
3030 default:
3031 fail("Klasse erwartet und gefunden, wird aber nicht überprüft " + genClass.getName());
3032 break;
3033 }
3034
3035 } else {
3036 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getName());
3037 }
3038
3039 }
3040 if (expectedClasses.size() != 0) {
3041 fail("Klasse erwartet, aber nicht gefunden");
3042 }
3043 final Set<String> expectedTypes = new HashSet<>();
3044 expectedTypes.addAll(TestUtil.getEverytimeExpectedTypes());
3045 expectedTypes.add("generated.model.group1.class1");
3046
3047
3048
3049
3050 expectedTypes.add("de.fhdw.wtf.context.model.collections.MutableList");
3051 expectedTypes.add(product0);
3052 assertEquals(expectedTypes.size(), javaGeneratorModel.getTypeMapping().size());
3053
3054 final Iterator<Tuple<GenType, Collection<ExceptionClassType>>> i2 =
3055 javaGeneratorModel.getTypeMapping().values().iterator();
3056 while (i2.hasNext()) {
3057 final GenType genType = i2.next().getA();
3058 if (expectedTypes.remove(genType.getFullyQualifiedTypeName())) {
3059 switch (genType.getName()) {
3060 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
3061 break;
3062 case "class1":
3063 genType.accept(new GenTypeVisitor() {
3064
3065 @Override
3066 public void handle(final GenImportType importType) {
3067 fail();
3068 }
3069
3070 @Override
3071 public void handle(final GenJavaUtilCollection javaUtilCollection) {
3072 fail();
3073 }
3074
3075 @Override
3076 public void handle(final Generic generic) {
3077 fail();
3078 }
3079
3080 @Override
3081 public void handle(final GenMapType mapType) {
3082 fail();
3083 }
3084
3085 @Override
3086 public void handle(final GenPrimitiveType primitiveType) {
3087 fail();
3088 }
3089
3090 @Override
3091 public void handle(final GenCollectionType collectionType) {
3092 fail();
3093 }
3094
3095 @Override
3096 public void handle(final GenClass cla) {
3097
3098 }
3099
3100 @Override
3101 public void handle(final GenDummyType dummy) {
3102 fail();
3103
3104 }
3105 });
3106 break;
3107 case "MutableList":
3108 genType.accept(new GenTypeVisitor() {
3109
3110 @Override
3111 public void handle(final GenImportType importType) {
3112 fail();
3113 }
3114
3115 @Override
3116 public void handle(final GenJavaUtilCollection javaUtilCollection) {
3117 fail();
3118 }
3119
3120 @Override
3121 public void handle(final Generic generic) {
3122 fail();
3123 }
3124
3125 @Override
3126 public void handle(final GenMapType mapType) {
3127 fail();
3128 }
3129
3130 @Override
3131 public void handle(final GenPrimitiveType primitiveType) {
3132 fail();
3133 }
3134
3135 @Override
3136 public void handle(final GenCollectionType collectionType) {
3137
3138 }
3139
3140 @Override
3141 public void handle(final GenClass cla) {
3142
3143 fail();
3144 }
3145
3146 @Override
3147 public void handle(final GenDummyType dummy) {
3148 fail();
3149
3150 }
3151 });
3152 break;
3153 case "Str":
3154 genType.accept(new GenTypeVisitor() {
3155
3156 @Override
3157 public void handle(final GenImportType importType) {
3158 fail();
3159 }
3160
3161 @Override
3162 public void handle(final GenJavaUtilCollection javaUtilCollection) {
3163 fail();
3164 }
3165
3166 @Override
3167 public void handle(final Generic generic) {
3168 fail();
3169 }
3170
3171 @Override
3172 public void handle(final GenMapType mapType) {
3173 fail();
3174 }
3175
3176 @Override
3177 public void handle(final GenPrimitiveType primitiveType) {
3178
3179 }
3180
3181 @Override
3182 public void handle(final GenCollectionType collectionType) {
3183 fail();
3184 }
3185
3186 @Override
3187 public void handle(final GenClass cla) {
3188 fail();
3189 }
3190
3191 @Override
3192 public void handle(final GenDummyType dummy) {
3193 fail();
3194
3195 }
3196 });
3197 break;
3198 case "Int":
3199 genType.accept(new GenTypeVisitor() {
3200
3201 @Override
3202 public void handle(final GenImportType importType) {
3203 fail();
3204 }
3205
3206 @Override
3207 public void handle(final GenJavaUtilCollection javaUtilCollection) {
3208 fail();
3209 }
3210
3211 @Override
3212 public void handle(final Generic generic) {
3213 fail();
3214 }
3215
3216 @Override
3217 public void handle(final GenMapType mapType) {
3218 fail();
3219 }
3220
3221 @Override
3222 public void handle(final GenPrimitiveType primitiveType) {
3223
3224 }
3225
3226 @Override
3227 public void handle(final GenCollectionType collectionType) {
3228 fail();
3229 }
3230
3231 @Override
3232 public void handle(final GenClass cla) {
3233 fail();
3234 }
3235
3236 @Override
3237 public void handle(final GenDummyType dummy) {
3238 fail();
3239
3240 }
3241 });
3242 break;
3243 case "Anything":
3244 genType.accept(new GenTypeVisitor() {
3245
3246 @Override
3247 public void handle(final GenImportType importType) {
3248 fail();
3249 }
3250
3251 @Override
3252 public void handle(final GenJavaUtilCollection javaUtilCollection) {
3253 fail();
3254 }
3255
3256 @Override
3257 public void handle(final Generic generic) {
3258 fail();
3259 }
3260
3261 @Override
3262 public void handle(final GenMapType mapType) {
3263 fail();
3264 }
3265
3266 @Override
3267 public void handle(final GenPrimitiveType primitiveType) {
3268 fail();
3269 }
3270
3271 @Override
3272 public void handle(final GenCollectionType collectionType) {
3273 fail();
3274 }
3275
3276 @Override
3277 public void handle(final GenClass cla) {
3278
3279 }
3280
3281 @Override
3282 public void handle(final GenDummyType dummy) {
3283 fail();
3284
3285 }
3286 });
3287 break;
3288 default:
3289 fail("Type erwartet und gefunden, wird aber nicht überprüft" + genType.getName());
3290 break;
3291 }
3292
3293 } else {
3294 fail("Type gefunden, die aber nicht erwartet wird." + genType.getName());
3295 }
3296
3297 }
3298 if (expectedTypes.size() != 0) {
3299 fail("Type erwartet, aber nicht gefunden");
3300 }
3301 }
3302
3303
3304
3305
3306
3307
3308 @Test
3309 public void testClassWithVoidOperation() throws Exception {
3310 final GeneratorModel javaGeneratorModel = this.generate(TestModels.classWithVoidOperation);
3311 final Set<String> expectedClasses = TestUtil.getEverytimeExpectedClasses();
3312 expectedClasses.addAll(TestUtil.getEverytimeExpectedClasses());
3313 expectedClasses.add("generated.model.group1.class1");
3314 final String product = TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
3315 expectedClasses.add("generated.products." + product);
3316
3317 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().values().size());
3318
3319 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
3320 while (i.hasNext()) {
3321 final GenClass genClass = i.next();
3322 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
3323 switch (genClass.getName()) {
3324 case "class1":
3325 assertEquals("generated.model.group1", genClass.getPackag().toString());
3326 genClass.accept(new GenClassVisitor() {
3327
3328 @Override
3329 public void handle(final GenInterfaceClass interfaceClass) {
3330 assertEquals(1, interfaceClass.getOperations().size());
3331 assertEquals("op", interfaceClass.getOperations().iterator().next().getName());
3332
3333 interfaceClass.accept(new GenInterfaceClassVisitor() {
3334
3335 @Override
3336 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
3337 final Set<String> operations = new HashSet<>();
3338 operations.add("private generated.model.group1.class1 $getThis()");
3339 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
3340 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
3341 + " get$generatedObjects()");
3342 operations.add("public void op()");
3343 final Set<String> attributes = new HashSet<>();
3344 attributes.add("private generated.model.group1.class1 This");
3345 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
3346 final Set<String> modifiers = new HashSet<>();
3347 final Set<String> implement = new HashSet<>();
3348 implement.add("generated.model.group1.class1");
3349 assertEquals(true, TestClassTransformer.controlImplClass(
3350 interfaceWithImplClass,
3351 "class1",
3352 "generated.model.group1",
3353 operations,
3354 attributes,
3355 modifiers,
3356 implement));
3357
3358 }
3359
3360 @Override
3361 public void handle(final GenSimpleInterfaceClass simpleInterface) {
3362 fail();
3363 }
3364
3365 @Override
3366 public void handle(final GenExternalInterfaceClass iface) {
3367 fail();
3368 }
3369 });
3370 }
3371
3372 @Override
3373 public void handle(final GenClassClass classClass) {
3374 fail();
3375 }
3376
3377 @Override
3378 public void handle(final GenPrimitiveClass primitiveClass) {
3379 fail();
3380 }
3381 });
3382 break;
3383 case product:
3384 genClass.accept(new GenClassVisitor() {
3385
3386 @Override
3387 public void handle(final GenInterfaceClass interfaceClass) {
3388 fail();
3389 }
3390
3391 @Override
3392 public void handle(final GenClassClass classClass) {
3393 assertEquals(0, classClass.getOperations().size());
3394 assertEquals(0, classClass.getAttributes().size());
3395 assertEquals(0, classClass.getModifieres().size());
3396 }
3397
3398 @Override
3399 public void handle(final GenPrimitiveClass primitiveClass) {
3400 fail();
3401 }
3402 });
3403 break;
3404 case "Anything":
3405 genClass.accept(new GenClassVisitor() {
3406
3407 @Override
3408 public void handle(final GenInterfaceClass interfaceClass) {
3409 assertEquals(0, interfaceClass.getOperations().size());
3410 }
3411
3412 @Override
3413 public void handle(final GenClassClass classClass) {
3414 fail();
3415 }
3416
3417 @Override
3418 public void handle(final GenPrimitiveClass primitiveClass) {
3419 fail();
3420 }
3421 });
3422 break;
3423 default:
3424 fail("Klasse erwartet und gefunden, wird aber nicht überprüft " + genClass.getName());
3425 break;
3426 }
3427
3428 } else {
3429 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getName());
3430 }
3431
3432 }
3433 if (expectedClasses.size() != 0) {
3434 fail("Klasse erwartet, aber nicht gefunden");
3435 }
3436 final Set<String> expectedTypes = new HashSet<>();
3437 expectedTypes.addAll(TestUtil.getEverytimeExpectedTypes());
3438 final String voidType = "void";
3439 expectedTypes.add(voidType);
3440 expectedTypes.add("generated.products." + product);
3441 expectedTypes.add("generated.model.group1.class1");
3442 assertEquals(expectedTypes.size(), javaGeneratorModel.getTypeMapping().size());
3443
3444 final Iterator<Tuple<GenType, Collection<ExceptionClassType>>> i2 =
3445 javaGeneratorModel.getTypeMapping().values().iterator();
3446 while (i2.hasNext()) {
3447 final GenType genType = i2.next().getA();
3448 if (expectedTypes.remove(genType.getFullyQualifiedTypeName())) {
3449 switch (genType.getName()) {
3450 case "class1":
3451 genType.accept(new GenTypeVisitor() {
3452
3453 @Override
3454 public void handle(final GenImportType importType) {
3455 fail();
3456 }
3457
3458 @Override
3459 public void handle(final GenJavaUtilCollection javaUtilCollection) {
3460 fail();
3461 }
3462
3463 @Override
3464 public void handle(final Generic generic) {
3465 fail();
3466 }
3467
3468 @Override
3469 public void handle(final GenMapType mapType) {
3470 fail();
3471 }
3472
3473 @Override
3474 public void handle(final GenPrimitiveType primitiveType) {
3475 fail();
3476 }
3477
3478 @Override
3479 public void handle(final GenCollectionType collectionType) {
3480 fail();
3481 }
3482
3483 @Override
3484 public void handle(final GenClass cla) {
3485
3486 }
3487
3488 @Override
3489 public void handle(final GenDummyType dummy) {
3490 fail();
3491
3492 }
3493 });
3494 break;
3495 case product:
3496 genType.accept(new GenTypeVisitor() {
3497
3498 @Override
3499 public void handle(final GenImportType importType) {
3500 fail();
3501 }
3502
3503 @Override
3504 public void handle(final GenJavaUtilCollection javaUtilCollection) {
3505 fail();
3506 }
3507
3508 @Override
3509 public void handle(final Generic generic) {
3510 fail();
3511 }
3512
3513 @Override
3514 public void handle(final GenMapType mapType) {
3515 fail();
3516 }
3517
3518 @Override
3519 public void handle(final GenPrimitiveType primitiveType) {
3520 fail();
3521 }
3522
3523 @Override
3524 public void handle(final GenCollectionType collectionType) {
3525 fail();
3526 }
3527
3528 @Override
3529 public void handle(final GenClass cla) {
3530
3531 }
3532
3533 @Override
3534 public void handle(final GenDummyType dummy) {
3535 fail();
3536
3537 }
3538 });
3539 break;
3540 case voidType:
3541 genType.accept(new GenTypeVisitor() {
3542
3543 @Override
3544 public void handle(final GenImportType importType) {
3545 fail();
3546 }
3547
3548 @Override
3549 public void handle(final GenJavaUtilCollection javaUtilCollection) {
3550 fail();
3551 }
3552
3553 @Override
3554 public void handle(final Generic generic) {
3555 fail();
3556 }
3557
3558 @Override
3559 public void handle(final GenMapType mapType) {
3560 fail();
3561 }
3562
3563 @Override
3564 public void handle(final GenPrimitiveType primitiveType) {
3565
3566 }
3567
3568 @Override
3569 public void handle(final GenCollectionType collectionType) {
3570 fail();
3571 }
3572
3573 @Override
3574 public void handle(final GenClass cla) {
3575 fail();
3576 }
3577
3578 @Override
3579 public void handle(final GenDummyType dummy) {
3580 fail();
3581
3582 }
3583 });
3584 break;
3585 case "Int":
3586 genType.accept(new GenTypeVisitor() {
3587
3588 @Override
3589 public void handle(final GenImportType importType) {
3590 fail();
3591 }
3592
3593 @Override
3594 public void handle(final GenJavaUtilCollection javaUtilCollection) {
3595 fail();
3596 }
3597
3598 @Override
3599 public void handle(final Generic generic) {
3600 fail();
3601 }
3602
3603 @Override
3604 public void handle(final GenMapType mapType) {
3605 fail();
3606 }
3607
3608 @Override
3609 public void handle(final GenPrimitiveType primitiveType) {
3610
3611 }
3612
3613 @Override
3614 public void handle(final GenCollectionType collectionType) {
3615 fail();
3616 }
3617
3618 @Override
3619 public void handle(final GenClass cla) {
3620 fail();
3621 }
3622
3623 @Override
3624 public void handle(final GenDummyType dummy) {
3625 fail();
3626
3627 }
3628 });
3629 break;
3630 case "Anything":
3631 genType.accept(new GenTypeVisitor() {
3632
3633 @Override
3634 public void handle(final GenImportType importType) {
3635 fail();
3636 }
3637
3638 @Override
3639 public void handle(final GenJavaUtilCollection javaUtilCollection) {
3640 fail();
3641 }
3642
3643 @Override
3644 public void handle(final Generic generic) {
3645 fail();
3646 }
3647
3648 @Override
3649 public void handle(final GenMapType mapType) {
3650 fail();
3651 }
3652
3653 @Override
3654 public void handle(final GenPrimitiveType primitiveType) {
3655 fail();
3656 }
3657
3658 @Override
3659 public void handle(final GenCollectionType collectionType) {
3660 fail();
3661 }
3662
3663 @Override
3664 public void handle(final GenClass cla) {
3665
3666 }
3667
3668 @Override
3669 public void handle(final GenDummyType dummy) {
3670 fail();
3671
3672 }
3673 });
3674 break;
3675 case "Str":
3676 genType.accept(new GenTypeVisitor() {
3677
3678 @Override
3679 public void handle(final GenImportType importType) {
3680 fail();
3681 }
3682
3683 @Override
3684 public void handle(final GenJavaUtilCollection javaUtilCollection) {
3685 fail();
3686 }
3687
3688 @Override
3689 public void handle(final Generic generic) {
3690 fail();
3691 }
3692
3693 @Override
3694 public void handle(final GenMapType mapType) {
3695 fail();
3696 }
3697
3698 @Override
3699 public void handle(final GenPrimitiveType primitiveType) {
3700
3701 }
3702
3703 @Override
3704 public void handle(final GenCollectionType collectionType) {
3705 fail();
3706 }
3707
3708 @Override
3709 public void handle(final GenClass cla) {
3710 fail();
3711 }
3712
3713 @Override
3714 public void handle(final GenDummyType dummy) {
3715 fail();
3716
3717 }
3718 });
3719 break;
3720 default:
3721 fail("Type erwartet und gefunden, wird aber nicht überprüft" + genType.getName());
3722 break;
3723 }
3724
3725 } else {
3726 fail("Type gefunden, die aber nicht erwartet wird." + genType.getName());
3727 }
3728
3729 }
3730 if (expectedTypes.size() != 0) {
3731 fail("Type erwartet, aber nicht gefunden");
3732 }
3733 }
3734
3735
3736
3737
3738
3739
3740 @Test
3741 @Ignore("not all expectedTypes are checked")
3742 public void testClassWithSumAttributeWhichContainsManyCompositeTypes() throws Exception {
3743 final GeneratorModel javaGeneratorModel =
3744 this.generate(TestModels.classWithSumAttributeWhichContainsManyCompositeTypes);
3745 final Set<String> expectedClasses = TestUtil.getEverytimeExpectedClasses();
3746 expectedClasses.addAll(TestUtil.getEverytimeExpectedClasses());
3747 expectedClasses.add("generated.model.group1.class1");
3748 expectedClasses.add("generated.model.group1.class2");
3749 final String sum =
3750 TypeNameGenerator.SUM_BEGIN + "Integer" + TypeNameGenerator.SUM_SEPERATE_ELEMENT + "String"
3751 + TypeNameGenerator.SUM_SEPERATE_ELEMENT + "class2" + TypeNameGenerator.SUM_SEPERATE_ELEMENT
3752 + TypeNameGenerator.LIST_BEGIN + "String" + TypeNameGenerator.LIST_END
3753 + TypeNameGenerator.SUM_SEPERATE_ELEMENT + TypeNameGenerator.LIST_BEGIN
3754 + TypeNameGenerator.LIST_BEGIN + "Integer" + TypeNameGenerator.LIST_END
3755 + TypeNameGenerator.LIST_END + TypeNameGenerator.SUM_SEPERATE_ELEMENT
3756 + TypeNameGenerator.MAP_BEGIN + "String" + TypeNameGenerator.MAP_SEPERATE_KEY_AND_VALUE
3757 + "Integer" + TypeNameGenerator.MAP_END + TypeNameGenerator.SUM_SEPERATE_ELEMENT
3758 + TypeNameGenerator.PRODUCT_BEGIN + "name" + TypeNameGenerator.PRODUCT_SEPERATE_TYPE_AND_NAME
3759 + "String" + TypeNameGenerator.PRODUCT_SEPERATE_ATTRIBUTES + "alter"
3760 + TypeNameGenerator.PRODUCT_SEPERATE_TYPE_AND_NAME + "Integer" + TypeNameGenerator.PRODUCT_END
3761 + TypeNameGenerator.SUM_END;
3762
3763 expectedClasses.add("generated.sums." + sum);
3764 final String product =
3765 TypeNameGenerator.PRODUCT_BEGIN + "name" + TypeNameGenerator.PRODUCT_SEPERATE_TYPE_AND_NAME + "String"
3766 + TypeNameGenerator.PRODUCT_SEPERATE_ATTRIBUTES + "alter"
3767 + TypeNameGenerator.PRODUCT_SEPERATE_TYPE_AND_NAME + "Integer" + TypeNameGenerator.PRODUCT_END;
3768 expectedClasses.add("generated.products." + product);
3769 final String product2 =
3770 TypeNameGenerator.PRODUCT_BEGIN + "p$1" + TypeNameGenerator.PRODUCT_SEPERATE_TYPE_AND_NAME + "String"
3771 + TypeNameGenerator.PRODUCT_SEPERATE_ATTRIBUTES + "p$2"
3772 + TypeNameGenerator.PRODUCT_SEPERATE_TYPE_AND_NAME + "Integer" + TypeNameGenerator.PRODUCT_END;
3773 expectedClasses.add("generated.products." + product2);
3774
3775 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
3776
3777 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
3778 while (i.hasNext()) {
3779 final GenClass genClass = i.next();
3780 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
3781 switch (genClass.getName()) {
3782 case "class1":
3783 assertEquals("generated.model.group1", genClass.getPackag().toString());
3784 genClass.accept(new GenClassVisitor() {
3785
3786 @Override
3787 public void handle(final GenInterfaceClass interfaceClass) {
3788 assertEquals(0, interfaceClass.getOperations().size());
3789
3790 interfaceClass.accept(new GenInterfaceClassVisitor() {
3791
3792 @Override
3793 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
3794 final Set<String> operations = new HashSet<>();
3795 final Set<String> attributes = new HashSet<>();
3796 attributes.add("private final " + sum + " att1");
3797 final Set<String> modifiers = new HashSet<>();
3798 final Set<String> implement = new HashSet<>();
3799 implement.add("generated.model.group1.class1");
3800 assertEquals(true, TestClassTransformer.controlImplClass(
3801 interfaceWithImplClass,
3802 "class1",
3803 "generated.model.group1",
3804 operations,
3805 attributes,
3806 modifiers,
3807 implement));
3808
3809 }
3810
3811 @Override
3812 public void handle(final GenSimpleInterfaceClass simpleInterface) {
3813 fail();
3814 }
3815
3816 @Override
3817 public void handle(final GenExternalInterfaceClass iface) {
3818 fail();
3819 }
3820 });
3821 }
3822
3823 @Override
3824 public void handle(final GenClassClass classClass) {
3825 fail();
3826 }
3827
3828 @Override
3829 public void handle(final GenPrimitiveClass primitiveClass) {
3830 fail();
3831 }
3832 });
3833 break;
3834 case "class2":
3835 assertEquals("generated.model.group1", genClass.getPackag().toString());
3836 genClass.accept(new GenClassVisitor() {
3837
3838 @Override
3839 public void handle(final GenInterfaceClass interfaceClass) {
3840 assertEquals(0, interfaceClass.getOperations().size());
3841
3842 interfaceClass.accept(new GenInterfaceClassVisitor() {
3843
3844 @Override
3845 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
3846 final Set<String> operations = new HashSet<>();
3847 final Set<String> attributes = new HashSet<>();
3848 final Set<String> modifiers = new HashSet<>();
3849 final Set<String> implement = new HashSet<>();
3850 implement.add("generated.model.group1.class2");
3851 assertEquals(true, TestClassTransformer.controlImplClass(
3852 interfaceWithImplClass,
3853 "class2",
3854 "generated.model.group1",
3855 operations,
3856 attributes,
3857 modifiers,
3858 implement));
3859
3860 }
3861
3862 @Override
3863 public void handle(final GenSimpleInterfaceClass simpleInterface) {
3864 fail();
3865 }
3866
3867 @Override
3868 public void handle(final GenExternalInterfaceClass iface) {
3869 fail();
3870 }
3871 });
3872 }
3873
3874 @Override
3875 public void handle(final GenClassClass classClass) {
3876 fail();
3877 }
3878
3879 @Override
3880 public void handle(final GenPrimitiveClass primitiveClass) {
3881 fail();
3882 }
3883 });
3884 break;
3885 case sum:
3886 genClass.accept(new GenClassVisitor() {
3887
3888 @Override
3889 public void handle(final GenInterfaceClass interfaceClass) {
3890 interfaceClass.accept(new GenInterfaceClassVisitor() {
3891
3892 @Override
3893 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
3894 fail();
3895 }
3896
3897 @Override
3898 public void handle(final GenSimpleInterfaceClass simpleInterface) {
3899 assertEquals(0, simpleInterface.getOperations().size());
3900 }
3901
3902 @Override
3903 public void handle(final GenExternalInterfaceClass iface) {
3904 fail();
3905 }
3906 });
3907 }
3908
3909 @Override
3910 public void handle(final GenClassClass classClass) {
3911 fail();
3912 }
3913
3914 @Override
3915 public void handle(final GenPrimitiveClass primitiveClass) {
3916 fail();
3917 }
3918 });
3919 break;
3920 case product:
3921 genClass.accept(new GenClassVisitor() {
3922
3923 @Override
3924 public void handle(final GenInterfaceClass interfaceClass) {
3925 fail();
3926 }
3927
3928 @Override
3929 public void handle(final GenClassClass classClass) {
3930 assertEquals(0, classClass.getOperations().size());
3931 assertEquals(0, classClass.getAttributes().size());
3932 assertEquals(0, classClass.getModifieres().size());
3933 }
3934
3935 @Override
3936 public void handle(final GenPrimitiveClass primitiveClass) {
3937 fail();
3938 }
3939 });
3940 break;
3941 case product2:
3942 genClass.accept(new GenClassVisitor() {
3943
3944 @Override
3945 public void handle(final GenInterfaceClass interfaceClass) {
3946 fail();
3947 }
3948
3949 @Override
3950 public void handle(final GenClassClass classClass) {
3951 assertEquals(0, classClass.getOperations().size());
3952 assertEquals(2, classClass.getAttributes().size());
3953 assertEquals(0, classClass.getModifieres().size());
3954 }
3955
3956 @Override
3957 public void handle(final GenPrimitiveClass primitiveClass) {
3958 fail();
3959 }
3960 });
3961 break;
3962 case "Anything":
3963 genClass.accept(new GenClassVisitor() {
3964
3965 @Override
3966 public void handle(final GenInterfaceClass interfaceClass) {
3967 assertEquals(0, interfaceClass.getOperations().size());
3968 }
3969
3970 @Override
3971 public void handle(final GenClassClass classClass) {
3972 fail();
3973 }
3974
3975 @Override
3976 public void handle(final GenPrimitiveClass primitiveClass) {
3977 fail();
3978 }
3979 });
3980 break;
3981 default:
3982 fail("Klasse erwartet und gefunden, wird aber nicht überprüft " + genClass.getName());
3983 break;
3984 }
3985
3986 } else {
3987 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getName());
3988 }
3989
3990 }
3991 if (expectedClasses.size() != 0) {
3992 fail("Klasse erwartet, aber nicht gefunden");
3993 }
3994 final Set<String> expectedTypes = new HashSet<>();
3995 expectedTypes.addAll(TestUtil.getEverytimeExpectedTypes());
3996 expectedTypes.add("generated.products." + product);
3997 expectedTypes.add("generated.model.group1.class1");
3998 expectedTypes.add("generated.model.group1.class2");
3999 expectedTypes.add("generated.sums." + sum);
4000 expectedTypes.add("generated.products." + product2);
4001
4002
4003
4004
4005
4006 expectedTypes.add("MutableList");
4007 final String map =
4008 TypeNameGenerator.MAP_BEGIN + "String" + TypeNameGenerator.MAP_SEPERATE_KEY_AND_VALUE + "Integer"
4009 + TypeNameGenerator.MAP_END;
4010 expectedTypes.add(map);
4011 expectedTypes.add("generated.sums." + sum);
4012
4013 assertEquals(expectedTypes.size(), javaGeneratorModel.getTypeMapping().size());
4014
4015 final Iterator<Tuple<GenType, Collection<ExceptionClassType>>> i2 =
4016 javaGeneratorModel.getTypeMapping().values().iterator();
4017 while (i2.hasNext()) {
4018 final GenType genType = i2.next().getA();
4019 if (expectedTypes.remove(genType.getFullyQualifiedTypeName())) {
4020 switch (genType.getName()) {
4021 case "class1":
4022 genType.accept(new GenTypeVisitor() {
4023
4024 @Override
4025 public void handle(final GenImportType importType) {
4026 fail();
4027 }
4028
4029 @Override
4030 public void handle(final GenJavaUtilCollection javaUtilCollection) {
4031 fail();
4032 }
4033
4034 @Override
4035 public void handle(final Generic generic) {
4036 fail();
4037 }
4038
4039 @Override
4040 public void handle(final GenMapType mapType) {
4041 fail();
4042 }
4043
4044 @Override
4045 public void handle(final GenPrimitiveType primitiveType) {
4046 fail();
4047 }
4048
4049 @Override
4050 public void handle(final GenCollectionType collectionType) {
4051 fail();
4052 }
4053
4054 @Override
4055 public void handle(final GenClass cla) {
4056
4057 }
4058
4059 @Override
4060 public void handle(final GenDummyType dummy) {
4061 fail();
4062
4063 }
4064 });
4065 break;
4066 case "class2":
4067 genType.accept(new GenTypeVisitor() {
4068
4069 @Override
4070 public void handle(final GenImportType importType) {
4071 fail();
4072 }
4073
4074 @Override
4075 public void handle(final GenJavaUtilCollection javaUtilCollection) {
4076 fail();
4077 }
4078
4079 @Override
4080 public void handle(final Generic generic) {
4081 fail();
4082 }
4083
4084 @Override
4085 public void handle(final GenMapType mapType) {
4086 fail();
4087 }
4088
4089 @Override
4090 public void handle(final GenPrimitiveType primitiveType) {
4091 fail();
4092 }
4093
4094 @Override
4095 public void handle(final GenCollectionType collectionType) {
4096 fail();
4097 }
4098
4099 @Override
4100 public void handle(final GenClass cla) {
4101
4102 }
4103
4104 @Override
4105 public void handle(final GenDummyType dummy) {
4106 fail();
4107
4108 }
4109 });
4110 break;
4111 case "MutableList":
4112 genType.accept(new GenTypeVisitor() {
4113
4114 @Override
4115 public void handle(final GenImportType importType) {
4116 fail();
4117 }
4118
4119 @Override
4120 public void handle(final GenJavaUtilCollection javaUtilCollection) {
4121 fail();
4122 }
4123
4124 @Override
4125 public void handle(final Generic generic) {
4126 fail();
4127 }
4128
4129 @Override
4130 public void handle(final GenMapType mapType) {
4131 fail();
4132 }
4133
4134 @Override
4135 public void handle(final GenPrimitiveType primitiveType) {
4136 fail();
4137 }
4138
4139 @Override
4140 public void handle(final GenCollectionType collectionType) {
4141
4142 }
4143
4144 @Override
4145 public void handle(final GenClass cla) {
4146 fail();
4147 }
4148
4149 @Override
4150 public void handle(final GenDummyType dummy) {
4151 fail();
4152
4153 }
4154 });
4155 break;
4156 case map:
4157 genType.accept(new GenTypeVisitor() {
4158
4159 @Override
4160 public void handle(final GenImportType importType) {
4161 fail();
4162 }
4163
4164 @Override
4165 public void handle(final GenJavaUtilCollection javaUtilCollection) {
4166 fail();
4167 }
4168
4169 @Override
4170 public void handle(final Generic generic) {
4171 fail();
4172 }
4173
4174 @Override
4175 public void handle(final GenMapType mapType) {
4176
4177 }
4178
4179 @Override
4180 public void handle(final GenPrimitiveType primitiveType) {
4181 fail();
4182 }
4183
4184 @Override
4185 public void handle(final GenCollectionType collectionType) {
4186 fail();
4187 }
4188
4189 @Override
4190 public void handle(final GenClass cla) {
4191 fail();
4192 }
4193
4194 @Override
4195 public void handle(final GenDummyType dummy) {
4196 fail();
4197
4198 }
4199 });
4200 break;
4201 case product:
4202 genType.accept(new GenTypeVisitor() {
4203
4204 @Override
4205 public void handle(final GenImportType importType) {
4206 fail();
4207 }
4208
4209 @Override
4210 public void handle(final GenJavaUtilCollection javaUtilCollection) {
4211 fail();
4212 }
4213
4214 @Override
4215 public void handle(final Generic generic) {
4216 fail();
4217 }
4218
4219 @Override
4220 public void handle(final GenMapType mapType) {
4221 fail();
4222 }
4223
4224 @Override
4225 public void handle(final GenPrimitiveType primitiveType) {
4226 fail();
4227 }
4228
4229 @Override
4230 public void handle(final GenCollectionType collectionType) {
4231 fail();
4232 }
4233
4234 @Override
4235 public void handle(final GenClass cla) {
4236
4237 }
4238
4239 @Override
4240 public void handle(final GenDummyType dummy) {
4241 fail();
4242
4243 }
4244 });
4245 break;
4246 case product2:
4247 genType.accept(new GenTypeVisitor() {
4248
4249 @Override
4250 public void handle(final GenImportType importType) {
4251 fail();
4252 }
4253
4254 @Override
4255 public void handle(final GenJavaUtilCollection javaUtilCollection) {
4256 fail();
4257 }
4258
4259 @Override
4260 public void handle(final Generic generic) {
4261 fail();
4262 }
4263
4264 @Override
4265 public void handle(final GenMapType mapType) {
4266 fail();
4267 }
4268
4269 @Override
4270 public void handle(final GenPrimitiveType primitiveType) {
4271 fail();
4272 }
4273
4274 @Override
4275 public void handle(final GenCollectionType collectionType) {
4276 fail();
4277 }
4278
4279 @Override
4280 public void handle(final GenClass cla) {
4281
4282 }
4283
4284 @Override
4285 public void handle(final GenDummyType dummy) {
4286 fail();
4287
4288 }
4289 });
4290 break;
4291
4292 case sum:
4293 genType.accept(new GenTypeVisitor() {
4294
4295 @Override
4296 public void handle(final GenImportType importType) {
4297 fail();
4298 }
4299
4300 @Override
4301 public void handle(final GenJavaUtilCollection javaUtilCollection) {
4302 fail();
4303 }
4304
4305 @Override
4306 public void handle(final Generic generic) {
4307 fail();
4308 }
4309
4310 @Override
4311 public void handle(final GenMapType mapType) {
4312 fail();
4313 }
4314
4315 @Override
4316 public void handle(final GenPrimitiveType primitiveType) {
4317 fail();
4318 }
4319
4320 @Override
4321 public void handle(final GenCollectionType collectionType) {
4322 fail();
4323 }
4324
4325 @Override
4326 public void handle(final GenClass cla) {
4327
4328 }
4329
4330 @Override
4331 public void handle(final GenDummyType dummy) {
4332 fail();
4333
4334 }
4335 });
4336 break;
4337 case "Str":
4338 genType.accept(new GenTypeVisitor() {
4339
4340 @Override
4341 public void handle(final GenImportType importType) {
4342 fail();
4343 }
4344
4345 @Override
4346 public void handle(final GenJavaUtilCollection javaUtilCollection) {
4347 fail();
4348 }
4349
4350 @Override
4351 public void handle(final Generic generic) {
4352 fail();
4353 }
4354
4355 @Override
4356 public void handle(final GenMapType mapType) {
4357 fail();
4358 }
4359
4360 @Override
4361 public void handle(final GenPrimitiveType primitiveType) {
4362
4363 }
4364
4365 @Override
4366 public void handle(final GenCollectionType collectionType) {
4367 fail();
4368 }
4369
4370 @Override
4371 public void handle(final GenClass cla) {
4372 fail();
4373 }
4374
4375 @Override
4376 public void handle(final GenDummyType dummy) {
4377 fail();
4378
4379 }
4380 });
4381 break;
4382 case "Int":
4383 genType.accept(new GenTypeVisitor() {
4384
4385 @Override
4386 public void handle(final GenImportType importType) {
4387 fail();
4388 }
4389
4390 @Override
4391 public void handle(final GenJavaUtilCollection javaUtilCollection) {
4392 fail();
4393 }
4394
4395 @Override
4396 public void handle(final Generic generic) {
4397 fail();
4398 }
4399
4400 @Override
4401 public void handle(final GenMapType mapType) {
4402 fail();
4403 }
4404
4405 @Override
4406 public void handle(final GenPrimitiveType primitiveType) {
4407
4408 }
4409
4410 @Override
4411 public void handle(final GenCollectionType collectionType) {
4412 fail();
4413 }
4414
4415 @Override
4416 public void handle(final GenClass cla) {
4417 fail();
4418 }
4419
4420 @Override
4421 public void handle(final GenDummyType dummy) {
4422 fail();
4423
4424 }
4425 });
4426 break;
4427 case "Anything":
4428 genType.accept(new GenTypeVisitor() {
4429
4430 @Override
4431 public void handle(final GenImportType importType) {
4432 fail();
4433 }
4434
4435 @Override
4436 public void handle(final GenJavaUtilCollection javaUtilCollection) {
4437 fail();
4438 }
4439
4440 @Override
4441 public void handle(final Generic generic) {
4442 fail();
4443 }
4444
4445 @Override
4446 public void handle(final GenMapType mapType) {
4447 fail();
4448 }
4449
4450 @Override
4451 public void handle(final GenPrimitiveType primitiveType) {
4452 fail();
4453 }
4454
4455 @Override
4456 public void handle(final GenCollectionType collectionType) {
4457 fail();
4458 }
4459
4460 @Override
4461 public void handle(final GenClass cla) {
4462
4463 }
4464
4465 @Override
4466 public void handle(final GenDummyType dummy) {
4467 fail();
4468
4469 }
4470 });
4471 break;
4472 default:
4473 fail("Type erwartet und gefunden, wird aber nicht überprüft " + genType.getName());
4474 break;
4475 }
4476
4477 } else {
4478 fail("Type gefunden, die aber nicht erwartet wird." + genType.getName());
4479 }
4480
4481 }
4482 if (expectedTypes.size() != 0) {
4483 fail("Type erwartet, aber nicht gefunden");
4484 }
4485 }
4486
4487
4488
4489
4490
4491
4492 @Test
4493 public void testClassWithMutableAttribute() throws Exception {
4494 final GeneratorModel javaGeneratorModel = this.generate(TestModels.classWithMutableAttribute);
4495
4496 final Set<String> expectedClasses = TestUtil.getEverytimeExpectedClasses();
4497 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
4498 expectedClasses.add(product0);
4499 expectedClasses.add("generated.model.group1.class1");
4500
4501 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
4502
4503 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
4504 while (i.hasNext()) {
4505 final GenClass genClass = i.next();
4506 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
4507 switch (genClass.getName()) {
4508 case "class1":
4509 assertEquals("generated.model.group1", genClass.getPackag().toString());
4510 genClass.accept(new GenClassVisitor() {
4511
4512 @Override
4513 public void handle(final GenInterfaceClass interfaceClass) {
4514 assertEquals(0, interfaceClass.getOperations().size());
4515
4516 interfaceClass.accept(new GenInterfaceClassVisitor() {
4517
4518 @Override
4519 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
4520 final Set<String> operations = new HashSet<>();
4521 operations.add("private generated.model.group1.class1 $getThis()");
4522
4523 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
4524 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
4525 + " get$generatedObjects()");
4526 final Set<String> attributes = new HashSet<>();
4527 attributes.add("private de.fhdw.wtf.context.model.Int att1");
4528 attributes.add("private generated.model.group1.class1 This");
4529 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
4530 final Set<String> modifiers = new HashSet<>();
4531 final Set<String> implement = new HashSet<>();
4532 implement.add("generated.model.group1.class1");
4533 assertEquals(true, TestClassTransformer.controlImplClass(
4534 interfaceWithImplClass,
4535 "class1",
4536 "generated.model.group1",
4537 operations,
4538 attributes,
4539 modifiers,
4540 implement));
4541
4542 }
4543
4544 @Override
4545 public void handle(final GenSimpleInterfaceClass simpleInterface) {
4546 fail();
4547 }
4548
4549 @Override
4550 public void handle(final GenExternalInterfaceClass iface) {
4551 fail();
4552 }
4553 });
4554 }
4555
4556 @Override
4557 public void handle(final GenClassClass classClass) {
4558 fail();
4559 }
4560
4561 @Override
4562 public void handle(final GenPrimitiveClass primitiveClass) {
4563 fail();
4564 }
4565 });
4566 break;
4567 case "Anything":
4568 genClass.accept(new GenClassVisitor() {
4569
4570 @Override
4571 public void handle(final GenInterfaceClass interfaceClass) {
4572 assertEquals(0, interfaceClass.getOperations().size());
4573 }
4574
4575 @Override
4576 public void handle(final GenClassClass classClass) {
4577 fail();
4578 }
4579
4580 @Override
4581 public void handle(final GenPrimitiveClass primitiveClass) {
4582 fail();
4583 }
4584 });
4585 break;
4586 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
4587 break;
4588 default:
4589 fail("Klasse erwartet und gefunden, wird aber nicht überprüft " + genClass.getName());
4590 break;
4591 }
4592
4593 } else {
4594 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getName());
4595 }
4596
4597 }
4598 if (expectedClasses.size() != 0) {
4599 fail("Klasse erwartet, aber nicht gefunden");
4600 }
4601 final Set<String> expectedTypes = new HashSet<>();
4602 expectedTypes.addAll(TestUtil.getEverytimeExpectedTypes());
4603 expectedTypes.add("generated.model.group1.class1");
4604 expectedTypes.add(product0);
4605 assertEquals(expectedTypes.size(), javaGeneratorModel.getTypeMapping().size());
4606
4607 final Iterator<Tuple<GenType, Collection<ExceptionClassType>>> i2 =
4608 javaGeneratorModel.getTypeMapping().values().iterator();
4609 while (i2.hasNext()) {
4610 final GenType genType = i2.next().getA();
4611 if (expectedTypes.remove(genType.getFullyQualifiedTypeName())) {
4612 switch (genType.getName()) {
4613 case "class1":
4614 genType.accept(new GenTypeVisitor() {
4615
4616 @Override
4617 public void handle(final GenImportType importType) {
4618 fail();
4619 }
4620
4621 @Override
4622 public void handle(final GenJavaUtilCollection javaUtilCollection) {
4623 fail();
4624 }
4625
4626 @Override
4627 public void handle(final Generic generic) {
4628 fail();
4629 }
4630
4631 @Override
4632 public void handle(final GenMapType mapType) {
4633 fail();
4634 }
4635
4636 @Override
4637 public void handle(final GenPrimitiveType primitiveType) {
4638 fail();
4639 }
4640
4641 @Override
4642 public void handle(final GenCollectionType collectionType) {
4643 fail();
4644 }
4645
4646 @Override
4647 public void handle(final GenClass cla) {
4648
4649 }
4650
4651 @Override
4652 public void handle(final GenDummyType dummy) {
4653 fail();
4654
4655 }
4656 });
4657 break;
4658 case "Str":
4659 genType.accept(new GenTypeVisitor() {
4660
4661 @Override
4662 public void handle(final GenImportType importType) {
4663 fail();
4664 }
4665
4666 @Override
4667 public void handle(final GenJavaUtilCollection javaUtilCollection) {
4668 fail();
4669 }
4670
4671 @Override
4672 public void handle(final Generic generic) {
4673 fail();
4674 }
4675
4676 @Override
4677 public void handle(final GenMapType mapType) {
4678 fail();
4679 }
4680
4681 @Override
4682 public void handle(final GenPrimitiveType primitiveType) {
4683
4684 }
4685
4686 @Override
4687 public void handle(final GenCollectionType collectionType) {
4688 fail();
4689 }
4690
4691 @Override
4692 public void handle(final GenClass cla) {
4693 fail();
4694 }
4695
4696 @Override
4697 public void handle(final GenDummyType dummy) {
4698 fail();
4699
4700 }
4701 });
4702 break;
4703 case "Int":
4704 genType.accept(new GenTypeVisitor() {
4705
4706 @Override
4707 public void handle(final GenImportType importType) {
4708 fail();
4709 }
4710
4711 @Override
4712 public void handle(final GenJavaUtilCollection javaUtilCollection) {
4713 fail();
4714 }
4715
4716 @Override
4717 public void handle(final Generic generic) {
4718 fail();
4719 }
4720
4721 @Override
4722 public void handle(final GenMapType mapType) {
4723 fail();
4724 }
4725
4726 @Override
4727 public void handle(final GenPrimitiveType primitiveType) {
4728
4729 }
4730
4731 @Override
4732 public void handle(final GenCollectionType collectionType) {
4733 fail();
4734 }
4735
4736 @Override
4737 public void handle(final GenClass cla) {
4738 fail();
4739 }
4740
4741 @Override
4742 public void handle(final GenDummyType dummy) {
4743 fail();
4744
4745 }
4746 });
4747 break;
4748 case "Anything":
4749 genType.accept(new GenTypeVisitor() {
4750
4751 @Override
4752 public void handle(final GenImportType importType) {
4753 fail();
4754 }
4755
4756 @Override
4757 public void handle(final GenJavaUtilCollection javaUtilCollection) {
4758 fail();
4759 }
4760
4761 @Override
4762 public void handle(final Generic generic) {
4763 fail();
4764 }
4765
4766 @Override
4767 public void handle(final GenMapType mapType) {
4768 fail();
4769 }
4770
4771 @Override
4772 public void handle(final GenPrimitiveType primitiveType) {
4773 fail();
4774 }
4775
4776 @Override
4777 public void handle(final GenCollectionType collectionType) {
4778 fail();
4779 }
4780
4781 @Override
4782 public void handle(final GenClass cla) {
4783
4784 }
4785
4786 @Override
4787 public void handle(final GenDummyType dummy) {
4788 fail();
4789
4790 }
4791 });
4792 break;
4793 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
4794 break;
4795 default:
4796 fail("Type erwartet und gefunden, wird aber nicht überprüft" + genType.getName());
4797 break;
4798
4799 }
4800
4801 } else {
4802 fail("Type gefunden, die aber nicht erwartet wird." + genType.getName());
4803 }
4804
4805 }
4806 if (expectedTypes.size() != 0) {
4807 fail("Type erwartet, aber nicht gefunden");
4808 }
4809 }
4810
4811
4812
4813
4814
4815
4816 @Test
4817 public void testClassWithFindableAttribute() throws Exception {
4818 final GeneratorModel javaGeneratorModel = this.generate(TestModels.classWithFindableAttribute);
4819
4820 final Set<String> expectedClasses = TestUtil.getEverytimeExpectedClasses();
4821 expectedClasses.add("generated.model.group1.class1");
4822 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
4823 expectedClasses.add(product0);
4824 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
4825
4826 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
4827 while (i.hasNext()) {
4828 final GenClass genClass = i.next();
4829 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
4830 switch (genClass.getName()) {
4831 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
4832 break;
4833 case "class1":
4834 assertEquals("generated.model.group1", genClass.getPackag().toString());
4835 genClass.accept(new GenClassVisitor() {
4836
4837 @Override
4838 public void handle(final GenInterfaceClass interfaceClass) {
4839 assertEquals(0, interfaceClass.getOperations().size());
4840
4841 interfaceClass.accept(new GenInterfaceClassVisitor() {
4842
4843 @Override
4844 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
4845 final Set<String> operations = new HashSet<>();
4846 operations.add("private generated.model.group1.class1 $getThis()");
4847
4848 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
4849 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
4850 + " get$generatedObjects()");
4851 final Set<String> attributes = new HashSet<>();
4852 attributes.add("private de.fhdw.wtf.context.model.Int att1");
4853 attributes.add("private generated.model.group1.class1 This");
4854 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
4855 final Set<String> modifiers = new HashSet<>();
4856 final Set<String> implement = new HashSet<>();
4857 implement.add("generated.model.group1.class1");
4858 assertEquals(true, TestClassTransformer.controlImplClass(
4859 interfaceWithImplClass,
4860 "class1",
4861 "generated.model.group1",
4862 operations,
4863 attributes,
4864 modifiers,
4865 implement));
4866
4867
4868 }
4869
4870 @Override
4871 public void handle(final GenSimpleInterfaceClass simpleInterface) {
4872 fail();
4873 }
4874
4875 @Override
4876 public void handle(final GenExternalInterfaceClass iface) {
4877 fail();
4878 }
4879 });
4880 }
4881
4882 @Override
4883 public void handle(final GenClassClass classClass) {
4884 fail();
4885 }
4886
4887 @Override
4888 public void handle(final GenPrimitiveClass primitiveClass) {
4889 fail();
4890 }
4891 });
4892 break;
4893 case "Anything":
4894 genClass.accept(new GenClassVisitor() {
4895
4896 @Override
4897 public void handle(final GenInterfaceClass interfaceClass) {
4898 assertEquals(0, interfaceClass.getOperations().size());
4899 }
4900
4901 @Override
4902 public void handle(final GenClassClass classClass) {
4903 fail();
4904 }
4905
4906 @Override
4907 public void handle(final GenPrimitiveClass primitiveClass) {
4908 fail();
4909 }
4910 });
4911 break;
4912 default:
4913 fail("Klasse erwartet und gefunden, wird aber nicht überprüft " + genClass.getName());
4914 break;
4915 }
4916
4917 } else {
4918 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getName());
4919 }
4920
4921 }
4922 if (expectedClasses.size() != 0) {
4923 fail("Klasse erwartet, aber nicht gefunden");
4924 }
4925 final Set<String> expectedTypes = new HashSet<>();
4926 expectedTypes.addAll(TestUtil.getEverytimeExpectedTypes());
4927 expectedTypes.add("generated.model.group1.class1");
4928 expectedTypes.add(product0);
4929 assertEquals(expectedTypes.size(), javaGeneratorModel.getTypeMapping().size());
4930
4931 final Iterator<Tuple<GenType, Collection<ExceptionClassType>>> i2 =
4932 javaGeneratorModel.getTypeMapping().values().iterator();
4933 while (i2.hasNext()) {
4934 final GenType genType = i2.next().getA();
4935 if (expectedTypes.remove(genType.getFullyQualifiedTypeName())) {
4936 switch (genType.getName()) {
4937 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
4938 break;
4939 case "class1":
4940 genType.accept(new GenTypeVisitor() {
4941
4942 @Override
4943 public void handle(final GenImportType importType) {
4944 fail();
4945 }
4946
4947 @Override
4948 public void handle(final GenJavaUtilCollection javaUtilCollection) {
4949 fail();
4950 }
4951
4952 @Override
4953 public void handle(final Generic generic) {
4954 fail();
4955 }
4956
4957 @Override
4958 public void handle(final GenMapType mapType) {
4959 fail();
4960 }
4961
4962 @Override
4963 public void handle(final GenPrimitiveType primitiveType) {
4964 fail();
4965 }
4966
4967 @Override
4968 public void handle(final GenCollectionType collectionType) {
4969 fail();
4970 }
4971
4972 @Override
4973 public void handle(final GenClass cla) {
4974
4975 }
4976
4977 @Override
4978 public void handle(final GenDummyType dummy) {
4979 fail();
4980
4981 }
4982 });
4983 break;
4984 case "Str":
4985 genType.accept(new GenTypeVisitor() {
4986
4987 @Override
4988 public void handle(final GenImportType importType) {
4989 fail();
4990 }
4991
4992 @Override
4993 public void handle(final GenJavaUtilCollection javaUtilCollection) {
4994 fail();
4995 }
4996
4997 @Override
4998 public void handle(final Generic generic) {
4999 fail();
5000 }
5001
5002 @Override
5003 public void handle(final GenMapType mapType) {
5004 fail();
5005 }
5006
5007 @Override
5008 public void handle(final GenPrimitiveType primitiveType) {
5009
5010 }
5011
5012 @Override
5013 public void handle(final GenCollectionType collectionType) {
5014 fail();
5015 }
5016
5017 @Override
5018 public void handle(final GenClass cla) {
5019 fail();
5020 }
5021
5022 @Override
5023 public void handle(final GenDummyType dummy) {
5024 fail();
5025
5026 }
5027 });
5028 break;
5029 case "Int":
5030 genType.accept(new GenTypeVisitor() {
5031
5032 @Override
5033 public void handle(final GenImportType importType) {
5034 fail();
5035 }
5036
5037 @Override
5038 public void handle(final GenJavaUtilCollection javaUtilCollection) {
5039 fail();
5040 }
5041
5042 @Override
5043 public void handle(final Generic generic) {
5044 fail();
5045 }
5046
5047 @Override
5048 public void handle(final GenMapType mapType) {
5049 fail();
5050 }
5051
5052 @Override
5053 public void handle(final GenPrimitiveType primitiveType) {
5054
5055 }
5056
5057 @Override
5058 public void handle(final GenCollectionType collectionType) {
5059 fail();
5060 }
5061
5062 @Override
5063 public void handle(final GenClass cla) {
5064 fail();
5065 }
5066
5067 @Override
5068 public void handle(final GenDummyType dummy) {
5069 fail();
5070
5071 }
5072 });
5073 break;
5074 case "Anything":
5075 genType.accept(new GenTypeVisitor() {
5076
5077 @Override
5078 public void handle(final GenImportType importType) {
5079 fail();
5080 }
5081
5082 @Override
5083 public void handle(final GenJavaUtilCollection javaUtilCollection) {
5084 fail();
5085 }
5086
5087 @Override
5088 public void handle(final Generic generic) {
5089 fail();
5090 }
5091
5092 @Override
5093 public void handle(final GenMapType mapType) {
5094 fail();
5095 }
5096
5097 @Override
5098 public void handle(final GenPrimitiveType primitiveType) {
5099 fail();
5100 }
5101
5102 @Override
5103 public void handle(final GenCollectionType collectionType) {
5104 fail();
5105 }
5106
5107 @Override
5108 public void handle(final GenClass cla) {
5109
5110 }
5111
5112 @Override
5113 public void handle(final GenDummyType dummy) {
5114 fail();
5115
5116 }
5117 });
5118 break;
5119 default:
5120 fail("Type erwartet und gefunden, wird aber nicht überprüft" + genType.getName());
5121 break;
5122 }
5123
5124 } else {
5125 fail("Type gefunden, die aber nicht erwartet wird." + genType.getName());
5126 }
5127
5128 }
5129 if (expectedTypes.size() != 0) {
5130 fail("Type erwartet, aber nicht gefunden");
5131 }
5132 }
5133
5134 @Test
5135 @Ignore("Transient noch nicht implementiert, siehe Bug 711")
5136 public void testClassWithTransientAttribute() throws Exception {
5137 final GeneratorModel javaGeneratorModel = this.generate(TestModels.classWithTransientAttribute);
5138
5139 final Set<String> expectedClasses = TestUtil.getEverytimeExpectedClasses();
5140 expectedClasses.add("generated.model.group1.class1");
5141
5142 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
5143
5144 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
5145 while (i.hasNext()) {
5146 final GenClass genClass = i.next();
5147 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
5148 switch (genClass.getName()) {
5149 case "class1":
5150 assertEquals("generated.model.group1", genClass.getPackag().toString());
5151 genClass.accept(new GenClassVisitor() {
5152
5153 @Override
5154 public void handle(final GenInterfaceClass interfaceClass) {
5155 assertEquals(0, interfaceClass.getOperations().size());
5156
5157 interfaceClass.accept(new GenInterfaceClassVisitor() {
5158
5159 @Override
5160 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
5161
5162 final Set<String> operations = new HashSet<>();
5163 final Set<String> attributes = new HashSet<>();
5164 attributes.add("att1");
5165 final Set<String> modifiers = new HashSet<>();
5166 final Set<String> implement = new HashSet<>();
5167 implement.add("generated.model.group1.class1");
5168 assertEquals(true, TestClassTransformer.controlImplClass(
5169 interfaceWithImplClass,
5170 "class1",
5171 "generated.model.group1",
5172 operations,
5173 attributes,
5174 modifiers,
5175 implement));
5176 assertEquals(GenAttributeModifier.FINAL, interfaceWithImplClass
5177 .getClassRepresentation().getAttributes().iterator().next().getModifiers()
5178 .iterator().next());
5179 assertEquals(GenAttributeModifier.TRANSIENT, interfaceWithImplClass
5180 .getClassRepresentation().getAttributes().iterator().next().getModifiers()
5181 .iterator().next());
5182
5183 }
5184
5185 @Override
5186 public void handle(final GenSimpleInterfaceClass simpleInterface) {
5187 fail();
5188 }
5189
5190 @Override
5191 public void handle(final GenExternalInterfaceClass iface) {
5192 fail();
5193 }
5194 });
5195 }
5196
5197 @Override
5198 public void handle(final GenClassClass classClass) {
5199 fail();
5200 }
5201
5202 @Override
5203 public void handle(final GenPrimitiveClass primitiveClass) {
5204 fail();
5205 }
5206 });
5207 break;
5208 case "Anything":
5209 genClass.accept(new GenClassVisitor() {
5210
5211 @Override
5212 public void handle(final GenInterfaceClass interfaceClass) {
5213 assertEquals(0, interfaceClass.getOperations().size());
5214 }
5215
5216 @Override
5217 public void handle(final GenClassClass classClass) {
5218 fail();
5219 }
5220
5221 @Override
5222 public void handle(final GenPrimitiveClass primitiveClass) {
5223 fail();
5224 }
5225 });
5226 break;
5227 default:
5228 fail("Klasse erwartet und gefunden, wird aber nicht überprüft " + genClass.getName());
5229 break;
5230 }
5231
5232 } else {
5233 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getName());
5234 }
5235
5236 }
5237 if (expectedClasses.size() != 0) {
5238 fail("Klasse erwartet, aber nicht gefunden");
5239 }
5240 final Set<String> expectedTypes = new HashSet<>();
5241 expectedTypes.addAll(TestUtil.getEverytimeExpectedTypes());
5242 expectedTypes.add("generated.model.group1.class1");
5243 assertEquals(expectedTypes.size(), javaGeneratorModel.getTypeMapping().size());
5244
5245 final Iterator<Tuple<GenType, Collection<ExceptionClassType>>> i2 =
5246 javaGeneratorModel.getTypeMapping().values().iterator();
5247 while (i2.hasNext()) {
5248 final GenType genType = i2.next().getA();
5249 if (expectedTypes.remove(genType.getFullyQualifiedTypeName())) {
5250 switch (genType.getName()) {
5251 case "class1":
5252 genType.accept(new GenTypeVisitor() {
5253
5254 @Override
5255 public void handle(final GenImportType importType) {
5256 fail();
5257 }
5258
5259 @Override
5260 public void handle(final GenJavaUtilCollection javaUtilCollection) {
5261 fail();
5262 }
5263
5264 @Override
5265 public void handle(final Generic generic) {
5266 fail();
5267 }
5268
5269 @Override
5270 public void handle(final GenMapType mapType) {
5271 fail();
5272 }
5273
5274 @Override
5275 public void handle(final GenPrimitiveType primitiveType) {
5276 fail();
5277 }
5278
5279 @Override
5280 public void handle(final GenCollectionType collectionType) {
5281 fail();
5282 }
5283
5284 @Override
5285 public void handle(final GenClass cla) {
5286
5287 }
5288
5289 @Override
5290 public void handle(final GenDummyType dummy) {
5291 fail();
5292
5293 }
5294 });
5295 break;
5296 case "Str":
5297 genType.accept(new GenTypeVisitor() {
5298
5299 @Override
5300 public void handle(final GenImportType importType) {
5301 fail();
5302 }
5303
5304 @Override
5305 public void handle(final GenJavaUtilCollection javaUtilCollection) {
5306 fail();
5307 }
5308
5309 @Override
5310 public void handle(final Generic generic) {
5311 fail();
5312 }
5313
5314 @Override
5315 public void handle(final GenMapType mapType) {
5316 fail();
5317 }
5318
5319 @Override
5320 public void handle(final GenPrimitiveType primitiveType) {
5321
5322 }
5323
5324 @Override
5325 public void handle(final GenCollectionType collectionType) {
5326 fail();
5327 }
5328
5329 @Override
5330 public void handle(final GenClass cla) {
5331 fail();
5332 }
5333
5334 @Override
5335 public void handle(final GenDummyType dummy) {
5336 fail();
5337
5338 }
5339 });
5340 break;
5341 case "Int":
5342 genType.accept(new GenTypeVisitor() {
5343
5344 @Override
5345 public void handle(final GenImportType importType) {
5346 fail();
5347 }
5348
5349 @Override
5350 public void handle(final GenJavaUtilCollection javaUtilCollection) {
5351 fail();
5352 }
5353
5354 @Override
5355 public void handle(final Generic generic) {
5356 fail();
5357 }
5358
5359 @Override
5360 public void handle(final GenMapType mapType) {
5361 fail();
5362 }
5363
5364 @Override
5365 public void handle(final GenPrimitiveType primitiveType) {
5366
5367 }
5368
5369 @Override
5370 public void handle(final GenCollectionType collectionType) {
5371 fail();
5372 }
5373
5374 @Override
5375 public void handle(final GenClass cla) {
5376 fail();
5377 }
5378
5379 @Override
5380 public void handle(final GenDummyType dummy) {
5381 fail();
5382
5383 }
5384 });
5385 break;
5386 case "Anything":
5387 genType.accept(new GenTypeVisitor() {
5388
5389 @Override
5390 public void handle(final GenImportType importType) {
5391 fail();
5392 }
5393
5394 @Override
5395 public void handle(final GenJavaUtilCollection javaUtilCollection) {
5396 fail();
5397 }
5398
5399 @Override
5400 public void handle(final Generic generic) {
5401 fail();
5402 }
5403
5404 @Override
5405 public void handle(final GenMapType mapType) {
5406 fail();
5407 }
5408
5409 @Override
5410 public void handle(final GenPrimitiveType primitiveType) {
5411 fail();
5412 }
5413
5414 @Override
5415 public void handle(final GenCollectionType collectionType) {
5416 fail();
5417 }
5418
5419 @Override
5420 public void handle(final GenClass cla) {
5421
5422 }
5423
5424 @Override
5425 public void handle(final GenDummyType dummy) {
5426 fail();
5427
5428 }
5429 });
5430 break;
5431 default:
5432 fail("Type erwartet und gefunden, wird aber nicht überprüft" + genType.getName());
5433 break;
5434 }
5435
5436 } else {
5437 fail("Type gefunden, die aber nicht erwartet wird." + genType.getName());
5438 }
5439
5440 }
5441 if (expectedTypes.size() != 0) {
5442 fail("Type erwartet, aber nicht gefunden");
5443 }
5444 }
5445
5446 @Test
5447 public void testProductUsesPrototypesAttributes() throws Exception {
5448 final GeneratorModel javaGeneratorModel = this.generate(TestModels.classWithProduct);
5449
5450 final Set<String> expectedTypes = new HashSet<>();
5451 expectedTypes.addAll(TestUtil.getEverytimeExpectedTypes());
5452 expectedTypes.add("generated.model.group1.class1");
5453 final String product0 = "generated.products." + TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END;
5454 expectedTypes.add(product0);
5455 final String product =
5456 TypeNameGenerator.PRODUCT_BEGIN + "vorname" + TypeNameGenerator.PRODUCT_SEPERATE_TYPE_AND_NAME
5457 + "String" + TypeNameGenerator.PRODUCT_SEPERATE_ATTRIBUTES + "nachname"
5458 + TypeNameGenerator.PRODUCT_SEPERATE_TYPE_AND_NAME + "String" + TypeNameGenerator.PRODUCT_END;
5459 expectedTypes.add("generated.products." + product);
5460 final String abstractProduct =
5461 TypeNameGenerator.PRODUCT_BEGIN + "p$1" + TypeNameGenerator.PRODUCT_SEPERATE_TYPE_AND_NAME + "String"
5462 + TypeNameGenerator.PRODUCT_SEPERATE_ATTRIBUTES + "p$2"
5463 + TypeNameGenerator.PRODUCT_SEPERATE_TYPE_AND_NAME + "String" + TypeNameGenerator.PRODUCT_END;
5464 expectedTypes.add("generated.products." + abstractProduct);
5465 final String voidType = "void";
5466 expectedTypes.add(voidType);
5467 assertEquals(expectedTypes.size(), javaGeneratorModel.getTypeMapping().size());
5468
5469 final Iterator<Tuple<GenType, Collection<ExceptionClassType>>> i2 =
5470 javaGeneratorModel.getTypeMapping().values().iterator();
5471 while (i2.hasNext()) {
5472 final GenType genType = i2.next().getA();
5473 if (expectedTypes.remove(genType.getFullyQualifiedTypeName())) {
5474 switch (genType.getName()) {
5475 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
5476 break;
5477 case "class1":
5478 genType.accept(new GenTypeVisitor() {
5479
5480 @Override
5481 public void handle(final GenImportType importType) {
5482 fail();
5483 }
5484
5485 @Override
5486 public void handle(final GenJavaUtilCollection javaUtilCollection) {
5487 fail();
5488 }
5489
5490 @Override
5491 public void handle(final Generic generic) {
5492 fail();
5493 }
5494
5495 @Override
5496 public void handle(final GenMapType mapType) {
5497 fail();
5498 }
5499
5500 @Override
5501 public void handle(final GenPrimitiveType primitiveType) {
5502 fail();
5503 }
5504
5505 @Override
5506 public void handle(final GenCollectionType collectionType) {
5507 fail();
5508 }
5509
5510 @Override
5511 public void handle(final GenClass cla) {
5512
5513 }
5514
5515 @Override
5516 public void handle(final GenDummyType dummy) {
5517 fail();
5518
5519 }
5520 });
5521 break;
5522 case "Str":
5523 genType.accept(new GenTypeVisitor() {
5524
5525 @Override
5526 public void handle(final GenImportType importType) {
5527 fail();
5528 }
5529
5530 @Override
5531 public void handle(final GenJavaUtilCollection javaUtilCollection) {
5532 fail();
5533 }
5534
5535 @Override
5536 public void handle(final Generic generic) {
5537 fail();
5538 }
5539
5540 @Override
5541 public void handle(final GenMapType mapType) {
5542 fail();
5543 }
5544
5545 @Override
5546 public void handle(final GenPrimitiveType primitiveType) {
5547
5548 }
5549
5550 @Override
5551 public void handle(final GenCollectionType collectionType) {
5552 fail();
5553 }
5554
5555 @Override
5556 public void handle(final GenClass cla) {
5557 fail();
5558 }
5559
5560 @Override
5561 public void handle(final GenDummyType dummy) {
5562 fail();
5563
5564 }
5565 });
5566 break;
5567 case "Int":
5568 genType.accept(new GenTypeVisitor() {
5569
5570 @Override
5571 public void handle(final GenImportType importType) {
5572 fail();
5573 }
5574
5575 @Override
5576 public void handle(final GenJavaUtilCollection javaUtilCollection) {
5577 fail();
5578 }
5579
5580 @Override
5581 public void handle(final Generic generic) {
5582 fail();
5583 }
5584
5585 @Override
5586 public void handle(final GenMapType mapType) {
5587 fail();
5588 }
5589
5590 @Override
5591 public void handle(final GenPrimitiveType primitiveType) {
5592
5593 }
5594
5595 @Override
5596 public void handle(final GenCollectionType collectionType) {
5597 fail();
5598 }
5599
5600 @Override
5601 public void handle(final GenClass cla) {
5602 fail();
5603 }
5604
5605 @Override
5606 public void handle(final GenDummyType dummy) {
5607 fail();
5608
5609 }
5610 });
5611 break;
5612 case "Anything":
5613 genType.accept(new GenTypeVisitor() {
5614
5615 @Override
5616 public void handle(final GenImportType importType) {
5617 fail();
5618 }
5619
5620 @Override
5621 public void handle(final GenJavaUtilCollection javaUtilCollection) {
5622 fail();
5623 }
5624
5625 @Override
5626 public void handle(final Generic generic) {
5627 fail();
5628 }
5629
5630 @Override
5631 public void handle(final GenMapType mapType) {
5632 fail();
5633 }
5634
5635 @Override
5636 public void handle(final GenPrimitiveType primitiveType) {
5637 fail();
5638 }
5639
5640 @Override
5641 public void handle(final GenCollectionType collectionType) {
5642 fail();
5643 }
5644
5645 @Override
5646 public void handle(final GenClass cla) {
5647
5648 }
5649
5650 @Override
5651 public void handle(final GenDummyType dummy) {
5652 fail();
5653
5654 }
5655 });
5656 break;
5657 case voidType:
5658 genType.accept(new GenTypeVisitor() {
5659
5660 @Override
5661 public void handle(final GenImportType importType) {
5662 fail();
5663 }
5664
5665 @Override
5666 public void handle(final GenJavaUtilCollection javaUtilCollection) {
5667 fail();
5668 }
5669
5670 @Override
5671 public void handle(final Generic generic) {
5672 fail();
5673 }
5674
5675 @Override
5676 public void handle(final GenMapType mapType) {
5677 fail();
5678 }
5679
5680 @Override
5681 public void handle(final GenPrimitiveType primitiveType) {
5682
5683 }
5684
5685 @Override
5686 public void handle(final GenCollectionType collectionType) {
5687 fail();
5688 }
5689
5690 @Override
5691 public void handle(final GenClass cla) {
5692 fail();
5693 }
5694
5695 @Override
5696 public void handle(final GenDummyType dummy) {
5697 fail();
5698
5699 }
5700 });
5701 break;
5702 case product:
5703 genType.accept(new GenTypeVisitor() {
5704
5705 @Override
5706 public void handle(final GenImportType importType) {
5707 fail();
5708 }
5709
5710 @Override
5711 public void handle(final GenJavaUtilCollection javaUtilCollection) {
5712 fail();
5713 }
5714
5715 @Override
5716 public void handle(final Generic generic) {
5717 fail();
5718 }
5719
5720 @Override
5721 public void handle(final GenMapType mapType) {
5722 fail();
5723 }
5724
5725 @Override
5726 public void handle(final GenPrimitiveType primitiveType) {
5727 fail();
5728 }
5729
5730 @Override
5731 public void handle(final GenCollectionType collectionType) {
5732 fail();
5733 }
5734
5735 @Override
5736 public void handle(final GenClass cla) {
5737
5738 }
5739
5740 @Override
5741 public void handle(final GenDummyType dummy) {
5742 fail();
5743
5744 }
5745 });
5746 break;
5747 case abstractProduct:
5748 genType.accept(new GenTypeVisitor() {
5749
5750 @Override
5751 public void handle(final GenImportType importType) {
5752 fail();
5753 }
5754
5755 @Override
5756 public void handle(final GenJavaUtilCollection javaUtilCollection) {
5757 fail();
5758 }
5759
5760 @Override
5761 public void handle(final Generic generic) {
5762 fail();
5763 }
5764
5765 @Override
5766 public void handle(final GenMapType mapType) {
5767 fail();
5768 }
5769
5770 @Override
5771 public void handle(final GenPrimitiveType primitiveType) {
5772 fail();
5773 }
5774
5775 @Override
5776 public void handle(final GenCollectionType collectionType) {
5777 fail();
5778 }
5779
5780 @Override
5781 public void handle(final GenClass cla) {
5782
5783 }
5784
5785 @Override
5786 public void handle(final GenDummyType dummy) {
5787 fail();
5788
5789 }
5790 });
5791 break;
5792 default:
5793 fail("Type erwartet und gefunden, wird aber nicht überprüft" + genType.getName());
5794 break;
5795 }
5796
5797 } else {
5798 fail("Type gefunden, die aber nicht erwartet wird." + genType.getName());
5799 }
5800
5801 }
5802 if (expectedTypes.size() != 0) {
5803 fail("Type erwartet, aber nicht gefunden");
5804 }
5805
5806 final Set<String> expectedClasses = TestUtil.getEverytimeExpectedClasses();
5807 expectedClasses.add("generated.model.group1.class1");
5808 expectedClasses.add("generated.products." + product);
5809 expectedClasses.add("generated.products." + abstractProduct);
5810 expectedClasses.add(product0);
5811 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
5812
5813 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
5814 while (i.hasNext()) {
5815 final GenClass genClass = i.next();
5816 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
5817 switch (genClass.getName()) {
5818 case TypeNameGenerator.PRODUCT_BEGIN + TypeNameGenerator.PRODUCT_END:
5819 break;
5820 case "class1":
5821 assertEquals("generated.model.group1", genClass.getPackag().toString());
5822 genClass.accept(new GenClassVisitor() {
5823
5824 @Override
5825 public void handle(final GenInterfaceClass interfaceClass) {
5826 assertEquals(1, interfaceClass.getOperations().size());
5827 final Collection<String> expectedOperations = new Vector<>();
5828 expectedOperations
5829 .add("public void op1(de.fhdw.wtf.context.model.Str vorname, de.fhdw.wtf.context.model.Str nachname)");
5830 TestUtil.assertEqualsForOperations(expectedOperations, interfaceClass.getOperations());
5831
5832 interfaceClass.accept(new GenInterfaceClassVisitor() {
5833
5834 @Override
5835 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
5836 final Set<String> operations = new HashSet<>();
5837 operations
5838 .add("public void op1(de.fhdw.wtf.context.model.Str vorname, de.fhdw.wtf.context.model.Str nachname)");
5839 operations.add("private generated.model.group1.class1 $getThis()");
5840
5841 operations.add("private de.fhdw.wtf.context.model.collections.MutableMap"
5842 + "<de.fhdw.wtf.context.model.Str,de.fhdw.wtf.context.model.AnyType>"
5843 + " get$generatedObjects()");
5844 final Set<String> attributes = new HashSet<>();
5845 attributes.add("private generated.model.group1.class1 This");
5846 attributes.add(TestConstants.INHERITANCE_MAP_ATTRIBUTE);
5847 final Set<String> modifiers = new HashSet<>();
5848 final Set<String> implement = new HashSet<>();
5849 implement.add("generated.model.group1.class1");
5850 assertEquals(true, TestClassTransformer.controlImplClass(
5851 interfaceWithImplClass,
5852 "class1",
5853 "generated.model.group1",
5854 operations,
5855 attributes,
5856 modifiers,
5857 implement));
5858
5859
5860 }
5861
5862 @Override
5863 public void handle(final GenSimpleInterfaceClass simpleInterface) {
5864 fail();
5865 }
5866
5867 @Override
5868 public void handle(final GenExternalInterfaceClass iface) {
5869 fail();
5870 }
5871 });
5872 }
5873
5874 @Override
5875 public void handle(final GenClassClass classClass) {
5876 fail();
5877 }
5878
5879 @Override
5880 public void handle(final GenPrimitiveClass primitiveClass) {
5881 fail();
5882 }
5883 });
5884 break;
5885 case "Anything":
5886 genClass.accept(new GenClassVisitor() {
5887
5888 @Override
5889 public void handle(final GenInterfaceClass interfaceClass) {
5890 assertEquals(0, interfaceClass.getOperations().size());
5891 }
5892
5893 @Override
5894 public void handle(final GenClassClass classClass) {
5895 fail();
5896 }
5897
5898 @Override
5899 public void handle(final GenPrimitiveClass primitiveClass) {
5900 fail();
5901 }
5902 });
5903 break;
5904 case product:
5905 genClass.accept(new GenClassVisitor() {
5906
5907 @Override
5908 public void handle(final GenPrimitiveClass primitiveClass) {
5909 fail();
5910 }
5911
5912 @Override
5913 public void handle(final GenInterfaceClass interfaceClass) {
5914 fail();
5915 }
5916
5917 @Override
5918 public void handle(final GenClassClass classClass) {
5919
5920
5921 final Collection<String> expectedImplement = new Vector<>();
5922 TestUtil.assertEqualsForImplement(expectedImplement, classClass.getImplement());
5923
5924 assertEquals("AnyType", classClass.getExtend().getName());
5925
5926 final Collection<String> expectedAttributes = new Vector<>();
5927 TestUtil.assertEqualsForAttributes(expectedAttributes, classClass.getAttributes());
5928
5929 final Collection<String> expectedOperations = new Vector<>();
5930 expectedOperations.add("public de.fhdw.wtf.context.model.Str getVorname()");
5931 expectedOperations.add("public void setVorname(de.fhdw.wtf.context.model.Str vorname)");
5932 expectedOperations.add("public de.fhdw.wtf.context.model.Str getNachname()");
5933 expectedOperations.add("public void setNachname(de.fhdw.wtf.context.model.Str nachname)");
5934 TestUtil.assertEqualsForOperations(expectedOperations, classClass.getOperations());
5935 }
5936 });
5937 break;
5938 case abstractProduct:
5939 genClass.accept(new GenClassVisitor() {
5940
5941 @Override
5942 public void handle(final GenPrimitiveClass primitiveClass) {
5943 fail();
5944 }
5945
5946 @Override
5947 public void handle(final GenInterfaceClass interfaceClass) {
5948 fail();
5949 }
5950
5951 @Override
5952 public void handle(final GenClassClass classClass) {
5953
5954
5955 final Collection<String> expectedImplement = new Vector<>();
5956 TestUtil.assertEqualsForImplement(expectedImplement, classClass.getImplement());
5957
5958 assertEquals("de.fhdw.wtf.context.model.AnyType", classClass.getExtend()
5959 .getFullyQualifiedTypeNameWithGenericArguments());
5960
5961 final Collection<String> expectedAttributes = new Vector<>();
5962 expectedAttributes.add("protected de.fhdw.wtf.context.model.Str p$1");
5963 expectedAttributes.add("protected de.fhdw.wtf.context.model.Str p$2");
5964 TestUtil.assertEqualsForAttributes(expectedAttributes, classClass.getAttributes());
5965
5966 final Collection<String> expectedOperations = new Vector<>();
5967
5968 TestUtil.assertEqualsForOperations(expectedOperations, classClass.getOperations());
5969 }
5970 });
5971 break;
5972 default:
5973 fail("Klasse erwartet und gefunden, wird aber nicht überprüft " + genClass.getName());
5974 break;
5975 }
5976
5977 } else {
5978 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getName());
5979 }
5980
5981 }
5982 if (expectedClasses.size() != 0) {
5983 fail("Klasse erwartet, aber nicht gefunden");
5984 }
5985 }
5986
5987
5988
5989
5990
5991
5992 @Ignore("Symmetric not implemented")
5993 @Test
5994 public void testClassWithSymmetricAttribute() throws Exception {
5995 final GeneratorModel javaGeneratorModel = this.generate(TestModels.classWithSymmetricAttribute);
5996
5997 final Set<String> expectedClasses = TestUtil.getEverytimeExpectedClasses();
5998 expectedClasses.addAll(TestUtil.getEverytimeExpectedClasses());
5999 expectedClasses.add("generated.model.group1.class1");
6000 expectedClasses.add("generated.model.group1.class2");
6001
6002 assertEquals(expectedClasses.size(), javaGeneratorModel.getClassMapping().size());
6003
6004 final Iterator<GenClass> i = javaGeneratorModel.getClassMapping().values().iterator();
6005 while (i.hasNext()) {
6006 final GenClass genClass = i.next();
6007 if (expectedClasses.remove(genClass.getFullyQualifiedTypeName())) {
6008 switch (genClass.getName()) {
6009 case "class1":
6010 assertEquals("generated.model.group1", genClass.getPackag().toString());
6011 genClass.accept(new GenClassVisitor() {
6012
6013 @Override
6014 public void handle(final GenInterfaceClass interfaceClass) {
6015 assertEquals(0, interfaceClass.getOperations().size());
6016
6017 interfaceClass.accept(new GenInterfaceClassVisitor() {
6018
6019 @Override
6020 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
6021 final Set<String> operations = new HashSet<>();
6022 final Set<String> attributes = new HashSet<>();
6023 attributes.add("private final symmetric att1");
6024 final Set<String> modifiers = new HashSet<>();
6025 final Set<String> implement = new HashSet<>();
6026 implement.add("generated.model.group1.class1");
6027 assertEquals(true, TestClassTransformer.controlImplClass(
6028 interfaceWithImplClass,
6029 "class1",
6030 "generated.model.group1",
6031 operations,
6032 attributes,
6033 modifiers,
6034 implement));
6035 }
6036
6037 @Override
6038 public void handle(final GenSimpleInterfaceClass simpleInterface) {
6039 fail();
6040 }
6041
6042 @Override
6043 public void handle(final GenExternalInterfaceClass iface) {
6044 fail();
6045 }
6046 });
6047 }
6048
6049 @Override
6050 public void handle(final GenClassClass classClass) {
6051 fail();
6052 }
6053
6054 @Override
6055 public void handle(final GenPrimitiveClass primitiveClass) {
6056 fail();
6057 }
6058 });
6059 break;
6060 case "class2":
6061 assertEquals("generated.model.group1", genClass.getPackag().toString());
6062 genClass.accept(new GenClassVisitor() {
6063
6064 @Override
6065 public void handle(final GenInterfaceClass interfaceClass) {
6066 assertEquals(0, interfaceClass.getOperations().size());
6067
6068 interfaceClass.accept(new GenInterfaceClassVisitor() {
6069
6070 @Override
6071 public void handle(final GenInterfaceWithClassImplClass interfaceWithImplClass) {
6072 final Set<String> operations = new HashSet<>();
6073 final Set<String> attributes = new HashSet<>();
6074 final Set<String> modifiers = new HashSet<>();
6075 final Set<String> implement = new HashSet<>();
6076 implement.add("generated.model.group1.class2");
6077 assertEquals(true, TestClassTransformer.controlImplClass(
6078 interfaceWithImplClass,
6079 "class2",
6080 "generated.model.group1",
6081 operations,
6082 attributes,
6083 modifiers,
6084 implement));
6085 }
6086
6087 @Override
6088 public void handle(final GenSimpleInterfaceClass simpleInterface) {
6089 fail();
6090 }
6091
6092 @Override
6093 public void handle(final GenExternalInterfaceClass iface) {
6094 fail();
6095 }
6096 });
6097 }
6098
6099 @Override
6100 public void handle(final GenClassClass classClass) {
6101 fail();
6102 }
6103
6104 @Override
6105 public void handle(final GenPrimitiveClass primitiveClass) {
6106 fail();
6107 }
6108 });
6109 break;
6110 case "Anything":
6111 genClass.accept(new GenClassVisitor() {
6112
6113 @Override
6114 public void handle(final GenInterfaceClass interfaceClass) {
6115 assertEquals(0, interfaceClass.getOperations().size());
6116 }
6117
6118 @Override
6119 public void handle(final GenClassClass classClass) {
6120 fail();
6121 }
6122
6123 @Override
6124 public void handle(final GenPrimitiveClass primitiveClass) {
6125 fail();
6126 }
6127 });
6128 break;
6129 default:
6130 fail("Klasse erwartet und gefunden, wird aber nicht überprüft " + genClass.getName());
6131 break;
6132 }
6133
6134 } else {
6135 fail("Klasse gefunden, die aber nicht erwartet wird." + genClass.getName());
6136 }
6137
6138 }
6139 if (expectedClasses.size() != 0) {
6140 fail("Klasse erwartet, aber nicht gefunden");
6141 }
6142 final Set<String> expectedTypes = new HashSet<>();
6143 expectedTypes.addAll(TestUtil.getEverytimeExpectedTypes());
6144 expectedTypes.add("generated.model.group1.class1");
6145
6146
6147
6148
6149 expectedTypes.add("MutableList");
6150 assertEquals(expectedTypes.size(), javaGeneratorModel.getTypeMapping().size());
6151
6152 final Iterator<Tuple<GenType, Collection<ExceptionClassType>>> i2 =
6153 javaGeneratorModel.getTypeMapping().values().iterator();
6154 while (i2.hasNext()) {
6155 final GenType genType = i2.next().getA();
6156 if (expectedTypes.remove(genType.getFullyQualifiedTypeName())) {
6157 switch (genType.getName()) {
6158 case "class1":
6159 genType.accept(new GenTypeVisitor() {
6160
6161 @Override
6162 public void handle(final GenImportType importType) {
6163 fail();
6164 }
6165
6166 @Override
6167 public void handle(final GenJavaUtilCollection javaUtilCollection) {
6168 fail();
6169 }
6170
6171 @Override
6172 public void handle(final Generic generic) {
6173 fail();
6174 }
6175
6176 @Override
6177 public void handle(final GenMapType mapType) {
6178 fail();
6179 }
6180
6181 @Override
6182 public void handle(final GenPrimitiveType primitiveType) {
6183 fail();
6184 }
6185
6186 @Override
6187 public void handle(final GenCollectionType collectionType) {
6188 fail();
6189 }
6190
6191 @Override
6192 public void handle(final GenClass cla) {
6193
6194 }
6195
6196 @Override
6197 public void handle(final GenDummyType dummy) {
6198 fail();
6199
6200 }
6201 });
6202 break;
6203 case "MutableList":
6204 genType.accept(new GenTypeVisitor() {
6205
6206 @Override
6207 public void handle(final GenImportType importType) {
6208 fail();
6209 }
6210
6211 @Override
6212 public void handle(final GenJavaUtilCollection javaUtilCollection) {
6213 fail();
6214 }
6215
6216 @Override
6217 public void handle(final Generic generic) {
6218 fail();
6219 }
6220
6221 @Override
6222 public void handle(final GenMapType mapType) {
6223 fail();
6224 }
6225
6226 @Override
6227 public void handle(final GenPrimitiveType primitiveType) {
6228 fail();
6229 }
6230
6231 @Override
6232 public void handle(final GenCollectionType collectionType) {
6233
6234 }
6235
6236 @Override
6237 public void handle(final GenClass cla) {
6238
6239 fail();
6240 }
6241
6242 @Override
6243 public void handle(final GenDummyType dummy) {
6244 fail();
6245
6246 }
6247 });
6248 break;
6249 case "Str":
6250 genType.accept(new GenTypeVisitor() {
6251
6252 @Override
6253 public void handle(final GenImportType importType) {
6254 fail();
6255 }
6256
6257 @Override
6258 public void handle(final GenJavaUtilCollection javaUtilCollection) {
6259 fail();
6260 }
6261
6262 @Override
6263 public void handle(final Generic generic) {
6264 fail();
6265 }
6266
6267 @Override
6268 public void handle(final GenMapType mapType) {
6269 fail();
6270 }
6271
6272 @Override
6273 public void handle(final GenPrimitiveType primitiveType) {
6274
6275 }
6276
6277 @Override
6278 public void handle(final GenCollectionType collectionType) {
6279 fail();
6280 }
6281
6282 @Override
6283 public void handle(final GenClass cla) {
6284 fail();
6285 }
6286
6287 @Override
6288 public void handle(final GenDummyType dummy) {
6289 fail();
6290
6291 }
6292 });
6293 break;
6294 case "Int":
6295 genType.accept(new GenTypeVisitor() {
6296
6297 @Override
6298 public void handle(final GenImportType importType) {
6299 fail();
6300 }
6301
6302 @Override
6303 public void handle(final GenJavaUtilCollection javaUtilCollection) {
6304 fail();
6305 }
6306
6307 @Override
6308 public void handle(final Generic generic) {
6309 fail();
6310 }
6311
6312 @Override
6313 public void handle(final GenMapType mapType) {
6314 fail();
6315 }
6316
6317 @Override
6318 public void handle(final GenPrimitiveType primitiveType) {
6319
6320 }
6321
6322 @Override
6323 public void handle(final GenCollectionType collectionType) {
6324 fail();
6325 }
6326
6327 @Override
6328 public void handle(final GenClass cla) {
6329 fail();
6330 }
6331
6332 @Override
6333 public void handle(final GenDummyType dummy) {
6334 fail();
6335
6336 }
6337 });
6338 break;
6339 case "Anything":
6340 genType.accept(new GenTypeVisitor() {
6341
6342 @Override
6343 public void handle(final GenImportType importType) {
6344 fail();
6345 }
6346
6347 @Override
6348 public void handle(final GenJavaUtilCollection javaUtilCollection) {
6349 fail();
6350 }
6351
6352 @Override
6353 public void handle(final Generic generic) {
6354 fail();
6355 }
6356
6357 @Override
6358 public void handle(final GenMapType mapType) {
6359 fail();
6360 }
6361
6362 @Override
6363 public void handle(final GenPrimitiveType primitiveType) {
6364 fail();
6365 }
6366
6367 @Override
6368 public void handle(final GenCollectionType collectionType) {
6369 fail();
6370 }
6371
6372 @Override
6373 public void handle(final GenClass cla) {
6374
6375 }
6376
6377 @Override
6378 public void handle(final GenDummyType dummy) {
6379 fail();
6380
6381 }
6382 });
6383 break;
6384 default:
6385 fail("Type erwartet und gefunden, wird aber nicht überprüft" + genType.getName());
6386 break;
6387 }
6388
6389 } else {
6390 fail("Type gefunden, die aber nicht erwartet wird." + genType.getName());
6391 }
6392
6393 }
6394 if (expectedTypes.size() != 0) {
6395 fail("Type erwartet, aber nicht gefunden");
6396 }
6397 }
6398 }