View Javadoc
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   * Test the functions of the referencer: - Finding the right type for a given name in {@link Model}. - Eliminate
48   * duplicate types. - Create anything.
49   */
50  public class TestTypeReferencer {
51  	
52  	/**
53  	 * Contains different functions to check the results of referencing.
54  	 */
55  	private AssertOperations assertOperations;
56  	
57  	/**
58  	 * Sets up the {@link AssertOperations} for each testcase.
59  	 */
60  	@Before
61  	public void setUp() {
62  		this.assertOperations = new AssertOperations();
63  	}
64  	
65  	/**
66  	 * Test the referencing of: Group1:group=[Class1:class={name:String prior;};];.
67  	 * 
68  	 * @throws Exception
69  	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
70  	 *             , {@link ExecutionException}.
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  	 * Test the referencing of: Group1:group=[Class1:class={name:String prior;};];.
90  	 * 
91  	 * @throws Exception
92  	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
93  	 *             , {@link ExecutionException}.
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 	 * Test the referencing of: Group1:group=[Class1:class={name:String prior;}; Class2:class={type:Class1*;name:String
116 	 * prior;alter:Integer prior;};]; Group2:group=[Class1:class= Class2 + {beschreibungen:String * prior;};];.
117 	 * 
118 	 * @throws Exception
119 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
120 	 *             , {@link ExecutionException}.
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 	 * Test the referencing of: Group1:group=[Class1:class={name:String prior;}; Class2:class={type:Class1*;name:String
142 	 * prior;alter:Integer prior;}; Group2:group=[Class1:class= Class2 + Class2 + {beschreibungen:String * prior;};];];.
143 	 * 
144 	 * @throws Exception
145 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
146 	 *             , {@link ExecutionException}.
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 	 * Test the referencing of:Group1:group=[Class1:class={name:String prior;};Class2:class={type:Class1*;name:String
167 	 * prior;alter:Integer prior;}abstract;Group2:group=[ Class1:class= Class2 + Class2 + {beschreibungen:String *
168 	 * prior;};Class1:class = {name:String prior;}; Group3:group=[Class1:class= Class1 + {alter:Integer;};];* ];];.
169 	 * 
170 	 * @throws Exception
171 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
172 	 *             , {@link ExecutionException}.
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 	 * Test the referencing of:Group1:group=[Group1:group=[Class1:class={};];Class1:class= Group1>Group1>Class1 + {};];
197 	 * Group2:group=[Class2:class = Group1>Class1 + Group1>Group1>Class1 + {class1:Group1>Class1* prior;};];.
198 	 * 
199 	 * @throws Exception
200 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
201 	 *             , {@link ExecutionException}.
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 		// TODO
219 		// assertEquals(3, v.getTypeReferencer().getExceptions().size());
220 		assertEquals(0, v.getOkResult().size());
221 	}
222 	
223 	/**
224 	 * Test the referencing of:Group1:group = [Group2:group = [Class1:class={};];];Group2:group=
225 	 * [Class1:class={};Group1:group=[Class1:class=
226 	 * Group2>Class1+{classa:Group1>Group2>Class1;};Group1:group=[Class1:class = Group2>Group1>Class1 +
227 	 * {class21:Group2>Group1>Class1;};];];];.
228 	 * 
229 	 * @throws Exception
230 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
231 	 *             , {@link ExecutionException}.
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 	 * Test the referencing of:Group1:group = [Group2:group = [Class1:class={};];]; Group2:group= [Class1:class=
401 	 * Group1>Class1 + {};Group1:group=[Class1:class= {classa:Group1>Group2>Class1;};Group1:group=[Class1:class =
402 	 * Group2>Group1>Class1 + {class21:Group2>Group1>Class1;};];];];.
403 	 * 
404 	 * @throws Exception
405 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
406 	 *             , {@link ExecutionException}.
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 	 * Test the referencing of: Group1:group = [Group2:group = [Class1:class={};];]; Group2:group= [Class1:class=
577 	 * Group1>Class1 + {}; Group1:group=[Class1:class= Group2>Class1 +{classa:Group1>Group2>Class1;};
578 	 * Group1:group=[Class1:class = Group2>Group1>Class1 + {class21:Group2>Group1>Class1;};];];];.
579 	 * 
580 	 * @throws Exception
581 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
582 	 *             , {@link ExecutionException}.
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 	 * Test the referencing of: group1:group = [class1:class= {} abstract; class2 : class = group1>class1 + {};] ;.
752 	 * 
753 	 * @throws Exception
754 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
755 	 *             , {@link ExecutionException}.
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 	 * Test the referencing of:group1 : group = [ class1 : class = {} abstract; class2 : class = class1 + {};] ;.
777 	 * 
778 	 * @throws Exception
779 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
780 	 *             , {@link ExecutionException}.
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 	 * Test the referencing of:group1 : group = [ class1 : class = {} abstract; class2 : class = {farbe : Integer;};];.
802 	 * 
803 	 * @throws Exception
804 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
805 	 *             , {@link ExecutionException}.
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 	 * Test the referencing of:group1:group=[class1:class={}abstract;
827 	 * group2:group=[class1:class={farben:String*;alter:Integer;};
828 	 * class2:class=class1+{x:class2;};class3:class=group1>class1+{};];];.
829 	 * 
830 	 * @throws Exception
831 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
832 	 *             , {@link ExecutionException}.
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 	 * Test the referencing of:group1:group=[class1:class={attr1:Class2 prior;};];.
855 	 * 
856 	 * @throws Exception
857 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
858 	 *             , {@link ExecutionException}.
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 	 * Test the referencing of: group1:group=[class1:class={attr1:group2>Class2 prior;};class2:class={};];
878 	 * group2:group=[class3:class={};];.
879 	 * 
880 	 * @throws Exception
881 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
882 	 *             , {@link ExecutionException}.
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 	 * Test the referencing of: group1:group=[class1:class={};
904 	 * group2:group=[class2:class={};group3:group=[class3:class={a:group2>class2;};];];];.
905 	 * 
906 	 * @throws Exception
907 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
908 	 *             , {@link ExecutionException}.
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 	 * Test the referencing of: group1:group=[class1:class={a:class1;};];.
930 	 * 
931 	 * @throws Exception
932 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
933 	 *             , {@link ExecutionException}.
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 	 * Test the referencing of: group1:group=[String:class={}; group2:group=[class1:class={a:String;};];];.
953 	 * 
954 	 * @throws Exception
955 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
956 	 *             , {@link ExecutionException}.
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 	 * Test the referencing of: group1:group=[class1:class={};group1:group=[class2:class=group1>class1+{};];];.
976 	 * 
977 	 * @throws Exception
978 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
979 	 *             , {@link ExecutionException}.
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 	 * Tests the elimination of duplicate Sums with: outerGroup:group=[outerClass:class={ op:[[(sum:{String, Integer})
1001 	 * -> Integer]];};innerGroup:group=[innerClass:class={ duplicateSumOp:[[(sameSum:{Integer, String} ) ->
1002 	 * Integer]];};];];.
1003 	 * 
1004 	 * @throws Exception
1005 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
1006 	 *             , {@link ExecutionException}.
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 		// final Parser parser = Parser.create(output);
1018 		// final Model model = parser.parse();
1019 		// final ReferencerTestReturnValue v = new ReferencerTestReturnValue(model);
1020 		
1021 		// TODO: Warum gibt es hier kein assert?
1022 		// final int expectedDifferentReferences = 6;
1023 		// this.assertOperations.assertNumberOfDifferentReferences(model, 6);
1024 	}
1025 	
1026 	/**
1027 	 * Tests the elimination of duplicate Sums with: outerGroup:group=[outerClass:class={ op:[[(param:Integer) ->
1028 	 * (x:Integer, y:Integer)]];};innerGroup:group=[ innerClass:class={duplicateSumOp:[[(param:Integer) -> (y:Integer,
1029 	 * x:Integer)]];};];];.
1030 	 * 
1031 	 * @throws Exception
1032 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
1033 	 *             , {@link ExecutionException}.
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 		// final Parser parser = Parser.create(output);
1045 		// final Model model = parser.parse();
1046 		// final ReferencerTestReturnValue v = new ReferencerTestReturnValue(model);
1047 		// TODO: Warum ist das auskommentiert?
1048 		// int expectedDifferentReferences = 6;
1049 		// this.assertOperations.assertNumberOfDifferentReferences(model, 6);
1050 	}
1051 	
1052 	/**
1053 	 * Tests the building of Anything with: group1:group=[class1:class={attribute:Anything;};];.
1054 	 * 
1055 	 * @throws Exception
1056 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
1057 	 *             , {@link ExecutionException}.
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 	 * Tests the building of Anything with: group1:group=[class1:class={attribute:(irgendwas:Anything);};];.
1120 	 * 
1121 	 * @throws Exception
1122 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
1123 	 *             , {@link ExecutionException}.
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 	 * Tests the building of Anything with: group1:group=[class1:class={operation:[[(param1:Anything) ->
1199 	 * Anything]];};class2:class={attribute:Anything;};];.
1200 	 * 
1201 	 * @throws Exception
1202 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
1203 	 *             , {@link ExecutionException}.
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 }