Exclude integer types from multipleOf = 1 specification and test

Signed-off-by: Michael Edgar <michael@xlate.io>

Author: MikeEdgar

spec/src/main/asciidoc/microprofile-openapi-spec.asciidoc

@@ -621,7 +621,7 @@ maxProperties = b`
 | `@DecimalMax(value = a, inclusive = false)` | `number` or `integer` | `exclusiveMaximum = a`
 | `@DecimalMin(value = a)` | `number` or `integer` | `minimum = a`
 | `@DecimalMin(value = a, inclusive = false)` | `number` or `integer` | `exclusiveMinimum = a`
-| `@Digits(integer = <any>, fraction = f)` | `number` or `integer` | `multipleOf` equal to `1` for integer types or 10^-f for non-integer types
+| `@Digits(integer = <any>, fraction = f)` | `number` | `multipleOf = 1` when `fraction` is less than 1, else `multipleOf` equal to 10^-f
 | `@Digits(integer = i, fraction = f)` | `string` | `pattern` matching any string value that satisfies the constraint
 | `@Max(a)` | `number` or `integer` | `maximum = a`
 | `@Min(a)` | `number` or `integer` | `minimum = a`

tck/src/main/java/org/eclipse/microprofile/openapi/apps/beanvalidation/BeanValidationData.java

@@ -86,6 +86,15 @@ public class BeanValidationData {
     @Digits(integer = 20, fraction = 10)
     private BigDecimal digitsDecimal;
 
+    @Digits(integer = 5, fraction = 0)
+    private float digitsFloat32AsInteger;
+
+    @Digits(integer = 10, fraction = 0)
+    private double digitsFloat64AsInteger;
+
+    @Digits(integer = 20, fraction = 0)
+    private BigDecimal digitsDecimalAsInteger;
+
     @Digits(integer = 20, fraction = 0)
     private BigInteger digitsInteger;
 
@@ -94,7 +103,7 @@ public class BeanValidationData {
     private BigInteger digitsCustomInteger;
 
     @Digits(integer = 10, fraction = 5)
-    private BigInteger digitsString;
+    private String digitsString;
 
     @Max(5)
     private int maxInt;
@@ -252,6 +261,30 @@ public void setDigitsDecimal(BigDecimal digitsDecimal) {
         this.digitsDecimal = digitsDecimal;
     }
 
+    public float getDigitsFloat32AsInteger() {
+        return digitsFloat32AsInteger;
+    }
+
+    public void setDigitsFloat32AsInteger(float digitsFloat32AsInteger) {
+        this.digitsFloat32AsInteger = digitsFloat32AsInteger;
+    }
+
+    public double getDigitsFloat64AsInteger() {
+        return digitsFloat64AsInteger;
+    }
+
+    public void setDigitsFloat64AsInteger(double digitsFloat64AsInteger) {
+        this.digitsFloat64AsInteger = digitsFloat64AsInteger;
+    }
+
+    public BigDecimal getDigitsDecimalAsInteger() {
+        return digitsDecimalAsInteger;
+    }
+
+    public void setDigitsDecimalAsInteger(BigDecimal digitsDecimalAsInteger) {
+        this.digitsDecimalAsInteger = digitsDecimalAsInteger;
+    }
+
     public BigInteger getDigitsInteger() {
         return digitsInteger;
     }
@@ -268,11 +301,11 @@ public void setDigitsCustomInteger(BigInteger digitsCustomInteger) {
         this.digitsCustomInteger = digitsCustomInteger;
     }
 
-    public BigInteger getDigitsString() {
+    public String getDigitsString() {
         return digitsString;
     }
 
-    public void setDigitsString(BigInteger digitsString) {
+    public void setDigitsString(String digitsString) {
         this.digitsString = digitsString;
     }
 

tck/src/main/java/org/eclipse/microprofile/openapi/tck/beanvalidation/BeanValidationTest.java

@@ -19,11 +19,14 @@
 import static org.eclipse.microprofile.openapi.tck.utils.TCKMatchers.comparesEqualToNumber;
 import static org.eclipse.microprofile.openapi.tck.utils.TCKMatchers.itemOrSingleton;
 import static org.eclipse.microprofile.openapi.tck.utils.TCKMatchers.patternMatchesValue;
+import static org.hamcrest.Matchers.either;
 import static org.hamcrest.Matchers.hasEntry;
 import static org.hamcrest.Matchers.hasKey;
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.not;
 
+import java.util.Arrays;
+
 import org.eclipse.microprofile.openapi.apps.beanvalidation.BeanValidationApp;
 import org.eclipse.microprofile.openapi.tck.AppTestBase;
 import org.hamcrest.Matcher;
@@ -185,12 +188,23 @@ public void defaultAndOtherGroupsTest(String format) {
         assertProperty(vr, "defaultAndOtherGroups", hasEntry("minLength", 1));
     }
 
+    @SuppressWarnings("unchecked")
     @Test(dataProvider = "formatProvider", groups = BEAN_VALIDATION)
-    public void integerDigitsTest(String format) {
+    public <T extends Object> void integerDigitsTest(String format) {
+        Matcher<T> isInteger = (Matcher<T>) hasEntry(is("type"), itemOrSingleton("integer"));
+        Matcher<T> isMultipleOfOne = (Matcher<T>) hasEntry(is(MULTIPLE_OF), comparesEqualToNumber(1));
+
         ValidatableResponse vr = callEndpoint(format);
-        assertProperty(vr, "digitsInt32", hasEntry(is(MULTIPLE_OF), comparesEqualToNumber(1)));
-        assertProperty(vr, "digitsInt64", hasEntry(is(MULTIPLE_OF), comparesEqualToNumber(1)));
-        assertProperty(vr, "digitsInteger", hasEntry(is(MULTIPLE_OF), comparesEqualToNumber(1)));
+
+        for (String property : Arrays.asList(
+                "digitsInt32",
+                "digitsInt64",
+                "digitsInteger",
+                "digitsFloat32AsInteger",
+                "digitsFloat64AsInteger",
+                "digitsDecimalAsInteger")) {
+            assertProperty(vr, property, either(isInteger).or(isMultipleOfOne));
+        }
     }
 
     @Test(dataProvider = "formatProvider", groups = BEAN_VALIDATION)