View Javadoc
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   * Tests the integration of scanner and parser.
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  	 * gruppenName:group=[]; .
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  	 * "gruppenName : group =  \n [    \n];   " .
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 	 * Group:group=[Class:class={attribute:[ [key -> value] -> [key -> value] ];};];" .
112 	 * 
113 	 * @throws Exception
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 	 * Group:group=[Class:class={operation:[[(parameter1) -> [key-> [key->value] ] ]];}] .
172 	 * 
173 	 * @throws Exception
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 	 * Tests the model "Person".
245 	 * 
246 	 * @throws IOException
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 }