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
59
60 public class TestParserScanner {
61
62 private CurlyBracketOpenToken curlyBracketOpenToken;
63 private BracketOpenToken bracketOpenToken;
64 private AbstractToken abstractToken;
65
66
67
68
69
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
80
81
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
136
137
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
200
201
202
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
281
282
283
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
365
366
367
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
455
456
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
515
516
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
576
577
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
597
598
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
638
639
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
695
696
697
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 }