1 package de.fhdw.wtf.common.task.test;
2
3 import static org.junit.Assert.assertEquals;
4 import static org.junit.Assert.assertNull;
5 import static org.junit.Assert.assertTrue;
6 import static org.junit.Assert.fail;
7
8 import java.util.Collection;
9 import java.util.concurrent.ExecutionException;
10
11 import org.junit.Test;
12
13 import de.fhdw.wtf.common.ast.Model;
14 import de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException;
15 import de.fhdw.wtf.common.exception.walker.CyclicDependencyException;
16 import de.fhdw.wtf.common.exception.walker.CyclicPartDefinitionException;
17 import de.fhdw.wtf.common.stream.FilteredTokenStream;
18 import de.fhdw.wtf.common.stream.SimpleScannerInput;
19 import de.fhdw.wtf.common.stream.TokenStream;
20 import de.fhdw.wtf.common.task.DependencyTask;
21 import de.fhdw.wtf.common.task.GroupDependencyTask;
22 import de.fhdw.wtf.common.task.TaskExecutor;
23 import de.fhdw.wtf.common.task.TaskExecutorFixed;
24 import de.fhdw.wtf.common.task.result.OKTaskResult;
25 import de.fhdw.wtf.common.task.result.TaskResult;
26 import de.fhdw.wtf.dsl.scanner.common.Scanner;
27 import de.fhdw.wtf.dsl.scanner.modelScanner.ModelDslScanner;
28 import de.fhdw.wtf.parser.Parser;
29 import de.fhdw.wtf.walker.tasks.CyclicInheritanceCheck;
30 import de.fhdw.wtf.walker.tasks.DoubleAttributenameCheck;
31 import de.fhdw.wtf.walker.tasks.DoubleGroupcomponentCheck;
32 import de.fhdw.wtf.walker.tasks.TypeReferencer;
33 import de.fhdw.wtf.walker.walker.SimpleWalkerTask;
34
35 public class TaskTest {
36
37 @Test
38 public void testCycle() throws CyclicDependencyException, InterruptedException {
39 final TaskExecutor taskmanager = TaskExecutorFixed.create();
40 final DependencyTask task1 = new DummyTask(taskmanager, "T1");
41 final DependencyTask task2 = new DummyTask(taskmanager, "T2");
42 task1.addDependency(task2);
43 try {
44 task2.addDependency(task1);
45 fail("Must be an exception!");
46 } catch (final CyclicDependencyException e) {
47 assertTrue(true);
48 }
49 taskmanager.startAllKnownTasks();
50 }
51
52 @Test
53 public void testReflexiveCycle() throws CyclicDependencyException, InterruptedException {
54 final TaskExecutor taskmanager = TaskExecutorFixed.create();
55 final DependencyTask task1 = new DummyTask(taskmanager, "T1");
56 try {
57 task1.addDependency(task1);
58 fail("Must be an exception!");
59 } catch (final CyclicDependencyException e) {
60 assertTrue(true);
61 }
62 taskmanager.startAllKnownTasks();
63 }
64
65 @Test
66 public void testCycle3() throws CyclicDependencyException, InterruptedException {
67 final TaskExecutor taskmanager = TaskExecutorFixed.create();
68 final DependencyTask task1 = new DummyTask(taskmanager, "T1");
69 final DependencyTask task2 = new DummyTask(taskmanager, "T2");
70 final DependencyTask task3 = new DummyTask(taskmanager, "T3");
71 task1.addDependency(task2);
72 task1.addDependency(task3);
73 task2.addDependency(task3);
74 try {
75 task3.addDependency(task1);
76 fail("Must be an exception!");
77 } catch (final CyclicDependencyException e) {
78 assertTrue(true);
79 }
80 try {
81 task2.addDependency(task1);
82 fail("Must be an exception!");
83 } catch (final CyclicDependencyException e) {
84 assertTrue(true);
85 }
86 try {
87 task3.addDependency(task2);
88 fail("Must be an exception!");
89 } catch (final CyclicDependencyException e) {
90 assertTrue(true);
91 }
92 taskmanager.startAllKnownTasks();
93 }
94
95 @Test
96 public void testGroup1() throws CyclicDependencyException, CyclicPartDefinitionException, InterruptedException,
97 ExecutionException {
98 final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
99 final DependencyTask task11 = new DummyTask(taskmanager, "T11");
100 final DependencyTask task12 = new DummyTask(taskmanager, "T12");
101 final DependencyTask task21 = new DummyTask(taskmanager, "T21");
102 final DependencyTask task22 = new DummyTask(taskmanager, "T22");
103
104 final GroupDependencyTask g1 = new DummyGroup(taskmanager, "G1");
105 final GroupDependencyTask g2 = new DummyGroup(taskmanager, "G2");
106 g1.addMembers(task11, task12);
107 g2.addMembers(task21, task22);
108
109 g2.addDependency(g1);
110 try {
111 g1.addDependency(g2);
112 fail("exception excpected.");
113 } catch (final CyclicDependencyException e) {
114 assertTrue(true);
115 }
116 try {
117 task11.addDependency(g2);
118 fail("exception expected");
119 } catch (final CyclicDependencyException e) {
120 assertTrue(true);
121 }
122 taskmanager.startAllKnownTasks();
123 taskmanager.getResultsAndShutdown();
124 }
125
126 @Test
127 public void testGroup2() throws CyclicDependencyException, CyclicPartDefinitionException, InterruptedException,
128 ExecutionException {
129 final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
130 final DummyTask task1 = new DummyTask(taskmanager, "T1");
131 new DummyTask(taskmanager, "T2");
132
133 final GroupDependencyTask g1 = new DummyGroup(taskmanager, "G1");
134 final GroupDependencyTask g2 = new DummyGroup(taskmanager, "G2");
135 final GroupDependencyTask g3 = new DummyGroup(taskmanager, "G3");
136 g1.addMembers(task1);
137 g2.addMembers(g1);
138 g3.addMembers(task1);
139 System.out.println("ok---");
140 try {
141 g2.addDependency(task1);
142 fail();
143 } catch (final CyclicDependencyException e) {
144 assertTrue(true);
145 }
146
147 taskmanager.startAllKnownTasks();
148 taskmanager.getResultsAndShutdown();
149 }
150
151 @Test
152 public void testCyclicDependency() {
153 final SimpleScannerInput input =
154 new SimpleScannerInput("" + "group1:group=[" + "class1:class={};" + "group2:group=["
155 + "class2:class={};" + "group3:group=[" + "class3:class={" + "a:group2>class2;" + "};" + "];"
156 + "];" + "];");
157 final TokenStream output = FilteredTokenStream.create();
158 final Scanner scanner = ModelDslScanner.create();
159 scanner.scan(input, output);
160 final Parser parser = Parser.create(output);
161 Model model = null;
162 try {
163 model = parser.parse();
164 } catch (final NoValidTokenStreamException e) {
165 fail();
166 }
167
168 final TaskExecutor taskmanager = TaskExecutorFixed.create();
169
170 final SimpleWalkerTask doubleAttributename = DoubleAttributenameCheck.create(model, taskmanager);
171 final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
172
173 Exception ex = null;
174 try {
175 doubleAttributename.addDependency(doubleGroupcomponent);
176 doubleGroupcomponent.addDependency(doubleAttributename);
177 } catch (final CyclicDependencyException e) {
178 ex = e;
179 }
180 if (ex == null) {
181 fail();
182 }
183 }
184
185 @Test
186 public void testDyclicDependencyTransitive() {
187 final SimpleScannerInput input =
188 new SimpleScannerInput("" + "group1:group=[" + "class1:class={};" + "group2:group=["
189 + "class2:class={};" + "group3:group=[" + "class3:class={" + "a:group2>class2;" + "};" + "];"
190 + "];" + "];");
191 final TokenStream output = FilteredTokenStream.create();
192 final Scanner scanner = ModelDslScanner.create();
193 scanner.scan(input, output);
194 final Parser parser = Parser.create(output);
195 Model model = null;
196 try {
197 model = parser.parse();
198 } catch (final NoValidTokenStreamException e) {
199 fail();
200 }
201
202 final TaskExecutor taskmanager = TaskExecutorFixed.create();
203
204 final SimpleWalkerTask doubleAttributename = DoubleAttributenameCheck.create(model, taskmanager);
205 final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
206 final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
207
208 Exception ex = null;
209 try {
210 doubleAttributename.addDependency(doubleGroupcomponent);
211 doubleGroupcomponent.addDependency(referencer);
212 } catch (final CyclicDependencyException e) {
213 ex = e;
214 }
215 assertNull(ex);
216 try {
217 referencer.addDependency(doubleAttributename);
218 } catch (final CyclicDependencyException e) {
219 ex = e;
220 }
221 if (ex == null) {
222 fail();
223 }
224 }
225
226 @Test
227 public void testParserWithTaskReferencer() throws InterruptedException, ExecutionException,
228 CyclicPartDefinitionException {
229 final SimpleScannerInput input =
230 new SimpleScannerInput("" + "group1:group=[" + "class1:class={};" + "group2:group=["
231 + "class2:class={};" + "group3:group=[" + "class3:class={" + "a:group2>class2;" + "};" + "];"
232 + "];" + "];");
233 final TokenStream output = FilteredTokenStream.create();
234 final Scanner scanner = ModelDslScanner.create();
235 scanner.scan(input, output);
236 final Parser parser = Parser.create(output);
237 Model model = null;
238 try {
239 model = parser.parse();
240 } catch (final NoValidTokenStreamException e) {
241 fail();
242 }
243
244 final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
245
246 final SimpleWalkerTask doubleAttributename = DoubleAttributenameCheck.create(model, taskmanager);
247 final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
248 final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
249 final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
250 final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
251 doubleChecks.addMembers(doubleAttributename, doubleGroupcomponent);
252
253 try {
254 referencer.addDependency(doubleChecks);
255 cyclicInheritance.addDependency(referencer);
256 } catch (final CyclicDependencyException e) {
257 e.printStackTrace();
258 fail();
259 }
260 taskmanager.startAllKnownTasks();
261
262 final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
263 for (final TaskResult current : results) {
264 assertTrue(current instanceof OKTaskResult);
265 }
266 assertEquals(5, results.size());
267 }
268 }
269
270
271
272
273 class DummyTask extends DependencyTask {
274
275 private final String name;
276
277 DummyTask(final TaskExecutor taskmanager, final String name) {
278 super(taskmanager);
279 this.name = name;
280 }
281
282 @Override
283 public boolean containsTransitive(final DependencyTask a) {
284 return false;
285 }
286
287 @Override
288 public TaskResult doWork() {
289 System.out.println(this.name);
290 return new OKTaskResult();
291 }
292
293 @Override
294 public String toString() {
295 return "DummyTask<" + this.name + ">";
296 }
297
298 }
299
300 class DummyGroup extends GroupDependencyTask {
301
302 private final String name;
303
304 DummyGroup(final TaskExecutor taskmanager, final String name) {
305 super(taskmanager);
306 this.name = name;
307 }
308
309 @Override
310 public TaskResult doWork() {
311 System.out.println("start" + this.name);
312 return super.doWork();
313 }
314
315 @Override
316 public String toString() {
317 return "DummyGroup<" + this.name + ">";
318 }
319
320 }