View Javadoc
1   package de.fhdw.wtf.walker.tasks.test;
2   
3   import static org.junit.Assert.assertEquals;
4   import static org.junit.Assert.fail;
5   
6   import java.util.ArrayList;
7   import java.util.Collection;
8   
9   import org.junit.Test;
10  
11  import de.fhdw.wtf.common.ast.Model;
12  import de.fhdw.wtf.common.exception.walker.InvalidAttributeModifierException;
13  import de.fhdw.wtf.common.stream.FilteredTokenStream;
14  import de.fhdw.wtf.common.stream.SimpleScannerInput;
15  import de.fhdw.wtf.common.stream.TokenStream;
16  import de.fhdw.wtf.common.task.TaskExecutorFixed;
17  import de.fhdw.wtf.common.task.result.ExceptionalTaskResult;
18  import de.fhdw.wtf.common.task.result.OKTaskResult;
19  import de.fhdw.wtf.common.task.result.TaskResult;
20  import de.fhdw.wtf.common.task.result.visitor.TaskResultVisitor;
21  import de.fhdw.wtf.common.token.Position;
22  import de.fhdw.wtf.dsl.scanner.common.Scanner;
23  import de.fhdw.wtf.dsl.scanner.modelScanner.ModelDslScanner;
24  import de.fhdw.wtf.parser.Parser;
25  import de.fhdw.wtf.walker.tasks.InvalidAttributeModifierCheck;
26  import de.fhdw.wtf.walker.tasks.TypeReferencer;
27  import de.fhdw.wtf.walker.walker.SimpleWalkerTask;
28  
29  /**
30   * Tests the {@link InvalidAttributeModifierCheck} and its exceptions.
31   */
32  public class TestInvalidAttributeModifierCheck {
33  	
34  	/**
35  	 * Group:group=[Class1:class={}; Class2:class={}; Class3:class={Attribute1:Class2 symmetric (Class1);};];.
36  	 * 
37  	 * @throws Exception
38  	 *             : {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
39  	 */
40  	@Test
41  	public void testSimpleValidSymmetricModifier() throws Exception {
42  		final SimpleScannerInput input =
43  				new SimpleScannerInput("Group:group=[Class1:class={}; Class2:class={};"
44  						+ "Class3:class={Attribute1:Class2 symmetric (Class1);};];");
45  		final TokenStream output = FilteredTokenStream.create();
46  		final Scanner scanner = ModelDslScanner.create();
47  		scanner.scan(input, output);
48  		final Parser parser = Parser.create(output);
49  		final Model model = parser.parse();
50  		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
51  		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
52  		final InvalidAttributeModifierCheck modifierCheck = InvalidAttributeModifierCheck.create(model, taskmanager);
53  		modifierCheck.addDependency(referencer);
54  		taskmanager.startAllKnownTasks();
55  		
56  		final Collection<OKTaskResult> okResult = new ArrayList<>();
57  		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
58  		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
59  		for (final TaskResult current : results) {
60  			current.accept(new TaskResultVisitor() {
61  				
62  				@Override
63  				public void handleOkTaskResult(final OKTaskResult result) {
64  					okResult.add(result);
65  				}
66  				
67  				@Override
68  				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
69  					failResult.add(result);
70  				}
71  			});
72  		}
73  		
74  		assertEquals(2, okResult.size());
75  		assertEquals(0, failResult.size());
76  	}
77  	
78  	/**
79  	 * Group:group=[Class1:class={}; Class2:class={}; Class3:class={Attribute1:Class2* symmetric (Class1);};];.
80  	 * 
81  	 * @throws Exception
82  	 *             : {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
83  	 */
84  	@Test
85  	public void testListOfSymmetricModifier() throws Exception {
86  		final SimpleScannerInput input =
87  				new SimpleScannerInput("Group:group=[Class1:class={}; Class2:class={};"
88  						+ "Class3:class={Attribute1:Class2* symmetric (Class1);};];");
89  		final TokenStream output = FilteredTokenStream.create();
90  		final Scanner scanner = ModelDslScanner.create();
91  		scanner.scan(input, output);
92  		final Parser parser = Parser.create(output);
93  		final Model model = parser.parse();
94  		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
95  		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
96  		final InvalidAttributeModifierCheck modifierCheck = InvalidAttributeModifierCheck.create(model, taskmanager);
97  		modifierCheck.addDependency(referencer);
98  		taskmanager.startAllKnownTasks();
99  		
100 		final Collection<OKTaskResult> okResult = new ArrayList<>();
101 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
102 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
103 		for (final TaskResult current : results) {
104 			current.accept(new TaskResultVisitor() {
105 				
106 				@Override
107 				public void handleOkTaskResult(final OKTaskResult result) {
108 					okResult.add(result);
109 				}
110 				
111 				@Override
112 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
113 					failResult.add(result);
114 				}
115 			});
116 		}
117 		
118 		assertEquals(2, okResult.size());
119 		assertEquals(0, failResult.size());
120 	}
121 	
122 	/**
123 	 * Group:group=[Class1:class={}; Class2:class={}; Class3:class={Attribute1:[Class1->Class2] symmetric (Class4);};
124 	 * Class4:class={};];.
125 	 * 
126 	 * @throws Exception
127 	 *             : {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
128 	 */
129 	@Test
130 	public void testMapOfSymmetricModifier() throws Exception {
131 		final SimpleScannerInput input =
132 				new SimpleScannerInput("Group:group=[Class1:class={}; Class2:class={};"
133 						+ "Class3:class={Attribute1:[Class1->Class2] symmetric (Class4);}; Class4:class={};];");
134 		final TokenStream output = FilteredTokenStream.create();
135 		final Scanner scanner = ModelDslScanner.create();
136 		scanner.scan(input, output);
137 		final Parser parser = Parser.create(output);
138 		final Model model = parser.parse();
139 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
140 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
141 		final InvalidAttributeModifierCheck modifierCheck = InvalidAttributeModifierCheck.create(model, taskmanager);
142 		modifierCheck.addDependency(referencer);
143 		taskmanager.startAllKnownTasks();
144 		
145 		final Collection<OKTaskResult> okResult = new ArrayList<>();
146 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
147 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
148 		for (final TaskResult current : results) {
149 			current.accept(new TaskResultVisitor() {
150 				
151 				@Override
152 				public void handleOkTaskResult(final OKTaskResult result) {
153 					okResult.add(result);
154 				}
155 				
156 				@Override
157 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
158 					failResult.add(result);
159 				}
160 			});
161 		}
162 		
163 		assertEquals(2, okResult.size());
164 		assertEquals(0, failResult.size());
165 	}
166 	
167 	/**
168 	 * Group:group=[Class1:class={Attribute:String findable prior transient mutable;};];.
169 	 * 
170 	 * @throws Exception
171 	 *             : {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
172 	 */
173 	@Test
174 	public void testModifiersCheck() throws Exception {
175 		final SimpleScannerInput input =
176 				new SimpleScannerInput(
177 						"Group:group=[Class1:class={Attribute:String findable prior transient mutable;};];");
178 		final TokenStream output = FilteredTokenStream.create();
179 		final Scanner scanner = ModelDslScanner.create();
180 		scanner.scan(input, output);
181 		final Parser parser = Parser.create(output);
182 		final Model model = parser.parse();
183 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
184 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
185 		final InvalidAttributeModifierCheck modifierCheck = InvalidAttributeModifierCheck.create(model, taskmanager);
186 		modifierCheck.addDependency(referencer);
187 		taskmanager.startAllKnownTasks();
188 		
189 		final Collection<OKTaskResult> okResult = new ArrayList<>();
190 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
191 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
192 		for (final TaskResult current : results) {
193 			current.accept(new TaskResultVisitor() {
194 				
195 				@Override
196 				public void handleOkTaskResult(final OKTaskResult result) {
197 					okResult.add(result);
198 				}
199 				
200 				@Override
201 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
202 					failResult.add(result);
203 				}
204 			});
205 		}
206 		
207 		assertEquals(2, okResult.size());
208 		assertEquals(0, failResult.size());
209 	}
210 	
211 	/**
212 	 * Group:group=[Class1:class={}; Class2:class={}; Class3:class={Attribute1:(class1:Class1, class2:Class2) symmetric
213 	 * (Class4);}; Class4:class={};];.
214 	 * 
215 	 * @throws Exception
216 	 *             : {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
217 	 */
218 	@Test
219 	public void testProductSymmetricModifier() throws Exception {
220 		final SimpleScannerInput input =
221 				new SimpleScannerInput("Group:group=[Class1:class={}; Class2:class={}; "
222 						+ "Class3:class={Attribute1:(class1:Class1, class2:Class2) symmetric (Class4);}; "
223 						+ "Class4:class={};];");
224 		final TokenStream output = FilteredTokenStream.create();
225 		final Scanner scanner = ModelDslScanner.create();
226 		scanner.scan(input, output);
227 		final Parser parser = Parser.create(output);
228 		final Model model = parser.parse();
229 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
230 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
231 		final InvalidAttributeModifierCheck modifierCheck = InvalidAttributeModifierCheck.create(model, taskmanager);
232 		modifierCheck.addDependency(referencer);
233 		taskmanager.startAllKnownTasks();
234 		
235 		final Collection<OKTaskResult> okResult = new ArrayList<>();
236 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
237 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
238 		for (final TaskResult current : results) {
239 			current.accept(new TaskResultVisitor() {
240 				
241 				@Override
242 				public void handleOkTaskResult(final OKTaskResult result) {
243 					okResult.add(result);
244 				}
245 				
246 				@Override
247 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
248 					failResult.add(result);
249 				}
250 			});
251 		}
252 		
253 		assertEquals(2, okResult.size());
254 		assertEquals(0, failResult.size());
255 	}
256 	
257 	/**
258 	 * Group:group=[Class1:class={}; Class2:class={}; Class3:class={Attribute1:{Class1, Class2} symmetric (Class4);};
259 	 * Class4:class={};];.
260 	 * 
261 	 * @throws Exception
262 	 *             : {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
263 	 */
264 	@Test
265 	public void testSumSymmetricModifier() throws Exception {
266 		final SimpleScannerInput input =
267 				new SimpleScannerInput("Group:group=[Class1:class={}; Class2:class={}; "
268 						+ "Class3:class={Attribute1:{Class1, Class2} symmetric (Class4);}; Class4:class={};];");
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 		final Model model = parser.parse();
274 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
275 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
276 		final InvalidAttributeModifierCheck modifierCheck = InvalidAttributeModifierCheck.create(model, taskmanager);
277 		modifierCheck.addDependency(referencer);
278 		taskmanager.startAllKnownTasks();
279 		
280 		final Collection<OKTaskResult> okResult = new ArrayList<>();
281 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
282 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
283 		for (final TaskResult current : results) {
284 			current.accept(new TaskResultVisitor() {
285 				
286 				@Override
287 				public void handleOkTaskResult(final OKTaskResult result) {
288 					okResult.add(result);
289 				}
290 				
291 				@Override
292 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
293 					failResult.add(result);
294 				}
295 			});
296 		}
297 		
298 		assertEquals(2, okResult.size());
299 		assertEquals(0, failResult.size());
300 	}
301 	
302 	/**
303 	 * Group:group=[Class:class={Attribute1:Integer symmetric (String);};];.
304 	 * 
305 	 * @throws Exception
306 	 *             : {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
307 	 */
308 	@Test
309 	public void testInvalidSymmetricModifier1() throws Exception {
310 		final SimpleScannerInput input =
311 				new SimpleScannerInput("Group:group=[Class:class={Attribute1:Integer symmetric (String);};];");
312 		final TokenStream output = FilteredTokenStream.create();
313 		final Scanner scanner = ModelDslScanner.create();
314 		scanner.scan(input, output);
315 		final Parser parser = Parser.create(output);
316 		final Model model = parser.parse();
317 		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
318 		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
319 		final InvalidAttributeModifierCheck modifierCheck = InvalidAttributeModifierCheck.create(model, taskmanager);
320 		modifierCheck.addDependency(referencer);
321 		taskmanager.startAllKnownTasks();
322 		
323 		final Collection<OKTaskResult> okResult = new ArrayList<>();
324 		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
325 		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
326 		for (final TaskResult current : results) {
327 			current.accept(new TaskResultVisitor() {
328 				
329 				@Override
330 				public void handleOkTaskResult(final OKTaskResult result) {
331 					okResult.add(result);
332 				}
333 				
334 				@Override
335 				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
336 					failResult.add(result);
337 				}
338 			});
339 		}
340 		
341 		assertEquals(1, okResult.size());
342 		assertEquals(1, failResult.size());
343 		
344 		final Exception exception = failResult.iterator().next().getError();
345 		if (exception instanceof InvalidAttributeModifierException) {
346 			final InvalidAttributeModifierException ex = (InvalidAttributeModifierException) exception;
347 			assertEquals(Position.create("", 1, 46, 45), ex.getStartPosition());
348 			assertEquals(Position.create("", 1, 63, 62), ex.getEndPos());
349 		} else {
350 			fail();
351 		}
352 	}
353 	
354 }