View Javadoc
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  	 * Checks if 2 of the same classnames will through a error.
29  	 * 
30  	 * @throws InterruptedException
31  	 * @throws ExecutionException
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  	 * Checks if 2 of the same classnames will through a error if there in different groups (shouldnt).
67  	 * 
68  	 * @throws InterruptedException
69  	 * @throws ExecutionException
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 	 * checks wether 2 groupnames can have the same name.
104 	 * 
105 	 * @throws InterruptedException
106 	 * @throws ExecutionException
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 	 * checks wether a group can have the same name as a class.
142 	 * 
143 	 * @throws InterruptedException
144 	 * @throws ExecutionException
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 	 * checks whether a group can have the same name as a class when the class is in same group.
177 	 * 
178 	 * @throws InterruptedException
179 	 * @throws ExecutionException
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 	 * checks whether a group can have the same name as a class when the class is not in same group (shouldnt error).
213 	 * 
214 	 * @throws InterruptedException
215 	 * @throws ExecutionException
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 }