View Javadoc
1   package de.fhdw.wtf.parser.test;
2   
3   import java.util.Iterator;
4   
5   import junit.framework.TestCase;
6   
7   import org.junit.Test;
8   
9   import de.fhdw.wtf.common.ast.Attribute;
10  import de.fhdw.wtf.common.ast.AttributeModifier;
11  import de.fhdw.wtf.common.ast.Group;
12  import de.fhdw.wtf.common.ast.GroupElement;
13  import de.fhdw.wtf.common.ast.Model;
14  import de.fhdw.wtf.common.ast.Name;
15  import de.fhdw.wtf.common.ast.Operation;
16  import de.fhdw.wtf.common.ast.UnqualifiedName;
17  import de.fhdw.wtf.common.ast.type.ClassType;
18  import de.fhdw.wtf.common.ast.type.ListType;
19  import de.fhdw.wtf.common.ast.type.MapType;
20  import de.fhdw.wtf.common.ast.type.ProductElementType;
21  import de.fhdw.wtf.common.ast.type.ProductType;
22  import de.fhdw.wtf.common.ast.type.Type;
23  import de.fhdw.wtf.common.ast.visitor.GroupElementReturnVisitor;
24  import de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException;
25  import de.fhdw.wtf.common.stream.FilteredTokenStream;
26  import de.fhdw.wtf.common.stream.SimpleScannerInput;
27  import de.fhdw.wtf.common.token.EndToken;
28  import de.fhdw.wtf.common.token.IdentifierToken;
29  import de.fhdw.wtf.common.token.Position;
30  import de.fhdw.wtf.common.token.Token;
31  import de.fhdw.wtf.common.token.keywords.FindableToken;
32  import de.fhdw.wtf.common.token.symbols.ArrowToken;
33  import de.fhdw.wtf.common.token.symbols.AsteriskToken;
34  import de.fhdw.wtf.common.token.symbols.BracketCloseToken;
35  import de.fhdw.wtf.common.token.symbols.BracketOpenToken;
36  import de.fhdw.wtf.common.token.symbols.ColonToken;
37  import de.fhdw.wtf.common.token.symbols.CurlyBracketCloseToken;
38  import de.fhdw.wtf.common.token.symbols.PlusSymbolToken;
39  import de.fhdw.wtf.common.token.symbols.SemicolonToken;
40  import de.fhdw.wtf.common.token.symbols.SquareBracketCloseToken;
41  import de.fhdw.wtf.common.token.symbols.SquareBracketOpenToken;
42  import de.fhdw.wtf.dsl.scanner.common.Scanner;
43  import de.fhdw.wtf.dsl.scanner.modelScanner.ModelDslScanner;
44  import de.fhdw.wtf.parser.Parser;
45  
46  /**
47   * Tests the positions of First- and LastToken.
48   */
49  public class TestGetFirstAndLastToken extends TestCase {
50  	
51  	/**
52  	 * gruppenName:group=[]; .
53  	 * 
54  	 * @throws NoValidTokenStreamException
55  	 */
56  	@Test
57  	public void testSimpleGroup() throws NoValidTokenStreamException {
58  		final SimpleScannerInput input = new SimpleScannerInput("gruppenName:group=[];");
59  		final FilteredTokenStream scannerOutput = FilteredTokenStream.create();
60  		final Scanner scanner = ModelDslScanner.create();
61  		scanner.scan(input, scannerOutput);
62  		final Parser parser = Parser.create(scannerOutput);
63  		final Model result = parser.parse();
64  		
65  		// Model
66  		final Token expectedFirstToken = IdentifierToken.create("gruppenName", Position.create("", 0 + 1, 0 + 1, 0));
67  		Token expectedLastToken = EndToken.create(Position.create("", 0 + 1, 21 + 1, 21));
68  		
69  		assertEquals(expectedFirstToken, result.getFirstToken());
70  		assertEquals(expectedLastToken, result.getLastToken());
71  		
72  		// Gruppe
73  		final Iterator<Group> iterator = result.getGroups().iterator();
74  		final Group group = iterator.next();
75  		expectedLastToken = EndToken.create(Position.create("", 0 + 1, 21 + 1, 21));
76  		assertEquals(expectedFirstToken, group.getFirstToken());
77  		assertEquals(expectedLastToken, group.getLastToken());
78  		
79  		// Gruppenname
80  		final Name name = group.getName();
81  		assertEquals(expectedFirstToken, name.getFirstToken());
82  		expectedLastToken = ColonToken.create(Position.create("", 0 + 1, 11 + 1, 11));
83  		assertEquals(expectedLastToken, name.getLastToken());
84  	}
85  	
86  	/**
87  	 * gruppenName:group=[klassenName:class={};]; .
88  	 * 
89  	 * @throws Exception
90  	 */
91  	@Test
92  	public void testSimpleClass() throws Exception {
93  		final SimpleScannerInput input = new SimpleScannerInput("gruppenName:group=[klassenName:class={};];");
94  		final FilteredTokenStream scannerOutput = FilteredTokenStream.create();
95  		final Scanner scanner = ModelDslScanner.create();
96  		scanner.scan(input, scannerOutput);
97  		final Parser parser = Parser.create(scannerOutput);
98  		final Model result = parser.parse();
99  		
100 		// Model
101 		Token expectedFirstToken = IdentifierToken.create("gruppenName", Position.create("", 0 + 1, 0 + 1, 0));
102 		Token expectedLastToken = EndToken.create(Position.create("", 0 + 1, 42 + 1, 42));
103 		
104 		assertEquals(expectedFirstToken, result.getFirstToken());
105 		assertEquals(expectedLastToken, result.getLastToken());
106 		
107 		// Gruppe
108 		final Iterator<Group> iterator = result.getGroups().iterator();
109 		final Group group = iterator.next();
110 		expectedLastToken = EndToken.create(Position.create("", 0 + 1, 42 + 1, 42));
111 		assertEquals(expectedFirstToken, group.getFirstToken());
112 		assertEquals(expectedLastToken, group.getLastToken());
113 		
114 		// Gruppenname
115 		Name name = group.getName();
116 		assertEquals(expectedFirstToken, name.getFirstToken());
117 		expectedLastToken = ColonToken.create(Position.create("", 0 + 1, 11 + 1, 11));
118 		assertEquals(expectedLastToken, name.getLastToken());
119 		
120 		// Klasse
121 		final Iterator<GroupElement> iterator2 = group.getGroupElements().iterator();
122 		final GroupElement groupElement = iterator2.next();
123 		final ClassType class1 = groupElement.accept(new GroupElementReturnVisitor<ClassType>() {
124 			
125 			@Override
126 			public ClassType handle(final Group group) {
127 				fail();
128 				return null;
129 			}
130 			
131 			@Override
132 			public ClassType handle(final ClassType clss) {
133 				return clss;
134 			}
135 		});
136 		
137 		expectedFirstToken = IdentifierToken.create("klassenName", Position.create("", 0 + 1, 19 + 1, 19));
138 		expectedLastToken = SquareBracketCloseToken.create(Position.create("", 0 + 1, 40 + 1, 40));
139 		
140 		assertEquals(expectedFirstToken, class1.getFirstToken());
141 		assertEquals(expectedLastToken, class1.getLastToken());
142 		
143 		// Klassenname
144 		name = class1.getName();
145 		
146 		// klassenName
147 		final UnqualifiedName lastAddedName = name.getLastAddedName();
148 		expectedFirstToken = IdentifierToken.create("klassenName", Position.create("", 0 + 1, 19 + 1, 19));
149 		expectedLastToken = ColonToken.create(Position.create("", 0 + 1, 30 + 1, 30));
150 		assertEquals(expectedFirstToken, lastAddedName.getFirstToken());
151 		assertEquals(expectedLastToken, lastAddedName.getLastToken());
152 		
153 		// gruppenName>klassenName
154 		expectedFirstToken = IdentifierToken.create("klassenName", Position.create("", 0 + 1, 19 + 1, 19)); // bleibt
155 																											// der
156 																											// klassenname,
157 																											// nicht
158 																											// der
159 																											// gruppenname
160 																											// -
161 																											// in
162 																											// absprache
163 																											// mit
164 																											// CS
165 		expectedLastToken = ColonToken.create(Position.create("", 0 + 1, 30 + 1, 30));
166 		assertEquals(expectedFirstToken, name.getFirstToken());
167 		assertEquals(expectedLastToken, name.getLastToken());
168 	}
169 	
170 	/**
171 	 * Group1:group=[Group2:group=[Group3:group=[];];]; .
172 	 * 
173 	 * @throws NoValidTokenStreamException
174 	 */
175 	@Test
176 	public void testThreeGroups() throws NoValidTokenStreamException {
177 		final SimpleScannerInput input = new SimpleScannerInput("Group1:group=[Group2:group=[Group3:group=[];];];");
178 		final FilteredTokenStream scannerOutput = FilteredTokenStream.create();
179 		final Scanner scanner = ModelDslScanner.create();
180 		scanner.scan(input, scannerOutput);
181 		final Parser parser = Parser.create(scannerOutput);
182 		final Model result = parser.parse();
183 		
184 		// Model
185 		Token expectedFirstToken = IdentifierToken.create("Group1", Position.create("", 0 + 1, 0 + 1, 0));
186 		Token expectedLastToken = EndToken.create(Position.create("", 0 + 1, 48 + 1, 48));
187 		
188 		assertEquals(expectedFirstToken, result.getFirstToken());
189 		assertEquals(expectedLastToken, result.getLastToken());
190 		
191 		// Gruppe Group1
192 		final Iterator<Group> iterator = result.getGroups().iterator();
193 		final Group group = iterator.next();
194 		
195 		expectedLastToken = EndToken.create(Position.create("", 0 + 1, 48 + 1, 48));
196 		
197 		assertEquals(expectedFirstToken, group.getFirstToken());
198 		assertEquals(expectedLastToken, group.getLastToken());
199 		
200 		// Gruppenname
201 		Name name = group.getName();
202 		assertEquals(expectedFirstToken, name.getFirstToken());
203 		expectedLastToken = ColonToken.create(Position.create("", 0 + 1, 6 + 1, 6));
204 		assertEquals(expectedLastToken, name.getLastToken());
205 		
206 		// Gruppe Group2
207 		final Iterator<GroupElement> iterator2 = group.getGroupElements().iterator();
208 		final Group group2 = iterator2.next().accept(new GroupElementReturnVisitor<Group>() {
209 			
210 			@Override
211 			public Group handle(final Group group) {
212 				return group;
213 			}
214 			
215 			@Override
216 			public Group handle(final ClassType clss) {
217 				fail();
218 				return null;
219 			}
220 		});
221 		
222 		expectedFirstToken = IdentifierToken.create("Group2", Position.create("", 0 + 1, 14 + 1, 14));
223 		expectedLastToken = SquareBracketCloseToken.create(Position.create("", 0 + 1, 46 + 1, 46));
224 		assertEquals(expectedFirstToken, group2.getFirstToken());
225 		assertEquals(expectedLastToken, group2.getLastToken());
226 		
227 		// Gruppenname
228 		name = group2.getName();
229 		assertEquals(expectedFirstToken, name.getFirstToken());
230 		expectedLastToken = ColonToken.create(Position.create("", 0 + 1, 20 + 1, 20));
231 		assertEquals(expectedLastToken, name.getLastToken());
232 		
233 		// Gruppe Group3
234 		final Iterator<GroupElement> iterator3 = group2.getGroupElements().iterator();
235 		final Group group3 = iterator3.next().accept(new GroupElementReturnVisitor<Group>() {
236 			
237 			@Override
238 			public Group handle(final Group group) {
239 				return group;
240 			}
241 			
242 			@Override
243 			public Group handle(final ClassType clss) {
244 				fail();
245 				return null;
246 			}
247 		});
248 		
249 		expectedFirstToken = IdentifierToken.create("Group3", Position.create("", 0 + 1, 28 + 1, 28));
250 		expectedLastToken = SquareBracketCloseToken.create(Position.create("", 0 + 1, 44 + 1, 44));
251 		assertEquals(expectedFirstToken, group3.getFirstToken());
252 		assertEquals(expectedLastToken, group3.getLastToken());
253 		
254 		// Gruppenname
255 		name = group3.getName();
256 		assertEquals(expectedFirstToken, name.getFirstToken());
257 		expectedLastToken = ColonToken.create(Position.create("", 0 + 1, 34 + 1, 34));
258 		assertEquals(expectedLastToken, name.getLastToken());
259 		
260 	}
261 	
262 	/**
263 	 * Group1:group=[Superclass:class={};];Group2:group=[Class:class=Superclass+ {};]; .
264 	 * 
265 	 * @throws Exception
266 	 */
267 	@Test
268 	public void testClassWithHierarchy() throws Exception {
269 		final SimpleScannerInput input =
270 				new SimpleScannerInput("Group1:group=[Superclass:class={};];Group2:group=[Class:class=Superclass+{};];");
271 		final FilteredTokenStream scannerOutput = FilteredTokenStream.create();
272 		final Scanner scanner = ModelDslScanner.create();
273 		scanner.scan(input, scannerOutput);
274 		final Parser parser = Parser.create(scannerOutput);
275 		final Model result = parser.parse();
276 		
277 		// Model
278 		Token expectedFirstToken = IdentifierToken.create("Group1", Position.create("", 0 + 1, 0 + 1, 0));
279 		Token expectedLastToken = EndToken.create(Position.create("", 0 + 1, 78 + 1, 78));
280 		
281 		assertEquals(expectedFirstToken, result.getFirstToken());
282 		assertEquals(expectedLastToken, result.getLastToken());
283 		
284 		// Gruppe Group1
285 		final Iterator<Group> iterator = result.getGroups().iterator();
286 		final Group group = iterator.next();
287 		
288 		expectedLastToken = IdentifierToken.create("Group2", Position.create("", 0 + 1, 36 + 1, 36));
289 		
290 		assertEquals(expectedFirstToken, group.getFirstToken());
291 		assertEquals(expectedLastToken, group.getLastToken());
292 		
293 		// Gruppenname
294 		Name name = group.getName();
295 		assertEquals(expectedFirstToken, name.getFirstToken());
296 		expectedLastToken = ColonToken.create(Position.create("", 0 + 1, 6 + 1, 6));
297 		assertEquals(expectedLastToken, name.getLastToken());
298 		
299 		// Gruppe Group2
300 		final Group group2 = iterator.next();
301 		
302 		expectedFirstToken = IdentifierToken.create("Group2", Position.create("", 0 + 1, 36 + 1, 36));
303 		expectedLastToken = EndToken.create(Position.create("", 0 + 1, 78 + 1, 78));
304 		
305 		assertEquals(expectedFirstToken, group2.getFirstToken());
306 		assertEquals(expectedLastToken, group2.getLastToken());
307 		
308 		// Gruppenname
309 		name = group2.getName();
310 		assertEquals(expectedFirstToken, name.getFirstToken());
311 		expectedLastToken = ColonToken.create(Position.create("", 0 + 1, 42 + 1, 42));
312 		assertEquals(expectedLastToken, name.getLastToken());
313 		
314 		// Klasse Superclass
315 		final Iterator<GroupElement> iterator2 = group.getGroupElements().iterator();
316 		final GroupElement groupElement = iterator2.next();
317 		final ClassType class1 = groupElement.accept(new GroupElementReturnVisitor<ClassType>() {
318 			
319 			@Override
320 			public ClassType handle(final Group group) {
321 				fail();
322 				return null;
323 			}
324 			
325 			@Override
326 			public ClassType handle(final ClassType clss) {
327 				return clss;
328 			}
329 		});
330 		
331 		expectedFirstToken = IdentifierToken.create("Superclass", Position.create("", 0 + 1, 14 + 1, 14));
332 		expectedLastToken = SquareBracketCloseToken.create(Position.create("", 0 + 1, 34 + 1, 34));
333 		
334 		assertEquals(expectedFirstToken, class1.getFirstToken());
335 		assertEquals(expectedLastToken, class1.getLastToken());
336 		
337 		// Klassenname
338 		name = class1.getName();
339 		
340 		// klassenName
341 		UnqualifiedName lastAddedName = name.getLastAddedName();
342 		expectedFirstToken = IdentifierToken.create("Superclass", Position.create("", 0 + 1, 14 + 1, 14));
343 		assertEquals(expectedFirstToken, lastAddedName.getFirstToken());
344 		expectedLastToken = ColonToken.create(Position.create("", 0 + 1, 24 + 1, 24));
345 		assertEquals(expectedLastToken, lastAddedName.getLastToken());
346 		
347 		// Klasse Class
348 		final Iterator<GroupElement> iterator3 = group2.getGroupElements().iterator();
349 		final GroupElement groupElement2 = iterator3.next();
350 		final ClassType class2 = groupElement2.accept(new GroupElementReturnVisitor<ClassType>() {
351 			
352 			@Override
353 			public ClassType handle(final Group group) {
354 				fail();
355 				return null;
356 			}
357 			
358 			@Override
359 			public ClassType handle(final ClassType clss) {
360 				return clss;
361 			}
362 		});
363 		
364 		expectedFirstToken = IdentifierToken.create("Class", Position.create("", 0 + 1, 50 + 1, 50));
365 		expectedLastToken = SquareBracketCloseToken.create(Position.create("", 0 + 1, 76 + 1, 76));
366 		
367 		assertEquals(expectedFirstToken, class2.getFirstToken());
368 		assertEquals(expectedLastToken, class2.getLastToken());
369 		
370 		// Klassenname
371 		name = class2.getName();
372 		
373 		// klassenName
374 		lastAddedName = name.getLastAddedName();
375 		expectedFirstToken = IdentifierToken.create("Class", Position.create("", 0 + 1, 50 + 1, 50));
376 		assertEquals(expectedFirstToken, lastAddedName.getFirstToken());
377 		expectedLastToken = ColonToken.create(Position.create("", 0 + 1, 55 + 1, 55));
378 		assertEquals(expectedLastToken, lastAddedName.getLastToken());
379 		
380 		// Vererbung Superclass
381 		final Iterator<Type> iterator4 = class2.getSuperTypes().iterator();
382 		final Type typeProxy = iterator4.next();
383 		expectedFirstToken = IdentifierToken.create("Superclass", Position.create("", 0 + 1, 62 + 1, 62));
384 		assertEquals(expectedFirstToken, typeProxy.getFirstToken());
385 		expectedLastToken = PlusSymbolToken.create(Position.create("", 0 + 1, 72 + 1, 72));
386 		assertEquals(expectedLastToken, typeProxy.getLastToken());
387 	}
388 	
389 	/**
390 	 * Group:group=[Class:class={Attribute:String;};]; .
391 	 * 
392 	 * @throws Exception
393 	 */
394 	@Test
395 	public void testSimpleAttributte() throws Exception {
396 		final SimpleScannerInput input = new SimpleScannerInput("Group:group=[Class:class={Attribute:String;};];");
397 		final FilteredTokenStream scannerOutput = FilteredTokenStream.create();
398 		final Scanner scanner = ModelDslScanner.create();
399 		scanner.scan(input, scannerOutput);
400 		final Parser parser = Parser.create(scannerOutput);
401 		final Model result = parser.parse();
402 		
403 		// Model
404 		Token expectedFirstToken = IdentifierToken.create("Group", Position.create("", 0 + 1, 0 + 1, 0));
405 		Token expectedLastToken = EndToken.create(Position.create("", 0 + 1, 47 + 1, 47));
406 		
407 		assertEquals(expectedFirstToken, result.getFirstToken());
408 		assertEquals(expectedLastToken, result.getLastToken());
409 		
410 		// Gruppe Group1
411 		final Iterator<Group> iterator = result.getGroups().iterator();
412 		final Group group = iterator.next();
413 		
414 		expectedLastToken = EndToken.create(Position.create("", 0 + 1, 47 + 1, 47));
415 		
416 		assertEquals(expectedFirstToken, group.getFirstToken());
417 		assertEquals(expectedLastToken, group.getLastToken());
418 		
419 		// Gruppenname
420 		Name name = group.getName();
421 		assertEquals(expectedFirstToken, name.getFirstToken());
422 		expectedLastToken = ColonToken.create(Position.create("", 0 + 1, 5 + 1, 5));
423 		assertEquals(expectedLastToken, name.getLastToken());
424 		
425 		// Klasse Class
426 		final Iterator<GroupElement> iterator2 = group.getGroupElements().iterator();
427 		final GroupElement groupElement = iterator2.next();
428 		final ClassType class1 = groupElement.accept(new GroupElementReturnVisitor<ClassType>() {
429 			
430 			@Override
431 			public ClassType handle(final Group group) {
432 				fail();
433 				return null;
434 			}
435 			
436 			@Override
437 			public ClassType handle(final ClassType clss) {
438 				return clss;
439 			}
440 		});
441 		
442 		expectedFirstToken = IdentifierToken.create("Class", Position.create("", 0 + 1, 13 + 1, 13));
443 		expectedLastToken = SquareBracketCloseToken.create(Position.create("", 0 + 1, 45 + 1, 45));
444 		
445 		assertEquals(expectedFirstToken, class1.getFirstToken());
446 		assertEquals(expectedLastToken, class1.getLastToken());
447 		
448 		// Klassenname
449 		name = class1.getName();
450 		
451 		// klassenName
452 		final UnqualifiedName lastAddedName = name.getLastAddedName();
453 		expectedFirstToken = IdentifierToken.create("Class", Position.create("", 0 + 1, 13 + 1, 13));
454 		assertEquals(expectedFirstToken, lastAddedName.getFirstToken());
455 		expectedLastToken = ColonToken.create(Position.create("", 0 + 1, 18 + 1, 18));
456 		assertEquals(expectedLastToken, lastAddedName.getLastToken());
457 		
458 		// Attribut Attribute
459 		final Iterator<Attribute> iterator3 = class1.getAttributes().iterator();
460 		final Attribute attribute = iterator3.next();
461 		
462 		expectedFirstToken = IdentifierToken.create("Attribute", Position.create("", 0 + 1, 26 + 1, 26));
463 		expectedLastToken = CurlyBracketCloseToken.create(Position.create("", 0 + 1, 43 + 1, 43));
464 		
465 		assertEquals(expectedFirstToken, attribute.getFirstToken());
466 		assertEquals(expectedLastToken, attribute.getLastToken());
467 		
468 		// Attributtyp String
469 		final Type attrType = attribute.getAttrType();
470 		
471 		expectedFirstToken = IdentifierToken.create("String", Position.create("", 0 + 1, 36 + 1, 36));
472 		expectedLastToken = SemicolonToken.create(Position.create("", 0 + 1, 42 + 1, 42));
473 		
474 		assertEquals(expectedFirstToken, attrType.getFirstToken());
475 		assertEquals(expectedLastToken, attrType.getLastToken());
476 	}
477 	
478 	/**
479 	 * Group:group=[Class:class={Attribute:Integer*;};]; .
480 	 * 
481 	 * @throws Exception
482 	 */
483 	@Test
484 	public void testList() throws Exception {
485 		final SimpleScannerInput input = new SimpleScannerInput("Group:group=[Class:class={Attribute:Integer*;};];");
486 		final FilteredTokenStream scannerOutput = FilteredTokenStream.create();
487 		final Scanner scanner = ModelDslScanner.create();
488 		scanner.scan(input, scannerOutput);
489 		final Parser parser = Parser.create(scannerOutput);
490 		final Model result = parser.parse();
491 		
492 		// Model
493 		Token expectedFirstToken = IdentifierToken.create("Group", Position.create("", 0 + 1, 0 + 1, 0));
494 		Token expectedLastToken = EndToken.create(Position.create("", 0 + 1, 50, 49));
495 		
496 		assertEquals(expectedFirstToken, result.getFirstToken());
497 		assertEquals(expectedLastToken, result.getLastToken());
498 		
499 		// Gruppe Group1
500 		final Iterator<Group> iterator = result.getGroups().iterator();
501 		final Group group = iterator.next();
502 		
503 		expectedLastToken = EndToken.create(Position.create("", 0 + 1, 50, 49));
504 		
505 		assertEquals(expectedFirstToken, group.getFirstToken());
506 		assertEquals(expectedLastToken, group.getLastToken());
507 		
508 		// Gruppenname
509 		Name name = group.getName();
510 		assertEquals(expectedFirstToken, name.getFirstToken());
511 		expectedLastToken = ColonToken.create(Position.create("", 0 + 1, 5 + 1, 5));
512 		assertEquals(expectedLastToken, name.getLastToken());
513 		
514 		// Klasse Class
515 		final Iterator<GroupElement> iterator2 = group.getGroupElements().iterator();
516 		final GroupElement groupElement = iterator2.next();
517 		final ClassType class1 = groupElement.accept(new GroupElementReturnVisitor<ClassType>() {
518 			
519 			@Override
520 			public ClassType handle(final Group group) {
521 				fail();
522 				return null;
523 			}
524 			
525 			@Override
526 			public ClassType handle(final ClassType clss) {
527 				return clss;
528 			}
529 		});
530 		
531 		expectedFirstToken = IdentifierToken.create("Class", Position.create("", 0 + 1, 13 + 1, 13));
532 		expectedLastToken = SquareBracketCloseToken.create(Position.create("", 0 + 1, 48, 47));
533 		
534 		assertEquals(expectedFirstToken, class1.getFirstToken());
535 		assertEquals(expectedLastToken, class1.getLastToken());
536 		
537 		// Klassenname
538 		name = class1.getName();
539 		
540 		// klassenName
541 		final UnqualifiedName lastAddedName = name.getLastAddedName();
542 		expectedFirstToken = IdentifierToken.create("Class", Position.create("", 0 + 1, 13 + 1, 13));
543 		assertEquals(expectedFirstToken, lastAddedName.getFirstToken());
544 		expectedLastToken = ColonToken.create(Position.create("", 0 + 1, 18 + 1, 18));
545 		assertEquals(expectedLastToken, lastAddedName.getLastToken());
546 		
547 		// Attribut Attribute
548 		final Iterator<Attribute> iterator3 = class1.getAttributes().iterator();
549 		final Attribute attribute = iterator3.next();
550 		
551 		expectedFirstToken = IdentifierToken.create("Attribute", Position.create("", 0 + 1, 26 + 1, 26));
552 		expectedLastToken = CurlyBracketCloseToken.create(Position.create("", 0 + 1, 46, 45));
553 		
554 		assertEquals(expectedFirstToken, attribute.getFirstToken());
555 		assertEquals(expectedLastToken, attribute.getLastToken());
556 		
557 		// Attributtyp List
558 		final Type attrType = attribute.getAttrType();
559 		
560 		expectedFirstToken = IdentifierToken.create("Integer", Position.create("", 0 + 1, 36 + 1, 36));
561 		expectedLastToken = SemicolonToken.create(Position.create("", 0 + 1, 45, 44));
562 		
563 		assertEquals(expectedFirstToken, attrType.getFirstToken());
564 		assertEquals(expectedLastToken, attrType.getLastToken());
565 		
566 		// List of
567 		final ListType list = (ListType) attrType;
568 		
569 		expectedFirstToken = IdentifierToken.create("Integer", Position.create("", 0 + 1, 37, 36));
570 		expectedLastToken = SemicolonToken.create(Position.create("", 0 + 1, 45, 44));
571 		
572 		assertEquals(expectedFirstToken, list.getFirstToken());
573 		assertEquals(expectedLastToken, list.getLastToken());
574 		
575 		expectedLastToken = AsteriskToken.create(Position.create("", 0 + 1, 44, 43));
576 		
577 		assertEquals(expectedFirstToken, list.getOf().getFirstToken());
578 		assertEquals(expectedLastToken, list.getOf().getLastToken());
579 	}
580 	
581 	/**
582 	 * Group:group=[Class:class={Attribute:[String->Integer]**;};]; .
583 	 * 
584 	 * @throws Exception
585 	 */
586 	@Test
587 	public void testListOfListOfMap() throws Exception {
588 		final SimpleScannerInput input =
589 				new SimpleScannerInput("Group:group=[Class:class={Attribute:[String->Integer]**;};];");
590 		final FilteredTokenStream scannerOutput = FilteredTokenStream.create();
591 		final Scanner scanner = ModelDslScanner.create();
592 		scanner.scan(input, scannerOutput);
593 		final Parser parser = Parser.create(scannerOutput);
594 		final Model result = parser.parse();
595 		
596 		// Model
597 		Token expectedFirstToken = IdentifierToken.create("Group", Position.create("", 0 + 1, 0 + 1, 0));
598 		Token expectedLastToken = EndToken.create(Position.create("", 0 + 1, 61, 60));
599 		
600 		assertEquals(expectedFirstToken, result.getFirstToken());
601 		assertEquals(expectedLastToken, result.getLastToken());
602 		
603 		// Gruppe Group1
604 		final Iterator<Group> iterator = result.getGroups().iterator();
605 		final Group group = iterator.next();
606 		
607 		expectedLastToken = EndToken.create(Position.create("", 0 + 1, 61, 60));
608 		
609 		assertEquals(expectedFirstToken, group.getFirstToken());
610 		assertEquals(expectedLastToken, group.getLastToken());
611 		
612 		// Gruppenname
613 		Name name = group.getName();
614 		assertEquals(expectedFirstToken, name.getFirstToken());
615 		expectedLastToken = ColonToken.create(Position.create("", 0 + 1, 5 + 1, 5));
616 		assertEquals(expectedLastToken, name.getLastToken());
617 		
618 		// Klasse Class
619 		final Iterator<GroupElement> iterator2 = group.getGroupElements().iterator();
620 		final GroupElement groupElement = iterator2.next();
621 		final ClassType class1 = groupElement.accept(new GroupElementReturnVisitor<ClassType>() {
622 			
623 			@Override
624 			public ClassType handle(final Group group) {
625 				fail();
626 				return null;
627 			}
628 			
629 			@Override
630 			public ClassType handle(final ClassType clss) {
631 				return clss;
632 			}
633 		});
634 		
635 		expectedFirstToken = IdentifierToken.create("Class", Position.create("", 1, 14, 13));
636 		expectedLastToken = SquareBracketCloseToken.create(Position.create("", 1, 59, 58));
637 		
638 		assertEquals(expectedFirstToken, class1.getFirstToken());
639 		assertEquals(expectedLastToken, class1.getLastToken());
640 		
641 		// Klassenname
642 		name = class1.getName();
643 		
644 		// klassenName
645 		final UnqualifiedName lastAddedName = name.getLastAddedName();
646 		expectedFirstToken = IdentifierToken.create("Class", Position.create("", 1, 14, 13));
647 		assertEquals(expectedFirstToken, lastAddedName.getFirstToken());
648 		expectedLastToken = ColonToken.create(Position.create("", 1, 19, 18));
649 		assertEquals(expectedLastToken, lastAddedName.getLastToken());
650 		
651 		// Attribut Attribute
652 		final Iterator<Attribute> iterator3 = class1.getAttributes().iterator();
653 		final Attribute attribute = iterator3.next();
654 		
655 		expectedFirstToken = IdentifierToken.create("Attribute", Position.create("", 1, 27, 26));
656 		expectedLastToken = CurlyBracketCloseToken.create(Position.create("", 1, 57, 56));
657 		
658 		assertEquals(expectedFirstToken, attribute.getFirstToken());
659 		assertEquals(expectedLastToken, attribute.getLastToken());
660 		
661 		// Attributtyp List of List
662 		final ListType list = (ListType) attribute.getAttrType();
663 		
664 		expectedFirstToken = SquareBracketOpenToken.create(Position.create("", 1, 37, 36));
665 		expectedLastToken = SemicolonToken.create(Position.create("", 1, 56, 55));
666 		
667 		assertEquals(expectedFirstToken, list.getFirstToken());
668 		assertEquals(expectedLastToken, list.getLastToken());
669 		
670 		// List of Map
671 		final ListType list2 = (ListType) list.getOf();
672 		
673 		expectedFirstToken = SquareBracketOpenToken.create(Position.create("", 1, 37, 36));
674 		expectedLastToken = AsteriskToken.create(Position.create("", 1, 55, 54));
675 		
676 		assertEquals(expectedFirstToken, list2.getFirstToken());
677 		assertEquals(expectedLastToken, list2.getLastToken());
678 		
679 		// Map
680 		final MapType map = (MapType) list2.getOf();
681 		
682 		expectedFirstToken = SquareBracketOpenToken.create(Position.create("", 1, 37, 36));
683 		expectedLastToken = SquareBracketCloseToken.create(Position.create("", 1, 53, 52));
684 		
685 		assertEquals(expectedFirstToken, map.getFirstToken());
686 		assertEquals(expectedLastToken, map.getLastToken());
687 	}
688 	
689 	/**
690 	 * Group:group=[Class:class={nummern:Integer* findable;};]; .
691 	 * 
692 	 * @throws Exception
693 	 */
694 	@Test
695 	public void testAttributeWithModifier() throws Exception {
696 		final SimpleScannerInput input =
697 				new SimpleScannerInput("Group:group=[Class:class={nummern:Integer* findable;};];");
698 		final FilteredTokenStream scannerOutput = FilteredTokenStream.create();
699 		final Scanner scanner = ModelDslScanner.create();
700 		scanner.scan(input, scannerOutput);
701 		final Parser parser = Parser.create(scannerOutput);
702 		final Model result = parser.parse();
703 		
704 		// Model
705 		Token expectedFirstToken = IdentifierToken.create("Group", Position.create("", 0 + 1, 0 + 1, 0));
706 		Token expectedLastToken = EndToken.create(Position.create("", 0 + 1, 57, 56));
707 		
708 		assertEquals(expectedFirstToken, result.getFirstToken());
709 		assertEquals(expectedLastToken, result.getLastToken());
710 		
711 		// Gruppe Group1
712 		final Iterator<Group> iterator = result.getGroups().iterator();
713 		final Group group = iterator.next();
714 		
715 		expectedLastToken = EndToken.create(Position.create("", 0 + 1, 57, 56));
716 		
717 		assertEquals(expectedFirstToken, group.getFirstToken());
718 		assertEquals(expectedLastToken, group.getLastToken());
719 		
720 		// Gruppenname
721 		Name name = group.getName();
722 		assertEquals(expectedFirstToken, name.getFirstToken());
723 		expectedLastToken = ColonToken.create(Position.create("", 0 + 1, 5 + 1, 5));
724 		assertEquals(expectedLastToken, name.getLastToken());
725 		
726 		// Klasse Class
727 		final Iterator<GroupElement> iterator2 = group.getGroupElements().iterator();
728 		final GroupElement groupElement = iterator2.next();
729 		final ClassType class1 = groupElement.accept(new GroupElementReturnVisitor<ClassType>() {
730 			
731 			@Override
732 			public ClassType handle(final Group group) {
733 				fail();
734 				return null;
735 			}
736 			
737 			@Override
738 			public ClassType handle(final ClassType clss) {
739 				return clss;
740 			}
741 		});
742 		
743 		expectedFirstToken = IdentifierToken.create("Class", Position.create("", 0 + 1, 13 + 1, 13));
744 		expectedLastToken = SquareBracketCloseToken.create(Position.create("", 0 + 1, 55, 54));
745 		
746 		assertEquals(expectedFirstToken, class1.getFirstToken());
747 		assertEquals(expectedLastToken, class1.getLastToken());
748 		
749 		// Klassenname
750 		name = class1.getName();
751 		
752 		// klassenName
753 		final UnqualifiedName lastAddedName = name.getLastAddedName();
754 		expectedFirstToken = IdentifierToken.create("Class", Position.create("", 0 + 1, 13 + 1, 13));
755 		assertEquals(expectedFirstToken, lastAddedName.getFirstToken());
756 		expectedLastToken = ColonToken.create(Position.create("", 0 + 1, 18 + 1, 18));
757 		assertEquals(expectedLastToken, lastAddedName.getLastToken());
758 		
759 		// Attribut Attribute
760 		final Iterator<Attribute> iterator3 = class1.getAttributes().iterator();
761 		final Attribute attribute = iterator3.next();
762 		
763 		expectedFirstToken = IdentifierToken.create("nummern", Position.create("", 0 + 1, 26 + 1, 26));
764 		expectedLastToken = CurlyBracketCloseToken.create(Position.create("", 0 + 1, 53, 52));
765 		
766 		assertEquals(expectedFirstToken, attribute.getFirstToken());
767 		assertEquals(expectedLastToken, attribute.getLastToken());
768 		
769 		// Modfifier
770 		final AttributeModifier modifier = attribute.getModifiers().iterator().next();
771 		expectedFirstToken = FindableToken.create(Position.create("", 0 + 1, 44, 43));
772 		expectedLastToken = SemicolonToken.create(Position.create("", 0 + 1, 52, 51));
773 		
774 		assertEquals(expectedFirstToken, modifier.getFirstToken());
775 		assertEquals(expectedLastToken, modifier.getLastToken());
776 		
777 		// Attributtyp List of Integer
778 		final ListType list = (ListType) attribute.getAttrType();
779 		
780 		expectedFirstToken = IdentifierToken.create("Integer", Position.create("", 0 + 1, 35, 34));
781 		expectedLastToken = FindableToken.create(Position.create("", 0 + 1, 44, 43));
782 		
783 		assertEquals(expectedFirstToken, list.getFirstToken());
784 		assertEquals(expectedLastToken, list.getLastToken());
785 		
786 		// Integer
787 		final Type type = list.getOf();
788 		
789 		expectedFirstToken = IdentifierToken.create("Integer", Position.create("", 0 + 1, 35, 34));
790 		expectedLastToken = AsteriskToken.create(Position.create("", 0 + 1, 42, 41));
791 		
792 		assertEquals(expectedFirstToken, type.getFirstToken());
793 		assertEquals(expectedLastToken, type.getLastToken());
794 	}
795 	
796 	/**
797 	 * Group:group=[Class:class={operation:[[(Number:Integer) -> String]] abstract;};]; .
798 	 * 
799 	 * @throws Exception
800 	 */
801 	@Test
802 	public void testOperation() throws Exception {
803 		final SimpleScannerInput input =
804 				new SimpleScannerInput(
805 						"Group:group=[Class:class={operation:[[(Number:Integer) -> String]] abstract;};];");
806 		final FilteredTokenStream scannerOutput = FilteredTokenStream.create();
807 		final Scanner scanner = ModelDslScanner.create();
808 		scanner.scan(input, scannerOutput);
809 		final Parser parser = Parser.create(scannerOutput);
810 		final Model result = parser.parse();
811 		
812 		// Model
813 		Token expectedFirstToken = IdentifierToken.create("Group", Position.create("", 1, 1, 0));
814 		Token expectedLastToken = EndToken.create(Position.create("", 1, 81, 80));
815 		
816 		assertEquals(expectedFirstToken, result.getFirstToken());
817 		assertEquals(expectedLastToken, result.getLastToken());
818 		
819 		// Gruppe Group1
820 		final Iterator<Group> iterator = result.getGroups().iterator();
821 		final Group group = iterator.next();
822 		
823 		expectedLastToken = EndToken.create(Position.create("", 1, 81, 80));
824 		
825 		assertEquals(expectedFirstToken, group.getFirstToken());
826 		assertEquals(expectedLastToken, group.getLastToken());
827 		
828 		// Gruppenname
829 		Name name = group.getName();
830 		assertEquals(expectedFirstToken, name.getFirstToken());
831 		
832 		expectedLastToken = ColonToken.create(Position.create("", 1, 6, 5));
833 		assertEquals(expectedLastToken, name.getLastToken());
834 		
835 		// Klasse Class
836 		final Iterator<GroupElement> iterator2 = group.getGroupElements().iterator();
837 		final GroupElement groupElement = iterator2.next();
838 		final ClassType class1 = groupElement.accept(new GroupElementReturnVisitor<ClassType>() {
839 			
840 			@Override
841 			public ClassType handle(final Group group) {
842 				fail();
843 				return null;
844 			}
845 			
846 			@Override
847 			public ClassType handle(final ClassType clss) {
848 				return clss;
849 			}
850 		});
851 		
852 		expectedFirstToken = IdentifierToken.create("Class", Position.create("", 1, 14, 13));
853 		expectedLastToken = SquareBracketCloseToken.create(Position.create("", 1, 79, 78));
854 		
855 		assertEquals(expectedFirstToken, class1.getFirstToken());
856 		assertEquals(expectedLastToken, class1.getLastToken());
857 		
858 		// Klassenname
859 		name = class1.getName();
860 		
861 		// klassenName
862 		final UnqualifiedName lastAddedName = name.getLastAddedName();
863 		expectedFirstToken = IdentifierToken.create("Class", Position.create("", 1, 14, 13));
864 		expectedLastToken = ColonToken.create(Position.create("", 1, 19, 18));
865 		assertEquals(expectedFirstToken, lastAddedName.getFirstToken());
866 		assertEquals(expectedLastToken, lastAddedName.getLastToken());
867 		
868 		// Operation
869 		final Iterator<Operation> iterator3 = class1.getOperations().iterator();
870 		final Operation operation = iterator3.next();
871 		
872 		expectedFirstToken = IdentifierToken.create("operation", Position.create("", 1, 27, 26));
873 		expectedLastToken = CurlyBracketCloseToken.create(Position.create("", 1, 77, 76));
874 		
875 		assertEquals(expectedFirstToken, operation.getFirstToken());
876 		assertEquals(expectedLastToken, operation.getLastToken());
877 		
878 		// Input-Parameter
879 		final ProductType params = operation.getParameters();
880 		
881 		final Iterator<ProductElementType> iterator4 = params.getElements().iterator();
882 		final ProductElementType parameterIdentifier = iterator4.next();
883 		
884 		expectedFirstToken = IdentifierToken.create("Number", Position.create("", 1, 40, 39));
885 		expectedLastToken = BracketCloseToken.create(Position.create("", 1, 54, 53));
886 		assertEquals(expectedFirstToken, parameterIdentifier.getFirstToken());
887 		assertEquals(expectedLastToken, parameterIdentifier.getLastToken());
888 		
889 		expectedFirstToken = BracketOpenToken.create(Position.create("", 1, 39, 38));
890 		expectedLastToken = ArrowToken.create(Position.create("", 1, 56, 55));
891 		assertEquals(expectedFirstToken, params.getFirstToken());
892 		assertEquals(expectedLastToken, params.getLastToken());
893 	}
894 }