(#706) : Default value for property of "integer enum" type caused POJ…

jsonschema2pojo-core/src/main/java/org/jsonschema2pojo/rules/DefaultRule.java

@@ -27,6 +27,8 @@
 import com.sun.codemodel.JFieldVar;
 import com.sun.codemodel.JInvocation;
 import com.sun.codemodel.JType;
+import com.sun.codemodel.JMethod;
+import com.sun.codemodel.JMod;
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
@@ -38,11 +40,12 @@
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
-import static org.apache.commons.lang3.StringUtils.*;
+import static org.apache.commons.lang3.StringUtils.isNotEmpty;
 import org.joda.time.DateTime;
 import org.joda.time.LocalDate;
 import org.joda.time.LocalTime;
 import org.jsonschema2pojo.Schema;
+import org.jsonschema2pojo.exception.GenerationException;
 
 /**
  * Applies the "enum" schema rule.
@@ -134,7 +137,7 @@ private JExpression getDefaultValue(JType fieldType, JsonNode node) {
             return newDateTime;
 
         } else if (fieldType.fullName().equals(LocalDate.class.getName()) ||
-                   fieldType.fullName().equals(LocalTime.class.getName())) {
+                fieldType.fullName().equals(LocalTime.class.getName())) {
 
             JInvocation stringParseableTypeInstance = JExpr._new(fieldType);
             stringParseableTypeInstance.arg(JExpr.lit(node.asText()));
@@ -152,7 +155,7 @@ private JExpression getDefaultValue(JType fieldType, JsonNode node) {
 
         } else if (fieldType instanceof JDefinedClass && ((JDefinedClass) fieldType).getClassType().equals(ClassType.ENUM)) {
 
-            return getDefaultEnum(fieldType, node);
+            return getDefaultEnum((JDefinedClass)fieldType, node);
 
         } else {
             return JExpr._null();
@@ -243,11 +246,35 @@ private JExpression getDefaultSet(JType fieldType, JsonNode node) {
 
     }
 
-    private JExpression getDefaultEnum(JType fieldType, JsonNode node) {
+    private JType getParameterType(JDefinedClass fieldType, String methodName){
 
-        JInvocation invokeFromValue = ((JClass) fieldType).staticInvoke("fromValue");
-        invokeFromValue.arg(node.asText());
+        for (JMethod method : fieldType.methods()) {
+            if (EnumRule.FROM_VALUE_METHOD_NAME.equals(method.name())
+                    && (method.mods().getValue() & JMod.PUBLIC) == JMod.PUBLIC
+                    && (method.mods().getValue() & JMod.STATIC) == JMod.STATIC) {
+                final JType[] type = method.listParamTypes();
+                if (type.length != 1)
+                    throw new GenerationException("Factory method '" + EnumRule.FROM_VALUE_METHOD_NAME + "' should has only one parameter in " + fieldType);
+                return type[0];
+            }
+        }
+        throw new GenerationException("Factory method '" + EnumRule.FROM_VALUE_METHOD_NAME + "' is not found in " + fieldType);
+
+    }
 
+    private JExpression getDefaultEnum(JDefinedClass fieldType, JsonNode node) {
+
+        JInvocation invokeFromValue = fieldType.staticInvoke(EnumRule.FROM_VALUE_METHOD_NAME);
+        JType paramType = getParameterType(fieldType, EnumRule.FROM_VALUE_METHOD_NAME).unboxify();
+        if (paramType == paramType.owner().INT) {
+            invokeFromValue.arg(JExpr.lit(node.asInt()));
+        } else if (paramType == paramType.owner().DOUBLE) {
+            invokeFromValue.arg(JExpr.lit(node.asDouble()));
+        } else if (paramType == paramType.owner().BOOLEAN) {
+            invokeFromValue.arg(JExpr.lit(node.asBoolean()));
+        } else {
+            invokeFromValue.arg(node.asText());
+        }
         return invokeFromValue;
 
     }

jsonschema2pojo-core/src/main/java/org/jsonschema2pojo/rules/EnumRule.java

@@ -62,6 +62,7 @@
 public class EnumRule implements Rule<JClassContainer, JType> {
 
     private static final String VALUE_FIELD_NAME = "value";
+    public static final String FROM_VALUE_METHOD_NAME = "fromValue";
 
     private final RuleFactory ruleFactory;
 
@@ -166,8 +167,8 @@ private JDefinedClass createEnum(JsonNode node, String nodeName, JClassContainer
     private void addFactoryMethod(JDefinedClass _enum, JType backingType) {
         JFieldVar quickLookupMap = addQuickLookupMap(_enum, backingType);
 
-        JMethod fromValue = _enum.method(JMod.PUBLIC | JMod.STATIC, _enum, "fromValue");
-        JVar valueParam = fromValue.param(backingType, "value");
+        JMethod fromValue = _enum.method(JMod.PUBLIC | JMod.STATIC, _enum, FROM_VALUE_METHOD_NAME);
+        JVar valueParam = fromValue.param(backingType, VALUE_FIELD_NAME);
 
         JBlock body = fromValue.body();
         JVar constant = body.decl(_enum, "constant");
@@ -200,7 +201,7 @@ private JFieldVar addQuickLookupMap(JDefinedClass _enum, JType backingType) {
 
         JForEach forEach = _enum.init().forEach(_enum, "c", JExpr.invoke("values"));
         JInvocation put = forEach.body().invoke(lookupMap, "put");
-        put.arg(forEach.var().ref("value"));
+        put.arg(forEach.var().ref(VALUE_FIELD_NAME));
         put.arg(forEach.var());
 
         return lookupMap;
@@ -232,7 +233,7 @@ private void addToString(JDefinedClass _enum, JFieldVar valueField) {
     }
 
     private void addValueMethod(JDefinedClass _enum, JFieldVar valueField) {
-        JMethod fromValue = _enum.method(JMod.PUBLIC, valueField.type(), "value");
+        JMethod fromValue = _enum.method(JMod.PUBLIC, valueField.type(), VALUE_FIELD_NAME);
 
         JBlock body = fromValue.body();
         body._return(JExpr._this().ref(valueField));

jsonschema2pojo-integration-tests/src/test/java/org/jsonschema2pojo/integration/EnumIT.java

@@ -27,6 +27,7 @@
 
 import org.hamcrest.core.IsInstanceOf;
 import org.jsonschema2pojo.integration.util.Jsonschema2PojoRule;
+import org.jsonschema2pojo.rules.EnumRule;
 import org.junit.BeforeClass;
 import org.junit.ClassRule;
 import org.junit.Rule;
@@ -95,7 +96,7 @@ public void enumContainsWorkingAnnotatedSerializationMethod() throws NoSuchMetho
     @Test
     public void enumContainsWorkingAnnotatedDeserializationMethod() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
 
-        Method fromValue = enumClass.getMethod("fromValue", String.class);
+        Method fromValue = enumClass.getMethod(EnumRule.FROM_VALUE_METHOD_NAME, String.class);
 
         assertThat((Enum) fromValue.invoke(enumClass, "one"), is(sameInstance(enumClass.getEnumConstants()[0])));
         assertThat((Enum) fromValue.invoke(enumClass, "secondOne"), is(sameInstance(enumClass.getEnumConstants()[1])));
@@ -108,7 +109,7 @@ public void enumContainsWorkingAnnotatedDeserializationMethod() throws NoSuchMet
     @Test
     public void enumDeserializationMethodRejectsInvalidValues() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
 
-        Method fromValue = enumClass.getMethod("fromValue", String.class);
+        Method fromValue = enumClass.getMethod(EnumRule.FROM_VALUE_METHOD_NAME, String.class);
 
         try {
             fromValue.invoke(enumClass, "something invalid");
@@ -141,7 +142,7 @@ public void intEnumAtRootCreatesIntBackedEnum() throws ClassNotFoundException, N
         Class<Enum> rootEnumClass = (Class<Enum>) resultsClassLoader.loadClass("com.example.enums.IntegerEnumAsRoot");
 
         assertThat(rootEnumClass.isEnum(), is(true));
-        assertThat(rootEnumClass.getDeclaredMethod("fromValue", Integer.class), is(notNullValue()));
+        assertThat(rootEnumClass.getDeclaredMethod(EnumRule.FROM_VALUE_METHOD_NAME, Integer.class), is(notNullValue()));
         assertThat(isPublic(rootEnumClass.getModifiers()), is(true));
     }
 
@@ -154,7 +155,7 @@ public void doubleEnumAtRootCreatesIntBackedEnum() throws ClassNotFoundException
         Class<Enum> rootEnumClass = (Class<Enum>) resultsClassLoader.loadClass("com.example.enums.DoubleEnumAsRoot");
 
         assertThat(rootEnumClass.isEnum(), is(true));
-        assertThat(rootEnumClass.getDeclaredMethod("fromValue", Double.class), is(notNullValue()));
+        assertThat(rootEnumClass.getDeclaredMethod(EnumRule.FROM_VALUE_METHOD_NAME, Double.class), is(notNullValue()));
         assertThat(isPublic(rootEnumClass.getModifiers()), is(true));
     }
 
@@ -284,6 +285,62 @@ public void intEnumIsDeserializedCorrectly() throws ClassNotFoundException, NoSu
         assertThat((Integer)getValueMethod.invoke(enumObject), is(2));
     }
 
+    @Test
+    @SuppressWarnings("unchecked")
+    public void booleanEnumIsDeserializedCorrectly() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, JsonParseException, JsonMappingException, IOException {
+
+        ClassLoader resultsClassLoader = schemaRule.generateAndCompile("/schema/enum/booleanEnumToSerialize.json", "com.example");
+
+        // the schema for a valid instance
+        Class<?> typeWithEnumProperty = resultsClassLoader.loadClass("com.example.enums.BooleanEnumToSerialize");
+        Class<Enum> enumClass = (Class<Enum>) resultsClassLoader.loadClass("com.example.enums.BooleanEnumToSerialize$TestEnum");
+
+        // read the instance into the type
+        ObjectMapper objectMapper = new ObjectMapper();
+        Object valueWithEnumProperty = objectMapper.readValue("{\"testEnum\" : false}", typeWithEnumProperty);
+
+        Method getEnumMethod = typeWithEnumProperty.getDeclaredMethod("getTestEnum");
+        Method getValueMethod = enumClass.getDeclaredMethod("value");
+
+        // call getTestEnum on the value
+        assertThat(getEnumMethod, is(notNullValue()));
+        Object enumObject = getEnumMethod.invoke(valueWithEnumProperty);
+
+        // assert that the object returned is a) a TestEnum, and b) calling .value() on it returns 'false'
+        // as per the json snippet above
+        assertThat(enumObject, IsInstanceOf.instanceOf(enumClass));
+        assertThat(getValueMethod, is(notNullValue()));
+        assertThat((Boolean)getValueMethod.invoke(enumObject), is(false));
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void doubleEnumIsDeserializedCorrectly() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, JsonParseException, JsonMappingException, IOException {
+
+        ClassLoader resultsClassLoader = schemaRule.generateAndCompile("/schema/enum/doubleEnumToSerialize.json", "com.example");
+
+        // the schema for a valid instance
+        Class<?> typeWithEnumProperty = resultsClassLoader.loadClass("com.example.enums.DoubleEnumToSerialize");
+        Class<Enum> enumClass = (Class<Enum>) resultsClassLoader.loadClass("com.example.enums.DoubleEnumToSerialize$TestEnum");
+
+        // read the instance into the type
+        ObjectMapper objectMapper = new ObjectMapper();
+        Object valueWithEnumProperty = objectMapper.readValue("{\"testEnum\" : 3.0 }", typeWithEnumProperty);
+
+        Method getEnumMethod = typeWithEnumProperty.getDeclaredMethod("getTestEnum");
+        Method getValueMethod = enumClass.getDeclaredMethod("value");
+
+        // call getTestEnum on the value
+        assertThat(getEnumMethod, is(notNullValue()));
+        Object enumObject = getEnumMethod.invoke(valueWithEnumProperty);
+
+        // assert that the object returned is a) a TestEnum, and b) calling .value() on it returns 3.0
+        // as per the json snippet above
+        assertThat(enumObject, IsInstanceOf.instanceOf(enumClass));
+        assertThat(getValueMethod, is(notNullValue()));
+        assertThat((Double)getValueMethod.invoke(enumObject), is(3d));
+    }
+
     @Test
     @SuppressWarnings("unchecked")
     public void intEnumIsSerializedCorrectly() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, JsonParseException, JsonMappingException, IOException, InstantiationException {
@@ -313,7 +370,65 @@ public void intEnumIsSerializedCorrectly() throws ClassNotFoundException, NoSuch
         assertThat(jsonTree.get("testEnum").asInt(), is(1));
     }
 
-
+    @Test
+    @SuppressWarnings("unchecked")
+    public void booleanEnumIsSerializedCorrectly() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, JsonParseException, JsonMappingException, IOException, InstantiationException {
+
+        ClassLoader resultsClassLoader = schemaRule.generateAndCompile("/schema/enum/booleanEnumToSerialize.json", "com.example");
+
+        // the schema for a valid instance
+        Class<?> typeWithEnumProperty = resultsClassLoader.loadClass("com.example.enums.BooleanEnumToSerialize");
+        Class<Enum> enumClass = (Class<Enum>) resultsClassLoader.loadClass("com.example.enums.BooleanEnumToSerialize$TestEnum");
+
+        // create an instance
+        Object valueWithEnumProperty = typeWithEnumProperty.newInstance();
+        Method enumSetter = typeWithEnumProperty.getMethod("setTestEnum", enumClass);
+
+        // call setTestEnum(TestEnum.ONE)
+        enumSetter.invoke(valueWithEnumProperty, enumClass.getEnumConstants()[0]);
+
+        ObjectMapper objectMapper = new ObjectMapper();
+
+        // write our instance out to json
+        String jsonString = objectMapper.writeValueAsString(valueWithEnumProperty);
+        JsonNode jsonTree = objectMapper.readTree(jsonString);
+
+        assertThat(jsonTree.size(), is(1));
+        assertThat(jsonTree.has("testEnum"), is(true));
+        assertThat(jsonTree.get("testEnum").isBoolean(), is(true));
+        assertThat(jsonTree.get("testEnum").asBoolean(), is(true));
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void doubleEnumIsSerializedCorrectly() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, JsonParseException, JsonMappingException, IOException, InstantiationException {
+
+        ClassLoader resultsClassLoader = schemaRule.generateAndCompile("/schema/enum/doubleEnumToSerialize.json", "com.example");
+
+        // the schema for a valid instance
+        Class<?> typeWithEnumProperty = resultsClassLoader.loadClass("com.example.enums.DoubleEnumToSerialize");
+        Class<Enum> enumClass = (Class<Enum>) resultsClassLoader.loadClass("com.example.enums.DoubleEnumToSerialize$TestEnum");
+
+        // create an instance
+        Object valueWithEnumProperty = typeWithEnumProperty.newInstance();
+        Method enumSetter = typeWithEnumProperty.getMethod("setTestEnum", enumClass);
+
+        // call setTestEnum(TestEnum.ONE)
+        enumSetter.invoke(valueWithEnumProperty, enumClass.getEnumConstants()[2]);
+
+        ObjectMapper objectMapper = new ObjectMapper();
+
+        // write our instance out to json
+        String jsonString = objectMapper.writeValueAsString(valueWithEnumProperty);
+        JsonNode jsonTree = objectMapper.readTree(jsonString);
+
+        assertThat(jsonTree.size(), is(1));
+        assertThat(jsonTree.has("testEnum"), is(true));
+        assertThat(jsonTree.get("testEnum").isDouble(), is(true));
+        assertThat(jsonTree.get("testEnum").asDouble(), is(3d));
+    }
+
+
     @Test
     @SuppressWarnings("unchecked")
     public void jacksonCanMarshalEnums() throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException, IOException {

jsonschema2pojo-integration-tests/src/test/resources/schema/enum/booleanEnumToSerialize.json

@@ -0,0 +1,11 @@
+{
+    "javaType" : "com.example.enums.BooleanEnumToSerialize",
+    "properties" : {
+       "testEnum" : { 
+          "type" : "boolean",
+          "enum" : [true, false],
+          "javaEnumNames" : ["ONE", "ZERO"],
+          "default": true
+      }
+    }
+}

jsonschema2pojo-integration-tests/src/test/resources/schema/enum/doubleEnumToSerialize.json

@@ -0,0 +1,11 @@
+{
+    "javaType" : "com.example.enums.DoubleEnumToSerialize",
+    "properties" : {
+       "testEnum" : {
+         "type" : "number",
+         "enum" : [1.0, 2.5, 3],
+         "javaEnumNames" : ["One", "TwoAndAHalf", "Three"],
+         "default": 3
+      }
+    }
+}

jsonschema2pojo-integration-tests/src/test/resources/schema/enum/integerEnumToSerialize.json

@@ -4,7 +4,8 @@
        "testEnum" : { 
           "type" : "integer",
           "enum" : [1, 2, 3],
-          "javaEnumNames" : ["One", "Two", "Three"]
+          "javaEnumNames" : ["One", "Two", "Three"],
+          "default": 3
       }
     }
 }