View Javadoc
1   package de.fhdw.wtf.parser.testWithScanner;
2   
3   import static org.junit.Assert.assertEquals;
4   import static org.junit.Assert.fail;
5   
6   import java.util.Vector;
7   
8   import org.junit.Before;
9   import org.junit.Test;
10  
11  import de.fhdw.wtf.common.ast.Attribute;
12  import de.fhdw.wtf.common.ast.AttributeModifier;
13  import de.fhdw.wtf.common.ast.AttributeModifierTransient;
14  import de.fhdw.wtf.common.ast.Constructor;
15  import de.fhdw.wtf.common.ast.Group;
16  import de.fhdw.wtf.common.ast.GroupElement;
17  import de.fhdw.wtf.common.ast.Model;
18  import de.fhdw.wtf.common.ast.Name;
19  import de.fhdw.wtf.common.ast.Operation;
20  import de.fhdw.wtf.common.ast.OperationModifier;
21  import de.fhdw.wtf.common.ast.OperationModifierAbstract;
22  import de.fhdw.wtf.common.ast.QualifiedName;
23  import de.fhdw.wtf.common.ast.UnqualifiedName;
24  import de.fhdw.wtf.common.ast.type.ByNameState;
25  import de.fhdw.wtf.common.ast.type.ClassModifier;
26  import de.fhdw.wtf.common.ast.type.ClassModifierAbstract;
27  import de.fhdw.wtf.common.ast.type.ClassModifierService;
28  import de.fhdw.wtf.common.ast.type.ClassModifierTransient;
29  import de.fhdw.wtf.common.ast.type.ClassModifierVisitable;
30  import de.fhdw.wtf.common.ast.type.ClassType;
31  import de.fhdw.wtf.common.ast.type.ExceptionClassType;
32  import de.fhdw.wtf.common.ast.type.ListType;
33  import de.fhdw.wtf.common.ast.type.MapType;
34  import de.fhdw.wtf.common.ast.type.ProductElementType;
35  import de.fhdw.wtf.common.ast.type.ProductType;
36  import de.fhdw.wtf.common.ast.type.RegularClassType;
37  import de.fhdw.wtf.common.ast.type.SumType;
38  import de.fhdw.wtf.common.ast.type.Type;
39  import de.fhdw.wtf.common.ast.type.TypeProxy;
40  import de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException;
41  import de.fhdw.wtf.common.stream.FilteredTokenStream;
42  import de.fhdw.wtf.common.stream.SimpleScannerInput;
43  import de.fhdw.wtf.common.stream.TokenStream;
44  import de.fhdw.wtf.common.token.IdentifierToken;
45  import de.fhdw.wtf.common.token.Position;
46  import de.fhdw.wtf.common.token.keywords.AbstractToken;
47  import de.fhdw.wtf.common.token.keywords.GroupToken;
48  import de.fhdw.wtf.common.token.keywords.ServiceToken;
49  import de.fhdw.wtf.common.token.keywords.TransientToken;
50  import de.fhdw.wtf.common.token.keywords.VisitableToken;
51  import de.fhdw.wtf.common.token.symbols.BracketOpenToken;
52  import de.fhdw.wtf.common.token.symbols.CurlyBracketOpenToken;
53  import de.fhdw.wtf.dsl.scanner.common.Scanner;
54  import de.fhdw.wtf.dsl.scanner.modelScanner.ModelDslScanner;
55  import de.fhdw.wtf.parser.Parser;
56  
57  /**
58   * Test the integration of scanner and parser.
59   */
60  public class TestParserScanner {
61  	
62  	private CurlyBracketOpenToken curlyBracketOpenToken;
63  	private BracketOpenToken bracketOpenToken;
64  	private AbstractToken abstractToken;
65  	
66  	/**
67  	 * Creates the most important Tokens.
68  	 * 
69  	 * @throws Exception
70  	 */
71  	@Before
72  	public void setUp() throws Exception {
73  		this.bracketOpenToken = BracketOpenToken.create(Position.create("", 1, 1, 0));
74  		this.curlyBracketOpenToken = CurlyBracketOpenToken.create(Position.create("", 1, 1, 0));
75  		this.abstractToken = AbstractToken.create(Position.create("", 1, 1, 0));
76  	}
77  	
78  	/**
79  	 * group : group = [ class : class = {op : [()->test];} service transient;]; .
80  	 * 
81  	 * @throws Exception
82  	 */
83  	@Test
84  	public void testSimpleClassOperation() throws Exception {
85  		final IdentifierToken classIdentifier = IdentifierToken.create("class1", Position.create("", 1, 1, 0));
86  		final IdentifierToken test = IdentifierToken.create("test", Position.create("", 1, 1, 0));
87  		final IdentifierToken op = IdentifierToken.create("op", Position.create("", 1, 1, 0));
88  		final IdentifierToken groupIdentifier = IdentifierToken.create("group1", Position.create("", 1, 1, 0));
89  		
90  		final SimpleScannerInput input =
91  				new SimpleScannerInput("group1 : group = [ class1 : class = {op : [[()->test]];} service transient;];");
92  		final TokenStream output = FilteredTokenStream.create();
93  		final Scanner scanner = ModelDslScanner.create();
94  		scanner.scan(input, output);
95  		final Parser parser = Parser.create(output);
96  		final Model model = parser.parse();
97  		
98  		final Vector<GroupElement> groupVector = new Vector<>();
99  		final Vector<Operation> operations = new Vector<>();
100 		final Vector<ClassModifier> modifiers = new Vector<>();
101 		
102 		final Name groupName = UnqualifiedName.create(groupIdentifier);
103 		final Group group = Group.create(groupName, groupVector, GroupToken.create(Position.create("", 1, 1, 0)));
104 		
105 		final Name className = groupName.addName(classIdentifier);
106 		final ClassType clazz =
107 				RegularClassType.create(
108 						className,
109 						modifiers,
110 						new Vector<Attribute>(),
111 						new Vector<Type>(),
112 						operations,
113 						new Vector<Constructor>(),
114 						classIdentifier,
115 						
116 						new Vector<ClassType>());
117 		
118 		final ProductType product = ProductType.create(this.bracketOpenToken);
119 		final ByNameState testByName = ByNameState.create(UnqualifiedName.create(test));
120 		final TypeProxy testTypeProxy = TypeProxy.create(test, testByName);
121 		
122 		final Operation operation =
123 				Operation.create("op", new Vector<OperationModifier>(), product, clazz, testTypeProxy, op);
124 		operations.add(operation);
125 		
126 		modifiers.add(ClassModifierService.create(ServiceToken.create(Position.create("", 1, 1, 0))));
127 		modifiers.add(ClassModifierTransient.create(TransientToken.create(Position.create("", 1, 1, 0))));
128 		groupVector.add(clazz);
129 		final Model expected = Model.create(groupIdentifier);
130 		expected.addGroup(group);
131 		assertEquals(expected, model);
132 	}
133 	
134 	/**
135 	 * group1 : group = [ class1 : class = {op : [(param:Integer)->test];} service transient;]; .
136 	 * 
137 	 * @throws Exception
138 	 */
139 	@Test
140 	public void testSimpleClassOperation2() throws Exception {
141 		final IdentifierToken classIdentifier = IdentifierToken.create("class1", Position.create("", 1, 1, 0));
142 		final IdentifierToken test = IdentifierToken.create("test", Position.create("", 1, 1, 0));
143 		final IdentifierToken op = IdentifierToken.create("op", Position.create("", 1, 1, 0));
144 		final IdentifierToken groupIdentifier = IdentifierToken.create("group1", Position.create("", 1, 1, 0));
145 		final IdentifierToken paramIdentifier = IdentifierToken.create("param", Position.create("", 1, 1, 0));
146 		final IdentifierToken integerIdentifier = IdentifierToken.create("Integer", Position.create("", 1, 1, 0));
147 		
148 		final SimpleScannerInput input =
149 				new SimpleScannerInput(
150 						"group1 : group = [ class1 : class = {op : [[(param:Integer)->test]];} service transient;];");
151 		final TokenStream output = FilteredTokenStream.create();
152 		final Scanner scanner = ModelDslScanner.create();
153 		scanner.scan(input, output);
154 		final Parser parser = Parser.create(output);
155 		final Model model = parser.parse();
156 		
157 		final Vector<GroupElement> groupVector = new Vector<>();
158 		final Vector<Operation> operations = new Vector<>();
159 		final Vector<ClassModifier> modifiers = new Vector<>();
160 		
161 		final Name groupName = UnqualifiedName.create(groupIdentifier);
162 		final Group group = Group.create(groupName, groupVector, GroupToken.create(Position.create("", 1, 1, 0)));
163 		
164 		final Name className = groupName.addName(classIdentifier);
165 		final ClassType clazz =
166 				RegularClassType.create(
167 						className,
168 						modifiers,
169 						new Vector<Attribute>(),
170 						new Vector<Type>(),
171 						operations,
172 						new Vector<Constructor>(),
173 						classIdentifier,
174 						
175 						new Vector<ClassType>());
176 		
177 		final ProductType product = ProductType.create(this.bracketOpenToken);
178 		final ByNameState integerByName = ByNameState.create(UnqualifiedName.create(integerIdentifier));
179 		final TypeProxy typeProxyInteger = TypeProxy.create(paramIdentifier, integerByName);
180 		final ProductElementType productElement = ProductElementType.create("param", typeProxyInteger, paramIdentifier);
181 		product.addElement(productElement);
182 		
183 		final ByNameState testByName = ByNameState.create(UnqualifiedName.create(test));
184 		final TypeProxy testTypeProxy = TypeProxy.create(test, testByName);
185 		
186 		final Operation operation =
187 				Operation.create("op", new Vector<OperationModifier>(), product, clazz, testTypeProxy, op);
188 		operations.add(operation);
189 		
190 		modifiers.add(ClassModifierService.create(ServiceToken.create(Position.create("", 1, 1, 0))));
191 		modifiers.add(ClassModifierTransient.create(TransientToken.create(Position.create("", 1, 1, 0))));
192 		groupVector.add(clazz);
193 		final Model expected = Model.create(groupIdentifier);
194 		expected.addGroup(group);
195 		assertEquals(expected, model);
196 	}
197 	
198 	/**
199 	 * group1 : group = [ class1 : class = {op : [(param1:Integer, param2:{Integer,String})->test] abstract;} service
200 	 * transient;]; .
201 	 * 
202 	 * @throws Exception
203 	 */
204 	@Test
205 	public void testSimpleClassOperation3() throws Exception {
206 		final IdentifierToken classIdentifier = IdentifierToken.create("class1", Position.create("", 1, 1, 0));
207 		final IdentifierToken test = IdentifierToken.create("test", Position.create("", 1, 1, 0));
208 		final IdentifierToken op = IdentifierToken.create("op", Position.create("", 1, 1, 0));
209 		final IdentifierToken groupIdentifier = IdentifierToken.create("group1", Position.create("", 1, 1, 0));
210 		final IdentifierToken param1Identifier = IdentifierToken.create("param1", Position.create("", 1, 1, 0));
211 		final IdentifierToken param2Identifier = IdentifierToken.create("param2", Position.create("", 1, 1, 0));
212 		final IdentifierToken integerIdentifier = IdentifierToken.create("Integer", Position.create("", 1, 1, 0));
213 		final IdentifierToken stringIdentifier = IdentifierToken.create("String", Position.create("", 1, 1, 0));
214 		
215 		final SimpleScannerInput input =
216 				new SimpleScannerInput(
217 						"group1 : group = [ class1 : class = {op : [[(param1:Integer, param2:{Integer,String})->test]] abstract;} service transient;];");
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 		
224 		final Vector<GroupElement> groupVector = new Vector<>();
225 		final Vector<Operation> operations = new Vector<>();
226 		final Vector<ClassModifier> modifiers = new Vector<>();
227 		
228 		final Name groupName = UnqualifiedName.create(groupIdentifier);
229 		final Group group = Group.create(groupName, groupVector, GroupToken.create(Position.create("", 1, 1, 0)));
230 		
231 		final Name className = groupName.addName(classIdentifier);
232 		final ClassType clazz =
233 				RegularClassType.create(
234 						className,
235 						modifiers,
236 						new Vector<Attribute>(),
237 						new Vector<Type>(),
238 						operations,
239 						new Vector<Constructor>(),
240 						classIdentifier,
241 						
242 						new Vector<ClassType>());
243 		
244 		final ProductType product = ProductType.create(this.bracketOpenToken);
245 		final ByNameState integerByName = ByNameState.create(UnqualifiedName.create(integerIdentifier));
246 		final TypeProxy typeProxyInteger = TypeProxy.create(param1Identifier, integerByName);
247 		final ProductElementType productElement1 =
248 				ProductElementType.create("param1", typeProxyInteger, param1Identifier);
249 		
250 		final ByNameState stringByName = ByNameState.create(UnqualifiedName.create(stringIdentifier));
251 		final TypeProxy typeProxyString = TypeProxy.create(param2Identifier, stringByName);
252 		
253 		final SumType sum = SumType.create(this.curlyBracketOpenToken);
254 		sum.add(typeProxyInteger);
255 		sum.add(typeProxyString);
256 		
257 		final ProductElementType productElement2 = ProductElementType.create("param2", sum, param2Identifier);
258 		
259 		product.addElement(productElement1);
260 		product.addElement(productElement2);
261 		
262 		final ByNameState testByName = ByNameState.create(UnqualifiedName.create(test));
263 		final TypeProxy testTypeProxy = TypeProxy.create(test, testByName);
264 		
265 		final Vector<OperationModifier> operationModifiers = new Vector<>();
266 		operationModifiers.add(OperationModifierAbstract.create(this.abstractToken));
267 		
268 		final Operation operation = Operation.create("op", operationModifiers, product, clazz, testTypeProxy, op);
269 		operations.add(operation);
270 		
271 		modifiers.add(ClassModifierService.create(ServiceToken.create(Position.create("", 1, 1, 0))));
272 		modifiers.add(ClassModifierTransient.create(TransientToken.create(Position.create("", 1, 1, 0))));
273 		groupVector.add(clazz);
274 		final Model expected = Model.create(groupIdentifier);
275 		expected.addGroup(group);
276 		assertEquals(expected, model);
277 	}
278 	
279 	/**
280 	 * group1 : group = [ class1 : class = {op1 : [(param1:Integer, param2:{Integer,String})->test] abstract; op2 :
281 	 * [(param1:Integer, param2:{Integer,String})->test] abstract;} service transient;]; .
282 	 * 
283 	 * @throws Exception
284 	 */
285 	@Test
286 	public void testSimpleClassOperation4() throws Exception {
287 		final IdentifierToken classIdentifier = IdentifierToken.create("class1", Position.create("", 1, 1, 0));
288 		final IdentifierToken test = IdentifierToken.create("test", Position.create("", 1, 1, 0));
289 		final IdentifierToken op1 = IdentifierToken.create("op1", Position.create("", 1, 1, 0));
290 		final IdentifierToken op2 = IdentifierToken.create("op2", Position.create("", 1, 1, 0));
291 		final IdentifierToken groupIdentifier = IdentifierToken.create("group1", Position.create("", 1, 1, 0));
292 		final IdentifierToken param1Identifier = IdentifierToken.create("param1", Position.create("", 1, 1, 0));
293 		final IdentifierToken param2Identifier = IdentifierToken.create("param2", Position.create("", 1, 1, 0));
294 		final IdentifierToken integerIdentifier = IdentifierToken.create("Integer", Position.create("", 1, 1, 0));
295 		final IdentifierToken stringIdentifier = IdentifierToken.create("String", Position.create("", 1, 1, 0));
296 		
297 		final SimpleScannerInput input =
298 				new SimpleScannerInput(
299 						"group1 : group = [ class1 : class = {op1 : [[(param1:Integer, param2:{Integer,String})->test]] abstract; op2 : [[(param1:Integer, param2:{Integer,String})->test]] abstract;} service transient;];");
300 		final TokenStream output = FilteredTokenStream.create();
301 		final Scanner scanner = ModelDslScanner.create();
302 		scanner.scan(input, output);
303 		final Parser parser = Parser.create(output);
304 		final Model model = parser.parse();
305 		
306 		final Vector<GroupElement> groupVector = new Vector<>();
307 		final Vector<Operation> operations = new Vector<>();
308 		final Vector<ClassModifier> modifiers = new Vector<>();
309 		
310 		final Name groupName = UnqualifiedName.create(groupIdentifier);
311 		final Group group = Group.create(groupName, groupVector, GroupToken.create(Position.create("", 1, 1, 0)));
312 		
313 		final Name className = groupName.addName(classIdentifier);
314 		final ClassType clazz =
315 				RegularClassType.create(
316 						className,
317 						modifiers,
318 						new Vector<Attribute>(),
319 						new Vector<Type>(),
320 						operations,
321 						new Vector<Constructor>(),
322 						classIdentifier,
323 						
324 						new Vector<ClassType>());
325 		
326 		final ProductType product = ProductType.create(this.bracketOpenToken);
327 		final ByNameState integerByName = ByNameState.create(UnqualifiedName.create(integerIdentifier));
328 		final TypeProxy typeProxyInteger = TypeProxy.create(param1Identifier, integerByName);
329 		final ProductElementType productElement1 =
330 				ProductElementType.create("param1", typeProxyInteger, param1Identifier);
331 		
332 		final ByNameState stringByName = ByNameState.create(UnqualifiedName.create(stringIdentifier));
333 		final TypeProxy typeProxyString = TypeProxy.create(param2Identifier, stringByName);
334 		
335 		final SumType sum = SumType.create(this.curlyBracketOpenToken);
336 		sum.add(typeProxyInteger);
337 		sum.add(typeProxyString);
338 		
339 		final ProductElementType productElement2 = ProductElementType.create("param2", sum, param2Identifier);
340 		
341 		product.addElement(productElement1);
342 		product.addElement(productElement2);
343 		
344 		final ByNameState testByName = ByNameState.create(UnqualifiedName.create(test));
345 		final TypeProxy testTypeProxy = TypeProxy.create(test, testByName);
346 		
347 		final Vector<OperationModifier> operationModifiers = new Vector<>();
348 		operationModifiers.add(OperationModifierAbstract.create(this.abstractToken));
349 		
350 		final Operation operation1 = Operation.create("op1", operationModifiers, product, clazz, testTypeProxy, op1);
351 		final Operation operation2 = Operation.create("op2", operationModifiers, product, clazz, testTypeProxy, op2);
352 		operations.add(operation1);
353 		operations.add(operation2);
354 		
355 		modifiers.add(ClassModifierService.create(ServiceToken.create(Position.create("", 1, 1, 0))));
356 		modifiers.add(ClassModifierTransient.create(TransientToken.create(Position.create("", 1, 1, 0))));
357 		groupVector.add(clazz);
358 		final Model expected = Model.create(groupIdentifier);
359 		expected.addGroup(group);
360 		assertEquals(expected, model);
361 	}
362 	
363 	/**
364 	 * group1 : group = [ class1 : class = {op1 : [(param1:Integer, param2:{})->test] abstract; op2 : [(param1:Integer,
365 	 * param2:{Integer,String})->test] abstract;} service transient;]; .
366 	 * 
367 	 * @throws Exception
368 	 */
369 	@Test
370 	public void testSimpleClassOperation5Empty() throws Exception {
371 		final IdentifierToken classIdentifier = IdentifierToken.create("class1", Position.create("", 1, 1, 0));
372 		final IdentifierToken test = IdentifierToken.create("test", Position.create("", 1, 1, 0));
373 		final IdentifierToken op1 = IdentifierToken.create("op1", Position.create("", 1, 1, 0));
374 		final IdentifierToken op2 = IdentifierToken.create("op2", Position.create("", 1, 1, 0));
375 		final IdentifierToken groupIdentifier = IdentifierToken.create("group1", Position.create("", 1, 1, 0));
376 		final IdentifierToken param1Identifier = IdentifierToken.create("param1", Position.create("", 1, 1, 0));
377 		final IdentifierToken param2Identifier = IdentifierToken.create("param2", Position.create("", 1, 1, 0));
378 		final IdentifierToken integerIdentifier = IdentifierToken.create("Integer", Position.create("", 1, 1, 0));
379 		final IdentifierToken stringIdentifier = IdentifierToken.create("String", Position.create("", 1, 1, 0));
380 		
381 		final SimpleScannerInput input =
382 				new SimpleScannerInput(
383 						"group1 : group = [ class1 : class = {op1 : [[(param1:Integer, param2:{})->test]] abstract; op2 : [[(param1:Integer, param2:{Integer,String})->test]] abstract;} service transient;];");
384 		final TokenStream output = FilteredTokenStream.create();
385 		final Scanner scanner = ModelDslScanner.create();
386 		scanner.scan(input, output);
387 		final Parser parser = Parser.create(output);
388 		final Model model = parser.parse();
389 		
390 		final Vector<GroupElement> groupVector = new Vector<>();
391 		final Vector<Operation> operations = new Vector<>();
392 		final Vector<ClassModifier> modifiers = new Vector<>();
393 		
394 		final Name groupName = UnqualifiedName.create(groupIdentifier);
395 		final Group group = Group.create(groupName, groupVector, GroupToken.create(Position.create("", 1, 1, 0)));
396 		
397 		final Name className = groupName.addName(classIdentifier);
398 		final ClassType clazz =
399 				RegularClassType.create(
400 						className,
401 						modifiers,
402 						new Vector<Attribute>(),
403 						new Vector<Type>(),
404 						operations,
405 						new Vector<Constructor>(),
406 						classIdentifier,
407 						
408 						new Vector<ClassType>());
409 		
410 		final ByNameState integerByName = ByNameState.create(UnqualifiedName.create(integerIdentifier));
411 		final TypeProxy typeProxyInteger = TypeProxy.create(param1Identifier, integerByName);
412 		
413 		final ByNameState stringByName = ByNameState.create(UnqualifiedName.create(stringIdentifier));
414 		final TypeProxy typeProxyString = TypeProxy.create(param2Identifier, stringByName);
415 		
416 		final ByNameState testByName = ByNameState.create(UnqualifiedName.create(test));
417 		final TypeProxy testTypeProxy = TypeProxy.create(test, testByName);
418 		
419 		final ProductType product1 = ProductType.create(this.bracketOpenToken);
420 		final ProductElementType productElement1 =
421 				ProductElementType.create("param1", typeProxyInteger, param1Identifier);
422 		final SumType sum = SumType.create(this.curlyBracketOpenToken);
423 		final ProductElementType productElement2 = ProductElementType.create("param2", sum, param2Identifier);
424 		product1.addElement(productElement1);
425 		product1.addElement(productElement2);
426 		
427 		final Vector<OperationModifier> operationModifiers = new Vector<>();
428 		operationModifiers.add(OperationModifierAbstract.create(this.abstractToken));
429 		
430 		final Operation operation1 = Operation.create("op1", operationModifiers, product1, clazz, testTypeProxy, op1);
431 		
432 		final ProductType product2 = ProductType.create(this.bracketOpenToken);
433 		product2.addElement(productElement1);
434 		
435 		final SumType sum2 = SumType.create(this.curlyBracketOpenToken);
436 		sum2.add(typeProxyInteger);
437 		sum2.add(typeProxyString);
438 		
439 		final ProductElementType productElement3 = ProductElementType.create("param2", sum2, param2Identifier);
440 		product2.addElement(productElement3);
441 		final Operation operation2 = Operation.create("op2", operationModifiers, product2, clazz, testTypeProxy, op2);
442 		operations.add(operation1);
443 		operations.add(operation2);
444 		
445 		modifiers.add(ClassModifierService.create(ServiceToken.create(Position.create("", 1, 1, 0))));
446 		modifiers.add(ClassModifierTransient.create(TransientToken.create(Position.create("", 1, 1, 0))));
447 		groupVector.add(clazz);
448 		final Model expected = Model.create(groupIdentifier);
449 		expected.addGroup(group);
450 		assertEquals(expected, model);
451 	}
452 	
453 	/**
454 	 * group1 : group = [ class1 : class = {map : [String->Integer];} visitable abstract;]; .
455 	 * 
456 	 * @throws Exception
457 	 */
458 	@Test
459 	public void testModifierVisitable() throws Exception {
460 		final IdentifierToken classIdentifier = IdentifierToken.create("class1", Position.create("", 1, 1, 0));
461 		final IdentifierToken groupIdentifier = IdentifierToken.create("group1", Position.create("", 1, 1, 0));
462 		final IdentifierToken mapIdentifier = IdentifierToken.create("map", Position.create("", 1, 1, 0));
463 		final IdentifierToken integerIdentifier = IdentifierToken.create("Integer", Position.create("", 1, 1, 0));
464 		final IdentifierToken stringIdentifier = IdentifierToken.create("String", Position.create("", 1, 1, 0));
465 		
466 		final SimpleScannerInput input =
467 				new SimpleScannerInput(
468 						"group1 : group = [ class1 : class = {map : [String->Integer];} visitable abstract;];");
469 		final TokenStream output = FilteredTokenStream.create();
470 		final Scanner scanner = ModelDslScanner.create();
471 		scanner.scan(input, output);
472 		final Parser parser = Parser.create(output);
473 		final Model model = parser.parse();
474 		
475 		final Vector<GroupElement> groupVector = new Vector<>();
476 		final Vector<Attribute> attributes = new Vector<>();
477 		final Vector<ClassModifier> modifiers = new Vector<>();
478 		
479 		final Name groupName = UnqualifiedName.create(groupIdentifier);
480 		final Group group = Group.create(groupName, groupVector, GroupToken.create(Position.create("", 1, 1, 0)));
481 		
482 		final Name className = groupName.addName(classIdentifier);
483 		final ClassType clazz =
484 				RegularClassType.create(
485 						className,
486 						modifiers,
487 						attributes,
488 						new Vector<Type>(),
489 						new Vector<Operation>(),
490 						new Vector<Constructor>(),
491 						classIdentifier,
492 						
493 						new Vector<ClassType>());
494 		
495 		final ByNameState integerByName = ByNameState.create(UnqualifiedName.create(integerIdentifier));
496 		final TypeProxy typeProxyInteger = TypeProxy.create(integerIdentifier, integerByName);
497 		
498 		final ByNameState stringByName = ByNameState.create(UnqualifiedName.create(stringIdentifier));
499 		final TypeProxy typeProxyString = TypeProxy.create(stringIdentifier, stringByName);
500 		final MapType map = MapType.create(mapIdentifier, typeProxyString, typeProxyInteger);
501 		
502 		final Attribute attribute = Attribute.create("map", map, new Vector<AttributeModifier>(), mapIdentifier);
503 		attributes.add(attribute);
504 		
505 		modifiers.add(ClassModifierVisitable.create(VisitableToken.create(Position.create("", 1, 1, 0))));
506 		modifiers.add(ClassModifierAbstract.create(AbstractToken.create(Position.create("", 1, 1, 0))));
507 		groupVector.add(clazz);
508 		final Model expected = Model.create(groupIdentifier);
509 		expected.addGroup(group);
510 		assertEquals(expected, model);
511 	}
512 	
513 	/**
514 	 * group1 : group=[group2:group=[class1:class={};class2:class={};];]; .
515 	 * 
516 	 * @throws Exception
517 	 */
518 	@Test
519 	public void testParserAfterScanner() throws Exception {
520 		final IdentifierToken class1Identifier = IdentifierToken.create("class1", Position.create("", 1, 1, 0));
521 		final IdentifierToken group1Identifier = IdentifierToken.create("group1", Position.create("", 1, 1, 0));
522 		final IdentifierToken class2Identifier = IdentifierToken.create("class2", Position.create("", 1, 1, 0));
523 		final IdentifierToken group2Identifier = IdentifierToken.create("group2", Position.create("", 1, 1, 0));
524 		
525 		final SimpleScannerInput input =
526 				new SimpleScannerInput("group1 : group=[group2:group=[class1:class={};class2:class={};];];");
527 		final TokenStream output = FilteredTokenStream.create();
528 		final Scanner scanner = ModelDslScanner.create();
529 		scanner.scan(input, output);
530 		final Parser parser = Parser.create(output);
531 		final Model model = parser.parse();
532 		
533 		final Vector<GroupElement> group1Vector = new Vector<>();
534 		final Vector<GroupElement> group2Vector = new Vector<>();
535 		
536 		final UnqualifiedName group1Name = UnqualifiedName.create(group1Identifier);
537 		final Group group1 = Group.create(group1Name, group1Vector, GroupToken.create(Position.create("", 1, 1, 0)));
538 		final Name group2Name = QualifiedName.create(group1Name, UnqualifiedName.create(group2Identifier));
539 		final Group group2 = Group.create(group2Name, group2Vector, GroupToken.create(Position.create("", 1, 1, 0)));
540 		group1Vector.add(group2);
541 		
542 		final Name class1Name = group2Name.addName(class1Identifier);
543 		final Name class2Name = group2Name.addName(class2Identifier);
544 		final ClassType clazz1 =
545 				RegularClassType.create(
546 						class1Name,
547 						new Vector<ClassModifier>(),
548 						new Vector<Attribute>(),
549 						new Vector<Type>(),
550 						new Vector<Operation>(),
551 						new Vector<Constructor>(),
552 						class1Identifier,
553 						
554 						new Vector<ClassType>());
555 		final ClassType clazz2 =
556 				RegularClassType.create(
557 						class2Name,
558 						new Vector<ClassModifier>(),
559 						new Vector<Attribute>(),
560 						new Vector<Type>(),
561 						new Vector<Operation>(),
562 						new Vector<Constructor>(),
563 						class2Identifier,
564 						
565 						new Vector<ClassType>());
566 		
567 		group2Vector.add(clazz1);
568 		group2Vector.add(clazz2);
569 		final Model expected = Model.create(group1Identifier);
570 		expected.addGroup(group1);
571 		assertEquals(expected, model);
572 	}
573 	
574 	/**
575 	 * group1 : group = [ class1 : class = {} abstract abstract abstract ; ] ; .
576 	 * 
577 	 * @throws Exception
578 	 */
579 	@Test
580 	public void testMultipleSameClassModifier() throws Exception {
581 		final SimpleScannerInput input =
582 				new SimpleScannerInput("group1 : group = [ class1 : class = {} abstract abstract abstract ; ] ; ");
583 		final TokenStream output = FilteredTokenStream.create();
584 		final Scanner scanner = ModelDslScanner.create();
585 		scanner.scan(input, output);
586 		final Parser parser = Parser.create(output);
587 		try {
588 			parser.parse();
589 			fail();
590 		} catch (final NoValidTokenStreamException e) {
591 			assertEquals(2, parser.getExceptions().size());
592 		}
593 	}
594 	
595 	/**
596 	 * group1 : group = [ someexception : exception = {};]; .
597 	 * 
598 	 * @throws Exception
599 	 */
600 	@Test
601 	public void testSimpleException() throws Exception {
602 		final IdentifierToken someexceptionIdentifier =
603 				IdentifierToken.create("someexception", Position.create("", 1, 1, 0));
604 		final IdentifierToken groupIdentifier = IdentifierToken.create("group1", Position.create("", 1, 1, 0));
605 		
606 		final SimpleScannerInput input = new SimpleScannerInput("group1 : group = [ someexception : exception = {};];");
607 		final TokenStream output = FilteredTokenStream.create();
608 		final Scanner scanner = ModelDslScanner.create();
609 		scanner.scan(input, output);
610 		final Parser parser = Parser.create(output);
611 		final Model model = parser.parse();
612 		
613 		final Vector<GroupElement> groupVector = new Vector<>();
614 		
615 		final UnqualifiedName groupName = UnqualifiedName.create(groupIdentifier);
616 		final Group group = Group.create(groupName, groupVector, GroupToken.create(Position.create("", 1, 1, 0)));
617 		
618 		final Name className = groupName.addName(someexceptionIdentifier);
619 		final ClassType clazz =
620 				ExceptionClassType.create(
621 						className,
622 						new Vector<ClassModifier>(),
623 						new Vector<Attribute>(),
624 						new Vector<Type>(),
625 						new Vector<Operation>(),
626 						new Vector<Constructor>(),
627 						someexceptionIdentifier,
628 						new Vector<ClassType>());
629 		
630 		groupVector.add(clazz);
631 		final Model expected = Model.create(groupIdentifier);
632 		expected.addGroup(group);
633 		assertEquals(expected, model);
634 	}
635 	
636 	/**
637 	 * group1 : group = [ class1 : class = {att1 : Integer transient;} service transient;]; .
638 	 * 
639 	 * @throws Exception
640 	 */
641 	@Test
642 	public void testFindableServiceTransientModifier() throws Exception {
643 		final IdentifierToken classIdentifier = IdentifierToken.create("class1", Position.create("", 1, 1, 0));
644 		final IdentifierToken groupIdentifier = IdentifierToken.create("group1", Position.create("", 1, 1, 0));
645 		final IdentifierToken integerIdentifier = IdentifierToken.create("Integer", Position.create("", 1, 1, 0));
646 		final IdentifierToken attributeIdentifier = IdentifierToken.create("att1", Position.create("", 1, 1, 0));
647 		
648 		final SimpleScannerInput input =
649 				new SimpleScannerInput(
650 						"group1 : group = [ class1 : class = {att1 : Integer transient;} service transient;];");
651 		final TokenStream output = FilteredTokenStream.create();
652 		final Scanner scanner = ModelDslScanner.create();
653 		scanner.scan(input, output);
654 		final Parser parser = Parser.create(output);
655 		final Model model = parser.parse();
656 		
657 		final Vector<GroupElement> groupVector = new Vector<>();
658 		final Vector<Attribute> attributes = new Vector<>();
659 		final Vector<ClassModifier> classModifiers = new Vector<>();
660 		
661 		final Name groupName = UnqualifiedName.create(groupIdentifier);
662 		final Group group = Group.create(groupName, groupVector, GroupToken.create(Position.create("", 1, 1, 0)));
663 		
664 		final Name className = groupName.addName(classIdentifier);
665 		final ClassType clazz =
666 				RegularClassType.create(
667 						className,
668 						classModifiers,
669 						attributes,
670 						new Vector<Type>(),
671 						new Vector<Operation>(),
672 						new Vector<Constructor>(),
673 						classIdentifier,
674 						
675 						new Vector<ClassType>());
676 		
677 		final ByNameState integerByName = ByNameState.create(UnqualifiedName.create(integerIdentifier));
678 		final TypeProxy typeProxyInteger = TypeProxy.create(integerIdentifier, integerByName);
679 		final Vector<AttributeModifier> attributeModifiers = new Vector<>();
680 		attributeModifiers.add(AttributeModifierTransient.create(TransientToken.create(Position.create("", 1, 1, 0))));
681 		
682 		final Attribute attribute = Attribute.create("att1", typeProxyInteger, attributeModifiers, attributeIdentifier);
683 		attributes.add(attribute);
684 		
685 		classModifiers.add(ClassModifierService.create(ServiceToken.create(Position.create("", 1, 1, 0))));
686 		classModifiers.add(ClassModifierTransient.create(TransientToken.create(Position.create("", 1, 1, 0))));
687 		groupVector.add(clazz);
688 		final Model expected = Model.create(groupIdentifier);
689 		expected.addGroup(group);
690 		assertEquals(expected, model);
691 	}
692 	
693 	/**
694 	 * group1 : group = [ class1 : class = {attribute : [Integer -> [Integer -> [Integer -> Integer*] ] ];} service
695 	 * transient;]; .
696 	 * 
697 	 * @throws Exception
698 	 */
699 	@Test
700 	public void testSimpleHashMap() throws Exception {
701 		final IdentifierToken classIdentifier = IdentifierToken.create("class1", Position.create("", 1, 1, 0));
702 		final IdentifierToken groupIdentifier = IdentifierToken.create("group1", Position.create("", 1, 1, 0));
703 		final IdentifierToken attributeIdentifier = IdentifierToken.create("attribute", Position.create("", 1, 1, 0));
704 		final IdentifierToken integerIdentifier = IdentifierToken.create("Integer", Position.create("", 1, 1, 0));
705 		
706 		final SimpleScannerInput input =
707 				new SimpleScannerInput(
708 						"group1 : group = [ class1 : class = {attribute : [Integer -> [Integer -> [Integer -> Integer*] ] ];} service transient;];");
709 		final TokenStream output = FilteredTokenStream.create();
710 		final Scanner scanner = ModelDslScanner.create();
711 		scanner.scan(input, output);
712 		final Parser parser = Parser.create(output);
713 		final Model model = parser.parse();
714 		
715 		final Vector<GroupElement> groupVector = new Vector<>();
716 		final Vector<Attribute> attributes = new Vector<>();
717 		final Vector<ClassModifier> modifiers = new Vector<>();
718 		
719 		final Name groupName = UnqualifiedName.create(groupIdentifier);
720 		final Group group = Group.create(groupName, groupVector, GroupToken.create(Position.create("", 1, 1, 0)));
721 		
722 		final Name className = groupName.addName(classIdentifier);
723 		final ClassType clazz =
724 				RegularClassType.create(
725 						className,
726 						modifiers,
727 						attributes,
728 						new Vector<Type>(),
729 						new Vector<Operation>(),
730 						new Vector<Constructor>(),
731 						classIdentifier,
732 						
733 						new Vector<ClassType>());
734 		
735 		final ByNameState integerByName = ByNameState.create(UnqualifiedName.create(integerIdentifier));
736 		final TypeProxy typeProxyInteger = TypeProxy.create(integerIdentifier, integerByName);
737 		
738 		final ListType list = ListType.create(integerIdentifier, typeProxyInteger);
739 		final MapType map1 = MapType.create(integerIdentifier, typeProxyInteger, list);
740 		final MapType map2 = MapType.create(integerIdentifier, typeProxyInteger, map1);
741 		final MapType map3 = MapType.create(integerIdentifier, typeProxyInteger, map2);
742 		
743 		final Attribute attribute =
744 				Attribute.create("attribute", map3, new Vector<AttributeModifier>(), attributeIdentifier);
745 		attributes.add(attribute);
746 		
747 		modifiers.add(ClassModifierService.create(ServiceToken.create(Position.create("", 1, 1, 0))));
748 		modifiers.add(ClassModifierTransient.create(TransientToken.create(Position.create("", 1, 1, 0))));
749 		groupVector.add(clazz);
750 		final Model expected = Model.create(groupIdentifier);
751 		expected.addGroup(group);
752 		assertEquals(expected, model);
753 	}
754 }