Adjusting recognition of floats and doubles with regards to AssertJ assertions, given JavaTemplate.Matcher changes around matching X.0 style numbers. (#816)

steve-aom-elliott · web-flow · commit bc1e84a7e761 · 2025-09-23T16:48:28.000-04:00
diff --git a/src/main/java/org/openrewrite/java/testing/assertj/AssertJDoubleRules.java b/src/main/java/org/openrewrite/java/testing/assertj/AssertJDoubleRules.java
@@ -64,7 +64,12 @@ static final class AbstractDoubleAssertIsEqualTo {
     @BeforeTemplate
     AbstractDoubleAssert<?> before(AbstractDoubleAssert<?> doubleAssert, double n) {
       return Refaster.anyOf(
-          doubleAssert.isCloseTo(n, offset(0.0)), doubleAssert.isCloseTo(n, withPercentage(0.0)));
+          doubleAssert.isCloseTo(n, offset(0.0)),
+          doubleAssert.isCloseTo(n, offset(0d)),
+          doubleAssert.isCloseTo(n, withPercentage(0)),
+          doubleAssert.isCloseTo(n, withPercentage(0.0)),
+          doubleAssert.isCloseTo(n, withPercentage(0d))
+      );
     }
 
     @AfterTemplate
@@ -82,7 +87,11 @@ static final class AbstractDoubleAssertIsNotEqualTo {
     AbstractDoubleAssert<?> before(AbstractDoubleAssert<?> doubleAssert, double n) {
       return Refaster.anyOf(
           doubleAssert.isNotCloseTo(n, offset(0.0)),
-          doubleAssert.isNotCloseTo(n, withPercentage(0.0)));
+          doubleAssert.isNotCloseTo(n, offset(0d)),
+          doubleAssert.isNotCloseTo(n, withPercentage(0)),
+          doubleAssert.isNotCloseTo(n, withPercentage(0.0)),
+          doubleAssert.isNotCloseTo(n, withPercentage(0d))
+      );
     }
 
     @AfterTemplate
@@ -98,7 +107,11 @@ AbstractDoubleAssert<?> after(AbstractDoubleAssert<?> doubleAssert, double n) {
   static final class AbstractDoubleAssertIsZero {
     @BeforeTemplate
     AbstractDoubleAssert<?> before(AbstractDoubleAssert<?> doubleAssert) {
-      return doubleAssert.isEqualTo(0);
+      return Refaster.anyOf(
+          doubleAssert.isEqualTo(0),
+          doubleAssert.isEqualTo(0.0),
+          doubleAssert.isEqualTo(0d)
+      );
     }
 
     @AfterTemplate
@@ -114,7 +127,11 @@ AbstractDoubleAssert<?> after(AbstractDoubleAssert<?> doubleAssert) {
   static final class AbstractDoubleAssertIsNotZero {
     @BeforeTemplate
     AbstractDoubleAssert<?> before(AbstractDoubleAssert<?> doubleAssert) {
-      return doubleAssert.isNotEqualTo(0);
+      return Refaster.anyOf(
+          doubleAssert.isNotEqualTo(0),
+          doubleAssert.isNotEqualTo(0.0),
+          doubleAssert.isNotEqualTo(0d)
+      );
     }
 
     @AfterTemplate
@@ -130,7 +147,11 @@ AbstractDoubleAssert<?> after(AbstractDoubleAssert<?> doubleAssert) {
   static final class AbstractDoubleAssertIsOne {
     @BeforeTemplate
     AbstractDoubleAssert<?> before(AbstractDoubleAssert<?> doubleAssert) {
-      return doubleAssert.isEqualTo(1);
+      return Refaster.anyOf(
+          doubleAssert.isEqualTo(1),
+          doubleAssert.isEqualTo(1.0),
+          doubleAssert.isEqualTo(1d)
+      );
     }
 
     @AfterTemplate
diff --git a/src/main/java/org/openrewrite/java/testing/assertj/AssertJFloatRules.java b/src/main/java/org/openrewrite/java/testing/assertj/AssertJFloatRules.java
@@ -64,7 +64,11 @@ static final class AbstractFloatAssertIsEqualTo {
     @BeforeTemplate
     AbstractFloatAssert<?> before(AbstractFloatAssert<?> floatAssert, float n) {
       return Refaster.anyOf(
-          floatAssert.isCloseTo(n, offset(0f)), floatAssert.isCloseTo(n, withPercentage(0)));
+          floatAssert.isCloseTo(n, offset(0f)),
+          floatAssert.isCloseTo(n, withPercentage(0)),
+          floatAssert.isCloseTo(n, withPercentage(0.0)),
+          floatAssert.isCloseTo(n, withPercentage(0d))
+      );
     }
 
     @AfterTemplate
@@ -81,7 +85,11 @@ static final class AbstractFloatAssertIsNotEqualTo {
     @BeforeTemplate
     AbstractFloatAssert<?> before(AbstractFloatAssert<?> floatAssert, float n) {
       return Refaster.anyOf(
-          floatAssert.isNotCloseTo(n, offset(0f)), floatAssert.isNotCloseTo(n, withPercentage(0)));
+          floatAssert.isNotCloseTo(n, offset(0f)),
+          floatAssert.isNotCloseTo(n, withPercentage(0)),
+          floatAssert.isNotCloseTo(n, withPercentage(0.0)),
+          floatAssert.isNotCloseTo(n, withPercentage(0d))
+      );
     }
 
     @AfterTemplate
@@ -97,7 +105,10 @@ AbstractFloatAssert<?> after(AbstractFloatAssert<?> floatAssert, float n) {
   static final class AbstractFloatAssertIsZero {
     @BeforeTemplate
     AbstractFloatAssert<?> before(AbstractFloatAssert<?> floatAssert) {
-      return floatAssert.isEqualTo(0);
+      return Refaster.anyOf(
+          floatAssert.isEqualTo(0),
+          floatAssert.isEqualTo(0f)
+      );
     }
 
     @AfterTemplate
@@ -113,7 +124,10 @@ AbstractFloatAssert<?> after(AbstractFloatAssert<?> floatAssert) {
   static final class AbstractFloatAssertIsNotZero {
     @BeforeTemplate
     AbstractFloatAssert<?> before(AbstractFloatAssert<?> floatAssert) {
-      return floatAssert.isNotEqualTo(0);
+      return Refaster.anyOf(
+          floatAssert.isNotEqualTo(0),
+          floatAssert.isNotEqualTo(0f)
+      );
     }
 
     @AfterTemplate
@@ -129,7 +143,10 @@ AbstractFloatAssert<?> after(AbstractFloatAssert<?> floatAssert) {
   static final class AbstractFloatAssertIsOne {
     @BeforeTemplate
     AbstractFloatAssert<?> before(AbstractFloatAssert<?> floatAssert) {
-      return floatAssert.isEqualTo(1);
+      return Refaster.anyOf(
+          floatAssert.isEqualTo(1),
+          floatAssert.isEqualTo(1f)
+      );
     }
 
     @AfterTemplate
diff --git a/src/test/java/org/openrewrite/java/testing/assertj/AssertJDoubleRulesTest.java b/src/test/java/org/openrewrite/java/testing/assertj/AssertJDoubleRulesTest.java
@@ -40,6 +40,7 @@ void isZero() {
 
                       class A {
                           public void test(double d) {
+                              Assertions.assertThat(d).isEqualTo(0);
                               Assertions.assertThat(d).isEqualTo(0.0);
                               Assertions.assertThat(d).isEqualTo(0d);
                           }
@@ -52,6 +53,7 @@ class A {
                           public void test(double d) {
                               Assertions.assertThat(d).isZero();
                               Assertions.assertThat(d).isZero();
+                              Assertions.assertThat(d).isZero();
                           }
                       }
                       """
@@ -69,7 +71,9 @@ void isNotZero() {
 
                       class A {
                           public void test(double d) {
+                              Assertions.assertThat(d).isNotEqualTo(0);
                               Assertions.assertThat(d).isNotEqualTo(0.0);
+                              Assertions.assertThat(d).isNotEqualTo(0d);
                           }
                       }
                       """,
@@ -79,6 +83,8 @@ public void test(double d) {
                       class A {
                           public void test(double d) {
                               Assertions.assertThat(d).isNotZero();
+                              Assertions.assertThat(d).isNotZero();
+                              Assertions.assertThat(d).isNotZero();
                           }
                       }
                       """
@@ -99,6 +105,7 @@ void isCloseTo() {
               class A {
                   public void test(double d, double expected) {
                       Assertions.assertThat(d).isEqualTo(expected, offset(0.0));
+                      Assertions.assertThat(d).isEqualTo(expected, offset(0d));
                       Assertions.assertThat(d).isEqualTo(expected, offset(1.0));
                   }
               }
@@ -110,6 +117,7 @@ public void test(double d, double expected) {
 
               class A {
                   public void test(double d, double expected) {
+                      Assertions.assertThat(d).isEqualTo(expected);
                       Assertions.assertThat(d).isEqualTo(expected);
                       Assertions.assertThat(d).isCloseTo(expected, offset(1.0));
                   }
@@ -133,7 +141,10 @@ void isEqualTo() {
               class A {
                   public void test(double d, double expected) {
                       Assertions.assertThat(d).isCloseTo(expected, offset(0.0));
+                      Assertions.assertThat(d).isCloseTo(expected, offset(0d));
                       Assertions.assertThat(d).isCloseTo(expected, withPercentage(0));
+                      Assertions.assertThat(d).isCloseTo(expected, withPercentage(0.0));
+                      Assertions.assertThat(d).isCloseTo(expected, withPercentage(0d));
                   }
               }
               """,
@@ -144,6 +155,9 @@ class A {
                   public void test(double d, double expected) {
                       Assertions.assertThat(d).isEqualTo(expected);
                       Assertions.assertThat(d).isEqualTo(expected);
+                      Assertions.assertThat(d).isEqualTo(expected);
+                      Assertions.assertThat(d).isEqualTo(expected);
+                      Assertions.assertThat(d).isEqualTo(expected);
                   }
               }
               """
@@ -165,7 +179,10 @@ void isNotEqualTo() {
               class A {
                   public void test(double d, double expected) {
                       Assertions.assertThat(d).isNotCloseTo(expected, offset(0.0));
+                      Assertions.assertThat(d).isNotCloseTo(expected, offset(0d));
                       Assertions.assertThat(d).isNotCloseTo(expected, withPercentage(0));
+                      Assertions.assertThat(d).isNotCloseTo(expected, withPercentage(0.0));
+                      Assertions.assertThat(d).isNotCloseTo(expected, withPercentage(0d));
                   }
               }
               """,
@@ -176,6 +193,9 @@ class A {
                   public void test(double d, double expected) {
                       Assertions.assertThat(d).isNotEqualTo(expected);
                       Assertions.assertThat(d).isNotEqualTo(expected);
+                      Assertions.assertThat(d).isNotEqualTo(expected);
+                      Assertions.assertThat(d).isNotEqualTo(expected);
+                      Assertions.assertThat(d).isNotEqualTo(expected);
                   }
               }
               """
@@ -193,7 +213,9 @@ void isOne() {
 
               class A {
                   public void test(double d) {
+                      Assertions.assertThat(d).isEqualTo(1);
                       Assertions.assertThat(d).isEqualTo(1.0);
+                      Assertions.assertThat(d).isEqualTo(1d);
                   }
               }
               """,
@@ -203,6 +225,8 @@ public void test(double d) {
               class A {
                   public void test(double d) {
                       Assertions.assertThat(d).isOne();
+                      Assertions.assertThat(d).isOne();
+                      Assertions.assertThat(d).isOne();
                   }
               }
               """
diff --git a/src/test/java/org/openrewrite/java/testing/assertj/AssertJFloatRulesTest.java b/src/test/java/org/openrewrite/java/testing/assertj/AssertJFloatRulesTest.java
@@ -40,7 +40,10 @@ void isZero() {
 
                       class A {
                           public void test(float f) {
+                              Assertions.assertThat(f).isEqualTo(0);
+                              Assertions.assertThat(f).isEqualTo(0f);
                               Assertions.assertThat(f).isEqualTo(0.0f);
+                              Assertions.assertThat(f).isEqualTo(0F);
                               Assertions.assertThat(f).isEqualTo(0.0F);
                           }
                       }
@@ -52,6 +55,9 @@ class A {
                           public void test(float f) {
                               Assertions.assertThat(f).isZero();
                               Assertions.assertThat(f).isZero();
+                              Assertions.assertThat(f).isZero();
+                              Assertions.assertThat(f).isZero();
+                              Assertions.assertThat(f).isZero();
                           }
                       }
                       """
@@ -69,6 +75,8 @@ void isNotZero() {
 
                       class A {
                           public void test(float f) {
+                              Assertions.assertThat(f).isNotEqualTo(0);
+                              Assertions.assertThat(f).isNotEqualTo(0f);
                               Assertions.assertThat(f).isNotEqualTo(0.0f);
                           }
                       }
@@ -79,6 +87,8 @@ public void test(float f) {
                       class A {
                           public void test(float f) {
                               Assertions.assertThat(f).isNotZero();
+                              Assertions.assertThat(f).isNotZero();
+                              Assertions.assertThat(f).isNotZero();
                           }
                       }
                       """
@@ -98,6 +108,7 @@ void isCloseTo() {
 
               class A {
                   public void test(float f, float expected) {
+                      Assertions.assertThat(f).isEqualTo(expected, offset(0f));
                       Assertions.assertThat(f).isEqualTo(expected, offset(0.0f));
                       Assertions.assertThat(f).isEqualTo(expected, offset(1.0f));
                   }
@@ -110,6 +121,7 @@ public void test(float f, float expected) {
 
               class A {
                   public void test(float f, float expected) {
+                      Assertions.assertThat(f).isEqualTo(expected);
                       Assertions.assertThat(f).isEqualTo(expected);
                       Assertions.assertThat(f).isCloseTo(expected, offset(1.0f));
                   }
@@ -166,6 +178,8 @@ class A {
                   public void test(float f, float expected) {
                       Assertions.assertThat(f).isNotCloseTo(expected, offset(0.0f));
                       Assertions.assertThat(f).isNotCloseTo(expected, withPercentage(0));
+                      Assertions.assertThat(f).isNotCloseTo(expected, withPercentage(0.0));
+                      Assertions.assertThat(f).isNotCloseTo(expected, withPercentage(0d));
                   }
               }
               """,
@@ -176,6 +190,8 @@ class A {
                   public void test(float f, float expected) {
                       Assertions.assertThat(f).isNotEqualTo(expected);
                       Assertions.assertThat(f).isNotEqualTo(expected);
+                      Assertions.assertThat(f).isNotEqualTo(expected);
+                      Assertions.assertThat(f).isNotEqualTo(expected);
                   }
               }
               """
@@ -193,6 +209,8 @@ void isOne() {
 
               class A {
                   public void test(float f) {
+                      Assertions.assertThat(f).isEqualTo(1);
+                      Assertions.assertThat(f).isEqualTo(1f);
                       Assertions.assertThat(f).isEqualTo(1.0f);
                   }
               }
@@ -203,6 +221,8 @@ public void test(float f) {
               class A {
                   public void test(float f) {
                       Assertions.assertThat(f).isOne();
+                      Assertions.assertThat(f).isOne();
+                      Assertions.assertThat(f).isOne();
                   }
               }
               """

Original file line number	Diff line number	Diff line change
`@@ -40,6 +40,7 @@ void isZero() {`
`40`	`40`
`41`	`41`	`class A {`
`42`	`42`	`public void test(double d) {`
	`43`	`+ Assertions.assertThat(d).isEqualTo(0);`
`43`	`44`	`Assertions.assertThat(d).isEqualTo(0.0);`
`44`	`45`	`Assertions.assertThat(d).isEqualTo(0d);`
`45`	`46`	`}`
`@@ -52,6 +53,7 @@ class A {`
`52`	`53`	`public void test(double d) {`
`53`	`54`	`Assertions.assertThat(d).isZero();`
`54`	`55`	`Assertions.assertThat(d).isZero();`
	`56`	`+ Assertions.assertThat(d).isZero();`
`55`	`57`	`}`
`56`	`58`	`}`
`57`	`59`	`"""`
`@@ -69,7 +71,9 @@ void isNotZero() {`
`69`	`71`
`70`	`72`	`class A {`
`71`	`73`	`public void test(double d) {`
	`74`	`+ Assertions.assertThat(d).isNotEqualTo(0);`
`72`	`75`	`Assertions.assertThat(d).isNotEqualTo(0.0);`
	`76`	`+ Assertions.assertThat(d).isNotEqualTo(0d);`
`73`	`77`	`}`
`74`	`78`	`}`
`75`	`79`	`""",`
`@@ -79,6 +83,8 @@ public void test(double d) {`
`79`	`83`	`class A {`
`80`	`84`	`public void test(double d) {`
`81`	`85`	`Assertions.assertThat(d).isNotZero();`
	`86`	`+ Assertions.assertThat(d).isNotZero();`
	`87`	`+ Assertions.assertThat(d).isNotZero();`
`82`	`88`	`}`
`83`	`89`	`}`
`84`	`90`	`"""`
`@@ -99,6 +105,7 @@ void isCloseTo() {`
`99`	`105`	`class A {`
`100`	`106`	`public void test(double d, double expected) {`
`101`	`107`	`Assertions.assertThat(d).isEqualTo(expected, offset(0.0));`
	`108`	`+ Assertions.assertThat(d).isEqualTo(expected, offset(0d));`
`102`	`109`	`Assertions.assertThat(d).isEqualTo(expected, offset(1.0));`
`103`	`110`	`}`
`104`	`111`	`}`
`@@ -110,6 +117,7 @@ public void test(double d, double expected) {`
`110`	`117`
`111`	`118`	`class A {`
`112`	`119`	`public void test(double d, double expected) {`
	`120`	`+ Assertions.assertThat(d).isEqualTo(expected);`
`113`	`121`	`Assertions.assertThat(d).isEqualTo(expected);`
`114`	`122`	`Assertions.assertThat(d).isCloseTo(expected, offset(1.0));`
`115`	`123`	`}`
`@@ -133,7 +141,10 @@ void isEqualTo() {`
`133`	`141`	`class A {`
`134`	`142`	`public void test(double d, double expected) {`
`135`	`143`	`Assertions.assertThat(d).isCloseTo(expected, offset(0.0));`
	`144`	`+ Assertions.assertThat(d).isCloseTo(expected, offset(0d));`
`136`	`145`	`Assertions.assertThat(d).isCloseTo(expected, withPercentage(0));`
	`146`	`+ Assertions.assertThat(d).isCloseTo(expected, withPercentage(0.0));`
	`147`	`+ Assertions.assertThat(d).isCloseTo(expected, withPercentage(0d));`
`137`	`148`	`}`
`138`	`149`	`}`
`139`	`150`	`""",`
`@@ -144,6 +155,9 @@ class A {`
`144`	`155`	`public void test(double d, double expected) {`
`145`	`156`	`Assertions.assertThat(d).isEqualTo(expected);`
`146`	`157`	`Assertions.assertThat(d).isEqualTo(expected);`
	`158`	`+ Assertions.assertThat(d).isEqualTo(expected);`
	`159`	`+ Assertions.assertThat(d).isEqualTo(expected);`
	`160`	`+ Assertions.assertThat(d).isEqualTo(expected);`
`147`	`161`	`}`
`148`	`162`	`}`
`149`	`163`	`"""`
`@@ -165,7 +179,10 @@ void isNotEqualTo() {`
`165`	`179`	`class A {`
`166`	`180`	`public void test(double d, double expected) {`
`167`	`181`	`Assertions.assertThat(d).isNotCloseTo(expected, offset(0.0));`
	`182`	`+ Assertions.assertThat(d).isNotCloseTo(expected, offset(0d));`
`168`	`183`	`Assertions.assertThat(d).isNotCloseTo(expected, withPercentage(0));`
	`184`	`+ Assertions.assertThat(d).isNotCloseTo(expected, withPercentage(0.0));`
	`185`	`+ Assertions.assertThat(d).isNotCloseTo(expected, withPercentage(0d));`
`169`	`186`	`}`
`170`	`187`	`}`
`171`	`188`	`""",`
`@@ -176,6 +193,9 @@ class A {`
`176`	`193`	`public void test(double d, double expected) {`
`177`	`194`	`Assertions.assertThat(d).isNotEqualTo(expected);`
`178`	`195`	`Assertions.assertThat(d).isNotEqualTo(expected);`
	`196`	`+ Assertions.assertThat(d).isNotEqualTo(expected);`
	`197`	`+ Assertions.assertThat(d).isNotEqualTo(expected);`
	`198`	`+ Assertions.assertThat(d).isNotEqualTo(expected);`
`179`	`199`	`}`
`180`	`200`	`}`
`181`	`201`	`"""`
`@@ -193,7 +213,9 @@ void isOne() {`
`193`	`213`
`194`	`214`	`class A {`
`195`	`215`	`public void test(double d) {`
	`216`	`+ Assertions.assertThat(d).isEqualTo(1);`
`196`	`217`	`Assertions.assertThat(d).isEqualTo(1.0);`
	`218`	`+ Assertions.assertThat(d).isEqualTo(1d);`
`197`	`219`	`}`
`198`	`220`	`}`
`199`	`221`	`""",`
`@@ -203,6 +225,8 @@ public void test(double d) {`
`203`	`225`	`class A {`
`204`	`226`	`public void test(double d) {`
`205`	`227`	`Assertions.assertThat(d).isOne();`
	`228`	`+ Assertions.assertThat(d).isOne();`
	`229`	`+ Assertions.assertThat(d).isOne();`
`206`	`230`	`}`
`207`	`231`	`}`
`208`	`232`	`"""`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,10 @@ void isZero() {`
`40`	`40`
`41`	`41`	`class A {`
`42`	`42`	`public void test(float f) {`
	`43`	`+ Assertions.assertThat(f).isEqualTo(0);`
	`44`	`+ Assertions.assertThat(f).isEqualTo(0f);`
`43`	`45`	`Assertions.assertThat(f).isEqualTo(0.0f);`
	`46`	`+ Assertions.assertThat(f).isEqualTo(0F);`
`44`	`47`	`Assertions.assertThat(f).isEqualTo(0.0F);`
`45`	`48`	`}`
`46`	`49`	`}`
`@@ -52,6 +55,9 @@ class A {`
`52`	`55`	`public void test(float f) {`
`53`	`56`	`Assertions.assertThat(f).isZero();`
`54`	`57`	`Assertions.assertThat(f).isZero();`
	`58`	`+ Assertions.assertThat(f).isZero();`
	`59`	`+ Assertions.assertThat(f).isZero();`
	`60`	`+ Assertions.assertThat(f).isZero();`
`55`	`61`	`}`
`56`	`62`	`}`
`57`	`63`	`"""`
`@@ -69,6 +75,8 @@ void isNotZero() {`
`69`	`75`
`70`	`76`	`class A {`
`71`	`77`	`public void test(float f) {`
	`78`	`+ Assertions.assertThat(f).isNotEqualTo(0);`
	`79`	`+ Assertions.assertThat(f).isNotEqualTo(0f);`
`72`	`80`	`Assertions.assertThat(f).isNotEqualTo(0.0f);`
`73`	`81`	`}`
`74`	`82`	`}`
`@@ -79,6 +87,8 @@ public void test(float f) {`
`79`	`87`	`class A {`
`80`	`88`	`public void test(float f) {`
`81`	`89`	`Assertions.assertThat(f).isNotZero();`
	`90`	`+ Assertions.assertThat(f).isNotZero();`
	`91`	`+ Assertions.assertThat(f).isNotZero();`
`82`	`92`	`}`
`83`	`93`	`}`
`84`	`94`	`"""`
`@@ -98,6 +108,7 @@ void isCloseTo() {`
`98`	`108`
`99`	`109`	`class A {`
`100`	`110`	`public void test(float f, float expected) {`
	`111`	`+ Assertions.assertThat(f).isEqualTo(expected, offset(0f));`
`101`	`112`	`Assertions.assertThat(f).isEqualTo(expected, offset(0.0f));`
`102`	`113`	`Assertions.assertThat(f).isEqualTo(expected, offset(1.0f));`
`103`	`114`	`}`
`@@ -110,6 +121,7 @@ public void test(float f, float expected) {`
`110`	`121`
`111`	`122`	`class A {`
`112`	`123`	`public void test(float f, float expected) {`
	`124`	`+ Assertions.assertThat(f).isEqualTo(expected);`
`113`	`125`	`Assertions.assertThat(f).isEqualTo(expected);`
`114`	`126`	`Assertions.assertThat(f).isCloseTo(expected, offset(1.0f));`
`115`	`127`	`}`
`@@ -166,6 +178,8 @@ class A {`
`166`	`178`	`public void test(float f, float expected) {`
`167`	`179`	`Assertions.assertThat(f).isNotCloseTo(expected, offset(0.0f));`
`168`	`180`	`Assertions.assertThat(f).isNotCloseTo(expected, withPercentage(0));`
	`181`	`+ Assertions.assertThat(f).isNotCloseTo(expected, withPercentage(0.0));`
	`182`	`+ Assertions.assertThat(f).isNotCloseTo(expected, withPercentage(0d));`
`169`	`183`	`}`
`170`	`184`	`}`
`171`	`185`	`""",`
`@@ -176,6 +190,8 @@ class A {`
`176`	`190`	`public void test(float f, float expected) {`
`177`	`191`	`Assertions.assertThat(f).isNotEqualTo(expected);`
`178`	`192`	`Assertions.assertThat(f).isNotEqualTo(expected);`
	`193`	`+ Assertions.assertThat(f).isNotEqualTo(expected);`
	`194`	`+ Assertions.assertThat(f).isNotEqualTo(expected);`
`179`	`195`	`}`
`180`	`196`	`}`
`181`	`197`	`"""`
`@@ -193,6 +209,8 @@ void isOne() {`
`193`	`209`
`194`	`210`	`class A {`
`195`	`211`	`public void test(float f) {`
	`212`	`+ Assertions.assertThat(f).isEqualTo(1);`
	`213`	`+ Assertions.assertThat(f).isEqualTo(1f);`
`196`	`214`	`Assertions.assertThat(f).isEqualTo(1.0f);`
`197`	`215`	`}`
`198`	`216`	`}`
`@@ -203,6 +221,8 @@ public void test(float f) {`
`203`	`221`	`class A {`
`204`	`222`	`public void test(float f) {`
`205`	`223`	`Assertions.assertThat(f).isOne();`
	`224`	`+ Assertions.assertThat(f).isOne();`
	`225`	`+ Assertions.assertThat(f).isOne();`
`206`	`226`	`}`
`207`	`227`	`}`
`208`	`228`	`"""`