deps(actions): Bump golangci/golangci-lint-action from 6 to 7 (#2357)

* deps(actions): Bump golangci/golangci-lint-action from 6 to 7

Bumps [golangci/golangci-lint-action](https://github.com/golangci/golangci-lint-action) from 6 to 7.
- [Release notes](https://github.com/golangci/golangci-lint-action/releases)
- [Commits](https://github.com/golangci/golangci-lint-action/compare/v6...v7)

---
updated-dependencies:
- dependency-name: golangci/golangci-lint-action
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>

* fix(lint): Fixing new lint errors

Signed-off-by: Dave Henderson <dhenderson@gmail.com>

---------

Signed-off-by: dependabot[bot] <support@github.com>
Signed-off-by: Dave Henderson <dhenderson@gmail.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Dave Henderson <dhenderson@gmail.com>

38 files changed, 256 insertions, 239 deletions

diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index 1c54b312..334d9951 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -22,7 +22,7 @@ jobs:
         with:
           go-version-file: go.mod
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v6
+        uses: golangci/golangci-lint-action@v7
         with:
           version: latest
           args: --verbose --max-same-issues=0 --max-issues-per-linter=0
diff --git a/.golangci.yml b/.golangci.yml
index bd370b77..f36409f1 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -1,28 +1,10 @@
-linters-settings:
-  govet:
-    enable-all: true
-  gocyclo:
-    min-complexity: 10
-  gomoddirectives:
-    replace-local: false
-    replace-allow-list: []
-    retract-allow-no-explanation: false
-    exclude-forbidden: true
-  dupl:
-    threshold: 100
-  goconst:
-    min-len: 2
-    min-occurrences: 5
-    ignore-tests: true
-  lll:
-    line-length: 140
-  nolintlint:
-    allow-unused: false # report any unused nolint directives
-    require-explanation: false # don't require an explanation for nolint directives
-    require-specific: false # don't require nolint directives to be specific about which linter is being skipped
+version: "2"
+
+run:
+  concurrency: 4
 
 linters:
-  disable-all: true
+  default: none
   enable:
     - asciicheck
     - bodyclose
@@ -40,16 +22,12 @@ linters:
     - gocritic
     # - gocyclo
     # - godox
-    - gofmt
-    - gofumpt
     - goheader
-    - goimports
     # - gomnd
     - gomoddirectives
     - gomodguard
     - goprintffuncname
     - gosec
-    - gosimple
     - govet
     - ineffassign
     # - lll
@@ -65,21 +43,60 @@ linters:
     - sloglint
     - sqlclosecheck
     - staticcheck
-    - stylecheck
     - testifylint
-    - typecheck
     - unconvert
     - unparam
     - unused
     - whitespace
     # - wsl
+  settings:
+    dupl:
+      threshold: 100
+    goconst:
+      min-len: 2
+      min-occurrences: 5
+    gocyclo:
+      min-complexity: 10
+    gomoddirectives:
+      replace-local: false
+      exclude-forbidden: true
+      retract-allow-no-explanation: false
+    govet:
+      enable-all: true
+    lll:
+      line-length: 140
+    nolintlint:
+      allow-unused: false # report any unused nolint directives
+      require-explanation: false # don't require an explanation for nolint directives
+      require-specific: false # don't require nolint directives to be specific about which linter is being skipped
 
-issues:
-  exclude-rules:
-    - path: _test\.go
-      linters:
-        - errcheck
+  exclusions:
+    generated: lax
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling
+    rules:
+      - linters:
+          - errcheck
+        path: _test\.go
+      - linters:
+          - goconst
+        path: (.+)_test\.go
+    paths:
+      - third_party$
+      - builtin$
+      - examples$
 
-run:
-  concurrency: 4
-  timeout: 5m
+formatters:
+  enable:
+    - gofmt
+    - gofumpt
+    - goimports
+  exclusions:
+    generated: lax
+    paths:
+      - third_party$
+      - builtin$
+      - examples$
diff --git a/aws/ec2info_test.go b/aws/ec2info_test.go
index 87db85a3..ddf9e38d 100644
--- a/aws/ec2info_test.go
+++ b/aws/ec2info_test.go
@@ -104,7 +104,7 @@ func TestTag_NonEC2(t *testing.T) {
 		cache:      make(map[string]any),
 	}
 
-	assert.Equal(t, "", must(e.Tag("foo")))
+	assert.Empty(t, must(e.Tag("foo")))
 	assert.Equal(t, "default", must(e.Tag("foo", "default")))
 }
 
diff --git a/aws/kms_test.go b/aws/kms_test.go
index f40c1fec..a24482ed 100644
--- a/aws/kms_test.go
+++ b/aws/kms_test.go
@@ -37,7 +37,7 @@ func TestEncrypt(t *testing.T) {
 	resp, err := kmsClient.Encrypt("dummykey", "plaintextvalue")
 	require.NoError(t, err)
 	expectedResp, _ := b64.Encode([]byte("PLAINTEXTVALUE"))
-	assert.EqualValues(t, expectedResp, resp)
+	assert.Equal(t, expectedResp, resp)
 }
 
 func TestDecrypt(t *testing.T) {
@@ -49,5 +49,5 @@ func TestDecrypt(t *testing.T) {
 	// Success
 	resp, err := kmsClient.Decrypt(encodedCiphertextBlob)
 	require.NoError(t, err)
-	assert.EqualValues(t, "ciphervalue", resp)
+	assert.Equal(t, "ciphervalue", resp)
 }
diff --git a/aws/sts_test.go b/aws/sts_test.go
index 6ce3be54..485d86a7 100644
--- a/aws/sts_test.go
+++ b/aws/sts_test.go
@@ -24,7 +24,7 @@ func TestNewSTS(t *testing.T) {
 
 	out, err := s.getCallerID()
 	require.NoError(t, err)
-	assert.EqualValues(t, &sts.GetCallerIdentityOutput{
+	assert.Equal(t, &sts.GetCallerIdentityOutput{
 		Account: aws.String("acct"),
 		Arn:     aws.String("arn"),
 		UserId:  aws.String("uid"),
@@ -46,7 +46,7 @@ func TestNewSTS(t *testing.T) {
 
 	out, err = s.getCallerID()
 	require.NoError(t, err)
-	assert.EqualValues(t, &sts.GetCallerIdentityOutput{
+	assert.Equal(t, &sts.GetCallerIdentityOutput{
 		Account: aws.String("acct"),
 		Arn:     aws.String("arn"),
 		UserId:  aws.String("uid"),
diff --git a/base64/base64_test.go b/base64/base64_test.go
index 2ecd3210..1374af52 100644
--- a/base64/base64_test.go
+++ b/base64/base64_test.go
@@ -15,7 +15,7 @@ func must(r any, err error) any {
 }
 
 func TestEncode(t *testing.T) {
-	assert.Equal(t, "", must(Encode([]byte(""))))
+	assert.Empty(t, must(Encode([]byte(""))))
 	assert.Equal(t, "Zg==", must(Encode([]byte("f"))))
 	assert.Equal(t, "Zm8=", must(Encode([]byte("fo"))))
 	assert.Equal(t, "Zm9v", must(Encode([]byte("foo"))))
diff --git a/coll/coll_test.go b/coll/coll_test.go
index ab2241ee..d39dc511 100644
--- a/coll/coll_test.go
+++ b/coll/coll_test.go
@@ -76,7 +76,7 @@ func TestKeys(t *testing.T) {
 	expected := []string{"bar", "foo"}
 	keys, err := Keys(in)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, keys)
+	assert.Equal(t, expected, keys)
 
 	in2 := map[string]any{
 		"baz": 3,
@@ -85,7 +85,7 @@ func TestKeys(t *testing.T) {
 	expected = []string{"bar", "foo", "baz", "qux"}
 	keys, err = Keys(in, in2)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, keys)
+	assert.Equal(t, expected, keys)
 
 	in3 := map[string]any{
 		"Foo": 5,
@@ -96,7 +96,7 @@ func TestKeys(t *testing.T) {
 	expected = []string{"bar", "foo", "baz", "qux", "Bar", "Foo", "bar", "foo"}
 	keys, err = Keys(in, in2, in3)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, keys)
+	assert.Equal(t, expected, keys)
 }
 
 func TestValues(t *testing.T) {
@@ -110,7 +110,7 @@ func TestValues(t *testing.T) {
 	expected := []any{2, 1}
 	values, err := Values(in)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, values)
+	assert.Equal(t, expected, values)
 
 	in2 := map[string]any{
 		"baz": 3,
@@ -119,7 +119,7 @@ func TestValues(t *testing.T) {
 	expected = []any{2, 1, 3, 4}
 	values, err = Values(in, in2)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, values)
+	assert.Equal(t, expected, values)
 
 	in3 := map[string]any{
 		"Foo": 5,
@@ -130,73 +130,73 @@ func TestValues(t *testing.T) {
 	expected = []any{2, 1, 3, 4, 6, 5, 8, 7}
 	values, err = Values(in, in2, in3)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, values)
+	assert.Equal(t, expected, values)
 }
 
 func TestAppend(t *testing.T) {
 	out, err := Append(42, []any{})
 	require.NoError(t, err)
-	assert.EqualValues(t, []any{42}, out)
+	assert.Equal(t, []any{42}, out)
 
 	out, err = Append(42, []any{4.9, false, "foo"})
 	require.NoError(t, err)
-	assert.EqualValues(t, []any{4.9, false, "foo", 42}, out)
+	assert.Equal(t, []any{4.9, false, "foo", 42}, out)
 
 	// a strange but valid use-cases, since we're converting to an []any
 	out, err = Append(42, []string{"foo"})
 	require.NoError(t, err)
-	assert.EqualValues(t, []any{"foo", 42}, out)
+	assert.Equal(t, []any{"foo", 42}, out)
 
 	out, err = Append("baz", []string{"foo", "bar"})
 	require.NoError(t, err)
-	assert.EqualValues(t, []any{"foo", "bar", "baz"}, out)
+	assert.Equal(t, []any{"foo", "bar", "baz"}, out)
 }
 
 func TestPrepend(t *testing.T) {
 	out, err := Prepend(42, []any{})
 	require.NoError(t, err)
-	assert.EqualValues(t, []any{42}, out)
+	assert.Equal(t, []any{42}, out)
 
 	out, err = Prepend(42, []any{4.9, false, "foo"})
 	require.NoError(t, err)
-	assert.EqualValues(t, []any{42, 4.9, false, "foo"}, out)
+	assert.Equal(t, []any{42, 4.9, false, "foo"}, out)
 
 	// a strange but valid use-cases, since we're converting to an []any
 	out, err = Prepend(42, []string{"foo"})
 	require.NoError(t, err)
-	assert.EqualValues(t, []any{42, "foo"}, out)
+	assert.Equal(t, []any{42, "foo"}, out)
 
 	out, err = Prepend("foo", []string{"bar", "baz"})
 	require.NoError(t, err)
-	assert.EqualValues(t, []any{"foo", "bar", "baz"}, out)
+	assert.Equal(t, []any{"foo", "bar", "baz"}, out)
 }
 
 func TestUniq(t *testing.T) {
 	out, err := Uniq([]any{1, 2, 3, 1, true, false, true, "1", 2})
 	require.NoError(t, err)
-	assert.EqualValues(t, []any{1, 2, 3, true, false, "1"}, out)
+	assert.Equal(t, []any{1, 2, 3, true, false, "1"}, out)
 
 	out, err = Uniq([]string{"one", "two", "one", "three"})
 	require.NoError(t, err)
-	assert.EqualValues(t, []any{"one", "two", "three"}, out)
+	assert.Equal(t, []any{"one", "two", "three"}, out)
 }
 
 func TestReverse(t *testing.T) {
 	out, err := Reverse([]any{})
 	require.NoError(t, err)
-	assert.EqualValues(t, []any{}, out)
+	assert.Equal(t, []any{}, out)
 
 	out, err = Reverse([]any{8})
 	require.NoError(t, err)
-	assert.EqualValues(t, []any{8}, out)
+	assert.Equal(t, []any{8}, out)
 
 	out, err = Reverse([]any{1, 2, 3, 4})
 	require.NoError(t, err)
-	assert.EqualValues(t, []any{4, 3, 2, 1}, out)
+	assert.Equal(t, []any{4, 3, 2, 1}, out)
 
 	out, err = Reverse([]int{1, 2, 3, 4})
 	require.NoError(t, err)
-	assert.EqualValues(t, []any{4, 3, 2, 1}, out)
+	assert.Equal(t, []any{4, 3, 2, 1}, out)
 }
 
 func TestMerge(t *testing.T) {
@@ -206,7 +206,7 @@ func TestMerge(t *testing.T) {
 
 	out, err := Merge(dst, src)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, out)
+	assert.Equal(t, expected, out)
 
 	dst = map[string]any{"a": 4, "c": 5}
 	src = map[string]any{"a": 1, "b": 2, "c": 3}
@@ -216,7 +216,7 @@ func TestMerge(t *testing.T) {
 
 	out, err = Merge(dst, src)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, out)
+	assert.Equal(t, expected, out)
 
 	dst = map[string]any{"a": 4, "c": 5}
 	src = map[string]any{"a": 1, "b": 2, "c": 3}
@@ -227,7 +227,7 @@ func TestMerge(t *testing.T) {
 
 	out, err = Merge(dst, src, src2)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, out)
+	assert.Equal(t, expected, out)
 
 	dst = map[string]any{"a": false, "c": 5}
 	src = map[string]any{"a": true, "b": 2, "c": 3}
@@ -238,7 +238,7 @@ func TestMerge(t *testing.T) {
 
 	out, err = Merge(dst, src, src2)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, out)
+	assert.Equal(t, expected, out)
 
 	dst = map[string]any{"a": true, "c": 5}
 	src = map[string]any{
@@ -254,7 +254,7 @@ func TestMerge(t *testing.T) {
 
 	out, err = Merge(dst, src, src2)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, out)
+	assert.Equal(t, expected, out)
 
 	dst = map[string]any{
 		"a": true,
@@ -279,7 +279,7 @@ func TestMerge(t *testing.T) {
 
 	out, err = Merge(dst, src)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, out)
+	assert.Equal(t, expected, out)
 }
 
 type coords struct {
@@ -464,7 +464,7 @@ func TestSort(t *testing.T) {
 		t.Run(fmt.Sprintf(`Sort("%s",<%T>)==%#v`, d.key, d.in, d.out), func(t *testing.T) {
 			out, err := Sort(d.key, d.in)
 			require.NoError(t, err)
-			assert.EqualValues(t, d.out, out)
+			assert.Equal(t, d.out, out)
 		})
 	}
 }
@@ -541,7 +541,7 @@ func TestFlatten(t *testing.T) {
 	for _, d := range data {
 		out, err := Flatten(d.in, d.depth)
 		require.NoError(t, err)
-		assert.EqualValues(t, d.expected, out)
+		assert.Equal(t, d.expected, out)
 	}
 
 	_, err := Flatten(42, -1)
@@ -583,20 +583,20 @@ func TestOmit(t *testing.T) {
 		"bar": true,
 		"":    "baz",
 	}
-	assert.EqualValues(t, in, Omit(in, "baz"))
+	assert.Equal(t, in, Omit(in, "baz"))
 
 	expected := map[string]any{
 		"foo": "bar",
 		"bar": true,
 	}
-	assert.EqualValues(t, expected, Omit(in, ""))
+	assert.Equal(t, expected, Omit(in, ""))
 
 	expected = map[string]any{
 		"": "baz",
 	}
-	assert.EqualValues(t, expected, Omit(in, "foo", "bar"))
+	assert.Equal(t, expected, Omit(in, "foo", "bar"))
 
-	assert.EqualValues(t, map[string]any{}, Omit(in, "foo", "bar", ""))
+	assert.Equal(t, map[string]any{}, Omit(in, "foo", "bar", ""))
 }
 
 func TestPick(t *testing.T) {
@@ -606,18 +606,18 @@ func TestPick(t *testing.T) {
 		"":    "baz",
 	}
 	expected := map[string]any{}
-	assert.EqualValues(t, expected, Pick(in, "baz"))
+	assert.Equal(t, expected, Pick(in, "baz"))
 
 	expected = map[string]any{
 		"": "baz",
 	}
-	assert.EqualValues(t, expected, Pick(in, ""))
+	assert.Equal(t, expected, Pick(in, ""))
 
 	expected = map[string]any{
 		"foo": "bar",
 		"bar": true,
 	}
-	assert.EqualValues(t, expected, Pick(in, "foo", "bar"))
+	assert.Equal(t, expected, Pick(in, "foo", "bar"))
 
-	assert.EqualValues(t, in, Pick(in, "foo", "bar", ""))
+	assert.Equal(t, in, Pick(in, "foo", "bar", ""))
 }
diff --git a/coll/jq_test.go b/coll/jq_test.go
index 0d45fdfb..2928293c 100644
--- a/coll/jq_test.go
+++ b/coll/jq_test.go
@@ -64,7 +64,7 @@ func TestJQ(t *testing.T) {
 
 	out, err = JQ(ctx, ".store", in)
 	require.NoError(t, err)
-	assert.EqualValues(t, in["store"], out)
+	assert.Equal(t, in["store"], out)
 
 	out, err = JQ(ctx, ".store.book[].author", in)
 	require.NoError(t, err)
@@ -91,7 +91,7 @@ func TestJQ(t *testing.T) {
 			"price":    8.99,
 		},
 	}
-	assert.EqualValues(t, expected, out)
+	assert.Equal(t, expected, out)
 
 	in = map[string]any{
 		"a": map[string]any{
diff --git a/coll/jsonpath_test.go b/coll/jsonpath_test.go
index 147fc2ea..c7bacc20 100644
--- a/coll/jsonpath_test.go
+++ b/coll/jsonpath_test.go
@@ -65,7 +65,7 @@ func TestJSONPath(t *testing.T) {
 
 	out, err = JSONPath(".store", in)
 	require.NoError(t, err)
-	assert.EqualValues(t, in["store"], out)
+	assert.Equal(t, in["store"], out)
 
 	out, err = JSONPath("$.store.book[*].author", in)
 	require.NoError(t, err)
@@ -92,7 +92,7 @@ func TestJSONPath(t *testing.T) {
 			"price":    8.99,
 		},
 	}
-	assert.EqualValues(t, expected, out)
+	assert.Equal(t, expected, out)
 
 	in = m{
 		"a": m{
diff --git a/config.go b/config.go
index 365cb840..78fed6dc 100644
--- a/config.go
+++ b/config.go
@@ -265,7 +265,7 @@ func (c *Config) MergeFrom(o *Config) *Config {
 		c.InputDir = o.InputDir
 		c.InputFiles = nil
 	case !isZero(o.InputFiles):
-		if !(len(o.InputFiles) == 1 && o.InputFiles[0] == "-") {
+		if len(o.InputFiles) != 1 || o.InputFiles[0] != "-" {
 			c.Input = ""
 			c.InputFiles = o.InputFiles
 			c.InputDir = ""
diff --git a/config_test.go b/config_test.go
index 349d3d27..75067e33 100644
--- a/config_test.go
+++ b/config_test.go
@@ -97,7 +97,7 @@ pluginTimeout: 2s
 
 	cf, err = Parse(strings.NewReader(in))
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, cf)
+	assert.Equal(t, expected, cf)
 }
 
 func mustURL(s string) *url.URL {
@@ -270,7 +270,7 @@ func TestMergeFrom(t *testing.T) {
 		OutMode: "644",
 	}
 
-	assert.EqualValues(t, expected, cfg.MergeFrom(other))
+	assert.Equal(t, expected, cfg.MergeFrom(other))
 
 	cfg = &Config{
 		Input: "hello world",
@@ -284,7 +284,7 @@ func TestMergeFrom(t *testing.T) {
 		OutputFiles: []string{"out", "out2"},
 	}
 
-	assert.EqualValues(t, expected, cfg.MergeFrom(other))
+	assert.Equal(t, expected, cfg.MergeFrom(other))
 
 	cfg = &Config{
 		Input:       "hello world",
@@ -299,7 +299,7 @@ func TestMergeFrom(t *testing.T) {
 		OutputDir: "out/",
 	}
 
-	assert.EqualValues(t, expected, cfg.MergeFrom(other))
+	assert.Equal(t, expected, cfg.MergeFrom(other))
 
 	cfg = &Config{
 		Input:       "hello world",
@@ -316,7 +316,7 @@ func TestMergeFrom(t *testing.T) {
 		PostExec: []string{"cat"},
 	}
 
-	assert.EqualValues(t, expected, cfg.MergeFrom(other))
+	assert.Equal(t, expected, cfg.MergeFrom(other))
 
 	cfg = &Config{
 		Input:       "hello world",
@@ -342,7 +342,7 @@ func TestMergeFrom(t *testing.T) {
 		PluginTimeout: 500 * time.Microsecond,
 	}
 
-	assert.EqualValues(t, expected, cfg.MergeFrom(other))
+	assert.Equal(t, expected, cfg.MergeFrom(other))
 
 	cfg = &Config{
 		Input:   "hello world",
@@ -397,7 +397,7 @@ func TestMergeFrom(t *testing.T) {
 		OutMode: "644",
 	}
 
-	assert.EqualValues(t, expected, cfg.MergeFrom(other))
+	assert.Equal(t, expected, cfg.MergeFrom(other))
 
 	// test template merging & a few other things
 	cfg = &Config{
@@ -441,7 +441,7 @@ func TestMergeFrom(t *testing.T) {
 		},
 	}
 
-	assert.EqualValues(t, expected, cfg.MergeFrom(other))
+	assert.Equal(t, expected, cfg.MergeFrom(other))
 }
 
 func TestConfig_String(t *testing.T) {
@@ -573,8 +573,8 @@ func TestApplyDefaults(t *testing.T) {
 	cfg := &Config{}
 
 	cfg.applyDefaults()
-	assert.EqualValues(t, []string{"-"}, cfg.InputFiles)
-	assert.EqualValues(t, []string{"-"}, cfg.OutputFiles)
+	assert.Equal(t, []string{"-"}, cfg.InputFiles)
+	assert.Equal(t, []string{"-"}, cfg.OutputFiles)
 	assert.Empty(t, cfg.OutputDir)
 	assert.Equal(t, "{{", cfg.LDelim)
 	assert.Equal(t, "}}", cfg.RDelim)
@@ -598,7 +598,7 @@ func TestApplyDefaults(t *testing.T) {
 
 	cfg.applyDefaults()
 	assert.Empty(t, cfg.InputFiles)
-	assert.EqualValues(t, []string{"-"}, cfg.OutputFiles)
+	assert.Equal(t, []string{"-"}, cfg.OutputFiles)
 	assert.Empty(t, cfg.OutputDir)
 	assert.Equal(t, "<", cfg.LDelim)
 	assert.Equal(t, ">", cfg.RDelim)
@@ -610,7 +610,7 @@ func TestApplyDefaults(t *testing.T) {
 
 	cfg.applyDefaults()
 	assert.Empty(t, cfg.InputFiles)
-	assert.EqualValues(t, []string{"-"}, cfg.OutputFiles)
+	assert.Equal(t, []string{"-"}, cfg.OutputFiles)
 	assert.Empty(t, cfg.OutputDir)
 	assert.True(t, cfg.ExecPipe)
 
@@ -657,7 +657,7 @@ func TestPluginConfig_UnmarshalYAML(t *testing.T) {
 	out := PluginConfig{}
 	err := yaml.Unmarshal([]byte(in), &out)
 	require.NoError(t, err)
-	assert.EqualValues(t, PluginConfig{Cmd: "foo"}, out)
+	assert.Equal(t, PluginConfig{Cmd: "foo"}, out)
 
 	in = `[foo, bar]`
 	out = PluginConfig{}
@@ -668,7 +668,7 @@ func TestPluginConfig_UnmarshalYAML(t *testing.T) {
 	out = PluginConfig{}
 	err = yaml.Unmarshal([]byte(in), &out)
 	require.NoError(t, err)
-	assert.EqualValues(t, PluginConfig{Cmd: "foo"}, out)
+	assert.Equal(t, PluginConfig{Cmd: "foo"}, out)
 
 	in = `cmd: foo
 timeout: 10ms
@@ -677,7 +677,7 @@ pipe: true
 	out = PluginConfig{}
 	err = yaml.Unmarshal([]byte(in), &out)
 	require.NoError(t, err)
-	assert.EqualValues(t, PluginConfig{
+	assert.Equal(t, PluginConfig{
 		Cmd:     "foo",
 		Timeout: time.Duration(10) * time.Millisecond,
 		Pipe:    true,
diff --git a/crypto/pbkdf2_test.go b/crypto/pbkdf2_test.go
index 05be16a2..7eb9982c 100644
--- a/crypto/pbkdf2_test.go
+++ b/crypto/pbkdf2_test.go
@@ -17,7 +17,7 @@ func TestPBKDF2(t *testing.T) {
 
 	// IEEE 802.11i-2004 test vectors
 	dk, err = PBKDF2([]byte("password"), []byte("IEEE"), 4096, 32, crypto.SHA1)
-	assert.EqualValues(t, []byte{
+	assert.Equal(t, []byte{
 		0xf4, 0x2c, 0x6f, 0xc5, 0x2d, 0xf0, 0xeb, 0xef,
 		0x9e, 0xbb, 0x4b, 0x90, 0xb3, 0x8a, 0x5f, 0x90,
 		0x2e, 0x83, 0xfe, 0x1b, 0x13, 0x5a, 0x70, 0xe2,
@@ -26,7 +26,7 @@ func TestPBKDF2(t *testing.T) {
 	require.NoError(t, err)
 
 	dk, err = PBKDF2([]byte("ThisIsAPassword"), []byte("ThisIsASSID"), 4096, 32, crypto.SHA1)
-	assert.EqualValues(t, []byte{
+	assert.Equal(t, []byte{
 		0x0d, 0xc0, 0xd6, 0xeb, 0x90, 0x55, 0x5e, 0xd6,
 		0x41, 0x97, 0x56, 0xb9, 0xa1, 0x5e, 0xc3, 0xe3,
 		0x20, 0x9b, 0x63, 0xdf, 0x70, 0x7d, 0xd5, 0x08,
@@ -35,7 +35,7 @@ func TestPBKDF2(t *testing.T) {
 	require.NoError(t, err)
 
 	dk, err = PBKDF2([]byte("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), []byte("ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ"), 4096, 32, crypto.SHA1)
-	assert.EqualValues(t, []byte{
+	assert.Equal(t, []byte{
 		0xbe, 0xcb, 0x93, 0x86, 0x6b, 0xb8, 0xc3, 0x83,
 		0x2c, 0xb7, 0x77, 0xc2, 0xf5, 0x59, 0x80, 0x7c,
 		0x8c, 0x59, 0xaf, 0xcb, 0x6e, 0xae, 0x73, 0x48,
@@ -45,7 +45,7 @@ func TestPBKDF2(t *testing.T) {
 
 	// some longer hash functions
 	dk, err = PBKDF2([]byte("password"), []byte("IEEE"), 4096, 64, crypto.SHA512)
-	assert.EqualValues(t, []byte{
+	assert.Equal(t, []byte{
 		0xc1, 0x6f, 0x4c, 0xb6, 0xd0, 0x3e, 0x23, 0x61,
 		0x43, 0x99, 0xde, 0xe5, 0xe7, 0xf6, 0x76, 0xfb,
 		0x1d, 0xa0, 0xeb, 0x94, 0x71, 0xb6, 0xa7, 0x4a,
diff --git a/gomplate_test.go b/gomplate_test.go
index 8a4b05d9..beee3c59 100644
--- a/gomplate_test.go
+++ b/gomplate_test.go
@@ -59,7 +59,7 @@ func TestEc2MetaTemplates(t *testing.T) {
 	}
 
 	g := createGomplate(nil, "")
-	assert.Equal(t, "", testTemplate(t, g, `{{ec2meta "foo"}}`))
+	assert.Empty(t, testTemplate(t, g, `{{ec2meta "foo"}}`))
 	assert.Equal(t, "default", testTemplate(t, g, `{{ec2meta "foo" "default"}}`))
 
 	g = createGomplate(map[string]string{"instance-id": "i-1234"}, "")
diff --git a/internal/cmd/config_test.go b/internal/cmd/config_test.go
index 069d10ce..65be5753 100644
--- a/internal/cmd/config_test.go
+++ b/internal/cmd/config_test.go
@@ -50,7 +50,7 @@ func TestReadConfigFile(t *testing.T) {
 
 	cfg, err := readConfigFile(ctx, cmd)
 	require.NoError(t, err)
-	assert.EqualValues(t, &gomplate.Config{}, cfg)
+	assert.Equal(t, &gomplate.Config{}, cfg)
 
 	cmd.ParseFlags([]string{"--config", "config.yaml"})
 
@@ -58,7 +58,7 @@ func TestReadConfigFile(t *testing.T) {
 
 	cfg, err = readConfigFile(ctx, cmd)
 	require.NoError(t, err)
-	assert.EqualValues(t, &gomplate.Config{Input: "hello world"}, cfg)
+	assert.Equal(t, &gomplate.Config{Input: "hello world"}, cfg)
 
 	fsys["config.yaml"] = &fstest.MapFile{Data: []byte("in: hello world\nin: \n")}
 
@@ -96,7 +96,7 @@ func TestLoadConfig(t *testing.T) {
 		Stderr: stderr,
 	}
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, out)
+	assert.Equal(t, expected, out)
 
 	cmd.ParseFlags([]string{"--in", "foo"})
 	out, err = loadConfig(ctx, cmd, cmd.Flags().Args())
@@ -107,7 +107,7 @@ func TestLoadConfig(t *testing.T) {
 		Stderr: stderr,
 	}
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, out)
+	assert.Equal(t, expected, out)
 
 	cmd.ParseFlags([]string{"--in", "foo", "--exec-pipe", "--", "tr", "[a-z]", "[A-Z]"})
 	out, err = loadConfig(ctx, cmd, cmd.Flags().Args())
@@ -120,7 +120,7 @@ func TestLoadConfig(t *testing.T) {
 		Stderr:   stderr,
 	}
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, out)
+	assert.Equal(t, expected, out)
 }
 
 func TestPostExecInput(t *testing.T) {
@@ -154,13 +154,13 @@ func TestCobraConfig(t *testing.T) {
 
 	cfg, err := cobraConfig(cmd, cmd.Flags().Args())
 	require.NoError(t, err)
-	assert.EqualValues(t, &gomplate.Config{}, cfg)
+	assert.Equal(t, &gomplate.Config{}, cfg)
 
 	cmd.ParseFlags([]string{"--file", "in", "--", "echo", "foo"})
 
 	cfg, err = cobraConfig(cmd, cmd.Flags().Args())
 	require.NoError(t, err)
-	assert.EqualValues(t, &gomplate.Config{
+	assert.Equal(t, &gomplate.Config{
 		InputFiles: []string{"in"},
 		PostExec:   []string{"echo", "foo"},
 	}, cfg)
@@ -179,7 +179,7 @@ func TestProcessIncludes(t *testing.T) {
 	}
 
 	for _, d := range data {
-		assert.EqualValues(t, d.expected, processIncludes(d.inc, d.exc))
+		assert.Equal(t, d.expected, processIncludes(d.inc, d.exc))
 	}
 }
 
@@ -221,7 +221,7 @@ func TestPickConfigFile(t *testing.T) {
 		cf, req, skip := pickConfigFile(cmd)
 		assert.False(t, req)
 		assert.True(t, skip)
-		assert.Equal(t, "", cf)
+		assert.Empty(t, cf)
 	})
 
 	t.Run("GOMPLATE_CONFIG env var with empty value should skip reading", func(t *testing.T) {
@@ -229,7 +229,7 @@ func TestPickConfigFile(t *testing.T) {
 		cf, req, skip := pickConfigFile(cmd)
 		assert.False(t, req)
 		assert.True(t, skip)
-		assert.Equal(t, "", cf)
+		assert.Empty(t, cf)
 	})
 }
 
@@ -308,7 +308,7 @@ func TestApplyEnvVars(t *testing.T) {
 
 			actual, err := applyEnvVars(context.Background(), d.input)
 			require.NoError(t, err)
-			assert.EqualValues(t, d.expected, actual)
+			assert.Equal(t, d.expected, actual)
 		})
 	}
 }
@@ -327,7 +327,7 @@ func TestParseDataSourceFlags(t *testing.T) {
 	cfg := &gomplate.Config{}
 	err := parseDataSourceFlags(cfg, nil, nil, nil, nil)
 	require.NoError(t, err)
-	assert.EqualValues(t, &gomplate.Config{}, cfg)
+	assert.Equal(t, &gomplate.Config{}, cfg)
 
 	cfg = &gomplate.Config{}
 	err = parseDataSourceFlags(cfg, []string{"foo/bar/baz.json"}, nil, nil, nil)
@@ -341,7 +341,7 @@ func TestParseDataSourceFlags(t *testing.T) {
 			"baz": {URL: mustURL("foo/bar/baz.json")},
 		},
 	}
-	assert.EqualValues(t, expected, cfg, "expected: %+v\nactual: %+v\n", expected, cfg)
+	assert.Equal(t, expected, cfg, "expected: %+v\nactual: %+v\n", expected, cfg)
 
 	cfg = &gomplate.Config{}
 	err = parseDataSourceFlags(cfg,
@@ -350,7 +350,7 @@ func TestParseDataSourceFlags(t *testing.T) {
 		nil,
 		[]string{"baz=Accept: application/json"})
 	require.NoError(t, err)
-	assert.EqualValues(t, &gomplate.Config{
+	assert.Equal(t, &gomplate.Config{
 		DataSources: map[string]gomplate.DataSource{
 			"baz": {
 				URL: mustURL("foo/bar/baz.json"),
@@ -372,7 +372,7 @@ func TestParseDataSourceFlags(t *testing.T) {
 		},
 	)
 	require.NoError(t, err)
-	assert.EqualValues(t, &gomplate.Config{
+	assert.Equal(t, &gomplate.Config{
 		DataSources: map[string]gomplate.DataSource{
 			"baz": {URL: mustURL("foo/bar/baz.json")},
 		},
@@ -397,7 +397,7 @@ func TestParseDataSourceFlags(t *testing.T) {
 		[]string{"foo=Accept: application/json", "bar=Authorization: Basic xxxxx"},
 	)
 	require.NoError(t, err)
-	assert.EqualValues(t, &gomplate.Config{
+	assert.Equal(t, &gomplate.Config{
 		Templates: map[string]gomplate.DataSource{
 			"foo": {
 				URL:    mustURL("http://example.com"),
@@ -421,7 +421,7 @@ func TestParsePluginFlags(t *testing.T) {
 	cfg = &gomplate.Config{}
 	err = ParsePluginFlags(cfg, []string{"foo=bar"})
 	require.NoError(t, err)
-	assert.EqualValues(t, &gomplate.Config{Plugins: map[string]gomplate.PluginConfig{"foo": {Cmd: "bar"}}}, cfg)
+	assert.Equal(t, &gomplate.Config{Plugins: map[string]gomplate.PluginConfig{"foo": {Cmd: "bar"}}}, cfg)
 }
 
 func TestParseDatasourceArgNoAlias(t *testing.T) {
@@ -441,7 +441,7 @@ func TestParseDatasourceArgWithAlias(t *testing.T) {
 	alias, ds, err := parseDatasourceArg("data=foo.json")
 	require.NoError(t, err)
 	assert.Equal(t, "data", alias)
-	assert.EqualValues(t, &url.URL{Path: "foo.json"}, ds.URL)
+	assert.Equal(t, &url.URL{Path: "foo.json"}, ds.URL)
 
 	alias, ds, err = parseDatasourceArg("data=/otherdir/foo.json")
 	require.NoError(t, err)
@@ -454,33 +454,33 @@ func TestParseDatasourceArgWithAlias(t *testing.T) {
 		alias, ds, err = parseDatasourceArg("data=foo.json")
 		require.NoError(t, err)
 		assert.Equal(t, "data", alias)
-		assert.EqualValues(t, &url.URL{Path: "foo.json"}, ds.URL)
+		assert.Equal(t, &url.URL{Path: "foo.json"}, ds.URL)
 
 		alias, ds, err = parseDatasourceArg(`data=\otherdir\foo.json`)
 		require.NoError(t, err)
 		assert.Equal(t, "data", alias)
-		assert.EqualValues(t, &url.URL{Scheme: "file", Path: "/otherdir/foo.json"}, ds.URL)
+		assert.Equal(t, &url.URL{Scheme: "file", Path: "/otherdir/foo.json"}, ds.URL)
 
 		alias, ds, err = parseDatasourceArg("data=C:\\windowsdir\\foo.json")
 		require.NoError(t, err)
 		assert.Equal(t, "data", alias)
-		assert.EqualValues(t, &url.URL{Scheme: "file", Path: "C:/windowsdir/foo.json"}, ds.URL)
+		assert.Equal(t, &url.URL{Scheme: "file", Path: "C:/windowsdir/foo.json"}, ds.URL)
 
 		alias, ds, err = parseDatasourceArg("data=\\\\somehost\\share\\foo.json")
 		require.NoError(t, err)
 		assert.Equal(t, "data", alias)
-		assert.EqualValues(t, &url.URL{Scheme: "file", Host: "somehost", Path: "/share/foo.json"}, ds.URL)
+		assert.Equal(t, &url.URL{Scheme: "file", Host: "somehost", Path: "/share/foo.json"}, ds.URL)
 	}
 
 	alias, ds, err = parseDatasourceArg("data=sftp://example.com/blahblah/foo.json")
 	require.NoError(t, err)
 	assert.Equal(t, "data", alias)
-	assert.EqualValues(t, &url.URL{Scheme: "sftp", Host: "example.com", Path: "/blahblah/foo.json"}, ds.URL)
+	assert.Equal(t, &url.URL{Scheme: "sftp", Host: "example.com", Path: "/blahblah/foo.json"}, ds.URL)
 
 	alias, ds, err = parseDatasourceArg("merged=merge:./foo.yaml|http://example.com/bar.json%3Ffoo=bar")
 	require.NoError(t, err)
 	assert.Equal(t, "merged", alias)
-	assert.EqualValues(t, &url.URL{Scheme: "merge", Opaque: "./foo.yaml|http://example.com/bar.json%3Ffoo=bar"}, ds.URL)
+	assert.Equal(t, &url.URL{Scheme: "merge", Opaque: "./foo.yaml|http://example.com/bar.json%3Ffoo=bar"}, ds.URL)
 }
 
 func TestParseHeaderArgs(t *testing.T) {
diff --git a/internal/datafs/fsys_test.go b/internal/datafs/fsys_test.go
index 14e2a0bd..b675c6a6 100644
--- a/internal/datafs/fsys_test.go
+++ b/internal/datafs/fsys_test.go
@@ -30,7 +30,7 @@ func TestFSysForPath(t *testing.T) {
 		fsp := fsimpl.FSProviderFunc(func(u *url.URL) (fs.FS, error) {
 			assert.Equal(t, "file", u.Scheme)
 
-			if runtime.GOOS == "windows" {
+			if runtime.GOOS == osWindows {
 				assert.Equal(t, vol+"/tmp/foo/", u.Path)
 				return os.DirFS(vol + "/"), nil
 			}
@@ -61,7 +61,7 @@ func TestFSysForPath(t *testing.T) {
 	t.Run("git+file url", func(t *testing.T) {
 		fsp := fsimpl.FSProviderFunc(func(u *url.URL) (fs.FS, error) {
 			assert.Equal(t, "git+file", u.Scheme)
-			if runtime.GOOS == "windows" {
+			if runtime.GOOS == osWindows {
 				assert.Equal(t, vol+"/tmp/repo/", u.Path)
 			} else {
 				assert.Equal(t, "/tmp/repo", u.Path)
diff --git a/internal/datafs/getenv_test.go b/internal/datafs/getenv_test.go
index c05a4c4b..8e5cc4df 100644
--- a/internal/datafs/getenv_test.go
+++ b/internal/datafs/getenv_test.go
@@ -46,7 +46,7 @@ func TestExpandEnvFsys(t *testing.T) {
 
 	fsys = writeOnly(fsys)
 	t.Setenv("FOO_FILE", "/tmp/unreadable")
-	assert.Equal(t, "", ExpandEnvFsys(fsys, "${FOO}"))
+	assert.Empty(t, ExpandEnvFsys(fsys, "${FOO}"))
 }
 
 // Maybe extract this into a separate package sometime...
diff --git a/internal/datafs/mergefs.go b/internal/datafs/mergefs.go
index 4c10fb1d..ac5a5013 100644
--- a/internal/datafs/mergefs.go
+++ b/internal/datafs/mergefs.go
@@ -133,7 +133,7 @@ func (f *mergeFS) Open(name string) (fs.File, error) {
 
 		// need to support absolute paths on local filesystem too
 		// TODO: this is a hack, probably fix this?
-		if fsURL.Scheme == "file" && runtime.GOOS != "windows" {
+		if fsURL.Scheme == "file" && runtime.GOOS != osWindows {
 			base = fsURL.Path + base
 		}
 
diff --git a/internal/datafs/reader.go b/internal/datafs/reader.go
index 298fd9da..0297ac69 100644
--- a/internal/datafs/reader.go
+++ b/internal/datafs/reader.go
@@ -18,6 +18,8 @@ import (
 	"github.com/hairyhenderson/gomplate/v4/internal/iohelpers"
 )
 
+const osWindows = "windows"
+
 // typeOverrideParam gets the query parameter used to override the content type
 // used to parse a given datasource - use GOMPLATE_TYPE_PARAM to use a different
 // parameter name.
@@ -132,7 +134,7 @@ func (d *dsReader) readFileContent(ctx context.Context, u *url.URL, hdr http.Hea
 
 	// need to support absolute paths on local filesystem too
 	// TODO: this is a hack, probably fix this?
-	if u.Scheme == "file" && runtime.GOOS != "windows" {
+	if u.Scheme == "file" && runtime.GOOS != osWindows {
 		fname = u.Path + fname
 	}
 
diff --git a/internal/datafs/reader_test.go b/internal/datafs/reader_test.go
index dbb37edc..a89656a7 100644
--- a/internal/datafs/reader_test.go
+++ b/internal/datafs/reader_test.go
@@ -19,8 +19,6 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-const osWindows = "windows"
-
 func TestResolveURL(t *testing.T) {
 	out, err := resolveURL(*mustParseURL("http://example.com/foo.json"), "bar.json")
 	require.NoError(t, err)
diff --git a/internal/datafs/wdfs_test.go b/internal/datafs/wdfs_test.go
index 30fd5cf0..571f1e83 100644
--- a/internal/datafs/wdfs_test.go
+++ b/internal/datafs/wdfs_test.go
@@ -158,14 +158,14 @@ func TestWDFS_WriteOps(t *testing.T) {
 
 func skipWindows(t *testing.T) {
 	t.Helper()
-	if runtime.GOOS == "windows" {
+	if runtime.GOOS == osWindows {
 		t.Skip("skipping non-Windows test")
 	}
 }
 
 func skipNonWindows(t *testing.T) {
 	t.Helper()
-	if runtime.GOOS != "windows" {
+	if runtime.GOOS != osWindows {
 		t.Skip("skipping Windows test")
 	}
 }
diff --git a/internal/funcs/aws_test.go b/internal/funcs/aws_test.go
index 396d7826..4804839f 100644
--- a/internal/funcs/aws_test.go
+++ b/internal/funcs/aws_test.go
@@ -33,8 +33,8 @@ func TestAWSFuncs(t *testing.T) {
 	i := aws.NewDummyEc2Info(m)
 	af := &Funcs{meta: m, info: i}
 	assert.Equal(t, "unknown", must(af.EC2Region()))
-	assert.Equal(t, "", must(af.EC2Meta("foo")))
-	assert.Equal(t, "", must(af.EC2Tag("foo")))
+	assert.Empty(t, must(af.EC2Meta("foo")))
+	assert.Empty(t, must(af.EC2Tag("foo")))
 	assert.Equal(t, "unknown", must(af.EC2Region()))
 }
 
diff --git a/internal/funcs/coll_test.go b/internal/funcs/coll_test.go
index 86e53e65..178f537d 100644
--- a/internal/funcs/coll_test.go
+++ b/internal/funcs/coll_test.go
@@ -40,11 +40,11 @@ func TestFlatten(t *testing.T) {
 
 	out, err := c.Flatten([]any{1, []any{[]int{2}, 3}})
 	require.NoError(t, err)
-	assert.EqualValues(t, []any{1, 2, 3}, out)
+	assert.Equal(t, []any{1, 2, 3}, out)
 
 	out, err = c.Flatten(1, []any{1, []any{[]int{2}, 3}})
 	require.NoError(t, err)
-	assert.EqualValues(t, []any{1, []int{2}, 3}, out)
+	assert.Equal(t, []any{1, []int{2}, 3}, out)
 }
 
 func TestPick(t *testing.T) {
@@ -74,7 +74,7 @@ func TestPick(t *testing.T) {
 	}
 	out, err := c.Pick("baz", in)
 	require.NoError(t, err)
-	assert.EqualValues(t, map[string]any{}, out)
+	assert.Equal(t, map[string]any{}, out)
 
 	expected := map[string]any{
 		"foo": "bar",
@@ -82,18 +82,18 @@ func TestPick(t *testing.T) {
 	}
 	out, err = c.Pick("foo", "bar", in)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, out)
+	assert.Equal(t, expected, out)
 
 	expected = map[string]any{
 		"": "baz",
 	}
 	out, err = c.Pick("", in)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, out)
+	assert.Equal(t, expected, out)
 
 	out, err = c.Pick("foo", "bar", "", in)
 	require.NoError(t, err)
-	assert.EqualValues(t, in, out)
+	assert.Equal(t, in, out)
 
 	t.Run("supports slice key", func(t *testing.T) {
 		t.Parallel()
@@ -105,7 +105,7 @@ func TestPick(t *testing.T) {
 		}
 		out, err := c.Pick([]string{"foo", "bar"}, in)
 		require.NoError(t, err)
-		assert.EqualValues(t, map[string]any{"foo": "bar", "bar": true}, out)
+		assert.Equal(t, map[string]any{"foo": "bar", "bar": true}, out)
 	})
 }
 
@@ -136,7 +136,7 @@ func TestOmit(t *testing.T) {
 	}
 	out, err := c.Omit("baz", in)
 	require.NoError(t, err)
-	assert.EqualValues(t, in, out)
+	assert.Equal(t, in, out)
 
 	expected := map[string]any{
 		"foo": "bar",
@@ -144,18 +144,18 @@ func TestOmit(t *testing.T) {
 	}
 	out, err = c.Omit("", in)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, out)
+	assert.Equal(t, expected, out)
 
 	expected = map[string]any{
 		"": "baz",
 	}
 	out, err = c.Omit("foo", "bar", in)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, out)
+	assert.Equal(t, expected, out)
 
 	out, err = c.Omit("foo", "bar", "", in)
 	require.NoError(t, err)
-	assert.EqualValues(t, map[string]any{}, out)
+	assert.Equal(t, map[string]any{}, out)
 
 	t.Run("supports slice of strings", func(t *testing.T) {
 		t.Parallel()
@@ -167,7 +167,7 @@ func TestOmit(t *testing.T) {
 		}
 		out, err := c.Omit([]string{"foo", "bar"}, in)
 		require.NoError(t, err)
-		assert.EqualValues(t, map[string]any{"": "baz"}, out)
+		assert.Equal(t, map[string]any{"": "baz"}, out)
 	})
 
 	t.Run("supports slice of any", func(t *testing.T) {
@@ -180,7 +180,7 @@ func TestOmit(t *testing.T) {
 		}
 		out, err := c.Omit([]any{"foo", "bar"}, in)
 		require.NoError(t, err)
-		assert.EqualValues(t, map[string]any{"": "baz"}, out)
+		assert.Equal(t, map[string]any{"": "baz"}, out)
 	})
 }
 
@@ -207,14 +207,14 @@ func TestGoSlice(t *testing.T) {
 	out, err := c.GoSlice(in)
 	require.NoError(t, err)
 	assert.Equal(t, reflect.TypeOf([]int{}), out.Type())
-	assert.EqualValues(t, []int{1}, out.Interface())
+	assert.Equal(t, []int{1}, out.Interface())
 
 	// valid slice, slicing
 	in = reflect.ValueOf([]string{"foo", "bar", "baz"})
 	out, err = c.GoSlice(in, reflect.ValueOf(1), reflect.ValueOf(3))
 	require.NoError(t, err)
 	assert.Equal(t, reflect.TypeOf([]string{}), out.Type())
-	assert.EqualValues(t, []string{"bar", "baz"}, out.Interface())
+	assert.Equal(t, []string{"bar", "baz"}, out.Interface())
 }
 
 func TestCollFuncs_Set(t *testing.T) {
@@ -225,12 +225,12 @@ func TestCollFuncs_Set(t *testing.T) {
 	m := map[string]any{"foo": "bar"}
 	out, err := c.Set("foo", "baz", m)
 	require.NoError(t, err)
-	assert.EqualValues(t, map[string]any{"foo": "baz"}, out)
+	assert.Equal(t, map[string]any{"foo": "baz"}, out)
 
 	// m was modified so foo is now baz
 	out, err = c.Set("bar", "baz", m)
 	require.NoError(t, err)
-	assert.EqualValues(t, map[string]any{"foo": "baz", "bar": "baz"}, out)
+	assert.Equal(t, map[string]any{"foo": "baz", "bar": "baz"}, out)
 }
 
 func TestCollFuncs_Unset(t *testing.T) {
diff --git a/internal/funcs/crypto.go b/internal/funcs/crypto.go
index 63387c1c..28b3b7ce 100644
--- a/internal/funcs/crypto.go
+++ b/internal/funcs/crypto.go
@@ -101,7 +101,7 @@ func (f CryptoFuncs) SHA512(input any) string {
 
 // SHA512_224 -
 //
-//nolint:revive,stylecheck
+//nolint:revive
 func (f CryptoFuncs) SHA512_224(input any) string {
 	out, _ := f.SHA512_224Bytes(input)
 	return fmt.Sprintf("%02x", out)
@@ -109,7 +109,7 @@ func (f CryptoFuncs) SHA512_224(input any) string {
 
 // SHA512_256 -
 //
-//nolint:revive,stylecheck
+//nolint:revive
 func (f CryptoFuncs) SHA512_256(input any) string {
 	out, _ := f.SHA512_256Bytes(input)
 	return fmt.Sprintf("%02x", out)
diff --git a/internal/funcs/datasource_test.go b/internal/funcs/datasource_test.go
index 18050009..3f0c0e97 100644
--- a/internal/funcs/datasource_test.go
+++ b/internal/funcs/datasource_test.go
@@ -82,7 +82,7 @@ func TestDatasource(t *testing.T) {
 	d := setup("", nil)
 	actual, err := d.Datasource("foo")
 	require.NoError(t, err)
-	assert.Equal(t, "", actual)
+	assert.Empty(t, actual)
 
 	_, err = d.Datasource("bar")
 	require.Error(t, err)
@@ -168,7 +168,7 @@ func TestDefineDatasource(t *testing.T) {
 	_, err = d.DefineDatasource("data", "foo.json")
 	s, _ := reg.Lookup("data")
 	require.NoError(t, err)
-	assert.EqualValues(t, &url.URL{Path: "foo.json"}, s.URL)
+	assert.Equal(t, &url.URL{Path: "foo.json"}, s.URL)
 
 	reg = datafs.NewRegistry()
 	d = &dataSourceFuncs{sr: datafs.NewSourceReader(reg)}
diff --git a/internal/funcs/filepath_unix_test.go b/internal/funcs/filepath_unix_test.go
index 381e7432..a598dda8 100644
--- a/internal/funcs/filepath_unix_test.go
+++ b/internal/funcs/filepath_unix_test.go
@@ -29,5 +29,5 @@ func TestFilePathFuncs(t *testing.T) {
 	r, _ := f.Rel("/foo/bar", "/foo/bar/baz")
 	assert.Equal(t, "baz", r)
 	assert.Equal(t, []string{"/foo/bar/", "baz"}, f.Split("/foo/bar/baz"))
-	assert.Equal(t, "", f.VolumeName("/foo/bar"))
+	assert.Empty(t, f.VolumeName("/foo/bar"))
 }
diff --git a/internal/funcs/math_test.go b/internal/funcs/math_test.go
index 717db2b6..51f85b79 100644
--- a/internal/funcs/math_test.go
+++ b/internal/funcs/math_test.go
@@ -169,11 +169,11 @@ func TestSeq(t *testing.T) {
 	t.Parallel()
 
 	m := MathFuncs{}
-	assert.EqualValues(t, []int64{0, 1, 2, 3}, mustSeq(t, 0, 3))
-	assert.EqualValues(t, []int64{1, 0}, mustSeq(t, 0))
-	assert.EqualValues(t, []int64{0, 2, 4}, mustSeq(t, 0, 4, 2))
-	assert.EqualValues(t, []int64{0, 2, 4}, mustSeq(t, 0, 5, 2))
-	assert.EqualValues(t, []int64{0}, mustSeq(t, 0, 5, 8))
+	assert.Equal(t, []int64{0, 1, 2, 3}, mustSeq(t, 0, 3))
+	assert.Equal(t, []int64{1, 0}, mustSeq(t, 0))
+	assert.Equal(t, []int64{0, 2, 4}, mustSeq(t, 0, 4, 2))
+	assert.Equal(t, []int64{0, 2, 4}, mustSeq(t, 0, 5, 2))
+	assert.Equal(t, []int64{0}, mustSeq(t, 0, 5, 8))
 	_, err := m.Seq()
 	require.Error(t, err)
 }
diff --git a/internal/funcs/regexp_test.go b/internal/funcs/regexp_test.go
index ac038eab..6d0619ce 100644
--- a/internal/funcs/regexp_test.go
+++ b/internal/funcs/regexp_test.go
@@ -63,7 +63,7 @@ func TestFind(t *testing.T) {
 
 	f, err = re.Find(false, 42)
 	require.NoError(t, err)
-	assert.Equal(t, "", f)
+	assert.Empty(t, f)
 }
 
 func TestFindAll(t *testing.T) {
@@ -72,11 +72,11 @@ func TestFindAll(t *testing.T) {
 	re := &ReFuncs{}
 	f, err := re.FindAll(`[a-z]+`, `foo bar baz`)
 	require.NoError(t, err)
-	assert.EqualValues(t, []string{"foo", "bar", "baz"}, f)
+	assert.Equal(t, []string{"foo", "bar", "baz"}, f)
 
 	f, err = re.FindAll(`[a-z]+`, -1, `foo bar baz`)
 	require.NoError(t, err)
-	assert.EqualValues(t, []string{"foo", "bar", "baz"}, f)
+	assert.Equal(t, []string{"foo", "bar", "baz"}, f)
 
 	_, err = re.FindAll(`[a-`, "")
 	require.Error(t, err)
@@ -93,11 +93,11 @@ func TestFindAll(t *testing.T) {
 
 	f, err = re.FindAll(`[a-z]+`, 2, `foo bar baz`)
 	require.NoError(t, err)
-	assert.EqualValues(t, []string{"foo", "bar"}, f)
+	assert.Equal(t, []string{"foo", "bar"}, f)
 
 	f, err = re.FindAll(`[a-z]+`, 14, `foo bar baz`)
 	require.NoError(t, err)
-	assert.EqualValues(t, []string{"foo", "bar", "baz"}, f)
+	assert.Equal(t, []string{"foo", "bar", "baz"}, f)
 
 	f, err = re.FindAll(`qux`, `foo bar baz`)
 	require.NoError(t, err)
@@ -110,11 +110,11 @@ func TestSplit(t *testing.T) {
 	re := &ReFuncs{}
 	f, err := re.Split(` `, `foo bar baz`)
 	require.NoError(t, err)
-	assert.EqualValues(t, []string{"foo", "bar", "baz"}, f)
+	assert.Equal(t, []string{"foo", "bar", "baz"}, f)
 
 	f, err = re.Split(`\s+`, -1, `foo  bar baz`)
 	require.NoError(t, err)
-	assert.EqualValues(t, []string{"foo", "bar", "baz"}, f)
+	assert.Equal(t, []string{"foo", "bar", "baz"}, f)
 
 	_, err = re.Split(`[a-`, "")
 	require.Error(t, err)
@@ -131,15 +131,15 @@ func TestSplit(t *testing.T) {
 
 	f, err = re.Split(`\s+`, 2, `foo bar baz`)
 	require.NoError(t, err)
-	assert.EqualValues(t, []string{"foo", "bar baz"}, f)
+	assert.Equal(t, []string{"foo", "bar baz"}, f)
 
 	f, err = re.Split(`\s`, 14, `foo  bar baz`)
 	require.NoError(t, err)
-	assert.EqualValues(t, []string{"foo", "", "bar", "baz"}, f)
+	assert.Equal(t, []string{"foo", "", "bar", "baz"}, f)
 
 	f, err = re.Split(`[\s,.]`, 14, `foo bar.baz,qux`)
 	require.NoError(t, err)
-	assert.EqualValues(t, []string{"foo", "bar", "baz", "qux"}, f)
+	assert.Equal(t, []string{"foo", "bar", "baz", "qux"}, f)
 }
 
 func TestReplaceLiteral(t *testing.T) {
diff --git a/internal/funcs/strings_test.go b/internal/funcs/strings_test.go
index 0194d446..57e0054a 100644
--- a/internal/funcs/strings_test.go
+++ b/internal/funcs/strings_test.go
@@ -94,8 +94,8 @@ func TestTrunc(t *testing.T) {
 	t.Parallel()
 
 	sf := &StringFuncs{}
-	assert.Equal(t, "", sf.Trunc(5, ""))
-	assert.Equal(t, "", sf.Trunc(0, nil))
+	assert.Empty(t, sf.Trunc(5, ""))
+	assert.Empty(t, sf.Trunc(0, nil))
 	assert.Equal(t, "123", sf.Trunc(3, 123456789))
 	assert.Equal(t, "hello, world", sf.Trunc(-1, "hello, world"))
 }
diff --git a/internal/iohelpers/writers_test.go b/internal/iohelpers/writers_test.go
index 42d68544..90b9336e 100644
--- a/internal/iohelpers/writers_test.go
+++ b/internal/iohelpers/writers_test.go
@@ -59,7 +59,7 @@ func TestEmptySkipper(t *testing.T) {
 		} else {
 			assert.NotNil(t, f.w)
 			assert.True(t, opened)
-			assert.EqualValues(t, d.in, w.Bytes())
+			assert.Equal(t, d.in, w.Bytes())
 		}
 	}
 }
@@ -116,7 +116,7 @@ func TestSameSkipper(t *testing.T) {
 			} else {
 				assert.NotNil(t, f.w)
 				assert.True(t, opened)
-				assert.EqualValues(t, d.in, w.Bytes())
+				assert.Equal(t, d.in, w.Bytes())
 			}
 		})
 	}
diff --git a/internal/parsers/parsefuncs_test.go b/internal/parsers/parsefuncs_test.go
index 76e7b2ac..706be30a 100644
--- a/internal/parsers/parsefuncs_test.go
+++ b/internal/parsers/parsefuncs_test.go
@@ -75,7 +75,7 @@ func TestUnmarshalArray(t *testing.T) {
 
 	test := func(actual []any, err error) {
 		require.NoError(t, err)
-		assert.EqualValues(t, expected, actual)
+		assert.Equal(t, expected, actual)
 	}
 	test(JSONArray(`["foo","bar",{"baz":{"qux": true},"quux":{"42":18},"corge":{"false":"blah"}}]`))
 	test(YAMLArray(`
@@ -115,7 +115,7 @@ this shouldn't be reached
     false: blah
 `)
 	require.NoError(t, err)
-	assert.EqualValues(t,
+	assert.Equal(t,
 		[]any{
 			map[string]any{
 				"foo": map[string]any{
@@ -520,11 +520,11 @@ func TestDecryptEJSON(t *testing.T) {
 	t.Setenv("EJSON_KEY", privateKey)
 	actual, err := decryptEJSON(in)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, actual)
+	assert.Equal(t, expected, actual)
 
 	actual, err = JSON(in)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, actual)
+	assert.Equal(t, expected, actual)
 
 	tmpDir := fs.NewDir(t, "gomplate-ejsontest",
 		fs.WithFile(publicKey, privateKey),
@@ -535,14 +535,14 @@ func TestDecryptEJSON(t *testing.T) {
 	t.Setenv("EJSON_KEY_FILE", tmpDir.Join(publicKey))
 	actual, err = decryptEJSON(in)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, actual)
+	assert.Equal(t, expected, actual)
 
 	os.Unsetenv("EJSON_KEY")
 	os.Unsetenv("EJSON_KEY_FILE")
 	t.Setenv("EJSON_KEYDIR", tmpDir.Path())
 	actual, err = decryptEJSON(in)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, actual)
+	assert.Equal(t, expected, actual)
 }
 
 func TestDotEnv(t *testing.T) {
@@ -564,7 +564,7 @@ QUX='single quotes ignore $variables'
 	}
 	out, err := DotEnv(in)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, out)
+	assert.Equal(t, expected, out)
 }
 
 func TestStringifyYAMLArrayMapKeys(t *testing.T) {
@@ -613,7 +613,7 @@ func TestStringifyYAMLArrayMapKeys(t *testing.T) {
 	for _, c := range cases {
 		err := stringifyYAMLArrayMapKeys(c.input)
 		require.NoError(t, err)
-		assert.EqualValues(t, c.want, c.input)
+		assert.Equal(t, c.want, c.input)
 	}
 }
 
@@ -655,7 +655,7 @@ func TestStringifyYAMLMapMapKeys(t *testing.T) {
 	for _, c := range cases {
 		err := stringifyYAMLMapMapKeys(c.input)
 		require.NoError(t, err)
-		assert.EqualValues(t, c.want, c.input)
+		assert.Equal(t, c.want, c.input)
 	}
 }
 
@@ -704,7 +704,7 @@ list: [ 1, 2, 3 ]
 
 	out, err = CUE(`42`)
 	require.NoError(t, err)
-	assert.EqualValues(t, int64(42), out)
+	assert.Equal(t, 42, out)
 
 	out, err = CUE(`42.0`)
 	require.NoError(t, err)
@@ -742,37 +742,37 @@ func TestToCUE(t *testing.T) {
 
 	out, err := ToCUE(in)
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, out)
+	assert.Equal(t, expected, out)
 
 	out, err = ToCUE([]any{1, 2, 3})
 	require.NoError(t, err)
-	assert.EqualValues(t, `[1, 2, 3]`, out)
+	assert.Equal(t, `[1, 2, 3]`, out)
 
 	out, err = ToCUE("hello world")
 	require.NoError(t, err)
-	assert.EqualValues(t, `"hello world"`, out)
+	assert.Equal(t, `"hello world"`, out)
 
 	out, err = ToCUE(true)
 	require.NoError(t, err)
-	assert.EqualValues(t, `true`, out)
+	assert.Equal(t, `true`, out)
 
 	out, err = ToCUE([]byte{0, 1, 2, 3, 4})
 	require.NoError(t, err)
-	assert.EqualValues(t, `'\x00\x01\x02\x03\x04'`, out)
+	assert.Equal(t, `'\x00\x01\x02\x03\x04'`, out)
 
 	out, err = ToCUE(42)
 	require.NoError(t, err)
-	assert.EqualValues(t, `42`, out)
+	assert.Equal(t, `42`, out)
 
 	out, err = ToCUE(42.0)
 	require.NoError(t, err)
-	assert.EqualValues(t, `42.0`, out)
+	assert.Equal(t, `42.0`, out)
 
 	out, err = ToCUE(nil)
 	require.NoError(t, err)
-	assert.EqualValues(t, `null`, out)
+	assert.Equal(t, `null`, out)
 
 	out, err = ToCUE(struct{}{})
 	require.NoError(t, err)
-	assert.EqualValues(t, `{}`, out)
+	assert.Equal(t, `{}`, out)
 }
diff --git a/internal/tests/integration/config_test.go b/internal/tests/integration/config_test.go
index 80c9d904..8800cc4c 100644
--- a/internal/tests/integration/config_test.go
+++ b/internal/tests/integration/config_test.go
@@ -186,7 +186,7 @@ datasources:
 	o, e, err := cmd(t).withDir(tmpDir.Path()).
 		withEnv("GOMPLATE_LEFT_DELIM", "<<").run()
 	require.NoError(t, err)
-	assert.Equal(t, "", e)
+	assert.Empty(t, e)
 	assert.Equal(t, "hello world", o)
 }
 
@@ -210,7 +210,7 @@ datasources:
 		withDir(tmpDir.Path()).
 		withEnv("GOMPLATE_LEFT_DELIM", "<<").run()
 	require.NoError(t, err)
-	assert.Equal(t, "", e)
+	assert.Empty(t, e)
 	assert.Equal(t, "hello world", o)
 }
 
diff --git a/internal/tests/integration/integration_test.go b/internal/tests/integration/integration_test.go
index 10439288..b060fb9f 100644
--- a/internal/tests/integration/integration_test.go
+++ b/internal/tests/integration/integration_test.go
@@ -52,7 +52,7 @@ func inOutContains(t *testing.T, i, o string) {
 	t.Helper()
 
 	stdout, stderr, err := cmd(t, "-i", i).run()
-	assert.Equal(t, "", stderr)
+	assert.Empty(t, stderr)
 	assert.Contains(t, stdout, o)
 	require.NoError(t, err)
 }
@@ -63,7 +63,7 @@ func assertSuccess(t *testing.T, o, e string, err error, expected string) {
 	require.NoError(t, err)
 	// Filter out AWS SDK checksum warnings
 	filteredErr := filterAWSChecksumWarnings(e)
-	assert.Equal(t, "", filteredErr)
+	assert.Empty(t, filteredErr)
 	assert.Equal(t, expected, o)
 }
 
@@ -87,7 +87,7 @@ func assertFailed(t *testing.T, o, e string, err error, expected string) {
 	t.Helper()
 
 	assert.Contains(t, e, expected)
-	assert.Equal(t, "", o)
+	assert.Empty(t, o)
 	require.Error(t, err)
 }
 
diff --git a/internal/urlhelpers/urlhelpers_test.go b/internal/urlhelpers/urlhelpers_test.go
index 2065e7bb..117042d6 100644
--- a/internal/urlhelpers/urlhelpers_test.go
+++ b/internal/urlhelpers/urlhelpers_test.go
@@ -17,26 +17,26 @@ func TestParseSourceURL(t *testing.T) {
 	}
 	u, err := ParseSourceURL("http://example.com/foo.json?bar")
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, u)
+	assert.Equal(t, expected, u)
 
 	expected = &url.URL{Scheme: "", Path: ""}
 	u, err = ParseSourceURL("")
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, u)
+	assert.Equal(t, expected, u)
 
 	expected = &url.URL{Scheme: "stdin"}
 	u, err = ParseSourceURL("-")
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, u)
+	assert.Equal(t, expected, u)
 
 	// behaviour change in v4 - return relative if it's relative
 	expected = &url.URL{Path: "./foo/bar.json"}
 	u, err = ParseSourceURL("./foo/bar.json")
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, u)
+	assert.Equal(t, expected, u)
 
 	expected = &url.URL{Scheme: "file", Path: "/absolute/bar.json"}
 	u, err = ParseSourceURL("/absolute/bar.json")
 	require.NoError(t, err)
-	assert.EqualValues(t, expected, u)
+	assert.Equal(t, expected, u)
 }
diff --git a/math/math_test.go b/math/math_test.go
index 358f172f..d5e950f6 100644
--- a/math/math_test.go
+++ b/math/math_test.go
@@ -12,18 +12,18 @@ func TestMath(t *testing.T) {
 }
 
 func TestSeq(t *testing.T) {
-	assert.EqualValues(t, []int64{1, 2, 3}, Seq(1, 3, 1))
-	assert.EqualValues(t, []int64{1, 3}, Seq(1, 3, 2))
-	assert.EqualValues(t, []int64{0, 2}, Seq(0, 3, 2))
-	assert.EqualValues(t, []int64{0, 2, 4}, Seq(0, 4, 2))
-	assert.EqualValues(t, []int64{0, -5, -10}, Seq(0, -10, -5))
-	assert.EqualValues(t, []int64{4, 3, 2, 1}, Seq(4, 1, 1))
-	assert.EqualValues(t, []int64{-2, -1, 0}, Seq(-2, 0, 1))
-	assert.EqualValues(t, []int64{-1, 0, 1}, Seq(-1, 1, 1))
-	assert.EqualValues(t, []int64{-1, 0, 1}, Seq(-1, 1, -1))
-	assert.EqualValues(t, []int64{1, 0, -1}, Seq(1, -1, 1))
-	assert.EqualValues(t, []int64{1, 0, -1}, Seq(1, -1, -1))
-	assert.EqualValues(t, []int64{}, Seq(1, -1, 0))
-	assert.EqualValues(t, []int64{1}, Seq(1, 10000, 10000))
-	assert.EqualValues(t, []int64{1, 0, -1}, Seq(1, -1, -1))
+	assert.Equal(t, []int64{1, 2, 3}, Seq(1, 3, 1))
+	assert.Equal(t, []int64{1, 3}, Seq(1, 3, 2))
+	assert.Equal(t, []int64{0, 2}, Seq(0, 3, 2))
+	assert.Equal(t, []int64{0, 2, 4}, Seq(0, 4, 2))
+	assert.Equal(t, []int64{0, -5, -10}, Seq(0, -10, -5))
+	assert.Equal(t, []int64{4, 3, 2, 1}, Seq(4, 1, 1))
+	assert.Equal(t, []int64{-2, -1, 0}, Seq(-2, 0, 1))
+	assert.Equal(t, []int64{-1, 0, 1}, Seq(-1, 1, 1))
+	assert.Equal(t, []int64{-1, 0, 1}, Seq(-1, 1, -1))
+	assert.Equal(t, []int64{1, 0, -1}, Seq(1, -1, 1))
+	assert.Equal(t, []int64{1, 0, -1}, Seq(1, -1, -1))
+	assert.Equal(t, []int64{}, Seq(1, -1, 0))
+	assert.Equal(t, []int64{1}, Seq(1, 10000, 10000))
+	assert.Equal(t, []int64{1, 0, -1}, Seq(1, -1, -1))
 }
diff --git a/plugins_test.go b/plugins_test.go
index a3596cda..f6b1ae86 100644
--- a/plugins_test.go
+++ b/plugins_test.go
@@ -22,7 +22,7 @@ func TestBindPlugins(t *testing.T) {
 	}
 	err := bindPlugins(ctx, cfg, fm)
 	require.NoError(t, err)
-	assert.EqualValues(t, template.FuncMap{}, fm)
+	assert.Equal(t, template.FuncMap{}, fm)
 
 	cfg.Plugins = map[string]PluginConfig{"foo": {Cmd: "bar"}}
 	err = bindPlugins(ctx, cfg, fm)
@@ -53,7 +53,7 @@ func TestBuildCommand(t *testing.T) {
 		}
 		name, args := p.buildCommand(d.args)
 		actual := append([]string{name}, args...)
-		assert.EqualValues(t, d.expected, actual)
+		assert.Equal(t, d.expected, actual)
 	}
 }
 
@@ -69,7 +69,7 @@ func TestRun(t *testing.T) {
 	}
 	out, err := p.run("foo")
 	require.NoError(t, err)
-	assert.Equal(t, "", stderr.String())
+	assert.Empty(t, stderr.String())
 	assert.Equal(t, "foo", strings.TrimSpace(out.(string)))
 
 	p = &plugin{
@@ -81,7 +81,7 @@ func TestRun(t *testing.T) {
 	}
 	out, err = p.run()
 	require.NoError(t, err)
-	assert.Equal(t, "", stderr.String())
+	assert.Empty(t, stderr.String())
 	assert.Equal(t, "foo bar", strings.TrimSpace(out.(string)))
 
 	p = &plugin{
@@ -93,7 +93,7 @@ func TestRun(t *testing.T) {
 	}
 	out, err = p.run("baz", "qux")
 	require.NoError(t, err)
-	assert.Equal(t, "", stderr.String())
+	assert.Empty(t, stderr.String())
 	assert.Equal(t, "foo bar baz qux", strings.TrimSpace(out.(string)))
 }
 
diff --git a/regexp/regexp_test.go b/regexp/regexp_test.go
index a899c9bb..5cfd9b5f 100644
--- a/regexp/regexp_test.go
+++ b/regexp/regexp_test.go
@@ -35,7 +35,7 @@ func TestFindAll(t *testing.T) {
 	for _, d := range testdata {
 		f, err := FindAll(d.re, d.n, d.in)
 		require.NoError(t, err)
-		assert.EqualValues(t, d.expected, f)
+		assert.Equal(t, d.expected, f)
 	}
 }
 
@@ -119,7 +119,7 @@ func TestSplit(t *testing.T) {
 	for _, d := range testdata {
 		f, err := Split(d.re, d.n, d.in)
 		require.NoError(t, err)
-		assert.EqualValues(t, d.expected, f)
+		assert.Equal(t, d.expected, f)
 	}
 }
 
diff --git a/strings/strings_test.go b/strings/strings_test.go
index 9c3afa8d..df4d7ac6 100644
--- a/strings/strings_test.go
+++ b/strings/strings_test.go
@@ -60,8 +60,8 @@ func BenchmarkIndent(b *testing.B) {
 }
 
 func TestTrunc(t *testing.T) {
-	assert.Equal(t, "", Trunc(5, ""))
-	assert.Equal(t, "", Trunc(0, "hello, world"))
+	assert.Empty(t, Trunc(5, ""))
+	assert.Empty(t, Trunc(0, "hello, world"))
 	assert.Equal(t, "hello", Trunc(5, "hello, world"))
 	assert.Equal(t, "hello, world", Trunc(12, "hello, world"))
 	assert.Equal(t, "hello, world", Trunc(42, "hello, world"))
@@ -78,15 +78,15 @@ func TestShellQuote(t *testing.T) {
 func TestSort(t *testing.T) {
 	in := []string{}
 	expected := []string{}
-	assert.EqualValues(t, expected, Sort(in))
+	assert.Equal(t, expected, Sort(in))
 
 	in = []string{"c", "a", "b"}
 	expected = []string{"a", "b", "c"}
-	assert.EqualValues(t, expected, Sort(in))
+	assert.Equal(t, expected, Sort(in))
 
 	in = []string{"42", "45", "18"}
 	expected = []string{"18", "42", "45"}
-	assert.EqualValues(t, expected, Sort(in))
+	assert.Equal(t, expected, Sort(in))
 }
 
 func TestCaseFuncs(t *testing.T) {
@@ -176,5 +176,5 @@ func TestSkipLines(t *testing.T) {
 
 	out, err = SkipLines(4, "foo\nbar\n\nbaz")
 	require.NoError(t, err)
-	assert.Equal(t, "", out)
+	assert.Empty(t, out)
 }
diff --git a/tmpl/tmpl_test.go b/tmpl/tmpl_test.go
index 00e66247..fe352a63 100644
--- a/tmpl/tmpl_test.go
+++ b/tmpl/tmpl_test.go
@@ -95,7 +95,7 @@ func TestPath(t *testing.T) {
 
 	p, err := tmpl.Path()
 	require.NoError(t, err)
-	assert.Equal(t, "", p)
+	assert.Empty(t, p)
 
 	tmpl = New(nil, nil, "foo")
 	p, err = tmpl.Path()
@@ -108,7 +108,7 @@ func TestPathDir(t *testing.T) {
 
 	p, err := tmpl.PathDir()
 	require.NoError(t, err)
-	assert.Equal(t, "", p)
+	assert.Empty(t, p)
 
 	tmpl = New(nil, nil, "foo")
 	p, err = tmpl.PathDir()