Merge "BUG-865: replaced deprecated code from binding-generator-util."

[mdsal.git] / code-generator / binding-java-api-generator / src / test / java / org / opendaylight / yangtools / sal / java / api / generator / test / TypedefCompilationTest.java

diff --git a/code-generator/binding-java-api-generator/src/test/java/org/opendaylight/yangtools/sal/java/api/generator/test/TypedefCompilationTest.java b/code-generator/binding-java-api-generator/src/test/java/org/opendaylight/yangtools/sal/java/api/generator/test/TypedefCompilationTest.java
index 071fa184c9f75249d5c36d97737ce81be6bdd697..887c92cfa159959cdb1d2683101e21a07a3557c3 100644 (file)
--- a/code-generator/binding-java-api-generator/src/test/java/org/opendaylight/yangtools/sal/java/api/generator/test/TypedefCompilationTest.java
+++ b/code-generator/binding-java-api-generator/src/test/java/org/opendaylight/yangtools/sal/java/api/generator/test/TypedefCompilationTest.java
@@ -16,6 +16,7 @@ import java.lang.reflect.Method;
 import java.math.BigDecimal;
 import java.net.URL;
 import java.net.URLClassLoader;
+import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -26,6 +27,8 @@ import org.opendaylight.yangtools.sal.java.api.generator.GeneratorJavaFile;
 import org.opendaylight.yangtools.yang.model.api.Module;
 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
 
+import com.google.common.collect.Range;
+
 /**
  * Test correct code generation.
  *
@@ -74,7 +77,7 @@ public class TypedefCompilationTest extends BaseCompilationTest {
         assertTrue(unionExt2.exists());
         assertTrue(unionExt3.exists());
         assertTrue(unionExt4.exists());
-        assertFilesCount(parent, 27);
+        assertFilesCount(parent, 30);
 
         // Test if sources are compilable
         testCompilation(sourcesOutputDir, compiledOutputDir);
@@ -124,8 +127,14 @@ public class TypedefCompilationTest extends BaseCompilationTest {
         assertContainsDefaultMethods(int32Ext1Class);
         assertContainsMethod(int32Ext1Class, Integer.class, GET_VAL);
         defInst = assertContainsMethod(int32Ext1Class, int32Ext1Class, "getDefaultInstance", String.class);
-        assertEquals(5, int32Ext1Class.getDeclaredMethods().length);
+        assertContainsGetLengthOrRange(int32Ext1Class, false);
+        assertEquals(6, int32Ext1Class.getDeclaredMethods().length);
 
+        List<Range<Integer>> rangeConstraints = new ArrayList<>();
+        rangeConstraints.add(Range.closed(new Integer("2"), new Integer("2147483647")));
+        Object arg = new Integer("1");
+        String expectedMsg = String.format("Invalid range: %s, expected: %s.", arg, rangeConstraints);
+        assertContainsRestrictionCheck(expectedConstructor, expectedMsg, arg);
         obj = expectedConstructor.newInstance(new Integer("159"));
         assertEquals(obj, defInst.invoke(null, "159"));
 
@@ -139,10 +148,17 @@ public class TypedefCompilationTest extends BaseCompilationTest {
         assertEquals(3, int32Ext2Class.getDeclaredConstructors().length);
         assertContainsMethod(int32Ext2Class, String.class, "toString");
         defInst = assertContainsMethod(int32Ext2Class, int32Ext2Class, "getDefaultInstance", String.class);
-        assertEquals(2, int32Ext2Class.getDeclaredMethods().length);
+        assertContainsGetLengthOrRange(int32Ext2Class, false);
+        assertEquals(3, int32Ext2Class.getDeclaredMethods().length);
 
-        obj = expectedConstructor.newInstance(new Integer("159"));
-        assertEquals(obj, defInst.invoke(null, "159"));
+        rangeConstraints.clear();
+        rangeConstraints.add(Range.closed(new Integer("3"), new Integer("9")));
+        rangeConstraints.add(Range.closed(new Integer("11"), new Integer("2147483647")));
+        arg = new Integer("10");
+        expectedMsg = String.format("Invalid range: %s, expected: %s.", arg, rangeConstraints);
+        assertContainsRestrictionCheck(expectedConstructor, expectedMsg, arg);
+        obj = expectedConstructor.newInstance(new Integer("2147483647"));
+        assertEquals(obj, defInst.invoke(null, "2147483647"));
 
         // typedef string-ext1
         assertFalse(stringExt1Class.isInterface());
@@ -156,9 +172,14 @@ public class TypedefCompilationTest extends BaseCompilationTest {
         assertContainsMethod(stringExt1Class, String.class, GET_VAL);
         defInst = assertContainsMethod(stringExt1Class, stringExt1Class, "getDefaultInstance", String.class);
         assertContainsDefaultMethods(stringExt1Class);
-        assertContainsGetLength(stringExt1Class);
+        assertContainsGetLengthOrRange(stringExt1Class, true);
         assertEquals(6, stringExt1Class.getDeclaredMethods().length);
 
+        List<Range<Integer>> lengthConstraints = new ArrayList<>();
+        lengthConstraints.add(Range.closed(5, 11));
+        arg = "abcd";
+        expectedMsg = String.format("Invalid length: %s, expected: %s.", arg, lengthConstraints);
+        assertContainsRestrictionCheck(expectedConstructor, expectedMsg, arg);
         obj = expectedConstructor.newInstance("hello world");
         assertEquals(obj, defInst.invoke(null, "hello world"));
 
@@ -169,10 +190,15 @@ public class TypedefCompilationTest extends BaseCompilationTest {
         assertContainsConstructor(stringExt2Class, stringExt2Class);
         assertContainsConstructor(stringExt2Class, stringExt1Class);
         assertEquals(3, stringExt2Class.getDeclaredConstructors().length);
-        assertContainsGetLength(stringExt2Class);
+        assertContainsGetLengthOrRange(stringExt2Class, true);
         defInst = assertContainsMethod(stringExt2Class, stringExt2Class, "getDefaultInstance", String.class);
         assertEquals(2, stringExt2Class.getDeclaredMethods().length);
 
+        lengthConstraints.clear();
+        lengthConstraints.add(Range.closed(6, 10));
+        arg = "abcde";
+        expectedMsg = String.format("Invalid length: %s, expected: %s.", arg, lengthConstraints);
+        assertContainsRestrictionCheck(expectedConstructor, expectedMsg, arg);
         obj = expectedConstructor.newInstance("helloWorld");
         assertEquals(obj, defInst.invoke(null, "helloWorld"));
 
@@ -200,8 +226,14 @@ public class TypedefCompilationTest extends BaseCompilationTest {
         assertContainsMethod(myDecimalTypeClass, BigDecimal.class, GET_VAL);
         assertContainsDefaultMethods(myDecimalTypeClass);
         defInst = assertContainsMethod(myDecimalTypeClass, myDecimalTypeClass, "getDefaultInstance", String.class);
-        assertEquals(5, myDecimalTypeClass.getDeclaredMethods().length);
+        assertContainsGetLengthOrRange(myDecimalTypeClass, false);
+        assertEquals(6, myDecimalTypeClass.getDeclaredMethods().length);
 
+        List<Range<BigDecimal>> decimalRangeConstraints = new ArrayList<>();
+        decimalRangeConstraints.add(Range.closed(new BigDecimal("1.5"), new BigDecimal("5.5")));
+        arg = new BigDecimal("1.4");
+        expectedMsg = String.format("Invalid range: %s, expected: %s.", arg, decimalRangeConstraints);
+        assertContainsRestrictionCheck(expectedConstructor, expectedMsg, arg);
         obj = expectedConstructor.newInstance(new BigDecimal("3.14"));
         assertEquals(obj, defInst.invoke(null, "3.14"));
 
@@ -209,13 +241,13 @@ public class TypedefCompilationTest extends BaseCompilationTest {
         assertFalse(unionExt1Class.isInterface());
         assertContainsField(unionExt1Class, "_int16", Short.class);
         assertContainsField(unionExt1Class, "_int32", Integer.class);
-        assertEquals(2, unionExt1Class.getDeclaredFields().length);
+        assertEquals(3, unionExt1Class.getDeclaredFields().length);
         assertContainsMethod(unionExt1Class, Short.class, "getInt16");
         assertContainsMethod(unionExt1Class, Integer.class, "getInt32");
         assertContainsConstructor(unionExt1Class, Short.class);
         assertContainsConstructor(unionExt1Class, Integer.class);
         assertContainsConstructor(unionExt1Class, unionExt1Class);
-        assertEquals(3, unionExt1Class.getDeclaredConstructors().length);
+        assertEquals(4, unionExt1Class.getDeclaredConstructors().length);
         assertContainsDefaultMethods(unionExt1Class);
 
         // typedef union-ext2
@@ -226,20 +258,20 @@ public class TypedefCompilationTest extends BaseCompilationTest {
         assertContainsConstructor(unionExt2Class, Integer.class);
         assertContainsConstructor(unionExt2Class, unionExt2Class);
         assertContainsConstructor(unionExt2Class, unionExt1Class);
-        assertEquals(4, unionExt2Class.getDeclaredConstructors().length);
+        assertEquals(5, unionExt2Class.getDeclaredConstructors().length);
 
         // typedef union-ext3
         assertFalse(unionExt3Class.isInterface());
         assertContainsField(unionExt3Class, "_string", String.class);
         assertContainsField(unionExt3Class, "_unionExt2", unionExt2Class);
         assertContainsFieldWithValue(unionExt3Class, UNITS, String.class, "object id", String.class);
-        assertEquals(3, unionExt3Class.getDeclaredFields().length);
+        assertEquals(4, unionExt3Class.getDeclaredFields().length);
         assertContainsMethod(unionExt3Class, String.class, "getString");
         assertContainsMethod(unionExt3Class, unionExt2Class, "getUnionExt2");
         assertContainsConstructor(unionExt3Class, String.class);
         assertContainsConstructor(unionExt3Class, unionExt2Class);
         assertContainsConstructor(unionExt3Class, unionExt3Class);
-        assertEquals(3, unionExt3Class.getDeclaredConstructors().length);
+        assertEquals(4, unionExt3Class.getDeclaredConstructors().length);
         assertContainsDefaultMethods(unionExt3Class);
 
         // typedef union-ext4
@@ -248,7 +280,7 @@ public class TypedefCompilationTest extends BaseCompilationTest {
         assertContainsField(unionExt4Class, "_int32Ext2", int32Ext2Class);
         assertContainsField(unionExt4Class, "_empty", Boolean.class);
         assertContainsField(unionExt4Class, "_myDecimalType", myDecimalTypeClass);
-        assertEquals(4, unionExt4Class.getDeclaredFields().length);
+        assertEquals(5, unionExt4Class.getDeclaredFields().length);
         assertContainsMethod(unionExt4Class, unionExt3Class, "getUnionExt3");
         assertContainsMethod(unionExt4Class, int32Ext2Class, "getInt32Ext2");
         assertContainsMethod(unionExt4Class, Boolean.class, "isEmpty");
@@ -258,7 +290,7 @@ public class TypedefCompilationTest extends BaseCompilationTest {
         assertContainsConstructor(unionExt4Class, Boolean.class);
         assertContainsConstructor(unionExt4Class, myDecimalTypeClass);
         assertContainsConstructor(unionExt4Class, unionExt4Class);
-        assertEquals(5, unionExt4Class.getDeclaredConstructors().length);
+        assertEquals(6, unionExt4Class.getDeclaredConstructors().length);
         assertContainsDefaultMethods(unionExt4Class);
 
         //cleanUp(sourcesOutputDir, compiledOutputDir);