diff --git a/analyzer/testdata/src/checkers-default/float-compare/float_compare_test.go b/analyzer/testdata/src/checkers-default/float-compare/float_compare_test.go
index 7854515..707250c 100644
--- a/analyzer/testdata/src/checkers-default/float-compare/float_compare_test.go
+++ b/analyzer/testdata/src/checkers-default/float-compare/float_compare_test.go
@@ -10,42 +10,134 @@ import (
 )
 
 func TestFloatCompareChecker(t *testing.T) {
-	var result float64
+	var result any
+	var resultFl float64
 
 	// Invalid.
 	{
-		assert.Equal(t, 42.42, result)                                         // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
-		assert.Equalf(t, 42.42, result, "msg with args %d %s", 42, "42")       // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)f"
-		assert.Equal(t, result, 42.42)                                         // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
-		assert.Equalf(t, result, 42.42, "msg with args %d %s", 42, "42")       // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)f"
-		assert.EqualValues(t, 42.42, result)                                   // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
-		assert.EqualValuesf(t, 42.42, result, "msg with args %d %s", 42, "42") // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)f"
-		assert.EqualValues(t, result, 42.42)                                   // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
-		assert.EqualValuesf(t, result, 42.42, "msg with args %d %s", 42, "42") // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)f"
-		assert.Exactly(t, 42.42, result)                                       // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
-		assert.Exactlyf(t, 42.42, result, "msg with args %d %s", 42, "42")     // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)f"
-		assert.Exactly(t, result, 42.42)                                       // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
-		assert.Exactlyf(t, result, 42.42, "msg with args %d %s", 42, "42")     // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)f"
-		assert.True(t, 42.42 == result)                                        // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
-		assert.Truef(t, 42.42 == result, "msg with args %d %s", 42, "42")      // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)f"
-		assert.True(t, result == 42.42)                                        // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
-		assert.Truef(t, result == 42.42, "msg with args %d %s", 42, "42")      // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)f"
-		assert.False(t, 42.42 != result)                                       // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
-		assert.Falsef(t, 42.42 != result, "msg with args %d %s", 42, "42")     // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)f"
-		assert.False(t, result != 42.42)                                       // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
-		assert.Falsef(t, result != 42.42, "msg with args %d %s", 42, "42")     // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)f"
+		assert.Equal(t, result, 42.42)          // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.Equal(t, 42.42, result)          // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.Equal(t, resultFl, 42.42)        // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.Equal(t, 42.42, resultFl)        // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.Equal(t, result, resultFl)       // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.Equal(t, resultFl, result)       // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.EqualValues(t, result, 42.42)    // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.EqualValues(t, 42.42, result)    // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.EqualValues(t, resultFl, 42.42)  // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.EqualValues(t, 42.42, resultFl)  // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.EqualValues(t, result, resultFl) // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.EqualValues(t, resultFl, result) // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.Exactly(t, result, 42.42)        // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.Exactly(t, 42.42, result)        // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.Exactly(t, resultFl, 42.42)      // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.Exactly(t, 42.42, resultFl)      // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.Exactly(t, result, resultFl)     // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.Exactly(t, resultFl, result)     // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.True(t, result == 42.42)         // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.True(t, 42.42 == result)         // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.True(t, resultFl == 42.42)       // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.True(t, 42.42 == resultFl)       // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.True(t, result == resultFl)      // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.True(t, resultFl == result)      // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.False(t, result != 42.42)        // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.False(t, 42.42 != result)        // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.False(t, resultFl != 42.42)      // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.False(t, 42.42 != resultFl)      // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.False(t, result != resultFl)     // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+		assert.False(t, resultFl != result)     // want "float-compare: use assert\\.InEpsilon \\(or InDelta\\)"
+
+		assert.Equalf(t, result, 42.42, "msg with args %d %s", 42, "42")          // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Equalf(t, 42.42, result, "msg with args %d %s", 42, "42")          // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Equalf(t, resultFl, 42.42, "msg with args %d %s", 42, "42")        // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Equalf(t, 42.42, resultFl, "msg with args %d %s", 42, "42")        // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Equalf(t, result, resultFl, "msg with args %d %s", 42, "42")       // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Equalf(t, resultFl, result, "msg with args %d %s", 42, "42")       // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.EqualValuesf(t, result, 42.42, "msg with args %d %s", 42, "42")    // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.EqualValuesf(t, 42.42, result, "msg with args %d %s", 42, "42")    // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.EqualValuesf(t, resultFl, 42.42, "msg with args %d %s", 42, "42")  // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.EqualValuesf(t, 42.42, resultFl, "msg with args %d %s", 42, "42")  // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.EqualValuesf(t, result, resultFl, "msg with args %d %s", 42, "42") // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.EqualValuesf(t, resultFl, result, "msg with args %d %s", 42, "42") // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Exactlyf(t, result, 42.42, "msg with args %d %s", 42, "42")        // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Exactlyf(t, 42.42, result, "msg with args %d %s", 42, "42")        // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Exactlyf(t, resultFl, 42.42, "msg with args %d %s", 42, "42")      // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Exactlyf(t, 42.42, resultFl, "msg with args %d %s", 42, "42")      // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Exactlyf(t, result, resultFl, "msg with args %d %s", 42, "42")     // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Exactlyf(t, resultFl, result, "msg with args %d %s", 42, "42")     // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Truef(t, result == 42.42, "msg with args %d %s", 42, "42")         // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Truef(t, 42.42 == result, "msg with args %d %s", 42, "42")         // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Truef(t, resultFl == 42.42, "msg with args %d %s", 42, "42")       // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Truef(t, 42.42 == resultFl, "msg with args %d %s", 42, "42")       // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Truef(t, result == resultFl, "msg with args %d %s", 42, "42")      // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Truef(t, resultFl == result, "msg with args %d %s", 42, "42")      // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Falsef(t, result != 42.42, "msg with args %d %s", 42, "42")        // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Falsef(t, 42.42 != result, "msg with args %d %s", 42, "42")        // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Falsef(t, resultFl != 42.42, "msg with args %d %s", 42, "42")      // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Falsef(t, 42.42 != resultFl, "msg with args %d %s", 42, "42")      // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Falsef(t, result != resultFl, "msg with args %d %s", 42, "42")     // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
+		assert.Falsef(t, resultFl != result, "msg with args %d %s", 42, "42")     // want "float-compare: use assert\\.InEpsilonf \\(or InDeltaf\\)"
 	}
 
 	// Valid.
 	{
+		assert.InDelta(t, result, 42.42, 0.0001)
+		assert.InDeltaf(t, result, 42.42, 0.0001, "msg with args %d %s", 42, "42")
 		assert.InDelta(t, 42.42, result, 0.0001)
 		assert.InDeltaf(t, 42.42, result, 0.0001, "msg with args %d %s", 42, "42")
+		assert.InDelta(t, resultFl, 42.42, 0.0001)
+		assert.InDeltaf(t, resultFl, 42.42, 0.0001, "msg with args %d %s", 42, "42")
+		assert.InDelta(t, 42.42, resultFl, 0.0001)
+		assert.InDeltaf(t, 42.42, resultFl, 0.0001, "msg with args %d %s", 42, "42")
+		assert.InDelta(t, result, resultFl, 0.0001)
+		assert.InDeltaf(t, result, resultFl, 0.0001, "msg with args %d %s", 42, "42")
+		assert.InDelta(t, resultFl, result, 0.0001)
+		assert.InDeltaf(t, resultFl, result, 0.0001, "msg with args %d %s", 42, "42")
+		assert.InEpsilon(t, result, 42.42, 0.0002)
+		assert.InEpsilonf(t, result, 42.42, 0.0002, "msg with args %d %s", 42, "42")
 		assert.InEpsilon(t, 42.42, result, 0.0002)
 		assert.InEpsilonf(t, 42.42, result, 0.0002, "msg with args %d %s", 42, "42")
+		assert.InEpsilon(t, resultFl, 42.42, 0.0002)
+		assert.InEpsilonf(t, resultFl, 42.42, 0.0002, "msg with args %d %s", 42, "42")
+		assert.InEpsilon(t, 42.42, resultFl, 0.0002)
+		assert.InEpsilonf(t, 42.42, resultFl, 0.0002, "msg with args %d %s", 42, "42")
+		assert.InEpsilon(t, result, resultFl, 0.0002)
+		assert.InEpsilonf(t, result, resultFl, 0.0002, "msg with args %d %s", 42, "42")
+		assert.InEpsilon(t, resultFl, result, 0.0002)
+		assert.InEpsilonf(t, resultFl, result, 0.0002, "msg with args %d %s", 42, "42")
 	}
 
 	// Unsupported.
 	{
+		assert.NotEqual(t, 42.42, resultFl)
+		assert.NotEqualf(t, 42.42, resultFl, "msg with args %d %s", 42, "42")
+		assert.Greater(t, 42.42, resultFl)
+		assert.Greaterf(t, 42.42, resultFl, "msg with args %d %s", 42, "42")
+		assert.GreaterOrEqual(t, 42.42, resultFl)
+		assert.GreaterOrEqualf(t, 42.42, resultFl, "msg with args %d %s", 42, "42")
+		assert.Less(t, 42.42, resultFl)
+		assert.Lessf(t, 42.42, resultFl, "msg with args %d %s", 42, "42")
+		assert.LessOrEqual(t, 42.42, resultFl)
+		assert.LessOrEqualf(t, 42.42, resultFl, "msg with args %d %s", 42, "42")
+		assert.True(t, 42.42 != resultFl)
+		assert.Truef(t, 42.42 != resultFl, "msg with args %d %s", 42, "42")
+		assert.True(t, 42.42 > resultFl)
+		assert.Truef(t, 42.42 > resultFl, "msg with args %d %s", 42, "42")
+		assert.True(t, 42.42 >= resultFl)
+		assert.Truef(t, 42.42 >= resultFl, "msg with args %d %s", 42, "42")
+		assert.True(t, 42.42 < resultFl)
+		assert.Truef(t, 42.42 < resultFl, "msg with args %d %s", 42, "42")
+		assert.True(t, 42.42 <= resultFl)
+		assert.Truef(t, 42.42 <= resultFl, "msg with args %d %s", 42, "42")
+		assert.False(t, 42.42 == resultFl)
+		assert.Falsef(t, 42.42 == resultFl, "msg with args %d %s", 42, "42")
+		assert.False(t, 42.42 <= resultFl)
+		assert.Falsef(t, 42.42 <= resultFl, "msg with args %d %s", 42, "42")
+		assert.False(t, 42.42 < resultFl)
+		assert.Falsef(t, 42.42 < resultFl, "msg with args %d %s", 42, "42")
+		assert.False(t, 42.42 <= resultFl)
+		assert.Falsef(t, 42.42 <= resultFl, "msg with args %d %s", 42, "42")
+		assert.False(t, 42.42 > resultFl)
+		assert.Falsef(t, 42.42 > resultFl, "msg with args %d %s", 42, "42")
 		assert.NotEqual(t, 42.42, result)
 		assert.NotEqualf(t, 42.42, result, "msg with args %d %s", 42, "42")
 		assert.Greater(t, 42.42, result)
@@ -58,50 +150,105 @@ func TestFloatCompareChecker(t *testing.T) {
 		assert.LessOrEqualf(t, 42.42, result, "msg with args %d %s", 42, "42")
 		assert.True(t, 42.42 != result)
 		assert.Truef(t, 42.42 != result, "msg with args %d %s", 42, "42")
-		assert.True(t, 42.42 > result)
-		assert.Truef(t, 42.42 > result, "msg with args %d %s", 42, "42")
-		assert.True(t, 42.42 >= result)
-		assert.Truef(t, 42.42 >= result, "msg with args %d %s", 42, "42")
-		assert.True(t, 42.42 < result)
-		assert.Truef(t, 42.42 < result, "msg with args %d %s", 42, "42")
-		assert.True(t, 42.42 <= result)
-		assert.Truef(t, 42.42 <= result, "msg with args %d %s", 42, "42")
 		assert.False(t, 42.42 == result)
 		assert.Falsef(t, 42.42 == result, "msg with args %d %s", 42, "42")
-		assert.False(t, 42.42 <= result)
-		assert.Falsef(t, 42.42 <= result, "msg with args %d %s", 42, "42")
-		assert.False(t, 42.42 < result)
-		assert.Falsef(t, 42.42 < result, "msg with args %d %s", 42, "42")
-		assert.False(t, 42.42 <= result)
-		assert.Falsef(t, 42.42 <= result, "msg with args %d %s", 42, "42")
-		assert.False(t, 42.42 > result)
-		assert.Falsef(t, 42.42 > result, "msg with args %d %s", 42, "42")
 	}
 }
 
 func TestFloatCompareChecker_NoFloatNoWorries(t *testing.T) {
-	var result int64
+	var result any
+	var resultInt int64
 
-	assert.Equal(t, 42, result)
-	assert.Equalf(t, 42, result, "msg with args %d %s", 42, "42")
 	assert.Equal(t, result, 42)
 	assert.Equalf(t, result, 42, "msg with args %d %s", 42, "42")
-	assert.EqualValues(t, 42, result)
-	assert.EqualValuesf(t, 42, result, "msg with args %d %s", 42, "42")
+	assert.Equal(t, 42, result)
+	assert.Equalf(t, 42, result, "msg with args %d %s", 42, "42")
+	assert.Equal(t, resultInt, 42)
+	assert.Equalf(t, resultInt, 42, "msg with args %d %s", 42, "42")
+	assert.Equal(t, 42, resultInt)
+	assert.Equalf(t, 42, resultInt, "msg with args %d %s", 42, "42")
+	assert.Equal(t, result, resultInt)
+	assert.Equalf(t, result, resultInt, "msg with args %d %s", 42, "42")
+	assert.Equal(t, resultInt, result)
+	assert.Equalf(t, resultInt, result, "msg with args %d %s", 42, "42")
+	assert.Equal(t, result, result)
+	assert.Equalf(t, result, result, "msg with args %d %s", 42, "42")
+	assert.Equal(t, resultInt, resultInt)
+	assert.Equalf(t, resultInt, resultInt, "msg with args %d %s", 42, "42")
+	assert.Equal(t, 42, 42)
+	assert.Equalf(t, 42, 42, "msg with args %d %s", 42, "42")
 	assert.EqualValues(t, result, 42)
 	assert.EqualValuesf(t, result, 42, "msg with args %d %s", 42, "42")
-	assert.Exactly(t, 42, result)
-	assert.Exactlyf(t, 42, result, "msg with args %d %s", 42, "42")
+	assert.EqualValues(t, 42, result)
+	assert.EqualValuesf(t, 42, result, "msg with args %d %s", 42, "42")
+	assert.EqualValues(t, resultInt, 42)
+	assert.EqualValuesf(t, resultInt, 42, "msg with args %d %s", 42, "42")
+	assert.EqualValues(t, 42, resultInt)
+	assert.EqualValuesf(t, 42, resultInt, "msg with args %d %s", 42, "42")
+	assert.EqualValues(t, result, resultInt)
+	assert.EqualValuesf(t, result, resultInt, "msg with args %d %s", 42, "42")
+	assert.EqualValues(t, resultInt, result)
+	assert.EqualValuesf(t, resultInt, result, "msg with args %d %s", 42, "42")
+	assert.EqualValues(t, result, result)
+	assert.EqualValuesf(t, result, result, "msg with args %d %s", 42, "42")
+	assert.EqualValues(t, resultInt, resultInt)
+	assert.EqualValuesf(t, resultInt, resultInt, "msg with args %d %s", 42, "42")
+	assert.EqualValues(t, 42, 42)
+	assert.EqualValuesf(t, 42, 42, "msg with args %d %s", 42, "42")
 	assert.Exactly(t, result, 42)
 	assert.Exactlyf(t, result, 42, "msg with args %d %s", 42, "42")
-	assert.True(t, 42 == result)
-	assert.Truef(t, 42 == result, "msg with args %d %s", 42, "42")
+	assert.Exactly(t, 42, result)
+	assert.Exactlyf(t, 42, result, "msg with args %d %s", 42, "42")
+	assert.Exactly(t, resultInt, 42)
+	assert.Exactlyf(t, resultInt, 42, "msg with args %d %s", 42, "42")
+	assert.Exactly(t, 42, resultInt)
+	assert.Exactlyf(t, 42, resultInt, "msg with args %d %s", 42, "42")
+	assert.Exactly(t, result, resultInt)
+	assert.Exactlyf(t, result, resultInt, "msg with args %d %s", 42, "42")
+	assert.Exactly(t, resultInt, result)
+	assert.Exactlyf(t, resultInt, result, "msg with args %d %s", 42, "42")
+	assert.Exactly(t, result, result)
+	assert.Exactlyf(t, result, result, "msg with args %d %s", 42, "42")
+	assert.Exactly(t, resultInt, resultInt)
+	assert.Exactlyf(t, resultInt, resultInt, "msg with args %d %s", 42, "42")
+	assert.Exactly(t, 42, 42)
+	assert.Exactlyf(t, 42, 42, "msg with args %d %s", 42, "42")
 	assert.True(t, result == 42)
 	assert.Truef(t, result == 42, "msg with args %d %s", 42, "42")
-	assert.False(t, 42 != result)
-	assert.Falsef(t, 42 != result, "msg with args %d %s", 42, "42")
+	assert.True(t, 42 == result)
+	assert.Truef(t, 42 == result, "msg with args %d %s", 42, "42")
+	assert.True(t, resultInt == 42)
+	assert.Truef(t, resultInt == 42, "msg with args %d %s", 42, "42")
+	assert.True(t, 42 == resultInt)
+	assert.Truef(t, 42 == resultInt, "msg with args %d %s", 42, "42")
+	assert.True(t, result == resultInt)
+	assert.Truef(t, result == resultInt, "msg with args %d %s", 42, "42")
+	assert.True(t, resultInt == result)
+	assert.Truef(t, resultInt == result, "msg with args %d %s", 42, "42")
+	assert.True(t, result == result)
+	assert.Truef(t, result == result, "msg with args %d %s", 42, "42")
+	assert.True(t, resultInt == resultInt)
+	assert.Truef(t, resultInt == resultInt, "msg with args %d %s", 42, "42")
+	assert.True(t, 42 == 42)
+	assert.Truef(t, 42 == 42, "msg with args %d %s", 42, "42")
 	assert.False(t, result != 42)
 	assert.Falsef(t, result != 42, "msg with args %d %s", 42, "42")
+	assert.False(t, 42 != result)
+	assert.Falsef(t, 42 != result, "msg with args %d %s", 42, "42")
+	assert.False(t, resultInt != 42)
+	assert.Falsef(t, resultInt != 42, "msg with args %d %s", 42, "42")
+	assert.False(t, 42 != resultInt)
+	assert.Falsef(t, 42 != resultInt, "msg with args %d %s", 42, "42")
+	assert.False(t, result != resultInt)
+	assert.Falsef(t, result != resultInt, "msg with args %d %s", 42, "42")
+	assert.False(t, resultInt != result)
+	assert.Falsef(t, resultInt != result, "msg with args %d %s", 42, "42")
+	assert.False(t, result != result)
+	assert.Falsef(t, result != result, "msg with args %d %s", 42, "42")
+	assert.False(t, resultInt != resultInt)
+	assert.Falsef(t, resultInt != resultInt, "msg with args %d %s", 42, "42")
+	assert.False(t, 42 != 42)
+	assert.Falsef(t, 42 != 42, "msg with args %d %s", 42, "42")
 }
 
 func TestFloatCompareChecker_Float32Detection(t *testing.T) {
diff --git a/internal/checkers/float_compare.go b/internal/checkers/float_compare.go
index af38220..f7fe65a 100644
--- a/internal/checkers/float_compare.go
+++ b/internal/checkers/float_compare.go
@@ -1,6 +1,7 @@
 package checkers
 
 import (
+	"fmt"
 	"go/ast"
 	"go/token"
 	"go/types"
@@ -27,7 +28,7 @@ func (checker FloatCompare) Check(pass *analysis.Pass, call *CallMeta) *analysis
 	invalid := func() bool {
 		switch call.Fn.NameFTrimmed {
 		case "Equal", "EqualValues", "Exactly":
-			return len(call.Args) > 1 && isFloat(pass, call.Args[0]) && isFloat(pass, call.Args[1])
+			return len(call.Args) > 1 && (isFloat(pass, call.Args[0]) || isFloat(pass, call.Args[1]))
 
 		case "True":
 			return len(call.Args) > 0 && isFloatCompare(pass, call.Args[0], token.EQL)
@@ -39,7 +40,11 @@ func (checker FloatCompare) Check(pass *analysis.Pass, call *CallMeta) *analysis
 	}()
 
 	if invalid {
-		return newUseFunctionDiagnostic(checker.Name(), call, "InEpsilon (or InDelta)", nil)
+		format := "use %s.InEpsilon (or InDelta)"
+		if call.Fn.IsFmt {
+			format = "use %s.InEpsilonf (or InDeltaf)"
+		}
+		return newDiagnostic(checker.Name(), call, fmt.Sprintf(format, call.SelectorXStr), nil)
 	}
 	return nil
 }
diff --git a/internal/testgen/gen_base.go b/internal/testgen/gen_base.go
index 2f155c9..8b7be38 100644
--- a/internal/testgen/gen_base.go
+++ b/internal/testgen/gen_base.go
@@ -131,34 +131,34 @@ func TestBaseTestsSuite(t *testing.T) {
 
 func (s *BaseTestsSuite) TestAll() {
 	var predicate bool
-	{{ template "suite-assertions" arr . "s.T()" }}
+	{{ template "suite-assertions" (arr . "s.T()") }}
 
 	s.Run("subtest1", func() {
-		{{- template "suite-assertions" arr . "s.T()" }}
+		{{- template "suite-assertions" (arr . "s.T()") }}
 
 		for range []struct{}{} {
 			s.Run("nested test", func() {
-				{{- template "suite-assertions" arr . "s.T()" -}}
+				{{- template "suite-assertions" (arr . "s.T()") -}}
 			})
 		}
 	})
 
 	s.Run("subtest2", func() {
-		{{- template "suite-assertions" arr . "s.T()" -}}
+		{{- template "suite-assertions" (arr . "s.T()") -}}
 	})
 
 	s.T().Run("subtest3", func(t *testing.T) {
-		{{- template "suite-assertions" arr . "t" }}
+		{{- template "suite-assertions" (arr . "t") }}
 
 		for range []struct{}{} {
 			s.T().Run("nested test", func(t *testing.T) {
-				{{- template "suite-assertions" arr . "t" -}}
+				{{- template "suite-assertions" (arr . "t") -}}
 			})
 		}
 	})
 
 	s.T().Run("subtest4", func(t *testing.T) {
-		{{- template "suite-assertions" arr . "t" -}}
+		{{- template "suite-assertions" (arr . "t") -}}
 	})
 }
 `
diff --git a/internal/testgen/gen_float_compare.go b/internal/testgen/gen_float_compare.go
index b0df4ca..d865a19 100644
--- a/internal/testgen/gen_float_compare.go
+++ b/internal/testgen/gen_float_compare.go
@@ -14,9 +14,9 @@ func (FloatCompareTestsGenerator) Checker() checkers.Checker {
 
 func (g FloatCompareTestsGenerator) TemplateData() any {
 	var (
-		name       = g.Checker().Name()
-		report     = name + ": use %s.%s"
-		proposedFn = "InEpsilon (or InDelta)"
+		name      = g.Checker().Name()
+		report    = name + ": use %s.InEpsilon (or %s)"
+		reportFmt = name + ": use %s.InEpsilonf (or %s)" // Workaround for two proposed functions.
 	)
 
 	type floatDetectionTest struct {
@@ -28,6 +28,7 @@ func (g FloatCompareTestsGenerator) TemplateData() any {
 		CheckerName           CheckerName
 		FloatDetection        floatDetectionTest
 		InvalidAssertions     []Assertion
+		InvalidAssertionsF    []Assertion
 		ValidAssertions       []Assertion
 		UnsupportedAssertions []Assertion
 	}{
@@ -48,43 +49,54 @@ func (g FloatCompareTestsGenerator) TemplateData() any {
 				"d * e / a",
 				"math.Round(float64(floatOp()))",
 			},
-			Assrn: Assertion{Fn: "Equal", Argsf: "42.42, %s", ReportMsgf: report, ProposedFn: proposedFn},
+			Assrn: Assertion{Fn: "Equal", Argsf: "42.42, %s", ReportMsgf: report, ProposedFn: "InDelta"},
 		},
 		InvalidAssertions: []Assertion{
-			{Fn: "Equal", Argsf: "%s, result", ReportMsgf: report, ProposedFn: proposedFn},
-			{Fn: "Equal", Argsf: "result, %s", ReportMsgf: report, ProposedFn: proposedFn},
-			{Fn: "EqualValues", Argsf: "%s, result", ReportMsgf: report, ProposedFn: proposedFn},
-			{Fn: "EqualValues", Argsf: "result, %s", ReportMsgf: report, ProposedFn: proposedFn},
-			{Fn: "Exactly", Argsf: "%s, result", ReportMsgf: report, ProposedFn: proposedFn},
-			{Fn: "Exactly", Argsf: "result, %s", ReportMsgf: report, ProposedFn: proposedFn},
-			{Fn: "True", Argsf: "%s == result", ReportMsgf: report, ProposedFn: proposedFn},
-			{Fn: "True", Argsf: "result == %s", ReportMsgf: report, ProposedFn: proposedFn},
-			{Fn: "False", Argsf: "%s != result", ReportMsgf: report, ProposedFn: proposedFn},
-			{Fn: "False", Argsf: "result != %s", ReportMsgf: report, ProposedFn: proposedFn},
+			{Fn: "Equal", Argsf: "%s, %s", ReportMsgf: report, ProposedFn: "InDelta"},
+			{Fn: "EqualValues", Argsf: "%s, %s", ReportMsgf: report, ProposedFn: "InDelta"},
+			{Fn: "Exactly", Argsf: "%s, %s", ReportMsgf: report, ProposedFn: "InDelta"},
+			{Fn: "True", Argsf: "%s == %s", ReportMsgf: report, ProposedFn: "InDelta"},
+			{Fn: "False", Argsf: "%s != %s", ReportMsgf: report, ProposedFn: "InDelta"},
+		},
+		InvalidAssertionsF: []Assertion{
+			{Fn: "Equal", Argsf: "%s, %s", ReportMsgf: reportFmt, ProposedFn: "InDelta"},
+			{Fn: "EqualValues", Argsf: "%s, %s", ReportMsgf: reportFmt, ProposedFn: "InDelta"},
+			{Fn: "Exactly", Argsf: "%s, %s", ReportMsgf: reportFmt, ProposedFn: "InDelta"},
+			{Fn: "True", Argsf: "%s == %s", ReportMsgf: reportFmt, ProposedFn: "InDelta"},
+			{Fn: "False", Argsf: "%s != %s", ReportMsgf: reportFmt, ProposedFn: "InDelta"},
 		},
 		ValidAssertions: []Assertion{
-			{Fn: "InDelta", Argsf: "42.42, result, 0.0001"},
-			{Fn: "InEpsilon", Argsf: "42.42, result, 0.0002"},
+			{Fn: "InDelta", Argsf: "%s, %s, 0.0001"},
+			{Fn: "InEpsilon", Argsf: "%s, %s, 0.0002"},
 		},
-		// NOTE(a.telyshev): Waiting for contribution.
+		// NOTE(a.telyshev): Waiting for contribution:
 		UnsupportedAssertions: []Assertion{
+			{Fn: "NotEqual", Argsf: "42.42, resultFl"},
+			{Fn: "Greater", Argsf: "42.42, resultFl"},
+			{Fn: "GreaterOrEqual", Argsf: "42.42, resultFl"},
+			{Fn: "Less", Argsf: "42.42, resultFl"},
+			{Fn: "LessOrEqual", Argsf: "42.42, resultFl"},
+
+			{Fn: "True", Argsf: "42.42 != resultFl"},
+			{Fn: "True", Argsf: "42.42 > resultFl"},
+			{Fn: "True", Argsf: "42.42 >= resultFl"},
+			{Fn: "True", Argsf: "42.42 < resultFl"},
+			{Fn: "True", Argsf: "42.42 <= resultFl"},
+
+			{Fn: "False", Argsf: "42.42 == resultFl"},
+			{Fn: "False", Argsf: "42.42 <= resultFl"},
+			{Fn: "False", Argsf: "42.42 < resultFl"},
+			{Fn: "False", Argsf: "42.42 <= resultFl"},
+			{Fn: "False", Argsf: "42.42 > resultFl"},
+
+			// `any` cases.
 			{Fn: "NotEqual", Argsf: "42.42, result"},
 			{Fn: "Greater", Argsf: "42.42, result"},
 			{Fn: "GreaterOrEqual", Argsf: "42.42, result"},
 			{Fn: "Less", Argsf: "42.42, result"},
 			{Fn: "LessOrEqual", Argsf: "42.42, result"},
-
 			{Fn: "True", Argsf: "42.42 != result"},
-			{Fn: "True", Argsf: "42.42 > result"},
-			{Fn: "True", Argsf: "42.42 >= result"},
-			{Fn: "True", Argsf: "42.42 < result"},
-			{Fn: "True", Argsf: "42.42 <= result"},
-
 			{Fn: "False", Argsf: "42.42 == result"},
-			{Fn: "False", Argsf: "42.42 <= result"},
-			{Fn: "False", Argsf: "42.42 < result"},
-			{Fn: "False", Argsf: "42.42 <= result"},
-			{Fn: "False", Argsf: "42.42 > result"},
 		},
 	}
 }
@@ -112,19 +124,39 @@ import (
 )
 
 func {{ .CheckerName.AsTestName }}(t *testing.T) {
-	var result float64
+	var result any
+	var resultFl float64
 
 	// Invalid.
 	{
 		{{- range $ai, $assrn := $.InvalidAssertions }}
-			{{ NewAssertionExpander.Expand $assrn "assert" "t" (arr "42.42") }}
+			{{ NewAssertionExpander.NotFmtSingleMode.Expand $assrn "assert" "t" (arr "result" "42.42") }}
+			{{ NewAssertionExpander.NotFmtSingleMode.Expand $assrn "assert" "t" (arr "42.42" "result" ) }}
+			{{ NewAssertionExpander.NotFmtSingleMode.Expand $assrn "assert" "t" (arr "resultFl" "42.42") }}
+			{{ NewAssertionExpander.NotFmtSingleMode.Expand $assrn "assert" "t" (arr "42.42" "resultFl" ) }}
+			{{ NewAssertionExpander.NotFmtSingleMode.Expand $assrn "assert" "t" (arr "result" "resultFl" ) }}
+			{{ NewAssertionExpander.NotFmtSingleMode.Expand $assrn "assert" "t" (arr "resultFl" "result" ) }}
+		{{- end }}
+
+		{{ range $ai, $assrn := $.InvalidAssertionsF }}
+			{{ NewAssertionExpander.FmtSingleMode.Expand $assrn "assert" "t" (arr "result" "42.42") }}
+			{{ NewAssertionExpander.FmtSingleMode.Expand $assrn "assert" "t" (arr "42.42" "result" ) }}
+			{{ NewAssertionExpander.FmtSingleMode.Expand $assrn "assert" "t" (arr "resultFl" "42.42") }}
+			{{ NewAssertionExpander.FmtSingleMode.Expand $assrn "assert" "t" (arr "42.42" "resultFl" ) }}
+			{{ NewAssertionExpander.FmtSingleMode.Expand $assrn "assert" "t" (arr "result" "resultFl" ) }}
+			{{ NewAssertionExpander.FmtSingleMode.Expand $assrn "assert" "t" (arr "resultFl" "result" ) }}
 		{{- end }}
 	}
 
 	// Valid.
 	{
 		{{- range $ai, $assrn := $.ValidAssertions }}
-			{{ NewAssertionExpander.Expand $assrn "assert" "t" nil }}
+			{{ NewAssertionExpander.Expand $assrn "assert" "t" (arr "result" "42.42") }}
+			{{ NewAssertionExpander.Expand $assrn "assert" "t" (arr "42.42" "result" ) }}
+			{{ NewAssertionExpander.Expand $assrn "assert" "t" (arr "resultFl" "42.42") }}
+			{{ NewAssertionExpander.Expand $assrn "assert" "t" (arr "42.42" "resultFl" ) }}
+			{{ NewAssertionExpander.Expand $assrn "assert" "t" (arr "result" "resultFl" ) }}
+			{{ NewAssertionExpander.Expand $assrn "assert" "t" (arr "resultFl" "result" ) }}
 		{{- end }}
 	}
 
@@ -137,10 +169,19 @@ func {{ .CheckerName.AsTestName }}(t *testing.T) {
 }
 
 func {{ .CheckerName.AsTestName }}_NoFloatNoWorries(t *testing.T) {
-	var result int64
+	var result any
+	var resultInt int64
 
 	{{ range $ai, $assrn := $.InvalidAssertions }}
-		{{ NewAssertionExpander.Expand $assrn.WithoutReport "assert" "t" (arr "42") }}
+		{{ NewAssertionExpander.Expand $assrn.WithoutReport "assert" "t" (arr "result" "42") }}
+		{{ NewAssertionExpander.Expand $assrn.WithoutReport "assert" "t" (arr "42" "result") }}
+		{{ NewAssertionExpander.Expand $assrn.WithoutReport "assert" "t" (arr "resultInt" "42") }}
+		{{ NewAssertionExpander.Expand $assrn.WithoutReport "assert" "t" (arr "42" "resultInt") }}
+		{{ NewAssertionExpander.Expand $assrn.WithoutReport "assert" "t" (arr "result" "resultInt") }}
+		{{ NewAssertionExpander.Expand $assrn.WithoutReport "assert" "t" (arr "resultInt" "result") }}
+		{{ NewAssertionExpander.Expand $assrn.WithoutReport "assert" "t" (arr "result" "result") }}
+		{{ NewAssertionExpander.Expand $assrn.WithoutReport "assert" "t" (arr "resultInt" "resultInt") }}
+		{{ NewAssertionExpander.Expand $assrn.WithoutReport "assert" "t" (arr "42" "42") }}
 	{{- end }}
 }
 
diff --git a/internal/testgen/gen_require_error.go b/internal/testgen/gen_require_error.go
index bb14dc9..50eb519 100644
--- a/internal/testgen/gen_require_error.go
+++ b/internal/testgen/gen_require_error.go
@@ -67,7 +67,7 @@ func {{ .CheckerName.AsTestName }}(t *testing.T) {
 	assObj, reqObj := assert.New(t), require.New(t)
 
 	// Invalid.
-	{{ range $si, $sel := arr "assert" "assObj" }}
+	{{ range $si, $sel := (arr "assert" "assObj") }}
 		{{- range $ai, $assrn := $.ErrorAssertions }}
 			{{- $t := "t" }}{{ if eq $sel "assObj"}}{{ $t = "" }}{{ end }}
 			{{- if ne $assrn.Fn "NoError" -}}
@@ -81,7 +81,7 @@ func {{ .CheckerName.AsTestName }}(t *testing.T) {
 	{{- end }}
 
 	// Valid.
-	{{ range $si, $sel := arr "require" "reqObj" }}
+	{{ range $si, $sel := (arr "require" "reqObj") }}
 		{{- range $ai, $assrn := $.ErrorAssertions }}
 			{{- $t := "t" }}{{ if eq $sel "reqObj"}}{{ $t = "" }}{{ end }}
 			{{- NewAssertionExpander.Expand $assrn.WithoutReport $sel $t nil }}
@@ -106,7 +106,7 @@ func (s *{{ $suiteName }}) TestAll() {
 	assObj, reqObj := s.Assert(), s.Require()
 
 	// Invalid.
-	{{ range $si, $sel := arr "s" "s.Assert()" "assObj" }}
+	{{ range $si, $sel := (arr "s" "s.Assert()" "assObj") }}
 		{{- range $ai, $assrn := $.ErrorAssertions }}
 			{{- if ne $assrn.Fn "NoError" -}}
 				{{- NewAssertionExpander.Expand $assrn $sel "" nil }}
@@ -119,7 +119,7 @@ func (s *{{ $suiteName }}) TestAll() {
 	{{- end }}
 
 	// Valid.
-	{{ range $si, $sel := arr "s.Require()" "reqObj" }}
+	{{ range $si, $sel := (arr "s.Require()" "reqObj") }}
 		{{- range $ai, $assrn := $.ErrorAssertions }}
 			{{- NewAssertionExpander.Expand $assrn.WithoutReport $sel "" nil }}
 		{{ end -}}