diff --git a/argument_config_validation_test.go b/argument_config_validation_test.go
index 7fe9ed7..6e7dabb 100644
--- a/argument_config_validation_test.go
+++ b/argument_config_validation_test.go
@@ -3,25 +3,25 @@ package cli
 import (
 	"testing"
 
-	"github.com/broothie/test"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestArgument_validateConfig(t *testing.T) {
 	t.Run("empty name", func(t *testing.T) {
 		arg := &Argument{name: ""}
 		err := arg.validateConfig()
-		test.ErrorMessageIs(t, err, "argument name cannot be empty")
+		assert.EqualError(t, err, "argument name cannot be empty")
 	})
 
 	t.Run("multiple tokens", func(t *testing.T) {
 		arg := &Argument{name: "invalid argument name"}
 		err := arg.validateConfig()
-		test.ErrorMessageIs(t, err, `argument name "invalid argument name" must be a single token`)
+		assert.EqualError(t, err, `argument name "invalid argument name" must be a single token`)
 	})
 
 	t.Run("valid name", func(t *testing.T) {
 		arg := &Argument{name: "valid-arg"}
 		err := arg.validateConfig()
-		test.NoError(t, err)
+		assert.NoError(t, err)
 	})
 }
diff --git a/argument_input_validation_test.go b/argument_input_validation_test.go
index 2cf44a1..760269e 100644
--- a/argument_input_validation_test.go
+++ b/argument_input_validation_test.go
@@ -3,15 +3,16 @@ package cli
 import (
 	"testing"
 
-	"github.com/broothie/test"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestArgument_validateInput(t *testing.T) {
 	arg, err := newArgument("test-arg", "Test arg.")
-	test.MustNoError(t, err)
+	require.NoError(t, err)
 
-	test.ErrorMessageIs(t, arg.validateInput(), `argument "test-arg": argument missing value`)
+	assert.EqualError(t, arg.validateInput(), `argument "test-arg": argument missing value`)
 
 	arg.value = "something"
-	test.NoError(t, arg.validateInput())
+	assert.NoError(t, arg.validateInput())
 }
diff --git a/cli_test.go b/cli_test.go
index 90117d1..3795f3f 100644
--- a/cli_test.go
+++ b/cli_test.go
@@ -4,13 +4,13 @@ import (
 	"context"
 	"testing"
 
-	"github.com/broothie/test"
 	"github.com/samber/lo"
+	"github.com/stretchr/testify/assert"
 )
 
 func ensureCalled(t *testing.T) func() {
 	called := false
-	t.Cleanup(func() { test.True(t, called) })
+	t.Cleanup(func() { assert.True(t, called) })
 
 	return func() { called = true }
 }
@@ -42,8 +42,8 @@ func Test_git(t *testing.T) {
 					called()
 
 					gitDir, err := FlagValue[string](ctx, "git-dir")
-					test.NoError(t, err)
-					test.Equal(t, "/path/to/something", gitDir)
+					assert.NoError(t, err)
+					assert.Equal(t, "/path/to/something", gitDir)
 
 					return nil
 				}
@@ -57,8 +57,8 @@ func Test_git(t *testing.T) {
 					called()
 
 					gitDir, err := FlagValue[string](ctx, "git-dir")
-					test.NoError(t, err)
-					test.Equal(t, "/path/to/something", gitDir)
+					assert.NoError(t, err)
+					assert.Equal(t, "/path/to/something", gitDir)
 
 					return nil
 				}
@@ -82,8 +82,8 @@ func Test_git(t *testing.T) {
 					called()
 
 					message, err := FlagValue[string](ctx, "message")
-					test.NoError(t, err)
-					test.Equal(t, "a commit message", message)
+					assert.NoError(t, err)
+					assert.Equal(t, "a commit message", message)
 
 					return nil
 				}
@@ -97,12 +97,12 @@ func Test_git(t *testing.T) {
 					called()
 
 					isAll, err := FlagValue[bool](ctx, "all")
-					test.NoError(t, err)
-					test.False(t, isAll)
+					assert.NoError(t, err)
+					assert.False(t, isAll)
 
 					message, err := FlagValue[string](ctx, "message")
-					test.NoError(t, err)
-					test.Equal(t, "a commit message", message)
+					assert.NoError(t, err)
+					assert.Equal(t, "a commit message", message)
 
 					return nil
 				}
@@ -116,12 +116,12 @@ func Test_git(t *testing.T) {
 					called()
 
 					isAll, err := FlagValue[bool](ctx, "all")
-					test.NoError(t, err)
-					test.False(t, isAll)
+					assert.NoError(t, err)
+					assert.False(t, isAll)
 
 					message, err := FlagValue[string](ctx, "message")
-					test.NoError(t, err)
-					test.Equal(t, "a commit message", message)
+					assert.NoError(t, err)
+					assert.Equal(t, "a commit message", message)
 
 					return nil
 				}
@@ -135,12 +135,12 @@ func Test_git(t *testing.T) {
 					called()
 
 					isAll, err := FlagValue[bool](ctx, "all")
-					test.NoError(t, err)
-					test.True(t, isAll)
+					assert.NoError(t, err)
+					assert.True(t, isAll)
 
 					message, err := FlagValue[string](ctx, "message")
-					test.NoError(t, err)
-					test.Equal(t, "a commit message", message)
+					assert.NoError(t, err)
+					assert.Equal(t, "a commit message", message)
 
 					return nil
 				}
@@ -154,8 +154,8 @@ func Test_git(t *testing.T) {
 					called()
 
 					branch, err := ArgValue[string](ctx, "branch")
-					test.NoError(t, err)
-					test.Equal(t, "some-branch", branch)
+					assert.NoError(t, err)
+					assert.Equal(t, "some-branch", branch)
 
 					return nil
 				}
@@ -169,12 +169,12 @@ func Test_git(t *testing.T) {
 					called()
 
 					branch, err := ArgValue[string](ctx, "branch")
-					test.NoError(t, err)
-					test.Equal(t, "some-branch", branch)
+					assert.NoError(t, err)
+					assert.Equal(t, "some-branch", branch)
 
 					isNewBranch, err := FlagValue[bool](ctx, "new-branch")
-					test.NoError(t, err)
-					test.True(t, isNewBranch)
+					assert.NoError(t, err)
+					assert.True(t, isNewBranch)
 
 					return nil
 				}
@@ -188,8 +188,8 @@ func Test_git(t *testing.T) {
 					called()
 
 					globalGitignore, err := FlagValue[string](ctx, "global-gitignore")
-					test.NoError(t, err)
-					test.Equal(t, globalGitignore, "path/to/some/.gitignore")
+					assert.NoError(t, err)
+					assert.Equal(t, globalGitignore, "path/to/some/.gitignore")
 					return nil
 				}
 			},
@@ -228,8 +228,8 @@ func Test_git(t *testing.T) {
 				SetHandler(lo.IfF(testCase.gitHandler != nil, func() Handler { return testCase.gitHandler(t) }).Else(nil)),
 			)
 
-			test.NoError(t, err)
-			test.Nil(t, command.Run(context.TODO(), testCase.rawArgs))
+			assert.NoError(t, err)
+			assert.Nil(t, command.Run(context.TODO(), testCase.rawArgs))
 		})
 	}
 }
diff --git a/command_config_validation_test.go b/command_config_validation_test.go
index c27f01b..0aaf4f3 100644
--- a/command_config_validation_test.go
+++ b/command_config_validation_test.go
@@ -4,7 +4,7 @@ import (
 	"testing"
 
 	"github.com/broothie/option"
-	"github.com/broothie/test"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestCommand_config_validations(t *testing.T) {
@@ -47,7 +47,7 @@ func TestCommand_config_validations(t *testing.T) {
 	for name, testCase := range testCases {
 		t.Run(name, func(t *testing.T) {
 			_, err := NewCommand("test", "test command", testCase.commandOptions...)
-			test.ErrorMessageIs(t, err, testCase.expectedError)
+			assert.EqualError(t, err, testCase.expectedError)
 		})
 	}
 }
diff --git a/exit_test.go b/exit_test.go
index 1f07b63..3225d49 100644
--- a/exit_test.go
+++ b/exit_test.go
@@ -5,17 +5,17 @@ import (
 	"os/exec"
 	"testing"
 
-	"github.com/broothie/test"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestExitError_Error(t *testing.T) {
 	err := &ExitError{Code: 2}
-	test.Equal(t, "exit status 2", err.Error())
+	assert.Equal(t, "exit status 2", err.Error())
 }
 
 func TestExitCode(t *testing.T) {
 	err := ExitCode(3)
-	test.Equal(t, 3, err.Code)
+	assert.Equal(t, 3, err.Code)
 }
 
 func TestExitWithError(t *testing.T) {
@@ -30,7 +30,7 @@ func TestExitWithError(t *testing.T) {
 	err := cmd.Run()
 
 	if exitErr, ok := err.(*exec.ExitError); ok {
-		test.Equal(t, 4, exitErr.ExitCode())
+		assert.Equal(t, 4, exitErr.ExitCode())
 	} else {
 		t.Errorf("expected ExitError, got %v", err)
 	}
diff --git a/flag_config_validation_test.go b/flag_config_validation_test.go
index 58ec6a0..c50d74e 100644
--- a/flag_config_validation_test.go
+++ b/flag_config_validation_test.go
@@ -3,25 +3,25 @@ package cli
 import (
 	"testing"
 
-	"github.com/broothie/test"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestFlag_validateConfig(t *testing.T) {
 	t.Run("empty name", func(t *testing.T) {
 		flag := &Flag{name: ""}
 		err := flag.validateConfig()
-		test.ErrorMessageIs(t, err, "flag name cannot be empty")
+		assert.EqualError(t, err, "flag name cannot be empty")
 	})
 
 	t.Run("multiple tokens", func(t *testing.T) {
 		flag := &Flag{name: "invalid flag name"}
 		err := flag.validateConfig()
-		test.ErrorMessageIs(t, err, `flag name "invalid flag name" must be a single token`)
+		assert.EqualError(t, err, `flag name "invalid flag name" must be a single token`)
 	})
 
 	t.Run("valid name", func(t *testing.T) {
 		flag := &Flag{name: "valid-flag"}
 		err := flag.validateConfig()
-		test.NoError(t, err)
+		assert.NoError(t, err)
 	})
 }
diff --git a/flag_test.go b/flag_test.go
index 74e568c..b922b52 100644
--- a/flag_test.go
+++ b/flag_test.go
@@ -3,7 +3,7 @@ package cli
 import (
 	"testing"
 
-	"github.com/broothie/test"
+	"github.com/stretchr/testify/assert"
 	"github.com/samber/lo"
 )
 
@@ -16,11 +16,11 @@ func TestCommand_flagsUpToRoot(t *testing.T) {
 		),
 	)
 
-	test.NoError(t, err)
+	assert.NoError(t, err)
 
 	flags := command.subCommands[0].flagsUpToRoot()
 	flagNames := lo.Map(flags, func(flag *Flag, _ int) string { return flag.name })
-	test.Contains(t, flagNames, "top-inherited")
-	test.Contains(t, flagNames, "flag")
-	test.NotContains(t, flagNames, "top-uninherited")
+	assert.Contains(t, flagNames, "top-inherited")
+	assert.Contains(t, flagNames, "flag")
+	assert.NotContains(t, flagNames, "top-uninherited")
 }
diff --git a/go.mod b/go.mod
index 77ba205..4db7e5f 100644
--- a/go.mod
+++ b/go.mod
@@ -6,12 +6,13 @@ require (
 	github.com/MakeNowJust/heredoc/v2 v2.0.1
 	github.com/bobg/errors v1.1.0
 	github.com/broothie/option v0.1.0
-	github.com/broothie/test v0.1.9
 	github.com/samber/lo v1.49.1
+	github.com/stretchr/testify v1.10.0
 )
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/kylelemons/godebug v1.1.0 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
 	golang.org/x/text v0.21.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/go.sum b/go.sum
index 8b834be..fed2452 100644
--- a/go.sum
+++ b/go.sum
@@ -4,21 +4,22 @@ github.com/bobg/errors v1.1.0 h1:gsVanPzJMpZQpwY+27/GQYElZez5CuMYwiIpk2A3RGw=
 github.com/bobg/errors v1.1.0/go.mod h1:Q4775qBZpnte7EGFJqmvnlB1U4pkI1XmU3qxqdp7Zcc=
 github.com/broothie/option v0.1.0 h1:5l6qdv9g1Ajxn7821brKVzOZxIjlVB0gA1MU8QbW8Fw=
 github.com/broothie/option v0.1.0/go.mod h1:doEn1r1TpaaBJRdHLZlsdjvnrnH0u1WW+FZA018hE2g=
-github.com/broothie/test v0.1.9 h1:YO+pAEssBJPvJEWSvl2dSjhsUFm9xszqOXFVEfiI33Q=
-github.com/broothie/test v0.1.9/go.mod h1:txzDcP9OHro3y7goC+ZznIkASy8NJks4dUcdbwsP0HM=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
-github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/samber/lo v1.49.1 h1:4BIFyVfuQSEpluc7Fua+j1NolZHiEHEpaSEKdsH0tew=
 github.com/samber/lo v1.49.1/go.mod h1:dO6KHFzUKXgP8LDhU0oI8d2hekjXnGOu0DB8Jecxd6o=
 github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU=
-go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM=
 golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
 golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/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=
diff --git a/help_test.go b/help_test.go
index f556f41..13bc127 100644
--- a/help_test.go
+++ b/help_test.go
@@ -7,7 +7,7 @@ import (
 	"time"
 
 	"github.com/MakeNowJust/heredoc/v2"
-	"github.com/broothie/test"
+	"github.com/stretchr/testify/assert"
 )
 
 type CustomType struct {
@@ -37,12 +37,12 @@ func TestCommand_renderHelp(t *testing.T) {
 			),
 		)
 
-		test.NoError(t, err)
+		assert.NoError(t, err)
 
 		buffer := new(bytes.Buffer)
-		test.NoError(t, command.renderHelp(buffer))
+		assert.NoError(t, command.renderHelp(buffer))
 
-		test.Equal(t,
+		assert.Equal(t,
 			heredoc.Doc(`
 				test v1.2.3-rc10: test command
 
@@ -74,12 +74,12 @@ func TestCommand_renderHelp(t *testing.T) {
 			AddSubCmd("some-command", "some command"),
 		)
 
-		test.NoError(t, err)
+		assert.NoError(t, err)
 
 		buffer := new(bytes.Buffer)
-		test.NoError(t, command.renderHelp(buffer))
+		assert.NoError(t, command.renderHelp(buffer))
 
-		test.Equal(t,
+		assert.Equal(t,
 			heredoc.Doc(`
 				test v1.2.3-rc10: test command
 
@@ -109,12 +109,12 @@ func TestCommand_renderHelp(t *testing.T) {
 			),
 		)
 
-		test.NoError(t, err)
+		assert.NoError(t, err)
 
 		buffer := new(bytes.Buffer)
-		test.NoError(t, command.subCommands[0].renderHelp(buffer))
+		assert.NoError(t, command.subCommands[0].renderHelp(buffer))
 
-		test.Equal(t,
+		assert.Equal(t,
 			heredoc.Doc(`
 				test v1.2.3-rc10: test command
 
diff --git a/options_test.go b/options_test.go
index cbf0da9..0fd8eb9 100644
--- a/options_test.go
+++ b/options_test.go
@@ -7,7 +7,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/broothie/test"
+	"github.com/stretchr/testify/assert"
 )
 
 func Test_options(t *testing.T) {
@@ -29,66 +29,66 @@ func Test_options(t *testing.T) {
 			SetHandler(func(context.Context) error { return nil }),
 		)
 
-		test.NoError(t, err)
+		assert.NoError(t, err)
 
 		// Command
-		test.Equal(t, "http", httpCommand.name)
-		test.Equal(t, "Run http server", httpCommand.description)
-		test.Equal(t, "v0.1.0", httpCommand.version)
-		test.Nil(t, httpCommand.parent)
-		test.Equal(t, httpCommand, httpCommand.root())
-		test.True(t, httpCommand.isRoot())
-		test.False(t, httpCommand.hasParent())
-		test.Equal(t, "http", httpCommand.qualifiedName())
-		test.Equal(t, "v0.1.0", httpCommand.findVersion())
+		assert.Equal(t, "http", httpCommand.name)
+		assert.Equal(t, "Run http server", httpCommand.description)
+		assert.Equal(t, "v0.1.0", httpCommand.version)
+		assert.Nil(t, httpCommand.parent)
+		assert.Equal(t, httpCommand, httpCommand.root())
+		assert.True(t, httpCommand.isRoot())
+		assert.False(t, httpCommand.hasParent())
+		assert.Equal(t, "http", httpCommand.qualifiedName())
+		assert.Equal(t, "v0.1.0", httpCommand.findVersion())
 
 		// Flags
-		test.NotSliceEmpty(t, httpCommand.flags)
+		assert.NotEmpty(t, httpCommand.flags)
 
 		helpFlag := httpCommand.flags[0]
-		test.Equal(t, "help", helpFlag.name)
-		test.Equal(t, "Print help.", helpFlag.description)
-		test.Equal(t, false, helpFlag.defaultValue)
-		test.Nil(t, helpFlag.value)
-		test.Equal(t, reflect.ValueOf(BoolParser).Pointer(), reflect.ValueOf(helpFlag.parser).Pointer())
-		test.True(t, helpFlag.isBool())
-		test.True(t, helpFlag.isHelp)
+		assert.Equal(t, "help", helpFlag.name)
+		assert.Equal(t, "Print help.", helpFlag.description)
+		assert.Equal(t, false, helpFlag.defaultValue)
+		assert.Nil(t, helpFlag.value)
+		assert.Equal(t, reflect.ValueOf(BoolParser).Pointer(), reflect.ValueOf(helpFlag.parser).Pointer())
+		assert.True(t, helpFlag.isBool())
+		assert.True(t, helpFlag.isHelp)
 
 		portFlag := httpCommand.flags[1]
-		test.Equal(t, "port", portFlag.name)
-		test.Equal(t, "Port to run server on", portFlag.description)
-		test.DeepEqual(t, []string{"addr"}, portFlag.aliases)
-		test.DeepEqual(t, []rune{'p'}, portFlag.shorts)
-		test.Equal(t, 3000, portFlag.defaultValue)
-		test.Equal(t, "PORT", portFlag.defaultEnvName)
-		test.Nil(t, portFlag.value)
-		test.Equal(t, reflect.ValueOf(IntParser).Pointer(), reflect.ValueOf(portFlag.parser).Pointer())
-		test.False(t, portFlag.isBool())
-		test.False(t, portFlag.isHelp)
+		assert.Equal(t, "port", portFlag.name)
+		assert.Equal(t, "Port to run server on", portFlag.description)
+		assert.Equal(t, []string{"addr"}, portFlag.aliases)
+		assert.Equal(t, []rune{'p'}, portFlag.shorts)
+		assert.Equal(t, 3000, portFlag.defaultValue)
+		assert.Equal(t, "PORT", portFlag.defaultEnvName)
+		assert.Nil(t, portFlag.value)
+		assert.Equal(t, reflect.ValueOf(IntParser).Pointer(), reflect.ValueOf(portFlag.parser).Pointer())
+		assert.False(t, portFlag.isBool())
+		assert.False(t, portFlag.isHelp)
 
 		// Sub-command
-		test.NotSliceEmpty(t, httpCommand.subCommands)
+		assert.NotEmpty(t, httpCommand.subCommands)
 
 		proxySubCommand := httpCommand.subCommands[0]
-		test.Equal(t, "proxy", proxySubCommand.name)
-		test.Equal(t, "Proxy requests", proxySubCommand.description)
-		test.Equal(t, "", proxySubCommand.version)
-		test.DeepEqual(t, []string{"p", "x"}, proxySubCommand.aliases)
-		test.NotNil(t, proxySubCommand.parent)
-		test.Equal(t, httpCommand, proxySubCommand.root())
-		test.False(t, proxySubCommand.isRoot())
-		test.True(t, proxySubCommand.hasParent())
-		test.Equal(t, "http proxy", proxySubCommand.qualifiedName())
-		test.Equal(t, "v0.1.0", proxySubCommand.findVersion())
+		assert.Equal(t, "proxy", proxySubCommand.name)
+		assert.Equal(t, "Proxy requests", proxySubCommand.description)
+		assert.Equal(t, "", proxySubCommand.version)
+		assert.Equal(t, []string{"p", "x"}, proxySubCommand.aliases)
+		assert.NotNil(t, proxySubCommand.parent)
+		assert.Equal(t, httpCommand, proxySubCommand.root())
+		assert.False(t, proxySubCommand.isRoot())
+		assert.True(t, proxySubCommand.hasParent())
+		assert.Equal(t, "http proxy", proxySubCommand.qualifiedName())
+		assert.Equal(t, "v0.1.0", proxySubCommand.findVersion())
 
 		// Argument
-		test.NotSliceEmpty(t, proxySubCommand.arguments)
+		assert.NotEmpty(t, proxySubCommand.arguments)
 
 		targetArgument := proxySubCommand.arguments[0]
-		test.Equal(t, "target", targetArgument.name)
-		test.Equal(t, "Target to proxy requests to", targetArgument.description)
-		test.Equal(t, reflect.ValueOf(URLParser).Pointer(), reflect.ValueOf(targetArgument.parser).Pointer())
-		test.Nil(t, targetArgument.value)
+		assert.Equal(t, "target", targetArgument.name)
+		assert.Equal(t, "Target to proxy requests to", targetArgument.description)
+		assert.Equal(t, reflect.ValueOf(URLParser).Pointer(), reflect.ValueOf(targetArgument.parser).Pointer())
+		assert.Nil(t, targetArgument.value)
 	})
 }