Add tests for DecimalMax DecimalMin with double values

blackbox-test/src/test/java/example/jakarta/JMyMinNumbers.java

@@ -10,15 +10,32 @@
 @Valid
 public class JMyMinNumbers {
 
+  private static final BigDecimal VALID = new BigDecimal("20");
+
   @DecimalMin("10.50")
   final BigDecimal price;
 
   @DecimalMin(value = "9.30", inclusive = false)
   final BigDecimal priceInc;
 
+  @DecimalMin("9.50")
+  final double dmin;
+
+  @DecimalMin(value = "8.30", inclusive = false)
+  final double dminInc;
+
   public JMyMinNumbers(BigDecimal price, BigDecimal priceInc) {
     this.price = price;
     this.priceInc = priceInc;
+    this.dmin = 20;
+    this.dminInc = 20;
+  }
+
+  public JMyMinNumbers(double dmin, double dminInc) {
+    this.price = VALID;
+    this.priceInc = VALID;
+    this.dmin = dmin;
+    this.dminInc = dminInc;
   }
 
   public BigDecimal price() {
@@ -29,4 +46,12 @@ public BigDecimal priceInc() {
     return priceInc;
   }
 
+
+  public double dmin() {
+    return dmin;
+  }
+
+  public double dminInc() {
+    return dminInc;
+  }
 }

blackbox-test/src/test/java/example/jakarta/JMyMinNumbersTest.java

@@ -25,6 +25,12 @@ void valid() {
     validator.validate(bean);
   }
 
+  @Test
+  void validDouble() {
+    var bean = new JMyMinNumbers(20d, 20d);
+    validator.validate(bean);
+  }
+
   @Test
   void decimalMin() {
     var violation = one(new JMyMinNumbers(ONE, valid));
@@ -49,6 +55,30 @@ void decimalMaxExclusiveDE() {
     assertThat(violation.message()).isEqualTo("muss größer 9.30 sein");
   }
 
+  @Test
+  void doubleDecimalMin() {
+    var violation = one(new JMyMinNumbers(1d, 20d));
+    assertThat(violation.message()).isEqualTo("must be greater than or equal to 9.50");
+  }
+
+  @Test
+  void doubleDecimalMinDE() {
+    var violation = one(new JMyMinNumbers(1d, 20d), Locale.GERMAN);
+    assertThat(violation.message()).isEqualTo("muss größer oder gleich 9.50 sein");
+  }
+
+  @Test
+  void doubleDecimalMinExclusive() {
+    var violation = one(new JMyMinNumbers(20d, 1d));
+    assertThat(violation.message()).isEqualTo("must be greater than 8.30");
+  }
+
+  @Test
+  void doubleDecimalMaxExclusiveDE() {
+    var violation = one(new JMyMinNumbers(20d, 1d), Locale.GERMAN);
+    assertThat(violation.message()).isEqualTo("muss größer 8.30 sein");
+  }
+
   ConstraintViolation one(Object any) {
     return one(any, Locale.ENGLISH);
   }

blackbox-test/src/test/java/example/jakarta/JMyNumbers.java

@@ -2,7 +2,6 @@
 
 import jakarta.validation.Valid;
 import jakarta.validation.constraints.DecimalMax;
-import jakarta.validation.constraints.Digits;
 
 import java.math.BigDecimal;
 
@@ -15,13 +14,24 @@ public class JMyNumbers {
   @DecimalMax(value = "9.30", inclusive = false)
   final BigDecimal priceInc;
 
-  @Digits(integer = 5, fraction = 3)
-  final String someDigits;
+  @DecimalMax("9.50")
+  final double dprice;
 
-  public JMyNumbers(BigDecimal price, BigDecimal priceInc, String someDigits) {
+  @DecimalMax(value = "8.30", inclusive = false)
+  final double dpriceInc;
+
+  public JMyNumbers(BigDecimal price, BigDecimal priceInc) {
     this.price = price;
     this.priceInc = priceInc;
-    this.someDigits = someDigits;
+    this.dprice = 1d;
+    this.dpriceInc = 1d;
+  }
+
+  public JMyNumbers(double dprice, double dpriceInc) {
+    this.price = BigDecimal.ONE;
+    this.priceInc = BigDecimal.ONE;
+    this.dprice = dprice;
+    this.dpriceInc = dpriceInc;
   }
 
   public BigDecimal price() {
@@ -32,7 +42,11 @@ public BigDecimal priceInc() {
     return priceInc;
   }
 
-  public String someDigits() {
-    return someDigits;
+  public double dprice() {
+    return dprice;
+  }
+
+  public double dpriceInc() {
+    return dpriceInc;
   }
 }

blackbox-test/src/test/java/example/jakarta/JMyNumbersTest.java

@@ -19,34 +19,64 @@ class JMyNumbersTest {
 
   @Test
   void valid() {
-    var bean = new JMyNumbers(ONE, ONE, "12345.123");
+    var bean = new JMyNumbers(ONE, ONE);
+    validator.validate(bean);
+  }
+
+  @Test
+  void validDouble() {
+    var bean = new JMyNumbers(1d, 1d);
     validator.validate(bean);
   }
 
   @Test
   void decimalMax() {
-    var violation = one(new JMyNumbers(new BigDecimal("11"), ONE, "12345.123"));
+    var violation = one(new JMyNumbers(new BigDecimal("11"), ONE));
     assertThat(violation.message()).isEqualTo("must be less than or equal to 10.50");
   }
 
   @Test
   void decimalMaxDE() {
-    var violation = one(new JMyNumbers(new BigDecimal("11"), ONE, "12345.123"), Locale.GERMAN);
+    var violation = one(new JMyNumbers(new BigDecimal("11"), ONE), Locale.GERMAN);
     assertThat(violation.message()).isEqualTo("muss kleiner oder gleich 10.50 sein");
   }
 
   @Test
   void decimalMaxExclusive() {
-    var violation = one(new JMyNumbers(ONE, new BigDecimal("11"), "12345.123"));
+    var violation = one(new JMyNumbers(ONE, new BigDecimal("11")));
     assertThat(violation.message()).isEqualTo("must be less than 9.30");
   }
 
   @Test
   void decimalMaxExclusiveDE() {
-    var violation = one(new JMyNumbers(ONE, new BigDecimal("11"), "12345.123"), Locale.GERMAN);
+    var violation = one(new JMyNumbers(ONE, new BigDecimal("11")), Locale.GERMAN);
     assertThat(violation.message()).isEqualTo("muss kleiner 9.30 sein");
   }
 
+  @Test
+  void doubleDecimalMax() {
+    var violation = one(new JMyNumbers(11d, 1d));
+    assertThat(violation.message()).isEqualTo("must be less than or equal to 9.50");
+  }
+
+  @Test
+  void doubleDecimalMaxDE() {
+    var violation = one(new JMyNumbers(11d, 1d), Locale.GERMAN);
+    assertThat(violation.message()).isEqualTo("muss kleiner oder gleich 9.50 sein");
+  }
+
+  @Test
+  void doubleDecimalMaxExclusive() {
+    var violation = one(new JMyNumbers(1d, 11d));
+    assertThat(violation.message()).isEqualTo("must be less than 8.30");
+  }
+
+  @Test
+  void doubleDecimalMaxExclusiveDE() {
+    var violation = one(new JMyNumbers(1d, 11d), Locale.GERMAN);
+    assertThat(violation.message()).isEqualTo("muss kleiner 8.30 sein");
+  }
+
   ConstraintViolation one(Object any) {
     return one(any, Locale.ENGLISH);
   }