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