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
31
32 public class TestInvalidAttributeModifierCheck {
33
34
35
36
37
38
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
80
81
82
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
124
125
126
127
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
169
170
171
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
213
214
215
216
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
259
260
261
262
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
304
305
306
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 }