1 package de.fhdw.wtf.walker.tasks.test;
2
3 import static org.junit.Assert.assertEquals;
4
5 import java.util.Collection;
6 import java.util.Iterator;
7 import java.util.List;
8 import java.util.Vector;
9 import java.util.concurrent.ExecutionException;
10
11 import org.junit.Before;
12 import org.junit.Test;
13
14 import de.fhdw.wtf.common.ast.Attribute;
15 import de.fhdw.wtf.common.ast.AttributeModifier;
16 import de.fhdw.wtf.common.ast.Constructor;
17 import de.fhdw.wtf.common.ast.Group;
18 import de.fhdw.wtf.common.ast.GroupElement;
19 import de.fhdw.wtf.common.ast.Model;
20 import de.fhdw.wtf.common.ast.Name;
21 import de.fhdw.wtf.common.ast.Operation;
22 import de.fhdw.wtf.common.ast.QualifiedName;
23 import de.fhdw.wtf.common.ast.UnqualifiedName;
24 import de.fhdw.wtf.common.ast.type.BaseType;
25 import de.fhdw.wtf.common.ast.type.ByReferenceState;
26 import de.fhdw.wtf.common.ast.type.ClassModifier;
27 import de.fhdw.wtf.common.ast.type.ClassType;
28 import de.fhdw.wtf.common.ast.type.ProductElementType;
29 import de.fhdw.wtf.common.ast.type.ProductType;
30 import de.fhdw.wtf.common.ast.type.RegularClassType;
31 import de.fhdw.wtf.common.ast.type.SumType;
32 import de.fhdw.wtf.common.ast.type.Type;
33 import de.fhdw.wtf.common.ast.type.TypeProxy;
34 import de.fhdw.wtf.common.stream.FilteredTokenStream;
35 import de.fhdw.wtf.common.stream.SimpleScannerInput;
36 import de.fhdw.wtf.common.stream.TokenStream;
37 import de.fhdw.wtf.common.token.DummyToken;
38 import de.fhdw.wtf.common.token.IdentifierToken;
39 import de.fhdw.wtf.common.token.Position;
40 import de.fhdw.wtf.core.integration.testutil.AssertOperations;
41 import de.fhdw.wtf.dsl.scanner.common.Scanner;
42 import de.fhdw.wtf.dsl.scanner.modelScanner.ModelDslScanner;
43 import de.fhdw.wtf.parser.Parser;
44 import de.fhdw.wtf.walker.tasks.util.TypeReferencerTestReturnValue;
45
46
47
48
49
50 public class TestTypeReferencer {
51
52
53
54
55 private AssertOperations assertOperations;
56
57
58
59
60 @Before
61 public void setUp() {
62 this.assertOperations = new AssertOperations();
63 }
64
65
66
67
68
69
70
71
72 @Test
73 public void simpleGroupWithClassAndOneAttribute() throws Exception {
74 final Scanner scanner = ModelDslScanner.create();
75 final SimpleScannerInput input = new SimpleScannerInput("Group1:group=[Class1:class={name:String prior;};];");
76 final TokenStream output = FilteredTokenStream.create();
77 scanner.scan(input, output);
78 final Parser parser = Parser.create(output);
79 final Model result = parser.parse();
80
81 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(result);
82
83 assertEquals(1, v.getOkResult().size());
84 assertEquals(0, v.getFailResult().size());
85 this.assertOperations.assertAllReferencesByType(result);
86 }
87
88
89
90
91
92
93
94
95 @Test
96 public void simpleGroupInGroupAnd3ClassesWithDifferentAttributes() throws Exception {
97 final Scanner scanner = ModelDslScanner.create();
98 final SimpleScannerInput input =
99 new SimpleScannerInput("Group1:group=[Class1:class={name:String prior;};"
100 + "Class2:class={type:Class1*;name:String prior;alter:Integer prior;};"
101 + "Group2:group=[Class1:class= Class2 + {beschreibungen:String * prior;};];];");
102 final TokenStream output = FilteredTokenStream.create();
103 scanner.scan(input, output);
104 final Parser parser = Parser.create(output);
105 final Model result = parser.parse();
106
107 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(result);
108
109 assertEquals(0, v.getFailResult().size());
110 assertEquals(1, v.getOkResult().size());
111 this.assertOperations.assertAllReferencesByType(result);
112 }
113
114
115
116
117
118
119
120
121
122 @Test
123 public void simple2GroupsAnd3ClassesWithDifferentAttributesAndAWrongQualification() throws Exception {
124 final Scanner scanner = ModelDslScanner.create();
125 final SimpleScannerInput input =
126 new SimpleScannerInput("Group1:group=[Class1:class={name:String prior;};"
127 + "Class2:class={type:Class1*;name:String prior;alter:Integer prior;};];"
128 + "Group2:group=[Class1:class= Class2 + {beschreibungen:String * prior;};];");
129 final TokenStream output = FilteredTokenStream.create();
130 scanner.scan(input, output);
131 final Parser parser = Parser.create(output);
132 final Model result = parser.parse();
133
134 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(result);
135
136 assertEquals(1, v.getFailResult().size());
137 assertEquals(0, v.getOkResult().size());
138 }
139
140
141
142
143
144
145
146
147
148 @Test
149 public void simple2GroupsAnd3ClassesWithDifferentAttributesAnd2Supertypes() throws Exception {
150 final Scanner scanner = ModelDslScanner.create();
151 final SimpleScannerInput input =
152 new SimpleScannerInput("Group1:group=[Class1:class={name:String prior;};"
153 + "Class2:class={type:Class1*;name:String prior;alter:Integer prior;};"
154 + "Group2:group=[Class1:class= Class2 + Class2 + {beschreibungen:String * prior;};];];");
155 final TokenStream output = FilteredTokenStream.create();
156 scanner.scan(input, output);
157 final Parser parser = Parser.create(output);
158 final Model result = parser.parse();
159 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(result);
160 assertEquals(0, v.getFailResult().size());
161 assertEquals(1, v.getOkResult().size());
162 this.assertOperations.assertAllReferencesByType(result);
163 }
164
165
166
167
168
169
170
171
172
173
174 @Test
175 public void test3GroupsAndManyClassesWithDifferentAttributes() throws Exception {
176 final Scanner scanner = ModelDslScanner.create();
177 final SimpleScannerInput input =
178 new SimpleScannerInput("Group1:group=[Class1:class={"
179 + "name:String prior;};Class2:class={type:Class1*;name:String prior;"
180 + "alter:Integer prior;}abstract;Group2:group=[Class1:class= Class2 + Class2 + {"
181 + "beschreibungen:String * prior;}; Class1:class = {name:String prior;};"
182 + "Group3:group=[Class1:class= Class1 + {alter:Integer;};];];];");
183 final TokenStream output = FilteredTokenStream.create();
184 scanner.scan(input, output);
185 final Parser parser = Parser.create(output);
186 final Model result = parser.parse();
187
188 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(result);
189
190 assertEquals(0, v.getFailResult().size());
191 assertEquals(1, v.getOkResult().size());
192 this.assertOperations.assertAllReferencesByType(result);
193 }
194
195
196
197
198
199
200
201
202
203 @Test
204 public void testSupertypesWithDifferentGroups() throws Exception {
205 final Scanner scanner = ModelDslScanner.create();
206 final SimpleScannerInput input =
207 new SimpleScannerInput("Group1:group=[Group1:group=[Class1:class={"
208 + "};];Class1:class= Group1>Group1>Class1 + {};];Group2:group=["
209 + "Class2:class = Group1>Class1 + Group1>Group1>Class1 + {class1:Group1>Class1* prior;};];");
210 final TokenStream output = FilteredTokenStream.create();
211 scanner.scan(input, output);
212 final Parser parser = Parser.create(output);
213 final Model result = parser.parse();
214
215 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(result);
216
217 assertEquals(1, v.getFailResult().size());
218
219
220 assertEquals(0, v.getOkResult().size());
221 }
222
223
224
225
226
227
228
229
230
231
232
233 @Test
234 public void test2GroupsInModelAndDifferentOtherGroupsCheckingRelativePath() throws Exception {
235 final Scanner scanner = ModelDslScanner.create();
236 final SimpleScannerInput input =
237 new SimpleScannerInput("Group1:group = [Group2:group = ["
238 + "Class1:class={};];];Group2:group= [Class1:class={};Group1:group=["
239 + "Class1:class= Group2>Class1 +{classa:Group1>Group2>Class1;};Group1:group=["
240 + "Class1:class = Group2>Group1>Class1 + {class21:Group2>Group1>Class1;};];];];");
241 final IdentifierToken group1IdentifierToken =
242 IdentifierToken.create("Group1", Position.create("", 0 + 1, 0 + 1, 0));
243 final Model model = Model.create(group1IdentifierToken, null);
244
245 final Name group1Name = UnqualifiedName.create(group1IdentifierToken);
246 final Collection<GroupElement> group1Elements = new Vector<>();
247 final Group group1 = Group.create(group1Name, group1Elements, group1IdentifierToken, null);
248 model.addGroup(group1);
249 final IdentifierToken group12IdentifierToken =
250 IdentifierToken.create("Group2", Position.create("", 0 + 1, 0 + 1, 0));
251 final Name group12Name = group1Name.addName(group12IdentifierToken);
252 final Collection<GroupElement> group12Elements = new Vector<>();
253 final Group group12 = Group.create(group12Name, group12Elements, group12IdentifierToken, null);
254 group1Elements.add(group12);
255 final IdentifierToken class121IdentifierToken =
256 IdentifierToken.create("Class1", Position.create("", 0 + 1, 0 + 1, 0));
257 final Name class121Name = group12Name.addName(class121IdentifierToken);
258 final Collection<ClassModifier> class121Modifiers = new Vector<>();
259 final Collection<Attribute> class121Attributes = new Vector<>();
260 final List<Type> class121SuperTypes = new Vector<>();
261 final Collection<Operation> class121Operations = new Vector<>();
262 final ClassType class121 =
263 RegularClassType.create(
264 class121Name,
265 class121Modifiers,
266 class121Attributes,
267 class121SuperTypes,
268 class121Operations,
269 new Vector<Constructor>(),
270 class121IdentifierToken,
271
272 new Vector<ClassType>(),
273 null);
274 group12Elements.add(class121);
275 final IdentifierToken group2IdentifierToken =
276 IdentifierToken.create("Group2", Position.create("", 0 + 1, 0 + 1, 0));
277 final Name group2Name = UnqualifiedName.create(group2IdentifierToken);
278 final Collection<GroupElement> group2Elements = new Vector<>();
279 final Group group2 = Group.create(group2Name, group2Elements, group2IdentifierToken, null);
280 model.addGroup(group2);
281 final IdentifierToken class21IdentifierToken =
282 IdentifierToken.create("Class1", Position.create("", 0 + 1, 0 + 1, 0));
283 final Name class21Name = group2Name.addName(class21IdentifierToken);
284 final Collection<ClassModifier> class21Modifiers = new Vector<>();
285 final Collection<Attribute> class21Attributes = new Vector<>();
286 final List<Type> class21SuperTypes = new Vector<>();
287 final Collection<Operation> class21Operations = new Vector<>();
288 final ClassType class21 =
289 RegularClassType.create(
290 class21Name,
291 class21Modifiers,
292 class21Attributes,
293 class21SuperTypes,
294 class21Operations,
295 new Vector<Constructor>(),
296 class21IdentifierToken,
297
298 new Vector<ClassType>(),
299 null);
300 group2Elements.add(class21);
301 final IdentifierToken group21IdentifierToken =
302 IdentifierToken.create("Group1", Position.create("", 0 + 1, 0 + 1, 0));
303 final Name group21Name = group2Name.addName(group21IdentifierToken);
304 final Collection<GroupElement> group21Elements = new Vector<>();
305 final Group group21 = Group.create(group21Name, group21Elements, group21IdentifierToken, null);
306 group2Elements.add(group21);
307 final IdentifierToken class211IdentifierToken =
308 IdentifierToken.create("Class1", Position.create("", 0 + 1, 0 + 1, 0));
309 final Name class211Name = group21Name.addName(class211IdentifierToken);
310 final Collection<ClassModifier> class211Modifiers = new Vector<>();
311 final Collection<Attribute> class211Attributes = new Vector<>();
312 final List<Type> class211SuperTypes = new Vector<>();
313 final Collection<Operation> class211Operations = new Vector<>();
314 final ClassType class211 =
315 RegularClassType.create(
316 class211Name,
317 class211Modifiers,
318 class211Attributes,
319 class211SuperTypes,
320 class211Operations,
321 new Vector<Constructor>(),
322 class211IdentifierToken,
323
324 new Vector<ClassType>(),
325 null);
326 group21Elements.add(class211);
327 final ByReferenceState class211SuperTypeState = ByReferenceState.create(class21, class21.getTypeName());
328 final TypeProxy class211Supertype = TypeProxy.create(class211IdentifierToken, class211SuperTypeState, null);
329 class211SuperTypes.add(class211Supertype);
330 final ByReferenceState class211AttributeTypeReferenceState =
331 ByReferenceState.create(class121, class121.getTypeName());
332 final TypeProxy class211AttributeTypeReference =
333 TypeProxy.create(class121IdentifierToken, class211AttributeTypeReferenceState, null);
334
335 final IdentifierToken class211AttributeTypeIdentifier =
336 IdentifierToken.create("", Position.create("", 0 + 1, 0 + 1, 0));
337 final Attribute class211Attribute =
338 Attribute.create(
339 "classa",
340 class211AttributeTypeReference,
341 new Vector<AttributeModifier>(),
342 class211IdentifierToken,
343 null);
344 class211Attributes.add(class211Attribute);
345 final IdentifierToken group211IdentifierToken =
346 IdentifierToken.create("Group1", Position.create("", 0 + 1, 0 + 1, 0));
347 final Name group211Name = group21Name.addName(group211IdentifierToken);
348 final Collection<GroupElement> group211Elements = new Vector<>();
349 final Group group211 = Group.create(group211Name, group211Elements, group211IdentifierToken, null);
350 group21Elements.add(group211);
351 final IdentifierToken class2111IdentifierToken =
352 IdentifierToken.create("Class1", Position.create("", 0 + 1, 0 + 1, 0));
353 final Name class2111Name = group211Name.addName(class2111IdentifierToken);
354 final Collection<ClassModifier> class2111Modifiers = new Vector<>();
355 final Collection<Attribute> class2111Attributes = new Vector<>();
356 final List<Type> class2111SuperTypes = new Vector<>();
357 final Collection<Operation> class2111Operations = new Vector<>();
358 final ClassType class2111 =
359 RegularClassType.create(
360 class2111Name,
361 class2111Modifiers,
362 class2111Attributes,
363 class2111SuperTypes,
364 class2111Operations,
365 new Vector<Constructor>(),
366 class211IdentifierToken,
367
368 new Vector<ClassType>(),
369 null);
370 group211Elements.add(class2111);
371 final ByReferenceState class2111SuperTypeState = ByReferenceState.create(class211, class211.getTypeName());
372 final TypeProxy class2111Supertype = TypeProxy.create(class2111IdentifierToken, class2111SuperTypeState, null);
373 class2111SuperTypes.add(class2111Supertype);
374 final ByReferenceState class2111AttributeTypeReferenceState =
375 ByReferenceState.create(class211, class211.getTypeName());
376 final TypeProxy class2111AttributeTypeReference =
377 TypeProxy.create(class211AttributeTypeIdentifier, class2111AttributeTypeReferenceState, null);
378 final Attribute class2111Attribute =
379 Attribute.create(
380 "class21",
381 class2111AttributeTypeReference,
382 new Vector<AttributeModifier>(),
383 class2111IdentifierToken,
384 null);
385 class2111Attributes.add(class2111Attribute);
386
387 final TokenStream output = FilteredTokenStream.create();
388 scanner.scan(input, output);
389 final Parser parser = Parser.create(output);
390
391 final Model result = parser.parse();
392 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(result);
393
394 assertEquals(1, v.getFailResult().size());
395 assertEquals(1, v.getTypeReferencer().getExceptions().size());
396 assertEquals(0, v.getOkResult().size());
397 }
398
399
400
401
402
403
404
405
406
407
408 @Test
409 public void test2GroupsWithClassesRelativePath() throws Exception {
410 final Scanner scanner = ModelDslScanner.create();
411 final SimpleScannerInput input =
412 new SimpleScannerInput("Group1:group = [Group2:group = ["
413 + "Class1:class={};];]; Group2:group= [Class1:class= Group1>Class1 + {};"
414 + "Group1:group=[Class1:class= {classa:Group1>Group2>Class1;};Group1:group=["
415 + "Class1:class = Group2>Group1>Class1 + {class21:Group2>Group1>Class1;};];];];");
416 final IdentifierToken group1IdentifierToken =
417 IdentifierToken.create("Group1", Position.create("", 0 + 1, 0 + 1, 0));
418 final Model model = Model.create(group1IdentifierToken, null);
419
420 final Name group1Name = UnqualifiedName.create(group1IdentifierToken);
421 final Collection<GroupElement> group1Elements = new Vector<>();
422 final Group group1 = Group.create(group1Name, group1Elements, group1IdentifierToken, null);
423 model.addGroup(group1);
424 final IdentifierToken group12IdentifierToken =
425 IdentifierToken.create("Group2", Position.create("", 0 + 1, 0 + 1, 0));
426 final Name group12Name = group1Name.addName(group12IdentifierToken);
427 final Collection<GroupElement> group12Elements = new Vector<>();
428 final Group group12 = Group.create(group12Name, group12Elements, group12IdentifierToken, null);
429 group1Elements.add(group12);
430 final IdentifierToken class121IdentifierToken =
431 IdentifierToken.create("Class1", Position.create("", 0 + 1, 0 + 1, 0));
432 final Name class121Name = group12Name.addName(class121IdentifierToken);
433 final Collection<ClassModifier> class121Modifiers = new Vector<>();
434 final Collection<Attribute> class121Attributes = new Vector<>();
435 final List<Type> class121SuperTypes = new Vector<>();
436 final Collection<Operation> class121Operations = new Vector<>();
437 final ClassType class121 =
438 RegularClassType.create(
439 class121Name,
440 class121Modifiers,
441 class121Attributes,
442 class121SuperTypes,
443 class121Operations,
444 new Vector<Constructor>(),
445 class121IdentifierToken,
446
447 new Vector<ClassType>(),
448 null);
449 group12Elements.add(class121);
450 final IdentifierToken group2IdentifierToken =
451 IdentifierToken.create("Group2", Position.create("", 0 + 1, 0 + 1, 0));
452 final Name group2Name = UnqualifiedName.create(group2IdentifierToken);
453 final Collection<GroupElement> group2Elements = new Vector<>();
454 final Group group2 = Group.create(group2Name, group2Elements, group2IdentifierToken, null);
455 model.addGroup(group2);
456 final IdentifierToken class21IdentifierToken =
457 IdentifierToken.create("Class1", Position.create("", 0 + 1, 0 + 1, 0));
458 final Name class21Name = group2Name.addName(class21IdentifierToken);
459 final Collection<ClassModifier> class21Modifiers = new Vector<>();
460 final Collection<Attribute> class21Attributes = new Vector<>();
461 final List<Type> class21SuperTypes = new Vector<>();
462 final Collection<Operation> class21Operations = new Vector<>();
463 final ClassType class21 =
464 RegularClassType.create(
465 class21Name,
466 class21Modifiers,
467 class21Attributes,
468 class21SuperTypes,
469 class21Operations,
470 new Vector<Constructor>(),
471 class21IdentifierToken,
472
473 new Vector<ClassType>(),
474 null);
475 group2Elements.add(class21);
476 final IdentifierToken group21IdentifierToken =
477 IdentifierToken.create("Group1", Position.create("", 0 + 1, 0 + 1, 0));
478 final Name group21Name = group2Name.addName(group21IdentifierToken);
479 final Collection<GroupElement> group21Elements = new Vector<>();
480 final Group group21 = Group.create(group21Name, group21Elements, group21IdentifierToken);
481 group2Elements.add(group21);
482 final IdentifierToken class211IdentifierToken =
483 IdentifierToken.create("Class1", Position.create("", 0 + 1, 0 + 1, 0));
484 final Name class211Name = group21Name.addName(class211IdentifierToken);
485 final Collection<ClassModifier> class211Modifiers = new Vector<>();
486 final Collection<Attribute> class211Attributes = new Vector<>();
487 final List<Type> class211SuperTypes = new Vector<>();
488 final Collection<Operation> class211Operations = new Vector<>();
489 final ClassType class211 =
490 RegularClassType.create(
491 class211Name,
492 class211Modifiers,
493 class211Attributes,
494 class211SuperTypes,
495 class211Operations,
496 new Vector<Constructor>(),
497 class211IdentifierToken,
498
499 new Vector<ClassType>());
500 group21Elements.add(class211);
501 final ByReferenceState class21SuperTypeReferenceState =
502 ByReferenceState.create(class211, class211.getTypeName());
503 final TypeProxy class21SuperTypeReference =
504 TypeProxy.create(class211IdentifierToken, class21SuperTypeReferenceState);
505 class21SuperTypes.add(class21SuperTypeReference);
506 final ByReferenceState class211AttributeTypeReferenceState =
507 ByReferenceState.create(class121, class121.getTypeName());
508 final TypeProxy class211AttributeTypeReference =
509 TypeProxy.create(class121IdentifierToken, class211AttributeTypeReferenceState);
510 final IdentifierToken class211AttributeTypeIdentifier =
511 IdentifierToken.create("", Position.create("", 0 + 1, 0 + 1, 0));
512 final IdentifierToken class211AttributeIdentifier =
513 IdentifierToken.create("classa", Position.create("", 0 + 1, 0 + 1, 0));
514 final Attribute class211Attribute =
515 Attribute.create(
516 "classa",
517 class211AttributeTypeReference,
518 new Vector<AttributeModifier>(),
519 class211AttributeIdentifier);
520 class211Attributes.add(class211Attribute);
521 final IdentifierToken group211IdentifierToken =
522 IdentifierToken.create("Group1", Position.create("", 0 + 1, 0 + 1, 0));
523 final Name group211Name = group21Name.addName(group211IdentifierToken);
524 final Collection<GroupElement> group211Elements = new Vector<>();
525 final Group group211 = Group.create(group211Name, group211Elements, group211IdentifierToken);
526 group21Elements.add(group211);
527 final IdentifierToken class2111IdentifierToken =
528 IdentifierToken.create("Class1", Position.create("", 0 + 1, 0 + 1, 0));
529 final Name class2111Name = group211Name.addName(class2111IdentifierToken);
530 final Collection<ClassModifier> class2111Modifiers = new Vector<>();
531 final Collection<Attribute> class2111Attributes = new Vector<>();
532 final List<Type> class2111SuperTypes = new Vector<>();
533 final Collection<Operation> class2111Operations = new Vector<>();
534 final ClassType class2111 =
535 RegularClassType.create(
536 class2111Name,
537 class2111Modifiers,
538 class2111Attributes,
539 class2111SuperTypes,
540 class2111Operations,
541 new Vector<Constructor>(),
542 class2111IdentifierToken,
543
544 new Vector<ClassType>());
545 group211Elements.add(class2111);
546 final ByReferenceState class2111SuperTypeState = ByReferenceState.create(class211, class211.getTypeName());
547 final TypeProxy class2111Supertype = TypeProxy.create(class2111IdentifierToken, class2111SuperTypeState);
548 class2111SuperTypes.add(class2111Supertype);
549 final ByReferenceState class2111AttributeTypeReferenceState =
550 ByReferenceState.create(class211, class211.getTypeName());
551 final TypeProxy class2111AttributeTypeReference =
552 TypeProxy.create(class211AttributeTypeIdentifier, class2111AttributeTypeReferenceState);
553 final IdentifierToken class2111AttributeIdentifier =
554 IdentifierToken.create("", Position.create("", 0 + 1, 0 + 1, 0));
555 final Attribute class2111Attribute =
556 Attribute.create(
557 "class21",
558 class2111AttributeTypeReference,
559 new Vector<AttributeModifier>(),
560 class2111AttributeIdentifier);
561 class2111Attributes.add(class2111Attribute);
562
563 final TokenStream output = FilteredTokenStream.create();
564 scanner.scan(input, output);
565 final Parser parser = Parser.create(output);
566 final Model result = parser.parse();
567
568 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(result);
569
570 assertEquals(1, v.getFailResult().size());
571 assertEquals(1, v.getTypeReferencer().getExceptions().size());
572 assertEquals(0, v.getOkResult().size());
573 }
574
575
576
577
578
579
580
581
582
583
584 @Test
585 public void test2GroupsWithClasseHierarchieZyklus() throws Exception {
586 final Scanner scanner = ModelDslScanner.create();
587 final SimpleScannerInput input =
588 new SimpleScannerInput("Group1:group = [Group2:group = ["
589 + "Class1:class={};];];Group2:group= [Class1:class= Group1>Class1 + {};"
590 + "Group1:group=[Class1:class= Group2>Class1 +{classa:Group1>Group2>Class1;};"
591 + "Group1:group=[Class1:class = Group2>Group1>Class1 + {class21:Group2>Group1>Class1;};];];];");
592 final IdentifierToken group1IdentifierToken =
593 IdentifierToken.create("Group1", Position.create("", 0 + 1, 0 + 1, 0));
594 final Model model = Model.create(group1IdentifierToken);
595
596 final Name group1Name = UnqualifiedName.create(group1IdentifierToken);
597 final Collection<GroupElement> group1Elements = new Vector<>();
598 final Group group1 = Group.create(group1Name, group1Elements, group1IdentifierToken);
599 model.addGroup(group1);
600 final IdentifierToken group12IdentifierToken =
601 IdentifierToken.create("Group2", Position.create("", 0 + 1, 0 + 1, 0));
602 final Name group12Name = group1Name.addName(group12IdentifierToken);
603 final Collection<GroupElement> group12Elements = new Vector<>();
604 final Group group12 = Group.create(group12Name, group12Elements, group12IdentifierToken);
605 group1Elements.add(group12);
606 final IdentifierToken class121IdentifierToken =
607 IdentifierToken.create("Class1", Position.create("", 0 + 1, 0 + 1, 0));
608 final Name class121Name = group12Name.addName(class121IdentifierToken);
609 final Collection<ClassModifier> class121Modifiers = new Vector<>();
610 final Collection<Attribute> class121Attributes = new Vector<>();
611 final List<Type> class121SuperTypes = new Vector<>();
612 final Collection<Operation> class121Operations = new Vector<>();
613 final ClassType class121 =
614 RegularClassType.create(
615 class121Name,
616 class121Modifiers,
617 class121Attributes,
618 class121SuperTypes,
619 class121Operations,
620 new Vector<Constructor>(),
621 class121IdentifierToken,
622
623 new Vector<ClassType>());
624 group12Elements.add(class121);
625 final IdentifierToken group2IdentifierToken =
626 IdentifierToken.create("Group2", Position.create("", 0 + 1, 0 + 1, 0));
627 final Name group2Name = UnqualifiedName.create(group2IdentifierToken);
628 final Collection<GroupElement> group2Elements = new Vector<>();
629 final Group group2 = Group.create(group2Name, group2Elements, group2IdentifierToken);
630 model.addGroup(group2);
631 final IdentifierToken class21IdentifierToken =
632 IdentifierToken.create("Class1", Position.create("", 0 + 1, 0 + 1, 0));
633 final Name class21Name = group2Name.addName(class21IdentifierToken);
634 final Collection<ClassModifier> class21Modifiers = new Vector<>();
635 final Collection<Attribute> class21Attributes = new Vector<>();
636 final List<Type> class21SuperTypes = new Vector<>();
637 final Collection<Operation> class21Operations = new Vector<>();
638 final ClassType class21 =
639 RegularClassType.create(
640 class21Name,
641 class21Modifiers,
642 class21Attributes,
643 class21SuperTypes,
644 class21Operations,
645 new Vector<Constructor>(),
646 class21IdentifierToken,
647
648 new Vector<ClassType>());
649 group2Elements.add(class21);
650 final IdentifierToken group21IdentifierToken =
651 IdentifierToken.create("Group1", Position.create("", 0 + 1, 0 + 1, 0));
652 final Name group21Name = group2Name.addName(group21IdentifierToken);
653 final Collection<GroupElement> group21Elements = new Vector<>();
654 final Group group21 = Group.create(group21Name, group21Elements, group21IdentifierToken);
655 group2Elements.add(group21);
656 final IdentifierToken class211IdentifierToken =
657 IdentifierToken.create("Class1", Position.create("", 0 + 1, 0 + 1, 0));
658 final Name class211Name = group21Name.addName(class211IdentifierToken);
659 final Collection<ClassModifier> class211Modifiers = new Vector<>();
660 final Collection<Attribute> class211Attributes = new Vector<>();
661 final List<Type> class211SuperTypes = new Vector<>();
662 final Collection<Operation> class211Operations = new Vector<>();
663 final ClassType class211 =
664 RegularClassType.create(
665 class211Name,
666 class211Modifiers,
667 class211Attributes,
668 class211SuperTypes,
669 class211Operations,
670 new Vector<Constructor>(),
671 class211IdentifierToken,
672
673 new Vector<ClassType>());
674 group21Elements.add(class211);
675 final ByReferenceState class21SuperTypeReferenceState =
676 ByReferenceState.create(class211, class211.getTypeName());
677 final TypeProxy class21SuperTypeReference =
678 TypeProxy.create(class211IdentifierToken, class21SuperTypeReferenceState);
679 class21SuperTypes.add(class21SuperTypeReference);
680 final ByReferenceState class211SuperTypeState = ByReferenceState.create(class21, class21.getTypeName());
681 final TypeProxy class211Supertype = TypeProxy.create(class21IdentifierToken, class211SuperTypeState);
682 class211SuperTypes.add(class211Supertype);
683 final ByReferenceState class211AttributeTypeReferenceState =
684 ByReferenceState.create(class121, class121.getTypeName());
685 final TypeProxy class211AttributeTypeReference =
686 TypeProxy.create(class121IdentifierToken, class211AttributeTypeReferenceState);
687 final IdentifierToken class211AttributeTypeIdentifier =
688 IdentifierToken.create("", Position.create("", 0 + 1, 0 + 1, 0));
689 final IdentifierToken class211AttributeIdentifier =
690 IdentifierToken.create("classa", Position.create("", 0 + 1, 0 + 1, 0));
691 final Attribute class211Attribute =
692 Attribute.create(
693 "classa",
694 class211AttributeTypeReference,
695 new Vector<AttributeModifier>(),
696 class211AttributeIdentifier);
697 class211Attributes.add(class211Attribute);
698 final IdentifierToken group211IdentifierToken =
699 IdentifierToken.create("Group1", Position.create("", 0 + 1, 0 + 1, 0));
700 final Name group211Name = group21Name.addName(group211IdentifierToken);
701 final Collection<GroupElement> group211Elements = new Vector<>();
702 final Group group211 = Group.create(group211Name, group211Elements, group211IdentifierToken);
703 group21Elements.add(group211);
704 final IdentifierToken class2111IdentifierToken =
705 IdentifierToken.create("Class1", Position.create("", 0 + 1, 0 + 1, 0));
706 final Name class2111Name = group211Name.addName(class2111IdentifierToken);
707 final Collection<ClassModifier> class2111Modifiers = new Vector<>();
708 final Collection<Attribute> class2111Attributes = new Vector<>();
709 final List<Type> class2111SuperTypes = new Vector<>();
710 final ClassType class2111 =
711 RegularClassType.create(
712 class2111Name,
713 class2111Modifiers,
714 class2111Attributes,
715 class2111SuperTypes,
716 class211Operations,
717 new Vector<Constructor>(),
718 class2111IdentifierToken,
719
720 new Vector<ClassType>());
721 group211Elements.add(class2111);
722 final ByReferenceState class2111SuperTypeState = ByReferenceState.create(class211, class211.getTypeName());
723 final TypeProxy class2111Supertype = TypeProxy.create(class211IdentifierToken, class2111SuperTypeState);
724 class2111SuperTypes.add(class2111Supertype);
725 final ByReferenceState class2111AttributeTypeReferenceState =
726 ByReferenceState.create(class211, class211.getTypeName());
727 final TypeProxy class2111AttributeTypeReference =
728 TypeProxy.create(class211AttributeTypeIdentifier, class2111AttributeTypeReferenceState);
729 final IdentifierToken class2111AttributeIdentifier =
730 IdentifierToken.create("class21", Position.create("", 0 + 1, 0 + 1, 0));
731 final Attribute class2111Attribute =
732 Attribute.create(
733 "class21",
734 class2111AttributeTypeReference,
735 new Vector<AttributeModifier>(),
736 class2111AttributeIdentifier);
737 class2111Attributes.add(class2111Attribute);
738
739 final TokenStream output = FilteredTokenStream.create();
740 scanner.scan(input, output);
741 final Parser parser = Parser.create(output);
742
743 final Model result = parser.parse();
744 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(result);
745 assertEquals(1, v.getFailResult().size());
746 assertEquals(1, v.getTypeReferencer().getExceptions().size());
747 assertEquals(0, v.getOkResult().size());
748 }
749
750
751
752
753
754
755
756
757 @Test
758 public void testSimpleReferencingFullQualified() throws Exception {
759 final SimpleScannerInput input =
760 new SimpleScannerInput(
761 "group1 : group = [ class1 : class = {} abstract; class2 : class = group1>class1 + {};] ; ");
762 final TokenStream output = FilteredTokenStream.create();
763 final Scanner scanner = ModelDslScanner.create();
764 scanner.scan(input, output);
765 final Parser parser = Parser.create(output);
766 final Model model = parser.parse();
767
768 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(model);
769
770 assertEquals(0, v.getFailResult().size());
771 assertEquals(1, v.getOkResult().size());
772 this.assertOperations.assertAllReferencesByType(model);
773 }
774
775
776
777
778
779
780
781
782 @Test
783 public void testSimpleReferencingUnqualified() throws Exception {
784 final SimpleScannerInput input =
785 new SimpleScannerInput(
786 "group1 : group = [ class1 : class = {} abstract; class2 : class = class1 + {};] ; ");
787 final TokenStream output = FilteredTokenStream.create();
788 final Scanner scanner = ModelDslScanner.create();
789 scanner.scan(input, output);
790 final Parser parser = Parser.create(output);
791 final Model model = parser.parse();
792
793 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(model);
794
795 assertEquals(0, v.getFailResult().size());
796 assertEquals(1, v.getOkResult().size());
797 this.assertOperations.assertAllReferencesByType(model);
798 }
799
800
801
802
803
804
805
806
807 @Test
808 public void testSimpleReferencingBaseTypeAttribute() throws Exception {
809 final SimpleScannerInput input =
810 new SimpleScannerInput(
811 "group1 : group = [ class1 : class = {} abstract; class2 : class = {farbe : Integer;};] ; ");
812 final TokenStream output = FilteredTokenStream.create();
813 final Scanner scanner = ModelDslScanner.create();
814 scanner.scan(input, output);
815 final Parser parser = Parser.create(output);
816 final Model model = parser.parse();
817
818 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(model);
819
820 assertEquals(0, v.getFailResult().size());
821 assertEquals(1, v.getOkResult().size());
822 this.assertOperations.assertAllReferencesByType(model);
823 }
824
825
826
827
828
829
830
831
832
833
834 @Test
835 public void testSameClassNameDifferentGroups() throws Exception {
836 final SimpleScannerInput input =
837 new SimpleScannerInput(
838 "group1:group=[class1:class={}abstract;group2:group=[class1:class={farben:String*;alter:Integer;};"
839 + "class2:class=class1+{x:class2;};class3:class=group1>class1+{};];];");
840 final TokenStream output = FilteredTokenStream.create();
841 final Scanner scanner = ModelDslScanner.create();
842 scanner.scan(input, output);
843 final Parser parser = Parser.create(output);
844 final Model model = parser.parse();
845
846 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(model);
847
848 assertEquals(0, v.getFailResult().size());
849 assertEquals(1, v.getOkResult().size());
850 this.assertOperations.assertAllReferencesByType(model);
851 }
852
853
854
855
856
857
858
859
860 @Test
861 public void testNoClassException1() throws Exception {
862 final SimpleScannerInput input =
863 new SimpleScannerInput("group1:group=[class1:class={" + "attr1:Class2 prior;};];");
864 final TokenStream output = FilteredTokenStream.create();
865 final Scanner scanner = ModelDslScanner.create();
866 scanner.scan(input, output);
867 final Parser parser = Parser.create(output);
868 final Model model = parser.parse();
869 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(model);
870
871 assertEquals(1, v.getFailResult().size());
872 assertEquals(0, v.getOkResult().size());
873 assertEquals(1, v.getTypeReferencer().getExceptions().size());
874 }
875
876
877
878
879
880
881
882
883
884 @Test
885 public void testNoClassException2() throws Exception {
886 final SimpleScannerInput input =
887 new SimpleScannerInput("group1:group=[class1:class={" + "attr1:group2>Class2 prior;};"
888 + "class2:class={};];group2:group=[" + "class3:class={};];");
889 final TokenStream output = FilteredTokenStream.create();
890 final Scanner scanner = ModelDslScanner.create();
891 scanner.scan(input, output);
892 final Parser parser = Parser.create(output);
893 final Model model = parser.parse();
894
895 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(model);
896
897 assertEquals(1, v.getFailResult().size());
898 assertEquals(0, v.getOkResult().size());
899 assertEquals(1, v.getTypeReferencer().getExceptions().size());
900 }
901
902
903
904
905
906
907
908
909
910 @Test
911 public void testRelativeQualifiers() throws Exception {
912 final SimpleScannerInput input =
913 new SimpleScannerInput("group1:group=[class1:class={};"
914 + "group2:group=[class2:class={};group3:group=[class3:class={a:group2>class2;};];];];");
915 final TokenStream output = FilteredTokenStream.create();
916 final Scanner scanner = ModelDslScanner.create();
917 scanner.scan(input, output);
918 final Parser parser = Parser.create(output);
919 final Model model = parser.parse();
920
921 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(model);
922
923 assertEquals(0, v.getFailResult().size());
924 assertEquals(1, v.getOkResult().size());
925 this.assertOperations.assertAllReferencesByType(model);
926 }
927
928
929
930
931
932
933
934
935 @Test
936 public void testClassAsAttribute() throws Exception {
937 final SimpleScannerInput input = new SimpleScannerInput("group1:group=[class1:class={a:class1;};];");
938 final TokenStream output = FilteredTokenStream.create();
939 final Scanner scanner = ModelDslScanner.create();
940 scanner.scan(input, output);
941 final Parser parser = Parser.create(output);
942 final Model model = parser.parse();
943
944 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(model);
945
946 assertEquals(0, v.getFailResult().size());
947 assertEquals(1, v.getOkResult().size());
948 this.assertOperations.assertAllReferencesByType(model);
949 }
950
951
952
953
954
955
956
957
958 @Test
959 public void testUserString() throws Exception {
960 final SimpleScannerInput input =
961 new SimpleScannerInput("group1:group=[String:class={};" + "group2:group=[class1:class={a:String;};];];");
962 final TokenStream output = FilteredTokenStream.create();
963 final Scanner scanner = ModelDslScanner.create();
964 scanner.scan(input, output);
965 final Parser parser = Parser.create(output);
966 final Model model = parser.parse();
967 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(model);
968
969 assertEquals(0, v.getFailResult().size());
970 assertEquals(1, v.getOkResult().size());
971 this.assertOperations.assertAllReferencesByType(model);
972 }
973
974
975
976
977
978
979
980
981 @Test
982 public void testFindNoClassBecauseLocal() throws Exception {
983 final SimpleScannerInput input =
984 new SimpleScannerInput("group1:group=[class1:class={};group1:group=["
985 + "class2:class=group1>class1+{};];];");
986 final TokenStream output = FilteredTokenStream.create();
987 final Scanner scanner = ModelDslScanner.create();
988 scanner.scan(input, output);
989 final Parser parser = Parser.create(output);
990 final Model model = parser.parse();
991
992 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(model);
993
994 assertEquals(1, v.getFailResult().size());
995 assertEquals(0, v.getOkResult().size());
996 assertEquals(1, v.getTypeReferencer().getExceptions().size());
997 }
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008 @Test
1009 public void testDuplicateSumElimination() throws Exception {
1010 final SimpleScannerInput input =
1011 new SimpleScannerInput("outerGroup:group=[outerClass:class={"
1012 + "op:[[(sum:{String, Integer}) -> Integer]];};innerGroup:group=[innerClass:class={"
1013 + "duplicateSumOp:[[(sameSum:{Integer, String} ) -> Integer]];};];];");
1014 final TokenStream output = FilteredTokenStream.create();
1015 final Scanner scanner = ModelDslScanner.create();
1016 scanner.scan(input, output);
1017
1018
1019
1020
1021
1022
1023
1024 }
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035 @Test
1036 public void testDuplicateProductElimination() throws Exception {
1037 final SimpleScannerInput input =
1038 new SimpleScannerInput("outerGroup:group=[outerClass:class={"
1039 + "op:[[(param:Integer) -> (x:Integer, y:Integer)]];};innerGroup:group=["
1040 + "innerClass:class={duplicateSumOp:[[(param:Integer) -> (y:Integer, x:Integer)]];};];];");
1041 final TokenStream output = FilteredTokenStream.create();
1042 final Scanner scanner = ModelDslScanner.create();
1043 scanner.scan(input, output);
1044
1045
1046
1047
1048
1049
1050 }
1051
1052
1053
1054
1055
1056
1057
1058
1059 @Test
1060 public void testSimpleAnything1() throws Exception {
1061
1062 final IdentifierToken class1Identifier = IdentifierToken.create("class1", Position.create("", 1, 15, 14));
1063 final IdentifierToken group1Identifier = IdentifierToken.create("group1", Position.create("", 1, 15, 14));
1064
1065 final SimpleScannerInput input = new SimpleScannerInput("group1:group=[class1:class={attribute:Anything;};];");
1066
1067 final TokenStream output = FilteredTokenStream.create();
1068 final Scanner scanner = ModelDslScanner.create();
1069 scanner.scan(input, output);
1070 final Parser parser = Parser.create(output);
1071 final Model model = parser.parse();
1072 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(model);
1073 assertEquals(1, v.getOkResult().size());
1074 assertEquals(0, v.getFailResult().size());
1075 this.assertOperations.assertAllReferencesByType(model);
1076
1077 final Vector<Attribute> attributes = new Vector<>();
1078
1079 final QualifiedName name =
1080 QualifiedName
1081 .create(UnqualifiedName.create(group1Identifier), UnqualifiedName.create(class1Identifier));
1082
1083 final ClassType clazz =
1084 RegularClassType.create(
1085 name,
1086 new Vector<ClassModifier>(),
1087 attributes,
1088 new Vector<Type>(),
1089 new Vector<Operation>(),
1090 new Vector<Constructor>(),
1091 DummyToken.getInstance(),
1092
1093 new Vector<ClassType>());
1094 ByReferenceState classState = ByReferenceState.create(clazz, clazz.getTypeName());
1095 TypeProxy proxy = TypeProxy.create(class1Identifier, classState);
1096 final SumType sum = SumType.create(DummyToken.getInstance());
1097 sum.add(proxy);
1098
1099 final BaseType string = model.getString();
1100 classState = ByReferenceState.create(string, string.getTypeName());
1101 proxy = TypeProxy.create(DummyToken.getInstance(), classState);
1102 sum.add(proxy);
1103
1104 final BaseType integer = model.getInteger();
1105 classState = ByReferenceState.create(integer, integer.getTypeName());
1106 proxy = TypeProxy.create(DummyToken.getInstance(), classState);
1107 sum.add(proxy);
1108
1109 final Group g = model.getGroups().iterator().next();
1110 final ClassType c = (ClassType) g.getGroupElements().iterator().next();
1111 final Attribute a = c.getAttributes().iterator().next();
1112 final TypeProxy t = (TypeProxy) a.getAttrType();
1113 final ByReferenceState state = (ByReferenceState) t.getState();
1114 assertEquals(sum, state.getTarget());
1115
1116 }
1117
1118
1119
1120
1121
1122
1123
1124
1125 @Test
1126 public void testSimpleAnything3() throws Exception {
1127
1128 final IdentifierToken class1Identifier = IdentifierToken.create("class1", Position.create("", 1, 15, 14));
1129 final IdentifierToken group1Identifier = IdentifierToken.create("group1", Position.create("", 1, 15, 14));
1130 final IdentifierToken anythingIdentifier = IdentifierToken.create("Anything", DummyToken.getDummyPosition());
1131 final IdentifierToken irgendwasIdentifier = IdentifierToken.create("irgendwas", DummyToken.getDummyPosition());
1132
1133 final SimpleScannerInput input =
1134 new SimpleScannerInput("group1:group=[" + "class1:class={attribute:(irgendwas:Anything);};];");
1135
1136 final TokenStream output = FilteredTokenStream.create();
1137 final Scanner scanner = ModelDslScanner.create();
1138 scanner.scan(input, output);
1139 final Parser parser = Parser.create(output);
1140 final Model model = parser.parse();
1141 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(model);
1142 assertEquals(1, v.getOkResult().size());
1143 assertEquals(0, v.getFailResult().size());
1144 this.assertOperations.assertAllReferencesByType(model);
1145
1146 final Vector<Attribute> attributes = new Vector<>();
1147
1148 final QualifiedName name =
1149 QualifiedName
1150 .create(UnqualifiedName.create(group1Identifier), UnqualifiedName.create(class1Identifier));
1151
1152 final SumType sum = SumType.create(DummyToken.getInstance());
1153 final ByReferenceState sumState = ByReferenceState.create(sum, UnqualifiedName.create(anythingIdentifier));
1154 final TypeProxy sumProxy = TypeProxy.create(anythingIdentifier, sumState);
1155
1156 final ProductElementType element = ProductElementType.create("irgendwas", sumProxy, irgendwasIdentifier);
1157 final ProductType product = ProductType.create(DummyToken.getInstance());
1158 product.addElement(element);
1159
1160 sum.add(product);
1161
1162 final ClassType clazz =
1163 RegularClassType.create(
1164 name,
1165 new Vector<ClassModifier>(),
1166 attributes,
1167 new Vector<Type>(),
1168 new Vector<Operation>(),
1169 new Vector<Constructor>(),
1170 DummyToken.getInstance(),
1171
1172 new Vector<ClassType>());
1173 ByReferenceState classState = ByReferenceState.create(clazz, clazz.getTypeName());
1174 TypeProxy proxy = TypeProxy.create(class1Identifier, classState);
1175
1176 sum.add(proxy);
1177
1178 final BaseType string = model.getString();
1179 classState = ByReferenceState.create(string, string.getTypeName());
1180 proxy = TypeProxy.create(DummyToken.getInstance(), classState);
1181 sum.add(proxy);
1182
1183 final BaseType integer = model.getInteger();
1184 classState = ByReferenceState.create(integer, integer.getTypeName());
1185 proxy = TypeProxy.create(DummyToken.getInstance(), classState);
1186 sum.add(proxy);
1187
1188 final Group g = model.getGroups().iterator().next();
1189 final ClassType c = (ClassType) g.getGroupElements().iterator().next();
1190 final Attribute a = c.getAttributes().iterator().next();
1191 final ProductType p = (ProductType) a.getAttrType();
1192 final TypeProxy s = (TypeProxy) p.getElements().get(0).getType();
1193 final ByReferenceState r = (ByReferenceState) s.getState();
1194 assertEquals(sum, r.getTarget());
1195 }
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205 @Test
1206 public void testSimpleAnything2() throws Exception {
1207
1208 final IdentifierToken class1Identifier = IdentifierToken.create("class1", Position.createDummyPosition());
1209 final IdentifierToken class2Identifier = IdentifierToken.create("class2", Position.createDummyPosition());
1210 final IdentifierToken group1Identifier = IdentifierToken.create("group1", Position.createDummyPosition());
1211 final IdentifierToken anythingIdentifier = IdentifierToken.create("Anything", DummyToken.getDummyPosition());
1212
1213 final SimpleScannerInput input =
1214 new SimpleScannerInput("group1:group=["
1215 + "class1:class={operation:[[(param1:Anything) -> Anything]];};"
1216 + "class2:class={attribute:Anything;};];");
1217
1218 final TokenStream output = FilteredTokenStream.create();
1219 final Scanner scanner = ModelDslScanner.create();
1220 scanner.scan(input, output);
1221 final Parser parser = Parser.create(output);
1222 final Model model = parser.parse();
1223 final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(model);
1224 assertEquals(1, v.getOkResult().size());
1225 assertEquals(0, v.getFailResult().size());
1226 this.assertOperations.assertAllReferencesByType(model);
1227
1228 final Vector<Attribute> attributes = new Vector<>();
1229 final Vector<Operation> operations = new Vector<>();
1230
1231 final QualifiedName class1Name =
1232 QualifiedName
1233 .create(UnqualifiedName.create(group1Identifier), UnqualifiedName.create(class1Identifier));
1234 final QualifiedName class2Name =
1235 QualifiedName
1236 .create(UnqualifiedName.create(group1Identifier), UnqualifiedName.create(class2Identifier));
1237
1238 final ClassType clazz1 =
1239 RegularClassType.create(
1240 class1Name,
1241 new Vector<ClassModifier>(),
1242 new Vector<Attribute>(),
1243 new Vector<Type>(),
1244 operations,
1245 new Vector<Constructor>(),
1246 DummyToken.getInstance(),
1247
1248 new Vector<ClassType>());
1249 final ByReferenceState class1State = ByReferenceState.create(clazz1, clazz1.getTypeName());
1250 final TypeProxy proxy1 = TypeProxy.create(class1Identifier, class1State);
1251
1252 final ClassType clazz2 =
1253 RegularClassType.create(
1254 class2Name,
1255 new Vector<ClassModifier>(),
1256 attributes,
1257 new Vector<Type>(),
1258 new Vector<Operation>(),
1259 new Vector<Constructor>(),
1260 DummyToken.getInstance(),
1261
1262 new Vector<ClassType>());
1263 final ByReferenceState class2State = ByReferenceState.create(clazz2, clazz2.getTypeName());
1264 final TypeProxy proxy2 = TypeProxy.create(class1Identifier, class2State);
1265 final SumType sum = SumType.create(DummyToken.getInstance());
1266 final ByReferenceState stateSum = ByReferenceState.create(sum, UnqualifiedName.create(anythingIdentifier));
1267 final TypeProxy typeProxySum = TypeProxy.create(DummyToken.getInstance(), stateSum);
1268
1269 final ProductType product = ProductType.create(DummyToken.getInstance());
1270 final ProductElementType element = ProductElementType.create("param1", typeProxySum, DummyToken.getInstance());
1271 product.addElement(element);
1272
1273 sum.add(product);
1274
1275 sum.add(proxy1);
1276 sum.add(proxy2);
1277
1278 final BaseType string = model.getString();
1279 ByReferenceState classState = ByReferenceState.create(string, string.getTypeName());
1280 TypeProxy proxy = TypeProxy.create(DummyToken.getInstance(), classState);
1281 sum.add(proxy);
1282
1283 final BaseType integer = model.getInteger();
1284 classState = ByReferenceState.create(integer, integer.getTypeName());
1285 proxy = TypeProxy.create(DummyToken.getInstance(), classState);
1286 sum.add(proxy);
1287
1288 final Group g = model.getGroups().iterator().next();
1289 final Iterator<GroupElement> classIterator = g.getGroupElements().iterator();
1290 final ClassType c1 = (ClassType) classIterator.next();
1291 final ClassType c2 = (ClassType) classIterator.next();
1292 final Operation o = c1.getOperations().iterator().next();
1293
1294 final TypeProxy typeProxyParam = (TypeProxy) o.getParameters().getElements().get(0).getType();
1295 final ByReferenceState stateParam = (ByReferenceState) typeProxyParam.getState();
1296 assertEquals(sum, stateParam.getTarget());
1297
1298 final TypeProxy typeProxyReferencerTestReturnValue = (TypeProxy) o.getReturnType();
1299 final ByReferenceState stateReferencerTestReturnValue =
1300 (ByReferenceState) typeProxyReferencerTestReturnValue.getState();
1301 assertEquals(sum, stateReferencerTestReturnValue.getTarget());
1302
1303 final Attribute a = c2.getAttributes().iterator().next();
1304 final TypeProxy t = (TypeProxy) a.getAttrType();
1305 final ByReferenceState state = (ByReferenceState) t.getState();
1306 assertEquals(state.getTarget(), sum);
1307 }
1308 }