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.DoubleAttributenameException;
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.dsl.scanner.common.Scanner;
26  import de.fhdw.wtf.dsl.scanner.modelScanner.ModelDslScanner;
27  import de.fhdw.wtf.parser.Parser;
28  import de.fhdw.wtf.walker.tasks.BaseTypeInheritanceCheck;
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.TypeReferencer;
33  import de.fhdw.wtf.walker.walker.SimpleWalkerTask;
34  
35  /**
36   * Test {@link DoubleAttributenameCheck}.
37   */
38  public class TestDoubleAttributenameCheck extends TestCase {
39  	
40  	/**
41  	 * Frist 2 tests check when a name contains another name it works.
42  	 * 
43  	 * @throws NoValidTokenStreamException
44  	 *             NoValidTokenStreamException
45  	 * @throws CyclicDependencyException
46  	 *             CyclicDependencyException
47  	 * @throws InterruptedException
48  	 *             InterruptedException
49  	 * @throws ExecutionException
50  	 *             ExecutionException
51  	 * @throws CyclicPartDefinitionException
52  	 *             CyclicPartDefinitionException
53  	 **/
54  	@Test
55  	public void testDoubleAttributename1() throws InterruptedException, ExecutionException,
56  			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
57  		final SimpleScannerInput input =
58  				new SimpleScannerInput("" + "group1:group=[" + "class1:class={" + "attribute: Integer;"
59  						+ "attributeLong: Integer;" + "};" + "];");
60  		final TokenStream output = FilteredTokenStream.create();
61  		final Scanner scanner = ModelDslScanner.create();
62  		scanner.scan(input, output);
63  		final Parser parser = Parser.create(output);
64  		final Model model = parser.parse();
65  		
66  		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
67  		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
68  		final TypeReferencer referencer = TypeReferencer.create(model, taskmanager);
69  		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
70  		final DoubleAttributenameCheck doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
71  		final GroupDependencyTask inheritanceChecker = GroupDependencyTask.create(taskmanager);
72  		final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
73  		
74  		referencer.addDependency(doubleGroupcomponent);
75  		baseTypeInheritanceCheck.addDependency(referencer);
76  		cyclicInheritance.addDependency(referencer);
77  		inheritanceChecker.addMembers(cyclicInheritance, baseTypeInheritanceCheck);
78  		
79  		doubleAttributenameCheck.addDependency(inheritanceChecker);
80  		taskmanager.startAllKnownTasks();
81  		
82  		final Collection<OKTaskResult> okResult = new ArrayList<>();
83  		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
84  		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
85  		for (final TaskResult current : results) {
86  			current.accept(new TaskResultVisitor() {
87  				
88  				@Override
89  				public void handleOkTaskResult(final OKTaskResult result) {
90  					okResult.add(result);
91  				}
92  				
93  				@Override
94  				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
95  					failResult.add(result);
96  				}
97  			});
98  		}
99  		
100 		assertEquals(6, okResult.size());
101 		assertEquals(0, failResult.size());
102 	}
103 	
104 	/**
105 	 * "" + "group1:group=[" + "class1:class={" + "attributelong: Integer;" + "attribute: Integer;" + "};" + "];" .
106 	 * 
107 	 * @throws NoValidTokenStreamException
108 	 *             NoValidTokenStreamException
109 	 * @throws CyclicDependencyException
110 	 *             CyclicDependencyException
111 	 * @throws InterruptedException
112 	 *             InterruptedException
113 	 * @throws ExecutionException
114 	 *             ExecutionException
115 	 * @throws CyclicPartDefinitionException
116 	 *             CyclicPartDefinitionException
117 	 */
118 	@Test
119 	public void testDoubleAttributename2() throws InterruptedException, ExecutionException,
120 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
121 		final SimpleScannerInput input =
122 				new SimpleScannerInput("" + "group1:group=[" + "class1:class={" + "attributelong: Integer;"
123 						+ "attribute: Integer;" + "};" + "];");
124 		final TokenStream output = FilteredTokenStream.create();
125 		final Scanner scanner = ModelDslScanner.create();
126 		scanner.scan(input, output);
127 		final Parser parser = Parser.create(output);
128 		final Model model = parser.parse();
129 		
130 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
131 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
132 		final TypeReferencer referencer = TypeReferencer.create(model, taskmanager);
133 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
134 		final DoubleAttributenameCheck doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
135 		final GroupDependencyTask inheritanceChecker = GroupDependencyTask.create(taskmanager);
136 		final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
137 		
138 		referencer.addDependency(doubleGroupcomponent);
139 		baseTypeInheritanceCheck.addDependency(referencer);
140 		cyclicInheritance.addDependency(referencer);
141 		inheritanceChecker.addMembers(cyclicInheritance, baseTypeInheritanceCheck);
142 		
143 		doubleAttributenameCheck.addDependency(inheritanceChecker);
144 		taskmanager.startAllKnownTasks();
145 		
146 		final Collection<OKTaskResult> okResult = new ArrayList<>();
147 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
148 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
149 		for (final TaskResult current : results) {
150 			current.accept(new TaskResultVisitor() {
151 				
152 				@Override
153 				public void handleOkTaskResult(final OKTaskResult result) {
154 					okResult.add(result);
155 				}
156 				
157 				@Override
158 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
159 					failResult.add(result);
160 				}
161 			});
162 		}
163 		
164 		assertEquals(6, okResult.size());
165 		assertEquals(0, failResult.size());
166 	}
167 	
168 	/**
169 	 * Checks wether you can only use a specific attributename one time per class.
170 	 * 
171 	 * @throws NoValidTokenStreamException
172 	 *             NoValidTokenStreamException
173 	 * @throws CyclicDependencyException
174 	 *             CyclicDependencyException
175 	 * @throws InterruptedException
176 	 *             InterruptedException
177 	 * @throws ExecutionException
178 	 *             ExecutionException
179 	 * @throws CyclicPartDefinitionException
180 	 *             CyclicPartDefinitionException
181 	 */
182 	@Test
183 	public void testDoubleAttributename3() throws InterruptedException, ExecutionException,
184 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
185 		final SimpleScannerInput input =
186 				new SimpleScannerInput("" + "group1:group=[" + "class1:class={" + "attribute: Integer;"
187 						+ "attribute: Integer;" + "};" + "];");
188 		final TokenStream output = FilteredTokenStream.create();
189 		final Scanner scanner = ModelDslScanner.create();
190 		scanner.scan(input, output);
191 		final Parser parser = Parser.create(output);
192 		final Model model = parser.parse();
193 		
194 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
195 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
196 		final TypeReferencer referencer = TypeReferencer.create(model, taskmanager);
197 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
198 		final DoubleAttributenameCheck doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
199 		final GroupDependencyTask inheritanceChecker = GroupDependencyTask.create(taskmanager);
200 		final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
201 		
202 		referencer.addDependency(doubleGroupcomponent);
203 		cyclicInheritance.addDependency(referencer);
204 		baseTypeInheritanceCheck.addDependency(referencer);
205 		inheritanceChecker.addMembers(cyclicInheritance, baseTypeInheritanceCheck);
206 		
207 		doubleAttributenameCheck.addDependency(inheritanceChecker);
208 		taskmanager.startAllKnownTasks();
209 		
210 		final Collection<OKTaskResult> okResult = new ArrayList<>();
211 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
212 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
213 		for (final TaskResult current : results) {
214 			current.accept(new TaskResultVisitor() {
215 				
216 				@Override
217 				public void handleOkTaskResult(final OKTaskResult result) {
218 					okResult.add(result);
219 				}
220 				
221 				@Override
222 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
223 					failResult.add(result);
224 				}
225 			});
226 		}
227 		
228 		assertEquals(5, okResult.size());
229 		assertEquals(1, failResult.size());
230 		
231 		final ExceptionalTaskResult exceptionalTaskResult = failResult.iterator().next();
232 		if (!(exceptionalTaskResult.getError() instanceof DoubleAttributenameException)) {
233 			fail();
234 		}
235 	}
236 	
237 	/**
238 	 * Checks wether you can use a specific attribute name in each class.
239 	 * 
240 	 * @throws NoValidTokenStreamException
241 	 *             NoValidTokenStreamException
242 	 * @throws CyclicDependencyException
243 	 *             CyclicDependencyException
244 	 * @throws InterruptedException
245 	 *             InterruptedException
246 	 * @throws ExecutionException
247 	 *             ExecutionException
248 	 * @throws CyclicPartDefinitionException
249 	 *             CyclicPartDefinitionException
250 	 */
251 	@Test
252 	public void testDoubleAttributename4() throws InterruptedException, ExecutionException,
253 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
254 		final SimpleScannerInput input =
255 				new SimpleScannerInput("" + "group1:group=[" + "class1:class={" + "attribute: Integer;" + "};"
256 						+ "class2:class={" + "attribute: Integer;" + "};" + "];");
257 		final TokenStream output = FilteredTokenStream.create();
258 		final Scanner scanner = ModelDslScanner.create();
259 		scanner.scan(input, output);
260 		final Parser parser = Parser.create(output);
261 		final Model model = parser.parse();
262 		
263 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
264 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
265 		final TypeReferencer referencer = TypeReferencer.create(model, taskmanager);
266 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
267 		final DoubleAttributenameCheck doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
268 		final GroupDependencyTask inheritanceChecker = GroupDependencyTask.create(taskmanager);
269 		final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
270 		
271 		referencer.addDependency(doubleGroupcomponent);
272 		cyclicInheritance.addDependency(referencer);
273 		baseTypeInheritanceCheck.addDependency(referencer);
274 		inheritanceChecker.addMembers(cyclicInheritance, baseTypeInheritanceCheck);
275 		
276 		doubleAttributenameCheck.addDependency(inheritanceChecker);
277 		taskmanager.startAllKnownTasks();
278 		
279 		final Collection<OKTaskResult> okResult = new ArrayList<>();
280 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
281 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
282 		for (final TaskResult current : results) {
283 			current.accept(new TaskResultVisitor() {
284 				
285 				@Override
286 				public void handleOkTaskResult(final OKTaskResult result) {
287 					okResult.add(result);
288 				}
289 				
290 				@Override
291 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
292 					failResult.add(result);
293 				}
294 			});
295 		}
296 		
297 		assertEquals(6, okResult.size());
298 		assertEquals(0, failResult.size());
299 	}
300 	
301 	/**
302 	 * group1:group=[class1:class=class2+{attribute: Integer;};class2:class={attribute: Integer;};]; .
303 	 * 
304 	 * @throws NoValidTokenStreamException
305 	 *             NoValidTokenStreamException
306 	 * @throws CyclicDependencyException
307 	 *             CyclicDependencyException
308 	 * @throws InterruptedException
309 	 *             InterruptedException
310 	 * @throws ExecutionException
311 	 *             ExecutionException
312 	 * @throws CyclicPartDefinitionException
313 	 *             CyclicPartDefinitionException
314 	 */
315 	@Test
316 	public void testDoubleAttributenameInInheritance1() throws InterruptedException, ExecutionException,
317 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
318 		final SimpleScannerInput input =
319 				new SimpleScannerInput("group1:group=[class1:class=class2+{attribute: Integer;};"
320 						+ "class2:class={attribute: Integer;};];");
321 		final TokenStream output = FilteredTokenStream.create();
322 		final Scanner scanner = ModelDslScanner.create();
323 		scanner.scan(input, output);
324 		final Parser parser = Parser.create(output);
325 		final Model model = parser.parse();
326 		
327 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
328 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
329 		final TypeReferencer referencer = TypeReferencer.create(model, taskmanager);
330 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
331 		final DoubleAttributenameCheck doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
332 		final GroupDependencyTask inheritanceChecker = GroupDependencyTask.create(taskmanager);
333 		final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
334 		
335 		referencer.addDependency(doubleGroupcomponent);
336 		baseTypeInheritanceCheck.addDependency(referencer);
337 		cyclicInheritance.addDependency(referencer);
338 		inheritanceChecker.addMembers(cyclicInheritance, baseTypeInheritanceCheck);
339 		
340 		doubleAttributenameCheck.addDependency(inheritanceChecker);
341 		taskmanager.startAllKnownTasks();
342 		
343 		final Collection<OKTaskResult> okResult = new ArrayList<>();
344 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
345 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
346 		for (final TaskResult current : results) {
347 			current.accept(new TaskResultVisitor() {
348 				
349 				@Override
350 				public void handleOkTaskResult(final OKTaskResult result) {
351 					okResult.add(result);
352 				}
353 				
354 				@Override
355 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
356 					failResult.add(result);
357 				}
358 			});
359 		}
360 		
361 		assertEquals(6, okResult.size());
362 		assertEquals(0, failResult.size());
363 		
364 	}
365 	
366 	/**
367 	 * group1:group=[class1:class=class2+class3{attribute: Integer;}; class2:class={attribute2: Integer;};
368 	 * class3:class={attribute: Integer;};]; .
369 	 * 
370 	 * @throws NoValidTokenStreamException
371 	 *             NoValidTokenStreamException
372 	 * @throws CyclicDependencyException
373 	 *             CyclicDependencyException
374 	 * @throws InterruptedException
375 	 *             InterruptedException
376 	 * @throws ExecutionException
377 	 *             ExecutionException
378 	 * @throws CyclicPartDefinitionException
379 	 *             CyclicPartDefinitionException
380 	 */
381 	@Test
382 	public void testDoubleAttributenameInInheritance2() throws InterruptedException, ExecutionException,
383 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
384 		final SimpleScannerInput input =
385 				new SimpleScannerInput("group1:group=[class1:class=class2+class3+{attribute: Integer;};"
386 						+ "class2:class={attribute2: Integer;}; class3:class={attribute: Integer;};];");
387 		final TokenStream output = FilteredTokenStream.create();
388 		final Scanner scanner = ModelDslScanner.create();
389 		scanner.scan(input, output);
390 		final Parser parser = Parser.create(output);
391 		final Model model = parser.parse();
392 		
393 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
394 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
395 		final TypeReferencer referencer = TypeReferencer.create(model, taskmanager);
396 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
397 		final DoubleAttributenameCheck doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
398 		final GroupDependencyTask inheritanceChecker = GroupDependencyTask.create(taskmanager);
399 		final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
400 		
401 		referencer.addDependency(doubleGroupcomponent);
402 		cyclicInheritance.addDependency(referencer);
403 		baseTypeInheritanceCheck.addDependency(referencer);
404 		inheritanceChecker.addMembers(cyclicInheritance, baseTypeInheritanceCheck);
405 		
406 		doubleAttributenameCheck.addDependency(inheritanceChecker);
407 		taskmanager.startAllKnownTasks();
408 		
409 		final Collection<OKTaskResult> okResult = new ArrayList<>();
410 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
411 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
412 		for (final TaskResult current : results) {
413 			current.accept(new TaskResultVisitor() {
414 				
415 				@Override
416 				public void handleOkTaskResult(final OKTaskResult result) {
417 					okResult.add(result);
418 				}
419 				
420 				@Override
421 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
422 					failResult.add(result);
423 				}
424 			});
425 		}
426 		
427 		assertEquals(6, okResult.size());
428 		assertEquals(0, failResult.size());
429 		
430 	}
431 	
432 	/**
433 	 * group1:group=[class1:class=class2+{attribute: Integer;};class2:class={attribute2: Integer;};]; .
434 	 * 
435 	 * @throws NoValidTokenStreamException
436 	 *             NoValidTokenStreamException
437 	 * @throws CyclicDependencyException
438 	 *             CyclicDependencyException
439 	 * @throws InterruptedException
440 	 *             InterruptedException
441 	 * @throws ExecutionException
442 	 *             ExecutionException
443 	 * @throws CyclicPartDefinitionException
444 	 *             CyclicPartDefinitionException
445 	 * 
446 	 */
447 	@Test
448 	public void testDoubleAttributenameInInheritance3() throws InterruptedException, ExecutionException,
449 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
450 		final SimpleScannerInput input =
451 				new SimpleScannerInput("group1:group=[class1:class=class2+{attribute: Integer;};"
452 						+ "class2:class={attribute2: Integer;};];");
453 		final TokenStream output = FilteredTokenStream.create();
454 		final Scanner scanner = ModelDslScanner.create();
455 		scanner.scan(input, output);
456 		final Parser parser = Parser.create(output);
457 		final Model model = parser.parse();
458 		
459 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
460 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
461 		final TypeReferencer referencer = TypeReferencer.create(model, taskmanager);
462 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
463 		final DoubleAttributenameCheck doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
464 		final GroupDependencyTask inheritanceChecker = GroupDependencyTask.create(taskmanager);
465 		final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
466 		
467 		referencer.addDependency(doubleGroupcomponent);
468 		cyclicInheritance.addDependency(referencer);
469 		baseTypeInheritanceCheck.addDependency(referencer);
470 		inheritanceChecker.addMembers(cyclicInheritance, baseTypeInheritanceCheck);
471 		
472 		doubleAttributenameCheck.addDependency(inheritanceChecker);
473 		taskmanager.startAllKnownTasks();
474 		
475 		final Collection<OKTaskResult> okResult = new ArrayList<>();
476 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
477 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
478 		for (final TaskResult current : results) {
479 			current.accept(new TaskResultVisitor() {
480 				
481 				@Override
482 				public void handleOkTaskResult(final OKTaskResult result) {
483 					okResult.add(result);
484 				}
485 				
486 				@Override
487 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
488 					failResult.add(result);
489 				}
490 			});
491 		}
492 		
493 		assertEquals(6, okResult.size());
494 		assertEquals(0, failResult.size());
495 	}
496 	
497 	/**
498 	 * group1:group=[class1:class=class2+{attribute: Integer;}; class2:class=class3+{attribute2: Integer;};
499 	 * class3:class={attribute: Integer;};]; .
500 	 * 
501 	 * @throws NoValidTokenStreamException
502 	 *             NoValidTokenStreamException
503 	 * @throws CyclicDependencyException
504 	 *             CyclicDependencyException
505 	 * @throws InterruptedException
506 	 *             InterruptedException
507 	 * @throws ExecutionException
508 	 *             ExecutionException
509 	 * @throws CyclicPartDefinitionException
510 	 *             CyclicPartDefinitionException
511 	 */
512 	@Test
513 	public void testDoubleAttributenameInInheritance4() throws InterruptedException, ExecutionException,
514 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
515 		final SimpleScannerInput input =
516 				new SimpleScannerInput("group1:group=[class1:class=class2+{attribute: Integer;};"
517 						+ "class2:class=class3+{attribute2: Integer;}; class3:class={attribute: Integer;};];");
518 		final TokenStream output = FilteredTokenStream.create();
519 		final Scanner scanner = ModelDslScanner.create();
520 		scanner.scan(input, output);
521 		final Parser parser = Parser.create(output);
522 		final Model model = parser.parse();
523 		
524 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
525 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
526 		final TypeReferencer referencer = TypeReferencer.create(model, taskmanager);
527 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
528 		final DoubleAttributenameCheck doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
529 		final GroupDependencyTask inheritanceChecker = GroupDependencyTask.create(taskmanager);
530 		final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
531 		
532 		referencer.addDependency(doubleGroupcomponent);
533 		cyclicInheritance.addDependency(referencer);
534 		baseTypeInheritanceCheck.addDependency(referencer);
535 		inheritanceChecker.addMembers(cyclicInheritance, baseTypeInheritanceCheck);
536 		
537 		doubleAttributenameCheck.addDependency(inheritanceChecker);
538 		taskmanager.startAllKnownTasks();
539 		
540 		final Collection<OKTaskResult> okResult = new ArrayList<>();
541 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
542 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
543 		for (final TaskResult current : results) {
544 			current.accept(new TaskResultVisitor() {
545 				
546 				@Override
547 				public void handleOkTaskResult(final OKTaskResult result) {
548 					okResult.add(result);
549 				}
550 				
551 				@Override
552 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
553 					failResult.add(result);
554 				}
555 			});
556 		}
557 		
558 		assertEquals(6, okResult.size());
559 		assertEquals(0, failResult.size());
560 		
561 	}
562 	
563 	/**
564 	 * group1:group=[class1:class=class2+class3{attribute: Integer;}; class2:class={attribute2: Integer;};
565 	 * class3:class={attribute2: Integer;};]; .
566 	 * 
567 	 * @throws NoValidTokenStreamException
568 	 *             NoValidTokenStreamException
569 	 * @throws CyclicDependencyException
570 	 *             CyclicDependencyException
571 	 * @throws InterruptedException
572 	 *             InterruptedException
573 	 * @throws ExecutionException
574 	 *             ExecutionException
575 	 * @throws CyclicPartDefinitionException
576 	 *             CyclicPartDefinitionException
577 	 */
578 	@Test
579 	public void testDoubleAttributenameInInheritance5() throws InterruptedException, ExecutionException,
580 			NoValidTokenStreamException, CyclicDependencyException, CyclicPartDefinitionException {
581 		final SimpleScannerInput input =
582 				new SimpleScannerInput("group1:group=[class1:class=class2+class3+{attribute: Integer;};"
583 						+ "class2:class={attribute2: Integer;}; class3:class={attribute2: Integer;};];");
584 		final TokenStream output = FilteredTokenStream.create();
585 		final Scanner scanner = ModelDslScanner.create();
586 		scanner.scan(input, output);
587 		final Parser parser = Parser.create(output);
588 		final Model model = parser.parse();
589 		
590 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
591 		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
592 		final TypeReferencer referencer = TypeReferencer.create(model, taskmanager);
593 		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
594 		final DoubleAttributenameCheck doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
595 		final GroupDependencyTask inheritanceChecker = GroupDependencyTask.create(taskmanager);
596 		final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
597 		
598 		referencer.addDependency(doubleGroupcomponent);
599 		cyclicInheritance.addDependency(referencer);
600 		baseTypeInheritanceCheck.addDependency(referencer);
601 		inheritanceChecker.addMembers(cyclicInheritance, baseTypeInheritanceCheck);
602 		
603 		doubleAttributenameCheck.addDependency(inheritanceChecker);
604 		taskmanager.startAllKnownTasks();
605 		
606 		final Collection<OKTaskResult> okResult = new ArrayList<>();
607 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
608 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
609 		for (final TaskResult current : results) {
610 			current.accept(new TaskResultVisitor() {
611 				
612 				@Override
613 				public void handleOkTaskResult(final OKTaskResult result) {
614 					okResult.add(result);
615 				}
616 				
617 				@Override
618 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
619 					failResult.add(result);
620 				}
621 			});
622 		}
623 		
624 		assertEquals(6, okResult.size());
625 		assertEquals(0, failResult.size());
626 		
627 	}
628 }