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.AbstractOperationsException;
14  import de.fhdw.wtf.common.exception.walker.CyclicDependencyException;
15  import de.fhdw.wtf.common.stream.FilteredTokenStream;
16  import de.fhdw.wtf.common.stream.SimpleScannerInput;
17  import de.fhdw.wtf.common.stream.TokenStream;
18  import de.fhdw.wtf.common.task.TaskExecutorFixed;
19  import de.fhdw.wtf.common.task.result.ExceptionalTaskResult;
20  import de.fhdw.wtf.common.task.result.OKTaskResult;
21  import de.fhdw.wtf.common.task.result.TaskResult;
22  import de.fhdw.wtf.common.task.result.visitor.TaskResultVisitor;
23  import de.fhdw.wtf.common.token.Position;
24  import de.fhdw.wtf.dsl.scanner.common.Scanner;
25  import de.fhdw.wtf.dsl.scanner.modelScanner.ModelDslScanner;
26  import de.fhdw.wtf.parser.Parser;
27  import de.fhdw.wtf.walker.tasks.AbstractOperationsCheck;
28  
29  /**
30   * Tests the {@link AbstractOperationsCheck}.
31   */
32  public class TestAbstractOperationsCheck extends TestCase {
33  	
34  	/**
35  	 * Group:group=[Klasse:class={name : String; operation : [[(parameter:Integer) -> String ]] abstract;}; ]; .
36  	 * 
37  	 * @throws InterruptedException
38  	 * @throws ExecutionException
39  	 * @throws NoValidTokenStreamException
40  	 * @throws CyclicDependencyException
41  	 */
42  	@Test
43  	public void testAbstractOperationInNotAbstractClass() throws InterruptedException, ExecutionException,
44  			NoValidTokenStreamException, CyclicDependencyException {
45  		final SimpleScannerInput input =
46  				new SimpleScannerInput(
47  						"Group:group=[Klasse:class={name : String; operation : [[(parameter:Integer) -> String ]] abstract;}; ];");
48  		final TokenStream output = FilteredTokenStream.create();
49  		final Scanner scanner = ModelDslScanner.create();
50  		scanner.scan(input, output);
51  		final Parser parser = Parser.create(output);
52  		Model model = null;
53  		model = parser.parse();
54  		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
55  		AbstractOperationsCheck.create(model, taskmanager);
56  		taskmanager.startAllKnownTasks();
57  		
58  		final Collection<OKTaskResult> okResult = new ArrayList<>();
59  		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
60  		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
61  		for (final TaskResult current : results) {
62  			current.accept(new TaskResultVisitor() {
63  				
64  				@Override
65  				public void handleOkTaskResult(final OKTaskResult result) {
66  					okResult.add(result);
67  				}
68  				
69  				@Override
70  				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
71  					failResult.add(result);
72  				}
73  			});
74  		}
75  		
76  		assertEquals(0, okResult.size());
77  		assertEquals(1, failResult.size());
78  		
79  		final Exception exception = failResult.iterator().next().getError();
80  		if (exception instanceof AbstractOperationsException) {
81  			final AbstractOperationsException ex = (AbstractOperationsException) exception;
82  			assertEquals(Position.create("", 1, 43, 42), ex.getStartPosition());
83  			assertEquals(Position.create("", 1, 99, 98), ex.getEndPos());
84  		} else {
85  			fail();
86  		}
87  	}
88  	
89  	/**
90  	 * Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]] abstract;}abstract;
91  	 * ];Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]] abstract;}; ]; .
92  	 * 
93  	 * @throws InterruptedException
94  	 * @throws ExecutionException
95  	 * @throws NoValidTokenStreamException
96  	 * @throws CyclicDependencyException
97  	 */
98  	@Test
99  	public void testAbstractOperationInNotAbstractClass2() throws InterruptedException, ExecutionException,
100 			NoValidTokenStreamException, CyclicDependencyException {
101 		final SimpleScannerInput input =
102 				new SimpleScannerInput(
103 						"Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]] abstract;}abstract; ];Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]] abstract;}; ];");
104 		final TokenStream output = FilteredTokenStream.create();
105 		final Scanner scanner = ModelDslScanner.create();
106 		scanner.scan(input, output);
107 		final Parser parser = Parser.create(output);
108 		Model model = null;
109 		model = parser.parse();
110 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
111 		AbstractOperationsCheck.create(model, taskmanager);
112 		taskmanager.startAllKnownTasks();
113 		
114 		final Collection<OKTaskResult> okResult = new ArrayList<>();
115 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
116 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
117 		for (final TaskResult current : results) {
118 			current.accept(new TaskResultVisitor() {
119 				
120 				@Override
121 				public void handleOkTaskResult(final OKTaskResult result) {
122 					okResult.add(result);
123 				}
124 				
125 				@Override
126 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
127 					failResult.add(result);
128 				}
129 			});
130 		}
131 		
132 		assertEquals(0, okResult.size());
133 		assertEquals(1, failResult.size());
134 		
135 		final Exception exception = failResult.iterator().next().getError();
136 		if (exception instanceof AbstractOperationsException) {
137 			final AbstractOperationsException ex = (AbstractOperationsException) exception;
138 			assertEquals(Position.create("", 1, 124, 123), ex.getStartPosition());
139 			assertEquals(Position.create("", 1, 180, 179), ex.getEndPos());
140 		} else {
141 			fail();
142 		}
143 	}
144 	
145 	/**
146 	 * Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]] abstract;}; Klasse2:class={operation :
147 	 * [[(parameter:Integer) -> String ]] abstract;}abstract;]; .
148 	 * 
149 	 * @throws InterruptedException
150 	 * @throws ExecutionException
151 	 * @throws NoValidTokenStreamException
152 	 * @throws CyclicDependencyException
153 	 */
154 	@Test
155 	public void testAbstractOperationInNotAbstractClass3() throws InterruptedException, ExecutionException,
156 			NoValidTokenStreamException, CyclicDependencyException {
157 		final SimpleScannerInput input =
158 				new SimpleScannerInput(
159 						"Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]] abstract;}; Klasse2:class={operation : [[(parameter:Integer) -> String ]] abstract;}abstract;];");
160 		final TokenStream output = FilteredTokenStream.create();
161 		final Scanner scanner = ModelDslScanner.create();
162 		scanner.scan(input, output);
163 		final Parser parser = Parser.create(output);
164 		Model model = null;
165 		model = parser.parse();
166 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
167 		AbstractOperationsCheck.create(model, taskmanager);
168 		taskmanager.startAllKnownTasks();
169 		
170 		final Collection<OKTaskResult> okResult = new ArrayList<>();
171 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
172 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
173 		for (final TaskResult current : results) {
174 			current.accept(new TaskResultVisitor() {
175 				
176 				@Override
177 				public void handleOkTaskResult(final OKTaskResult result) {
178 					okResult.add(result);
179 				}
180 				
181 				@Override
182 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
183 					failResult.add(result);
184 				}
185 			});
186 		}
187 		
188 		assertEquals(0, okResult.size());
189 		assertEquals(1, failResult.size());
190 		
191 		final Exception exception = failResult.iterator().next().getError();
192 		if (exception instanceof AbstractOperationsException) {
193 			final AbstractOperationsException ex = (AbstractOperationsException) exception;
194 			assertEquals(Position.create("", 1, 28, 27), ex.getStartPosition());
195 			assertEquals(Position.create("", 1, 84, 83), ex.getEndPos());
196 		} else {
197 			fail();
198 		}
199 	}
200 	
201 	/**
202 	 * Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]] ;}; Klasse2:class={operation :
203 	 * [[(parameter:Integer) -> String ]] abstract;};]; .
204 	 * 
205 	 * @throws InterruptedException
206 	 * @throws ExecutionException
207 	 * @throws NoValidTokenStreamException
208 	 * @throws CyclicDependencyException
209 	 */
210 	@Test
211 	public void testAbstractOperationInNotAbstractClass4() throws InterruptedException, ExecutionException,
212 			NoValidTokenStreamException, CyclicDependencyException {
213 		final SimpleScannerInput input =
214 				new SimpleScannerInput(
215 						"Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]] ;}; Klasse2:class={operation : [[(parameter:Integer) -> String ]] abstract;};];");
216 		final TokenStream output = FilteredTokenStream.create();
217 		final Scanner scanner = ModelDslScanner.create();
218 		scanner.scan(input, output);
219 		final Parser parser = Parser.create(output);
220 		Model model = null;
221 		model = parser.parse();
222 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
223 		AbstractOperationsCheck.create(model, taskmanager);
224 		taskmanager.startAllKnownTasks();
225 		
226 		final Collection<OKTaskResult> okResult = new ArrayList<>();
227 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
228 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
229 		for (final TaskResult current : results) {
230 			current.accept(new TaskResultVisitor() {
231 				
232 				@Override
233 				public void handleOkTaskResult(final OKTaskResult result) {
234 					okResult.add(result);
235 				}
236 				
237 				@Override
238 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
239 					failResult.add(result);
240 				}
241 			});
242 		}
243 		
244 		assertEquals(0, okResult.size());
245 		assertEquals(1, failResult.size());
246 		
247 		final Exception exception = failResult.iterator().next().getError();
248 		if (exception instanceof AbstractOperationsException) {
249 			final AbstractOperationsException ex = (AbstractOperationsException) exception;
250 			assertEquals(Position.create("", 1, 94, 93), ex.getStartPosition());
251 			assertEquals(Position.create("", 1, 150, 149), ex.getEndPos());
252 		} else {
253 			fail();
254 		}
255 	}
256 	
257 	/**
258 	 * Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]];operation2 :[[(parameter:Integer) ->
259 	 * String ]] abstract;}; ]; .
260 	 * 
261 	 * @throws InterruptedException
262 	 * @throws ExecutionException
263 	 * @throws NoValidTokenStreamException
264 	 * @throws CyclicDependencyException
265 	 */
266 	@Test
267 	public void testAbstractOperationInNotAbstractClass5() throws InterruptedException, ExecutionException,
268 			NoValidTokenStreamException, CyclicDependencyException {
269 		final SimpleScannerInput input =
270 				new SimpleScannerInput(
271 						"Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]];operation2 :[[(parameter:Integer) -> String ]] abstract;}; ];");
272 		final TokenStream output = FilteredTokenStream.create();
273 		final Scanner scanner = ModelDslScanner.create();
274 		scanner.scan(input, output);
275 		final Parser parser = Parser.create(output);
276 		Model model = null;
277 		model = parser.parse();
278 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
279 		AbstractOperationsCheck.create(model, taskmanager);
280 		taskmanager.startAllKnownTasks();
281 		
282 		final Collection<OKTaskResult> okResult = new ArrayList<>();
283 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
284 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
285 		for (final TaskResult current : results) {
286 			current.accept(new TaskResultVisitor() {
287 				
288 				@Override
289 				public void handleOkTaskResult(final OKTaskResult result) {
290 					okResult.add(result);
291 				}
292 				
293 				@Override
294 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
295 					failResult.add(result);
296 				}
297 			});
298 		}
299 		
300 		assertEquals(0, okResult.size());
301 		assertEquals(1, failResult.size());
302 		
303 		final Exception exception = failResult.iterator().next().getError();
304 		if (exception instanceof AbstractOperationsException) {
305 			final AbstractOperationsException ex = (AbstractOperationsException) exception;
306 			assertEquals(Position.create("", 1, 75, 74), ex.getStartPosition());
307 			assertEquals(Position.create("", 1, 131, 130), ex.getEndPos());
308 		} else {
309 			fail();
310 		}
311 	}
312 	
313 	/**
314 	 * Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]] abstract;operation2 :
315 	 * [[(parameter:Integer) -> String ]] abstract;}; ]; .
316 	 * 
317 	 * @throws InterruptedException
318 	 * @throws ExecutionException
319 	 * @throws NoValidTokenStreamException
320 	 * @throws CyclicDependencyException
321 	 */
322 	@Test
323 	public void testAbstractOperationInNotAbstractClass6() throws InterruptedException, ExecutionException,
324 			NoValidTokenStreamException, CyclicDependencyException {
325 		final SimpleScannerInput input =
326 				new SimpleScannerInput(
327 						"Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]] abstract;operation2 : [[(parameter:Integer) -> String ]] abstract;}; ];");
328 		final TokenStream output = FilteredTokenStream.create();
329 		final Scanner scanner = ModelDslScanner.create();
330 		scanner.scan(input, output);
331 		final Parser parser = Parser.create(output);
332 		Model model = null;
333 		model = parser.parse();
334 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
335 		AbstractOperationsCheck.create(model, taskmanager);
336 		taskmanager.startAllKnownTasks();
337 		
338 		final Collection<OKTaskResult> okResult = new ArrayList<>();
339 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
340 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
341 		for (final TaskResult current : results) {
342 			current.accept(new TaskResultVisitor() {
343 				
344 				@Override
345 				public void handleOkTaskResult(final OKTaskResult result) {
346 					okResult.add(result);
347 				}
348 				
349 				@Override
350 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
351 					failResult.add(result);
352 				}
353 			});
354 		}
355 		
356 		assertEquals(0, okResult.size());
357 		assertEquals(1, failResult.size());
358 		
359 		final Exception exception = failResult.iterator().next().getError();
360 		if (exception instanceof AbstractOperationsException) {
361 			final AbstractOperationsException ex = (AbstractOperationsException) exception;
362 			assertEquals(Position.create("", 1, 28, 27), ex.getStartPosition());
363 			assertEquals(Position.create("", 1, 84, 83), ex.getEndPos());
364 		} else {
365 			fail();
366 		}
367 	}
368 	
369 	/**
370 	 * Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]] abstract;} abstract;
371 	 * Klasse2:class={operation : [[(parameter:Integer) -> String ]] abstract;};]; .
372 	 * 
373 	 * @throws InterruptedException
374 	 * @throws ExecutionException
375 	 * @throws NoValidTokenStreamException
376 	 * @throws CyclicDependencyException
377 	 */
378 	@Test
379 	public void testAbstractOperationInNotAbstractClass7() throws InterruptedException, ExecutionException,
380 			NoValidTokenStreamException, CyclicDependencyException {
381 		final SimpleScannerInput input =
382 				new SimpleScannerInput(
383 						"Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]] abstract;} abstract; Klasse2:class={operation : [[(parameter:Integer) -> String ]] abstract;};];");
384 		final TokenStream output = FilteredTokenStream.create();
385 		final Scanner scanner = ModelDslScanner.create();
386 		scanner.scan(input, output);
387 		final Parser parser = Parser.create(output);
388 		Model model = null;
389 		model = parser.parse();
390 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
391 		AbstractOperationsCheck.create(model, taskmanager);
392 		taskmanager.startAllKnownTasks();
393 		
394 		final Collection<OKTaskResult> okResult = new ArrayList<>();
395 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
396 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
397 		for (final TaskResult current : results) {
398 			current.accept(new TaskResultVisitor() {
399 				
400 				@Override
401 				public void handleOkTaskResult(final OKTaskResult result) {
402 					okResult.add(result);
403 				}
404 				
405 				@Override
406 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
407 					failResult.add(result);
408 				}
409 			});
410 		}
411 		
412 		assertEquals(0, okResult.size());
413 		assertEquals(1, failResult.size());
414 		
415 		final Exception exception = failResult.iterator().next().getError();
416 		if (exception instanceof AbstractOperationsException) {
417 			final AbstractOperationsException ex = (AbstractOperationsException) exception;
418 			assertEquals(Position.create("", 1, 111, 110), ex.getStartPosition());
419 			assertEquals(Position.create("", 1, 167, 166), ex.getEndPos());
420 		} else {
421 			fail();
422 		}
423 	}
424 	
425 	/**
426 	 * Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]] abstract;} abstract; ]; .
427 	 * 
428 	 * @throws InterruptedException
429 	 * @throws ExecutionException
430 	 * @throws NoValidTokenStreamException
431 	 * @throws CyclicDependencyException
432 	 */
433 	@Test
434 	public void testAbstractOperationInAbstractClass() throws InterruptedException, ExecutionException,
435 			NoValidTokenStreamException, CyclicDependencyException {
436 		final SimpleScannerInput input =
437 				new SimpleScannerInput(
438 						"Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]] abstract;} abstract; ];");
439 		final TokenStream output = FilteredTokenStream.create();
440 		final Scanner scanner = ModelDslScanner.create();
441 		scanner.scan(input, output);
442 		final Parser parser = Parser.create(output);
443 		final Model model = parser.parse();
444 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
445 		AbstractOperationsCheck.create(model, taskmanager);
446 		taskmanager.startAllKnownTasks();
447 		
448 		final Collection<OKTaskResult> okResult = new ArrayList<>();
449 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
450 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
451 		for (final TaskResult current : results) {
452 			current.accept(new TaskResultVisitor() {
453 				
454 				@Override
455 				public void handleOkTaskResult(final OKTaskResult result) {
456 					okResult.add(result);
457 				}
458 				
459 				@Override
460 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
461 					failResult.add(result);
462 				}
463 			});
464 		}
465 		
466 		assertEquals(1, okResult.size());
467 		assertEquals(0, failResult.size());
468 	}
469 	
470 	/**
471 	 * Group:group=[Klasse:class={name : String;operation : [[(parameter:Integer) -> String ]] ;operation2 :
472 	 * [[(parameter:Integer) -> String ]] abstract;} abstract; ]; .
473 	 * 
474 	 * @throws InterruptedException
475 	 * @throws ExecutionException
476 	 * @throws NoValidTokenStreamException
477 	 * @throws CyclicDependencyException
478 	 */
479 	@Test
480 	public void testAbstractOperationInAbstractClass1() throws InterruptedException, ExecutionException,
481 			NoValidTokenStreamException, CyclicDependencyException {
482 		final SimpleScannerInput input =
483 				new SimpleScannerInput(
484 						"Group:group=[Klasse:class={name : String;operation : [[(parameter:Integer) -> String ]] ;operation2 : [[(parameter:Integer) -> String ]] abstract;} abstract; ];");
485 		final TokenStream output = FilteredTokenStream.create();
486 		final Scanner scanner = ModelDslScanner.create();
487 		scanner.scan(input, output);
488 		final Parser parser = Parser.create(output);
489 		Model model = null;
490 		model = parser.parse();
491 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
492 		AbstractOperationsCheck.create(model, taskmanager);
493 		taskmanager.startAllKnownTasks();
494 		
495 		final Collection<OKTaskResult> okResult = new ArrayList<>();
496 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
497 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
498 		for (final TaskResult current : results) {
499 			current.accept(new TaskResultVisitor() {
500 				
501 				@Override
502 				public void handleOkTaskResult(final OKTaskResult result) {
503 					okResult.add(result);
504 				}
505 				
506 				@Override
507 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
508 					failResult.add(result);
509 				}
510 			});
511 		}
512 		
513 		assertEquals(1, okResult.size());
514 		assertEquals(0, failResult.size());
515 	}
516 	
517 	/**
518 	 * Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]] ;operation2 : [[(parameter:Integer) ->
519 	 * String ]] ;} ; Klasse2:class={operation : [[(parameter:Integer) -> String ]] ;operation2 : [[(parameter:Integer)
520 	 * -> String ]] abstract;} abstract; ]; .
521 	 * 
522 	 * @throws InterruptedException
523 	 * @throws ExecutionException
524 	 * @throws NoValidTokenStreamException
525 	 * @throws CyclicDependencyException
526 	 */
527 	@Test
528 	public void testAbstractOperationInAbstractClass2() throws InterruptedException, ExecutionException,
529 			NoValidTokenStreamException, CyclicDependencyException {
530 		final SimpleScannerInput input =
531 				new SimpleScannerInput("Group:group=[Klasse:class={operation : [[(parameter:Integer) -> String ]] ;"
532 						+ "operation2 : [[(parameter:Integer) -> String ]] ;} ; "
533 						+ "Klasse2:class={operation : [[(parameter:Integer) -> String ]] ;"
534 						+ "operation2 : [[(parameter:Integer) -> String ]] abstract;} abstract; ];");
535 		final TokenStream output = FilteredTokenStream.create();
536 		final Scanner scanner = ModelDslScanner.create();
537 		scanner.scan(input, output);
538 		final Parser parser = Parser.create(output);
539 		Model model = null;
540 		model = parser.parse();
541 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
542 		AbstractOperationsCheck.create(model, taskmanager);
543 		taskmanager.startAllKnownTasks();
544 		
545 		final Collection<OKTaskResult> okResult = new ArrayList<>();
546 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
547 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
548 		for (final TaskResult current : results) {
549 			current.accept(new TaskResultVisitor() {
550 				
551 				@Override
552 				public void handleOkTaskResult(final OKTaskResult result) {
553 					okResult.add(result);
554 				}
555 				
556 				@Override
557 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
558 					failResult.add(result);
559 				}
560 			});
561 		}
562 		
563 		assertEquals(1, okResult.size());
564 		assertEquals(0, failResult.size());
565 	}
566 }