View Javadoc
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()); // 4 Checks + group
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 }