1 package de.fhdw.wtf.core.integration.test;
2
3 import static org.junit.Assert.assertEquals;
4 import static org.junit.Assert.fail;
5
6 import java.io.File;
7 import java.io.IOException;
8 import java.util.Vector;
9
10 import org.junit.Test;
11
12 import de.fhdw.wtf.common.ast.Attribute;
13 import de.fhdw.wtf.common.ast.AttributeModifier;
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.UnqualifiedName;
22 import de.fhdw.wtf.common.ast.type.ByNameState;
23 import de.fhdw.wtf.common.ast.type.ClassModifier;
24 import de.fhdw.wtf.common.ast.type.ClassType;
25 import de.fhdw.wtf.common.ast.type.MapType;
26 import de.fhdw.wtf.common.ast.type.ProductElementType;
27 import de.fhdw.wtf.common.ast.type.ProductType;
28 import de.fhdw.wtf.common.ast.type.RegularClassType;
29 import de.fhdw.wtf.common.ast.type.Type;
30 import de.fhdw.wtf.common.ast.type.TypeProxy;
31 import de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException;
32 import de.fhdw.wtf.common.stream.FilteredTokenStream;
33 import de.fhdw.wtf.common.stream.ScannerInputStream;
34 import de.fhdw.wtf.common.stream.SimpleScannerInput;
35 import de.fhdw.wtf.common.stream.SimpleTokenStream;
36 import de.fhdw.wtf.common.token.IdentifierToken;
37 import de.fhdw.wtf.common.token.Position;
38 import de.fhdw.wtf.common.token.symbols.BracketOpenToken;
39 import de.fhdw.wtf.common.token.symbols.DoubleSquareBracketOpenToken;
40 import de.fhdw.wtf.common.token.symbols.SquareBracketOpenToken;
41 import de.fhdw.wtf.dsl.scanner.modelScanner.ModelDslScanner;
42 import de.fhdw.wtf.parser.Parser;
43 import de.fhdw.wtf.testutil.TestUtil;
44
45
46
47
48 public class TestScannerParserIntegration {
49
50 private static final String PATH_TO_TEST_FILE_DIR = "src/test/java/de/fhdw/wtf/core/integration/test/files/";
51 private static final String MODEL_SUFFIX = "model";
52
53 public static ScannerInputStream loadTestModel(final String modelName) throws IOException {
54 return TestUtil.readFileToScannerStream(TestScannerParserIntegration.PATH_TO_TEST_FILE_DIR + modelName + '.'
55 + TestScannerParserIntegration.MODEL_SUFFIX);
56 }
57
58
59
60
61 @Test
62 public void modelSimpleValid() {
63 final SimpleScannerInput input = new SimpleScannerInput("gruppenName:group=[];");
64 final SimpleTokenStream scannerOutput = SimpleTokenStream.create();
65 final ModelDslScanner scanner = ModelDslScanner.create();
66 scanner.scan(input, scannerOutput);
67 final Parser p = Parser.create(scannerOutput);
68
69 try {
70 final Model result = p.parse();
71 assertEquals(0, p.getExceptions().size());
72 assertEquals(1, result.getGroups().size());
73 final Group g = result.getGroups().iterator().next();
74 assertEquals("gruppenName", ((UnqualifiedName) g.getName()).getIdentifierToken().getIdentifier());
75 assertEquals(0, g.getGroupElements().size());
76 } catch (final NoValidTokenStreamException e) {
77 if (p.getExceptions().size() > 0) {
78 System.out.println(p.getExceptions());
79 }
80 fail();
81 }
82 }
83
84
85
86
87 @Test
88 public void modelSimpleValidWhitespace() {
89 final SimpleScannerInput input = new SimpleScannerInput("gruppenName : group = \n [ \n]; ");
90 final FilteredTokenStream scannerOutput = FilteredTokenStream.create();
91 final ModelDslScanner scanner = ModelDslScanner.create();
92 scanner.scan(input, scannerOutput);
93 final Parser p = Parser.create(scannerOutput);
94
95 try {
96 final Model result = p.parse();
97 assertEquals(0, p.getExceptions().size());
98 assertEquals(1, result.getGroups().size());
99 final Group g = result.getGroups().iterator().next();
100 assertEquals("gruppenName", ((UnqualifiedName) g.getName()).getIdentifierToken().getIdentifier());
101 assertEquals(0, g.getGroupElements().size());
102 } catch (final NoValidTokenStreamException e) {
103 if (p.getExceptions().size() > 0) {
104 System.out.println(p.getExceptions());
105 }
106 fail();
107 }
108 }
109
110
111
112
113
114
115 @Test
116 public void testSquareBracketsInMaps() throws Exception {
117 final Position position = Position.create("", 1, 1, 0);
118
119 final SimpleScannerInput input =
120 new SimpleScannerInput("Group:group=[Class:class={attribute:[ [key -> value] -> [key -> value] ];};];");
121 final FilteredTokenStream scannerOutput = FilteredTokenStream.create();
122 final ModelDslScanner scanner = ModelDslScanner.create();
123 scanner.scan(input, scannerOutput);
124 final Parser p = Parser.create(scannerOutput);
125 final Model actual = p.parse();
126
127 final IdentifierToken groupIdentifier = IdentifierToken.create("Group", position);
128 final IdentifierToken classIdentifier = IdentifierToken.create("Class", position);
129 final IdentifierToken attributeIdentifier = IdentifierToken.create("attribute", position);
130 final IdentifierToken keyIdentifier = IdentifierToken.create("key", position);
131 final IdentifierToken valueIdentifier = IdentifierToken.create("value", position);
132
133 final Vector<GroupElement> groupVector = new Vector<>();
134 final Vector<Attribute> attributes = new Vector<>();
135
136 final Name groupName = UnqualifiedName.create(groupIdentifier);
137 final Group group = Group.create(groupName, groupVector, groupIdentifier);
138
139 final Name className = groupName.addName(classIdentifier);
140 final ClassType classModel =
141 RegularClassType.create(
142 className,
143 new Vector<ClassModifier>(),
144 attributes,
145 new Vector<Type>(),
146 new Vector<Operation>(),
147 new Vector<Constructor>(),
148 classIdentifier,
149 new Vector<ClassType>());
150
151 final ByNameState keyReferenceState = ByNameState.create(UnqualifiedName.create(keyIdentifier));
152 final TypeProxy keyType = TypeProxy.create(keyIdentifier, keyReferenceState);
153 final ByNameState valueReferenceState = ByNameState.create(UnqualifiedName.create(valueIdentifier));
154 final TypeProxy valueType = TypeProxy.create(valueIdentifier, valueReferenceState);
155
156 final MapType mapIn1 = MapType.create(SquareBracketOpenToken.create(position), keyType, valueType);
157 final MapType mapIn2 = MapType.create(SquareBracketOpenToken.create(position), keyType, valueType);
158 final MapType mapOut = MapType.create(SquareBracketOpenToken.create(position), mapIn1, mapIn2);
159
160 final Attribute attribute =
161 Attribute.create("attribute", mapOut, new Vector<AttributeModifier>(), attributeIdentifier);
162 attributes.add(attribute);
163 groupVector.add(classModel);
164 final Model expected = Model.create(groupIdentifier);
165 expected.addGroup(group);
166 assertEquals(expected, actual);
167 assertEquals(0, p.getExceptions().size());
168 }
169
170
171
172
173
174
175 @Test
176 public void testSquareBracketsInOperation() throws Exception {
177 final Position position = Position.create("", 1, 1, 0);
178
179 final SimpleScannerInput input =
180 new SimpleScannerInput(
181 "Group:group=[Class:class={operation:[[(parameter:String) -> [key-> [key->value] ] ]];};];");
182 final FilteredTokenStream scannerOutput = FilteredTokenStream.create();
183 final ModelDslScanner scanner = ModelDslScanner.create();
184 scanner.scan(input, scannerOutput);
185 final Parser p = Parser.create(scannerOutput);
186 final Model actual = p.parse();
187
188 final IdentifierToken groupIdentifier = IdentifierToken.create("Group", position);
189 final IdentifierToken classIdentifier = IdentifierToken.create("Class", position);
190 final IdentifierToken keyIdentifier = IdentifierToken.create("key", position);
191 final IdentifierToken valueIdentifier = IdentifierToken.create("value", position);
192 final IdentifierToken stringIdentifier = IdentifierToken.create("String", position);
193 final IdentifierToken parameterIdentifier = IdentifierToken.create("parameter", position);
194
195 final Vector<GroupElement> groupVector = new Vector<>();
196 final Vector<Operation> operations = new Vector<>();
197
198 final Name groupName = UnqualifiedName.create(groupIdentifier);
199 final Group group = Group.create(groupName, groupVector, groupIdentifier);
200
201 final Name className = groupName.addName(classIdentifier);
202 final ClassType classModel =
203 RegularClassType.create(
204 className,
205 new Vector<ClassModifier>(),
206 new Vector<Attribute>(),
207 new Vector<Type>(),
208 operations,
209 new Vector<Constructor>(),
210 classIdentifier,
211 new Vector<ClassType>());
212
213 final ByNameState stringReferenceState = ByNameState.create(UnqualifiedName.create(stringIdentifier));
214 final TypeProxy stringType = TypeProxy.create(stringIdentifier, stringReferenceState);
215 final ByNameState keyReferenceState = ByNameState.create(UnqualifiedName.create(keyIdentifier));
216 final TypeProxy keyType = TypeProxy.create(keyIdentifier, keyReferenceState);
217 final ByNameState valueReferenceState = ByNameState.create(UnqualifiedName.create(valueIdentifier));
218 final TypeProxy valueType = TypeProxy.create(valueIdentifier, valueReferenceState);
219
220 final ProductElementType element = ProductElementType.create("parameter", stringType, parameterIdentifier);
221 final ProductType product = ProductType.create(BracketOpenToken.create(position));
222 product.addElement(element);
223
224 final MapType mapIn = MapType.create(SquareBracketOpenToken.create(position), keyType, valueType);
225 final MapType mapOut = MapType.create(SquareBracketOpenToken.create(position), keyType, mapIn);
226
227 final Operation op =
228 Operation.create(
229 "operation",
230 new Vector<OperationModifier>(),
231 product,
232 classModel,
233 mapOut,
234 DoubleSquareBracketOpenToken.create(position));
235 operations.add(op);
236 groupVector.add(classModel);
237 final Model expected = Model.create(groupIdentifier);
238 expected.addGroup(group);
239 assertEquals(expected, actual);
240 assertEquals(0, p.getExceptions().size());
241 }
242
243
244
245
246
247
248 @Test
249 public void modelFilePerson() throws IOException {
250 System.out.println(new File("").getAbsolutePath());
251 final ScannerInputStream input = TestScannerParserIntegration.loadTestModel("Person");
252 final FilteredTokenStream output = FilteredTokenStream.create();
253 final ModelDslScanner scanner = ModelDslScanner.create();
254 scanner.scan(input, output);
255 final Parser p = Parser.create(output);
256
257 try {
258 final Model result = p.parse();
259 assertEquals(0, p.getExceptions().size());
260 assertEquals(1, result.getGroups().size());
261 final Group g = result.getGroups().iterator().next();
262 assertEquals("personGroup", ((UnqualifiedName) g.getName()).getIdentifierToken().getIdentifier());
263 assertEquals(3, g.getGroupElements().size());
264 } catch (final NoValidTokenStreamException e) {
265 if (p.getExceptions().size() > 0) {
266 System.out.println(p.getExceptions());
267 }
268 fail();
269 }
270
271 }
272
273 }