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
40
41 public class TestOverloadingCheck extends TestCase {
42
43
44
45
46
47
48
49
50
51
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
116
117
118
119
120
121
122
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
187
188
189
190
191
192
193
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
258
259
260
261
262
263
264
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
330
331
332
333
334
335
336
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
402
403
404
405
406
407
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
472
473
474
475
476
477
478
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
535
536
537
538
539
540
541
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
598
599
600
601
602
603
604
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
661
662
663
664
665
666
667
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
723
724
725
726
727
728
729
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
786
787
788
789
790
791
792
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
849
850
851
852
853
854
855
856
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
914
915
916
917
918
919
920
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
976
977
978
979
980
981
982
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
1046
1047
1048
1049
1050
1051
1052
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
1108
1109
1110
1111
1112
1113
1114
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
1170
1171
1172
1173
1174
1175
1176
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 }