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.BaseTypeInheritanceException;
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.BaseTypeInheritanceCheck;
28 import de.fhdw.wtf.walker.tasks.TypeReferencer;
29 import de.fhdw.wtf.walker.walker.SimpleWalkerTask;
30
31
32
33
34
35 public class TestBaseTypeInheritanceCheck extends TestCase {
36
37
38
39
40
41
42
43
44
45
46
47
48
49 @Test
50 public void testInheritFromInteger() throws InterruptedException, ExecutionException, NoValidTokenStreamException,
51 CyclicDependencyException {
52 final SimpleScannerInput input = new SimpleScannerInput("personGroup:group=[Person:class=Integer+{};];");
53 final TokenStream output = FilteredTokenStream.create();
54 final Scanner scanner = ModelDslScanner.create();
55 scanner.scan(input, output);
56 final Parser parser = Parser.create(output);
57 final Model model = parser.parse();
58 final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
59 final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
60 final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
61 baseTypeInheritanceCheck.addDependency(referencer);
62 taskmanager.startAllKnownTasks();
63
64 final Collection<OKTaskResult> okResult = new ArrayList<>();
65 final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
66 final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
67 for (final TaskResult current : results) {
68 current.accept(new TaskResultVisitor() {
69
70 @Override
71 public void handleOkTaskResult(final OKTaskResult result) {
72 okResult.add(result);
73 }
74
75 @Override
76 public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
77 failResult.add(result);
78 }
79 });
80 }
81
82 assertEquals(1, okResult.size());
83 assertEquals(1, failResult.size());
84
85 final Exception exception = failResult.iterator().next().getError();
86 if (exception instanceof BaseTypeInheritanceException) {
87 final BaseTypeInheritanceException ex = (BaseTypeInheritanceException) exception;
88 assertEquals(Position.create("", 1, 33, 32), ex.getStartPosition());
89 assertEquals(Position.create("", 1, 40, 39), ex.getEndPos());
90 } else {
91 fail();
92 }
93 }
94
95
96
97
98
99
100
101
102
103
104
105
106
107 @Test
108 public void testInheritFromString() throws InterruptedException, ExecutionException, NoValidTokenStreamException,
109 CyclicDependencyException {
110 final SimpleScannerInput input = new SimpleScannerInput("personGroup:group=[Person:class=String+{};];");
111 final TokenStream output = FilteredTokenStream.create();
112 final Scanner scanner = ModelDslScanner.create();
113 scanner.scan(input, output);
114 final Parser parser = Parser.create(output);
115 final Model model = parser.parse();
116 final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
117 final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
118 final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
119 baseTypeInheritanceCheck.addDependency(referencer);
120 taskmanager.startAllKnownTasks();
121
122 final Collection<OKTaskResult> okResult = new ArrayList<>();
123 final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
124 final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
125 for (final TaskResult current : results) {
126 current.accept(new TaskResultVisitor() {
127
128 @Override
129 public void handleOkTaskResult(final OKTaskResult result) {
130 okResult.add(result);
131 }
132
133 @Override
134 public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
135 failResult.add(result);
136 }
137 });
138 }
139
140 assertEquals(1, okResult.size());
141 assertEquals(1, failResult.size());
142
143 final Exception exception = failResult.iterator().next().getError();
144 if (exception instanceof BaseTypeInheritanceException) {
145 final BaseTypeInheritanceException ex = (BaseTypeInheritanceException) exception;
146 assertEquals(Position.create("", 1, 33, 32), ex.getStartPosition());
147 assertEquals(Position.create("", 1, 39, 38), ex.getEndPos());
148 } else {
149 fail();
150 }
151 }
152
153
154
155
156
157
158
159
160
161
162
163
164
165 @Test
166 public void testInheritFromAnything() throws InterruptedException, ExecutionException, NoValidTokenStreamException,
167 CyclicDependencyException {
168 final SimpleScannerInput input = new SimpleScannerInput("personGroup:group=[Person:class=Anything+{};];");
169 final TokenStream output = FilteredTokenStream.create();
170 final Scanner scanner = ModelDslScanner.create();
171 scanner.scan(input, output);
172 final Parser parser = Parser.create(output);
173 final Model model = parser.parse();
174 final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
175 final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
176 final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
177 baseTypeInheritanceCheck.addDependency(referencer);
178 taskmanager.startAllKnownTasks();
179
180 final Collection<OKTaskResult> okResult = new ArrayList<>();
181 final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
182 final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
183 for (final TaskResult current : results) {
184 current.accept(new TaskResultVisitor() {
185
186 @Override
187 public void handleOkTaskResult(final OKTaskResult result) {
188 okResult.add(result);
189 }
190
191 @Override
192 public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
193 failResult.add(result);
194 }
195 });
196 }
197
198 assertEquals(2, okResult.size());
199 assertEquals(0, failResult.size());
200 }
201
202
203
204
205
206
207
208
209
210
211
212
213
214 @Test
215 public void testInheritFromItself() throws InterruptedException, ExecutionException, NoValidTokenStreamException,
216 CyclicDependencyException {
217 final SimpleScannerInput input = new SimpleScannerInput("personGroup:group=[Person:class=Person+{};];");
218 final TokenStream output = FilteredTokenStream.create();
219 final Scanner scanner = ModelDslScanner.create();
220 scanner.scan(input, output);
221 final Parser parser = Parser.create(output);
222 final Model model = parser.parse();
223 final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
224 final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
225 final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
226 baseTypeInheritanceCheck.addDependency(referencer);
227 taskmanager.startAllKnownTasks();
228
229 final Collection<OKTaskResult> okResult = new ArrayList<>();
230 final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
231 final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
232 for (final TaskResult current : results) {
233 current.accept(new TaskResultVisitor() {
234
235 @Override
236 public void handleOkTaskResult(final OKTaskResult result) {
237 okResult.add(result);
238 }
239
240 @Override
241 public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
242 failResult.add(result);
243 }
244 });
245 }
246
247 assertEquals(2, okResult.size());
248 assertEquals(0, failResult.size());
249 }
250
251
252
253
254
255
256
257
258
259
260
261
262
263 @Test
264 public void testInheritFromOtherClass() throws InterruptedException, ExecutionException,
265 NoValidTokenStreamException, CyclicDependencyException {
266 final SimpleScannerInput input =
267 new SimpleScannerInput("personGroup:group=[Person:class=Object+{}; Object:class={};];");
268 final TokenStream output = FilteredTokenStream.create();
269 final Scanner scanner = ModelDslScanner.create();
270 scanner.scan(input, output);
271 final Parser parser = Parser.create(output);
272 final Model model = parser.parse();
273 final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
274 final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
275 final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
276 baseTypeInheritanceCheck.addDependency(referencer);
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(2, okResult.size());
298 assertEquals(0, failResult.size());
299 }
300 }