2 * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.mdsal.binding.java.api.generator;
10 import static org.junit.Assert.assertEquals;
11 import static org.junit.Assert.assertFalse;
12 import static org.junit.Assert.assertTrue;
14 import com.google.common.collect.Range;
16 import java.lang.reflect.Constructor;
17 import java.lang.reflect.Method;
19 import java.net.URLClassLoader;
20 import java.util.ArrayList;
21 import java.util.List;
22 import java.util.regex.Pattern;
23 import org.junit.Test;
24 import org.opendaylight.yangtools.yang.common.Decimal64;
25 import org.opendaylight.yangtools.yang.common.Empty;
28 * Test correct code generation.
30 public class TypedefCompilationTest extends BaseCompilationTest {
31 private static final String VAL = "_value";
32 private static final String GET_VAL = "getValue";
33 private static final String UNITS = "_UNITS";
36 public void test() throws Exception {
37 final File sourcesOutputDir = CompilationTestUtils.generatorOutput("typedef");
38 final File compiledOutputDir = CompilationTestUtils.compilerOutput("typedef");
39 generateTestSources("/compilation/typedef", sourcesOutputDir);
41 final File parent = new File(sourcesOutputDir, CompilationTestUtils.NS_FOO);
42 assertTrue(new File(parent, "BitsExt.java").exists());
43 assertTrue(new File(parent, "Int32Ext0.java").exists());
44 assertTrue(new File(parent, "Int32Ext1.java").exists());
45 assertTrue(new File(parent, "Int32Ext2.java").exists());
46 assertTrue(new File(parent, "MyDecimalType.java").exists());
47 assertTrue(new File(parent, "StringExt1.java").exists());
48 assertTrue(new File(parent, "StringExt2.java").exists());
49 assertTrue(new File(parent, "StringExt3.java").exists());
50 assertTrue(new File(parent, "UnionExt1.java").exists());
51 assertTrue(new File(parent, "UnionExt2.java").exists());
52 assertTrue(new File(parent, "UnionExt3.java").exists());
53 assertTrue(new File(parent, "UnionExt4.java").exists());
54 CompilationTestUtils.assertFilesCount(parent, 30);
55 final File svcParent = new File(sourcesOutputDir, CompilationTestUtils.NS_SVC_FOO);
56 CompilationTestUtils.assertFilesCount(svcParent, 1);
58 // Test if sources are compilable
59 CompilationTestUtils.testCompilation(sourcesOutputDir, compiledOutputDir);
61 String pkg = CompilationTestUtils.BASE_PKG + ".urn.opendaylight.foo.rev131008";
62 final ClassLoader loader = new URLClassLoader(new URL[] { compiledOutputDir.toURI().toURL() });
63 final Class<?> bitsExtClass = Class.forName(pkg + ".BitsExt", true, loader);
64 final Class<?> int32Ext1Class = Class.forName(pkg + ".Int32Ext1", true, loader);
65 final Class<?> int32Ext2Class = Class.forName(pkg + ".Int32Ext2", true, loader);
66 final Class<?> myDecimalTypeClass = Class.forName(pkg + ".MyDecimalType", true, loader);
67 final Class<?> myDecimalType2Class = Class.forName(pkg + ".MyDecimalType2", true, loader);
68 final Class<?> stringExt1Class = Class.forName(pkg + ".StringExt1", true, loader);
69 final Class<?> stringExt2Class = Class.forName(pkg + ".StringExt2", true, loader);
70 final Class<?> stringExt3Class = Class.forName(pkg + ".StringExt3", true, loader);
71 final Class<?> unionExt1Class = Class.forName(pkg + ".UnionExt1", true, loader);
72 final Class<?> unionExt2Class = Class.forName(pkg + ".UnionExt2", true, loader);
73 final Class<?> unionExt3Class = Class.forName(pkg + ".UnionExt3", true, loader);
74 final Class<?> unionExt4Class = Class.forName(pkg + ".UnionExt4", true, loader);
77 assertFalse(bitsExtClass.isInterface());
78 CompilationTestUtils.assertContainsField(bitsExtClass, "_pc", boolean.class);
79 CompilationTestUtils.assertContainsField(bitsExtClass, "_bpc", boolean.class);
80 CompilationTestUtils.assertContainsField(bitsExtClass, "_dpc", boolean.class);
81 CompilationTestUtils.assertContainsField(bitsExtClass, "_lbpc", boolean.class);
82 CompilationTestUtils.assertContainsField(bitsExtClass, "_spc", boolean.class);
83 CompilationTestUtils.assertContainsField(bitsExtClass, "_sfmof", boolean.class);
84 CompilationTestUtils.assertContainsField(bitsExtClass, "_sfapc", boolean.class);
85 CompilationTestUtils.assertContainsFieldWithValue(bitsExtClass, "serialVersionUID", Long.TYPE,
86 -2922917845344851623L, boolean.class, boolean.class, boolean.class, boolean.class, boolean.class,
87 boolean.class, boolean.class);
89 assertEquals(9, bitsExtClass.getDeclaredFields().length);
90 CompilationTestUtils.assertContainsConstructor(bitsExtClass, bitsExtClass);
91 assertEquals(2, bitsExtClass.getConstructors().length);
92 Method defInst = CompilationTestUtils.assertContainsMethod(bitsExtClass, bitsExtClass, "getDefaultInstance",
94 CompilationTestUtils.assertContainsDefaultMethods(bitsExtClass);
95 assertEquals(13, bitsExtClass.getDeclaredMethods().length);
97 Constructor<?> expectedConstructor = CompilationTestUtils.assertContainsConstructor(bitsExtClass, boolean.class,
98 boolean.class, boolean.class, boolean.class, boolean.class, boolean.class, boolean.class);
99 Object obj = expectedConstructor.newInstance(false, false, false, false, false, true, false);
100 assertEquals(obj, defInst.invoke(true, "sfmof"));
102 // typedef int32-ext1
103 assertFalse(int32Ext1Class.isInterface());
104 CompilationTestUtils.assertContainsField(int32Ext1Class, VAL, Integer.class);
105 CompilationTestUtils.assertContainsFieldWithValue(int32Ext1Class, "serialVersionUID", Long.TYPE,
106 5351634010010233292L, Integer.class);
107 assertEquals(2, int32Ext1Class.getDeclaredFields().length);
109 expectedConstructor = CompilationTestUtils.assertContainsConstructor(int32Ext1Class, Integer.class);
110 CompilationTestUtils.assertContainsConstructor(int32Ext1Class, int32Ext1Class);
111 assertEquals(2, int32Ext1Class.getConstructors().length);
112 CompilationTestUtils.assertContainsDefaultMethods(int32Ext1Class);
113 CompilationTestUtils.assertContainsMethod(int32Ext1Class, Integer.class, GET_VAL);
114 defInst = CompilationTestUtils.assertContainsMethod(int32Ext1Class, int32Ext1Class, "getDefaultInstance",
116 assertEquals(7, int32Ext1Class.getDeclaredMethods().length);
118 List<Range<Integer>> rangeConstraints = new ArrayList<>();
119 rangeConstraints.add(Range.closed(2, 2147483647));
121 String expectedMsg = String.format("Invalid range: %s, expected: %s.", arg, rangeConstraints);
122 CompilationTestUtils.assertContainsRestrictionCheck(expectedConstructor, expectedMsg, arg);
123 obj = expectedConstructor.newInstance(159);
124 assertEquals(obj, defInst.invoke(null, "159"));
126 // typedef int32-ext2
127 assertFalse(int32Ext2Class.isInterface());
128 CompilationTestUtils.assertContainsFieldWithValue(int32Ext2Class, UNITS, String.class, "mile", Integer.class);
129 CompilationTestUtils.assertContainsFieldWithValue(int32Ext2Class, "serialVersionUID", Long.TYPE,
130 317831889060130988L, Integer.class);
131 assertEquals(2, int32Ext2Class.getDeclaredFields().length);
132 expectedConstructor = CompilationTestUtils.assertContainsConstructor(int32Ext2Class, Integer.class);
133 CompilationTestUtils.assertContainsConstructor(int32Ext2Class, int32Ext2Class);
134 CompilationTestUtils.assertContainsConstructor(int32Ext2Class, int32Ext1Class);
135 assertEquals(3, int32Ext2Class.getDeclaredConstructors().length);
136 CompilationTestUtils.assertContainsMethod(int32Ext2Class, String.class, "toString");
137 defInst = CompilationTestUtils.assertContainsMethod(int32Ext2Class, int32Ext2Class, "getDefaultInstance",
139 assertEquals(3, int32Ext2Class.getDeclaredMethods().length);
141 rangeConstraints.clear();
142 rangeConstraints.add(Range.closed(3, 9));
143 rangeConstraints.add(Range.closed(11, 2147483647));
144 arg = Integer.valueOf("10");
145 expectedMsg = String.format("Invalid range: %s, expected: %s.", arg, rangeConstraints);
146 CompilationTestUtils.assertContainsRestrictionCheck(expectedConstructor, expectedMsg, arg);
147 obj = expectedConstructor.newInstance(2147483647);
148 assertEquals(obj, defInst.invoke(null, "2147483647"));
150 // typedef string-ext1
151 assertFalse(stringExt1Class.isInterface());
152 CompilationTestUtils.assertContainsField(stringExt1Class, VAL, String.class);
153 CompilationTestUtils.assertContainsField(stringExt1Class, "patterns", Pattern.class);
154 CompilationTestUtils.assertContainsField(stringExt1Class, "PATTERN_CONSTANTS", List.class);
155 CompilationTestUtils.assertContainsFieldWithValue(stringExt1Class, "serialVersionUID", Long.TYPE,
156 6943827552297110991L, String.class);
157 assertEquals(5, stringExt1Class.getDeclaredFields().length);
158 expectedConstructor = CompilationTestUtils.assertContainsConstructor(stringExt1Class, String.class);
159 CompilationTestUtils.assertContainsConstructor(stringExt1Class, stringExt1Class);
160 assertEquals(2, stringExt1Class.getDeclaredConstructors().length);
161 CompilationTestUtils.assertContainsMethod(stringExt1Class, String.class, GET_VAL);
162 defInst = CompilationTestUtils.assertContainsMethod(stringExt1Class, stringExt1Class, "getDefaultInstance",
164 CompilationTestUtils.assertContainsDefaultMethods(stringExt1Class);
165 assertEquals(7, stringExt1Class.getDeclaredMethods().length);
167 List<Range<Integer>> lengthConstraints = new ArrayList<>();
168 lengthConstraints.add(Range.closed(5, 11));
170 expectedMsg = String.format("Invalid length: %s, expected: %s.", arg, lengthConstraints);
171 CompilationTestUtils.assertContainsRestrictionCheck(expectedConstructor, expectedMsg, arg);
173 obj = expectedConstructor.newInstance("abcde");
174 assertEquals(obj, defInst.invoke(null, "abcde"));
176 // typedef string-ext2
177 assertFalse(stringExt2Class.isInterface());
178 CompilationTestUtils.assertContainsFieldWithValue(stringExt2Class, "serialVersionUID", Long.TYPE,
179 8100233177432072092L, String.class);
180 assertEquals(1, stringExt2Class.getDeclaredFields().length);
181 expectedConstructor = CompilationTestUtils.assertContainsConstructor(stringExt2Class, String.class);
182 CompilationTestUtils.assertContainsConstructor(stringExt2Class, stringExt2Class);
183 CompilationTestUtils.assertContainsConstructor(stringExt2Class, stringExt1Class);
184 assertEquals(3, stringExt2Class.getDeclaredConstructors().length);
185 defInst = CompilationTestUtils.assertContainsMethod(stringExt2Class, stringExt2Class, "getDefaultInstance",
187 assertEquals(2, stringExt2Class.getDeclaredMethods().length);
189 lengthConstraints.clear();
190 lengthConstraints.add(Range.closed(6, 10));
192 expectedMsg = String.format("Invalid length: %s, expected: %s.", arg, lengthConstraints);
193 CompilationTestUtils.assertContainsRestrictionCheck(expectedConstructor, expectedMsg, arg);
194 obj = expectedConstructor.newInstance("abcdef");
195 assertEquals(obj, defInst.invoke(null, "abcdef"));
197 // typedef string-ext3
198 assertFalse(stringExt3Class.isInterface());
199 CompilationTestUtils.assertContainsFieldWithValue(stringExt3Class, "serialVersionUID", Long.TYPE,
200 -2751063130555484180L, String.class);
201 assertEquals(4, stringExt3Class.getDeclaredFields().length);
202 expectedConstructor = CompilationTestUtils.assertContainsConstructor(stringExt3Class, String.class);
203 CompilationTestUtils.assertContainsConstructor(stringExt3Class, stringExt3Class);
204 CompilationTestUtils.assertContainsConstructor(stringExt3Class, stringExt2Class);
205 assertEquals(3, stringExt3Class.getDeclaredConstructors().length);
206 defInst = CompilationTestUtils.assertContainsMethod(stringExt3Class, stringExt3Class, "getDefaultInstance",
208 assertEquals(1, stringExt3Class.getDeclaredMethods().length);
210 obj = expectedConstructor.newInstance("bbbbbb");
211 assertEquals(obj, defInst.invoke(null, "bbbbbb"));
213 // typedef my-decimal-type
214 assertFalse(myDecimalTypeClass.isInterface());
215 CompilationTestUtils.assertContainsField(myDecimalTypeClass, VAL, Decimal64.class);
216 CompilationTestUtils.assertContainsFieldWithValue(myDecimalTypeClass, "serialVersionUID", Long.TYPE,
217 3143735729419861095L, Decimal64.class);
218 assertEquals(3, myDecimalTypeClass.getDeclaredFields().length);
219 CompilationTestUtils.assertContainsMethod(myDecimalTypeClass, Decimal64.class, "getValue");
220 expectedConstructor = CompilationTestUtils.assertContainsConstructor(myDecimalTypeClass, Decimal64.class);
221 CompilationTestUtils.assertContainsConstructor(myDecimalTypeClass, myDecimalTypeClass);
222 assertEquals(2, myDecimalTypeClass.getDeclaredConstructors().length);
223 CompilationTestUtils.assertContainsMethod(myDecimalTypeClass, Decimal64.class, GET_VAL);
224 CompilationTestUtils.assertContainsDefaultMethods(myDecimalTypeClass);
225 defInst = CompilationTestUtils.assertContainsMethod(myDecimalTypeClass, myDecimalTypeClass,
226 "getDefaultInstance", String.class);
227 assertEquals(7, myDecimalTypeClass.getDeclaredMethods().length);
229 List<Range<Decimal64>> decimalRangeConstraints = new ArrayList<>();
230 decimalRangeConstraints.add(Range.closed(Decimal64.valueOf("1.5"), Decimal64.valueOf("5.5")));
231 arg = Decimal64.valueOf("1.4");
232 expectedMsg = String.format("Invalid range: %s, expected: %s.", arg, decimalRangeConstraints);
233 CompilationTestUtils.assertContainsRestrictionCheck(expectedConstructor, expectedMsg, arg);
234 obj = expectedConstructor.newInstance(Decimal64.valueOf("3.14"));
235 assertEquals(obj, defInst.invoke(null, "3.14"));
237 // typedef my-decimal-type2
238 assertFalse(myDecimalType2Class.isInterface());
239 CompilationTestUtils.assertContainsField(myDecimalType2Class, VAL, Decimal64.class);
240 CompilationTestUtils.assertContainsFieldWithValue(myDecimalType2Class, "serialVersionUID", Long.TYPE,
241 -672265764962082714L, Decimal64.class);
242 assertEquals(3, myDecimalType2Class.getDeclaredFields().length);
243 CompilationTestUtils.assertContainsMethod(myDecimalType2Class, Decimal64.class, "getValue");
244 expectedConstructor = CompilationTestUtils.assertContainsConstructor(myDecimalType2Class, Decimal64.class);
245 CompilationTestUtils.assertContainsConstructor(myDecimalType2Class, myDecimalType2Class);
246 assertEquals(2, myDecimalType2Class.getDeclaredConstructors().length);
247 CompilationTestUtils.assertContainsMethod(myDecimalType2Class, Decimal64.class, GET_VAL);
248 CompilationTestUtils.assertContainsDefaultMethods(myDecimalType2Class);
249 defInst = CompilationTestUtils.assertContainsMethod(myDecimalType2Class, myDecimalType2Class,
250 "getDefaultInstance", String.class);
251 assertEquals(7, myDecimalType2Class.getDeclaredMethods().length);
253 List<Range<Decimal64>> decimal2RangeConstraints = new ArrayList<>();
254 decimal2RangeConstraints.add(Range.closed(Decimal64.valueOf("0.0"), Decimal64.valueOf("1.0")));
255 arg = Decimal64.valueOf("1.4");
256 expectedMsg = String.format("Invalid range: %s, expected: %s.", arg, decimal2RangeConstraints);
257 CompilationTestUtils.assertContainsRestrictionCheck(expectedConstructor, expectedMsg, arg);
258 obj = expectedConstructor.newInstance(Decimal64.valueOf("0.14"));
259 assertEquals(obj, defInst.invoke(null, "0.14"));
261 // typedef union-ext1
262 assertFalse(unionExt1Class.isInterface());
263 CompilationTestUtils.assertContainsField(unionExt1Class, "_int16", Short.class);
264 CompilationTestUtils.assertContainsField(unionExt1Class, "_int32", Integer.class);
265 CompilationTestUtils.assertContainsFieldWithValue(unionExt1Class, "serialVersionUID", Long.TYPE,
266 -6955858981055390623L, new Class<?>[] { Short.class }, Short.valueOf("1"));
267 assertEquals(3, unionExt1Class.getDeclaredFields().length);
268 CompilationTestUtils.assertContainsMethod(unionExt1Class, Short.class, "getInt16");
269 CompilationTestUtils.assertContainsMethod(unionExt1Class, Integer.class, "getInt32");
270 CompilationTestUtils.assertContainsConstructor(unionExt1Class, Short.class);
271 CompilationTestUtils.assertContainsConstructor(unionExt1Class, Integer.class);
272 CompilationTestUtils.assertContainsConstructor(unionExt1Class, unionExt1Class);
273 assertEquals(3, unionExt1Class.getDeclaredConstructors().length);
274 CompilationTestUtils.assertContainsDefaultMethods(unionExt1Class);
276 // typedef union-ext2
277 assertFalse(unionExt2Class.isInterface());
278 CompilationTestUtils.assertContainsFieldWithValue(unionExt2Class, "serialVersionUID", Long.TYPE,
279 -8833407459073585206L, new Class<?>[] { Short.class }, Short.valueOf("1"));
280 assertEquals(1, unionExt2Class.getDeclaredFields().length);
281 assertEquals(1, unionExt2Class.getDeclaredMethods().length);
282 CompilationTestUtils.assertContainsConstructor(unionExt2Class, Short.class);
283 CompilationTestUtils.assertContainsConstructor(unionExt2Class, Integer.class);
284 CompilationTestUtils.assertContainsConstructor(unionExt2Class, unionExt2Class);
285 CompilationTestUtils.assertContainsConstructor(unionExt2Class, unionExt1Class);
286 assertEquals(4, unionExt2Class.getDeclaredConstructors().length);
288 // typedef union-ext3
289 assertFalse(unionExt3Class.isInterface());
290 CompilationTestUtils.assertContainsField(unionExt3Class, "_string", String.class);
291 CompilationTestUtils.assertContainsField(unionExt3Class, "_unionExt2", unionExt2Class);
292 CompilationTestUtils.assertContainsFieldWithValue(unionExt3Class, UNITS, String.class, "object id",
293 new Class<?>[] { String.class }, "");
294 CompilationTestUtils.assertContainsFieldWithValue(unionExt3Class, "serialVersionUID", Long.TYPE,
295 -1558836942803815106L, new Class<?>[] { String.class }, "");
296 assertEquals(4, unionExt3Class.getDeclaredFields().length);
297 CompilationTestUtils.assertContainsMethod(unionExt3Class, String.class, "getString");
298 CompilationTestUtils.assertContainsMethod(unionExt3Class, unionExt2Class, "getUnionExt2");
299 CompilationTestUtils.assertContainsConstructor(unionExt3Class, String.class);
300 CompilationTestUtils.assertContainsConstructor(unionExt3Class, unionExt2Class);
301 CompilationTestUtils.assertContainsConstructor(unionExt3Class, unionExt3Class);
302 assertEquals(3, unionExt3Class.getDeclaredConstructors().length);
303 CompilationTestUtils.assertContainsDefaultMethods(unionExt3Class);
305 // typedef union-ext4
306 assertFalse(unionExt4Class.isInterface());
307 CompilationTestUtils.assertContainsField(unionExt4Class, "_unionExt3", unionExt3Class);
308 CompilationTestUtils.assertContainsField(unionExt4Class, "_int32Ext2", int32Ext2Class);
309 CompilationTestUtils.assertContainsField(unionExt4Class, "_empty", Empty.class);
310 CompilationTestUtils.assertContainsField(unionExt4Class, "_myDecimalType", myDecimalTypeClass);
311 CompilationTestUtils.assertContainsFieldWithValue(unionExt4Class, "serialVersionUID", Long.TYPE,
312 6500918776827711885L, new Class<?>[] { Boolean.class }, false);
313 assertEquals(6, unionExt4Class.getDeclaredFields().length);
314 CompilationTestUtils.assertContainsMethod(unionExt4Class, unionExt3Class, "getUnionExt3");
315 CompilationTestUtils.assertContainsMethod(unionExt4Class, int32Ext2Class, "getInt32Ext2");
316 CompilationTestUtils.assertContainsMethod(unionExt4Class, Empty.class, "getEmpty");
317 CompilationTestUtils.assertContainsMethod(unionExt4Class, myDecimalTypeClass, "getMyDecimalType");
318 CompilationTestUtils.assertContainsMethod(unionExt4Class, bitsExtClass, "getBitsExt");
319 CompilationTestUtils.assertContainsConstructor(unionExt4Class, unionExt3Class);
320 CompilationTestUtils.assertContainsConstructor(unionExt4Class, int32Ext2Class);
321 CompilationTestUtils.assertContainsConstructor(unionExt4Class, Empty.class);
322 CompilationTestUtils.assertContainsConstructor(unionExt4Class, myDecimalTypeClass);
323 CompilationTestUtils.assertContainsConstructor(unionExt4Class, unionExt4Class);
324 assertEquals(6, unionExt4Class.getDeclaredConstructors().length);
325 CompilationTestUtils.assertContainsDefaultMethods(unionExt4Class);
327 CompilationTestUtils.cleanUp(sourcesOutputDir, compiledOutputDir);