View Javadoc
1   package de.fhdw.wtf.common.ast.type.test;
2   
3   import static org.junit.Assert.assertEquals;
4   import static org.junit.Assert.assertFalse;
5   import static org.junit.Assert.assertTrue;
6   
7   import java.util.Collection;
8   import java.util.List;
9   import java.util.Vector;
10  
11  import org.junit.Test;
12  
13  import de.fhdw.wtf.common.ast.Attribute;
14  import de.fhdw.wtf.common.ast.AttributeModifier;
15  import de.fhdw.wtf.common.ast.AttributeModifierPrior;
16  import de.fhdw.wtf.common.ast.Constructor;
17  import de.fhdw.wtf.common.ast.Name;
18  import de.fhdw.wtf.common.ast.Operation;
19  import de.fhdw.wtf.common.ast.OperationModifier;
20  import de.fhdw.wtf.common.ast.UnqualifiedName;
21  import de.fhdw.wtf.common.ast.type.BaseType;
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.ClassModifierAbstract;
25  import de.fhdw.wtf.common.ast.type.ClassModifierService;
26  import de.fhdw.wtf.common.ast.type.ClassModifierTransient;
27  import de.fhdw.wtf.common.ast.type.ClassModifierVisitable;
28  import de.fhdw.wtf.common.ast.type.ClassType;
29  import de.fhdw.wtf.common.ast.type.ListType;
30  import de.fhdw.wtf.common.ast.type.MapType;
31  import de.fhdw.wtf.common.ast.type.ProductType;
32  import de.fhdw.wtf.common.ast.type.RegularClassType;
33  import de.fhdw.wtf.common.ast.type.SumType;
34  import de.fhdw.wtf.common.ast.type.Type;
35  import de.fhdw.wtf.common.ast.type.TypeProxy;
36  import de.fhdw.wtf.common.token.IdentifierToken;
37  import de.fhdw.wtf.common.token.Position;
38  import de.fhdw.wtf.common.token.keywords.AbstractToken;
39  import de.fhdw.wtf.common.token.keywords.PriorToken;
40  import de.fhdw.wtf.common.token.keywords.ServiceToken;
41  import de.fhdw.wtf.common.token.keywords.TransientToken;
42  import de.fhdw.wtf.common.token.keywords.VisitableToken;
43  import de.fhdw.wtf.common.token.symbols.BracketOpenToken;
44  import de.fhdw.wtf.common.token.symbols.CurlyBracketOpenToken;
45  import de.fhdw.wtf.common.token.symbols.SquareBracketOpenToken;
46  
47  /**
48   * Tests some {@link de.fhdw.wtf.common.ast.type.Type}s.
49   */
50  public class TypeTest {
51  	
52  	/**
53  	 * Tests an abstract class.
54  	 */
55  	@Test
56  	public void testClassAbstract() {
57  		final IdentifierToken className = IdentifierToken.create("className", Position.createDummyPosition());
58  		final Name name = UnqualifiedName.create(className);
59  		final Collection<ClassModifier> modifiers = new Vector<>();
60  		final Collection<Attribute> attributes = new Vector<>();
61  		final List<Type> superTypes = new Vector<>();
62  		final Collection<Operation> operations = new Vector<>();
63  		final Collection<Constructor> superConstructors = new Vector<>();
64  		final Collection<ClassType> subTypes = new Vector<>();
65  		
66  		final ClassType clazz =
67  				RegularClassType.create(
68  						name,
69  						modifiers,
70  						attributes,
71  						superTypes,
72  						operations,
73  						superConstructors,
74  						className,
75  						subTypes);
76  		
77  		final AbstractToken abstractToken = AbstractToken.create(Position.createDummyPosition());
78  		modifiers.add(ClassModifierAbstract.create(abstractToken));
79  		
80  		assertTrue(clazz.isAbstract());
81  		assertFalse(clazz.isService());
82  		assertFalse(clazz.isTransient());
83  		assertFalse(clazz.isVisitable());
84  		// TODO -> Use visitor instead
85  		assertTrue(clazz instanceof RegularClassType);
86  	}
87  	
88  	/**
89  	 * Tests an service class.
90  	 */
91  	@Test
92  	public void testClassService() {
93  		final IdentifierToken className = IdentifierToken.create("className", Position.createDummyPosition());
94  		final Name name = UnqualifiedName.create(className);
95  		final Collection<ClassModifier> modifiers = new Vector<>();
96  		final Collection<Attribute> attributes = new Vector<>();
97  		final List<Type> superTypes = new Vector<>();
98  		final Collection<Operation> operations = new Vector<>();
99  		final Collection<Constructor> superConstructors = new Vector<>();
100 		final Collection<ClassType> subTypes = new Vector<>();
101 		
102 		final ClassType clazz =
103 				RegularClassType.create(
104 						name,
105 						modifiers,
106 						attributes,
107 						superTypes,
108 						operations,
109 						superConstructors,
110 						className,
111 						subTypes);
112 		
113 		final ServiceToken serviceToken = ServiceToken.create(Position.createDummyPosition());
114 		modifiers.add(ClassModifierService.create(serviceToken));
115 		
116 		assertFalse(clazz.isAbstract());
117 		assertTrue(clazz.isService());
118 		assertFalse(clazz.isTransient());
119 		assertFalse(clazz.isVisitable());
120 		// TODO -> Use visitor instead
121 		assertTrue(clazz instanceof RegularClassType);
122 	}
123 	
124 	/**
125 	 * Tests an transient class.
126 	 */
127 	@Test
128 	public void testClassTransient() {
129 		final IdentifierToken className = IdentifierToken.create("className", Position.createDummyPosition());
130 		final Name name = UnqualifiedName.create(className);
131 		final Collection<ClassModifier> modifiers = new Vector<>();
132 		final Collection<Attribute> attributes = new Vector<>();
133 		final List<Type> superTypes = new Vector<>();
134 		final Collection<Operation> operations = new Vector<>();
135 		final Collection<Constructor> superConstructors = new Vector<>();
136 		final Collection<ClassType> subTypes = new Vector<>();
137 		
138 		final ClassType clazz =
139 				RegularClassType.create(
140 						name,
141 						modifiers,
142 						attributes,
143 						superTypes,
144 						operations,
145 						superConstructors,
146 						className,
147 						subTypes);
148 		
149 		final TransientToken transientToken = TransientToken.create(Position.createDummyPosition());
150 		modifiers.add(ClassModifierTransient.create(transientToken));
151 		
152 		assertFalse(clazz.isAbstract());
153 		assertFalse(clazz.isService());
154 		assertTrue(clazz.isTransient());
155 		assertFalse(clazz.isVisitable());
156 		// TODO -> Use visitor instead
157 		assertTrue(clazz instanceof RegularClassType);
158 	}
159 	
160 	/**
161 	 * Tests an visitable class.
162 	 */
163 	@Test
164 	public void testClassVisitable() {
165 		final IdentifierToken className = IdentifierToken.create("className", Position.createDummyPosition());
166 		final Name name = UnqualifiedName.create(className);
167 		final Collection<ClassModifier> modifiers = new Vector<>();
168 		final Collection<Attribute> attributes = new Vector<>();
169 		final List<Type> superTypes = new Vector<>();
170 		final Collection<Operation> operations = new Vector<>();
171 		final Collection<Constructor> superConstructors = new Vector<>();
172 		final Collection<ClassType> subTypes = new Vector<>();
173 		
174 		final ClassType clazz =
175 				RegularClassType.create(
176 						name,
177 						modifiers,
178 						attributes,
179 						superTypes,
180 						operations,
181 						superConstructors,
182 						className,
183 						subTypes);
184 		
185 		final VisitableToken visitableToken = VisitableToken.create(Position.createDummyPosition());
186 		modifiers.add(ClassModifierVisitable.create(visitableToken));
187 		
188 		assertFalse(clazz.isAbstract());
189 		assertFalse(clazz.isService());
190 		assertFalse(clazz.isTransient());
191 		assertTrue(clazz.isVisitable());
192 		// TODO -> Use visitor instead
193 		assertTrue(clazz instanceof RegularClassType);
194 	}
195 	
196 	/**
197 	 * Tests an exception.
198 	 */
199 	@Test
200 	public void testClassIsException() {
201 		final IdentifierToken className = IdentifierToken.create("className", Position.createDummyPosition());
202 		final Name name = UnqualifiedName.create(className);
203 		final Collection<ClassModifier> modifiers = new Vector<>();
204 		final Collection<Attribute> attributes = new Vector<>();
205 		final List<Type> superTypes = new Vector<>();
206 		final Collection<Operation> operations = new Vector<>();
207 		final Collection<Constructor> superConstructors = new Vector<>();
208 		final Collection<ClassType> subTypes = new Vector<>();
209 		
210 		final ClassType clazz =
211 				RegularClassType.create(
212 						name,
213 						modifiers,
214 						attributes,
215 						superTypes,
216 						operations,
217 						superConstructors,
218 						className,
219 						subTypes);
220 		
221 		assertFalse(clazz.isAbstract());
222 		assertFalse(clazz.isService());
223 		assertFalse(clazz.isTransient());
224 		// TODO -> Use visitor instead
225 		assertTrue(clazz instanceof RegularClassType);
226 	}
227 	
228 	/**
229 	 * Tests class toString()-Method.
230 	 */
231 	@Test
232 	public void testClassTypeToString() {
233 		final IdentifierToken classNameToken = IdentifierToken.create("className", Position.createDummyPosition());
234 		final Name className = UnqualifiedName.create(classNameToken);
235 		final Collection<ClassModifier> classModifiers = new Vector<>();
236 		final Collection<Attribute> attributes = new Vector<>();
237 		final List<Type> superTypes = new Vector<>();
238 		final Collection<Operation> operations = new Vector<>();
239 		final Collection<Constructor> superConstructors = new Vector<>();
240 		final Collection<ClassType> subTypes = new Vector<>();
241 		
242 		final ClassType clazz =
243 				RegularClassType.create(
244 						className,
245 						classModifiers,
246 						attributes,
247 						superTypes,
248 						operations,
249 						superConstructors,
250 						classNameToken,
251 						subTypes);
252 		
253 		final AbstractToken abstractToken = AbstractToken.create(Position.createDummyPosition());
254 		classModifiers.add(ClassModifierAbstract.create(abstractToken));
255 		
256 		final IdentifierToken typeNameToken = IdentifierToken.create("String", Position.createDummyPosition());
257 		final Name typeName = UnqualifiedName.create(typeNameToken);
258 		final BaseType bt = BaseType.create(typeName, typeNameToken, typeNameToken);
259 		
260 		final Collection<AttributeModifier> attributeModifiers = new Vector<>();
261 		final PriorToken priorToken = PriorToken.create(Position.createDummyPosition());
262 		attributeModifiers.add(AttributeModifierPrior.create(priorToken));
263 		final IdentifierToken attributeToken = IdentifierToken.create("Attribute", Position.createDummyPosition());
264 		final Attribute attribute = Attribute.create("Attribute", bt, attributeModifiers, attributeToken);
265 		attributes.add(attribute);
266 		
267 		final IdentifierToken superClassNameToken =
268 				IdentifierToken.create("superClass", Position.createDummyPosition());
269 		final Name superClassName = UnqualifiedName.create(superClassNameToken);
270 		final ByNameState state = ByNameState.create(superClassName);
271 		superTypes.add(TypeProxy.create(superClassNameToken, state));
272 		
273 		final ProductType pT = ProductType.create(BracketOpenToken.create(Position.createDummyPosition()));
274 		final SumType sT = SumType.create(CurlyBracketOpenToken.create(Position.createDummyPosition()));
275 		final IdentifierToken operationToken = IdentifierToken.create("Operation", Position.createDummyPosition());
276 		final Operation operation =
277 				Operation.create("Operation", new Vector<OperationModifier>(), pT, clazz, sT, operationToken);
278 		operations.add(operation);
279 		
280 		final String expected =
281 				"className:class=superClass + { \n" + "Attribute:String prior; \n"
282 						+ "Operation:[[()->{}]]; \n} abstract;";
283 		assertEquals(expected, clazz.toString());
284 	}
285 	
286 	/**
287 	 * Tests toString() of ListType.
288 	 */
289 	@Test
290 	public void testListTypeToString() {
291 		final IdentifierToken string = IdentifierToken.create("String", Position.createDummyPosition());
292 		final Name typeName = UnqualifiedName.create(string);
293 		final BaseType stringType = BaseType.create(typeName, string, string);
294 		final ListType listType = ListType.create(string, stringType);
295 		final String expected = "String*";
296 		
297 		assertEquals(expected, listType.toString());
298 	}
299 	
300 	/**
301 	 * Tests toString() of ListType with MapType.
302 	 */
303 	@Test
304 	public void testListTypeMapTypeToString() {
305 		final IdentifierToken string = IdentifierToken.create("String", Position.createDummyPosition());
306 		final IdentifierToken integer = IdentifierToken.create("Integer", Position.createDummyPosition());
307 		final Name typeName = UnqualifiedName.create(string);
308 		final BaseType stringType = BaseType.create(typeName, string, string);
309 		
310 		final Name typeNameInteger = UnqualifiedName.create(integer);
311 		final BaseType integerType = BaseType.create(typeNameInteger, integer, integer);
312 		final SquareBracketOpenToken sbo = SquareBracketOpenToken.create(Position.createDummyPosition());
313 		final MapType mapType = MapType.create(sbo, stringType, integerType);
314 		final ListType listType = ListType.create(sbo, mapType);
315 		
316 		final String expected = "[String->Integer]*";
317 		assertEquals(expected, listType.toString());
318 	}
319 	
320 	/**
321 	 * Tests toString() of MapType.
322 	 */
323 	@Test
324 	public void testMapTypeToString() {
325 		final IdentifierToken string = IdentifierToken.create("String", Position.createDummyPosition());
326 		final IdentifierToken integer = IdentifierToken.create("Integer", Position.createDummyPosition());
327 		final Name typeNameString = UnqualifiedName.create(string);
328 		final Name typeNameInteger = UnqualifiedName.create(integer);
329 		final BaseType stringType = BaseType.create(typeNameString, string, string);
330 		final BaseType integerType = BaseType.create(typeNameInteger, integer, integer);
331 		final SquareBracketOpenToken sbo = SquareBracketOpenToken.create(Position.createDummyPosition());
332 		final MapType mapType = MapType.create(sbo, stringType, integerType);
333 		final String expected = "[String->Integer]";
334 		
335 		assertEquals(expected, mapType.toString());
336 	}
337 }