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
49
50 public class TypeTest {
51
52
53
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
85 assertTrue(clazz instanceof RegularClassType);
86 }
87
88
89
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
121 assertTrue(clazz instanceof RegularClassType);
122 }
123
124
125
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
157 assertTrue(clazz instanceof RegularClassType);
158 }
159
160
161
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
193 assertTrue(clazz instanceof RegularClassType);
194 }
195
196
197
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
225 assertTrue(clazz instanceof RegularClassType);
226 }
227
228
229
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
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
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
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 }