View Javadoc
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   * Tests for {@link de.fhdw.wtf.walker.tasks.BaseTypeInheritanceCheck}.
33   * 
34   */
35  public class TestBaseTypeInheritanceCheck extends TestCase {
36  	
37  	/**
38  	 * personGroup:group=[Person:class=Integer+{};];.
39  	 * 
40  	 * @throws InterruptedException
41  	 *             InterruptedException
42  	 * @throws ExecutionException
43  	 *             ExecutionException
44  	 * @throws NoValidTokenStreamException
45  	 *             NoValidTokenStreamException
46  	 * @throws CyclicDependencyException
47  	 *             CyclicDependencyException
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  	 * personGroup:group=[Person:class=String+{};];.
97  	 * 
98  	 * @throws InterruptedException
99  	 *             InterruptedException
100 	 * @throws ExecutionException
101 	 *             ExecutionException
102 	 * @throws NoValidTokenStreamException
103 	 *             NoValidTokenStreamException
104 	 * @throws CyclicDependencyException
105 	 *             CyclicDependencyException
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 	 * personGroup:group=[Person:class=Anything+{};];.
155 	 * 
156 	 * @throws InterruptedException
157 	 *             InterruptedException
158 	 * @throws ExecutionException
159 	 *             ExecutionException
160 	 * @throws NoValidTokenStreamException
161 	 *             NoValidTokenStreamException
162 	 * @throws CyclicDependencyException
163 	 *             CyclicDependencyException
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 	 * personGroup:group=[Person:class=Person+{};];.
204 	 * 
205 	 * @throws InterruptedException
206 	 *             InterruptedException
207 	 * @throws ExecutionException
208 	 *             ExecutionException
209 	 * @throws NoValidTokenStreamException
210 	 *             NoValidTokenStreamException
211 	 * @throws CyclicDependencyException
212 	 *             CyclicDependencyException
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 	 * personGroup:group=[Person:class=Object+{}; Object:class={};];.
253 	 * 
254 	 * @throws InterruptedException
255 	 *             InterruptedException
256 	 * @throws ExecutionException
257 	 *             ExecutionException
258 	 * @throws NoValidTokenStreamException
259 	 *             NoValidTokenStreamException
260 	 * @throws CyclicDependencyException
261 	 *             CyclicDependencyException
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 }