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, 31);
56 // Test if sources are compilable
57 CompilationTestUtils.testCompilation(sourcesOutputDir, compiledOutputDir);
59 String pkg = CompilationTestUtils.BASE_PKG + ".urn.opendaylight.foo.rev131008";
60 final ClassLoader loader = new URLClassLoader(new URL[] { compiledOutputDir.toURI().toURL() });
61 final Class<?> bitsExtClass = Class.forName(pkg + ".BitsExt", true, loader);
62 final Class<?> int32Ext1Class = Class.forName(pkg + ".Int32Ext1", true, loader);
63 final Class<?> int32Ext2Class = Class.forName(pkg + ".Int32Ext2", true, loader);
64 final Class<?> myDecimalTypeClass = Class.forName(pkg + ".MyDecimalType", true, loader);
65 final Class<?> myDecimalType2Class = Class.forName(pkg + ".MyDecimalType2", true, loader);
66 final Class<?> stringExt1Class = Class.forName(pkg + ".StringExt1", true, loader);
67 final Class<?> stringExt2Class = Class.forName(pkg + ".StringExt2", true, loader);
68 final Class<?> stringExt3Class = Class.forName(pkg + ".StringExt3", true, loader);
69 final Class<?> unionExt1Class = Class.forName(pkg + ".UnionExt1", true, loader);
70 final Class<?> unionExt2Class = Class.forName(pkg + ".UnionExt2", true, loader);
71 final Class<?> unionExt3Class = Class.forName(pkg + ".UnionExt3", true, loader);
72 final Class<?> unionExt4Class = Class.forName(pkg + ".UnionExt4", true, loader);
75 assertFalse(bitsExtClass.isInterface());
76 CompilationTestUtils.assertContainsField(bitsExtClass, "_pc", boolean.class);
77 CompilationTestUtils.assertContainsField(bitsExtClass, "_bpc", boolean.class);
78 CompilationTestUtils.assertContainsField(bitsExtClass, "_dpc", boolean.class);
79 CompilationTestUtils.assertContainsField(bitsExtClass, "_lbpc", boolean.class);
80 CompilationTestUtils.assertContainsField(bitsExtClass, "_spc", boolean.class);
81 CompilationTestUtils.assertContainsField(bitsExtClass, "_sfmof", boolean.class);
82 CompilationTestUtils.assertContainsField(bitsExtClass, "_sfapc", boolean.class);
83 CompilationTestUtils.assertContainsFieldWithValue(bitsExtClass, "serialVersionUID", Long.TYPE,
84 -2922917845344851623L, boolean.class, boolean.class, boolean.class, boolean.class, boolean.class,
85 boolean.class, boolean.class);
87 assertEquals(8, bitsExtClass.getDeclaredFields().length);
88 CompilationTestUtils.assertContainsConstructor(bitsExtClass, bitsExtClass);
89 assertEquals(2, bitsExtClass.getConstructors().length);
90 Method defInst = CompilationTestUtils.assertContainsMethod(bitsExtClass, bitsExtClass, "getDefaultInstance",
92 CompilationTestUtils.assertContainsDefaultMethods(bitsExtClass);
93 assertEquals(12, bitsExtClass.getDeclaredMethods().length);
95 Constructor<?> expectedConstructor = CompilationTestUtils.assertContainsConstructor(bitsExtClass, boolean.class,
96 boolean.class, boolean.class, boolean.class, boolean.class, boolean.class, boolean.class);
97 Object obj = expectedConstructor.newInstance(false, false, false, false, false, true, false);
98 assertEquals(obj, defInst.invoke(true, "sfmof"));
100 // typedef int32-ext1
101 assertFalse(int32Ext1Class.isInterface());
102 CompilationTestUtils.assertContainsField(int32Ext1Class, VAL, Integer.class);
103 CompilationTestUtils.assertContainsFieldWithValue(int32Ext1Class, "serialVersionUID", Long.TYPE,
104 5351634010010233292L, Integer.class);
105 assertEquals(2, int32Ext1Class.getDeclaredFields().length);
107 expectedConstructor = CompilationTestUtils.assertContainsConstructor(int32Ext1Class, Integer.class);
108 CompilationTestUtils.assertContainsConstructor(int32Ext1Class, int32Ext1Class);
109 assertEquals(2, int32Ext1Class.getConstructors().length);
110 CompilationTestUtils.assertContainsDefaultMethods(int32Ext1Class);
111 CompilationTestUtils.assertContainsMethod(int32Ext1Class, Integer.class, GET_VAL);
112 defInst = CompilationTestUtils.assertContainsMethod(int32Ext1Class, int32Ext1Class, "getDefaultInstance",
114 assertEquals(7, int32Ext1Class.getDeclaredMethods().length);
116 List<Range<Integer>> rangeConstraints = new ArrayList<>();
117 rangeConstraints.add(Range.closed(2, 2147483647));
119 String expectedMsg = String.format("Invalid range: %s, expected: %s.", arg, rangeConstraints);
120 CompilationTestUtils.assertContainsRestrictionCheck(expectedConstructor, expectedMsg, arg);
121 obj = expectedConstructor.newInstance(159);
122 assertEquals(obj, defInst.invoke(null, "159"));
124 // typedef int32-ext2
125 assertFalse(int32Ext2Class.isInterface());
126 CompilationTestUtils.assertContainsFieldWithValue(int32Ext2Class, UNITS, String.class, "mile", Integer.class);
127 CompilationTestUtils.assertContainsFieldWithValue(int32Ext2Class, "serialVersionUID", Long.TYPE,
128 317831889060130988L, Integer.class);
129 assertEquals(2, int32Ext2Class.getDeclaredFields().length);
130 expectedConstructor = CompilationTestUtils.assertContainsConstructor(int32Ext2Class, Integer.class);
131 CompilationTestUtils.assertContainsConstructor(int32Ext2Class, int32Ext2Class);
132 CompilationTestUtils.assertContainsConstructor(int32Ext2Class, int32Ext1Class);
133 assertEquals(3, int32Ext2Class.getDeclaredConstructors().length);
134 CompilationTestUtils.assertContainsMethod(int32Ext2Class, String.class, "toString");
135 defInst = CompilationTestUtils.assertContainsMethod(int32Ext2Class, int32Ext2Class, "getDefaultInstance",
137 assertEquals(3, int32Ext2Class.getDeclaredMethods().length);
139 rangeConstraints.clear();
140 rangeConstraints.add(Range.closed(3, 9));
141 rangeConstraints.add(Range.closed(11, 2147483647));
142 arg = Integer.valueOf("10");
143 expectedMsg = String.format("Invalid range: %s, expected: %s.", arg, rangeConstraints);
144 CompilationTestUtils.assertContainsRestrictionCheck(expectedConstructor, expectedMsg, arg);
145 obj = expectedConstructor.newInstance(2147483647);
146 assertEquals(obj, defInst.invoke(null, "2147483647"));
148 // typedef string-ext1
149 assertFalse(stringExt1Class.isInterface());
150 CompilationTestUtils.assertContainsField(stringExt1Class, VAL, String.class);
151 CompilationTestUtils.assertContainsField(stringExt1Class, "patterns", Pattern.class);
152 CompilationTestUtils.assertContainsField(stringExt1Class, "PATTERN_CONSTANTS", List.class);
153 CompilationTestUtils.assertContainsFieldWithValue(stringExt1Class, "serialVersionUID", Long.TYPE,
154 6943827552297110991L, String.class);
155 assertEquals(5, stringExt1Class.getDeclaredFields().length);
156 expectedConstructor = CompilationTestUtils.assertContainsConstructor(stringExt1Class, String.class);
157 CompilationTestUtils.assertContainsConstructor(stringExt1Class, stringExt1Class);
158 assertEquals(2, stringExt1Class.getDeclaredConstructors().length);
159 CompilationTestUtils.assertContainsMethod(stringExt1Class, String.class, GET_VAL);
160 defInst = CompilationTestUtils.assertContainsMethod(stringExt1Class, stringExt1Class, "getDefaultInstance",
162 CompilationTestUtils.assertContainsDefaultMethods(stringExt1Class);
163 assertEquals(7, stringExt1Class.getDeclaredMethods().length);
165 List<Range<Integer>> lengthConstraints = new ArrayList<>();
166 lengthConstraints.add(Range.closed(5, 11));
168 expectedMsg = String.format("Invalid length: %s, expected: %s.", arg, lengthConstraints);
169 CompilationTestUtils.assertContainsRestrictionCheck(expectedConstructor, expectedMsg, arg);
171 obj = expectedConstructor.newInstance("abcde");
172 assertEquals(obj, defInst.invoke(null, "abcde"));
174 // typedef string-ext2
175 assertFalse(stringExt2Class.isInterface());
176 CompilationTestUtils.assertContainsFieldWithValue(stringExt2Class, "serialVersionUID", Long.TYPE,
177 8100233177432072092L, String.class);
178 assertEquals(1, stringExt2Class.getDeclaredFields().length);
179 expectedConstructor = CompilationTestUtils.assertContainsConstructor(stringExt2Class, String.class);
180 CompilationTestUtils.assertContainsConstructor(stringExt2Class, stringExt2Class);
181 CompilationTestUtils.assertContainsConstructor(stringExt2Class, stringExt1Class);
182 assertEquals(3, stringExt2Class.getDeclaredConstructors().length);
183 defInst = CompilationTestUtils.assertContainsMethod(stringExt2Class, stringExt2Class, "getDefaultInstance",
185 assertEquals(2, stringExt2Class.getDeclaredMethods().length);
187 lengthConstraints.clear();
188 lengthConstraints.add(Range.closed(6, 10));
190 expectedMsg = String.format("Invalid length: %s, expected: %s.", arg, lengthConstraints);
191 CompilationTestUtils.assertContainsRestrictionCheck(expectedConstructor, expectedMsg, arg);
192 obj = expectedConstructor.newInstance("abcdef");
193 assertEquals(obj, defInst.invoke(null, "abcdef"));
195 // typedef string-ext3
196 assertFalse(stringExt3Class.isInterface());
197 CompilationTestUtils.assertContainsFieldWithValue(stringExt3Class, "serialVersionUID", Long.TYPE,
198 -2751063130555484180L, String.class);
199 assertEquals(4, stringExt3Class.getDeclaredFields().length);
200 expectedConstructor = CompilationTestUtils.assertContainsConstructor(stringExt3Class, String.class);
201 CompilationTestUtils.assertContainsConstructor(stringExt3Class, stringExt3Class);
202 CompilationTestUtils.assertContainsConstructor(stringExt3Class, stringExt2Class);
203 assertEquals(3, stringExt3Class.getDeclaredConstructors().length);
204 defInst = CompilationTestUtils.assertContainsMethod(stringExt3Class, stringExt3Class, "getDefaultInstance",
206 assertEquals(1, stringExt3Class.getDeclaredMethods().length);
208 obj = expectedConstructor.newInstance("bbbbbb");
209 assertEquals(obj, defInst.invoke(null, "bbbbbb"));
211 // typedef my-decimal-type
212 assertFalse(myDecimalTypeClass.isInterface());
213 CompilationTestUtils.assertContainsField(myDecimalTypeClass, VAL, Decimal64.class);
214 CompilationTestUtils.assertContainsFieldWithValue(myDecimalTypeClass, "serialVersionUID", Long.TYPE,
215 3143735729419861095L, Decimal64.class);
216 assertEquals(3, myDecimalTypeClass.getDeclaredFields().length);
217 CompilationTestUtils.assertContainsMethod(myDecimalTypeClass, Decimal64.class, "getValue");
218 expectedConstructor = CompilationTestUtils.assertContainsConstructor(myDecimalTypeClass, Decimal64.class);
219 CompilationTestUtils.assertContainsConstructor(myDecimalTypeClass, myDecimalTypeClass);
220 assertEquals(2, myDecimalTypeClass.getDeclaredConstructors().length);
221 CompilationTestUtils.assertContainsMethod(myDecimalTypeClass, Decimal64.class, GET_VAL);
222 CompilationTestUtils.assertContainsDefaultMethods(myDecimalTypeClass);
223 defInst = CompilationTestUtils.assertContainsMethod(myDecimalTypeClass, myDecimalTypeClass,
224 "getDefaultInstance", String.class);
225 assertEquals(7, myDecimalTypeClass.getDeclaredMethods().length);
227 List<Range<Decimal64>> decimalRangeConstraints = new ArrayList<>();
228 decimalRangeConstraints.add(Range.closed(Decimal64.valueOf("1.5"), Decimal64.valueOf("5.5")));
229 arg = Decimal64.valueOf("1.4");
230 expectedMsg = String.format("Invalid range: %s, expected: %s.", arg, decimalRangeConstraints);
231 CompilationTestUtils.assertContainsRestrictionCheck(expectedConstructor, expectedMsg, arg);
232 obj = expectedConstructor.newInstance(Decimal64.valueOf("3.14"));
233 assertEquals(obj, defInst.invoke(null, "3.14"));
235 // typedef my-decimal-type2
236 assertFalse(myDecimalType2Class.isInterface());
237 CompilationTestUtils.assertContainsField(myDecimalType2Class, VAL, Decimal64.class);
238 CompilationTestUtils.assertContainsFieldWithValue(myDecimalType2Class, "serialVersionUID", Long.TYPE,
239 -672265764962082714L, Decimal64.class);
240 assertEquals(3, myDecimalType2Class.getDeclaredFields().length);
241 CompilationTestUtils.assertContainsMethod(myDecimalType2Class, Decimal64.class, "getValue");
242 expectedConstructor = CompilationTestUtils.assertContainsConstructor(myDecimalType2Class, Decimal64.class);
243 CompilationTestUtils.assertContainsConstructor(myDecimalType2Class, myDecimalType2Class);
244 assertEquals(2, myDecimalType2Class.getDeclaredConstructors().length);
245 CompilationTestUtils.assertContainsMethod(myDecimalType2Class, Decimal64.class, GET_VAL);
246 CompilationTestUtils.assertContainsDefaultMethods(myDecimalType2Class);
247 defInst = CompilationTestUtils.assertContainsMethod(myDecimalType2Class, myDecimalType2Class,
248 "getDefaultInstance", String.class);
249 assertEquals(7, myDecimalType2Class.getDeclaredMethods().length);
251 List<Range<Decimal64>> decimal2RangeConstraints = new ArrayList<>();
252 decimal2RangeConstraints.add(Range.closed(Decimal64.valueOf("0.0"), Decimal64.valueOf("1.0")));
253 arg = Decimal64.valueOf("1.4");
254 expectedMsg = String.format("Invalid range: %s, expected: %s.", arg, decimal2RangeConstraints);
255 CompilationTestUtils.assertContainsRestrictionCheck(expectedConstructor, expectedMsg, arg);
256 obj = expectedConstructor.newInstance(Decimal64.valueOf("0.14"));
257 assertEquals(obj, defInst.invoke(null, "0.14"));
259 // typedef union-ext1
260 assertFalse(unionExt1Class.isInterface());
261 CompilationTestUtils.assertContainsField(unionExt1Class, "_int16", Short.class);
262 CompilationTestUtils.assertContainsField(unionExt1Class, "_int32", Integer.class);
263 CompilationTestUtils.assertContainsFieldWithValue(unionExt1Class, "serialVersionUID", Long.TYPE,
264 -6955858981055390623L, new Class<?>[] { Short.class }, Short.valueOf("1"));
265 assertEquals(3, unionExt1Class.getDeclaredFields().length);
266 CompilationTestUtils.assertContainsMethod(unionExt1Class, Short.class, "getInt16");
267 CompilationTestUtils.assertContainsMethod(unionExt1Class, Integer.class, "getInt32");
268 CompilationTestUtils.assertContainsConstructor(unionExt1Class, Short.class);
269 CompilationTestUtils.assertContainsConstructor(unionExt1Class, Integer.class);
270 CompilationTestUtils.assertContainsConstructor(unionExt1Class, unionExt1Class);
271 assertEquals(3, unionExt1Class.getDeclaredConstructors().length);
272 CompilationTestUtils.assertContainsDefaultMethods(unionExt1Class);
274 // typedef union-ext2
275 assertFalse(unionExt2Class.isInterface());
276 CompilationTestUtils.assertContainsFieldWithValue(unionExt2Class, "serialVersionUID", Long.TYPE,
277 -8833407459073585206L, new Class<?>[] { Short.class }, Short.valueOf("1"));
278 assertEquals(1, unionExt2Class.getDeclaredFields().length);
279 assertEquals(1, unionExt2Class.getDeclaredMethods().length);
280 CompilationTestUtils.assertContainsConstructor(unionExt2Class, Short.class);
281 CompilationTestUtils.assertContainsConstructor(unionExt2Class, Integer.class);
282 CompilationTestUtils.assertContainsConstructor(unionExt2Class, unionExt2Class);
283 CompilationTestUtils.assertContainsConstructor(unionExt2Class, unionExt1Class);
284 assertEquals(4, unionExt2Class.getDeclaredConstructors().length);
286 // typedef union-ext3
287 assertFalse(unionExt3Class.isInterface());
288 CompilationTestUtils.assertContainsField(unionExt3Class, "_string", String.class);
289 CompilationTestUtils.assertContainsField(unionExt3Class, "_unionExt2", unionExt2Class);
290 CompilationTestUtils.assertContainsFieldWithValue(unionExt3Class, UNITS, String.class, "object id",
291 new Class<?>[] { String.class }, "");
292 CompilationTestUtils.assertContainsFieldWithValue(unionExt3Class, "serialVersionUID", Long.TYPE,
293 -1558836942803815106L, new Class<?>[] { String.class }, "");
294 assertEquals(4, unionExt3Class.getDeclaredFields().length);
295 CompilationTestUtils.assertContainsMethod(unionExt3Class, String.class, "getString");
296 CompilationTestUtils.assertContainsMethod(unionExt3Class, unionExt2Class, "getUnionExt2");
297 CompilationTestUtils.assertContainsConstructor(unionExt3Class, String.class);
298 CompilationTestUtils.assertContainsConstructor(unionExt3Class, unionExt2Class);
299 CompilationTestUtils.assertContainsConstructor(unionExt3Class, unionExt3Class);
300 assertEquals(3, unionExt3Class.getDeclaredConstructors().length);
301 CompilationTestUtils.assertContainsDefaultMethods(unionExt3Class);
303 // typedef union-ext4
304 assertFalse(unionExt4Class.isInterface());
305 CompilationTestUtils.assertContainsField(unionExt4Class, "_unionExt3", unionExt3Class);
306 CompilationTestUtils.assertContainsField(unionExt4Class, "_int32Ext2", int32Ext2Class);
307 CompilationTestUtils.assertContainsField(unionExt4Class, "_empty", Empty.class);
308 CompilationTestUtils.assertContainsField(unionExt4Class, "_myDecimalType", myDecimalTypeClass);
309 CompilationTestUtils.assertContainsFieldWithValue(unionExt4Class, "serialVersionUID", Long.TYPE,
310 8089656970520476667L, new Class<?>[] { Boolean.class }, false);
311 assertEquals(5, unionExt4Class.getDeclaredFields().length);
312 CompilationTestUtils.assertContainsMethod(unionExt4Class, unionExt3Class, "getUnionExt3");
313 CompilationTestUtils.assertContainsMethod(unionExt4Class, int32Ext2Class, "getInt32Ext2");
314 CompilationTestUtils.assertContainsMethod(unionExt4Class, Empty.class, "getEmpty");
315 CompilationTestUtils.assertContainsMethod(unionExt4Class, myDecimalTypeClass, "getMyDecimalType");
316 CompilationTestUtils.assertContainsConstructor(unionExt4Class, unionExt3Class);
317 CompilationTestUtils.assertContainsConstructor(unionExt4Class, int32Ext2Class);
318 CompilationTestUtils.assertContainsConstructor(unionExt4Class, Empty.class);
319 CompilationTestUtils.assertContainsConstructor(unionExt4Class, myDecimalTypeClass);
320 CompilationTestUtils.assertContainsConstructor(unionExt4Class, unionExt4Class);
321 assertEquals(5, unionExt4Class.getDeclaredConstructors().length);
322 CompilationTestUtils.assertContainsDefaultMethods(unionExt4Class);
324 CompilationTestUtils.cleanUp(sourcesOutputDir, compiledOutputDir);