refactor: switch to alecthomas/assert

.golangci.yml

@@ -36,6 +36,11 @@ linters:
     - thelper
     - godox
     - goconst
+    - varnamelen
+    - ireturn
+    - exhaustruct
+    - nonamedreturns
+    - nilnil
 
 linters-settings:
   govet:

benchmark_test.go

@@ -5,7 +5,7 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/alecthomas/assert/v2"
 )
 
 func BenchmarkKong_interpolate(b *testing.B) {
@@ -23,7 +23,7 @@ func BenchmarkKong_interpolate(b *testing.B) {
 			Param0 string `help:"${help_param0}"`
 		}{}
 		model, err := build(k, grammar)
-		require.NoError(t, err)
+		assert.NoError(t, err)
 		for i := 0; i < count; i++ {
 			model.Node.Flags = append(model.Node.Flags, &Flag{
 				Value: &Value{
@@ -44,7 +44,7 @@ func BenchmarkKong_interpolate(b *testing.B) {
 			for i := 0; i < b.N; i++ {
 				err = k.interpolate(k.Model.Node)
 			}
-			require.NoError(b, err)
+			assert.NoError(b, err)
 			b.ReportAllocs()
 		})
 	}

bin/go

@@ -1 +1 @@
-.go-1.17.8.pkg
+.go-1.18.3.pkg

bin/gofmt

@@ -1 +1 @@
-.go-1.17.8.pkg
+.go-1.18.3.pkg

bin/golangci-lint

@@ -1 +1 @@
-.golangci-lint-1.42.0.pkg
+.golangci-lint-1.46.2.pkg

callbacks.go

@@ -96,5 +96,5 @@ func callMethod(name string, v, f reflect.Value, bindings bindings) error {
 	if out[0].IsNil() {
 		return nil
 	}
-	return out[0].Interface().(error)
+	return out[0].Interface().(error) // nolint
 }

config_test.go

@@ -6,8 +6,7 @@ import (
 	"os"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/alecthomas/assert/v2"
-
 	"github.com/alecthomas/kong"
 )
 
@@ -26,8 +25,8 @@ func TestMultipleConfigLoading(t *testing.T) {
 
 	p := mustNew(t, &cli, kong.Configuration(kong.JSON, first, second))
 	_, err := p.Parse(nil)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "first", cli.Flag)
+	assert.Equal(t, "first", cli.Flag)
 }
 
 func TestConfigValidation(t *testing.T) {
@@ -41,15 +40,15 @@ func TestConfigValidation(t *testing.T) {
 
 	p := mustNew(t, &cli, kong.Configuration(kong.JSON, conf))
 	_, err := p.Parse(nil)
-	require.Error(t, err)
+	assert.Error(t, err)
 }
 
 func makeConfig(t *testing.T, config interface{}) (path string, cleanup func()) {
 	t.Helper()
 	w, err := ioutil.TempFile("", "")
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	defer w.Close() // nolint: gosec
 	err = json.NewEncoder(w).Encode(config)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	return w.Name(), func() { os.Remove(w.Name()) }
 }

defaults_test.go

@@ -4,7 +4,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/require"
+	"github.com/alecthomas/assert/v2"
 )
 
 func TestApplyDefaults(t *testing.T) {
@@ -26,8 +26,8 @@ func TestApplyDefaults(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			err := ApplyDefaults(&tt.target)
-			require.NoError(t, err)
+			assert.NoError(t, err)
-			require.Equal(t, tt.expected, tt.target)
+			assert.Equal(t, tt.expected, tt.target)
 		})
 	}
 }

global_test.go

@@ -4,7 +4,7 @@ import (
 	"os"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/alecthomas/assert/v2"
 )
 
 func TestParseHandlingBadBuild(t *testing.T) {
@@ -21,11 +21,11 @@ func TestParseHandlingBadBuild(t *testing.T) {
 
 	defer func() {
 		if r := recover(); r != nil {
-			require.Equal(t, "fail=' is not quoted properly", r.(error).Error())
+			assert.Equal(t, "fail=' is not quoted properly", r.(error).Error()) // nolint
 		}
 	}()
 
 	Parse(&cli, Exit(func(_ int) { panic("exiting") }))
 
-	require.Fail(t, "we were expecting a panic")
+	t.Fatal("we were expecting a panic")
 }

go.mod

@@ -1,9 +1,10 @@
 module github.com/alecthomas/kong
 
 require (
-	github.com/alecthomas/repr v0.0.0-20210801044451-80ca428c5142
+	github.com/alecthomas/assert/v2 v2.1.0
-	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/alecthomas/repr v0.1.0
-	github.com/stretchr/testify v1.7.2
 )
 
-go 1.13
+require github.com/hexops/gotextdiff v1.0.3 // indirect
+
+go 1.18

go.sum

@@ -1,14 +1,6 @@
-github.com/alecthomas/repr v0.0.0-20210801044451-80ca428c5142 h1:8Uy0oSf5co/NZXje7U1z8Mpep++QJOldL2hs/sBQf48=
+github.com/alecthomas/assert/v2 v2.1.0 h1:tbredtNcQnoSd3QBhQWI7QZ3XHOVkw1Moklp2ojoH/0=
-github.com/alecthomas/repr v0.0.0-20210801044451-80ca428c5142/go.mod h1:2kn6fqh/zIyPLmm3ugklbEi5hg5wS435eygvNfaDQL8=
+github.com/alecthomas/assert/v2 v2.1.0/go.mod h1:b/+1DI2Q6NckYi+3mXyH3wFb8qG37K/DuK80n7WefXA=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/alecthomas/repr v0.1.0 h1:ENn2e1+J3k09gyj2shc0dHr/yjaWSHRlrJ4DPMevDqE=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/alecthomas/repr v0.1.0/go.mod h1:2kn6fqh/zIyPLmm3ugklbEi5hg5wS435eygvNfaDQL8=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.7.2 h1:4jaiDzPyXQvSd7D0EjG45355tLlV3VOECpq10pLC+8s=
-github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

help_test.go

@@ -6,11 +6,22 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/alecthomas/assert/v2"
-
 	"github.com/alecthomas/kong"
 )
 
+func panicsTrue(t *testing.T, f func()) {
+	defer func() {
+		if value := recover(); value != nil {
+			if boolval, ok := value.(bool); !ok || !boolval {
+				t.Fatalf("expected panic with true but got %v", value)
+			}
+		}
+	}()
+	f()
+	t.Fatal("expected panic did not occur")
+}
+
 type threeArg struct {
 	RequiredThree bool   `required`
 	Three         string `arg`
@@ -35,11 +46,11 @@ func TestHelpOptionalArgs(t *testing.T) {
 			panic(true) // Panic to fake "exit".
 		}),
 	)
-	require.PanicsWithValue(t, true, func() {
+	panicsTrue(t, func() {
 		_, err := app.Parse([]string{"--help"})
-		require.NoError(t, err)
+		assert.NoError(t, err)
 	})
-	require.True(t, exited)
+	assert.True(t, exited)
 	expected := `Usage: test-app [<one> [<two>]]
 
 Arguments:
@@ -49,7 +60,7 @@ Arguments:
 Flags:
   -h, --help    Show context-sensitive help.
 `
-	require.Equal(t, expected, w.String())
+	assert.Equal(t, expected, w.String())
 }
 
 func TestHelp(t *testing.T) {
@@ -89,11 +100,11 @@ func TestHelp(t *testing.T) {
 	)
 
 	t.Run("Full", func(t *testing.T) {
-		require.PanicsWithValue(t, true, func() {
+		panicsTrue(t, func() {
 			_, err := app.Parse([]string{"--help"})
-			require.NoError(t, err)
+			assert.NoError(t, err)
 		})
-		require.True(t, exited)
+		assert.True(t, exited)
 		expected := `Usage: test-app --required <command>
 
 A test app.
@@ -122,17 +133,17 @@ Run "test-app <command> --help" for more information on a command.
 `
 		t.Log(w.String())
 		t.Log(expected)
-		require.Equal(t, expected, w.String())
+		assert.Equal(t, expected, w.String())
 	})
 
 	t.Run("Selected", func(t *testing.T) {
 		exited = false
 		w.Truncate(0)
-		require.PanicsWithValue(t, true, func() {
+		panicsTrue(t, func() {
 			_, err := app.Parse([]string{"two", "hello", "--help"})
-			require.NoError(t, err)
+			assert.NoError(t, err)
 		})
-		require.True(t, exited)
+		assert.True(t, exited)
 		expected := `Usage: test-app two <three> --required --required-two --required-three
 
 Sub-sub-arg.
@@ -156,7 +167,7 @@ Flags:
 `
 		t.Log(expected)
 		t.Log(w.String())
-		require.Equal(t, expected, w.String())
+		assert.Equal(t, expected, w.String())
 	})
 }
 
@@ -199,11 +210,11 @@ func TestFlagsLast(t *testing.T) {
 	)
 
 	t.Run("Full", func(t *testing.T) {
-		require.PanicsWithValue(t, true, func() {
+		panicsTrue(t, func() {
 			_, err := app.Parse([]string{"--help"})
-			require.NoError(t, err)
+			assert.NoError(t, err)
 		})
-		require.True(t, exited)
+		assert.True(t, exited)
 		expected := `Usage: test-app --required <command>
 
 A test app.
@@ -231,17 +242,17 @@ Run "test-app <command> --help" for more information on a command.
 `
 		t.Log(w.String())
 		t.Log(expected)
-		require.Equal(t, expected, w.String())
+		assert.Equal(t, expected, w.String())
 	})
 
 	t.Run("Selected", func(t *testing.T) {
 		exited = false
 		w.Truncate(0)
-		require.PanicsWithValue(t, true, func() {
+		panicsTrue(t, func() {
 			_, err := app.Parse([]string{"two", "hello", "--help"})
-			require.NoError(t, err)
+			assert.NoError(t, err)
 		})
-		require.True(t, exited)
+		assert.True(t, exited)
 		expected := `Usage: test-app two <three> --required --required-two --required-three
 
 Sub-sub-arg.
@@ -264,7 +275,7 @@ Flags:
 `
 		t.Log(expected)
 		t.Log(w.String())
-		require.Equal(t, expected, w.String())
+		assert.Equal(t, expected, w.String())
 	})
 }
 
@@ -304,11 +315,11 @@ func TestHelpTree(t *testing.T) {
 	)
 
 	t.Run("Full", func(t *testing.T) {
-		require.PanicsWithValue(t, true, func() {
+		panicsTrue(t, func() {
 			_, err := app.Parse([]string{"--help"})
-			require.NoError(t, err)
+			assert.NoError(t, err)
 		})
-		require.True(t, exited)
+		assert.True(t, exited)
 		expected := `Usage: test-app <command>
 
 A test app.
@@ -331,17 +342,17 @@ Run "test-app <command> --help" for more information on a command.
 		if expected != w.String() {
 			t.Errorf("help command returned:\n%v\n\nwant:\n%v", w.String(), expected)
 		}
-		require.Equal(t, expected, w.String())
+		assert.Equal(t, expected, w.String())
 	})
 
 	t.Run("Selected", func(t *testing.T) {
 		exited = false
 		w.Truncate(0)
-		require.PanicsWithValue(t, true, func() {
+		panicsTrue(t, func() {
 			_, err := app.Parse([]string{"one", "--help"})
-			require.NoError(t, err)
+			assert.NoError(t, err)
 		})
-		require.True(t, exited)
+		assert.True(t, exited)
 		expected := `Usage: test-app one (un,uno) <command>
 
 subcommand one
@@ -358,7 +369,7 @@ Commands:
 		if expected != w.String() {
 			t.Errorf("help command returned:\n%v\n\nwant:\n%v", w.String(), expected)
 		}
-		require.Equal(t, expected, w.String())
+		assert.Equal(t, expected, w.String())
 	})
 }
 
@@ -398,11 +409,11 @@ func TestHelpCompactNoExpand(t *testing.T) {
 	)
 
 	t.Run("Full", func(t *testing.T) {
-		require.PanicsWithValue(t, true, func() {
+		panicsTrue(t, func() {
 			_, err := app.Parse([]string{"--help"})
-			require.NoError(t, err)
+			assert.NoError(t, err)
 		})
-		require.True(t, exited)
+		assert.True(t, exited)
 		expected := `Usage: test-app <command>
 
 A test app.
@@ -421,17 +432,17 @@ Run "test-app <command> --help" for more information on a command.
 		if expected != w.String() {
 			t.Errorf("help command returned:\n%v\n\nwant:\n%v", w.String(), expected)
 		}
-		require.Equal(t, expected, w.String())
+		assert.Equal(t, expected, w.String())
 	})
 
 	t.Run("Selected", func(t *testing.T) {
 		exited = false
 		w.Truncate(0)
-		require.PanicsWithValue(t, true, func() {
+		panicsTrue(t, func() {
 			_, err := app.Parse([]string{"one", "--help"})
-			require.NoError(t, err)
+			assert.NoError(t, err)
 		})
-		require.True(t, exited)
+		assert.True(t, exited)
 		expected := `Usage: test-app one (un,uno) <command>
 
 subcommand one
@@ -446,7 +457,7 @@ Group A
 		if expected != w.String() {
 			t.Errorf("help command returned:\n%v\n\nwant:\n%v", w.String(), expected)
 		}
-		require.Equal(t, expected, w.String())
+		assert.Equal(t, expected, w.String())
 	})
 }
 
@@ -457,8 +468,8 @@ func TestEnvarAutoHelp(t *testing.T) {
 	w := &strings.Builder{}
 	p := mustNew(t, &cli, kong.Writers(w, w), kong.Exit(func(int) {}))
 	_, err := p.Parse([]string{"--help"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Contains(t, w.String(), "A flag ($FLAG).")
+	assert.Contains(t, w.String(), "A flag ($FLAG).")
 }
 
 func TestEnvarAutoHelpWithEnvPrefix(t *testing.T) {
@@ -472,9 +483,9 @@ func TestEnvarAutoHelpWithEnvPrefix(t *testing.T) {
 	w := &strings.Builder{}
 	p := mustNew(t, &cli, kong.Writers(w, w), kong.Exit(func(int) {}))
 	_, err := p.Parse([]string{"--help"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Contains(t, w.String(), "A flag ($ANON_FLAG).")
+	assert.Contains(t, w.String(), "A flag ($ANON_FLAG).")
-	require.Contains(t, w.String(), "A different flag.")
+	assert.Contains(t, w.String(), "A different flag.")
 }
 
 func TestCustomValueFormatter(t *testing.T) {
@@ -490,8 +501,8 @@ func TestCustomValueFormatter(t *testing.T) {
 		}),
 	)
 	_, err := p.Parse([]string{"--help"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Contains(t, w.String(), "A flag.")
+	assert.Contains(t, w.String(), "A flag.")
 }
 
 func TestAutoGroup(t *testing.T) {
@@ -541,14 +552,14 @@ func TestAutoGroup(t *testing.T) {
 			if node, ok := parent.(*kong.Node); ok {
 				return &kong.Group{
 					Key:   node.Name,
-					Title: strings.Title(node.Name) + " flags:",
+					Title: strings.Title(node.Name) + " flags:", // nolint
 				}
 			}
 			return nil
 		}),
 	)
 	_, _ = app.Parse([]string{"--help", "two"})
-	require.Equal(t, `Usage: test two
+	assert.Equal(t, `Usage: test two
 
 A non grouped subcommand.
 
@@ -627,10 +638,10 @@ func TestHelpGrouping(t *testing.T) {
 	)
 
 	t.Run("Full", func(t *testing.T) {
-		require.PanicsWithValue(t, true, func() {
+		panicsTrue(t, func() {
 			_, err := app.Parse([]string{"--help"})
-			require.True(t, exited)
+			assert.True(t, exited)
-			require.NoError(t, err)
+			assert.NoError(t, err)
 		})
 		expected := `Usage: test-app <command>
 
@@ -677,16 +688,16 @@ Run "test-app <command> --help" for more information on a command.
 `
 		t.Log(w.String())
 		t.Log(expected)
-		require.Equal(t, expected, w.String())
+		assert.Equal(t, expected, w.String())
 	})
 
 	t.Run("Selected", func(t *testing.T) {
 		exited = false
 		w.Truncate(0)
-		require.PanicsWithValue(t, true, func() {
+		panicsTrue(t, func() {
 			_, err := app.Parse([]string{"two", "--help"})
-			require.NoError(t, err)
+			assert.NoError(t, err)
-			require.True(t, exited)
+			assert.True(t, exited)
 		})
 		expected := `Usage: test-app two
 
@@ -719,7 +730,7 @@ Group 2
 `
 		t.Log(expected)
 		t.Log(w.String())
-		require.Equal(t, expected, w.String())
+		assert.Equal(t, expected, w.String())
 	})
 }
 
@@ -747,7 +758,7 @@ Flags:
 
 test: error: missing flags: --flag=STRING
 `
-	require.Equal(t, expected, w.String())
+	assert.Equal(t, expected, w.String())
 }
 
 func TestShortUsageOnError(t *testing.T) {
@@ -762,7 +773,7 @@ func TestShortUsageOnError(t *testing.T) {
 		kong.ShortUsageOnError(),
 	)
 	_, err := p.Parse([]string{})
-	require.Error(t, err)
+	assert.Error(t, err)
 	p.FatalIfErrorf(err)
 
 	expected := `Usage: test --flag=STRING
@@ -770,7 +781,7 @@ Run "test --help" for more information.
 
 test: error: missing flags: --flag=STRING
 `
-	require.Equal(t, expected, w.String())
+	assert.Equal(t, expected, w.String())
 }
 
 func TestCustomShortUsageOnError(t *testing.T) {
@@ -790,14 +801,14 @@ func TestCustomShortUsageOnError(t *testing.T) {
 		kong.ShortUsageOnError(),
 	)
 	_, err := p.Parse([]string{})
-	require.Error(t, err)
+	assert.Error(t, err)
 	p.FatalIfErrorf(err)
 
 	expected := `🤷 wish I could help
 
 test: error: missing flags: --flag=STRING
 `
-	require.Equal(t, expected, w.String())
+	assert.Equal(t, expected, w.String())
 }
 
 func TestCustomWrap(t *testing.T) {
@@ -817,7 +828,7 @@ func TestCustomWrap(t *testing.T) {
 	)
 
 	_, err := app.Parse([]string{"--help"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	expected := `Usage: test-app
 
 A test app.
@@ -832,5 +843,5 @@ Flags:
 `
 	t.Log(w.String())
 	t.Log(expected)
-	require.Equal(t, expected, w.String())
+	assert.Equal(t, expected, w.String())
 }

interpolate_test.go

@@ -3,7 +3,7 @@ package kong
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/alecthomas/assert/v2"
 )
 
 func TestInterpolate(t *testing.T) {
@@ -15,16 +15,16 @@ func TestInterpolate(t *testing.T) {
 		"height": "180",
 	}
 	actual, err := interpolate("${name=Bobby Brown} is ${age} years old, ${height} cm tall, lives in ${city=<unknown>}, and likes $${AUD}", vars, updatedVars)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, `Bobby Brown is 35 years old, 180 cm tall, lives in Melbourne, and likes ${AUD}`, actual)
+	assert.Equal(t, `Bobby Brown is 35 years old, 180 cm tall, lives in Melbourne, and likes ${AUD}`, actual)
 }
 
 func TestHasInterpolatedVar(t *testing.T) {
 	for _, tag := range []string{"name", "age", "height", "city"} {
-		require.True(t, HasInterpolatedVar("${name=Bobby Brown} is ${age} years old, ${height} cm tall, lives in ${city=<unknown>}, and likes $${AUD}", tag), tag)
+		assert.True(t, HasInterpolatedVar("${name=Bobby Brown} is ${age} years old, ${height} cm tall, lives in ${city=<unknown>}, and likes $${AUD}", tag), tag)
 	}
 
 	for _, tag := range []string{"name", "age", "height", "AUD"} {
-		require.False(t, HasInterpolatedVar("$name $$age {height} $${AUD}", tag), tag)
+		assert.False(t, HasInterpolatedVar("$name $$age {height} $${AUD}", tag), tag)
 	}
 }

kong.go

@@ -379,7 +379,7 @@ func (k *Kong) FatalIfErrorf(err error, args ...interface{}) {
 	}
 	msg := err.Error()
 	if len(args) > 0 {
-		msg = fmt.Sprintf(args[0].(string), args[1:]...) + ": " + err.Error()
+		msg = fmt.Sprintf(args[0].(string), args[1:]...) + ": " + err.Error() // nolint
 	}
 	// Maybe display usage information.
 	var parseErr *ParseError

mapper.go

@@ -53,9 +53,9 @@ type mapperValueAdapter struct {
 
 func (m *mapperValueAdapter) Decode(ctx *DecodeContext, target reflect.Value) error {
 	if target.Type().Implements(mapperValueType) {
-		return target.Interface().(MapperValue).Decode(ctx)
+		return target.Interface().(MapperValue).Decode(ctx) // nolint
 	}
-	return target.Addr().Interface().(MapperValue).Decode(ctx)
+	return target.Addr().Interface().(MapperValue).Decode(ctx) // nolint
 }
 
 func (m *mapperValueAdapter) IsBool() bool {
@@ -71,9 +71,9 @@ func (m *textUnmarshalerAdapter) Decode(ctx *DecodeContext, target reflect.Value
 		return err
 	}
 	if target.Type().Implements(textUnmarshalerType) {
-		return target.Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(value))
+		return target.Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(value)) // nolint
 	}
-	return target.Addr().Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(value))
+	return target.Addr().Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(value)) // nolint
 }
 
 type binaryUnmarshalerAdapter struct{}
@@ -85,9 +85,9 @@ func (m *binaryUnmarshalerAdapter) Decode(ctx *DecodeContext, target reflect.Val
 		return err
 	}
 	if target.Type().Implements(binaryUnmarshalerType) {
-		return target.Interface().(encoding.BinaryUnmarshaler).UnmarshalBinary([]byte(value))
+		return target.Interface().(encoding.BinaryUnmarshaler).UnmarshalBinary([]byte(value)) // nolint
 	}
-	return target.Addr().Interface().(encoding.BinaryUnmarshaler).UnmarshalBinary([]byte(value))
+	return target.Addr().Interface().(encoding.BinaryUnmarshaler).UnmarshalBinary([]byte(value)) // nolint
 }
 
 type jsonUnmarshalerAdapter struct{}
@@ -99,9 +99,9 @@ func (j *jsonUnmarshalerAdapter) Decode(ctx *DecodeContext, target reflect.Value
 		return err
 	}
 	if target.Type().Implements(jsonUnmarshalerType) {
-		return target.Interface().(json.Unmarshaler).UnmarshalJSON([]byte(value))
+		return target.Interface().(json.Unmarshaler).UnmarshalJSON([]byte(value)) // nolint
 	}
-	return target.Addr().Interface().(json.Unmarshaler).UnmarshalJSON([]byte(value))
+	return target.Addr().Interface().(json.Unmarshaler).UnmarshalJSON([]byte(value)) // nolint
 }
 
 // A Mapper represents how a field is mapped from command-line values to Go.

mapper_linux_test.go

@@ -6,7 +6,7 @@ package kong_test
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	require "github.com/alecthomas/assert/v2"
 )
 
 func TestPathMapper(t *testing.T) {
@@ -16,10 +16,10 @@ func TestPathMapper(t *testing.T) {
 	p := mustNew(t, &cli)
 
 	_, err := p.Parse([]string{"/an/absolute/path"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "/an/absolute/path", cli.Path)
+	assert.Equal(t, "/an/absolute/path", cli.Path)
 
 	_, err = p.Parse([]string{"-"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "-", cli.Path)
+	assert.Equal(t, "-", cli.Path)
 }

mapper_test.go

@@ -14,8 +14,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/require"
+	"github.com/alecthomas/assert/v2"
-
 	"github.com/alecthomas/kong"
 )
 
@@ -25,11 +24,11 @@ func TestValueMapper(t *testing.T) {
 	}
 	k := mustNew(t, &cli, kong.ValueMapper(&cli.Flag, testMooMapper{}))
 	_, err := k.Parse(nil)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "", cli.Flag)
+	assert.Equal(t, "", cli.Flag)
 	_, err = k.Parse([]string{"--flag"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "MOO", cli.Flag)
+	assert.Equal(t, "MOO", cli.Flag)
 }
 
 type textUnmarshalerValue int
@@ -50,10 +49,10 @@ func TestTextUnmarshaler(t *testing.T) {
 	}
 	p := mustNew(t, &cli)
 	_, err := p.Parse([]string{"--value=hello"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, 10, int(cli.Value))
+	assert.Equal(t, 10, int(cli.Value))
 	_, err = p.Parse([]string{"--value=other"})
-	require.Error(t, err)
+	assert.Error(t, err)
 }
 
 type jsonUnmarshalerValue string
@@ -74,8 +73,8 @@ func TestJSONUnmarshaler(t *testing.T) {
 	}
 	p := mustNew(t, &cli)
 	_, err := p.Parse([]string{"--value=\"hello\""})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "HELLO", string(cli.Value))
+	assert.Equal(t, "HELLO", string(cli.Value))
 }
 
 func TestNamedMapper(t *testing.T) {
@@ -84,11 +83,11 @@ func TestNamedMapper(t *testing.T) {
 	}
 	k := mustNew(t, &cli, kong.NamedMapper("moo", testMooMapper{}))
 	_, err := k.Parse(nil)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "", cli.Flag)
+	assert.Equal(t, "", cli.Flag)
 	_, err = k.Parse([]string{"--flag"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "MOO", cli.Flag)
+	assert.Equal(t, "MOO", cli.Flag)
 }
 
 type testMooMapper struct {
@@ -111,11 +110,11 @@ func TestTimeMapper(t *testing.T) {
 	}
 	k := mustNew(t, &cli)
 	_, err := k.Parse([]string{"--flag=2008"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	expected, err := time.Parse("2006", "2008")
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, 2008, expected.Year())
+	assert.Equal(t, 2008, expected.Year())
-	require.Equal(t, expected, cli.Flag)
+	assert.Equal(t, expected, cli.Flag)
 }
 
 func TestDurationMapper(t *testing.T) {
@@ -124,8 +123,8 @@ func TestDurationMapper(t *testing.T) {
 	}
 	k := mustNew(t, &cli)
 	_, err := k.Parse([]string{"--flag=5s"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, time.Second*5, cli.Flag)
+	assert.Equal(t, time.Second*5, cli.Flag)
 }
 
 func TestDurationMapperJSONResolver(t *testing.T) {
@@ -133,23 +132,23 @@ func TestDurationMapperJSONResolver(t *testing.T) {
 		Flag time.Duration
 	}
 	resolver, err := kong.JSON(strings.NewReader(`{"flag": 5000000000}`))
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	k := mustNew(t, &cli, kong.Resolvers(resolver))
 	_, err = k.Parse(nil)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, time.Second*5, cli.Flag)
+	assert.Equal(t, time.Second*5, cli.Flag)
 }
 
 func TestSplitEscaped(t *testing.T) {
-	require.Equal(t, []string{"a", "b"}, kong.SplitEscaped("a,b", ','))
+	assert.Equal(t, []string{"a", "b"}, kong.SplitEscaped("a,b", ','))
-	require.Equal(t, []string{"a,b", "c"}, kong.SplitEscaped(`a\,b,c`, ','))
+	assert.Equal(t, []string{"a,b", "c"}, kong.SplitEscaped(`a\,b,c`, ','))
-	require.Equal(t, []string{"a,b,c"}, kong.SplitEscaped(`a,b,c`, -1))
+	assert.Equal(t, []string{"a,b,c"}, kong.SplitEscaped(`a,b,c`, -1))
 }
 
 func TestJoinEscaped(t *testing.T) {
-	require.Equal(t, `a,b`, kong.JoinEscaped([]string{"a", "b"}, ','))
+	assert.Equal(t, `a,b`, kong.JoinEscaped([]string{"a", "b"}, ','))
-	require.Equal(t, `a\,b,c`, kong.JoinEscaped([]string{`a,b`, `c`}, ','))
+	assert.Equal(t, `a\,b,c`, kong.JoinEscaped([]string{`a,b`, `c`}, ','))
-	require.Equal(t, kong.JoinEscaped(kong.SplitEscaped(`a\,b,c`, ','), ','), `a\,b,c`)
+	assert.Equal(t, kong.JoinEscaped(kong.SplitEscaped(`a\,b,c`, ','), ','), `a\,b,c`)
 }
 
 func TestMapWithNamedTypes(t *testing.T) {
@@ -159,11 +158,11 @@ func TestMapWithNamedTypes(t *testing.T) {
 	}
 	k := mustNew(t, &cli, kong.NamedMapper("moo", testMooMapper{}), kong.NamedMapper("upper", testUppercaseMapper{}))
 	_, err := k.Parse([]string{"--typed-value", "first=5s", "--typed-value", "second=10s"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, map[string]string{"first": "MOO", "second": "MOO"}, cli.TypedValue)
+	assert.Equal(t, map[string]string{"first": "MOO", "second": "MOO"}, cli.TypedValue)
 	_, err = k.Parse([]string{"--typed-key", "first=5s", "--typed-key", "second=10s"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, map[string]string{"FIRST": "5s", "SECOND": "10s"}, cli.TypedKey)
+	assert.Equal(t, map[string]string{"FIRST": "5s", "SECOND": "10s"}, cli.TypedKey)
 }
 
 func TestMapWithMultipleValues(t *testing.T) {
@@ -172,8 +171,8 @@ func TestMapWithMultipleValues(t *testing.T) {
 	}
 	k := mustNew(t, &cli)
 	_, err := k.Parse([]string{"--value=a=b;c=d"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, map[string]string{"a": "b", "c": "d"}, cli.Value)
+	assert.Equal(t, map[string]string{"a": "b", "c": "d"}, cli.Value)
 }
 
 func TestMapWithDifferentSeparator(t *testing.T) {
@@ -182,8 +181,8 @@ func TestMapWithDifferentSeparator(t *testing.T) {
 	}
 	k := mustNew(t, &cli)
 	_, err := k.Parse([]string{"--value=a=b,c=d"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, map[string]string{"a": "b", "c": "d"}, cli.Value)
+	assert.Equal(t, map[string]string{"a": "b", "c": "d"}, cli.Value)
 }
 
 func TestMapWithNoSeparator(t *testing.T) {
@@ -193,9 +192,9 @@ func TestMapWithNoSeparator(t *testing.T) {
 	}
 	k := mustNew(t, &cli)
 	_, err := k.Parse([]string{"--slice=a,n,c", "--value=a=b;n=d"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, []string{"a,n,c"}, cli.Slice)
+	assert.Equal(t, []string{"a,n,c"}, cli.Slice)
-	require.Equal(t, map[string]string{"a": "b;n=d"}, cli.Value)
+	assert.Equal(t, map[string]string{"a": "b;n=d"}, cli.Value)
 }
 
 func TestURLMapper(t *testing.T) {
@@ -204,10 +203,10 @@ func TestURLMapper(t *testing.T) {
 	}
 	p := mustNew(t, &cli)
 	_, err := p.Parse([]string{"http://w3.org"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "http://w3.org", cli.URL.String())
+	assert.Equal(t, "http://w3.org", cli.URL.String())
 	_, err = p.Parse([]string{":foo"})
-	require.Error(t, err)
+	assert.Error(t, err)
 }
 
 func TestSliceConsumesRemainingPositionalArgs(t *testing.T) {
@@ -216,8 +215,8 @@ func TestSliceConsumesRemainingPositionalArgs(t *testing.T) {
 	}
 	p := mustNew(t, &cli)
 	_, err := p.Parse([]string{"--", "ls", "-lart"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, []string{"ls", "-lart"}, cli.Remainder)
+	assert.Equal(t, []string{"ls", "-lart"}, cli.Remainder)
 }
 
 func TestPassthroughStopsParsing(t *testing.T) {
@@ -231,16 +230,16 @@ func TestPassthroughStopsParsing(t *testing.T) {
 	p := mustNew(t, &actual)
 
 	_, err := p.Parse([]string{"alpine", "sudo", "-i", "true"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, cli{
+	assert.Equal(t, cli{
 		Interactive: false,
 		Image:       "alpine",
 		Argv:        []string{"sudo", "-i", "true"},
 	}, actual)
 
 	_, err = p.Parse([]string{"alpine", "-i", "sudo", "-i", "true"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, cli{
+	assert.Equal(t, cli{
 		Interactive: true,
 		Image:       "alpine",
 		Argv:        []string{"sudo", "-i", "true"},
@@ -262,8 +261,8 @@ func TestMapperValue(t *testing.T) {
 	}
 	p := mustNew(t, &cli)
 	_, err := p.Parse([]string{"foo"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "foo", cli.Value.decoded)
+	assert.Equal(t, "foo", cli.Value.decoded)
 }
 
 func TestFileContentFlag(t *testing.T) {
@@ -271,13 +270,13 @@ func TestFileContentFlag(t *testing.T) {
 		File kong.FileContentFlag
 	}
 	f, err := ioutil.TempFile("", "")
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	defer os.Remove(f.Name())
 	fmt.Fprint(f, "hello world")
 	f.Close()
 	_, err = mustNew(t, &cli).Parse([]string{"--file", f.Name()})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, []byte("hello world"), []byte(cli.File))
+	assert.Equal(t, []byte("hello world"), []byte(cli.File))
 }
 
 func TestNamedFileContentFlag(t *testing.T) {
@@ -285,14 +284,14 @@ func TestNamedFileContentFlag(t *testing.T) {
 		File kong.NamedFileContentFlag
 	}
 	f, err := ioutil.TempFile("", "")
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	defer os.Remove(f.Name())
 	fmt.Fprint(f, "hello world")
 	f.Close()
 	_, err = mustNew(t, &cli).Parse([]string{"--file", f.Name()})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, []byte("hello world"), cli.File.Contents)
+	assert.Equal(t, []byte("hello world"), cli.File.Contents)
-	require.Equal(t, f.Name(), cli.File.Filename)
+	assert.Equal(t, f.Name(), cli.File.Filename)
 }
 
 func TestNamedSliceTypesDontHaveEllipsis(t *testing.T) {
@@ -302,11 +301,11 @@ func TestNamedSliceTypesDontHaveEllipsis(t *testing.T) {
 	b := bytes.NewBuffer(nil)
 	parser := mustNew(t, &cli, kong.Writers(b, b), kong.Exit(func(int) { panic("exit") }))
 	// Ensure that --help
-	require.Panics(t, func() {
+	assert.Panics(t, func() {
 		_, err := parser.Parse([]string{"--help"})
-		require.NoError(t, err)
+		assert.NoError(t, err)
 	})
-	require.NotContains(t, b.String(), `--file=FILE-CONTENT-FLAG,...`)
+	assert.NotContains(t, b.String(), `--file=FILE-CONTENT-FLAG,...`)
 }
 
 func TestCounter(t *testing.T) {
@@ -318,24 +317,24 @@ func TestCounter(t *testing.T) {
 	p := mustNew(t, &cli)
 
 	_, err := p.Parse([]string{"--int", "--int", "--int"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, 3, cli.Int)
+	assert.Equal(t, 3, cli.Int)
 
 	_, err = p.Parse([]string{"--int=5"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, 5, cli.Int)
+	assert.Equal(t, 5, cli.Int)
 
 	_, err = p.Parse([]string{"-iii"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, 3, cli.Int)
+	assert.Equal(t, 3, cli.Int)
 
 	_, err = p.Parse([]string{"-uuu"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, uint(3), cli.Uint)
+	assert.Equal(t, uint(3), cli.Uint)
 
 	_, err = p.Parse([]string{"-fff"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, 3., cli.Float)
+	assert.Equal(t, 3., cli.Float)
 }
 
 func TestNumbers(t *testing.T) {
@@ -366,8 +365,8 @@ func TestNumbers(t *testing.T) {
 			"--u-32", fmt.Sprintf("%v", uint32(math.MaxUint32)),
 			"--u-64", fmt.Sprintf("%v", uint64(math.MaxUint64)),
 		})
-		require.NoError(t, err)
+		assert.NoError(t, err)
-		require.Equal(t, CLI{
+		assert.Equal(t, CLI{
 			F32: math.MaxFloat32,
 			F64: math.MaxFloat64,
 			I8:  math.MaxInt8,
@@ -391,8 +390,8 @@ func TestNumbers(t *testing.T) {
 			fmt.Sprintf("--u-32=%v", 0),
 			fmt.Sprintf("--u-64=%v", 0),
 		})
-		require.NoError(t, err)
+		assert.NoError(t, err)
-		require.Equal(t, CLI{
+		assert.Equal(t, CLI{
 			I8:  math.MinInt8,
 			I16: math.MinInt16,
 			I32: math.MinInt32,
@@ -408,19 +407,19 @@ func TestFileMapper(t *testing.T) {
 	var cli CLI
 	p := mustNew(t, &cli)
 	_, err := p.Parse([]string{"testdata/file.txt"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.NotNil(t, cli.File)
+	assert.NotZero(t, cli.File)
 	_ = cli.File.Close()
 	_, err = p.Parse([]string{"testdata/missing.txt"})
-	require.Error(t, err)
+	assert.Error(t, err)
 	if runtime.GOOS == "windows" {
-		require.Contains(t, err.Error(), "missing.txt: The system cannot find the file specified.")
+		assert.Contains(t, err.Error(), "missing.txt: The system cannot find the file specified.")
 	} else {
-		require.Contains(t, err.Error(), "missing.txt: no such file or directory")
+		assert.Contains(t, err.Error(), "missing.txt: no such file or directory")
 	}
 	_, err = p.Parse([]string{"-"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, os.Stdin, cli.File)
+	assert.Equal(t, os.Stdin, cli.File)
 }
 
 //nolint:dupl
@@ -431,16 +430,16 @@ func TestExistingFileMapper(t *testing.T) {
 	var cli CLI
 	p := mustNew(t, &cli)
 	_, err := p.Parse([]string{"--file", "testdata/file.txt"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.NotNil(t, cli.File)
+	assert.NotZero(t, cli.File)
 	p = mustNew(t, &cli)
 	_, err = p.Parse([]string{"--file", "testdata/missing.txt"})
-	require.Error(t, err)
+	assert.Error(t, err)
-	require.Contains(t, err.Error(), "missing.txt: no such file or directory")
+	assert.Contains(t, err.Error(), "missing.txt: no such file or directory")
 	p = mustNew(t, &cli)
 	_, err = p.Parse([]string{"--file", "testdata/"})
-	require.Error(t, err)
+	assert.Error(t, err)
-	require.Contains(t, err.Error(), "exists but is a directory")
+	assert.Contains(t, err.Error(), "exists but is a directory")
 }
 
 func TestExistingFileMapperDefaultMissing(t *testing.T) {
@@ -451,9 +450,9 @@ func TestExistingFileMapperDefaultMissing(t *testing.T) {
 	p := mustNew(t, &cli)
 	file := "testdata/file.txt"
 	_, err := p.Parse([]string{"--file", file})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.NotNil(t, cli.File)
+	assert.NotZero(t, cli.File)
-	require.Contains(t, cli.File, file)
+	assert.Contains(t, cli.File, file)
 }
 
 //nolint:dupl
@@ -464,16 +463,16 @@ func TestExistingDirMapper(t *testing.T) {
 	var cli CLI
 	p := mustNew(t, &cli)
 	_, err := p.Parse([]string{"--dir", "testdata/"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.NotNil(t, cli.Dir)
+	assert.NotZero(t, cli.Dir)
 	p = mustNew(t, &cli)
 	_, err = p.Parse([]string{"--dir", "missingdata/"})
-	require.Error(t, err)
+	assert.Error(t, err)
-	require.Contains(t, err.Error(), "missingdata: no such file or directory")
+	assert.Contains(t, err.Error(), "missingdata: no such file or directory")
 	p = mustNew(t, &cli)
 	_, err = p.Parse([]string{"--dir", "testdata/file.txt"})
-	require.Error(t, err)
+	assert.Error(t, err)
-	require.Contains(t, err.Error(), "exists but is not a directory")
+	assert.Contains(t, err.Error(), "exists but is not a directory")
 }
 
 func TestExistingDirMapperDefaultMissing(t *testing.T) {
@@ -484,9 +483,9 @@ func TestExistingDirMapperDefaultMissing(t *testing.T) {
 	p := mustNew(t, &cli)
 	dir := "testdata"
 	_, err := p.Parse([]string{"--dir", dir})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.NotNil(t, cli.Dir)
+	assert.NotZero(t, cli.Dir)
-	require.Contains(t, cli.Dir, dir)
+	assert.Contains(t, cli.Dir, dir)
 }
 
 func TestMapperPlaceHolder(t *testing.T) {
@@ -502,11 +501,11 @@ func TestMapperPlaceHolder(t *testing.T) {
 		kong.Exit(func(int) { panic("exit") }),
 	)
 	// Ensure that --help
-	require.Panics(t, func() {
+	assert.Panics(t, func() {
 		_, err := k.Parse([]string{"--help"})
-		require.NoError(t, err)
+		assert.NoError(t, err)
 	})
-	require.Contains(t, b.String(), "--flag=/a/b/c")
+	assert.Contains(t, b.String(), "--flag=/a/b/c")
 }
 
 type testMapperWithPlaceHolder struct {
@@ -534,11 +533,12 @@ func TestMapperVarsContributor(t *testing.T) {
 		kong.Exit(func(int) { panic("exit") }),
 	)
 	// Ensure that --help
-	require.Panics(t, func() {
+	assert.Panics(t, func() {
 		_, err := k.Parse([]string{"--help"})
-		require.NoError(t, err)
+		assert.NoError(t, err)
 	})
-	require.Regexp(t, "--flag=STRING\\s+Some help with a var", b.String())
+	assert.Contains(t, b.String(), "--flag=STRING")
+	assert.Contains(t, b.String(), "Some help with a var", b.String())
 }
 
 type testMapperVarsContributor struct{}
@@ -559,13 +559,13 @@ func TestValuesThatLookLikeFlags(t *testing.T) {
 	}
 	k := mustNew(t, &cli)
 	_, err := k.Parse([]string{"--slice", "-foo"})
-	require.Error(t, err)
+	assert.Error(t, err)
 	_, err = k.Parse([]string{"--map", "-foo=-bar"})
-	require.Error(t, err)
+	assert.Error(t, err)
 	_, err = k.Parse([]string{"--slice=-foo", "--slice=-bar"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, []string{"-foo", "-bar"}, cli.Slice)
+	assert.Equal(t, []string{"-foo", "-bar"}, cli.Slice)
 	_, err = k.Parse([]string{"--map=-foo=-bar"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, map[string]string{"-foo": "-bar"}, cli.Map)
+	assert.Equal(t, map[string]string{"-foo": "-bar"}, cli.Map)
 }

mapper_windows_test.go

@@ -7,7 +7,7 @@ import (
 	"os"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	require "github.com/alecthomas/assert/v2"
 )
 
 func TestWindowsPathMapper(t *testing.T) {
@@ -16,13 +16,13 @@ func TestWindowsPathMapper(t *testing.T) {
 		Files []string `short:"f" type:"path"`
 	}
 	wd, err := os.Getwd()
-	require.NoError(t, err, "Getwd failed")
+	assert.NoError(t, err, "Getwd failed")
 	p := mustNew(t, &cli)
 
 	_, err = p.Parse([]string{`-p`, `c:\an\absolute\path`, `-f`, `c:\second\absolute\path\`, `-f`, `relative\path\file`})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, `c:\an\absolute\path`, cli.Path)
+	assert.Equal(t, `c:\an\absolute\path`, cli.Path)
-	require.Equal(t, []string{`c:\second\absolute\path\`, wd + `\relative\path\file`}, cli.Files)
+	assert.Equal(t, []string{`c:\second\absolute\path\`, wd + `\relative\path\file`}, cli.Files)
 }
 
 func TestWindowsFileMapper(t *testing.T) {
@@ -32,13 +32,13 @@ func TestWindowsFileMapper(t *testing.T) {
 	var cli CLI
 	p := mustNew(t, &cli)
 	_, err := p.Parse([]string{"testdata\\file.txt"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.NotNil(t, cli.File)
+	assert.NotNil(t, cli.File)
 	_ = cli.File.Close()
 	_, err = p.Parse([]string{"testdata\\missing.txt"})
-	require.Error(t, err)
+	assert.Error(t, err)
-	require.Contains(t, err.Error(), "missing.txt: The system cannot find the file specified.")
+	assert.Contains(t, err.Error(), "missing.txt: The system cannot find the file specified.")
 	_, err = p.Parse([]string{"-"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, os.Stdin, cli.File)
+	assert.Equal(t, os.Stdin, cli.File)
 }

model_test.go

@@ -3,7 +3,7 @@ package kong_test
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/alecthomas/assert/v2"
 )
 
 func TestModelApplicationCommands(t *testing.T) {
@@ -23,7 +23,7 @@ func TestModelApplicationCommands(t *testing.T) {
 	for _, cmd := range p.Model.Leaves(false) {
 		actual = append(actual, cmd.Path())
 	}
-	require.Equal(t, []string{"one two", "one three <four>"}, actual)
+	assert.Equal(t, []string{"one two", "one three <four>"}, actual)
 }
 
 func TestFlagString(t *testing.T) {
@@ -66,7 +66,7 @@ func TestFlagString(t *testing.T) {
 	p := mustNew(t, &cli)
 	for _, flag := range p.Model.Flags {
 		want, ok := tests[flag.Name]
-		require.Truef(t, ok, "unknown flag name: %s", flag.Name)
+		assert.True(t, ok, "unknown flag name: %s", flag.Name)
-		require.Equal(t, want, flag.String())
+		assert.Equal(t, want, flag.String())
 	}
 }

options_test.go

@@ -4,18 +4,18 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/alecthomas/assert/v2"
 )
 
 func TestOptions(t *testing.T) {
 	var cli struct{}
 	p, err := New(&cli, Name("name"), Description("description"), Writers(nil, nil), Exit(nil))
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "name", p.Model.Name)
+	assert.Equal(t, "name", p.Model.Name)
-	require.Equal(t, "description", p.Model.Help)
+	assert.Equal(t, "description", p.Model.Help)
-	require.Nil(t, p.Stdout)
+	assert.Zero(t, p.Stdout)
-	require.Nil(t, p.Stderr)
+	assert.Zero(t, p.Stderr)
-	require.Nil(t, p.Exit)
+	assert.Zero(t, p.Exit)
 }
 
 type impl string
@@ -29,17 +29,17 @@ func TestBindTo(t *testing.T) {
 
 	saw := ""
 	method := func(i iface) error {
-		saw = string(i.(impl))
+		saw = string(i.(impl)) // nolint
 		return nil
 	}
 
 	var cli struct{}
 
 	p, err := New(&cli, BindTo(impl("foo"), (*iface)(nil)))
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	err = callMethod("method", reflect.ValueOf(impl("??")), reflect.ValueOf(method), p.bindings)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "foo", saw)
+	assert.Equal(t, "foo", saw)
 }
 
 func TestInvalidCallback(t *testing.T) {
@@ -49,16 +49,16 @@ func TestInvalidCallback(t *testing.T) {
 
 	saw := ""
 	method := func(i iface) string {
-		saw = string(i.(impl))
+		saw = string(i.(impl)) // nolint
 		return saw
 	}
 
 	var cli struct{}
 
 	p, err := New(&cli, BindTo(impl("foo"), (*iface)(nil)))
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	err = callMethod("method", reflect.ValueOf(impl("??")), reflect.ValueOf(method), p.bindings)
-	require.EqualError(t, err, `return value of *reflect.rtype.method() must implement "error"`)
+	assert.EqualError(t, err, `return value of *reflect.rtype.method() must implement "error"`)
 }
 
 type zrror struct{}
@@ -74,17 +74,17 @@ func TestCallbackCustomError(t *testing.T) {
 
 	saw := ""
 	method := func(i iface) *zrror {
-		saw = string(i.(impl))
+		saw = string(i.(impl)) // nolint
 		return nil
 	}
 
 	var cli struct{}
 
 	p, err := New(&cli, BindTo(impl("foo"), (*iface)(nil)))
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	err = callMethod("method", reflect.ValueOf(impl("??")), reflect.ValueOf(method), p.bindings)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "foo", saw)
+	assert.Equal(t, "foo", saw)
 }
 
 type bindToProviderCLI struct {
@@ -105,10 +105,10 @@ func (*bindToProviderCmd) Run(cli *bindToProviderCLI, b *boundThing) error {
 func TestBindToProvider(t *testing.T) {
 	var cli bindToProviderCLI
 	app, err := New(&cli, BindToProvider(func() (*boundThing, error) { return &boundThing{}, nil }))
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	ctx, err := app.Parse([]string{"cmd"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	err = ctx.Run()
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.True(t, cli.Called)
+	assert.True(t, cli.Called)
 }

resolver_test.go

@@ -7,8 +7,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/alecthomas/assert/v2"
-
 	"github.com/alecthomas/kong"
 )
 
@@ -53,10 +52,10 @@ func TestEnvarsFlagBasic(t *testing.T) {
 	defer unsetEnvs()
 
 	_, err := parser.Parse([]string{})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "bye", cli.String)
+	assert.Equal(t, "bye", cli.String)
-	require.Equal(t, []int{5, 2, 9}, cli.Slice)
+	assert.Equal(t, []int{5, 2, 9}, cli.Slice)
-	require.Equal(t, "foo", cli.Interp)
+	assert.Equal(t, "foo", cli.Interp)
 }
 
 func TestEnvarsFlagOverride(t *testing.T) {
@@ -67,8 +66,8 @@ func TestEnvarsFlagOverride(t *testing.T) {
 	defer restoreEnv()
 
 	_, err := parser.Parse([]string{"--flag=hello"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "hello", cli.Flag)
+	assert.Equal(t, "hello", cli.Flag)
 }
 
 func TestEnvarsTag(t *testing.T) {
@@ -79,8 +78,8 @@ func TestEnvarsTag(t *testing.T) {
 	defer restoreEnv()
 
 	_, err := parser.Parse([]string{})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, []int{5, 2, 9}, cli.Slice)
+	assert.Equal(t, []int{5, 2, 9}, cli.Slice)
 }
 
 func TestEnvarsEnvPrefix(t *testing.T) {
@@ -94,8 +93,8 @@ func TestEnvarsEnvPrefix(t *testing.T) {
 	defer restoreEnv()
 
 	_, err := parser.Parse([]string{})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, []int{1, 2, 3}, cli.Slice)
+	assert.Equal(t, []int{1, 2, 3}, cli.Slice)
 }
 
 func TestEnvarsNestedEnvPrefix(t *testing.T) {
@@ -112,8 +111,8 @@ func TestEnvarsNestedEnvPrefix(t *testing.T) {
 	defer restoreEnv()
 
 	_, err := parser.Parse([]string{})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "abc", cli.String)
+	assert.Equal(t, "abc", cli.String)
 }
 
 func TestEnvarsWithDefault(t *testing.T) {
@@ -124,14 +123,14 @@ func TestEnvarsWithDefault(t *testing.T) {
 	defer restoreEnv()
 
 	_, err := parser.Parse(nil)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "default", cli.Flag)
+	assert.Equal(t, "default", cli.Flag)
 
 	parser, restoreEnv = newEnvParser(t, &cli, envMap{"KONG_FLAG": "moo"})
 	defer restoreEnv()
 	_, err = parser.Parse(nil)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "moo", cli.Flag)
+	assert.Equal(t, "moo", cli.Flag)
 }
 
 func TestEnv(t *testing.T) {
@@ -169,8 +168,8 @@ func TestEnv(t *testing.T) {
 	defer unsetEnvs()
 
 	_, err := parser.Parse(nil)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, expected, cli)
+	assert.Equal(t, expected, cli)
 
 	// Without the prefix
 	parser, unsetEnvs = newEnvParser(t, &cli, envMap{
@@ -184,8 +183,8 @@ func TestEnv(t *testing.T) {
 	defer unsetEnvs()
 
 	_, err = parser.Parse(nil)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, expected, cli)
+	assert.Equal(t, expected, cli)
 }
 
 func TestJSONBasic(t *testing.T) {
@@ -215,17 +214,17 @@ func TestJSONBasic(t *testing.T) {
 	}`
 
 	r, err := kong.JSON(strings.NewReader(json))
-	require.NoError(t, err)
+	assert.NoError(t, err)
 
 	parser := mustNew(t, &cli, kong.Resolvers(r))
 	_, err = parser.Parse([]string{})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "🍕", cli.String)
+	assert.Equal(t, "🍕", cli.String)
-	require.Equal(t, []int{5, 8}, cli.Slice)
+	assert.Equal(t, []int{5, 8}, cli.Slice)
-	require.Equal(t, []string{"a,b", "c"}, cli.SliceWithCommas)
+	assert.Equal(t, []string{"a,b", "c"}, cli.SliceWithCommas)
-	require.Equal(t, "one value", cli.One.String)
+	assert.Equal(t, "one value", cli.One.String)
-	require.Equal(t, "two value", cli.Two.String)
+	assert.Equal(t, "two value", cli.Two.String)
-	require.True(t, cli.Bool)
+	assert.True(t, cli.Bool)
 }
 
 type testUppercaseMapper struct{}
@@ -252,8 +251,8 @@ func TestResolversWithMappers(t *testing.T) {
 		kong.NamedMapper("upper", testUppercaseMapper{}),
 	)
 	_, err := parser.Parse([]string{})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "MEOW", cli.Flag)
+	assert.Equal(t, "MEOW", cli.Flag)
 }
 
 func TestResolverWithBool(t *testing.T) {
@@ -271,8 +270,8 @@ func TestResolverWithBool(t *testing.T) {
 	p := mustNew(t, &cli, kong.Resolvers(resolver))
 
 	_, err := p.Parse(nil)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.True(t, cli.Bool)
+	assert.True(t, cli.Bool)
 }
 
 func TestLastResolverWins(t *testing.T) {
@@ -296,8 +295,8 @@ func TestLastResolverWins(t *testing.T) {
 
 	p := mustNew(t, &cli, kong.Resolvers(first, second))
 	_, err := p.Parse(nil)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, []int{2}, cli.Int)
+	assert.Equal(t, []int{2}, cli.Int)
 }
 
 func TestResolverSatisfiesRequired(t *testing.T) {
@@ -311,8 +310,8 @@ func TestResolverSatisfiesRequired(t *testing.T) {
 		return nil, nil
 	}
 	_, err := mustNew(t, &cli, kong.Resolvers(resolver)).Parse(nil)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, 1, cli.Int)
+	assert.Equal(t, 1, cli.Int)
 }
 
 func TestResolverTriggersHooks(t *testing.T) {
@@ -330,10 +329,10 @@ func TestResolverTriggersHooks(t *testing.T) {
 	}
 
 	_, err := mustNew(t, &cli, kong.Bind(ctx), kong.Resolvers(first)).Parse(nil)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 
-	require.Equal(t, "one", string(cli.Flag))
+	assert.Equal(t, "one", string(cli.Flag))
-	require.Equal(t, []string{"before:", "after:one"}, ctx.values)
+	assert.Equal(t, []string{"before:", "after:one"}, ctx.values)
 }
 
 type validatingResolver struct {
@@ -349,5 +348,5 @@ func TestValidatingResolverErrors(t *testing.T) {
 	resolver := &validatingResolver{err: errors.New("invalid")}
 	var cli struct{}
 	_, err := mustNew(t, &cli, kong.Resolvers(resolver)).Parse(nil)
-	require.EqualError(t, err, "invalid")
+	assert.EqualError(t, err, "invalid")
 }

scanner_test.go

@@ -3,26 +3,26 @@ package kong
 import (
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/alecthomas/assert/v2"
 )
 
 func TestScannerTake(t *testing.T) {
 	s := Scan("a", "b", "c", "-")
-	require.Equal(t, "a", s.Pop().Value)
+	assert.Equal(t, "a", s.Pop().Value)
-	require.Equal(t, "b", s.Pop().Value)
+	assert.Equal(t, "b", s.Pop().Value)
-	require.Equal(t, "c", s.Pop().Value)
+	assert.Equal(t, "c", s.Pop().Value)
 	hyphen := s.Pop()
-	require.Equal(t, PositionalArgumentToken, hyphen.InferredType())
+	assert.Equal(t, PositionalArgumentToken, hyphen.InferredType())
-	require.Equal(t, EOLToken, s.Pop().Type)
+	assert.Equal(t, EOLToken, s.Pop().Type)
 }
 
 func TestScannerPeek(t *testing.T) {
 	s := Scan("a", "b", "c")
-	require.Equal(t, s.Peek().Value, "a")
+	assert.Equal(t, s.Peek().Value, "a")
-	require.Equal(t, s.Pop().Value, "a")
+	assert.Equal(t, s.Pop().Value, "a")
-	require.Equal(t, s.Peek().Value, "b")
+	assert.Equal(t, s.Peek().Value, "b")
-	require.Equal(t, s.Pop().Value, "b")
+	assert.Equal(t, s.Pop().Value, "b")
-	require.Equal(t, s.Peek().Value, "c")
+	assert.Equal(t, s.Peek().Value, "c")
-	require.Equal(t, s.Pop().Value, "c")
+	assert.Equal(t, s.Pop().Value, "c")
-	require.Equal(t, s.Peek().Type, EOLToken)
+	assert.Equal(t, s.Peek().Type, EOLToken)
 }

tag_test.go

@@ -4,8 +4,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/alecthomas/assert/v2"
-
 	"github.com/alecthomas/kong"
 )
 
@@ -15,8 +14,8 @@ func TestDefaultValueForOptionalArg(t *testing.T) {
 	}
 	p := mustNew(t, &cli)
 	_, err := p.Parse(nil)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "👌", cli.Arg)
+	assert.Equal(t, "👌", cli.Arg)
 }
 
 func TestNoValueInTag(t *testing.T) {
@@ -26,9 +25,9 @@ func TestNoValueInTag(t *testing.T) {
 	}
 	p := mustNew(t, &cli)
 	_, err := p.Parse(nil)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "", cli.Empty1)
+	assert.Equal(t, "", cli.Empty1)
-	require.Equal(t, "", cli.Empty2)
+	assert.Equal(t, "", cli.Empty2)
 }
 
 func TestCommaInQuotes(t *testing.T) {
@@ -37,8 +36,8 @@ func TestCommaInQuotes(t *testing.T) {
 	}
 	p := mustNew(t, &cli)
 	_, err := p.Parse(nil)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "1,2", cli.Numbers)
+	assert.Equal(t, "1,2", cli.Numbers)
 }
 
 func TestBadString(t *testing.T) {
@@ -46,7 +45,7 @@ func TestBadString(t *testing.T) {
 		Numbers string `kong:"default='yay'n"`
 	}
 	_, err := kong.New(&cli)
-	require.Error(t, err)
+	assert.Error(t, err)
 }
 
 func TestNoQuoteEnd(t *testing.T) {
@@ -54,7 +53,7 @@ func TestNoQuoteEnd(t *testing.T) {
 		Numbers string `kong:"default='yay"`
 	}
 	_, err := kong.New(&cli)
-	require.Error(t, err)
+	assert.Error(t, err)
 }
 
 func TestEscapedQuote(t *testing.T) {
@@ -63,8 +62,8 @@ func TestEscapedQuote(t *testing.T) {
 	}
 	p := mustNew(t, &cli)
 	_, err := p.Parse(nil)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "i don't know", cli.DoYouKnow)
+	assert.Equal(t, "i don't know", cli.DoYouKnow)
 }
 
 func TestBareTags(t *testing.T) {
@@ -77,9 +76,9 @@ func TestBareTags(t *testing.T) {
 
 	p := mustNew(t, &cli)
 	_, err := p.Parse([]string{"cmd", "arg", "--flag=hi"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "hi", cli.Cmd.Flag)
+	assert.Equal(t, "hi", cli.Cmd.Flag)
-	require.Equal(t, "arg", cli.Cmd.Arg)
+	assert.Equal(t, "arg", cli.Cmd.Arg)
 }
 
 func TestBareTagsWithJsonTag(t *testing.T) {
@@ -92,9 +91,9 @@ func TestBareTagsWithJsonTag(t *testing.T) {
 
 	p := mustNew(t, &cli)
 	_, err := p.Parse([]string{"cmd"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "\"'👌'\"", cli.Cmd.Flag)
+	assert.Equal(t, "\"'👌'\"", cli.Cmd.Flag)
-	require.Equal(t, "", cli.Cmd.Arg)
+	assert.Equal(t, "", cli.Cmd.Arg)
 }
 
 func TestManySeps(t *testing.T) {
@@ -104,8 +103,8 @@ func TestManySeps(t *testing.T) {
 
 	p := mustNew(t, &cli)
 	_, err := p.Parse([]string{})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "hi", cli.Arg)
+	assert.Equal(t, "hi", cli.Arg)
 }
 
 func TestTagSetOnEmbeddedStruct(t *testing.T) {
@@ -118,8 +117,8 @@ func TestTagSetOnEmbeddedStruct(t *testing.T) {
 	buf := &strings.Builder{}
 	p := mustNew(t, &cli, kong.Writers(buf, buf), kong.Exit(func(int) {}))
 	_, err := p.Parse([]string{"--help"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Contains(t, buf.String(), `A key from somewhere.`)
+	assert.Contains(t, buf.String(), `A key from somewhere.`)
 }
 
 func TestTagSetOnCommand(t *testing.T) {
@@ -132,8 +131,8 @@ func TestTagSetOnCommand(t *testing.T) {
 	buf := &strings.Builder{}
 	p := mustNew(t, &cli, kong.Writers(buf, buf), kong.Exit(func(int) {}))
 	_, err := p.Parse([]string{"command", "--help"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Contains(t, buf.String(), `A key from somewhere.`)
+	assert.Contains(t, buf.String(), `A key from somewhere.`)
 }
 
 func TestTagSetOnFlag(t *testing.T) {
@@ -143,8 +142,8 @@ func TestTagSetOnFlag(t *testing.T) {
 	buf := &strings.Builder{}
 	p := mustNew(t, &cli, kong.Writers(buf, buf), kong.Exit(func(int) {}))
 	_, err := p.Parse([]string{"--help"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Contains(t, buf.String(), `A key from somewhere.`)
+	assert.Contains(t, buf.String(), `A key from somewhere.`)
 }
 
 func TestTagAliases(t *testing.T) {
@@ -156,11 +155,11 @@ func TestTagAliases(t *testing.T) {
 	}
 	p := mustNew(t, &cli)
 	_, err := p.Parse([]string{"alias1", "arg"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "arg", cli.Cmd.Arg)
+	assert.Equal(t, "arg", cli.Cmd.Arg)
 	_, err = p.Parse([]string{"alias2", "arg"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "arg", cli.Cmd.Arg)
+	assert.Equal(t, "arg", cli.Cmd.Arg)
 }
 
 func TestTagAliasesConflict(t *testing.T) {
@@ -173,8 +172,8 @@ func TestTagAliasesConflict(t *testing.T) {
 	}
 	p := mustNew(t, &cli)
 	_, err := p.Parse([]string{"other-cmd", "arg"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "arg", cli.OtherCmd.Arg)
+	assert.Equal(t, "arg", cli.OtherCmd.Arg)
 }
 
 func TestTagAliasesSub(t *testing.T) {
@@ -189,8 +188,8 @@ func TestTagAliasesSub(t *testing.T) {
 	}
 	p := mustNew(t, &cli)
 	_, err := p.Parse([]string{"cmd", "other-sub-cmd", "arg"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "arg", cli.Cmd.SubCmd.Arg)
+	assert.Equal(t, "arg", cli.Cmd.SubCmd.Arg)
 }
 
 func TestInvalidRuneErrors(t *testing.T) {
@@ -198,5 +197,5 @@ func TestInvalidRuneErrors(t *testing.T) {
 		Flag bool `short:"invalid"`
 	}{}
 	_, err := kong.New(&cli)
-	require.EqualError(t, err, "<anonymous struct>.Flag: invalid short flag name \"invalid\": invalid rune")
+	assert.EqualError(t, err, "<anonymous struct>.Flag: invalid short flag name \"invalid\": invalid rune")
 }

util.go

@@ -17,7 +17,7 @@ func (c ConfigFlag) BeforeResolve(kong *Kong, ctx *Context, trace *Path) error {
 	if kong.loader == nil {
 		return fmt.Errorf("kong must be configured with kong.Configuration(...)")
 	}
-	path := string(ctx.FlagValue(trace.Flag).(ConfigFlag))
+	path := string(ctx.FlagValue(trace.Flag).(ConfigFlag)) // nolint
 	resolver, err := kong.LoadConfig(path)
 	if err != nil {
 		return err

util_test.go

@@ -8,7 +8,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/alecthomas/assert/v2"
 )
 
 func TestConfigFlag(t *testing.T) {
@@ -18,15 +18,15 @@ func TestConfigFlag(t *testing.T) {
 	}
 
 	w, err := ioutil.TempFile("", "")
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	defer os.Remove(w.Name())
 	w.WriteString(`{"flag": "hello world"}`) // nolint: errcheck
 	w.Close()
 
 	p := Must(&cli, Configuration(JSON))
 	_, err = p.Parse([]string{"--config", w.Name()})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "hello world", cli.Flag)
+	assert.Equal(t, "hello world", cli.Flag)
 }
 
 func TestVersionFlag(t *testing.T) {
@@ -40,20 +40,20 @@ func TestVersionFlag(t *testing.T) {
 	p.Exit = func(s int) { called = s }
 
 	_, err := p.Parse([]string{"--version"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, "0.1.1", strings.TrimSpace(w.String()))
+	assert.Equal(t, "0.1.1", strings.TrimSpace(w.String()))
-	require.Equal(t, 0, called)
+	assert.Equal(t, 0, called)
 }
 
 func TestChangeDirFlag(t *testing.T) {
 	cwd, err := os.Getwd()
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	defer os.Chdir(cwd) // nolint: errcheck
 
 	dir := t.TempDir()
 	file := filepath.Join(dir, "out.txt")
 	err = os.WriteFile(file, []byte("foobar"), 0o600)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 
 	var cli struct {
 		ChangeDir ChangeDirFlag `short:"C"`
@@ -62,10 +62,10 @@ func TestChangeDirFlag(t *testing.T) {
 
 	p := Must(&cli)
 	_, err = p.Parse([]string{"-C", dir, "out.txt"})
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	if runtime.GOOS != "windows" {
 		file, err = filepath.EvalSymlinks(file) // Needed because OSX uses a symlinked tmp dir.
-		require.NoError(t, err)
+		assert.NoError(t, err)
 	}
-	require.Equal(t, file, cli.Path)
+	assert.Equal(t, file, cli.Path)
 }