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
37
38 public class TestDoubleAttributenameCheck extends TestCase {
39
40
41
42
43
44
45
46
47
48
49
50
51
52
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
106
107
108
109
110
111
112
113
114
115
116
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
170
171
172
173
174
175
176
177
178
179
180
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
239
240
241
242
243
244
245
246
247
248
249
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
303
304
305
306
307
308
309
310
311
312
313
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
368
369
370
371
372
373
374
375
376
377
378
379
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
434
435
436
437
438
439
440
441
442
443
444
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
499
500
501
502
503
504
505
506
507
508
509
510
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
565
566
567
568
569
570
571
572
573
574
575
576
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 }