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
31
32 public class TestAbstractOperationsCheck extends TestCase {
33
34
35
36
37
38
39
40
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
91
92
93
94
95
96
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
147
148
149
150
151
152
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
203
204
205
206
207
208
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
259
260
261
262
263
264
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
315
316
317
318
319
320
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
371
372
373
374
375
376
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
427
428
429
430
431
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
472
473
474
475
476
477
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
519
520
521
522
523
524
525
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 }