View Javadoc
1   package de.fhdw.wtf.walker.tasks.test;
2   
3   import java.util.ArrayList;
4   import java.util.Collection;
5   import java.util.concurrent.ExecutionException;
6   
7   import junit.framework.TestCase;
8   
9   import org.junit.Test;
10  
11  import de.fhdw.wtf.common.ast.Model;
12  import de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException;
13  import de.fhdw.wtf.common.exception.walker.CyclicDependencyException;
14  import de.fhdw.wtf.common.exception.walker.CyclicPartDefinitionException;
15  import de.fhdw.wtf.common.exception.walker.InvalidOverloadingException;
16  import de.fhdw.wtf.common.stream.FilteredTokenStream;
17  import de.fhdw.wtf.common.stream.SimpleScannerInput;
18  import de.fhdw.wtf.common.stream.TokenStream;
19  import de.fhdw.wtf.common.task.GroupDependencyTask;
20  import de.fhdw.wtf.common.task.TaskExecutorFixed;
21  import de.fhdw.wtf.common.task.result.ExceptionalTaskResult;
22  import de.fhdw.wtf.common.task.result.OKTaskResult;
23  import de.fhdw.wtf.common.task.result.TaskResult;
24  import de.fhdw.wtf.common.task.result.visitor.TaskResultVisitor;
25  import de.fhdw.wtf.common.token.Position;
26  import de.fhdw.wtf.dsl.scanner.common.Scanner;
27  import de.fhdw.wtf.dsl.scanner.modelScanner.ModelDslScanner;
28  import de.fhdw.wtf.parser.Parser;
29  import de.fhdw.wtf.walker.tasks.CyclicInheritanceCheck;
30  import de.fhdw.wtf.walker.tasks.DoubleAttributenameCheck;
31  import de.fhdw.wtf.walker.tasks.DoubleGroupcomponentCheck;
32  import de.fhdw.wtf.walker.tasks.OverloadingCheck;
33  import de.fhdw.wtf.walker.tasks.PrototypesTask;
34  import de.fhdw.wtf.walker.tasks.SubtypesFillTask;
35  import de.fhdw.wtf.walker.tasks.TypeReferencer;
36  import de.fhdw.wtf.walker.walker.SimpleWalkerTask;
37  
38  /**
39   * Test {@link OverloadingCheck}.
40   */
41  public class TestOverloadingCheck extends TestCase {
42  	
43  	/**
44  	 * Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]];operation : [[(parameter:Integer) ->
45  	 * String ]];}; ]; .
46  	 * 
47  	 * @throws InterruptedException
48  	 * @throws ExecutionException
49  	 * @throws NoValidTokenStreamException
50  	 * @throws CyclicDependencyException
51  	 * @throws CyclicPartDefinitionException
52  	 */
53  	@Test
54  	public void testTwoEqualOperations() throws InterruptedException, ExecutionException, NoValidTokenStreamException,
55  			CyclicDependencyException, CyclicPartDefinitionException {
56  		final SimpleScannerInput input =
57  				new SimpleScannerInput("Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]];"
58  						+ "operation : [[(parameter:Integer) -> String ]];}; ];");
59  		final TokenStream output = FilteredTokenStream.create();
60  		final Scanner scanner = ModelDslScanner.create();
61  		scanner.scan(input, output);
62  		final Parser parser = Parser.create(output);
63  		Model model = null;
64  		model = parser.parse();
65  		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
66  		
67  		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
68  		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
69  		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
70  		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
71  		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
72  		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
73  		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
74  		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
75  		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
76  		referencer.addDependency(doubleChecks);
77  		cyclicInheritance.addDependency(referencer);
78  		subtypesFillTask.addDependency(cyclicInheritance);
79  		prototypesTask.addDependency(subtypesFillTask);
80  		overloadingCheck.addDependency(prototypesTask);
81  		taskmanager.startAllKnownTasks();
82  		
83  		final Collection<OKTaskResult> okResult = new ArrayList<>();
84  		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
85  		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
86  		for (final TaskResult current : results) {
87  			current.accept(new TaskResultVisitor() {
88  				
89  				@Override
90  				public void handleOkTaskResult(final OKTaskResult result) {
91  					okResult.add(result);
92  				}
93  				
94  				@Override
95  				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
96  					failResult.add(result);
97  				}
98  			});
99  		}
100 		
101 		assertEquals(7, okResult.size());
102 		assertEquals(1, failResult.size());
103 		
104 		final Exception exception = failResult.iterator().next().getError();
105 		if (exception instanceof InvalidOverloadingException) {
106 			final InvalidOverloadingException ex = (InvalidOverloadingException) exception;
107 			assertEquals(Position.create("", 1, 75, 74), ex.getStartPosition());
108 			assertEquals(Position.create("", 1, 122, 121), ex.getEndPos());
109 		} else {
110 			fail();
111 		}
112 	}
113 	
114 	/**
115 	 * Group:group=[Klasse:class={operation : [[(parameter:Klasse) -> String ]];operation : [[(parameter:Klasse) ->
116 	 * String ]];}; ]; .
117 	 * 
118 	 * @throws InterruptedException
119 	 * @throws ExecutionException
120 	 * @throws NoValidTokenStreamException
121 	 * @throws CyclicDependencyException
122 	 * @throws CyclicPartDefinitionException
123 	 */
124 	@Test
125 	public void testTwoEqualOperations2() throws InterruptedException, ExecutionException, NoValidTokenStreamException,
126 			CyclicDependencyException, CyclicPartDefinitionException {
127 		final SimpleScannerInput input =
128 				new SimpleScannerInput("Group:group=[Klasse:class={operation : [[(parameter:Klasse) -> String ]];"
129 						+ "operation : [[(parameter:Klasse) -> String ]];}; ];");
130 		final TokenStream output = FilteredTokenStream.create();
131 		final Scanner scanner = ModelDslScanner.create();
132 		scanner.scan(input, output);
133 		final Parser parser = Parser.create(output);
134 		Model model = null;
135 		model = parser.parse();
136 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
137 		
138 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
139 		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
140 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
141 		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
142 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
143 		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
144 		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
145 		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
146 		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
147 		referencer.addDependency(doubleChecks);
148 		cyclicInheritance.addDependency(referencer);
149 		subtypesFillTask.addDependency(cyclicInheritance);
150 		prototypesTask.addDependency(subtypesFillTask);
151 		overloadingCheck.addDependency(prototypesTask);
152 		taskmanager.startAllKnownTasks();
153 		
154 		final Collection<OKTaskResult> okResult = new ArrayList<>();
155 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
156 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
157 		for (final TaskResult current : results) {
158 			current.accept(new TaskResultVisitor() {
159 				
160 				@Override
161 				public void handleOkTaskResult(final OKTaskResult result) {
162 					okResult.add(result);
163 				}
164 				
165 				@Override
166 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
167 					failResult.add(result);
168 				}
169 			});
170 		}
171 		
172 		assertEquals(7, okResult.size());
173 		assertEquals(1, failResult.size());
174 		
175 		final Exception exception = failResult.iterator().next().getError();
176 		if (exception instanceof InvalidOverloadingException) {
177 			final InvalidOverloadingException ex = (InvalidOverloadingException) exception;
178 			assertEquals(Position.create("", 1, 74, 73), ex.getStartPosition());
179 			assertEquals(Position.create("", 1, 120, 119), ex.getEndPos());
180 		} else {
181 			fail();
182 		}
183 	}
184 	
185 	/**
186 	 * Group:group=[Klasse:class={operation : [[(parameter:Klasse2) -> String ]];operation : [[(parameter:Klasse2) ->
187 	 * String ]];}; Klasse2:class={};]; .
188 	 * 
189 	 * @throws InterruptedException
190 	 * @throws ExecutionException
191 	 * @throws NoValidTokenStreamException
192 	 * @throws CyclicDependencyException
193 	 * @throws CyclicPartDefinitionException
194 	 */
195 	@Test
196 	public void testTwoEqualOperations3() throws InterruptedException, ExecutionException, NoValidTokenStreamException,
197 			CyclicDependencyException, CyclicPartDefinitionException {
198 		final SimpleScannerInput input =
199 				new SimpleScannerInput("Group:group=[Klasse:class={operation : [[(parameter:Klasse2) -> String ]];"
200 						+ "operation : [[(parameter:Klasse2) -> String ]];}; Klasse2:class={};];");
201 		final TokenStream output = FilteredTokenStream.create();
202 		final Scanner scanner = ModelDslScanner.create();
203 		scanner.scan(input, output);
204 		final Parser parser = Parser.create(output);
205 		Model model = null;
206 		model = parser.parse();
207 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
208 		
209 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
210 		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
211 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
212 		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
213 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
214 		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
215 		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
216 		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
217 		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
218 		referencer.addDependency(doubleChecks);
219 		cyclicInheritance.addDependency(referencer);
220 		subtypesFillTask.addDependency(cyclicInheritance);
221 		prototypesTask.addDependency(subtypesFillTask);
222 		overloadingCheck.addDependency(prototypesTask);
223 		taskmanager.startAllKnownTasks();
224 		
225 		final Collection<OKTaskResult> okResult = new ArrayList<>();
226 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
227 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
228 		for (final TaskResult current : results) {
229 			current.accept(new TaskResultVisitor() {
230 				
231 				@Override
232 				public void handleOkTaskResult(final OKTaskResult result) {
233 					okResult.add(result);
234 				}
235 				
236 				@Override
237 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
238 					failResult.add(result);
239 				}
240 			});
241 		}
242 		
243 		assertEquals(7, okResult.size());
244 		assertEquals(1, failResult.size());
245 		
246 		final Exception exception = failResult.iterator().next().getError();
247 		if (exception instanceof InvalidOverloadingException) {
248 			final InvalidOverloadingException ex = (InvalidOverloadingException) exception;
249 			assertEquals(Position.create("", 1, 75, 74), ex.getStartPosition());
250 			assertEquals(Position.create("", 1, 122, 121), ex.getEndPos());
251 		} else {
252 			fail();
253 		}
254 	}
255 	
256 	/**
257 	 * Group:group=[Klasse:class={operation : [[(parameter:{Integer,String}) -> String ]];operation :
258 	 * [[(parameter:{String,Integer}) -> String ]];}; Klasse2:class={};]; .
259 	 * 
260 	 * @throws InterruptedException
261 	 * @throws ExecutionException
262 	 * @throws NoValidTokenStreamException
263 	 * @throws CyclicDependencyException
264 	 * @throws CyclicPartDefinitionException
265 	 */
266 	@Test
267 	public void testTwoEqualOperations4Sum() throws InterruptedException, ExecutionException,
268 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
269 		final SimpleScannerInput input =
270 				new SimpleScannerInput(
271 						"Group:group=[Klasse:class={operation : [[(parameter:{Integer,String}) -> String ]];"
272 								+ "operation : [[(parameter:{String,Integer}) -> String ]];}; Klasse2:class={};];");
273 		final TokenStream output = FilteredTokenStream.create();
274 		final Scanner scanner = ModelDslScanner.create();
275 		scanner.scan(input, output);
276 		final Parser parser = Parser.create(output);
277 		Model model = null;
278 		model = parser.parse();
279 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
280 		
281 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
282 		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
283 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
284 		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
285 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
286 		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
287 		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
288 		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
289 		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
290 		referencer.addDependency(doubleChecks);
291 		cyclicInheritance.addDependency(referencer);
292 		subtypesFillTask.addDependency(cyclicInheritance);
293 		prototypesTask.addDependency(subtypesFillTask);
294 		overloadingCheck.addDependency(prototypesTask);
295 		taskmanager.startAllKnownTasks();
296 		
297 		final Collection<OKTaskResult> okResult = new ArrayList<>();
298 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
299 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
300 		for (final TaskResult current : results) {
301 			current.accept(new TaskResultVisitor() {
302 				
303 				@Override
304 				public void handleOkTaskResult(final OKTaskResult result) {
305 					okResult.add(result);
306 				}
307 				
308 				@Override
309 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
310 					failResult.add(result);
311 				}
312 			});
313 		}
314 		
315 		assertEquals(7, okResult.size());
316 		assertEquals(1, failResult.size());
317 		
318 		final Exception exception = failResult.iterator().next().getError();
319 		if (exception instanceof InvalidOverloadingException) {
320 			final InvalidOverloadingException ex = (InvalidOverloadingException) exception;
321 			assertEquals(Position.create("", 1, 84, 83), ex.getStartPosition());
322 			assertEquals(Position.create("", 1, 140, 139), ex.getEndPos());
323 		} else {
324 			fail();
325 		}
326 	}
327 	
328 	/**
329 	 * Group:group=[Klasse:class={operation : [[(parameter:(p1:Integer,p2:String)) -> String ]];operation :
330 	 * [[(parameter:(p1:Integer,p2:String)) -> String ]];}; Klasse2:class={};]; .
331 	 * 
332 	 * @throws InterruptedException
333 	 * @throws ExecutionException
334 	 * @throws NoValidTokenStreamException
335 	 * @throws CyclicDependencyException
336 	 * @throws CyclicPartDefinitionException
337 	 */
338 	@Test
339 	public void testTwoEqualOperations5Product() throws InterruptedException, ExecutionException,
340 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
341 		final SimpleScannerInput input =
342 				new SimpleScannerInput(
343 						"Group:group=[Klasse:class={operation : [[(parameter:(p1:Integer,p2:String)) -> String ]];"
344 								+ "operation : [[(parameter:(p1:Integer,p2:String)) -> String ]];}; Klasse2:class={};];");
345 		final TokenStream output = FilteredTokenStream.create();
346 		final Scanner scanner = ModelDslScanner.create();
347 		scanner.scan(input, output);
348 		final Parser parser = Parser.create(output);
349 		Model model = null;
350 		model = parser.parse();
351 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
352 		
353 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
354 		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
355 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
356 		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
357 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
358 		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
359 		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
360 		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
361 		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
362 		referencer.addDependency(doubleChecks);
363 		cyclicInheritance.addDependency(referencer);
364 		subtypesFillTask.addDependency(cyclicInheritance);
365 		prototypesTask.addDependency(subtypesFillTask);
366 		overloadingCheck.addDependency(prototypesTask);
367 		taskmanager.startAllKnownTasks();
368 		
369 		final Collection<OKTaskResult> okResult = new ArrayList<>();
370 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
371 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
372 		for (final TaskResult current : results) {
373 			current.accept(new TaskResultVisitor() {
374 				
375 				@Override
376 				public void handleOkTaskResult(final OKTaskResult result) {
377 					okResult.add(result);
378 				}
379 				
380 				@Override
381 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
382 					failResult.add(result);
383 				}
384 			});
385 		}
386 		
387 		assertEquals(7, okResult.size());
388 		assertEquals(1, failResult.size());
389 		
390 		final Exception exception = failResult.iterator().next().getError();
391 		if (exception instanceof InvalidOverloadingException) {
392 			final InvalidOverloadingException ex = (InvalidOverloadingException) exception;
393 			assertEquals(Position.create("", 1, 90, 89), ex.getStartPosition());
394 			assertEquals(Position.create("", 1, 152, 151), ex.getEndPos());
395 		} else {
396 			fail();
397 		}
398 	}
399 	
400 	/**
401 	 * Group:group=[Klasse:class={operation : [[() -> String ]];operation : [[() -> String ]];}; ]; .
402 	 * 
403 	 * @throws InterruptedException
404 	 * @throws ExecutionException
405 	 * @throws NoValidTokenStreamException
406 	 * @throws CyclicDependencyException
407 	 * @throws CyclicPartDefinitionException
408 	 */
409 	@Test
410 	public void testTwoEqualOperationsWithNoParameter() throws InterruptedException, ExecutionException,
411 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
412 		final SimpleScannerInput input =
413 				new SimpleScannerInput(
414 						"Group:group=[Klasse:class={operation : [[() -> String ]];operation : [[() -> String ]];}; ];");
415 		final TokenStream output = FilteredTokenStream.create();
416 		final Scanner scanner = ModelDslScanner.create();
417 		scanner.scan(input, output);
418 		final Parser parser = Parser.create(output);
419 		Model model = null;
420 		model = parser.parse();
421 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
422 		
423 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
424 		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
425 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
426 		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
427 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
428 		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
429 		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
430 		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
431 		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
432 		referencer.addDependency(doubleChecks);
433 		cyclicInheritance.addDependency(referencer);
434 		subtypesFillTask.addDependency(cyclicInheritance);
435 		prototypesTask.addDependency(subtypesFillTask);
436 		overloadingCheck.addDependency(prototypesTask);
437 		taskmanager.startAllKnownTasks();
438 		
439 		final Collection<OKTaskResult> okResult = new ArrayList<>();
440 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
441 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
442 		for (final TaskResult current : results) {
443 			current.accept(new TaskResultVisitor() {
444 				
445 				@Override
446 				public void handleOkTaskResult(final OKTaskResult result) {
447 					okResult.add(result);
448 				}
449 				
450 				@Override
451 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
452 					failResult.add(result);
453 				}
454 			});
455 		}
456 		
457 		assertEquals(7, okResult.size());
458 		assertEquals(1, failResult.size());
459 		
460 		final Exception exception = failResult.iterator().next().getError();
461 		if (exception instanceof InvalidOverloadingException) {
462 			final InvalidOverloadingException ex = (InvalidOverloadingException) exception;
463 			assertEquals(Position.create("", 1, 58, 57), ex.getStartPosition());
464 			assertEquals(Position.create("", 1, 88, 87), ex.getEndPos());
465 		} else {
466 			fail();
467 		}
468 	}
469 	
470 	/**
471 	 * Group:group=[Klasse:class={operation : [[(param1:Integer,param2:String) -> String ]];operation :
472 	 * [[(param1:String,param2:Integer) -> String ]];}; ]; .
473 	 * 
474 	 * @throws InterruptedException
475 	 * @throws ExecutionException
476 	 * @throws NoValidTokenStreamException
477 	 * @throws CyclicDependencyException
478 	 * @throws CyclicPartDefinitionException
479 	 */
480 	@Test
481 	public void testTwoEqualOperationsButDifferentTypeSort() throws InterruptedException, ExecutionException,
482 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
483 		final SimpleScannerInput input =
484 				new SimpleScannerInput(
485 						"Group:group=[Klasse:class={operation : [[(param1:Integer,param2:String) -> String ]];"
486 								+ "operation : [[(param1:String,param2:Integer) -> String ]];}; ];");
487 		final TokenStream output = FilteredTokenStream.create();
488 		final Scanner scanner = ModelDslScanner.create();
489 		scanner.scan(input, output);
490 		final Parser parser = Parser.create(output);
491 		Model model = null;
492 		model = parser.parse();
493 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
494 		
495 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
496 		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
497 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
498 		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
499 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
500 		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
501 		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
502 		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
503 		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
504 		referencer.addDependency(doubleChecks);
505 		cyclicInheritance.addDependency(referencer);
506 		subtypesFillTask.addDependency(cyclicInheritance);
507 		prototypesTask.addDependency(subtypesFillTask);
508 		overloadingCheck.addDependency(prototypesTask);
509 		taskmanager.startAllKnownTasks();
510 		
511 		final Collection<OKTaskResult> okResult = new ArrayList<>();
512 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
513 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
514 		for (final TaskResult current : results) {
515 			current.accept(new TaskResultVisitor() {
516 				
517 				@Override
518 				public void handleOkTaskResult(final OKTaskResult result) {
519 					okResult.add(result);
520 				}
521 				
522 				@Override
523 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
524 					failResult.add(result);
525 				}
526 			});
527 		}
528 		
529 		assertEquals(8, okResult.size());
530 		assertEquals(0, failResult.size());
531 	}
532 	
533 	/**
534 	 * "Group:group=[Klasse:class={operation : [[(param:(p1:Integer,p2:String)) -> String ]];operation :
535 	 * [[(param:(p001:Integer,p002:String)) -> String ]];}; ]; .
536 	 * 
537 	 * @throws InterruptedException
538 	 * @throws ExecutionException
539 	 * @throws NoValidTokenStreamException
540 	 * @throws CyclicDependencyException
541 	 * @throws CyclicPartDefinitionException
542 	 */
543 	@Test
544 	public void testTwoDifferentProductsAsParamDifferentInProductElementNames() throws InterruptedException,
545 			ExecutionException, NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
546 		final SimpleScannerInput input =
547 				new SimpleScannerInput(
548 						"Group:group=[Klasse:class={operation : [[(param:(p1:Integer,p2:String)) -> String ]];"
549 								+ "operation : [[(param:(p001:Integer,p002:String)) -> String ]];}; ];");
550 		final TokenStream output = FilteredTokenStream.create();
551 		final Scanner scanner = ModelDslScanner.create();
552 		scanner.scan(input, output);
553 		final Parser parser = Parser.create(output);
554 		Model model = null;
555 		model = parser.parse();
556 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
557 		
558 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
559 		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
560 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
561 		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
562 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
563 		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
564 		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
565 		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
566 		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
567 		referencer.addDependency(doubleChecks);
568 		cyclicInheritance.addDependency(referencer);
569 		subtypesFillTask.addDependency(cyclicInheritance);
570 		prototypesTask.addDependency(subtypesFillTask);
571 		overloadingCheck.addDependency(prototypesTask);
572 		taskmanager.startAllKnownTasks();
573 		
574 		final Collection<OKTaskResult> okResult = new ArrayList<>();
575 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
576 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
577 		for (final TaskResult current : results) {
578 			current.accept(new TaskResultVisitor() {
579 				
580 				@Override
581 				public void handleOkTaskResult(final OKTaskResult result) {
582 					okResult.add(result);
583 				}
584 				
585 				@Override
586 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
587 					failResult.add(result);
588 				}
589 			});
590 		}
591 		
592 		assertEquals(8, okResult.size());
593 		assertEquals(0, failResult.size());
594 	}
595 	
596 	/**
597 	 * Group:group=[Klasse:class={operation : [[(param1:Integer,param2:String, param3:Integer) -> String ]];operation :
598 	 * [[(param1:String,param2:Integer,param3:Integer) -> String ]];}; ]; .
599 	 * 
600 	 * @throws InterruptedException
601 	 * @throws ExecutionException
602 	 * @throws NoValidTokenStreamException
603 	 * @throws CyclicDependencyException
604 	 * @throws CyclicPartDefinitionException
605 	 */
606 	@Test
607 	public void testTwoEqualOperationsButDifferentTypeSort2() throws InterruptedException, ExecutionException,
608 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
609 		final SimpleScannerInput input =
610 				new SimpleScannerInput(
611 						"Group:group=[Klasse:class={operation : [[(param1:Integer,param2:String, param3:Integer) -> String ]];"
612 								+ "operation : [[(param1:String,param2:Integer,param3:Integer) -> String ]];}; ];");
613 		final TokenStream output = FilteredTokenStream.create();
614 		final Scanner scanner = ModelDslScanner.create();
615 		scanner.scan(input, output);
616 		final Parser parser = Parser.create(output);
617 		Model model = null;
618 		model = parser.parse();
619 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
620 		
621 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
622 		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
623 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
624 		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
625 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
626 		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
627 		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
628 		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
629 		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
630 		referencer.addDependency(doubleChecks);
631 		cyclicInheritance.addDependency(referencer);
632 		subtypesFillTask.addDependency(cyclicInheritance);
633 		prototypesTask.addDependency(subtypesFillTask);
634 		overloadingCheck.addDependency(prototypesTask);
635 		taskmanager.startAllKnownTasks();
636 		
637 		final Collection<OKTaskResult> okResult = new ArrayList<>();
638 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
639 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
640 		for (final TaskResult current : results) {
641 			current.accept(new TaskResultVisitor() {
642 				
643 				@Override
644 				public void handleOkTaskResult(final OKTaskResult result) {
645 					okResult.add(result);
646 				}
647 				
648 				@Override
649 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
650 					failResult.add(result);
651 				}
652 			});
653 		}
654 		
655 		assertEquals(8, okResult.size());
656 		assertEquals(0, failResult.size());
657 	}
658 	
659 	/**
660 	 * Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]];operation : [[(parameter:String) ->
661 	 * String ]];}; ]; .
662 	 * 
663 	 * @throws InterruptedException
664 	 * @throws ExecutionException
665 	 * @throws NoValidTokenStreamException
666 	 * @throws CyclicDependencyException
667 	 * @throws CyclicPartDefinitionException
668 	 */
669 	@Test
670 	public void testTwoOperationWithCorrectOverloading() throws InterruptedException, ExecutionException,
671 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
672 		final SimpleScannerInput input =
673 				new SimpleScannerInput("Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]];"
674 						+ "operation : [[(parameter:String) -> String ]];}; ];");
675 		final TokenStream output = FilteredTokenStream.create();
676 		final Scanner scanner = ModelDslScanner.create();
677 		scanner.scan(input, output);
678 		final Parser parser = Parser.create(output);
679 		Model model = null;
680 		model = parser.parse();
681 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
682 		
683 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
684 		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
685 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
686 		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
687 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
688 		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
689 		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
690 		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
691 		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
692 		referencer.addDependency(doubleChecks);
693 		cyclicInheritance.addDependency(referencer);
694 		subtypesFillTask.addDependency(cyclicInheritance);
695 		prototypesTask.addDependency(subtypesFillTask);
696 		overloadingCheck.addDependency(prototypesTask);
697 		taskmanager.startAllKnownTasks();
698 		
699 		final Collection<OKTaskResult> okResult = new ArrayList<>();
700 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
701 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
702 		for (final TaskResult current : results) {
703 			current.accept(new TaskResultVisitor() {
704 				
705 				@Override
706 				public void handleOkTaskResult(final OKTaskResult result) {
707 					okResult.add(result);
708 				}
709 				
710 				@Override
711 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
712 					failResult.add(result);
713 				}
714 			});
715 		}
716 		
717 		assertEquals(8, okResult.size());
718 		assertEquals(0, failResult.size());
719 	}
720 	
721 	/**
722 	 * Group:group=[Klasse:class={operation : [[(parameter:Integer,parameter2:String) -> String ]];operation :
723 	 * [[(parameter:String,parameter2:String) -> String ]];}; ]; .
724 	 * 
725 	 * @throws InterruptedException
726 	 * @throws ExecutionException
727 	 * @throws NoValidTokenStreamException
728 	 * @throws CyclicDependencyException
729 	 * @throws CyclicPartDefinitionException
730 	 */
731 	@Test
732 	public void testTwoOperationWithCorrectOverloading2() throws InterruptedException, ExecutionException,
733 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
734 		final SimpleScannerInput input =
735 				new SimpleScannerInput(
736 						"Group:group=[Klasse:class={operation : [[(parameter:Integer,parameter2:String) -> String ]];"
737 								+ "operation : [[(parameter:String,parameter2:String) -> String ]];}; ];");
738 		final TokenStream output = FilteredTokenStream.create();
739 		final Scanner scanner = ModelDslScanner.create();
740 		scanner.scan(input, output);
741 		final Parser parser = Parser.create(output);
742 		Model model = null;
743 		model = parser.parse();
744 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
745 		
746 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
747 		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
748 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
749 		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
750 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
751 		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
752 		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
753 		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
754 		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
755 		referencer.addDependency(doubleChecks);
756 		cyclicInheritance.addDependency(referencer);
757 		subtypesFillTask.addDependency(cyclicInheritance);
758 		prototypesTask.addDependency(subtypesFillTask);
759 		overloadingCheck.addDependency(prototypesTask);
760 		taskmanager.startAllKnownTasks();
761 		
762 		final Collection<OKTaskResult> okResult = new ArrayList<>();
763 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
764 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
765 		for (final TaskResult current : results) {
766 			current.accept(new TaskResultVisitor() {
767 				
768 				@Override
769 				public void handleOkTaskResult(final OKTaskResult result) {
770 					okResult.add(result);
771 				}
772 				
773 				@Override
774 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
775 					failResult.add(result);
776 				}
777 			});
778 		}
779 		
780 		assertEquals(8, okResult.size());
781 		assertEquals(0, failResult.size());
782 	}
783 	
784 	/**
785 	 * Group:group=[Klasse:class={operation : [[(parameter:Integer,parameter2:String) -> String ]];operation :
786 	 * [[(parameter:Integer,parameter2:String,parameter3:Integer) -> String ]];}; ]; .
787 	 * 
788 	 * @throws InterruptedException
789 	 * @throws ExecutionException
790 	 * @throws NoValidTokenStreamException
791 	 * @throws CyclicDependencyException
792 	 * @throws CyclicPartDefinitionException
793 	 */
794 	@Test
795 	public void testTwoOperationWithCorrectOverloadingDifferentParameterCount() throws InterruptedException,
796 			ExecutionException, NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
797 		final SimpleScannerInput input =
798 				new SimpleScannerInput(
799 						"Group:group=[Klasse:class={operation : [[(parameter:Integer,parameter2:String) -> String ]];"
800 								+ "operation : [[(parameter:Integer,parameter2:String,parameter3:Integer) -> String ]];}; ];");
801 		final TokenStream output = FilteredTokenStream.create();
802 		final Scanner scanner = ModelDslScanner.create();
803 		scanner.scan(input, output);
804 		final Parser parser = Parser.create(output);
805 		Model model = null;
806 		model = parser.parse();
807 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
808 		
809 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
810 		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
811 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
812 		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
813 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
814 		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
815 		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
816 		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
817 		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
818 		referencer.addDependency(doubleChecks);
819 		cyclicInheritance.addDependency(referencer);
820 		subtypesFillTask.addDependency(cyclicInheritance);
821 		prototypesTask.addDependency(subtypesFillTask);
822 		overloadingCheck.addDependency(prototypesTask);
823 		taskmanager.startAllKnownTasks();
824 		
825 		final Collection<OKTaskResult> okResult = new ArrayList<>();
826 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
827 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
828 		for (final TaskResult current : results) {
829 			current.accept(new TaskResultVisitor() {
830 				
831 				@Override
832 				public void handleOkTaskResult(final OKTaskResult result) {
833 					okResult.add(result);
834 				}
835 				
836 				@Override
837 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
838 					failResult.add(result);
839 				}
840 			});
841 		}
842 		
843 		assertEquals(8, okResult.size());
844 		assertEquals(0, failResult.size());
845 	}
846 	
847 	/**
848 	 * Group:group=[Klasse:class={operation : [[(parameter:Integer,parameter2:String) -> String ]];operation :
849 	 * [[(parameter:String,parameter2:String) -> String ]];operation : [[(parameter:Integer,parameter2:Integer) ->
850 	 * String ]];}; ]; .
851 	 * 
852 	 * @throws InterruptedException
853 	 * @throws ExecutionException
854 	 * @throws NoValidTokenStreamException
855 	 * @throws CyclicDependencyException
856 	 * @throws CyclicPartDefinitionException
857 	 */
858 	@Test
859 	public void testThreeOperationWithCorrectOverloading() throws InterruptedException, ExecutionException,
860 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
861 		final SimpleScannerInput input =
862 				new SimpleScannerInput(
863 						"Group:group=[Klasse:class={operation : [[(parameter:Integer,parameter2:String) -> String ]];"
864 								+ "operation : [[(parameter:String,parameter2:String) -> String ]];"
865 								+ "operation : [[(parameter:Integer,parameter2:Integer) -> String ]];}; ];");
866 		final TokenStream output = FilteredTokenStream.create();
867 		final Scanner scanner = ModelDslScanner.create();
868 		scanner.scan(input, output);
869 		final Parser parser = Parser.create(output);
870 		Model model = null;
871 		model = parser.parse();
872 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
873 		
874 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
875 		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
876 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
877 		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
878 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
879 		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
880 		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
881 		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
882 		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
883 		referencer.addDependency(doubleChecks);
884 		cyclicInheritance.addDependency(referencer);
885 		subtypesFillTask.addDependency(cyclicInheritance);
886 		prototypesTask.addDependency(subtypesFillTask);
887 		overloadingCheck.addDependency(prototypesTask);
888 		taskmanager.startAllKnownTasks();
889 		
890 		final Collection<OKTaskResult> okResult = new ArrayList<>();
891 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
892 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
893 		for (final TaskResult current : results) {
894 			current.accept(new TaskResultVisitor() {
895 				
896 				@Override
897 				public void handleOkTaskResult(final OKTaskResult result) {
898 					okResult.add(result);
899 				}
900 				
901 				@Override
902 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
903 					failResult.add(result);
904 				}
905 			});
906 		}
907 		
908 		assertEquals(8, okResult.size());
909 		assertEquals(0, failResult.size());
910 	}
911 	
912 	/**
913 	 * Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]];operation2 : [[(parameter:Integer) ->
914 	 * String ]];}; ]; .
915 	 * 
916 	 * @throws InterruptedException
917 	 * @throws ExecutionException
918 	 * @throws NoValidTokenStreamException
919 	 * @throws CyclicDependencyException
920 	 * @throws CyclicPartDefinitionException
921 	 */
922 	@Test
923 	public void testTwoDifferentOperationNames() throws InterruptedException, ExecutionException,
924 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
925 		final SimpleScannerInput input =
926 				new SimpleScannerInput("Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]];"
927 						+ "operation2 : [[(parameter:Integer) -> String ]];}; ];");
928 		final TokenStream output = FilteredTokenStream.create();
929 		final Scanner scanner = ModelDslScanner.create();
930 		scanner.scan(input, output);
931 		final Parser parser = Parser.create(output);
932 		Model model = null;
933 		model = parser.parse();
934 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
935 		
936 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
937 		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
938 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
939 		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
940 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
941 		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
942 		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
943 		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
944 		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
945 		referencer.addDependency(doubleChecks);
946 		cyclicInheritance.addDependency(referencer);
947 		subtypesFillTask.addDependency(cyclicInheritance);
948 		prototypesTask.addDependency(subtypesFillTask);
949 		overloadingCheck.addDependency(prototypesTask);
950 		taskmanager.startAllKnownTasks();
951 		
952 		final Collection<OKTaskResult> okResult = new ArrayList<>();
953 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
954 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
955 		for (final TaskResult current : results) {
956 			current.accept(new TaskResultVisitor() {
957 				
958 				@Override
959 				public void handleOkTaskResult(final OKTaskResult result) {
960 					okResult.add(result);
961 				}
962 				
963 				@Override
964 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
965 					failResult.add(result);
966 				}
967 			});
968 		}
969 		
970 		assertEquals(8, okResult.size());
971 		assertEquals(0, failResult.size());
972 	}
973 	
974 	/**
975 	 * Group:group=[Klasse:class={operation : [[(parameter:{A}) -> String ]];operation : [[(parameter:{A,B,C}) -> String
976 	 * ]];}; A:class={};B:class=A+{};C:class=A+{};];"); .
977 	 * 
978 	 * @throws InterruptedException
979 	 * @throws ExecutionException
980 	 * @throws NoValidTokenStreamException
981 	 * @throws CyclicDependencyException
982 	 * @throws CyclicPartDefinitionException
983 	 */
984 	@Test
985 	public void testNormallyEqualSumIfStandardized() throws InterruptedException, ExecutionException,
986 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
987 		final SimpleScannerInput input =
988 				new SimpleScannerInput("Group:group=[Klasse:class={operation : [[(parameter:{A}) -> String ]];"
989 						+ "operation : [[(parameter:{A,B,C}) -> String ]];}; A:class={};B:class=A+{};C:class=A+{};];");
990 		final TokenStream output = FilteredTokenStream.create();
991 		final Scanner scanner = ModelDslScanner.create();
992 		scanner.scan(input, output);
993 		final Parser parser = Parser.create(output);
994 		Model model = null;
995 		model = parser.parse();
996 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
997 		
998 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
999 		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
1000 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
1001 		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
1002 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
1003 		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
1004 		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
1005 		referencer.addDependency(doubleGroupcomponent);
1006 		cyclicInheritance.addDependency(referencer);
1007 		subtypesFillTask.addDependency(cyclicInheritance);
1008 		doubleAttributenameCheck.addDependency(cyclicInheritance);
1009 		prototypesTask.addDependency(subtypesFillTask);
1010 		overloadingCheck.addDependency(prototypesTask);
1011 		taskmanager.startAllKnownTasks();
1012 		
1013 		final Collection<OKTaskResult> okResult = new ArrayList<>();
1014 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
1015 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
1016 		for (final TaskResult current : results) {
1017 			current.accept(new TaskResultVisitor() {
1018 				
1019 				@Override
1020 				public void handleOkTaskResult(final OKTaskResult result) {
1021 					okResult.add(result);
1022 				}
1023 				
1024 				@Override
1025 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
1026 					failResult.add(result);
1027 				}
1028 			});
1029 		}
1030 		
1031 		assertEquals(6, okResult.size());
1032 		assertEquals(1, failResult.size());
1033 		
1034 		final Exception exception = failResult.iterator().next().getError();
1035 		if (exception instanceof InvalidOverloadingException) {
1036 			final InvalidOverloadingException ex = (InvalidOverloadingException) exception;
1037 			assertEquals(Position.create("", 1, 71, 70), ex.getStartPosition());
1038 			assertEquals(Position.create("", 1, 118, 117), ex.getEndPos());
1039 		} else {
1040 			fail();
1041 		}
1042 	}
1043 	
1044 	/**
1045 	 * Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]];}; Klasse2:class={operation :
1046 	 * [[(parameter:Integer) -> String ]];};]; .
1047 	 * 
1048 	 * @throws InterruptedException
1049 	 * @throws ExecutionException
1050 	 * @throws NoValidTokenStreamException
1051 	 * @throws CyclicDependencyException
1052 	 * @throws CyclicPartDefinitionException
1053 	 */
1054 	@Test
1055 	public void testTwoEqualOperationsinDifferentClasses() throws InterruptedException, ExecutionException,
1056 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
1057 		final SimpleScannerInput input =
1058 				new SimpleScannerInput("Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]];}; "
1059 						+ "Klasse2:class={operation : [[(parameter:Integer) -> String ]];};];");
1060 		final TokenStream output = FilteredTokenStream.create();
1061 		final Scanner scanner = ModelDslScanner.create();
1062 		scanner.scan(input, output);
1063 		final Parser parser = Parser.create(output);
1064 		Model model = null;
1065 		model = parser.parse();
1066 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
1067 		
1068 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
1069 		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
1070 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
1071 		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
1072 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
1073 		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
1074 		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
1075 		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
1076 		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
1077 		referencer.addDependency(doubleChecks);
1078 		cyclicInheritance.addDependency(referencer);
1079 		subtypesFillTask.addDependency(cyclicInheritance);
1080 		prototypesTask.addDependency(subtypesFillTask);
1081 		overloadingCheck.addDependency(prototypesTask);
1082 		taskmanager.startAllKnownTasks();
1083 		
1084 		final Collection<OKTaskResult> okResult = new ArrayList<>();
1085 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
1086 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
1087 		for (final TaskResult current : results) {
1088 			current.accept(new TaskResultVisitor() {
1089 				
1090 				@Override
1091 				public void handleOkTaskResult(final OKTaskResult result) {
1092 					okResult.add(result);
1093 				}
1094 				
1095 				@Override
1096 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
1097 					failResult.add(result);
1098 				}
1099 			});
1100 		}
1101 		
1102 		assertEquals(8, okResult.size());
1103 		assertEquals(0, failResult.size());
1104 	}
1105 	
1106 	/**
1107 	 * Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]];};];Group2:group=[
1108 	 * Klasse:class={operation : [[(parameter:Integer) -> String ]];};]; .
1109 	 * 
1110 	 * @throws InterruptedException
1111 	 * @throws ExecutionException
1112 	 * @throws NoValidTokenStreamException
1113 	 * @throws CyclicDependencyException
1114 	 * @throws CyclicPartDefinitionException
1115 	 */
1116 	@Test
1117 	public void testTwoEqualKlassesWithEqualOperationInDifferentGroups() throws InterruptedException,
1118 			ExecutionException, NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
1119 		final SimpleScannerInput input =
1120 				new SimpleScannerInput("Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]];};];"
1121 						+ "Group2:group=[ Klasse:class={operation : [[(parameter:Integer) -> String ]];};];");
1122 		final TokenStream output = FilteredTokenStream.create();
1123 		final Scanner scanner = ModelDslScanner.create();
1124 		scanner.scan(input, output);
1125 		final Parser parser = Parser.create(output);
1126 		Model model = null;
1127 		model = parser.parse();
1128 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
1129 		
1130 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
1131 		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
1132 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
1133 		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
1134 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
1135 		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
1136 		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
1137 		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
1138 		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
1139 		referencer.addDependency(doubleChecks);
1140 		cyclicInheritance.addDependency(referencer);
1141 		subtypesFillTask.addDependency(cyclicInheritance);
1142 		prototypesTask.addDependency(subtypesFillTask);
1143 		overloadingCheck.addDependency(prototypesTask);
1144 		taskmanager.startAllKnownTasks();
1145 		
1146 		final Collection<OKTaskResult> okResult = new ArrayList<>();
1147 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
1148 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
1149 		for (final TaskResult current : results) {
1150 			current.accept(new TaskResultVisitor() {
1151 				
1152 				@Override
1153 				public void handleOkTaskResult(final OKTaskResult result) {
1154 					okResult.add(result);
1155 				}
1156 				
1157 				@Override
1158 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
1159 					failResult.add(result);
1160 				}
1161 			});
1162 		}
1163 		
1164 		assertEquals(8, okResult.size());
1165 		assertEquals(0, failResult.size());
1166 	}
1167 	
1168 	/**
1169 	 * Group:group=[Klasse:class={operation : [[(parameter:Klasse) -> String ]];operation : [[(parameter: Group2>Klasse)
1170 	 * -> String ]];}; Group2:group=[ Klasse:class={operation : [[(parameter:Klasse) -> String ]];};];]; .
1171 	 * 
1172 	 * @throws InterruptedException
1173 	 * @throws ExecutionException
1174 	 * @throws NoValidTokenStreamException
1175 	 * @throws CyclicDependencyException
1176 	 * @throws CyclicPartDefinitionException
1177 	 */
1178 	@Test
1179 	public void testTwoOperationsWithDifferentTypeOfTwoGroups() throws InterruptedException, ExecutionException,
1180 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
1181 		final SimpleScannerInput input =
1182 				new SimpleScannerInput("Group:group=[Klasse:class={operation : [[(parameter:Klasse) -> String ]];"
1183 						+ "operation : [[(parameter: Group2>Klasse) -> String ]];}; "
1184 						+ "Group2:group=[ Klasse:class={operation : [[(parameter:Klasse) -> String ]];};];];");
1185 		final TokenStream output = FilteredTokenStream.create();
1186 		final Scanner scanner = ModelDslScanner.create();
1187 		scanner.scan(input, output);
1188 		final Parser parser = Parser.create(output);
1189 		Model model = null;
1190 		model = parser.parse();
1191 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
1192 		
1193 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
1194 		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
1195 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
1196 		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
1197 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
1198 		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
1199 		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
1200 		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
1201 		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
1202 		referencer.addDependency(doubleChecks);
1203 		cyclicInheritance.addDependency(referencer);
1204 		subtypesFillTask.addDependency(cyclicInheritance);
1205 		prototypesTask.addDependency(subtypesFillTask);
1206 		overloadingCheck.addDependency(prototypesTask);
1207 		taskmanager.startAllKnownTasks();
1208 		
1209 		final Collection<OKTaskResult> okResult = new ArrayList<>();
1210 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
1211 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
1212 		for (final TaskResult current : results) {
1213 			current.accept(new TaskResultVisitor() {
1214 				
1215 				@Override
1216 				public void handleOkTaskResult(final OKTaskResult result) {
1217 					okResult.add(result);
1218 				}
1219 				
1220 				@Override
1221 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
1222 					failResult.add(result);
1223 				}
1224 			});
1225 		}
1226 		
1227 		assertEquals(8, okResult.size());
1228 		assertEquals(0, failResult.size());
1229 	}
1230 }