diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 60b8d66..bba4b14 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -124,9 +124,11 @@ Describe a new checker in [checkers section](./README.md#checkers).
- [elements-match](#elements-match)
- [error-compare](#error-compare)
- [equal-values](#equal-values)
+- [graceful-teardown](#graceful-teardown)
- [float-compare](#float-compare)
- [http-const](#http-const)
- [http-sugar](#http-sugar)
+- [inefficient-assert](#inefficient-assert)
- [negative-positive](#negative-positive)
- [no-fmt-mess](#no-fmt-mess)
- [require-len](#require-len)
@@ -178,6 +180,29 @@ Describe a new checker in [checkers section](./README.md#checkers).
---
+### graceful-teardown
+
+Warns about usage of `require` in `t.Cleanup` functions and suite teardown methods:
+
+```go
+func (s *ServiceIntegrationSuite) TearDownTest() {
+ if p := s.verdictsProducer; p != nil {
+ s.Require().NoError(p.Close()) ❌
+ }
+ if c := s.dlqVerdictsConsumer; c != nil {
+ s.NoError(c.Close())
+ }
+ s.DBSuite.TearDownTest()
+ s.ks.TearDownTest()
+}
+```
+
+**Autofix**: false.
+**Enabled by default**: false.
+**Reason**: Possible resource leaks, because `require` finishes the current goroutine.
+
+---
+
### equal-values
```go
@@ -272,6 +297,31 @@ And similar idea for `assert.InEpsilonSlice` / `assert.InDeltaSlice`.
---
+### inefficient-assert
+
+Simple:
+```go
+body, err := io.ReadAll(rr.Body)
+require.NoError(t, err)
+require.NoError(t, err) ❌
+
+expectedJSON, err := json.Marshal(expected)
+require.NoError(t, err)
+require.JSONEq(t, string(expectedJSON), string(body))
+```
+
+Complex:
+```go
+require.NoError(t, err)
+assert.ErrorContains(t, err, "user") ❌
+```
+
+**Autofix**: false.
+**Enabled by default**: Probably false, depends on implementation performance.
+**Reason**: Code simplification, elimination of possible bugs.
+
+---
+
### negative-positive
```go
diff --git a/analyzer/testdata/src/checkers-default/bool-compare/bool_compare_test.go b/analyzer/testdata/src/checkers-default/bool-compare/bool_compare_test.go
index 30a5019..1a7f7b2 100644
--- a/analyzer/testdata/src/checkers-default/bool-compare/bool_compare_test.go
+++ b/analyzer/testdata/src/checkers-default/bool-compare/bool_compare_test.go
@@ -15,34 +15,46 @@ func TestBoolCompareChecker(t *testing.T) {
// assert.True cases.
{
// Invalid.
- assert.Equal(t, predicate, true) // want "bool-compare: use assert\\.True"
- assert.Equalf(t, predicate, true, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
- assert.Equal(t, true, predicate) // want "bool-compare: use assert\\.True"
- assert.Equalf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
- assert.NotEqual(t, predicate, false) // want "bool-compare: use assert\\.True"
- assert.NotEqualf(t, predicate, false, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
- assert.NotEqual(t, false, predicate) // want "bool-compare: use assert\\.True"
- assert.NotEqualf(t, false, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
- assert.True(t, predicate == true) // want "bool-compare: need to simplify the assertion"
- assert.Truef(t, predicate == true, "msg with args %d %s", 42, "42") // want "bool-compare: need to simplify the assertion"
- assert.True(t, true == predicate) // want "bool-compare: need to simplify the assertion"
- assert.Truef(t, true == predicate, "msg with args %d %s", 42, "42") // want "bool-compare: need to simplify the assertion"
- assert.False(t, predicate == false) // want "bool-compare: use assert\\.True"
- assert.Falsef(t, predicate == false, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
- assert.False(t, false == predicate) // want "bool-compare: use assert\\.True"
- assert.Falsef(t, false == predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
- assert.False(t, predicate != true) // want "bool-compare: use assert\\.True"
- assert.Falsef(t, predicate != true, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
- assert.False(t, true != predicate) // want "bool-compare: use assert\\.True"
- assert.Falsef(t, true != predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
- assert.True(t, predicate != false) // want "bool-compare: need to simplify the assertion"
- assert.Truef(t, predicate != false, "msg with args %d %s", 42, "42") // want "bool-compare: need to simplify the assertion"
- assert.True(t, false != predicate) // want "bool-compare: need to simplify the assertion"
- assert.Truef(t, false != predicate, "msg with args %d %s", 42, "42") // want "bool-compare: need to simplify the assertion"
- assert.False(t, !predicate) // want "bool-compare: use assert\\.True"
- assert.Falsef(t, !predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
- assert.False(t, !result["flag"].(bool)) // want "bool-compare: use assert\\.True"
- assert.Falsef(t, !result["flag"].(bool), "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.Equal(t, predicate, true) // want "bool-compare: use assert\\.True"
+ assert.Equalf(t, predicate, true, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.Equal(t, true, predicate) // want "bool-compare: use assert\\.True"
+ assert.Equalf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.EqualValues(t, predicate, true) // want "bool-compare: use assert\\.True"
+ assert.EqualValuesf(t, predicate, true, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.EqualValues(t, true, predicate) // want "bool-compare: use assert\\.True"
+ assert.EqualValuesf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.Exactly(t, predicate, true) // want "bool-compare: use assert\\.True"
+ assert.Exactlyf(t, predicate, true, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.Exactly(t, true, predicate) // want "bool-compare: use assert\\.True"
+ assert.Exactlyf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.NotEqual(t, predicate, false) // want "bool-compare: use assert\\.True"
+ assert.NotEqualf(t, predicate, false, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.NotEqual(t, false, predicate) // want "bool-compare: use assert\\.True"
+ assert.NotEqualf(t, false, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.NotEqualValues(t, predicate, false) // want "bool-compare: use assert\\.True"
+ assert.NotEqualValuesf(t, predicate, false, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.NotEqualValues(t, false, predicate) // want "bool-compare: use assert\\.True"
+ assert.NotEqualValuesf(t, false, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.True(t, predicate == true) // want "bool-compare: need to simplify the assertion"
+ assert.Truef(t, predicate == true, "msg with args %d %s", 42, "42") // want "bool-compare: need to simplify the assertion"
+ assert.True(t, true == predicate) // want "bool-compare: need to simplify the assertion"
+ assert.Truef(t, true == predicate, "msg with args %d %s", 42, "42") // want "bool-compare: need to simplify the assertion"
+ assert.False(t, predicate == false) // want "bool-compare: use assert\\.True"
+ assert.Falsef(t, predicate == false, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.False(t, false == predicate) // want "bool-compare: use assert\\.True"
+ assert.Falsef(t, false == predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.False(t, predicate != true) // want "bool-compare: use assert\\.True"
+ assert.Falsef(t, predicate != true, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.False(t, true != predicate) // want "bool-compare: use assert\\.True"
+ assert.Falsef(t, true != predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.True(t, predicate != false) // want "bool-compare: need to simplify the assertion"
+ assert.Truef(t, predicate != false, "msg with args %d %s", 42, "42") // want "bool-compare: need to simplify the assertion"
+ assert.True(t, false != predicate) // want "bool-compare: need to simplify the assertion"
+ assert.Truef(t, false != predicate, "msg with args %d %s", 42, "42") // want "bool-compare: need to simplify the assertion"
+ assert.False(t, !predicate) // want "bool-compare: use assert\\.True"
+ assert.Falsef(t, !predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.False(t, !result["flag"].(bool)) // want "bool-compare: use assert\\.True"
+ assert.Falsef(t, !result["flag"].(bool), "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
// Valid.
assert.True(t, predicate)
@@ -52,34 +64,46 @@ func TestBoolCompareChecker(t *testing.T) {
// assert.False cases.
{
// Invalid.
- assert.Equal(t, predicate, false) // want "bool-compare: use assert\\.False"
- assert.Equalf(t, predicate, false, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
- assert.Equal(t, false, predicate) // want "bool-compare: use assert\\.False"
- assert.Equalf(t, false, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
- assert.NotEqual(t, predicate, true) // want "bool-compare: use assert\\.False"
- assert.NotEqualf(t, predicate, true, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
- assert.NotEqual(t, true, predicate) // want "bool-compare: use assert\\.False"
- assert.NotEqualf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
- assert.False(t, predicate == true) // want "bool-compare: need to simplify the assertion"
- assert.Falsef(t, predicate == true, "msg with args %d %s", 42, "42") // want "bool-compare: need to simplify the assertion"
- assert.False(t, true == predicate) // want "bool-compare: need to simplify the assertion"
- assert.Falsef(t, true == predicate, "msg with args %d %s", 42, "42") // want "bool-compare: need to simplify the assertion"
- assert.True(t, predicate == false) // want "bool-compare: use assert\\.False"
- assert.Truef(t, predicate == false, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
- assert.True(t, false == predicate) // want "bool-compare: use assert\\.False"
- assert.Truef(t, false == predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
- assert.True(t, predicate != true) // want "bool-compare: use assert\\.False"
- assert.Truef(t, predicate != true, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
- assert.True(t, true != predicate) // want "bool-compare: use assert\\.False"
- assert.Truef(t, true != predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
- assert.False(t, predicate != false) // want "bool-compare: need to simplify the assertion"
- assert.Falsef(t, predicate != false, "msg with args %d %s", 42, "42") // want "bool-compare: need to simplify the assertion"
- assert.False(t, false != predicate) // want "bool-compare: need to simplify the assertion"
- assert.Falsef(t, false != predicate, "msg with args %d %s", 42, "42") // want "bool-compare: need to simplify the assertion"
- assert.True(t, !predicate) // want "bool-compare: use assert\\.False"
- assert.Truef(t, !predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
- assert.True(t, !result["flag"].(bool)) // want "bool-compare: use assert\\.False"
- assert.Truef(t, !result["flag"].(bool), "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.Equal(t, predicate, false) // want "bool-compare: use assert\\.False"
+ assert.Equalf(t, predicate, false, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.Equal(t, false, predicate) // want "bool-compare: use assert\\.False"
+ assert.Equalf(t, false, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.EqualValues(t, predicate, false) // want "bool-compare: use assert\\.False"
+ assert.EqualValuesf(t, predicate, false, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.EqualValues(t, false, predicate) // want "bool-compare: use assert\\.False"
+ assert.EqualValuesf(t, false, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.Exactly(t, predicate, false) // want "bool-compare: use assert\\.False"
+ assert.Exactlyf(t, predicate, false, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.Exactly(t, false, predicate) // want "bool-compare: use assert\\.False"
+ assert.Exactlyf(t, false, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.NotEqual(t, predicate, true) // want "bool-compare: use assert\\.False"
+ assert.NotEqualf(t, predicate, true, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.NotEqual(t, true, predicate) // want "bool-compare: use assert\\.False"
+ assert.NotEqualf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.NotEqualValues(t, predicate, true) // want "bool-compare: use assert\\.False"
+ assert.NotEqualValuesf(t, predicate, true, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.NotEqualValues(t, true, predicate) // want "bool-compare: use assert\\.False"
+ assert.NotEqualValuesf(t, true, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.False(t, predicate == true) // want "bool-compare: need to simplify the assertion"
+ assert.Falsef(t, predicate == true, "msg with args %d %s", 42, "42") // want "bool-compare: need to simplify the assertion"
+ assert.False(t, true == predicate) // want "bool-compare: need to simplify the assertion"
+ assert.Falsef(t, true == predicate, "msg with args %d %s", 42, "42") // want "bool-compare: need to simplify the assertion"
+ assert.True(t, predicate == false) // want "bool-compare: use assert\\.False"
+ assert.Truef(t, predicate == false, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.True(t, false == predicate) // want "bool-compare: use assert\\.False"
+ assert.Truef(t, false == predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.True(t, predicate != true) // want "bool-compare: use assert\\.False"
+ assert.Truef(t, predicate != true, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.True(t, true != predicate) // want "bool-compare: use assert\\.False"
+ assert.Truef(t, true != predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.False(t, predicate != false) // want "bool-compare: need to simplify the assertion"
+ assert.Falsef(t, predicate != false, "msg with args %d %s", 42, "42") // want "bool-compare: need to simplify the assertion"
+ assert.False(t, false != predicate) // want "bool-compare: need to simplify the assertion"
+ assert.Falsef(t, false != predicate, "msg with args %d %s", 42, "42") // want "bool-compare: need to simplify the assertion"
+ assert.True(t, !predicate) // want "bool-compare: use assert\\.False"
+ assert.Truef(t, !predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.True(t, !result["flag"].(bool)) // want "bool-compare: use assert\\.False"
+ assert.Truef(t, !result["flag"].(bool), "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
// Valid.
assert.False(t, predicate)
diff --git a/analyzer/testdata/src/checkers-default/bool-compare/bool_compare_test.go.golden b/analyzer/testdata/src/checkers-default/bool-compare/bool_compare_test.go.golden
index b32b0ef..cf6704d 100644
--- a/analyzer/testdata/src/checkers-default/bool-compare/bool_compare_test.go.golden
+++ b/analyzer/testdata/src/checkers-default/bool-compare/bool_compare_test.go.golden
@@ -23,6 +23,18 @@ func TestBoolCompareChecker(t *testing.T) {
assert.Truef(t, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
assert.True(t, predicate) // want "bool-compare: use assert\\.True"
assert.Truef(t, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.True(t, predicate) // want "bool-compare: use assert\\.True"
+ assert.Truef(t, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.True(t, predicate) // want "bool-compare: use assert\\.True"
+ assert.Truef(t, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.True(t, predicate) // want "bool-compare: use assert\\.True"
+ assert.Truef(t, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.True(t, predicate) // want "bool-compare: use assert\\.True"
+ assert.Truef(t, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.True(t, predicate) // want "bool-compare: use assert\\.True"
+ assert.Truef(t, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
+ assert.True(t, predicate) // want "bool-compare: use assert\\.True"
+ assert.Truef(t, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Truef"
assert.True(t, predicate) // want "bool-compare: need to simplify the assertion"
assert.Truef(t, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: need to simplify the assertion"
assert.True(t, predicate) // want "bool-compare: need to simplify the assertion"
@@ -60,6 +72,18 @@ func TestBoolCompareChecker(t *testing.T) {
assert.Falsef(t, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
assert.False(t, predicate) // want "bool-compare: use assert\\.False"
assert.Falsef(t, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.False(t, predicate) // want "bool-compare: use assert\\.False"
+ assert.Falsef(t, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.False(t, predicate) // want "bool-compare: use assert\\.False"
+ assert.Falsef(t, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.False(t, predicate) // want "bool-compare: use assert\\.False"
+ assert.Falsef(t, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.False(t, predicate) // want "bool-compare: use assert\\.False"
+ assert.Falsef(t, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.False(t, predicate) // want "bool-compare: use assert\\.False"
+ assert.Falsef(t, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
+ assert.False(t, predicate) // want "bool-compare: use assert\\.False"
+ assert.Falsef(t, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: use assert\\.Falsef"
assert.False(t, predicate) // want "bool-compare: need to simplify the assertion"
assert.Falsef(t, predicate, "msg with args %d %s", 42, "42") // want "bool-compare: need to simplify the assertion"
assert.False(t, predicate) // want "bool-compare: need to simplify the assertion"
diff --git a/analyzer/testdata/src/checkers-default/empty/empty_test.go b/analyzer/testdata/src/checkers-default/empty/empty_test.go
index 0b62475..4978fdb 100644
--- a/analyzer/testdata/src/checkers-default/empty/empty_test.go
+++ b/analyzer/testdata/src/checkers-default/empty/empty_test.go
@@ -20,6 +20,14 @@ func TestEmptyChecker(t *testing.T) {
assert.Equalf(t, len(elems), 0, "msg with args %d %s", 42, "42") // want "empty: use assert\\.Emptyf"
assert.Equal(t, 0, len(elems)) // want "empty: use assert\\.Empty"
assert.Equalf(t, 0, len(elems), "msg with args %d %s", 42, "42") // want "empty: use assert\\.Emptyf"
+ assert.EqualValues(t, len(elems), 0) // want "empty: use assert\\.Empty"
+ assert.EqualValuesf(t, len(elems), 0, "msg with args %d %s", 42, "42") // want "empty: use assert\\.Emptyf"
+ assert.EqualValues(t, 0, len(elems)) // want "empty: use assert\\.Empty"
+ assert.EqualValuesf(t, 0, len(elems), "msg with args %d %s", 42, "42") // want "empty: use assert\\.Emptyf"
+ assert.Exactly(t, len(elems), 0) // want "empty: use assert\\.Empty"
+ assert.Exactlyf(t, len(elems), 0, "msg with args %d %s", 42, "42") // want "empty: use assert\\.Emptyf"
+ assert.Exactly(t, 0, len(elems)) // want "empty: use assert\\.Empty"
+ assert.Exactlyf(t, 0, len(elems), "msg with args %d %s", 42, "42") // want "empty: use assert\\.Emptyf"
assert.LessOrEqual(t, len(elems), 0) // want "empty: use assert\\.Empty"
assert.LessOrEqualf(t, len(elems), 0, "msg with args %d %s", 42, "42") // want "empty: use assert\\.Emptyf"
assert.GreaterOrEqual(t, 0, len(elems)) // want "empty: use assert\\.Empty"
@@ -37,14 +45,18 @@ func TestEmptyChecker(t *testing.T) {
// assert.NotEmpty cases.
{
// Invalid.
- assert.NotEqual(t, len(elems), 0) // want "empty: use assert\\.NotEmpty"
- assert.NotEqualf(t, len(elems), 0, "msg with args %d %s", 42, "42") // want "empty: use assert\\.NotEmptyf"
- assert.NotEqual(t, 0, len(elems)) // want "empty: use assert\\.NotEmpty"
- assert.NotEqualf(t, 0, len(elems), "msg with args %d %s", 42, "42") // want "empty: use assert\\.NotEmptyf"
- assert.Greater(t, len(elems), 0) // want "empty: use assert\\.NotEmpty"
- assert.Greaterf(t, len(elems), 0, "msg with args %d %s", 42, "42") // want "empty: use assert\\.NotEmptyf"
- assert.Less(t, 0, len(elems)) // want "empty: use assert\\.NotEmpty"
- assert.Lessf(t, 0, len(elems), "msg with args %d %s", 42, "42") // want "empty: use assert\\.NotEmptyf"
+ assert.NotEqual(t, len(elems), 0) // want "empty: use assert\\.NotEmpty"
+ assert.NotEqualf(t, len(elems), 0, "msg with args %d %s", 42, "42") // want "empty: use assert\\.NotEmptyf"
+ assert.NotEqual(t, 0, len(elems)) // want "empty: use assert\\.NotEmpty"
+ assert.NotEqualf(t, 0, len(elems), "msg with args %d %s", 42, "42") // want "empty: use assert\\.NotEmptyf"
+ assert.NotEqualValues(t, len(elems), 0) // want "empty: use assert\\.NotEmpty"
+ assert.NotEqualValuesf(t, len(elems), 0, "msg with args %d %s", 42, "42") // want "empty: use assert\\.NotEmptyf"
+ assert.NotEqualValues(t, 0, len(elems)) // want "empty: use assert\\.NotEmpty"
+ assert.NotEqualValuesf(t, 0, len(elems), "msg with args %d %s", 42, "42") // want "empty: use assert\\.NotEmptyf"
+ assert.Greater(t, len(elems), 0) // want "empty: use assert\\.NotEmpty"
+ assert.Greaterf(t, len(elems), 0, "msg with args %d %s", 42, "42") // want "empty: use assert\\.NotEmptyf"
+ assert.Less(t, 0, len(elems)) // want "empty: use assert\\.NotEmpty"
+ assert.Lessf(t, 0, len(elems), "msg with args %d %s", 42, "42") // want "empty: use assert\\.NotEmptyf"
// Valid.
assert.NotEmpty(t, elems)
diff --git a/analyzer/testdata/src/checkers-default/empty/empty_test.go.golden b/analyzer/testdata/src/checkers-default/empty/empty_test.go.golden
index 5252d7c..d774ff3 100644
--- a/analyzer/testdata/src/checkers-default/empty/empty_test.go.golden
+++ b/analyzer/testdata/src/checkers-default/empty/empty_test.go.golden
@@ -28,6 +28,14 @@ func TestEmptyChecker(t *testing.T) {
assert.Emptyf(t, elems, "msg with args %d %s", 42, "42") // want "empty: use assert\\.Emptyf"
assert.Empty(t, elems) // want "empty: use assert\\.Empty"
assert.Emptyf(t, elems, "msg with args %d %s", 42, "42") // want "empty: use assert\\.Emptyf"
+ assert.Empty(t, elems) // want "empty: use assert\\.Empty"
+ assert.Emptyf(t, elems, "msg with args %d %s", 42, "42") // want "empty: use assert\\.Emptyf"
+ assert.Empty(t, elems) // want "empty: use assert\\.Empty"
+ assert.Emptyf(t, elems, "msg with args %d %s", 42, "42") // want "empty: use assert\\.Emptyf"
+ assert.Empty(t, elems) // want "empty: use assert\\.Empty"
+ assert.Emptyf(t, elems, "msg with args %d %s", 42, "42") // want "empty: use assert\\.Emptyf"
+ assert.Empty(t, elems) // want "empty: use assert\\.Empty"
+ assert.Emptyf(t, elems, "msg with args %d %s", 42, "42") // want "empty: use assert\\.Emptyf"
// Valid.
assert.Empty(t, elems)
@@ -45,6 +53,10 @@ func TestEmptyChecker(t *testing.T) {
assert.NotEmptyf(t, elems, "msg with args %d %s", 42, "42") // want "empty: use assert\\.NotEmptyf"
assert.NotEmpty(t, elems) // want "empty: use assert\\.NotEmpty"
assert.NotEmptyf(t, elems, "msg with args %d %s", 42, "42") // want "empty: use assert\\.NotEmptyf"
+ assert.NotEmpty(t, elems) // want "empty: use assert\\.NotEmpty"
+ assert.NotEmptyf(t, elems, "msg with args %d %s", 42, "42") // want "empty: use assert\\.NotEmptyf"
+ assert.NotEmpty(t, elems) // want "empty: use assert\\.NotEmpty"
+ assert.NotEmptyf(t, elems, "msg with args %d %s", 42, "42") // want "empty: use assert\\.NotEmptyf"
// Valid.
assert.NotEmpty(t, elems)
diff --git a/analyzer/testdata/src/checkers-default/error-nil/error_nil_test.go b/analyzer/testdata/src/checkers-default/error-nil/error_nil_test.go
index 70f907d..407b90a 100644
--- a/analyzer/testdata/src/checkers-default/error-nil/error_nil_test.go
+++ b/analyzer/testdata/src/checkers-default/error-nil/error_nil_test.go
@@ -15,22 +15,34 @@ func TestErrorNilChecker(t *testing.T) {
// Invalid.
{
- assert.Nil(t, err) // want "error-nil: use assert\\.NoError"
- assert.Nilf(t, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.NoErrorf"
- assert.NotNil(t, err) // want "error-nil: use assert\\.Error"
- assert.NotNilf(t, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.Errorf"
- assert.Equal(t, err, nil) // want "error-nil: use assert\\.NoError"
- assert.Equalf(t, err, nil, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.NoErrorf"
- assert.Equal(t, nil, err) // want "error-nil: use assert\\.NoError"
- assert.Equalf(t, nil, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.NoErrorf"
- assert.NotEqual(t, err, nil) // want "error-nil: use assert\\.Error"
- assert.NotEqualf(t, err, nil, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.Errorf"
- assert.NotEqual(t, nil, err) // want "error-nil: use assert\\.Error"
- assert.NotEqualf(t, nil, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.Errorf"
- assert.ErrorIs(t, err, nil) // want "error-nil: use assert\\.NoError"
- assert.ErrorIsf(t, err, nil, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.NoErrorf"
- assert.NotErrorIs(t, err, nil) // want "error-nil: use assert\\.Error"
- assert.NotErrorIsf(t, err, nil, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.Errorf"
+ assert.Nil(t, err) // want "error-nil: use assert\\.NoError"
+ assert.Nilf(t, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.NoErrorf"
+ assert.NotNil(t, err) // want "error-nil: use assert\\.Error"
+ assert.NotNilf(t, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.Errorf"
+ assert.Equal(t, err, nil) // want "error-nil: use assert\\.NoError"
+ assert.Equalf(t, err, nil, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.NoErrorf"
+ assert.Equal(t, nil, err) // want "error-nil: use assert\\.NoError"
+ assert.Equalf(t, nil, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.NoErrorf"
+ assert.EqualValues(t, err, nil) // want "error-nil: use assert\\.NoError"
+ assert.EqualValuesf(t, err, nil, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.NoErrorf"
+ assert.EqualValues(t, nil, err) // want "error-nil: use assert\\.NoError"
+ assert.EqualValuesf(t, nil, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.NoErrorf"
+ assert.Exactly(t, err, nil) // want "error-nil: use assert\\.NoError"
+ assert.Exactlyf(t, err, nil, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.NoErrorf"
+ assert.Exactly(t, nil, err) // want "error-nil: use assert\\.NoError"
+ assert.Exactlyf(t, nil, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.NoErrorf"
+ assert.NotEqual(t, err, nil) // want "error-nil: use assert\\.Error"
+ assert.NotEqualf(t, err, nil, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.Errorf"
+ assert.NotEqual(t, nil, err) // want "error-nil: use assert\\.Error"
+ assert.NotEqualf(t, nil, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.Errorf"
+ assert.NotEqualValues(t, err, nil) // want "error-nil: use assert\\.Error"
+ assert.NotEqualValuesf(t, err, nil, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.Errorf"
+ assert.NotEqualValues(t, nil, err) // want "error-nil: use assert\\.Error"
+ assert.NotEqualValuesf(t, nil, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.Errorf"
+ assert.ErrorIs(t, err, nil) // want "error-nil: use assert\\.NoError"
+ assert.ErrorIsf(t, err, nil, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.NoErrorf"
+ assert.NotErrorIs(t, err, nil) // want "error-nil: use assert\\.Error"
+ assert.NotErrorIsf(t, err, nil, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.Errorf"
}
// Valid.
diff --git a/analyzer/testdata/src/checkers-default/error-nil/error_nil_test.go.golden b/analyzer/testdata/src/checkers-default/error-nil/error_nil_test.go.golden
index 9b7f469..ba25565 100644
--- a/analyzer/testdata/src/checkers-default/error-nil/error_nil_test.go.golden
+++ b/analyzer/testdata/src/checkers-default/error-nil/error_nil_test.go.golden
@@ -23,6 +23,18 @@ func TestErrorNilChecker(t *testing.T) {
assert.NoErrorf(t, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.NoErrorf"
assert.NoError(t, err) // want "error-nil: use assert\\.NoError"
assert.NoErrorf(t, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.NoErrorf"
+ assert.NoError(t, err) // want "error-nil: use assert\\.NoError"
+ assert.NoErrorf(t, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.NoErrorf"
+ assert.NoError(t, err) // want "error-nil: use assert\\.NoError"
+ assert.NoErrorf(t, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.NoErrorf"
+ assert.NoError(t, err) // want "error-nil: use assert\\.NoError"
+ assert.NoErrorf(t, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.NoErrorf"
+ assert.NoError(t, err) // want "error-nil: use assert\\.NoError"
+ assert.NoErrorf(t, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.NoErrorf"
+ assert.Error(t, err) // want "error-nil: use assert\\.Error"
+ assert.Errorf(t, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.Errorf"
+ assert.Error(t, err) // want "error-nil: use assert\\.Error"
+ assert.Errorf(t, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.Errorf"
assert.Error(t, err) // want "error-nil: use assert\\.Error"
assert.Errorf(t, err, "msg with args %d %s", 42, "42") // want "error-nil: use assert\\.Errorf"
assert.Error(t, err) // want "error-nil: use assert\\.Error"
diff --git a/analyzer/testdata/src/checkers-default/expected-actual/expected_actual_test.go b/analyzer/testdata/src/checkers-default/expected-actual/expected_actual_test.go
index 87e312b..d71a0cd 100644
--- a/analyzer/testdata/src/checkers-default/expected-actual/expected_actual_test.go
+++ b/analyzer/testdata/src/checkers-default/expected-actual/expected_actual_test.go
@@ -7,11 +7,17 @@ import (
"io"
"net/http"
"testing"
+ "time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
+type user struct {
+ Name string
+ id uint64
+}
+
type testCase struct{ expected string } //
func (c testCase) exp() string { return c.expected }
@@ -24,59 +30,67 @@ func TestExpectedActualChecker(t *testing.T) {
// Invalid.
{
- assert.Equal(t, result, expected) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, result, expected, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, result, tt.expected) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, result, tt.expected, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, result, tt.exp()) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, result, tt.exp(), "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, result, expectedVal()) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, result, expectedVal(), "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, result, []int{1, 2, 3}) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, result, []int{1, 2, 3}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, result, [3]int{1, 2, 3}) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, result, [3]int{1, 2, 3}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, result, map[string]int{"0": 1}) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, result, map[string]int{"0": 1}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, result, 42) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, result, 42, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, result, 3.14) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, result, 3.14, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, result, 0.707i) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, result, 0.707i, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, result, "raw string") // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, result, "raw string", "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, result, '\U00101234') // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, result, '\U00101234', "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, result, true) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, result, true, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
-
- assert.NotEqual(t, result, expected) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, result, expected, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, result, tt.expected) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, result, tt.expected, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, result, tt.exp()) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, result, tt.exp(), "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, result, expectedVal()) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, result, expectedVal(), "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, result, []int{1, 2, 3}) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, result, []int{1, 2, 3}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, result, [3]int{1, 2, 3}) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, result, [3]int{1, 2, 3}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, result, map[string]int{"0": 1}) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, result, map[string]int{"0": 1}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, result, 42) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, result, 42, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, result, 3.14) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, result, 3.14, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, result, 0.707i) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, result, 0.707i, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, result, "raw string") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, result, "raw string", "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, result, '\U00101234') // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, result, '\U00101234', "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, result, true) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, result, true, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, result, expected) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, result, expected, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, result, tt.expected) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, result, tt.expected, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, result, tt.exp()) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, result, tt.exp(), "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, result, expectedVal()) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, result, expectedVal(), "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, result, []int{1, 2, 3}) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, result, []int{1, 2, 3}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, result, [3]int{1, 2, 3}) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, result, [3]int{1, 2, 3}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, result, map[string]int{"0": 1}) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, result, map[string]int{"0": 1}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, result, user{Name: "Anton"}) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, result, user{Name: "Anton"}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, result, struct{ Name string }{Name: "Anton"}) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, result, struct{ Name string }{Name: "Anton"}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, result, 42) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, result, 42, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, result, 3.14) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, result, 3.14, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, result, 0.707i) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, result, 0.707i, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, result, "raw string") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, result, "raw string", "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, result, '\U00101234') // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, result, '\U00101234', "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, result, true) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, result, true, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+
+ assert.NotEqual(t, result, expected) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, result, expected, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, result, tt.expected) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, result, tt.expected, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, result, tt.exp()) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, result, tt.exp(), "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, result, expectedVal()) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, result, expectedVal(), "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, result, []int{1, 2, 3}) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, result, []int{1, 2, 3}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, result, [3]int{1, 2, 3}) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, result, [3]int{1, 2, 3}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, result, map[string]int{"0": 1}) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, result, map[string]int{"0": 1}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, result, user{Name: "Anton"}) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, result, user{Name: "Anton"}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, result, struct{ Name string }{Name: "Anton"}) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, result, struct{ Name string }{Name: "Anton"}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, result, 42) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, result, 42, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, result, 3.14) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, result, 3.14, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, result, 0.707i) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, result, 0.707i, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, result, "raw string") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, result, "raw string", "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, result, '\U00101234') // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, result, '\U00101234', "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, result, true) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, result, true, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
}
// Valid.
@@ -95,6 +109,10 @@ func TestExpectedActualChecker(t *testing.T) {
assert.Equalf(t, [3]int{1, 2, 3}, result, "msg with args %d %s", 42, "42")
assert.Equal(t, map[string]int{"0": 1}, result)
assert.Equalf(t, map[string]int{"0": 1}, result, "msg with args %d %s", 42, "42")
+ assert.Equal(t, user{Name: "Anton"}, result)
+ assert.Equalf(t, user{Name: "Anton"}, result, "msg with args %d %s", 42, "42")
+ assert.Equal(t, struct{ Name string }{Name: "Anton"}, result)
+ assert.Equalf(t, struct{ Name string }{Name: "Anton"}, 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, 3.14, result)
@@ -122,6 +140,10 @@ func TestExpectedActualChecker(t *testing.T) {
assert.NotEqualf(t, [3]int{1, 2, 3}, result, "msg with args %d %s", 42, "42")
assert.NotEqual(t, map[string]int{"0": 1}, result)
assert.NotEqualf(t, map[string]int{"0": 1}, result, "msg with args %d %s", 42, "42")
+ assert.NotEqual(t, user{Name: "Anton"}, result)
+ assert.NotEqualf(t, user{Name: "Anton"}, result, "msg with args %d %s", 42, "42")
+ assert.NotEqual(t, struct{ Name string }{Name: "Anton"}, result)
+ assert.NotEqualf(t, struct{ Name string }{Name: "Anton"}, result, "msg with args %d %s", 42, "42")
assert.NotEqual(t, 42, result)
assert.NotEqualf(t, 42, result, "msg with args %d %s", 42, "42")
assert.NotEqual(t, 3.14, result)
@@ -137,6 +159,120 @@ func TestExpectedActualChecker(t *testing.T) {
}
}
+func TestExpectedActualChecker_Other(t *testing.T) {
+ var (
+ result, expected any
+ resultPtr, expectedPtr *int
+ resultObj, expectedObj user
+ resultTime, expectedTime time.Time
+ value int
+ )
+
+ // Invalid.
+ {
+ assert.EqualExportedValues(t, resultObj, expectedObj) // want "expected-actual: need to reverse actual and expected values"
+ assert.EqualExportedValuesf(t, resultObj, expectedObj, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.EqualExportedValues(t, resultObj, user{Name: "Anton"}) // want "expected-actual: need to reverse actual and expected values"
+ assert.EqualExportedValuesf(t, resultObj, user{Name: "Anton"}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.EqualExportedValues(t, resultObj, struct{ Name string }{Name: "Anton"}) // want "expected-actual: need to reverse actual and expected values"
+ assert.EqualExportedValuesf(t, resultObj, struct{ Name string }{Name: "Anton"}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.EqualValues(t, result, expected) // want "expected-actual: need to reverse actual and expected values"
+ assert.EqualValuesf(t, result, expected, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.EqualValues(t, result, uint32(100)) // want "expected-actual: need to reverse actual and expected values"
+ assert.EqualValuesf(t, result, uint32(100), "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualValues(t, result, expected) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualValuesf(t, result, expected, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualValues(t, result, uint32(100)) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualValuesf(t, result, uint32(100), "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Exactly(t, result, expected) // want "expected-actual: need to reverse actual and expected values"
+ assert.Exactlyf(t, result, expected, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Exactly(t, result, int64(1)) // want "expected-actual: need to reverse actual and expected values"
+ assert.Exactlyf(t, result, int64(1), "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.InDelta(t, result, expected, 1.0) // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaf(t, result, expected, 1.0, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.InDelta(t, result, 42.42, 1.0) // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaf(t, result, 42.42, 1.0, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaMapValues(t, result, expected, 2.0) // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaMapValuesf(t, result, expected, 2.0, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaMapValues(t, result, map[string]float64{"score": 0.99}, 2.0) // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaMapValuesf(t, result, map[string]float64{"score": 0.99}, 2.0, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaSlice(t, result, expected, 1.0) // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaSlicef(t, result, expected, 1.0, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaSlice(t, result, []float64{0.98, 0.99}, 1.0) // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaSlicef(t, result, []float64{0.98, 0.99}, 1.0, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.InEpsilon(t, result, expected, 0.0001) // want "expected-actual: need to reverse actual and expected values"
+ assert.InEpsilonf(t, result, expected, 0.0001, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.InEpsilon(t, result, 42.42, 0.0001) // want "expected-actual: need to reverse actual and expected values"
+ assert.InEpsilonf(t, result, 42.42, 0.0001, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.IsType(t, result, expected) // want "expected-actual: need to reverse actual and expected values"
+ assert.IsTypef(t, result, expected, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.IsType(t, result, user{}) // want "expected-actual: need to reverse actual and expected values"
+ assert.IsTypef(t, result, user{}, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.IsType(t, result, (*user)(nil)) // want "expected-actual: need to reverse actual and expected values"
+ assert.IsTypef(t, result, (*user)(nil), "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Same(t, resultPtr, expectedPtr) // want "expected-actual: need to reverse actual and expected values"
+ assert.Samef(t, resultPtr, expectedPtr, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Same(t, resultPtr, &value) // want "expected-actual: need to reverse actual and expected values"
+ assert.Samef(t, resultPtr, &value, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotSame(t, resultPtr, expectedPtr) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotSamef(t, resultPtr, expectedPtr, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotSame(t, resultPtr, &value) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotSamef(t, resultPtr, &value, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.WithinDuration(t, resultTime, expectedTime, time.Second) // want "expected-actual: need to reverse actual and expected values"
+ assert.WithinDurationf(t, resultTime, expectedTime, time.Second, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ }
+
+ // Valid.
+ {
+ assert.EqualExportedValues(t, expectedObj, resultObj)
+ assert.EqualExportedValuesf(t, expectedObj, resultObj, "msg with args %d %s", 42, "42")
+ assert.EqualExportedValues(t, user{Name: "Anton"}, resultObj)
+ assert.EqualExportedValuesf(t, user{Name: "Anton"}, resultObj, "msg with args %d %s", 42, "42")
+ assert.EqualExportedValues(t, struct{ Name string }{Name: "Anton"}, resultObj)
+ assert.EqualExportedValuesf(t, struct{ Name string }{Name: "Anton"}, resultObj, "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, expected, result)
+ assert.EqualValuesf(t, expected, result, "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, uint32(100), result)
+ assert.EqualValuesf(t, uint32(100), result, "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, expected, result)
+ assert.NotEqualValuesf(t, expected, result, "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, uint32(100), result)
+ assert.NotEqualValuesf(t, uint32(100), result, "msg with args %d %s", 42, "42")
+ assert.Exactly(t, expected, result)
+ assert.Exactlyf(t, expected, result, "msg with args %d %s", 42, "42")
+ assert.Exactly(t, int64(1), result)
+ assert.Exactlyf(t, int64(1), result, "msg with args %d %s", 42, "42")
+ assert.InDelta(t, expected, result, 1.0)
+ assert.InDeltaf(t, expected, result, 1.0, "msg with args %d %s", 42, "42")
+ assert.InDelta(t, 42.42, result, 1.0)
+ assert.InDeltaf(t, 42.42, result, 1.0, "msg with args %d %s", 42, "42")
+ assert.InDeltaMapValues(t, expected, result, 2.0)
+ assert.InDeltaMapValuesf(t, expected, result, 2.0, "msg with args %d %s", 42, "42")
+ assert.InDeltaMapValues(t, map[string]float64{"score": 0.99}, result, 2.0)
+ assert.InDeltaMapValuesf(t, map[string]float64{"score": 0.99}, result, 2.0, "msg with args %d %s", 42, "42")
+ assert.InEpsilon(t, expected, result, 0.0001)
+ assert.InEpsilonf(t, expected, result, 0.0001, "msg with args %d %s", 42, "42")
+ assert.InEpsilon(t, 42.42, result, 0.0001)
+ assert.InEpsilonf(t, 42.42, result, 0.0001, "msg with args %d %s", 42, "42")
+ assert.IsType(t, expected, result)
+ assert.IsTypef(t, expected, result, "msg with args %d %s", 42, "42")
+ assert.IsType(t, user{}, result)
+ assert.IsTypef(t, user{}, result, "msg with args %d %s", 42, "42")
+ assert.IsType(t, (*user)(nil), result)
+ assert.IsTypef(t, (*user)(nil), result, "msg with args %d %s", 42, "42")
+ assert.Same(t, expectedPtr, resultPtr)
+ assert.Samef(t, expectedPtr, resultPtr, "msg with args %d %s", 42, "42")
+ assert.Same(t, &value, resultPtr)
+ assert.Samef(t, &value, resultPtr, "msg with args %d %s", 42, "42")
+ assert.NotSame(t, expectedPtr, resultPtr)
+ assert.NotSamef(t, expectedPtr, resultPtr, "msg with args %d %s", 42, "42")
+ assert.NotSame(t, &value, resultPtr)
+ assert.NotSamef(t, &value, resultPtr, "msg with args %d %s", 42, "42")
+ assert.WithinDuration(t, expectedTime, resultTime, time.Second)
+ assert.WithinDurationf(t, expectedTime, resultTime, time.Second, "msg with args %d %s", 42, "42")
+ }
+}
+
func TestExpectedActualChecker_DetectConsts(t *testing.T) {
type OwnInt int
type OwnString string
@@ -884,7 +1020,12 @@ func TestExpectedActualChecker_CannotDetectVariablesLookedLikeConsts(t *testing.
}
func TestExpectedActualChecker_Ignored(t *testing.T) {
- var result, expected any
+ var (
+ result, expected any
+ expectedPtr *int
+ expectedTime time.Time
+ value int
+ )
assert.Equal(t, "value", "value")
assert.Equalf(t, "value", "value", "msg with args %d %s", 42, "42")
@@ -894,4 +1035,28 @@ func TestExpectedActualChecker_Ignored(t *testing.T) {
assert.Equalf(t, []int{1, 2}, map[int]int{1: 2}, "msg with args %d %s", 42, "42")
assert.NotEqual(t, result, result)
assert.NotEqualf(t, result, result, "msg with args %d %s", 42, "42")
+ assert.EqualExportedValues(t, user{Name: "Anton"}, struct{ Name string }{Name: "Anton"})
+ assert.EqualExportedValuesf(t, user{Name: "Anton"}, struct{ Name string }{Name: "Anton"}, "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, uint32(100), int32(100))
+ assert.EqualValuesf(t, uint32(100), int32(100), "msg with args %d %s", 42, "42")
+ assert.Exactly(t, int32(200), int64(200))
+ assert.Exactlyf(t, int32(200), int64(200), "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, int32(100), uint32(100))
+ assert.NotEqualValuesf(t, int32(100), uint32(100), "msg with args %d %s", 42, "42")
+ assert.InDelta(t, 42.42, expected, 1.0)
+ assert.InDeltaf(t, 42.42, expected, 1.0, "msg with args %d %s", 42, "42")
+ assert.InDeltaMapValues(t, map[string]float64{"score": 0.99}, nil, 2.0)
+ assert.InDeltaMapValuesf(t, map[string]float64{"score": 0.99}, nil, 2.0, "msg with args %d %s", 42, "42")
+ assert.InDeltaSlice(t, []float64{0.98, 0.99}, []float64{0.97, 0.99}, 1.0)
+ assert.InDeltaSlicef(t, []float64{0.98, 0.99}, []float64{0.97, 0.99}, 1.0, "msg with args %d %s", 42, "42")
+ assert.InEpsilon(t, 42.42, 0.0001, 0.0001)
+ assert.InEpsilonf(t, 42.42, 0.0001, 0.0001, "msg with args %d %s", 42, "42")
+ assert.IsType(t, (*user)(nil), user{})
+ assert.IsTypef(t, (*user)(nil), user{}, "msg with args %d %s", 42, "42")
+ assert.Same(t, &value, &value)
+ assert.Samef(t, &value, &value, "msg with args %d %s", 42, "42")
+ assert.NotSame(t, expectedPtr, &value)
+ assert.NotSamef(t, expectedPtr, &value, "msg with args %d %s", 42, "42")
+ assert.WithinDuration(t, expectedTime, time.Now(), time.Second)
+ assert.WithinDurationf(t, expectedTime, time.Now(), time.Second, "msg with args %d %s", 42, "42")
}
diff --git a/analyzer/testdata/src/checkers-default/expected-actual/expected_actual_test.go.golden b/analyzer/testdata/src/checkers-default/expected-actual/expected_actual_test.go.golden
index b2763cc..13e3d94 100644
--- a/analyzer/testdata/src/checkers-default/expected-actual/expected_actual_test.go.golden
+++ b/analyzer/testdata/src/checkers-default/expected-actual/expected_actual_test.go.golden
@@ -7,11 +7,17 @@ import (
"io"
"net/http"
"testing"
+ "time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
+type user struct {
+ Name string
+ id uint64
+}
+
type testCase struct{ expected string } //
func (c testCase) exp() string { return c.expected }
@@ -24,59 +30,67 @@ func TestExpectedActualChecker(t *testing.T) {
// Invalid.
{
- assert.Equal(t, expected, result) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, expected, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, tt.expected, result) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, tt.expected, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, tt.exp(), result) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, tt.exp(), result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, expectedVal(), result) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, expectedVal(), result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, []int{1, 2, 3}, result) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, []int{1, 2, 3}, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, [3]int{1, 2, 3}, result) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, [3]int{1, 2, 3}, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, map[string]int{"0": 1}, result) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, map[string]int{"0": 1}, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, 42, result) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, 42, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, 3.14, result) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, 3.14, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, 0.707i, result) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, 0.707i, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, "raw string", result) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, "raw string", result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, '\U00101234', result) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, '\U00101234', result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.Equal(t, true, result) // want "expected-actual: need to reverse actual and expected values"
- assert.Equalf(t, true, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
-
- assert.NotEqual(t, expected, result) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, expected, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, tt.expected, result) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, tt.expected, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, tt.exp(), result) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, tt.exp(), result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, expectedVal(), result) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, expectedVal(), result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, []int{1, 2, 3}, result) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, []int{1, 2, 3}, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, [3]int{1, 2, 3}, result) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, [3]int{1, 2, 3}, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, map[string]int{"0": 1}, result) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, map[string]int{"0": 1}, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, 42, result) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, 42, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, 3.14, result) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, 3.14, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, 0.707i, result) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, 0.707i, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, "raw string", result) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, "raw string", result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, '\U00101234', result) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, '\U00101234', result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqual(t, true, result) // want "expected-actual: need to reverse actual and expected values"
- assert.NotEqualf(t, true, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, expected, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, expected, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, tt.expected, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, tt.expected, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, tt.exp(), result) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, tt.exp(), result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, expectedVal(), result) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, expectedVal(), result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, []int{1, 2, 3}, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, []int{1, 2, 3}, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, [3]int{1, 2, 3}, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, [3]int{1, 2, 3}, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, map[string]int{"0": 1}, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, map[string]int{"0": 1}, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, user{Name: "Anton"}, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, user{Name: "Anton"}, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, struct{ Name string }{Name: "Anton"}, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, struct{ Name string }{Name: "Anton"}, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, 42, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, 42, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, 3.14, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, 3.14, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, 0.707i, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, 0.707i, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, "raw string", result) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, "raw string", result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, '\U00101234', result) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, '\U00101234', result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Equal(t, true, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.Equalf(t, true, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+
+ assert.NotEqual(t, expected, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, expected, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, tt.expected, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, tt.expected, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, tt.exp(), result) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, tt.exp(), result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, expectedVal(), result) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, expectedVal(), result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, []int{1, 2, 3}, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, []int{1, 2, 3}, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, [3]int{1, 2, 3}, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, [3]int{1, 2, 3}, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, map[string]int{"0": 1}, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, map[string]int{"0": 1}, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, user{Name: "Anton"}, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, user{Name: "Anton"}, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, struct{ Name string }{Name: "Anton"}, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, struct{ Name string }{Name: "Anton"}, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, 42, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, 42, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, 3.14, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, 3.14, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, 0.707i, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, 0.707i, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, "raw string", result) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, "raw string", result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, '\U00101234', result) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, '\U00101234', result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqual(t, true, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualf(t, true, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
}
// Valid.
@@ -95,6 +109,10 @@ func TestExpectedActualChecker(t *testing.T) {
assert.Equalf(t, [3]int{1, 2, 3}, result, "msg with args %d %s", 42, "42")
assert.Equal(t, map[string]int{"0": 1}, result)
assert.Equalf(t, map[string]int{"0": 1}, result, "msg with args %d %s", 42, "42")
+ assert.Equal(t, user{Name: "Anton"}, result)
+ assert.Equalf(t, user{Name: "Anton"}, result, "msg with args %d %s", 42, "42")
+ assert.Equal(t, struct{ Name string }{Name: "Anton"}, result)
+ assert.Equalf(t, struct{ Name string }{Name: "Anton"}, 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, 3.14, result)
@@ -122,6 +140,10 @@ func TestExpectedActualChecker(t *testing.T) {
assert.NotEqualf(t, [3]int{1, 2, 3}, result, "msg with args %d %s", 42, "42")
assert.NotEqual(t, map[string]int{"0": 1}, result)
assert.NotEqualf(t, map[string]int{"0": 1}, result, "msg with args %d %s", 42, "42")
+ assert.NotEqual(t, user{Name: "Anton"}, result)
+ assert.NotEqualf(t, user{Name: "Anton"}, result, "msg with args %d %s", 42, "42")
+ assert.NotEqual(t, struct{ Name string }{Name: "Anton"}, result)
+ assert.NotEqualf(t, struct{ Name string }{Name: "Anton"}, result, "msg with args %d %s", 42, "42")
assert.NotEqual(t, 42, result)
assert.NotEqualf(t, 42, result, "msg with args %d %s", 42, "42")
assert.NotEqual(t, 3.14, result)
@@ -137,6 +159,120 @@ func TestExpectedActualChecker(t *testing.T) {
}
}
+func TestExpectedActualChecker_Other(t *testing.T) {
+ var (
+ result, expected any
+ resultPtr, expectedPtr *int
+ resultObj, expectedObj user
+ resultTime, expectedTime time.Time
+ value int
+ )
+
+ // Invalid.
+ {
+ assert.EqualExportedValues(t, expectedObj, resultObj) // want "expected-actual: need to reverse actual and expected values"
+ assert.EqualExportedValuesf(t, expectedObj, resultObj, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.EqualExportedValues(t, user{Name: "Anton"}, resultObj) // want "expected-actual: need to reverse actual and expected values"
+ assert.EqualExportedValuesf(t, user{Name: "Anton"}, resultObj, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.EqualExportedValues(t, struct{ Name string }{Name: "Anton"}, resultObj) // want "expected-actual: need to reverse actual and expected values"
+ assert.EqualExportedValuesf(t, struct{ Name string }{Name: "Anton"}, resultObj, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.EqualValues(t, expected, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.EqualValuesf(t, expected, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.EqualValues(t, uint32(100), result) // want "expected-actual: need to reverse actual and expected values"
+ assert.EqualValuesf(t, uint32(100), result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualValues(t, expected, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualValuesf(t, expected, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualValues(t, uint32(100), result) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotEqualValuesf(t, uint32(100), result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Exactly(t, expected, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.Exactlyf(t, expected, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Exactly(t, int64(1), result) // want "expected-actual: need to reverse actual and expected values"
+ assert.Exactlyf(t, int64(1), result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.InDelta(t, expected, result, 1.0) // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaf(t, expected, result, 1.0, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.InDelta(t, 42.42, result, 1.0) // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaf(t, 42.42, result, 1.0, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaMapValues(t, expected, result, 2.0) // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaMapValuesf(t, expected, result, 2.0, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaMapValues(t, map[string]float64{"score": 0.99}, result, 2.0) // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaMapValuesf(t, map[string]float64{"score": 0.99}, result, 2.0, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaSlice(t, expected, result, 1.0) // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaSlicef(t, expected, result, 1.0, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaSlice(t, []float64{0.98, 0.99}, result, 1.0) // want "expected-actual: need to reverse actual and expected values"
+ assert.InDeltaSlicef(t, []float64{0.98, 0.99}, result, 1.0, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.InEpsilon(t, expected, result, 0.0001) // want "expected-actual: need to reverse actual and expected values"
+ assert.InEpsilonf(t, expected, result, 0.0001, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.InEpsilon(t, 42.42, result, 0.0001) // want "expected-actual: need to reverse actual and expected values"
+ assert.InEpsilonf(t, 42.42, result, 0.0001, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.IsType(t, expected, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.IsTypef(t, expected, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.IsType(t, user{}, result) // want "expected-actual: need to reverse actual and expected values"
+ assert.IsTypef(t, user{}, result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.IsType(t, (*user)(nil), result) // want "expected-actual: need to reverse actual and expected values"
+ assert.IsTypef(t, (*user)(nil), result, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Same(t, expectedPtr, resultPtr) // want "expected-actual: need to reverse actual and expected values"
+ assert.Samef(t, expectedPtr, resultPtr, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.Same(t, &value, resultPtr) // want "expected-actual: need to reverse actual and expected values"
+ assert.Samef(t, &value, resultPtr, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotSame(t, expectedPtr, resultPtr) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotSamef(t, expectedPtr, resultPtr, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.NotSame(t, &value, resultPtr) // want "expected-actual: need to reverse actual and expected values"
+ assert.NotSamef(t, &value, resultPtr, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ assert.WithinDuration(t, expectedTime, resultTime, time.Second) // want "expected-actual: need to reverse actual and expected values"
+ assert.WithinDurationf(t, expectedTime, resultTime, time.Second, "msg with args %d %s", 42, "42") // want "expected-actual: need to reverse actual and expected values"
+ }
+
+ // Valid.
+ {
+ assert.EqualExportedValues(t, expectedObj, resultObj)
+ assert.EqualExportedValuesf(t, expectedObj, resultObj, "msg with args %d %s", 42, "42")
+ assert.EqualExportedValues(t, user{Name: "Anton"}, resultObj)
+ assert.EqualExportedValuesf(t, user{Name: "Anton"}, resultObj, "msg with args %d %s", 42, "42")
+ assert.EqualExportedValues(t, struct{ Name string }{Name: "Anton"}, resultObj)
+ assert.EqualExportedValuesf(t, struct{ Name string }{Name: "Anton"}, resultObj, "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, expected, result)
+ assert.EqualValuesf(t, expected, result, "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, uint32(100), result)
+ assert.EqualValuesf(t, uint32(100), result, "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, expected, result)
+ assert.NotEqualValuesf(t, expected, result, "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, uint32(100), result)
+ assert.NotEqualValuesf(t, uint32(100), result, "msg with args %d %s", 42, "42")
+ assert.Exactly(t, expected, result)
+ assert.Exactlyf(t, expected, result, "msg with args %d %s", 42, "42")
+ assert.Exactly(t, int64(1), result)
+ assert.Exactlyf(t, int64(1), result, "msg with args %d %s", 42, "42")
+ assert.InDelta(t, expected, result, 1.0)
+ assert.InDeltaf(t, expected, result, 1.0, "msg with args %d %s", 42, "42")
+ assert.InDelta(t, 42.42, result, 1.0)
+ assert.InDeltaf(t, 42.42, result, 1.0, "msg with args %d %s", 42, "42")
+ assert.InDeltaMapValues(t, expected, result, 2.0)
+ assert.InDeltaMapValuesf(t, expected, result, 2.0, "msg with args %d %s", 42, "42")
+ assert.InDeltaMapValues(t, map[string]float64{"score": 0.99}, result, 2.0)
+ assert.InDeltaMapValuesf(t, map[string]float64{"score": 0.99}, result, 2.0, "msg with args %d %s", 42, "42")
+ assert.InEpsilon(t, expected, result, 0.0001)
+ assert.InEpsilonf(t, expected, result, 0.0001, "msg with args %d %s", 42, "42")
+ assert.InEpsilon(t, 42.42, result, 0.0001)
+ assert.InEpsilonf(t, 42.42, result, 0.0001, "msg with args %d %s", 42, "42")
+ assert.IsType(t, expected, result)
+ assert.IsTypef(t, expected, result, "msg with args %d %s", 42, "42")
+ assert.IsType(t, user{}, result)
+ assert.IsTypef(t, user{}, result, "msg with args %d %s", 42, "42")
+ assert.IsType(t, (*user)(nil), result)
+ assert.IsTypef(t, (*user)(nil), result, "msg with args %d %s", 42, "42")
+ assert.Same(t, expectedPtr, resultPtr)
+ assert.Samef(t, expectedPtr, resultPtr, "msg with args %d %s", 42, "42")
+ assert.Same(t, &value, resultPtr)
+ assert.Samef(t, &value, resultPtr, "msg with args %d %s", 42, "42")
+ assert.NotSame(t, expectedPtr, resultPtr)
+ assert.NotSamef(t, expectedPtr, resultPtr, "msg with args %d %s", 42, "42")
+ assert.NotSame(t, &value, resultPtr)
+ assert.NotSamef(t, &value, resultPtr, "msg with args %d %s", 42, "42")
+ assert.WithinDuration(t, expectedTime, resultTime, time.Second)
+ assert.WithinDurationf(t, expectedTime, resultTime, time.Second, "msg with args %d %s", 42, "42")
+ }
+}
+
func TestExpectedActualChecker_DetectConsts(t *testing.T) {
type OwnInt int
type OwnString string
@@ -884,7 +1020,12 @@ func TestExpectedActualChecker_CannotDetectVariablesLookedLikeConsts(t *testing.
}
func TestExpectedActualChecker_Ignored(t *testing.T) {
- var result, expected any
+ var (
+ result, expected any
+ expectedPtr *int
+ expectedTime time.Time
+ value int
+ )
assert.Equal(t, "value", "value")
assert.Equalf(t, "value", "value", "msg with args %d %s", 42, "42")
@@ -894,4 +1035,28 @@ func TestExpectedActualChecker_Ignored(t *testing.T) {
assert.Equalf(t, []int{1, 2}, map[int]int{1: 2}, "msg with args %d %s", 42, "42")
assert.NotEqual(t, result, result)
assert.NotEqualf(t, result, result, "msg with args %d %s", 42, "42")
+ assert.EqualExportedValues(t, user{Name: "Anton"}, struct{ Name string }{Name: "Anton"})
+ assert.EqualExportedValuesf(t, user{Name: "Anton"}, struct{ Name string }{Name: "Anton"}, "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, uint32(100), int32(100))
+ assert.EqualValuesf(t, uint32(100), int32(100), "msg with args %d %s", 42, "42")
+ assert.Exactly(t, int32(200), int64(200))
+ assert.Exactlyf(t, int32(200), int64(200), "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, int32(100), uint32(100))
+ assert.NotEqualValuesf(t, int32(100), uint32(100), "msg with args %d %s", 42, "42")
+ assert.InDelta(t, 42.42, expected, 1.0)
+ assert.InDeltaf(t, 42.42, expected, 1.0, "msg with args %d %s", 42, "42")
+ assert.InDeltaMapValues(t, map[string]float64{"score": 0.99}, nil, 2.0)
+ assert.InDeltaMapValuesf(t, map[string]float64{"score": 0.99}, nil, 2.0, "msg with args %d %s", 42, "42")
+ assert.InDeltaSlice(t, []float64{0.98, 0.99}, []float64{0.97, 0.99}, 1.0)
+ assert.InDeltaSlicef(t, []float64{0.98, 0.99}, []float64{0.97, 0.99}, 1.0, "msg with args %d %s", 42, "42")
+ assert.InEpsilon(t, 42.42, 0.0001, 0.0001)
+ assert.InEpsilonf(t, 42.42, 0.0001, 0.0001, "msg with args %d %s", 42, "42")
+ assert.IsType(t, (*user)(nil), user{})
+ assert.IsTypef(t, (*user)(nil), user{}, "msg with args %d %s", 42, "42")
+ assert.Same(t, &value, &value)
+ assert.Samef(t, &value, &value, "msg with args %d %s", 42, "42")
+ assert.NotSame(t, expectedPtr, &value)
+ assert.NotSamef(t, expectedPtr, &value, "msg with args %d %s", 42, "42")
+ assert.WithinDuration(t, expectedTime, time.Now(), time.Second)
+ assert.WithinDurationf(t, expectedTime, time.Now(), time.Second, "msg with args %d %s", 42, "42")
}
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 32442c5..7854515 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
@@ -14,12 +14,26 @@ func TestFloatCompareChecker(t *testing.T) {
// 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.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.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.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"
}
// Valid.
@@ -70,10 +84,24 @@ func TestFloatCompareChecker_NoFloatNoWorries(t *testing.T) {
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.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.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.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.False(t, result != 42)
+ assert.Falsef(t, result != 42, "msg with args %d %s", 42, "42")
}
func TestFloatCompareChecker_Float32Detection(t *testing.T) {
diff --git a/analyzer/testdata/src/checkers-default/len/len_test.go b/analyzer/testdata/src/checkers-default/len/len_test.go
index 141a715..8f1b3ec 100644
--- a/analyzer/testdata/src/checkers-default/len/len_test.go
+++ b/analyzer/testdata/src/checkers-default/len/len_test.go
@@ -14,16 +14,28 @@ func TestLenChecker(t *testing.T) {
// Invalid.
{
- assert.Equal(t, len(arr), 42) // want "len: use assert\\.Len"
- assert.Equalf(t, len(arr), 42, "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
- assert.Equal(t, 42, len(arr)) // want "len: use assert\\.Len"
- assert.Equalf(t, 42, len(arr), "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
- assert.Equal(t, value, len(arr)) // want "len: use assert\\.Len"
- assert.Equalf(t, value, len(arr), "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
- assert.True(t, len(arr) == 42) // want "len: use assert\\.Len"
- assert.Truef(t, len(arr) == 42, "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
- assert.True(t, 42 == len(arr)) // want "len: use assert\\.Len"
- assert.Truef(t, 42 == len(arr), "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
+ assert.Equal(t, len(arr), 42) // want "len: use assert\\.Len"
+ assert.Equalf(t, len(arr), 42, "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
+ assert.Equal(t, 42, len(arr)) // want "len: use assert\\.Len"
+ assert.Equalf(t, 42, len(arr), "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
+ assert.Equal(t, value, len(arr)) // want "len: use assert\\.Len"
+ assert.Equalf(t, value, len(arr), "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
+ assert.EqualValues(t, len(arr), 42) // want "len: use assert\\.Len"
+ assert.EqualValuesf(t, len(arr), 42, "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
+ assert.EqualValues(t, 42, len(arr)) // want "len: use assert\\.Len"
+ assert.EqualValuesf(t, 42, len(arr), "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
+ assert.EqualValues(t, value, len(arr)) // want "len: use assert\\.Len"
+ assert.EqualValuesf(t, value, len(arr), "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
+ assert.Exactly(t, len(arr), 42) // want "len: use assert\\.Len"
+ assert.Exactlyf(t, len(arr), 42, "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
+ assert.Exactly(t, 42, len(arr)) // want "len: use assert\\.Len"
+ assert.Exactlyf(t, 42, len(arr), "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
+ assert.Exactly(t, value, len(arr)) // want "len: use assert\\.Len"
+ assert.Exactlyf(t, value, len(arr), "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
+ assert.True(t, len(arr) == 42) // want "len: use assert\\.Len"
+ assert.Truef(t, len(arr) == 42, "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
+ assert.True(t, 42 == len(arr)) // want "len: use assert\\.Len"
+ assert.Truef(t, 42 == len(arr), "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
}
// Valid.
@@ -40,6 +52,14 @@ func TestLenChecker(t *testing.T) {
assert.Equalf(t, len(arr), len(arr), "msg with args %d %s", 42, "42")
assert.Equal(t, len(arr), value)
assert.Equalf(t, len(arr), value, "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, len(arr), len(arr))
+ assert.EqualValuesf(t, len(arr), len(arr), "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, len(arr), value)
+ assert.EqualValuesf(t, len(arr), value, "msg with args %d %s", 42, "42")
+ assert.Exactly(t, len(arr), len(arr))
+ assert.Exactlyf(t, len(arr), len(arr), "msg with args %d %s", 42, "42")
+ assert.Exactly(t, len(arr), value)
+ assert.Exactlyf(t, len(arr), value, "msg with args %d %s", 42, "42")
assert.True(t, len(arr) == len(arr))
assert.Truef(t, len(arr) == len(arr), "msg with args %d %s", 42, "42")
assert.True(t, len(arr) == value)
@@ -50,6 +70,10 @@ func TestLenChecker(t *testing.T) {
assert.NotEqualf(t, 42, len(arr), "msg with args %d %s", 42, "42")
assert.NotEqual(t, len(arr), 42)
assert.NotEqualf(t, len(arr), 42, "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, 42, len(arr))
+ assert.NotEqualValuesf(t, 42, len(arr), "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, len(arr), 42)
+ assert.NotEqualValuesf(t, len(arr), 42, "msg with args %d %s", 42, "42")
assert.Greater(t, len(arr), 42)
assert.Greaterf(t, len(arr), 42, "msg with args %d %s", 42, "42")
assert.Greater(t, 42, len(arr))
diff --git a/analyzer/testdata/src/checkers-default/len/len_test.go.golden b/analyzer/testdata/src/checkers-default/len/len_test.go.golden
index 740a34d..9a0928e 100644
--- a/analyzer/testdata/src/checkers-default/len/len_test.go.golden
+++ b/analyzer/testdata/src/checkers-default/len/len_test.go.golden
@@ -24,6 +24,18 @@ func TestLenChecker(t *testing.T) {
assert.Lenf(t, arr, 42, "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
assert.Len(t, arr, 42) // want "len: use assert\\.Len"
assert.Lenf(t, arr, 42, "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
+ assert.Len(t, arr, value) // want "len: use assert\\.Len"
+ assert.Lenf(t, arr, value, "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
+ assert.Len(t, arr, 42) // want "len: use assert\\.Len"
+ assert.Lenf(t, arr, 42, "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
+ assert.Len(t, arr, 42) // want "len: use assert\\.Len"
+ assert.Lenf(t, arr, 42, "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
+ assert.Len(t, arr, value) // want "len: use assert\\.Len"
+ assert.Lenf(t, arr, value, "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
+ assert.Len(t, arr, 42) // want "len: use assert\\.Len"
+ assert.Lenf(t, arr, 42, "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
+ assert.Len(t, arr, 42) // want "len: use assert\\.Len"
+ assert.Lenf(t, arr, 42, "msg with args %d %s", 42, "42") // want "len: use assert\\.Lenf"
}
// Valid.
@@ -40,6 +52,14 @@ func TestLenChecker(t *testing.T) {
assert.Equalf(t, len(arr), len(arr), "msg with args %d %s", 42, "42")
assert.Equal(t, len(arr), value)
assert.Equalf(t, len(arr), value, "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, len(arr), len(arr))
+ assert.EqualValuesf(t, len(arr), len(arr), "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, len(arr), value)
+ assert.EqualValuesf(t, len(arr), value, "msg with args %d %s", 42, "42")
+ assert.Exactly(t, len(arr), len(arr))
+ assert.Exactlyf(t, len(arr), len(arr), "msg with args %d %s", 42, "42")
+ assert.Exactly(t, len(arr), value)
+ assert.Exactlyf(t, len(arr), value, "msg with args %d %s", 42, "42")
assert.True(t, len(arr) == len(arr))
assert.Truef(t, len(arr) == len(arr), "msg with args %d %s", 42, "42")
assert.True(t, len(arr) == value)
@@ -50,6 +70,10 @@ func TestLenChecker(t *testing.T) {
assert.NotEqualf(t, 42, len(arr), "msg with args %d %s", 42, "42")
assert.NotEqual(t, len(arr), 42)
assert.NotEqualf(t, len(arr), 42, "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, 42, len(arr))
+ assert.NotEqualValuesf(t, 42, len(arr), "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, len(arr), 42)
+ assert.NotEqualValuesf(t, len(arr), 42, "msg with args %d %s", 42, "42")
assert.Greater(t, len(arr), 42)
assert.Greaterf(t, len(arr), 42, "msg with args %d %s", 42, "42")
assert.Greater(t, 42, len(arr))
diff --git a/analyzer/testdata/src/checkers-default/nil-compare/nil_compare_test.go b/analyzer/testdata/src/checkers-default/nil-compare/nil_compare_test.go
index 46a5b32..57cbf6c 100644
--- a/analyzer/testdata/src/checkers-default/nil-compare/nil_compare_test.go
+++ b/analyzer/testdata/src/checkers-default/nil-compare/nil_compare_test.go
@@ -6,7 +6,6 @@ import (
"testing"
"github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func TestNilCompareChecker(t *testing.T) {
@@ -15,93 +14,107 @@ func TestNilCompareChecker(t *testing.T) {
// Invalid.
{
- assert.Equal(t, value, nil) // want "nil-compare: use assert\\.Nil"
- assert.Equalf(t, value, nil, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
- require.Equal(t, value, nil) // want "nil-compare: use require\\.Nil"
- require.Equalf(t, value, nil, "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.Nilf"
- assert.Equal(t, nil, value) // want "nil-compare: use assert\\.Nil"
- assert.Equalf(t, nil, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
- require.Equal(t, nil, value) // want "nil-compare: use require\\.Nil"
- require.Equalf(t, nil, value, "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.Nilf"
- assert.Equal(t, Row["col"], nil) // want "nil-compare: use assert\\.Nil"
- assert.Equalf(t, Row["col"], nil, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
- require.Equal(t, Row["col"], nil) // want "nil-compare: use require\\.Nil"
- require.Equalf(t, Row["col"], nil, "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.Nilf"
- assert.Equal(t, nil, Row["col"]) // want "nil-compare: use assert\\.Nil"
- assert.Equalf(t, nil, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
- require.Equal(t, nil, Row["col"]) // want "nil-compare: use require\\.Nil"
- require.Equalf(t, nil, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.Nilf"
- assert.NotEqual(t, value, nil) // want "nil-compare: use assert\\.NotNil"
- assert.NotEqualf(t, value, nil, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
- require.NotEqual(t, value, nil) // want "nil-compare: use require\\.NotNil"
- require.NotEqualf(t, value, nil, "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.NotNilf"
- assert.NotEqual(t, nil, value) // want "nil-compare: use assert\\.NotNil"
- assert.NotEqualf(t, nil, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
- require.NotEqual(t, nil, value) // want "nil-compare: use require\\.NotNil"
- require.NotEqualf(t, nil, value, "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.NotNilf"
- assert.NotEqual(t, Row["col"], nil) // want "nil-compare: use assert\\.NotNil"
- assert.NotEqualf(t, Row["col"], nil, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
- require.NotEqual(t, Row["col"], nil) // want "nil-compare: use require\\.NotNil"
- require.NotEqualf(t, Row["col"], nil, "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.NotNilf"
- assert.NotEqual(t, nil, Row["col"]) // want "nil-compare: use assert\\.NotNil"
- assert.NotEqualf(t, nil, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
- require.NotEqual(t, nil, Row["col"]) // want "nil-compare: use require\\.NotNil"
- require.NotEqualf(t, nil, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.NotNilf"
+ assert.Equal(t, value, nil) // want "nil-compare: use assert\\.Nil"
+ assert.Equalf(t, value, nil, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.Equal(t, nil, value) // want "nil-compare: use assert\\.Nil"
+ assert.Equalf(t, nil, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.Equal(t, Row["col"], nil) // want "nil-compare: use assert\\.Nil"
+ assert.Equalf(t, Row["col"], nil, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.Equal(t, nil, Row["col"]) // want "nil-compare: use assert\\.Nil"
+ assert.Equalf(t, nil, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.EqualValues(t, value, nil) // want "nil-compare: use assert\\.Nil"
+ assert.EqualValuesf(t, value, nil, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.EqualValues(t, nil, value) // want "nil-compare: use assert\\.Nil"
+ assert.EqualValuesf(t, nil, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.EqualValues(t, Row["col"], nil) // want "nil-compare: use assert\\.Nil"
+ assert.EqualValuesf(t, Row["col"], nil, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.EqualValues(t, nil, Row["col"]) // want "nil-compare: use assert\\.Nil"
+ assert.EqualValuesf(t, nil, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.Exactly(t, value, nil) // want "nil-compare: use assert\\.Nil"
+ assert.Exactlyf(t, value, nil, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.Exactly(t, nil, value) // want "nil-compare: use assert\\.Nil"
+ assert.Exactlyf(t, nil, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.Exactly(t, Row["col"], nil) // want "nil-compare: use assert\\.Nil"
+ assert.Exactlyf(t, Row["col"], nil, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.Exactly(t, nil, Row["col"]) // want "nil-compare: use assert\\.Nil"
+ assert.Exactlyf(t, nil, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.NotEqual(t, value, nil) // want "nil-compare: use assert\\.NotNil"
+ assert.NotEqualf(t, value, nil, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
+ assert.NotEqual(t, nil, value) // want "nil-compare: use assert\\.NotNil"
+ assert.NotEqualf(t, nil, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
+ assert.NotEqual(t, Row["col"], nil) // want "nil-compare: use assert\\.NotNil"
+ assert.NotEqualf(t, Row["col"], nil, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
+ assert.NotEqual(t, nil, Row["col"]) // want "nil-compare: use assert\\.NotNil"
+ assert.NotEqualf(t, nil, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
+ assert.NotEqualValues(t, value, nil) // want "nil-compare: use assert\\.NotNil"
+ assert.NotEqualValuesf(t, value, nil, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
+ assert.NotEqualValues(t, nil, value) // want "nil-compare: use assert\\.NotNil"
+ assert.NotEqualValuesf(t, nil, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
+ assert.NotEqualValues(t, Row["col"], nil) // want "nil-compare: use assert\\.NotNil"
+ assert.NotEqualValuesf(t, Row["col"], nil, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
+ assert.NotEqualValues(t, nil, Row["col"]) // want "nil-compare: use assert\\.NotNil"
+ assert.NotEqualValuesf(t, nil, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
}
// Valid.
{
assert.Nil(t, value)
assert.Nilf(t, value, "msg with args %d %s", 42, "42")
- require.Nil(t, value)
- require.Nilf(t, value, "msg with args %d %s", 42, "42")
assert.NotNil(t, value)
assert.NotNilf(t, value, "msg with args %d %s", 42, "42")
- require.NotNil(t, value)
- require.NotNilf(t, value, "msg with args %d %s", 42, "42")
}
// Ignored.
{
assert.Equal(t, value, value)
assert.Equalf(t, value, value, "msg with args %d %s", 42, "42")
- require.Equal(t, value, value)
- require.Equalf(t, value, value, "msg with args %d %s", 42, "42")
assert.Equal(t, nil, nil)
assert.Equalf(t, nil, nil, "msg with args %d %s", 42, "42")
- require.Equal(t, nil, nil)
- require.Equalf(t, nil, nil, "msg with args %d %s", 42, "42")
assert.Equal(t, Row["col"], "foo")
assert.Equalf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
- require.Equal(t, Row["col"], "foo")
- require.Equalf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
assert.Equal(t, "foo", Row["col"])
assert.Equalf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
- require.Equal(t, "foo", Row["col"])
- require.Equalf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
assert.Equal(t, Row["col"], Row["col"])
assert.Equalf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
- require.Equal(t, Row["col"], Row["col"])
- require.Equalf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, value, value)
+ assert.EqualValuesf(t, value, value, "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, nil, nil)
+ assert.EqualValuesf(t, nil, nil, "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, Row["col"], "foo")
+ assert.EqualValuesf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, "foo", Row["col"])
+ assert.EqualValuesf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, Row["col"], Row["col"])
+ assert.EqualValuesf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
+ assert.Exactly(t, value, value)
+ assert.Exactlyf(t, value, value, "msg with args %d %s", 42, "42")
+ assert.Exactly(t, nil, nil)
+ assert.Exactlyf(t, nil, nil, "msg with args %d %s", 42, "42")
+ assert.Exactly(t, Row["col"], "foo")
+ assert.Exactlyf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
+ assert.Exactly(t, "foo", Row["col"])
+ assert.Exactlyf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
+ assert.Exactly(t, Row["col"], Row["col"])
+ assert.Exactlyf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
assert.NotEqual(t, value, value)
assert.NotEqualf(t, value, value, "msg with args %d %s", 42, "42")
- require.NotEqual(t, value, value)
- require.NotEqualf(t, value, value, "msg with args %d %s", 42, "42")
assert.NotEqual(t, nil, nil)
assert.NotEqualf(t, nil, nil, "msg with args %d %s", 42, "42")
- require.NotEqual(t, nil, nil)
- require.NotEqualf(t, nil, nil, "msg with args %d %s", 42, "42")
assert.NotEqual(t, Row["col"], "foo")
assert.NotEqualf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
- require.NotEqual(t, Row["col"], "foo")
- require.NotEqualf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
assert.NotEqual(t, "foo", Row["col"])
assert.NotEqualf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
- require.NotEqual(t, "foo", Row["col"])
- require.NotEqualf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
assert.NotEqual(t, Row["col"], Row["col"])
assert.NotEqualf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
- require.NotEqual(t, Row["col"], Row["col"])
- require.NotEqualf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, value, value)
+ assert.NotEqualValuesf(t, value, value, "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, nil, nil)
+ assert.NotEqualValuesf(t, nil, nil, "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, Row["col"], "foo")
+ assert.NotEqualValuesf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, "foo", Row["col"])
+ assert.NotEqualValuesf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, Row["col"], Row["col"])
+ assert.NotEqualValuesf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
}
}
diff --git a/analyzer/testdata/src/checkers-default/nil-compare/nil_compare_test.go.golden b/analyzer/testdata/src/checkers-default/nil-compare/nil_compare_test.go.golden
index 6714fa9..77ebf0e 100644
--- a/analyzer/testdata/src/checkers-default/nil-compare/nil_compare_test.go.golden
+++ b/analyzer/testdata/src/checkers-default/nil-compare/nil_compare_test.go.golden
@@ -6,7 +6,6 @@ import (
"testing"
"github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func TestNilCompareChecker(t *testing.T) {
@@ -15,93 +14,107 @@ func TestNilCompareChecker(t *testing.T) {
// Invalid.
{
- assert.Nil(t, value) // want "nil-compare: use assert\\.Nil"
- assert.Nilf(t, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
- require.Nil(t, value) // want "nil-compare: use require\\.Nil"
- require.Nilf(t, value, "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.Nilf"
- assert.Nil(t, value) // want "nil-compare: use assert\\.Nil"
- assert.Nilf(t, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
- require.Nil(t, value) // want "nil-compare: use require\\.Nil"
- require.Nilf(t, value, "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.Nilf"
- assert.Nil(t, Row["col"]) // want "nil-compare: use assert\\.Nil"
- assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
- require.Nil(t, Row["col"]) // want "nil-compare: use require\\.Nil"
- require.Nilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.Nilf"
- assert.Nil(t, Row["col"]) // want "nil-compare: use assert\\.Nil"
- assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
- require.Nil(t, Row["col"]) // want "nil-compare: use require\\.Nil"
- require.Nilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.Nilf"
- assert.NotNil(t, value) // want "nil-compare: use assert\\.NotNil"
- assert.NotNilf(t, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
- require.NotNil(t, value) // want "nil-compare: use require\\.NotNil"
- require.NotNilf(t, value, "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.NotNilf"
- assert.NotNil(t, value) // want "nil-compare: use assert\\.NotNil"
- assert.NotNilf(t, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
- require.NotNil(t, value) // want "nil-compare: use require\\.NotNil"
- require.NotNilf(t, value, "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.NotNilf"
- assert.NotNil(t, Row["col"]) // want "nil-compare: use assert\\.NotNil"
- assert.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
- require.NotNil(t, Row["col"]) // want "nil-compare: use require\\.NotNil"
- require.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.NotNilf"
- assert.NotNil(t, Row["col"]) // want "nil-compare: use assert\\.NotNil"
- assert.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
- require.NotNil(t, Row["col"]) // want "nil-compare: use require\\.NotNil"
- require.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.NotNilf"
+ assert.Nil(t, value) // want "nil-compare: use assert\\.Nil"
+ assert.Nilf(t, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.Nil(t, value) // want "nil-compare: use assert\\.Nil"
+ assert.Nilf(t, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.Nil(t, Row["col"]) // want "nil-compare: use assert\\.Nil"
+ assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.Nil(t, Row["col"]) // want "nil-compare: use assert\\.Nil"
+ assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.Nil(t, value) // want "nil-compare: use assert\\.Nil"
+ assert.Nilf(t, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.Nil(t, value) // want "nil-compare: use assert\\.Nil"
+ assert.Nilf(t, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.Nil(t, Row["col"]) // want "nil-compare: use assert\\.Nil"
+ assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.Nil(t, Row["col"]) // want "nil-compare: use assert\\.Nil"
+ assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.Nil(t, value) // want "nil-compare: use assert\\.Nil"
+ assert.Nilf(t, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.Nil(t, value) // want "nil-compare: use assert\\.Nil"
+ assert.Nilf(t, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.Nil(t, Row["col"]) // want "nil-compare: use assert\\.Nil"
+ assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.Nil(t, Row["col"]) // want "nil-compare: use assert\\.Nil"
+ assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.Nilf"
+ assert.NotNil(t, value) // want "nil-compare: use assert\\.NotNil"
+ assert.NotNilf(t, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
+ assert.NotNil(t, value) // want "nil-compare: use assert\\.NotNil"
+ assert.NotNilf(t, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
+ assert.NotNil(t, Row["col"]) // want "nil-compare: use assert\\.NotNil"
+ assert.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
+ assert.NotNil(t, Row["col"]) // want "nil-compare: use assert\\.NotNil"
+ assert.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
+ assert.NotNil(t, value) // want "nil-compare: use assert\\.NotNil"
+ assert.NotNilf(t, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
+ assert.NotNil(t, value) // want "nil-compare: use assert\\.NotNil"
+ assert.NotNilf(t, value, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
+ assert.NotNil(t, Row["col"]) // want "nil-compare: use assert\\.NotNil"
+ assert.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
+ assert.NotNil(t, Row["col"]) // want "nil-compare: use assert\\.NotNil"
+ assert.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
}
// Valid.
{
assert.Nil(t, value)
assert.Nilf(t, value, "msg with args %d %s", 42, "42")
- require.Nil(t, value)
- require.Nilf(t, value, "msg with args %d %s", 42, "42")
assert.NotNil(t, value)
assert.NotNilf(t, value, "msg with args %d %s", 42, "42")
- require.NotNil(t, value)
- require.NotNilf(t, value, "msg with args %d %s", 42, "42")
}
// Ignored.
{
assert.Equal(t, value, value)
assert.Equalf(t, value, value, "msg with args %d %s", 42, "42")
- require.Equal(t, value, value)
- require.Equalf(t, value, value, "msg with args %d %s", 42, "42")
assert.Equal(t, nil, nil)
assert.Equalf(t, nil, nil, "msg with args %d %s", 42, "42")
- require.Equal(t, nil, nil)
- require.Equalf(t, nil, nil, "msg with args %d %s", 42, "42")
assert.Equal(t, Row["col"], "foo")
assert.Equalf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
- require.Equal(t, Row["col"], "foo")
- require.Equalf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
assert.Equal(t, "foo", Row["col"])
assert.Equalf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
- require.Equal(t, "foo", Row["col"])
- require.Equalf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
assert.Equal(t, Row["col"], Row["col"])
assert.Equalf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
- require.Equal(t, Row["col"], Row["col"])
- require.Equalf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, value, value)
+ assert.EqualValuesf(t, value, value, "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, nil, nil)
+ assert.EqualValuesf(t, nil, nil, "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, Row["col"], "foo")
+ assert.EqualValuesf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, "foo", Row["col"])
+ assert.EqualValuesf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
+ assert.EqualValues(t, Row["col"], Row["col"])
+ assert.EqualValuesf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
+ assert.Exactly(t, value, value)
+ assert.Exactlyf(t, value, value, "msg with args %d %s", 42, "42")
+ assert.Exactly(t, nil, nil)
+ assert.Exactlyf(t, nil, nil, "msg with args %d %s", 42, "42")
+ assert.Exactly(t, Row["col"], "foo")
+ assert.Exactlyf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
+ assert.Exactly(t, "foo", Row["col"])
+ assert.Exactlyf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
+ assert.Exactly(t, Row["col"], Row["col"])
+ assert.Exactlyf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
assert.NotEqual(t, value, value)
assert.NotEqualf(t, value, value, "msg with args %d %s", 42, "42")
- require.NotEqual(t, value, value)
- require.NotEqualf(t, value, value, "msg with args %d %s", 42, "42")
assert.NotEqual(t, nil, nil)
assert.NotEqualf(t, nil, nil, "msg with args %d %s", 42, "42")
- require.NotEqual(t, nil, nil)
- require.NotEqualf(t, nil, nil, "msg with args %d %s", 42, "42")
assert.NotEqual(t, Row["col"], "foo")
assert.NotEqualf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
- require.NotEqual(t, Row["col"], "foo")
- require.NotEqualf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
assert.NotEqual(t, "foo", Row["col"])
assert.NotEqualf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
- require.NotEqual(t, "foo", Row["col"])
- require.NotEqualf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
assert.NotEqual(t, Row["col"], Row["col"])
assert.NotEqualf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
- require.NotEqual(t, Row["col"], Row["col"])
- require.NotEqualf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, value, value)
+ assert.NotEqualValuesf(t, value, value, "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, nil, nil)
+ assert.NotEqualValuesf(t, nil, nil, "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, Row["col"], "foo")
+ assert.NotEqualValuesf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, "foo", Row["col"])
+ assert.NotEqualValuesf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
+ assert.NotEqualValues(t, Row["col"], Row["col"])
+ assert.NotEqualValuesf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
}
}
diff --git a/internal/checkers/bool_compare.go b/internal/checkers/bool_compare.go
index 72e2664..5bf9e8e 100644
--- a/internal/checkers/bool_compare.go
+++ b/internal/checkers/bool_compare.go
@@ -60,8 +60,8 @@ func (checker BoolCompare) Check(pass *analysis.Pass, call *CallMeta) *analysis.
)
}
- switch call.Fn.Name {
- case "Equal", "Equalf":
+ switch call.Fn.NameFTrimmed {
+ case "Equal", "EqualValues", "Exactly":
if len(call.Args) < 2 {
return nil
}
@@ -84,7 +84,7 @@ func (checker BoolCompare) Check(pass *analysis.Pass, call *CallMeta) *analysis.
return newUseFalseDiagnostic(survivingArg, arg1.Pos(), arg2.End())
}
- case "NotEqual", "NotEqualf":
+ case "NotEqual", "NotEqualValues":
if len(call.Args) < 2 {
return nil
}
@@ -107,7 +107,7 @@ func (checker BoolCompare) Check(pass *analysis.Pass, call *CallMeta) *analysis.
return newUseTrueDiagnostic(survivingArg, arg1.Pos(), arg2.End())
}
- case "True", "Truef":
+ case "True":
if len(call.Args) < 1 {
return nil
}
@@ -134,7 +134,7 @@ func (checker BoolCompare) Check(pass *analysis.Pass, call *CallMeta) *analysis.
}
}
- case "False", "Falsef":
+ case "False":
if len(call.Args) < 1 {
return nil
}
diff --git a/internal/checkers/call_meta.go b/internal/checkers/call_meta.go
index a6b8f1c..44eed49 100644
--- a/internal/checkers/call_meta.go
+++ b/internal/checkers/call_meta.go
@@ -45,6 +45,8 @@ type FnMeta struct {
analysis.Range
// Name is a function name.
Name string
+ // NameFTrimmed is a function name without "f" suffix.
+ NameFTrimmed string
// IsFmt is true if function is formatted, e.g. "Equalf".
IsFmt bool
}
@@ -97,9 +99,10 @@ func NewCallMeta(pass *analysis.Pass, ce *ast.CallExpr) *CallMeta {
Selector: se,
SelectorXStr: analysisutil.NodeString(pass.Fset, se.X),
Fn: FnMeta{
- Range: se.Sel,
- Name: fnName,
- IsFmt: strings.HasSuffix(fnName, "f"),
+ Range: se.Sel,
+ Name: fnName,
+ NameFTrimmed: strings.TrimSuffix(fnName, "f"),
+ IsFmt: strings.HasSuffix(fnName, "f"),
},
Args: trimTArg(pass, ce.Args),
ArgsRaw: ce.Args,
diff --git a/internal/checkers/compares.go b/internal/checkers/compares.go
index afc829f..21b3ea1 100644
--- a/internal/checkers/compares.go
+++ b/internal/checkers/compares.go
@@ -46,10 +46,10 @@ func (checker Compares) Check(pass *analysis.Pass, call *CallMeta) *analysis.Dia
var tokenToProposedFn map[token.Token]string
- switch call.Fn.Name {
- case "True", "Truef":
+ switch call.Fn.NameFTrimmed {
+ case "True":
tokenToProposedFn = tokenToProposedFnInsteadOfTrue
- case "False", "Falsef":
+ case "False":
tokenToProposedFn = tokenToProposedFnInsteadOfFalse
default:
return nil
diff --git a/internal/checkers/empty.go b/internal/checkers/empty.go
index 6f67572..6aadaf5 100644
--- a/internal/checkers/empty.go
+++ b/internal/checkers/empty.go
@@ -53,13 +53,13 @@ func (checker Empty) checkEmpty(pass *analysis.Pass, call *CallMeta) *analysis.D
}
a, b := call.Args[0], call.Args[1]
- switch call.Fn.Name {
- case "Len", "Lenf":
+ switch call.Fn.NameFTrimmed {
+ case "Len":
if isZero(b) {
return newUseEmptyDiagnostic(a.Pos(), b.End(), a)
}
- case "Equal", "Equalf":
+ case "Equal", "EqualValues", "Exactly":
arg1, ok1 := isLenCallAndZero(pass, a, b)
arg2, ok2 := isLenCallAndZero(pass, b, a)
@@ -67,22 +67,22 @@ func (checker Empty) checkEmpty(pass *analysis.Pass, call *CallMeta) *analysis.D
return newUseEmptyDiagnostic(a.Pos(), b.End(), lenArg)
}
- case "LessOrEqual", "LessOrEqualf":
+ case "LessOrEqual":
if lenArg, ok := isBuiltinLenCall(pass, a); ok && isZero(b) {
return newUseEmptyDiagnostic(a.Pos(), b.End(), lenArg)
}
- case "GreaterOrEqual", "GreaterOrEqualf":
+ case "GreaterOrEqual":
if lenArg, ok := isBuiltinLenCall(pass, b); ok && isZero(a) {
return newUseEmptyDiagnostic(a.Pos(), b.End(), lenArg)
}
- case "Less", "Lessf":
+ case "Less":
if lenArg, ok := isBuiltinLenCall(pass, a); ok && isOne(b) {
return newUseEmptyDiagnostic(a.Pos(), b.End(), lenArg)
}
- case "Greater", "Greaterf":
+ case "Greater":
if lenArg, ok := isBuiltinLenCall(pass, b); ok && isOne(a) {
return newUseEmptyDiagnostic(a.Pos(), b.End(), lenArg)
}
@@ -107,8 +107,8 @@ func (checker Empty) checkNotEmpty(pass *analysis.Pass, call *CallMeta) *analysi
}
a, b := call.Args[0], call.Args[1]
- switch call.Fn.Name {
- case "NotEqual", "NotEqualf":
+ switch call.Fn.NameFTrimmed {
+ case "NotEqual", "NotEqualValues":
arg1, ok1 := isLenCallAndZero(pass, a, b)
arg2, ok2 := isLenCallAndZero(pass, b, a)
@@ -116,12 +116,12 @@ func (checker Empty) checkNotEmpty(pass *analysis.Pass, call *CallMeta) *analysi
return newUseNotEmptyDiagnostic(a.Pos(), b.End(), lenArg)
}
- case "Greater", "Greaterf":
+ case "Greater":
if lenArg, ok := isBuiltinLenCall(pass, a); ok && isZero(b) {
return newUseNotEmptyDiagnostic(a.Pos(), b.End(), lenArg)
}
- case "Less", "Lessf":
+ case "Less":
if lenArg, ok := isBuiltinLenCall(pass, b); ok && isZero(a) {
return newUseNotEmptyDiagnostic(a.Pos(), b.End(), lenArg)
}
diff --git a/internal/checkers/error_is_as.go b/internal/checkers/error_is_as.go
index e844408..0363873 100644
--- a/internal/checkers/error_is_as.go
+++ b/internal/checkers/error_is_as.go
@@ -32,22 +32,22 @@ func NewErrorIsAs() ErrorIsAs { return ErrorIsAs{} }
func (ErrorIsAs) Name() string { return "error-is-as" }
func (checker ErrorIsAs) Check(pass *analysis.Pass, call *CallMeta) *analysis.Diagnostic {
- switch call.Fn.Name {
- case "Error", "Errorf":
+ switch call.Fn.NameFTrimmed {
+ case "Error":
if len(call.Args) >= 2 && isError(pass, call.Args[1]) {
const proposed = "ErrorIs"
msg := fmt.Sprintf("invalid usage of %[1]s.Error, use %[1]s.%[2]s instead", call.SelectorXStr, proposed)
return newDiagnostic(checker.Name(), call, msg, newSuggestedFuncReplacement(call, proposed))
}
- case "NoError", "NoErrorf":
+ case "NoError":
if len(call.Args) >= 2 && isError(pass, call.Args[1]) {
const proposed = "NotErrorIs"
msg := fmt.Sprintf("invalid usage of %[1]s.NoError, use %[1]s.%[2]s instead", call.SelectorXStr, proposed)
return newDiagnostic(checker.Name(), call, msg, newSuggestedFuncReplacement(call, proposed))
}
- case "True", "Truef":
+ case "True":
if len(call.Args) < 1 {
return nil
}
@@ -77,7 +77,7 @@ func (checker ErrorIsAs) Check(pass *analysis.Pass, call *CallMeta) *analysis.Di
)
}
- case "False", "Falsef":
+ case "False":
if len(call.Args) < 1 {
return nil
}
@@ -101,7 +101,7 @@ func (checker ErrorIsAs) Check(pass *analysis.Pass, call *CallMeta) *analysis.Di
)
}
- case "ErrorAs", "ErrorAsf":
+ case "ErrorAs":
if len(call.Args) < 2 {
return nil
}
diff --git a/internal/checkers/error_nil.go b/internal/checkers/error_nil.go
index 8546e2f..8e1f53c 100644
--- a/internal/checkers/error_nil.go
+++ b/internal/checkers/error_nil.go
@@ -36,18 +36,18 @@ func (checker ErrorNil) Check(pass *analysis.Pass, call *CallMeta) *analysis.Dia
)
proposedFn, survivingArg, replacementEndPos := func() (string, ast.Expr, token.Pos) {
- switch call.Fn.Name {
- case "NotNil", "NotNilf":
+ switch call.Fn.NameFTrimmed {
+ case "NotNil":
if len(call.Args) >= 1 && isError(pass, call.Args[0]) {
return errorFn, call.Args[0], call.Args[0].End()
}
- case "Nil", "Nilf":
+ case "Nil":
if len(call.Args) >= 1 && isError(pass, call.Args[0]) {
return noErrorFn, call.Args[0], call.Args[0].End()
}
- case "Equal", "Equalf", "ErrorIs", "ErrorIsf":
+ case "Equal", "EqualValues", "Exactly", "ErrorIs":
if len(call.Args) < 2 {
return "", nil, token.NoPos
}
@@ -60,7 +60,7 @@ func (checker ErrorNil) Check(pass *analysis.Pass, call *CallMeta) *analysis.Dia
return noErrorFn, b, b.End()
}
- case "NotEqual", "NotEqualf", "NotErrorIs", "NotErrorIsf":
+ case "NotEqual", "NotEqualValues", "NotErrorIs":
if len(call.Args) < 2 {
return "", nil, token.NoPos
}
diff --git a/internal/checkers/expected_actual.go b/internal/checkers/expected_actual.go
index ff82439..852628e 100644
--- a/internal/checkers/expected_actual.go
+++ b/internal/checkers/expected_actual.go
@@ -2,6 +2,7 @@ package checkers
import (
"go/ast"
+ "go/token"
"go/types"
"regexp"
@@ -38,9 +39,23 @@ func (checker *ExpectedActual) SetExpVarPattern(p *regexp.Regexp) *ExpectedActua
}
func (checker ExpectedActual) Check(pass *analysis.Pass, call *CallMeta) *analysis.Diagnostic {
- switch call.Fn.Name {
- case "Equal", "Equalf", "NotEqual", "NotEqualf",
- "JSONEq", "JSONEqf", "YAMLEq", "YAMLEqf":
+ switch call.Fn.NameFTrimmed {
+ case "Equal",
+ "EqualExportedValues",
+ "EqualValues",
+ "Exactly",
+ "JSONEq",
+ "InDelta",
+ "InDeltaMapValues",
+ "InDeltaSlice",
+ "InEpsilon",
+ "IsType",
+ "NotEqual",
+ "NotEqualValues",
+ "NotSame",
+ "Same",
+ "WithinDuration",
+ "YAMLEq":
default:
return nil
}
@@ -77,17 +92,24 @@ func (checker ExpectedActual) isExpectedValueCandidate(pass *analysis.Pass, expr
return true
case *ast.CallExpr:
- return isCastedBasicLitOrExpectedValue(v, checker.expVarPattern) ||
+ return isParenExpr(v) ||
+ isCastedBasicLitOrExpectedValue(v, checker.expVarPattern) ||
isExpectedValueFactory(v, checker.expVarPattern)
}
return isBasicLit(expr) ||
isUntypedConst(pass, expr) ||
isTypedConst(pass, expr) ||
+ isAddressOperation(expr) ||
isIdentNamedAsExpected(checker.expVarPattern, expr) ||
isStructFieldNamedAsExpected(checker.expVarPattern, expr)
}
+func isParenExpr(ce *ast.CallExpr) bool {
+ _, ok := ce.Fun.(*ast.ParenExpr)
+ return ok
+}
+
func isCastedBasicLitOrExpectedValue(ce *ast.CallExpr, pattern *regexp.Regexp) bool {
if len(ce.Args) != 1 {
return false
@@ -145,6 +167,11 @@ func isTypedConst(p *analysis.Pass, e ast.Expr) bool {
return ok && tt.IsValue() && tt.Value != nil
}
+func isAddressOperation(e ast.Expr) bool {
+ ue, ok := e.(*ast.UnaryExpr)
+ return ok && ue.Op == token.AND
+}
+
func isIdentNamedAsExpected(pattern *regexp.Regexp, e ast.Expr) bool {
id, ok := e.(*ast.Ident)
return ok && pattern.MatchString(id.Name)
diff --git a/internal/checkers/float_compare.go b/internal/checkers/float_compare.go
index 7d5b358..af38220 100644
--- a/internal/checkers/float_compare.go
+++ b/internal/checkers/float_compare.go
@@ -25,14 +25,14 @@ func (FloatCompare) Name() string { return "float-compare" }
func (checker FloatCompare) Check(pass *analysis.Pass, call *CallMeta) *analysis.Diagnostic {
invalid := func() bool {
- switch call.Fn.Name {
- case "Equal", "Equalf":
+ switch call.Fn.NameFTrimmed {
+ case "Equal", "EqualValues", "Exactly":
return len(call.Args) > 1 && isFloat(pass, call.Args[0]) && isFloat(pass, call.Args[1])
- case "True", "Truef":
+ case "True":
return len(call.Args) > 0 && isFloatCompare(pass, call.Args[0], token.EQL)
- case "False", "Falsef":
+ case "False":
return len(call.Args) > 0 && isFloatCompare(pass, call.Args[0], token.NEQ)
}
return false
diff --git a/internal/checkers/go_require.go b/internal/checkers/go_require.go
index f374398..4c0c9d1 100644
--- a/internal/checkers/go_require.go
+++ b/internal/checkers/go_require.go
@@ -213,7 +213,7 @@ func (checker GoRequire) checkCall(call *CallMeta) goRequireVerdict {
if !call.IsAssert {
return goRequireVerdictRequire
}
- if fnName := call.Fn.Name; (fnName == "FailNow") || (fnName == "FailNowf") {
+ if call.Fn.NameFTrimmed == "FailNow" {
return goRequireVerdictAssertFailNow
}
return goRequireVerdictNoExit
diff --git a/internal/checkers/len.go b/internal/checkers/len.go
index aaf7623..ffbc54e 100644
--- a/internal/checkers/len.go
+++ b/internal/checkers/len.go
@@ -24,8 +24,8 @@ func (Len) Name() string { return "len" }
func (checker Len) Check(pass *analysis.Pass, call *CallMeta) *analysis.Diagnostic {
const proposedFn = "Len"
- switch call.Fn.Name {
- case "Equal", "Equalf":
+ switch call.Fn.NameFTrimmed {
+ case "Equal", "EqualValues", "Exactly":
if len(call.Args) < 2 {
return nil
}
@@ -45,7 +45,7 @@ func (checker Len) Check(pass *analysis.Pass, call *CallMeta) *analysis.Diagnost
)
}
- case "True", "Truef":
+ case "True":
if len(call.Args) < 1 {
return nil
}
diff --git a/internal/checkers/nil_compare.go b/internal/checkers/nil_compare.go
index 1c929de..fc670e2 100644
--- a/internal/checkers/nil_compare.go
+++ b/internal/checkers/nil_compare.go
@@ -35,10 +35,10 @@ func (checker NilCompare) Check(pass *analysis.Pass, call *CallMeta) *analysis.D
var proposedFn string
- switch call.Fn.Name {
- case "Equal", "Equalf":
+ switch call.Fn.NameFTrimmed {
+ case "Equal", "EqualValues", "Exactly":
proposedFn = "Nil"
- case "NotEqual", "NotEqualf":
+ case "NotEqual", "NotEqualValues":
proposedFn = "NotNil"
default:
return nil
diff --git a/internal/checkers/require_error.go b/internal/checkers/require_error.go
index 0f80438..2bda58f 100644
--- a/internal/checkers/require_error.go
+++ b/internal/checkers/require_error.go
@@ -115,11 +115,10 @@ func (checker RequireError) Check(pass *analysis.Pass, inspector *inspector.Insp
if !c.testifyCall.IsAssert {
continue
}
- switch c.testifyCall.Fn.Name {
+ switch c.testifyCall.Fn.NameFTrimmed {
default:
continue
- case "Error", "ErrorIs", "ErrorAs", "EqualError", "ErrorContains", "NoError", "NotErrorIs",
- "Errorf", "ErrorIsf", "ErrorAsf", "EqualErrorf", "ErrorContainsf", "NoErrorf", "NotErrorIsf":
+ case "Error", "ErrorIs", "ErrorAs", "EqualError", "ErrorContains", "NoError", "NotErrorIs":
}
if needToSkipBasedOnContext(c, i, calls, callsByBlock) {
diff --git a/internal/testgen/gen_bool_compare.go b/internal/testgen/gen_bool_compare.go
index f754dc1..ce5c2bb 100644
--- a/internal/testgen/gen_bool_compare.go
+++ b/internal/testgen/gen_bool_compare.go
@@ -38,8 +38,14 @@ func (g BoolCompareTestsGenerator) TemplateData() any {
InvalidAssertions: []Assertion{
{Fn: "Equal", Argsf: "predicate, true", ReportMsgf: reportUse, ProposedFn: "True", ProposedArgsf: "predicate"},
{Fn: "Equal", Argsf: "true, predicate", ReportMsgf: reportUse, ProposedFn: "True", ProposedArgsf: "predicate"},
+ {Fn: "EqualValues", Argsf: "predicate, true", ReportMsgf: reportUse, ProposedFn: "True", ProposedArgsf: "predicate"},
+ {Fn: "EqualValues", Argsf: "true, predicate", ReportMsgf: reportUse, ProposedFn: "True", ProposedArgsf: "predicate"},
+ {Fn: "Exactly", Argsf: "predicate, true", ReportMsgf: reportUse, ProposedFn: "True", ProposedArgsf: "predicate"},
+ {Fn: "Exactly", Argsf: "true, predicate", ReportMsgf: reportUse, ProposedFn: "True", ProposedArgsf: "predicate"},
{Fn: "NotEqual", Argsf: "predicate, false", ReportMsgf: reportUse, ProposedFn: "True", ProposedArgsf: "predicate"},
{Fn: "NotEqual", Argsf: "false, predicate", ReportMsgf: reportUse, ProposedFn: "True", ProposedArgsf: "predicate"},
+ {Fn: "NotEqualValues", Argsf: "predicate, false", ReportMsgf: reportUse, ProposedFn: "True", ProposedArgsf: "predicate"},
+ {Fn: "NotEqualValues", Argsf: "false, predicate", ReportMsgf: reportUse, ProposedFn: "True", ProposedArgsf: "predicate"},
{Fn: "True", Argsf: "predicate == true", ReportMsgf: reportSimplify, ProposedArgsf: "predicate"},
{Fn: "True", Argsf: "true == predicate", ReportMsgf: reportSimplify, ProposedArgsf: "predicate"},
{Fn: "False", Argsf: "predicate == false", ReportMsgf: reportUse, ProposedFn: "True", ProposedArgsf: "predicate"},
@@ -60,8 +66,14 @@ func (g BoolCompareTestsGenerator) TemplateData() any {
InvalidAssertions: []Assertion{
{Fn: "Equal", Argsf: "predicate, false", ReportMsgf: reportUse, ProposedFn: "False", ProposedArgsf: "predicate"},
{Fn: "Equal", Argsf: "false, predicate", ReportMsgf: reportUse, ProposedFn: "False", ProposedArgsf: "predicate"},
+ {Fn: "EqualValues", Argsf: "predicate, false", ReportMsgf: reportUse, ProposedFn: "False", ProposedArgsf: "predicate"},
+ {Fn: "EqualValues", Argsf: "false, predicate", ReportMsgf: reportUse, ProposedFn: "False", ProposedArgsf: "predicate"},
+ {Fn: "Exactly", Argsf: "predicate, false", ReportMsgf: reportUse, ProposedFn: "False", ProposedArgsf: "predicate"},
+ {Fn: "Exactly", Argsf: "false, predicate", ReportMsgf: reportUse, ProposedFn: "False", ProposedArgsf: "predicate"},
{Fn: "NotEqual", Argsf: "predicate, true", ReportMsgf: reportUse, ProposedFn: "False", ProposedArgsf: "predicate"},
{Fn: "NotEqual", Argsf: "true, predicate", ReportMsgf: reportUse, ProposedFn: "False", ProposedArgsf: "predicate"},
+ {Fn: "NotEqualValues", Argsf: "predicate, true", ReportMsgf: reportUse, ProposedFn: "False", ProposedArgsf: "predicate"},
+ {Fn: "NotEqualValues", Argsf: "true, predicate", ReportMsgf: reportUse, ProposedFn: "False", ProposedArgsf: "predicate"},
{Fn: "False", Argsf: "predicate == true", ReportMsgf: reportSimplify, ProposedArgsf: "predicate"},
{Fn: "False", Argsf: "true == predicate", ReportMsgf: reportSimplify, ProposedArgsf: "predicate"},
{Fn: "True", Argsf: "predicate == false", ReportMsgf: reportUse, ProposedFn: "False", ProposedArgsf: "predicate"},
diff --git a/internal/testgen/gen_empty.go b/internal/testgen/gen_empty.go
index 233b741..34af6a5 100644
--- a/internal/testgen/gen_empty.go
+++ b/internal/testgen/gen_empty.go
@@ -51,6 +51,10 @@ func (g EmptyTestsGenerator) TemplateData() any {
{Fn: "Len", Argsf: "elems, 0", ReportMsgf: report, ProposedFn: "Empty", ProposedArgsf: "elems"},
{Fn: "Equal", Argsf: "len(elems), 0", ReportMsgf: report, ProposedFn: "Empty", ProposedArgsf: "elems"},
{Fn: "Equal", Argsf: "0, len(elems)", ReportMsgf: report, ProposedFn: "Empty", ProposedArgsf: "elems"},
+ {Fn: "EqualValues", Argsf: "len(elems), 0", ReportMsgf: report, ProposedFn: "Empty", ProposedArgsf: "elems"},
+ {Fn: "EqualValues", Argsf: "0, len(elems)", ReportMsgf: report, ProposedFn: "Empty", ProposedArgsf: "elems"},
+ {Fn: "Exactly", Argsf: "len(elems), 0", ReportMsgf: report, ProposedFn: "Empty", ProposedArgsf: "elems"},
+ {Fn: "Exactly", Argsf: "0, len(elems)", ReportMsgf: report, ProposedFn: "Empty", ProposedArgsf: "elems"},
{Fn: "LessOrEqual", Argsf: "len(elems), 0", ReportMsgf: report, ProposedFn: "Empty", ProposedArgsf: "elems"},
{Fn: "GreaterOrEqual", Argsf: "0, len(elems)", ReportMsgf: report, ProposedFn: "Empty", ProposedArgsf: "elems"},
{Fn: "Less", Argsf: "len(elems), 1", ReportMsgf: report, ProposedFn: "Empty", ProposedArgsf: "elems"},
@@ -68,6 +72,8 @@ func (g EmptyTestsGenerator) TemplateData() any {
// 0 != n, 0 < n
{Fn: "NotEqual", Argsf: "len(elems), 0", ReportMsgf: report, ProposedFn: "NotEmpty", ProposedArgsf: "elems"},
{Fn: "NotEqual", Argsf: "0, len(elems)", ReportMsgf: report, ProposedFn: "NotEmpty", ProposedArgsf: "elems"},
+ {Fn: "NotEqualValues", Argsf: "len(elems), 0", ReportMsgf: report, ProposedFn: "NotEmpty", ProposedArgsf: "elems"},
+ {Fn: "NotEqualValues", Argsf: "0, len(elems)", ReportMsgf: report, ProposedFn: "NotEmpty", ProposedArgsf: "elems"},
{Fn: "Greater", Argsf: "len(elems), 0", ReportMsgf: report, ProposedFn: "NotEmpty", ProposedArgsf: "elems"},
{Fn: "Less", Argsf: "0, len(elems)", ReportMsgf: report, ProposedFn: "NotEmpty", ProposedArgsf: "elems"},
},
diff --git a/internal/testgen/gen_error_nil.go b/internal/testgen/gen_error_nil.go
index 38c37bf..75168a6 100644
--- a/internal/testgen/gen_error_nil.go
+++ b/internal/testgen/gen_error_nil.go
@@ -52,13 +52,16 @@ func (g ErrorNilTestsGenerator) TemplateData() any {
InvalidAssertions: []Assertion{
{Fn: "Nil", Argsf: "err", ReportMsgf: report, ProposedFn: "NoError"},
{Fn: "NotNil", Argsf: "err", ReportMsgf: report, ProposedFn: "Error"},
-
{Fn: "Equal", Argsf: "err, nil", ReportMsgf: report, ProposedFn: "NoError", ProposedArgsf: "err"},
{Fn: "Equal", Argsf: "nil, err", ReportMsgf: report, ProposedFn: "NoError", ProposedArgsf: "err"},
-
+ {Fn: "EqualValues", Argsf: "err, nil", ReportMsgf: report, ProposedFn: "NoError", ProposedArgsf: "err"},
+ {Fn: "EqualValues", Argsf: "nil, err", ReportMsgf: report, ProposedFn: "NoError", ProposedArgsf: "err"},
+ {Fn: "Exactly", Argsf: "err, nil", ReportMsgf: report, ProposedFn: "NoError", ProposedArgsf: "err"},
+ {Fn: "Exactly", Argsf: "nil, err", ReportMsgf: report, ProposedFn: "NoError", ProposedArgsf: "err"},
{Fn: "NotEqual", Argsf: "err, nil", ReportMsgf: report, ProposedFn: "Error", ProposedArgsf: "err"},
{Fn: "NotEqual", Argsf: "nil, err", ReportMsgf: report, ProposedFn: "Error", ProposedArgsf: "err"},
-
+ {Fn: "NotEqualValues", Argsf: "err, nil", ReportMsgf: report, ProposedFn: "Error", ProposedArgsf: "err"},
+ {Fn: "NotEqualValues", Argsf: "nil, err", ReportMsgf: report, ProposedFn: "Error", ProposedArgsf: "err"},
{Fn: "ErrorIs", Argsf: "err, nil", ReportMsgf: report, ProposedFn: "NoError", ProposedArgsf: "err"},
{Fn: "NotErrorIs", Argsf: "err, nil", ReportMsgf: report, ProposedFn: "Error", ProposedArgsf: "err"},
},
diff --git a/internal/testgen/gen_expected_actual.go b/internal/testgen/gen_expected_actual.go
index c57ffe5..85e7479 100644
--- a/internal/testgen/gen_expected_actual.go
+++ b/internal/testgen/gen_expected_actual.go
@@ -30,15 +30,16 @@ func (g ExpectedActualTestsGenerator) TemplateData() any {
}
return struct {
- CheckerName CheckerName
- Typed []literal
- Untyped []string
- ExpVars []string
- Basic test
- Strings test
- NotDetected []Assertion
- RealLifeJSONEq Assertion
- IgnoredAssertions []Assertion
+ CheckerName CheckerName
+ Typed []literal
+ Untyped []string
+ ExpVars []string
+ Basic test
+ OtherExpActFunctions test
+ Strings test
+ NotDetected []Assertion
+ RealLifeJSONEq Assertion
+ IgnoredAssertions []Assertion
}{
CheckerName: CheckerName(checker),
Typed: []literal{
@@ -86,6 +87,8 @@ func (g ExpectedActualTestsGenerator) TemplateData() any {
"[]int{1, 2, 3}",
"[3]int{1, 2, 3}",
`map[string]int{"0": 1}`,
+ `user{Name: "Anton"}`,
+ `struct {Name string}{Name: "Anton"}`,
},
Basic: test{
InvalidAssertions: []Assertion{
@@ -97,6 +100,107 @@ func (g ExpectedActualTestsGenerator) TemplateData() any {
{Fn: "NotEqual", Argsf: "%s, result"},
},
},
+ OtherExpActFunctions: test{
+ InvalidAssertions: []Assertion{
+ {
+ Fn: "EqualExportedValues", Argsf: "resultObj, expectedObj",
+ ReportMsgf: report, ProposedArgsf: "expectedObj, resultObj",
+ },
+ {
+ Fn: "EqualExportedValues", Argsf: `resultObj, user{Name: "Anton"}`,
+ ReportMsgf: report, ProposedArgsf: `user{Name: "Anton"}, resultObj`,
+ },
+ {
+ Fn: "EqualExportedValues", Argsf: `resultObj, struct {Name string}{Name: "Anton"}`,
+ ReportMsgf: report, ProposedArgsf: `struct {Name string}{Name: "Anton"}, resultObj`,
+ },
+
+ {Fn: "EqualValues", Argsf: "result, expected", ReportMsgf: report, ProposedArgsf: "expected, result"},
+ {Fn: "EqualValues", Argsf: "result, uint32(100)", ReportMsgf: report, ProposedArgsf: "uint32(100), result"},
+ {Fn: "NotEqualValues", Argsf: "result, expected", ReportMsgf: report, ProposedArgsf: "expected, result"},
+ {Fn: "NotEqualValues", Argsf: "result, uint32(100)", ReportMsgf: report, ProposedArgsf: "uint32(100), result"},
+
+ {Fn: "Exactly", Argsf: "result, expected", ReportMsgf: report, ProposedArgsf: "expected, result"},
+ {Fn: "Exactly", Argsf: "result, int64(1)", ReportMsgf: report, ProposedArgsf: "int64(1), result"},
+
+ {Fn: "InDelta", Argsf: "result, expected, 1.0", ReportMsgf: report, ProposedArgsf: "expected, result, 1.0"},
+ {Fn: "InDelta", Argsf: "result, 42.42, 1.0", ReportMsgf: report, ProposedArgsf: "42.42, result, 1.0"},
+
+ {
+ Fn: "InDeltaMapValues", Argsf: "result, expected, 2.0",
+ ReportMsgf: report, ProposedArgsf: "expected, result, 2.0",
+ },
+ {
+ Fn: "InDeltaMapValues", Argsf: `result, map[string]float64{"score": 0.99}, 2.0`,
+ ReportMsgf: report, ProposedArgsf: `map[string]float64{"score": 0.99}, result, 2.0`,
+ },
+
+ {
+ Fn: "InDeltaSlice", Argsf: "result, expected, 1.0",
+ ReportMsgf: report, ProposedArgsf: "expected, result, 1.0",
+ },
+ {
+ Fn: "InDeltaSlice", Argsf: `result, []float64{0.98, 0.99}, 1.0`,
+ ReportMsgf: report, ProposedArgsf: `[]float64{0.98, 0.99}, result, 1.0`,
+ },
+
+ {
+ Fn: "InEpsilon", Argsf: "result, expected, 0.0001",
+ ReportMsgf: report, ProposedArgsf: "expected, result, 0.0001",
+ },
+ {
+ Fn: "InEpsilon", Argsf: "result, 42.42, 0.0001",
+ ReportMsgf: report, ProposedArgsf: "42.42, result, 0.0001",
+ },
+
+ {Fn: "IsType", Argsf: "result, expected", ReportMsgf: report, ProposedArgsf: "expected, result"},
+ {Fn: "IsType", Argsf: "result, user{}", ReportMsgf: report, ProposedArgsf: "user{}, result"},
+ {Fn: "IsType", Argsf: "result, (*user)(nil)", ReportMsgf: report, ProposedArgsf: "(*user)(nil), result"},
+
+ {Fn: "Same", Argsf: "resultPtr, expectedPtr", ReportMsgf: report, ProposedArgsf: "expectedPtr, resultPtr"},
+ {Fn: "Same", Argsf: "resultPtr, &value", ReportMsgf: report, ProposedArgsf: "&value, resultPtr"},
+ {Fn: "NotSame", Argsf: "resultPtr, expectedPtr", ReportMsgf: report, ProposedArgsf: "expectedPtr, resultPtr"},
+ {Fn: "NotSame", Argsf: "resultPtr, &value", ReportMsgf: report, ProposedArgsf: "&value, resultPtr"},
+
+ {
+ Fn: "WithinDuration", Argsf: "resultTime, expectedTime, time.Second",
+ ReportMsgf: report, ProposedArgsf: "expectedTime, resultTime, time.Second",
+ },
+ },
+ ValidAssertions: []Assertion{
+ {Fn: "EqualExportedValues", Argsf: "expectedObj, resultObj"},
+ {Fn: "EqualExportedValues", Argsf: `user{Name: "Anton"}, resultObj`},
+ {Fn: "EqualExportedValues", Argsf: `struct {Name string}{Name: "Anton"}, resultObj`},
+
+ {Fn: "EqualValues", Argsf: "expected, result"},
+ {Fn: "EqualValues", Argsf: "uint32(100), result"},
+ {Fn: "NotEqualValues", Argsf: "expected, result"},
+ {Fn: "NotEqualValues", Argsf: "uint32(100), result"},
+
+ {Fn: "Exactly", Argsf: "expected, result"},
+ {Fn: "Exactly", Argsf: "int64(1), result"},
+
+ {Fn: "InDelta", Argsf: "expected, result, 1.0"},
+ {Fn: "InDelta", Argsf: "42.42, result, 1.0"},
+
+ {Fn: "InDeltaMapValues", Argsf: "expected, result, 2.0"},
+ {Fn: "InDeltaMapValues", Argsf: `map[string]float64{"score": 0.99}, result, 2.0`},
+
+ {Fn: "InEpsilon", Argsf: "expected, result, 0.0001"},
+ {Fn: "InEpsilon", Argsf: "42.42, result, 0.0001"},
+
+ {Fn: "IsType", Argsf: "expected, result"},
+ {Fn: "IsType", Argsf: "user{}, result"},
+ {Fn: "IsType", Argsf: "(*user)(nil), result"},
+
+ {Fn: "Same", Argsf: "expectedPtr, resultPtr"},
+ {Fn: "Same", Argsf: "&value, resultPtr"},
+ {Fn: "NotSame", Argsf: "expectedPtr, resultPtr"},
+ {Fn: "NotSame", Argsf: "&value, resultPtr"},
+
+ {Fn: "WithinDuration", Argsf: "expectedTime, resultTime, time.Second"},
+ },
+ },
Strings: test{
InvalidAssertions: []Assertion{
{Fn: "JSONEq", Argsf: "result, %s", ReportMsgf: report, ProposedArgsf: "%s, result"},
@@ -122,6 +226,18 @@ func (g ExpectedActualTestsGenerator) TemplateData() any {
{Fn: "Equal", Argsf: "expected, expected"},
{Fn: "Equal", Argsf: "[]int{1, 2}, map[int]int{1: 2}"},
{Fn: "NotEqual", Argsf: "result, result"},
+ {Fn: "EqualExportedValues", Argsf: `user{Name: "Anton"}, struct {Name string}{Name: "Anton"}`},
+ {Fn: "EqualValues", Argsf: "uint32(100), int32(100)"},
+ {Fn: "Exactly", Argsf: "int32(200), int64(200)"},
+ {Fn: "NotEqualValues", Argsf: "int32(100), uint32(100)"},
+ {Fn: "InDelta", Argsf: "42.42, expected, 1.0"},
+ {Fn: "InDeltaMapValues", Argsf: `map[string]float64{"score": 0.99}, nil, 2.0`},
+ {Fn: "InDeltaSlice", Argsf: `[]float64{0.98, 0.99}, []float64{0.97, 0.99}, 1.0`},
+ {Fn: "InEpsilon", Argsf: "42.42, 0.0001, 0.0001"},
+ {Fn: "IsType", Argsf: "(*user)(nil), user{}"},
+ {Fn: "Same", Argsf: "&value, &value"},
+ {Fn: "NotSame", Argsf: "expectedPtr, &value"},
+ {Fn: "WithinDuration", Argsf: "expectedTime, time.Now(), time.Second"},
},
}
}
@@ -147,11 +263,17 @@ import (
"io"
"net/http"
"testing"
+ "time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
+type user struct {
+ Name string
+ id uint64
+}
+
type testCase struct { expected string } //
func (c testCase) exp() string { return c.expected }
@@ -188,6 +310,30 @@ func {{ .CheckerName.AsTestName }}(t *testing.T) {
}
}
+func {{ .CheckerName.AsTestName }}_Other(t *testing.T) {
+ var (
+ result, expected any
+ resultPtr, expectedPtr *int
+ resultObj, expectedObj user
+ resultTime, expectedTime time.Time
+ value int
+ )
+
+ // Invalid.
+ {
+ {{- range $ai, $assrn := $.OtherExpActFunctions.InvalidAssertions }}
+ {{ NewAssertionExpander.Expand $assrn "assert" "t" nil }}
+ {{- end }}
+ }
+
+ // Valid.
+ {
+ {{- range $ai, $assrn := $.OtherExpActFunctions.ValidAssertions }}
+ {{ NewAssertionExpander.Expand $assrn "assert" "t" nil }}
+ {{- end }}
+ }
+}
+
{{ define "const-tests" }}
{{- $ := index . 0 }}
{{- $Assertions := index . 1 }}
@@ -300,7 +446,12 @@ func {{ .CheckerName.AsTestName }}_CannotDetectVariablesLookedLikeConsts(t *test
}
func {{ .CheckerName.AsTestName }}_Ignored(t *testing.T) {
- var result, expected any
+ var (
+ result, expected any
+ expectedPtr *int
+ expectedTime time.Time
+ value int
+ )
{{ range $ai, $assrn := $.IgnoredAssertions }}
{{ NewAssertionExpander.Expand $assrn "assert" "t" nil }}
diff --git a/internal/testgen/gen_float_compare.go b/internal/testgen/gen_float_compare.go
index d38951a..b0df4ca 100644
--- a/internal/testgen/gen_float_compare.go
+++ b/internal/testgen/gen_float_compare.go
@@ -52,8 +52,15 @@ func (g FloatCompareTestsGenerator) TemplateData() any {
},
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},
},
ValidAssertions: []Assertion{
{Fn: "InDelta", Argsf: "42.42, result, 0.0001"},
diff --git a/internal/testgen/gen_len.go b/internal/testgen/gen_len.go
index 2544203..4b3140d 100644
--- a/internal/testgen/gen_len.go
+++ b/internal/testgen/gen_len.go
@@ -31,6 +31,12 @@ func (g LenTestsGenerator) TemplateData() any {
{Fn: "Equal", Argsf: "len(arr), 42", ReportMsgf: report, ProposedFn: proposedFn, ProposedArgsf: "arr, 42"},
{Fn: "Equal", Argsf: "42, len(arr)", ReportMsgf: report, ProposedFn: proposedFn, ProposedArgsf: "arr, 42"},
{Fn: "Equal", Argsf: "value, len(arr)", ReportMsgf: report, ProposedFn: proposedFn, ProposedArgsf: "arr, value"},
+ {Fn: "EqualValues", Argsf: "len(arr), 42", ReportMsgf: report, ProposedFn: proposedFn, ProposedArgsf: "arr, 42"},
+ {Fn: "EqualValues", Argsf: "42, len(arr)", ReportMsgf: report, ProposedFn: proposedFn, ProposedArgsf: "arr, 42"},
+ {Fn: "EqualValues", Argsf: "value, len(arr)", ReportMsgf: report, ProposedFn: proposedFn, ProposedArgsf: "arr, value"},
+ {Fn: "Exactly", Argsf: "len(arr), 42", ReportMsgf: report, ProposedFn: proposedFn, ProposedArgsf: "arr, 42"},
+ {Fn: "Exactly", Argsf: "42, len(arr)", ReportMsgf: report, ProposedFn: proposedFn, ProposedArgsf: "arr, 42"},
+ {Fn: "Exactly", Argsf: "value, len(arr)", ReportMsgf: report, ProposedFn: proposedFn, ProposedArgsf: "arr, value"},
{Fn: "True", Argsf: "len(arr) == 42", ReportMsgf: report, ProposedFn: proposedFn, ProposedArgsf: "arr, 42"},
{Fn: "True", Argsf: "42 == len(arr)", ReportMsgf: report, ProposedFn: proposedFn, ProposedArgsf: "arr, 42"},
},
@@ -41,12 +47,18 @@ func (g LenTestsGenerator) TemplateData() any {
IgnoredAssertions: []Assertion{
{Fn: "Equal", Argsf: "len(arr), len(arr)"},
{Fn: "Equal", Argsf: "len(arr), value"},
+ {Fn: "EqualValues", Argsf: "len(arr), len(arr)"},
+ {Fn: "EqualValues", Argsf: "len(arr), value"},
+ {Fn: "Exactly", Argsf: "len(arr), len(arr)"},
+ {Fn: "Exactly", Argsf: "len(arr), value"},
{Fn: "True", Argsf: "len(arr) == len(arr)"},
{Fn: "True", Argsf: "len(arr) == value"},
{Fn: "True", Argsf: "value == len(arr)"},
{Fn: "NotEqual", Argsf: "42, len(arr)"},
{Fn: "NotEqual", Argsf: "len(arr), 42"},
+ {Fn: "NotEqualValues", Argsf: "42, len(arr)"},
+ {Fn: "NotEqualValues", Argsf: "len(arr), 42"},
{Fn: "Greater", Argsf: "len(arr), 42"},
{Fn: "Greater", Argsf: "42, len(arr)"},
{Fn: "GreaterOrEqual", Argsf: "len(arr), 42"},
diff --git a/internal/testgen/gen_nil_compare.go b/internal/testgen/gen_nil_compare.go
index 5daad72..34cf7bc 100644
--- a/internal/testgen/gen_nil_compare.go
+++ b/internal/testgen/gen_nil_compare.go
@@ -32,10 +32,25 @@ func (g NilCompareTestsGenerator) TemplateData() any {
{Fn: "Equal", Argsf: `Row["col"], nil`, ReportMsgf: report, ProposedFn: "Nil", ProposedArgsf: `Row["col"]`},
{Fn: "Equal", Argsf: `nil, Row["col"]`, ReportMsgf: report, ProposedFn: "Nil", ProposedArgsf: `Row["col"]`},
+ {Fn: "EqualValues", Argsf: "value, nil", ReportMsgf: report, ProposedFn: "Nil", ProposedArgsf: "value"},
+ {Fn: "EqualValues", Argsf: "nil, value", ReportMsgf: report, ProposedFn: "Nil", ProposedArgsf: "value"},
+ {Fn: "EqualValues", Argsf: `Row["col"], nil`, ReportMsgf: report, ProposedFn: "Nil", ProposedArgsf: `Row["col"]`},
+ {Fn: "EqualValues", Argsf: `nil, Row["col"]`, ReportMsgf: report, ProposedFn: "Nil", ProposedArgsf: `Row["col"]`},
+
+ {Fn: "Exactly", Argsf: "value, nil", ReportMsgf: report, ProposedFn: "Nil", ProposedArgsf: "value"},
+ {Fn: "Exactly", Argsf: "nil, value", ReportMsgf: report, ProposedFn: "Nil", ProposedArgsf: "value"},
+ {Fn: "Exactly", Argsf: `Row["col"], nil`, ReportMsgf: report, ProposedFn: "Nil", ProposedArgsf: `Row["col"]`},
+ {Fn: "Exactly", Argsf: `nil, Row["col"]`, ReportMsgf: report, ProposedFn: "Nil", ProposedArgsf: `Row["col"]`},
+
{Fn: "NotEqual", Argsf: "value, nil", ReportMsgf: report, ProposedFn: "NotNil", ProposedArgsf: "value"},
{Fn: "NotEqual", Argsf: "nil, value", ReportMsgf: report, ProposedFn: "NotNil", ProposedArgsf: "value"},
{Fn: "NotEqual", Argsf: `Row["col"], nil`, ReportMsgf: report, ProposedFn: "NotNil", ProposedArgsf: `Row["col"]`},
{Fn: "NotEqual", Argsf: `nil, Row["col"]`, ReportMsgf: report, ProposedFn: "NotNil", ProposedArgsf: `Row["col"]`},
+
+ {Fn: "NotEqualValues", Argsf: "value, nil", ReportMsgf: report, ProposedFn: "NotNil", ProposedArgsf: "value"},
+ {Fn: "NotEqualValues", Argsf: "nil, value", ReportMsgf: report, ProposedFn: "NotNil", ProposedArgsf: "value"},
+ {Fn: "NotEqualValues", Argsf: `Row["col"], nil`, ReportMsgf: report, ProposedFn: "NotNil", ProposedArgsf: `Row["col"]`},
+ {Fn: "NotEqualValues", Argsf: `nil, Row["col"]`, ReportMsgf: report, ProposedFn: "NotNil", ProposedArgsf: `Row["col"]`},
},
ValidAssertions: []Assertion{
{Fn: "Nil", Argsf: "value"},
@@ -48,11 +63,29 @@ func (g NilCompareTestsGenerator) TemplateData() any {
{Fn: "Equal", Argsf: `"foo", Row["col"]`},
{Fn: "Equal", Argsf: `Row["col"], Row["col"]`},
+ {Fn: "EqualValues", Argsf: "value, value"},
+ {Fn: "EqualValues", Argsf: "nil, nil"},
+ {Fn: "EqualValues", Argsf: `Row["col"], "foo"`},
+ {Fn: "EqualValues", Argsf: `"foo", Row["col"]`},
+ {Fn: "EqualValues", Argsf: `Row["col"], Row["col"]`},
+
+ {Fn: "Exactly", Argsf: "value, value"},
+ {Fn: "Exactly", Argsf: "nil, nil"},
+ {Fn: "Exactly", Argsf: `Row["col"], "foo"`},
+ {Fn: "Exactly", Argsf: `"foo", Row["col"]`},
+ {Fn: "Exactly", Argsf: `Row["col"], Row["col"]`},
+
{Fn: "NotEqual", Argsf: "value, value"},
{Fn: "NotEqual", Argsf: "nil, nil"},
{Fn: "NotEqual", Argsf: `Row["col"], "foo"`},
{Fn: "NotEqual", Argsf: `"foo", Row["col"]`},
{Fn: "NotEqual", Argsf: `Row["col"], Row["col"]`},
+
+ {Fn: "NotEqualValues", Argsf: "value, value"},
+ {Fn: "NotEqualValues", Argsf: "nil, nil"},
+ {Fn: "NotEqualValues", Argsf: `Row["col"], "foo"`},
+ {Fn: "NotEqualValues", Argsf: `"foo", Row["col"]`},
+ {Fn: "NotEqualValues", Argsf: `Row["col"], Row["col"]`},
},
}
}
@@ -77,7 +110,6 @@ import (
"testing"
"github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func {{ .CheckerName.AsTestName }}(t *testing.T) {
@@ -88,7 +120,6 @@ func {{ .CheckerName.AsTestName }}(t *testing.T) {
{
{{- range $ai, $assrn := $.InvalidAssertions }}
{{ NewAssertionExpander.Expand $assrn "assert" "t" nil }}
- {{ NewAssertionExpander.Expand $assrn "require" "t" nil }}
{{- end }}
}
@@ -96,7 +127,6 @@ func {{ .CheckerName.AsTestName }}(t *testing.T) {
{
{{- range $ai, $assrn := $.ValidAssertions }}
{{ NewAssertionExpander.Expand $assrn "assert" "t" nil }}
- {{ NewAssertionExpander.Expand $assrn "require" "t" nil }}
{{- end }}
}
@@ -104,7 +134,6 @@ func {{ .CheckerName.AsTestName }}(t *testing.T) {
{
{{- range $ai, $assrn := $.IgnoredAssertions }}
{{ NewAssertionExpander.Expand $assrn "assert" "t" nil }}
- {{ NewAssertionExpander.Expand $assrn "require" "t" nil }}
{{- end }}
}
}