1 package de.fhdw.wtf.walker.tasks.test;
2
3 import java.util.Collection;
4 import java.util.Vector;
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.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.TaskResult;
19 import de.fhdw.wtf.dsl.scanner.common.Scanner;
20 import de.fhdw.wtf.dsl.scanner.modelScanner.ModelDslScanner;
21 import de.fhdw.wtf.parser.Parser;
22 import de.fhdw.wtf.walker.tasks.DoubleGroupcomponentCheck;
23 import de.fhdw.wtf.walker.walker.SimpleWalkerTask;
24
25 public class TestDoubleGroupcomponentCheck extends TestCase {
26
27
28
29
30
31
32
33 @Test
34 public void testDoubleGroupcomponent1_1() throws InterruptedException, ExecutionException {
35 final SimpleScannerInput input =
36 new SimpleScannerInput("" + "group1:group=[" + "class1:class={};" + "class1:class={};"
37 + "group2:group=[" + "class2:class={};" + "group3:group=[" + "class3:class={"
38 + "a:group2>class2;" + "};" + "];" + "];" + "];");
39 final TokenStream output = FilteredTokenStream.create();
40 final Scanner scanner = ModelDslScanner.create();
41 scanner.scan(input, output);
42 final Parser parser = Parser.create(output);
43 Model model = null;
44 try {
45 model = parser.parse();
46 } catch (final NoValidTokenStreamException e) {
47 fail();
48 }
49
50 final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
51
52 final SimpleWalkerTask doubleClassname = DoubleGroupcomponentCheck.create(model, taskmanager);
53
54 final Collection<SimpleWalkerTask> tasks = new Vector<>();
55 tasks.add(doubleClassname);
56 taskmanager.start(tasks);
57
58 final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
59 for (final TaskResult current : results) {
60 assertTrue(current instanceof ExceptionalTaskResult);
61 }
62 assertEquals(1, results.size());
63 }
64
65
66
67
68
69
70
71 @Test
72 public void testDoubleGroupcomponent1_2() throws InterruptedException, ExecutionException {
73 final SimpleScannerInput input =
74 new SimpleScannerInput("" + "group1:group=[" + "class1:class={};" + "];" + "group2:group=["
75 + "class1:class={};" + "];");
76 final TokenStream output = FilteredTokenStream.create();
77 final Scanner scanner = ModelDslScanner.create();
78 scanner.scan(input, output);
79 final Parser parser = Parser.create(output);
80 Model model = null;
81 try {
82 model = parser.parse();
83 } catch (final NoValidTokenStreamException e) {
84 fail();
85 }
86
87 final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
88
89 final SimpleWalkerTask doubleClassname = DoubleGroupcomponentCheck.create(model, taskmanager);
90
91 final Collection<SimpleWalkerTask> tasks = new Vector<>();
92 tasks.add(doubleClassname);
93 taskmanager.start(tasks);
94
95 final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
96 for (final TaskResult current : results) {
97 assertFalse(current instanceof ExceptionalTaskResult);
98 }
99 assertEquals(1, results.size());
100 }
101
102
103
104
105
106
107
108 @Test
109 public void testDoubleGroupcomponent2() throws InterruptedException, ExecutionException {
110 final SimpleScannerInput input =
111 new SimpleScannerInput("" + "group1:group=[" + "class1:class={};" + "group2:group=[];"
112 + "group2:group=[" + "class2:class={};" + "group3:group=[" + "class3:class={"
113 + "a:group2>class2;" + "};" + "];" + "];" + "];");
114 final TokenStream output = FilteredTokenStream.create();
115 final Scanner scanner = ModelDslScanner.create();
116 scanner.scan(input, output);
117 final Parser parser = Parser.create(output);
118 Model model = null;
119 try {
120 model = parser.parse();
121 } catch (final NoValidTokenStreamException e) {
122 fail();
123 }
124
125 final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
126
127 final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
128
129 final Collection<SimpleWalkerTask> tasks = new Vector<>();
130 tasks.add(doubleGroupcomponent);
131 taskmanager.start(tasks);
132
133 final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
134 for (final TaskResult current : results) {
135 assertTrue(current instanceof ExceptionalTaskResult);
136 }
137 assertEquals(1, results.size());
138 }
139
140
141
142
143
144
145
146 @Test
147 public void testDoubleGroupcomponents3() throws InterruptedException, ExecutionException {
148 final SimpleScannerInput input = new SimpleScannerInput("" + "k:group=[" + "k:class={};" + "];");
149 final TokenStream output = FilteredTokenStream.create();
150 final Scanner scanner = ModelDslScanner.create();
151 scanner.scan(input, output);
152 final Parser parser = Parser.create(output);
153 Model model = null;
154 try {
155 model = parser.parse();
156 } catch (final NoValidTokenStreamException e) {
157 fail();
158 }
159
160 final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
161
162 final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
163
164 final Collection<SimpleWalkerTask> tasks = new Vector<>();
165 tasks.add(doubleGroupcomponent);
166 taskmanager.start(tasks);
167
168 final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
169 for (final TaskResult current : results) {
170 assertFalse(current instanceof ExceptionalTaskResult);
171 }
172 assertEquals(1, results.size());
173 }
174
175
176
177
178
179
180
181 @Test
182 public void testDoubleGroupcomponents4() throws InterruptedException, ExecutionException {
183 final SimpleScannerInput input =
184 new SimpleScannerInput("" + "group1:group=[" + "k:class={};" + "k:group=[];" + "];");
185 final TokenStream output = FilteredTokenStream.create();
186 final Scanner scanner = ModelDslScanner.create();
187 scanner.scan(input, output);
188 final Parser parser = Parser.create(output);
189 Model model = null;
190 try {
191 model = parser.parse();
192 } catch (final NoValidTokenStreamException e) {
193 fail();
194 }
195
196 final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
197
198 final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
199
200 final Collection<SimpleWalkerTask> tasks = new Vector<>();
201 tasks.add(doubleGroupcomponent);
202 taskmanager.start(tasks);
203
204 final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
205 for (final TaskResult current : results) {
206 assertTrue(current instanceof ExceptionalTaskResult);
207 }
208 assertEquals(1, results.size());
209 }
210
211
212
213
214
215
216
217 @Test
218 public void testDoubleGroupcomponents5() throws InterruptedException, ExecutionException {
219 final SimpleScannerInput input =
220 new SimpleScannerInput("" + "group1:group=[" + "k:class={};" + "];" + "group2:group=[" + "k:group=[];"
221 + "];");
222 final TokenStream output = FilteredTokenStream.create();
223 final Scanner scanner = ModelDslScanner.create();
224 scanner.scan(input, output);
225 final Parser parser = Parser.create(output);
226 Model model = null;
227 try {
228 model = parser.parse();
229 } catch (final NoValidTokenStreamException e) {
230 fail();
231 }
232
233 final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
234
235 final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
236
237 final Collection<SimpleWalkerTask> tasks = new Vector<>();
238 tasks.add(doubleGroupcomponent);
239 taskmanager.start(tasks);
240
241 final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
242 for (final TaskResult current : results) {
243 assertFalse(current instanceof ExceptionalTaskResult);
244 }
245 assertEquals(1, results.size());
246 }
247
248 }