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.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   * Tests {@link ProductCheck}.
31   */
32  public class TestProductCheck extends TestCase {
33  	
34  	/**
35  	 * Group:group=[Klasse:class={operation : [[(parameter:Integer,parameter:String) -> String ]];};]; .
36  	 * 
37  	 * @throws InterruptedException
38  	 * @throws ExecutionException
39  	 * @throws NoValidTokenStreamException
40  	 * @throws CyclicDependencyException
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  	 * Group:group=[Klasse:class={attr : (parameter:Integer,parameter:String);};]; .
91  	 * 
92  	 * @throws InterruptedException
93  	 * @throws ExecutionException
94  	 * @throws NoValidTokenStreamException
95  	 * @throws CyclicDependencyException
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 	 * Group:group=[Klasse:class={operation : [[(parameter:Integer,parameter:String,parameter:String) -> String ]];};];
145 	 * .
146 	 * 
147 	 * @throws InterruptedException
148 	 * @throws ExecutionException
149 	 * @throws NoValidTokenStreamException
150 	 * @throws CyclicDependencyException
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 	 * Group:group=[Klasse:class={attr : (parameter:Integer,parameter:String,parameter:String);};]; .
202 	 * 
203 	 * @throws InterruptedException
204 	 * @throws ExecutionException
205 	 * @throws NoValidTokenStreamException
206 	 * @throws CyclicDependencyException
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 	 * Group:group=[Klasse:class={operation : [[(parameter1:Integer,parameter2:String) -> String ]];};]; .
257 	 * 
258 	 * @throws InterruptedException
259 	 * @throws ExecutionException
260 	 * @throws NoValidTokenStreamException
261 	 * @throws CyclicDependencyException
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 	 * Group:group=[Klasse:class={operation : [[(parameter1:Integer,parameter2:String) -> String ]];};]; .
303 	 * 
304 	 * @throws InterruptedException
305 	 * @throws ExecutionException
306 	 * @throws NoValidTokenStreamException
307 	 * @throws CyclicDependencyException
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 	 * Group:group=[Klasse:class={operation : [[(parameter:Integer,Parameter:String) -> String ]];};]; .
349 	 * 
350 	 * @throws InterruptedException
351 	 * @throws ExecutionException
352 	 * @throws NoValidTokenStreamException
353 	 * @throws CyclicDependencyException
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 	 * Group:group=[Klasse:class={operation : [[(parameter:Integer,paraMeter:String) -> String ]];};]; .
395 	 * 
396 	 * @throws InterruptedException
397 	 * @throws ExecutionException
398 	 * @throws NoValidTokenStreamException
399 	 * @throws CyclicDependencyException
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 	 * Group:group=[Klasse:class={attr : (parameter:Integer,Parameter:String);};]; .
441 	 * 
442 	 * @throws InterruptedException
443 	 * @throws ExecutionException
444 	 * @throws NoValidTokenStreamException
445 	 * @throws CyclicDependencyException
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 	 * Group:group=[Klasse:class={attr : (parameter:Integer,paraMeter:String);};]; .
486 	 * 
487 	 * @throws InterruptedException
488 	 * @throws ExecutionException
489 	 * @throws NoValidTokenStreamException
490 	 * @throws CyclicDependencyException
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 	 * Group:group=[Klasse:class={attr:(parameter:Integer,paraMeter:String);
531 	 * attr2:(parameter:Integer,paraMeter:String);operation : [[(parameter:Integer,paraMeter:String) -> String ]];};]; .
532 	 * 
533 	 * @throws InterruptedException
534 	 * @throws ExecutionException
535 	 * @throws NoValidTokenStreamException
536 	 * @throws CyclicDependencyException
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 }