diff --git a/example_test.go b/example_test.go
index 4bd7632..47ab26c 100644
--- a/example_test.go
+++ b/example_test.go
@@ -199,13 +199,13 @@ func Example_helpPlaceholder() {
 	MustParse(&args)
 
 	// output:
-
+	//
 	// Usage: example [--optimize LEVEL] [--maxjobs N] SRC [DST [DST ...]]
-
+	//
 	// Positional arguments:
 	//   SRC
 	//   DST
-
+	//
 	// Options:
 	//   --optimize LEVEL, -O LEVEL
 	//                          optimization level
@@ -501,7 +501,9 @@ func Example_envVarOnly() {
 	os.Args = split("./example")
 	_ = os.Setenv("AUTH_KEY", "my_key")
 
-	defer os.Unsetenv("AUTH_KEY")
+	defer func() {
+		_ = os.Unsetenv("AUTH_KEY")
+	}()
 
 	var args struct {
 		AuthKey string `arg:"--,env:AUTH_KEY"`
diff --git a/go.mod b/go.mod
index 44ddff5..706a230 100644
--- a/go.mod
+++ b/go.mod
@@ -1,14 +1,14 @@
 module github.com/alexflint/go-arg
 
+go 1.18
+
 require (
 	github.com/alexflint/go-scalar v1.2.0
-	github.com/stretchr/testify v1.7.0
+	github.com/stretchr/testify v1.8.4
 )
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
-
-go 1.18
diff --git a/go.sum b/go.sum
index 385ca8f..401488a 100644
--- a/go.sum
+++ b/go.sum
@@ -1,15 +1,13 @@
 github.com/alexflint/go-scalar v1.2.0 h1:WR7JPKkeNpnYIOfHRa7ivM21aWAdHD0gEWHCx+WQBRw=
 github.com/alexflint/go-scalar v1.2.0/go.mod h1:LoFvNMqS1CPrMVltza4LvnGKhaSpc3oyLEBUZVhhS2o=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 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/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 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.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 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.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+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/parse.go b/parse.go
index 0bdddc7..78cfa45 100644
--- a/parse.go
+++ b/parse.go
@@ -11,7 +11,7 @@ import (
 	"reflect"
 	"strings"
 
-	scalar "github.com/alexflint/go-scalar"
+	"github.com/alexflint/go-scalar"
 )
 
 // path represents a sequence of steps to find the output location for an
@@ -94,7 +94,7 @@ func mustParse(config Config, dest ...interface{}) *Parser {
 
 	p, err := NewParser(config, dest...)
 	if err != nil {
-		fmt.Fprintln(config.Out, err)
+		_, _ = fmt.Fprintln(config.Out, err)
 		config.Exit(-1)
 		return nil
 	}
@@ -141,6 +141,9 @@ type Config struct {
 
 	// Out is where help text, usage text, and failure messages are printed (defaults to os.Stdout)
 	Out io.Writer
+
+	// Environment is a map of environment variables to override those in the process environment, or provide values to those not in the process environment.
+	Environment map[string]string
 }
 
 // Parser represents a set of command line options with destination values
@@ -513,11 +516,11 @@ func (p *Parser) Parse(args []string) error {
 func (p *Parser) MustParse(args []string) {
 	err := p.Parse(args)
 	switch {
-	case err == ErrHelp:
+	case errors.Is(err, ErrHelp):
 		p.writeHelpForSubcommand(p.config.Out, p.lastCmd)
 		p.config.Exit(0)
-	case err == ErrVersion:
-		fmt.Fprintln(p.config.Out, p.version)
+	case errors.Is(err, ErrVersion):
+		_, _ = fmt.Fprintln(p.config.Out, p.version)
 		p.config.Exit(0)
 	case err != nil:
 		p.failWithSubcommand(err.Error(), p.lastCmd)
@@ -531,7 +534,17 @@ func (p *Parser) captureEnvVars(specs []*spec, wasPresent map[*spec]bool) error
 			continue
 		}
 
-		value, found := os.LookupEnv(spec.env)
+		var value string
+		var found bool
+
+		if !p.config.IgnoreEnv {
+			value, found = os.LookupEnv(spec.env)
+		}
+
+		if p.config.Environment != nil {
+			value, found = p.config.Environment[spec.env]
+		}
+
 		if !found {
 			continue
 		}
@@ -584,7 +597,7 @@ func (p *Parser) process(args []string) error {
 	copy(specs, curCmd.specs)
 
 	// deal with environment vars
-	if !p.config.IgnoreEnv {
+	if !p.config.IgnoreEnv || p.config.Environment != nil {
 		err := p.captureEnvVars(specs, wasPresent)
 		if err != nil {
 			return err
@@ -640,7 +653,7 @@ func (p *Parser) process(args []string) error {
 			}
 
 			// capture environment vars for these new options
-			if !p.config.IgnoreEnv {
+			if !p.config.IgnoreEnv || p.config.Environment != nil {
 				err := p.captureEnvVars(subcmd.specs, wasPresent)
 				if err != nil {
 					return err
diff --git a/parse_test.go b/parse_test.go
index 06e7a76..e437cdf 100644
--- a/parse_test.go
+++ b/parse_test.go
@@ -16,23 +16,36 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func setenv(t *testing.T, name, val string) {
-	if err := os.Setenv(name, val); err != nil {
-		t.Error(err)
-	}
+func setenv(tb testing.TB, name, val string) {
+	tb.Helper()
+	tb.Setenv(name, val)
 }
 
-func parse(cmdline string, dest interface{}) error {
-	_, err := pparse(cmdline, dest)
-	return err
+func parse(tb testing.TB, cmdline string, dest interface{}) {
+	tb.Helper()
+	pparse(tb, cmdline, dest)
 }
 
-func pparse(cmdline string, dest interface{}) (*Parser, error) {
-	return parseWithEnv(cmdline, nil, dest)
+func pparse(tb testing.TB, cmdline string, dest interface{}) *Parser {
+	tb.Helper()
+	return parseWithEnv(tb, cmdline, nil, dest)
 }
 
-func parseWithEnv(cmdline string, env []string, dest interface{}) (*Parser, error) {
-	p, err := NewParser(Config{}, dest)
+func parseWithEnv(tb testing.TB, cmdline string, env []string, dest interface{}) *Parser {
+	tb.Helper()
+	p, err := parseWithEnvErr(tb, cmdline, env, dest)
+	require.NoError(tb, err)
+	return p
+}
+
+func parseWithEnvErr(tb testing.TB, cmdline string, env []string, dest interface{}) (*Parser, error) {
+	tb.Helper()
+	return parseWithConfigEnvErr(tb, Config{}, cmdline, env, dest)
+}
+
+func parseWithConfigEnvErr(tb testing.TB, config Config, cmdline string, env []string, dest interface{}) (*Parser, error) {
+	tb.Helper()
+	p, err := NewParser(config, dest)
 	if err != nil {
 		return nil, err
 	}
@@ -49,10 +62,7 @@ func parseWithEnv(cmdline string, env []string, dest interface{}) (*Parser, erro
 		if pos == -1 {
 			return nil, fmt.Errorf("missing equals sign in %q", s)
 		}
-		err := os.Setenv(s[:pos], s[pos+1:])
-		if err != nil {
-			return nil, err
-		}
+		tb.Setenv(s[:pos], s[pos+1:])
 	}
 
 	// execute the parser
@@ -64,8 +74,7 @@ func TestString(t *testing.T) {
 		Foo string
 		Ptr *string
 	}
-	err := parse("--foo bar --ptr baz", &args)
-	require.NoError(t, err)
+	parse(t, "--foo bar --ptr baz", &args)
 	assert.Equal(t, "bar", args.Foo)
 	assert.Equal(t, "baz", *args.Ptr)
 }
@@ -77,8 +86,7 @@ func TestBool(t *testing.T) {
 		C *bool
 		D *bool
 	}
-	err := parse("--a --c", &args)
-	require.NoError(t, err)
+	parse(t, "--a --c", &args)
 	assert.True(t, args.A)
 	assert.False(t, args.B)
 	assert.True(t, *args.C)
@@ -90,8 +98,7 @@ func TestInt(t *testing.T) {
 		Foo int
 		Ptr *int
 	}
-	err := parse("--foo 7 --ptr 8", &args)
-	require.NoError(t, err)
+	parse(t, "--foo 7 --ptr 8", &args)
 	assert.EqualValues(t, 7, args.Foo)
 	assert.EqualValues(t, 8, *args.Ptr)
 }
@@ -103,8 +110,7 @@ func TestHexOctBin(t *testing.T) {
 		Bin         int
 		Underscored int
 	}
-	err := parse("--hex 0xA --oct 0o10 --bin 0b101 --underscored 123_456", &args)
-	require.NoError(t, err)
+	parse(t, "--hex 0xA --oct 0o10 --bin 0b101 --underscored 123_456", &args)
 	assert.EqualValues(t, 10, args.Hex)
 	assert.EqualValues(t, 8, args.Oct)
 	assert.EqualValues(t, 5, args.Bin)
@@ -115,8 +121,7 @@ func TestNegativeInt(t *testing.T) {
 	var args struct {
 		Foo int
 	}
-	err := parse("-foo -100", &args)
-	require.NoError(t, err)
+	parse(t, "-foo -100", &args)
 	assert.EqualValues(t, args.Foo, -100)
 }
 
@@ -126,8 +131,7 @@ func TestNegativeIntAndFloatAndTricks(t *testing.T) {
 		Bar float64
 		N   int `arg:"--100"`
 	}
-	err := parse("-foo -100 -bar -60.14 -100 -100", &args)
-	require.NoError(t, err)
+	parse(t, "-foo -100 -bar -60.14 -100 -100", &args)
 	assert.EqualValues(t, args.Foo, -100)
 	assert.EqualValues(t, args.Bar, -60.14)
 	assert.EqualValues(t, args.N, -100)
@@ -138,8 +142,7 @@ func TestUint(t *testing.T) {
 		Foo uint
 		Ptr *uint
 	}
-	err := parse("--foo 7 --ptr 8", &args)
-	require.NoError(t, err)
+	parse(t, "--foo 7 --ptr 8", &args)
 	assert.EqualValues(t, 7, args.Foo)
 	assert.EqualValues(t, 8, *args.Ptr)
 }
@@ -149,8 +152,7 @@ func TestFloat(t *testing.T) {
 		Foo float32
 		Ptr *float32
 	}
-	err := parse("--foo 3.4 --ptr 3.5", &args)
-	require.NoError(t, err)
+	parse(t, "--foo 3.4 --ptr 3.5", &args)
 	assert.EqualValues(t, 3.4, args.Foo)
 	assert.EqualValues(t, 3.5, *args.Ptr)
 }
@@ -160,8 +162,7 @@ func TestDuration(t *testing.T) {
 		Foo time.Duration
 		Ptr *time.Duration
 	}
-	err := parse("--foo 3ms --ptr 4ms", &args)
-	require.NoError(t, err)
+	parse(t, "--foo 3ms --ptr 4ms", &args)
 	assert.Equal(t, 3*time.Millisecond, args.Foo)
 	assert.Equal(t, 4*time.Millisecond, *args.Ptr)
 }
@@ -170,7 +171,7 @@ func TestInvalidDuration(t *testing.T) {
 	var args struct {
 		Foo time.Duration
 	}
-	err := parse("--foo xxx", &args)
+	_, err := parseWithEnvErr(t, "--foo xxx", nil, &args)
 	require.Error(t, err)
 }
 
@@ -178,8 +179,7 @@ func TestIntPtr(t *testing.T) {
 	var args struct {
 		Foo *int
 	}
-	err := parse("--foo 123", &args)
-	require.NoError(t, err)
+	parse(t, "--foo 123", &args)
 	require.NotNil(t, args.Foo)
 	assert.Equal(t, 123, *args.Foo)
 }
@@ -188,8 +188,7 @@ func TestIntPtrNotPresent(t *testing.T) {
 	var args struct {
 		Foo *int
 	}
-	err := parse("", &args)
-	require.NoError(t, err)
+	parse(t, "", &args)
 	assert.Nil(t, args.Foo)
 }
 
@@ -202,8 +201,7 @@ func TestMixed(t *testing.T) {
 		Spam float32
 	}
 	args.Bar = 3
-	err := parse("123 -spam=1.2 -ham -f xyz", &args)
-	require.NoError(t, err)
+	parse(t, "123 -spam=1.2 -ham -f xyz", &args)
 	assert.Equal(t, "xyz", args.Foo)
 	assert.Equal(t, 3, args.Bar)
 	assert.Equal(t, uint(123), args.Baz)
@@ -215,7 +213,7 @@ func TestRequired(t *testing.T) {
 	var args struct {
 		Foo string `arg:"required"`
 	}
-	err := parse("", &args)
+	_, err := parseWithEnvErr(t, "", nil, &args)
 	require.Error(t, err, "--foo is required")
 }
 
@@ -223,7 +221,7 @@ func TestRequiredWithEnv(t *testing.T) {
 	var args struct {
 		Foo string `arg:"required,env:FOO"`
 	}
-	err := parse("", &args)
+	_, err := parseWithEnvErr(t, "", nil, &args)
 	require.Error(t, err, "--foo is required (or environment variable FOO)")
 }
 
@@ -231,7 +229,7 @@ func TestRequiredWithEnvOnly(t *testing.T) {
 	var args struct {
 		Foo string `arg:"required,--,-,env:FOO"`
 	}
-	_, err := parseWithEnv("", []string{}, &args)
+	_, err := parseWithEnvErr(t, "", []string{}, &args)
 	require.Error(t, err, "environment variable FOO is required")
 }
 
@@ -240,16 +238,13 @@ func TestShortFlag(t *testing.T) {
 		Foo string `arg:"-f"`
 	}
 
-	err := parse("-f xyz", &args)
-	require.NoError(t, err)
+	parse(t, "-f xyz", &args)
 	assert.Equal(t, "xyz", args.Foo)
 
-	err = parse("-foo xyz", &args)
-	require.NoError(t, err)
+	parse(t, "-foo xyz", &args)
 	assert.Equal(t, "xyz", args.Foo)
 
-	err = parse("--foo xyz", &args)
-	require.NoError(t, err)
+	parse(t, "--foo xyz", &args)
 	assert.Equal(t, "xyz", args.Foo)
 }
 
@@ -257,7 +252,7 @@ func TestInvalidShortFlag(t *testing.T) {
 	var args struct {
 		Foo string `arg:"-foo"`
 	}
-	err := parse("", &args)
+	_, err := parseWithEnvErr(t, "", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -266,12 +261,10 @@ func TestLongFlag(t *testing.T) {
 		Foo string `arg:"--abc"`
 	}
 
-	err := parse("-abc xyz", &args)
-	require.NoError(t, err)
+	parse(t, "-abc xyz", &args)
 	assert.Equal(t, "xyz", args.Foo)
 
-	err = parse("--abc xyz", &args)
-	require.NoError(t, err)
+	parse(t, "--abc xyz", &args)
 	assert.Equal(t, "xyz", args.Foo)
 }
 
@@ -279,8 +272,7 @@ func TestSlice(t *testing.T) {
 	var args struct {
 		Strings []string
 	}
-	err := parse("--strings a b c", &args)
-	require.NoError(t, err)
+	parse(t, "--strings a b c", &args)
 	assert.Equal(t, []string{"a", "b", "c"}, args.Strings)
 }
 func TestSliceOfBools(t *testing.T) {
@@ -288,8 +280,7 @@ func TestSliceOfBools(t *testing.T) {
 		B []bool
 	}
 
-	err := parse("--b true false true", &args)
-	require.NoError(t, err)
+	parse(t, "--b true false true", &args)
 	assert.Equal(t, []bool{true, false, true}, args.B)
 }
 
@@ -297,8 +288,7 @@ func TestMap(t *testing.T) {
 	var args struct {
 		Values map[string]int
 	}
-	err := parse("--values a=1 b=2 c=3", &args)
-	require.NoError(t, err)
+	parse(t, "--values a=1 b=2 c=3", &args)
 	assert.Len(t, args.Values, 3)
 	assert.Equal(t, 1, args.Values["a"])
 	assert.Equal(t, 2, args.Values["b"])
@@ -309,8 +299,7 @@ func TestMapPositional(t *testing.T) {
 	var args struct {
 		Values map[string]int `arg:"positional"`
 	}
-	err := parse("a=1 b=2 c=3", &args)
-	require.NoError(t, err)
+	parse(t, "a=1 b=2 c=3", &args)
 	assert.Len(t, args.Values, 3)
 	assert.Equal(t, 1, args.Values["a"])
 	assert.Equal(t, 2, args.Values["b"])
@@ -321,8 +310,7 @@ func TestMapWithSeparate(t *testing.T) {
 	var args struct {
 		Values map[string]int `arg:"separate"`
 	}
-	err := parse("--values a=1 --values b=2 --values c=3", &args)
-	require.NoError(t, err)
+	parse(t, "--values a=1 --values b=2 --values c=3", &args)
 	assert.Len(t, args.Values, 3)
 	assert.Equal(t, 1, args.Values["a"])
 	assert.Equal(t, 2, args.Values["b"])
@@ -336,8 +324,7 @@ func TestPlaceholder(t *testing.T) {
 		Optimize int      `arg:"-O" placeholder:"LEVEL"`
 		MaxJobs  int      `arg:"-j" placeholder:"N"`
 	}
-	err := parse("-O 5 --maxjobs 2 src dest1 dest2", &args)
-	assert.NoError(t, err)
+	parse(t, "-O 5 --maxjobs 2 src dest1 dest2", &args)
 }
 
 func TestNoLongName(t *testing.T) {
@@ -346,8 +333,7 @@ func TestNoLongName(t *testing.T) {
 		EnvOnly   string `arg:"--,env"`
 	}
 	setenv(t, "ENVONLY", "TestVal")
-	err := parse("-s TestVal2", &args)
-	assert.NoError(t, err)
+	parse(t, "-s TestVal2", &args)
 	assert.Equal(t, "TestVal", args.EnvOnly)
 	assert.Equal(t, "TestVal2", args.ShortOnly)
 }
@@ -358,8 +344,7 @@ func TestCaseSensitive(t *testing.T) {
 		Upper bool `arg:"-V"`
 	}
 
-	err := parse("-v", &args)
-	require.NoError(t, err)
+	parse(t, "-v", &args)
 	assert.True(t, args.Lower)
 	assert.False(t, args.Upper)
 }
@@ -370,8 +355,7 @@ func TestCaseSensitive2(t *testing.T) {
 		Upper bool `arg:"-V"`
 	}
 
-	err := parse("-V", &args)
-	require.NoError(t, err)
+	parse(t, "-V", &args)
 	assert.False(t, args.Lower)
 	assert.True(t, args.Upper)
 }
@@ -381,8 +365,7 @@ func TestPositional(t *testing.T) {
 		Input  string `arg:"positional"`
 		Output string `arg:"positional"`
 	}
-	err := parse("foo", &args)
-	require.NoError(t, err)
+	parse(t, "foo", &args)
 	assert.Equal(t, "foo", args.Input)
 	assert.Equal(t, "", args.Output)
 }
@@ -392,8 +375,7 @@ func TestPositionalPointer(t *testing.T) {
 		Input  string    `arg:"positional"`
 		Output []*string `arg:"positional"`
 	}
-	err := parse("foo bar baz", &args)
-	require.NoError(t, err)
+	parse(t, "foo bar baz", &args)
 	assert.Equal(t, "foo", args.Input)
 	bar := "bar"
 	baz := "baz"
@@ -405,7 +387,7 @@ func TestRequiredPositional(t *testing.T) {
 		Input  string `arg:"positional"`
 		Output string `arg:"positional,required"`
 	}
-	err := parse("foo", &args)
+	_, err := parseWithEnvErr(t, "foo", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -414,7 +396,7 @@ func TestRequiredPositionalMultiple(t *testing.T) {
 		Input    string   `arg:"positional"`
 		Multiple []string `arg:"positional,required"`
 	}
-	err := parse("foo", &args)
+	_, err := parseWithEnvErr(t, "foo", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -423,7 +405,7 @@ func TestTooManyPositional(t *testing.T) {
 		Input  string `arg:"positional"`
 		Output string `arg:"positional"`
 	}
-	err := parse("foo bar baz", &args)
+	_, err := parseWithEnvErr(t, "foo bar baz", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -432,8 +414,7 @@ func TestMultiple(t *testing.T) {
 		Foo []int
 		Bar []string
 	}
-	err := parse("--foo 1 2 3 --bar x y z", &args)
-	require.NoError(t, err)
+	parse(t, "--foo 1 2 3 --bar x y z", &args)
 	assert.Equal(t, []int{1, 2, 3}, args.Foo)
 	assert.Equal(t, []string{"x", "y", "z"}, args.Bar)
 }
@@ -443,8 +424,7 @@ func TestMultiplePositionals(t *testing.T) {
 		Input    string   `arg:"positional"`
 		Multiple []string `arg:"positional,required"`
 	}
-	err := parse("foo a b c", &args)
-	assert.NoError(t, err)
+	parse(t, "foo a b c", &args)
 	assert.Equal(t, "foo", args.Input)
 	assert.Equal(t, []string{"a", "b", "c"}, args.Multiple)
 }
@@ -454,8 +434,7 @@ func TestMultipleWithEq(t *testing.T) {
 		Foo []int
 		Bar []string
 	}
-	err := parse("--foo 1 2 3 --bar=x", &args)
-	require.NoError(t, err)
+	parse(t, "--foo 1 2 3 --bar=x", &args)
 	assert.Equal(t, []int{1, 2, 3}, args.Foo)
 	assert.Equal(t, []string{"x"}, args.Bar)
 }
@@ -467,8 +446,7 @@ func TestMultipleWithDefault(t *testing.T) {
 	}
 	args.Foo = []int{42}
 	args.Bar = []string{"foo"}
-	err := parse("--foo 1 2 3 --bar x y z", &args)
-	require.NoError(t, err)
+	parse(t, "--foo 1 2 3 --bar x y z", &args)
 	assert.Equal(t, []int{1, 2, 3}, args.Foo)
 	assert.Equal(t, []string{"x", "y", "z"}, args.Bar)
 }
@@ -478,8 +456,7 @@ func TestExemptField(t *testing.T) {
 		Foo string
 		Bar interface{} `arg:"-"`
 	}
-	err := parse("--foo xyz", &args)
-	require.NoError(t, err)
+	parse(t, "--foo xyz", &args)
 	assert.Equal(t, "xyz", args.Foo)
 }
 
@@ -487,7 +464,7 @@ func TestUnknownField(t *testing.T) {
 	var args struct {
 		Foo string
 	}
-	err := parse("--bar xyz", &args)
+	_, err := parseWithEnvErr(t, "--bar xyz", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -496,7 +473,7 @@ func TestMissingRequired(t *testing.T) {
 		Foo string   `arg:"required"`
 		X   []string `arg:"positional"`
 	}
-	err := parse("x", &args)
+	_, err := parseWithEnvErr(t, "x", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -504,7 +481,7 @@ func TestNonsenseKey(t *testing.T) {
 	var args struct {
 		X []string `arg:"positional, nonsense"`
 	}
-	err := parse("x", &args)
+	_, err := parseWithEnvErr(t, "x", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -512,7 +489,7 @@ func TestMissingValueAtEnd(t *testing.T) {
 	var args struct {
 		Foo string
 	}
-	err := parse("--foo", &args)
+	_, err := parseWithEnvErr(t, "--foo", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -521,7 +498,7 @@ func TestMissingValueInMiddle(t *testing.T) {
 		Foo string
 		Bar string
 	}
-	err := parse("--foo --bar=abc", &args)
+	_, err := parseWithEnvErr(t, "--foo --bar=abc", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -529,8 +506,7 @@ func TestNegativeValue(t *testing.T) {
 	var args struct {
 		Foo int
 	}
-	err := parse("--foo -123", &args)
-	require.NoError(t, err)
+	parse(t, "--foo -123", &args)
 	assert.Equal(t, -123, args.Foo)
 }
 
@@ -538,7 +514,7 @@ func TestInvalidInt(t *testing.T) {
 	var args struct {
 		Foo int
 	}
-	err := parse("--foo=xyz", &args)
+	_, err := parseWithEnvErr(t, "--foo=xyz", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -546,7 +522,7 @@ func TestInvalidUint(t *testing.T) {
 	var args struct {
 		Foo uint
 	}
-	err := parse("--foo=xyz", &args)
+	_, err := parseWithEnvErr(t, "--foo=xyz", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -554,7 +530,7 @@ func TestInvalidFloat(t *testing.T) {
 	var args struct {
 		Foo float64
 	}
-	err := parse("--foo xyz", &args)
+	_, err := parseWithEnvErr(t, "--foo xyz", nil, &args)
 	require.Error(t, err)
 }
 
@@ -562,7 +538,7 @@ func TestInvalidBool(t *testing.T) {
 	var args struct {
 		Foo bool
 	}
-	err := parse("--foo=xyz", &args)
+	_, err := parseWithEnvErr(t, "--foo=xyz", nil, &args)
 	require.Error(t, err)
 }
 
@@ -570,7 +546,7 @@ func TestInvalidIntSlice(t *testing.T) {
 	var args struct {
 		Foo []int
 	}
-	err := parse("--foo 1 2 xyz", &args)
+	_, err := parseWithEnvErr(t, "--foo 1 2 xyz", nil, &args)
 	require.Error(t, err)
 }
 
@@ -578,7 +554,7 @@ func TestInvalidPositional(t *testing.T) {
 	var args struct {
 		Foo int `arg:"positional"`
 	}
-	err := parse("xyz", &args)
+	_, err := parseWithEnvErr(t, "xyz", nil, &args)
 	require.Error(t, err)
 }
 
@@ -586,7 +562,7 @@ func TestInvalidPositionalSlice(t *testing.T) {
 	var args struct {
 		Foo []int `arg:"positional"`
 	}
-	err := parse("1 2 xyz", &args)
+	_, err := parseWithEnvErr(t, "1 2 xyz", nil, &args)
 	require.Error(t, err)
 }
 
@@ -595,8 +571,7 @@ func TestNoMoreOptions(t *testing.T) {
 		Foo string
 		Bar []string `arg:"positional"`
 	}
-	err := parse("abc -- --foo xyz", &args)
-	require.NoError(t, err)
+	parse(t, "abc -- --foo xyz", &args)
 	assert.Equal(t, "", args.Foo)
 	assert.Equal(t, []string{"abc", "--foo", "xyz"}, args.Bar)
 }
@@ -605,7 +580,7 @@ func TestNoMoreOptionsBeforeHelp(t *testing.T) {
 	var args struct {
 		Foo int
 	}
-	err := parse("not_an_integer -- --help", &args)
+	_, err := parseWithEnvErr(t, "not_an_integer -- --help", nil, &args)
 	assert.NotEqual(t, ErrHelp, err)
 }
 
@@ -614,20 +589,20 @@ func TestHelpFlag(t *testing.T) {
 		Foo string
 		Bar interface{} `arg:"-"`
 	}
-	err := parse("--help", &args)
+	_, err := parseWithEnvErr(t, "--help", nil, &args)
 	assert.Equal(t, ErrHelp, err)
 }
 
 func TestPanicOnNonPointer(t *testing.T) {
 	var args struct{}
 	assert.Panics(t, func() {
-		_ = parse("", args)
+		parse(t, "", args)
 	})
 }
 
 func TestErrorOnNonStruct(t *testing.T) {
 	var args string
-	err := parse("", &args)
+	_, err := parseWithEnvErr(t, "", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -635,7 +610,7 @@ func TestUnsupportedType(t *testing.T) {
 	var args struct {
 		Foo interface{}
 	}
-	err := parse("--foo", &args)
+	_, err := parseWithEnvErr(t, "--foo", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -643,7 +618,7 @@ func TestUnsupportedSliceElement(t *testing.T) {
 	var args struct {
 		Foo []interface{}
 	}
-	err := parse("--foo 3", &args)
+	_, err := parseWithEnvErr(t, "--foo 3", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -651,7 +626,7 @@ func TestUnsupportedSliceElementMissingValue(t *testing.T) {
 	var args struct {
 		Foo []interface{}
 	}
-	err := parse("--foo", &args)
+	_, err := parseWithEnvErr(t, "--foo", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -659,7 +634,7 @@ func TestUnknownTag(t *testing.T) {
 	var args struct {
 		Foo string `arg:"this_is_not_valid"`
 	}
-	err := parse("--foo xyz", &args)
+	_, err := parseWithEnvErr(t, "--foo xyz", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -696,7 +671,24 @@ func TestEnvironmentVariable(t *testing.T) {
 	var args struct {
 		Foo string `arg:"env"`
 	}
-	_, err := parseWithEnv("", []string{"FOO=bar"}, &args)
+	parseWithEnv(t, "", []string{"FOO=bar"}, &args)
+	assert.Equal(t, "bar", args.Foo)
+}
+
+func TestEnvironmentVariableViaCustomEnvironment(t *testing.T) {
+	var args struct {
+		Foo string `arg:"env"`
+	}
+	_, err := parseWithConfigEnvErr(t, Config{Environment: map[string]string{"FOO": "bar"}}, "", nil, &args)
+	require.NoError(t, err)
+	assert.Equal(t, "bar", args.Foo)
+}
+
+func TestEnvironmentVariableOverriddenByCustomEnvironment(t *testing.T) {
+	var args struct {
+		Foo string `arg:"env"`
+	}
+	_, err := parseWithConfigEnvErr(t, Config{Environment: map[string]string{"FOO": "bar"}}, "", []string{"FOO=foo"}, &args)
 	require.NoError(t, err)
 	assert.Equal(t, "bar", args.Foo)
 }
@@ -705,8 +697,7 @@ func TestEnvironmentVariableNotPresent(t *testing.T) {
 	var args struct {
 		NotPresent string `arg:"env"`
 	}
-	_, err := parseWithEnv("", nil, &args)
-	require.NoError(t, err)
+	parseWithEnv(t, "", nil, &args)
 	assert.Equal(t, "", args.NotPresent)
 }
 
@@ -714,8 +705,7 @@ func TestEnvironmentVariableOverrideName(t *testing.T) {
 	var args struct {
 		Foo string `arg:"env:BAZ"`
 	}
-	_, err := parseWithEnv("", []string{"BAZ=bar"}, &args)
-	require.NoError(t, err)
+	parseWithEnv(t, "", []string{"BAZ=bar"}, &args)
 	assert.Equal(t, "bar", args.Foo)
 }
 
@@ -723,8 +713,7 @@ func TestEnvironmentVariableOverrideArgument(t *testing.T) {
 	var args struct {
 		Foo string `arg:"env"`
 	}
-	_, err := parseWithEnv("--foo zzz", []string{"FOO=bar"}, &args)
-	require.NoError(t, err)
+	parseWithEnv(t, "--foo zzz", []string{"FOO=bar"}, &args)
 	assert.Equal(t, "zzz", args.Foo)
 }
 
@@ -732,7 +721,7 @@ func TestEnvironmentVariableError(t *testing.T) {
 	var args struct {
 		Foo int `arg:"env"`
 	}
-	_, err := parseWithEnv("", []string{"FOO=bar"}, &args)
+	_, err := parseWithEnvErr(t, "", []string{"FOO=bar"}, &args)
 	assert.Error(t, err)
 }
 
@@ -740,8 +729,7 @@ func TestEnvironmentVariableRequired(t *testing.T) {
 	var args struct {
 		Foo string `arg:"env,required"`
 	}
-	_, err := parseWithEnv("", []string{"FOO=bar"}, &args)
-	require.NoError(t, err)
+	parseWithEnv(t, "", []string{"FOO=bar"}, &args)
 	assert.Equal(t, "bar", args.Foo)
 }
 
@@ -749,8 +737,7 @@ func TestEnvironmentVariableSliceArgumentString(t *testing.T) {
 	var args struct {
 		Foo []string `arg:"env"`
 	}
-	_, err := parseWithEnv("", []string{`FOO=bar,"baz, qux"`}, &args)
-	require.NoError(t, err)
+	parseWithEnv(t, "", []string{`FOO=bar,"baz, qux"`}, &args)
 	assert.Equal(t, []string{"bar", "baz, qux"}, args.Foo)
 }
 
@@ -758,8 +745,7 @@ func TestEnvironmentVariableSliceEmpty(t *testing.T) {
 	var args struct {
 		Foo []string `arg:"env"`
 	}
-	_, err := parseWithEnv("", []string{`FOO=`}, &args)
-	require.NoError(t, err)
+	parseWithEnv(t, "", []string{`FOO=`}, &args)
 	assert.Len(t, args.Foo, 0)
 }
 
@@ -767,8 +753,7 @@ func TestEnvironmentVariableSliceArgumentInteger(t *testing.T) {
 	var args struct {
 		Foo []int `arg:"env"`
 	}
-	_, err := parseWithEnv("", []string{`FOO=1,99`}, &args)
-	require.NoError(t, err)
+	parseWithEnv(t, "", []string{`FOO=1,99`}, &args)
 	assert.Equal(t, []int{1, 99}, args.Foo)
 }
 
@@ -776,8 +761,7 @@ func TestEnvironmentVariableSliceArgumentFloat(t *testing.T) {
 	var args struct {
 		Foo []float32 `arg:"env"`
 	}
-	_, err := parseWithEnv("", []string{`FOO=1.1,99.9`}, &args)
-	require.NoError(t, err)
+	parseWithEnv(t, "", []string{`FOO=1.1,99.9`}, &args)
 	assert.Equal(t, []float32{1.1, 99.9}, args.Foo)
 }
 
@@ -785,8 +769,7 @@ func TestEnvironmentVariableSliceArgumentBool(t *testing.T) {
 	var args struct {
 		Foo []bool `arg:"env"`
 	}
-	_, err := parseWithEnv("", []string{`FOO=true,false,0,1`}, &args)
-	require.NoError(t, err)
+	parseWithEnv(t, "", []string{`FOO=true,false,0,1`}, &args)
 	assert.Equal(t, []bool{true, false, false, true}, args.Foo)
 }
 
@@ -794,7 +777,7 @@ func TestEnvironmentVariableSliceArgumentWrongCsv(t *testing.T) {
 	var args struct {
 		Foo []int `arg:"env"`
 	}
-	_, err := parseWithEnv("", []string{`FOO=1,99\"`}, &args)
+	_, err := parseWithEnvErr(t, "", []string{`FOO=1,99\"`}, &args)
 	assert.Error(t, err)
 }
 
@@ -802,7 +785,7 @@ func TestEnvironmentVariableSliceArgumentWrongType(t *testing.T) {
 	var args struct {
 		Foo []bool `arg:"env"`
 	}
-	_, err := parseWithEnv("", []string{`FOO=one,two`}, &args)
+	_, err := parseWithEnvErr(t, "", []string{`FOO=one,two`}, &args)
 	assert.Error(t, err)
 }
 
@@ -810,8 +793,7 @@ func TestEnvironmentVariableMap(t *testing.T) {
 	var args struct {
 		Foo map[int]string `arg:"env"`
 	}
-	_, err := parseWithEnv("", []string{`FOO=1=one,99=ninetynine`}, &args)
-	require.NoError(t, err)
+	parseWithEnv(t, "", []string{`FOO=1=one,99=ninetynine`}, &args)
 	assert.Len(t, args.Foo, 2)
 	assert.Equal(t, "one", args.Foo[1])
 	assert.Equal(t, "ninetynine", args.Foo[99])
@@ -821,8 +803,7 @@ func TestEnvironmentVariableEmptyMap(t *testing.T) {
 	var args struct {
 		Foo map[int]string `arg:"env"`
 	}
-	_, err := parseWithEnv("", []string{`FOO=`}, &args)
-	require.NoError(t, err)
+	parseWithEnv(t, "", []string{`FOO=`}, &args)
 	assert.Len(t, args.Foo, 0)
 }
 
@@ -858,7 +839,7 @@ func TestRequiredEnvironmentOnlyVariableIsMissing(t *testing.T) {
 		Foo string `arg:"required,--,env:FOO"`
 	}
 
-	_, err := parseWithEnv("", []string{""}, &args)
+	_, err := parseWithEnvErr(t, "", []string{""}, &args)
 	assert.Error(t, err)
 }
 
@@ -867,8 +848,7 @@ func TestOptionalEnvironmentOnlyVariable(t *testing.T) {
 		Foo string `arg:"env:FOO"`
 	}
 
-	_, err := parseWithEnv("", []string{}, &args)
-	assert.NoError(t, err)
+	parseWithEnv(t, "", []string{}, &args)
 }
 
 func TestEnvironmentVariableInSubcommandIgnored(t *testing.T) {
@@ -941,8 +921,7 @@ func TestTextUnmarshaler(t *testing.T) {
 	var args struct {
 		Foo textUnmarshaler
 	}
-	err := parse("--foo abc", &args)
-	require.NoError(t, err)
+	parse(t, "--foo abc", &args)
 	assert.Equal(t, 3, args.Foo.val)
 }
 
@@ -951,8 +930,7 @@ func TestPtrToTextUnmarshaler(t *testing.T) {
 	var args struct {
 		Foo *textUnmarshaler
 	}
-	err := parse("--foo abc", &args)
-	require.NoError(t, err)
+	parse(t, "--foo abc", &args)
 	assert.Equal(t, 3, args.Foo.val)
 }
 
@@ -961,8 +939,7 @@ func TestRepeatedTextUnmarshaler(t *testing.T) {
 	var args struct {
 		Foo []textUnmarshaler
 	}
-	err := parse("--foo abc d ef", &args)
-	require.NoError(t, err)
+	parse(t, "--foo abc d ef", &args)
 	require.Len(t, args.Foo, 3)
 	assert.Equal(t, 3, args.Foo[0].val)
 	assert.Equal(t, 1, args.Foo[1].val)
@@ -974,8 +951,7 @@ func TestRepeatedPtrToTextUnmarshaler(t *testing.T) {
 	var args struct {
 		Foo []*textUnmarshaler
 	}
-	err := parse("--foo abc d ef", &args)
-	require.NoError(t, err)
+	parse(t, "--foo abc d ef", &args)
 	require.Len(t, args.Foo, 3)
 	assert.Equal(t, 3, args.Foo[0].val)
 	assert.Equal(t, 1, args.Foo[1].val)
@@ -987,8 +963,7 @@ func TestPositionalTextUnmarshaler(t *testing.T) {
 	var args struct {
 		Foo []textUnmarshaler `arg:"positional"`
 	}
-	err := parse("abc d ef", &args)
-	require.NoError(t, err)
+	parse(t, "abc d ef", &args)
 	require.Len(t, args.Foo, 3)
 	assert.Equal(t, 3, args.Foo[0].val)
 	assert.Equal(t, 1, args.Foo[1].val)
@@ -1000,8 +975,7 @@ func TestPositionalPtrToTextUnmarshaler(t *testing.T) {
 	var args struct {
 		Foo []*textUnmarshaler `arg:"positional"`
 	}
-	err := parse("abc d ef", &args)
-	require.NoError(t, err)
+	parse(t, "abc d ef", &args)
 	require.Len(t, args.Foo, 3)
 	assert.Equal(t, 3, args.Foo[0].val)
 	assert.Equal(t, 1, args.Foo[1].val)
@@ -1021,8 +995,7 @@ func TestBoolUnmarhsaler(t *testing.T) {
 	var args struct {
 		Foo *boolUnmarshaler
 	}
-	err := parse("--foo ab", &args)
-	require.NoError(t, err)
+	parse(t, "--foo ab", &args)
 	assert.EqualValues(t, true, *args.Foo)
 }
 
@@ -1040,8 +1013,7 @@ func TestSliceUnmarhsaler(t *testing.T) {
 		Foo *sliceUnmarshaler
 		Bar string `arg:"positional"`
 	}
-	err := parse("--foo abcde xyz", &args)
-	require.NoError(t, err)
+	parse(t, "--foo abcde xyz", &args)
 	require.Len(t, *args.Foo, 1)
 	assert.EqualValues(t, 5, (*args.Foo)[0])
 	assert.Equal(t, "xyz", args.Bar)
@@ -1051,8 +1023,7 @@ func TestIP(t *testing.T) {
 	var args struct {
 		Host net.IP
 	}
-	err := parse("--host 192.168.0.1", &args)
-	require.NoError(t, err)
+	parse(t, "--host 192.168.0.1", &args)
 	assert.Equal(t, "192.168.0.1", args.Host.String())
 }
 
@@ -1060,8 +1031,7 @@ func TestPtrToIP(t *testing.T) {
 	var args struct {
 		Host *net.IP
 	}
-	err := parse("--host 192.168.0.1", &args)
-	require.NoError(t, err)
+	parse(t, "--host 192.168.0.1", &args)
 	assert.Equal(t, "192.168.0.1", args.Host.String())
 }
 
@@ -1069,8 +1039,7 @@ func TestURL(t *testing.T) {
 	var args struct {
 		URL url.URL
 	}
-	err := parse("--url https://example.com/get?item=xyz", &args)
-	require.NoError(t, err)
+	parse(t, "--url https://example.com/get?item=xyz", &args)
 	assert.Equal(t, "https://example.com/get?item=xyz", args.URL.String())
 }
 
@@ -1078,8 +1047,7 @@ func TestPtrToURL(t *testing.T) {
 	var args struct {
 		URL *url.URL
 	}
-	err := parse("--url http://example.com/#xyz", &args)
-	require.NoError(t, err)
+	parse(t, "--url http://example.com/#xyz", &args)
 	assert.Equal(t, "http://example.com/#xyz", args.URL.String())
 }
 
@@ -1087,8 +1055,7 @@ func TestIPSlice(t *testing.T) {
 	var args struct {
 		Host []net.IP
 	}
-	err := parse("--host 192.168.0.1 127.0.0.1", &args)
-	require.NoError(t, err)
+	parse(t, "--host 192.168.0.1 127.0.0.1", &args)
 	require.Len(t, args.Host, 2)
 	assert.Equal(t, "192.168.0.1", args.Host[0].String())
 	assert.Equal(t, "127.0.0.1", args.Host[1].String())
@@ -1098,7 +1065,7 @@ func TestInvalidIPAddress(t *testing.T) {
 	var args struct {
 		Host net.IP
 	}
-	err := parse("--host xxx", &args)
+	_, err := parseWithEnvErr(t, "--host xxx", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -1106,8 +1073,7 @@ func TestMAC(t *testing.T) {
 	var args struct {
 		Host net.HardwareAddr
 	}
-	err := parse("--host 0123.4567.89ab", &args)
-	require.NoError(t, err)
+	parse(t, "--host 0123.4567.89ab", &args)
 	assert.Equal(t, "01:23:45:67:89:ab", args.Host.String())
 }
 
@@ -1115,7 +1081,7 @@ func TestInvalidMac(t *testing.T) {
 	var args struct {
 		Host net.HardwareAddr
 	}
-	err := parse("--host xxx", &args)
+	_, err := parseWithEnvErr(t, "--host xxx", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -1123,8 +1089,7 @@ func TestMailAddr(t *testing.T) {
 	var args struct {
 		Recipient mail.Address
 	}
-	err := parse("--recipient foo@example.com", &args)
-	require.NoError(t, err)
+	parse(t, "--recipient foo@example.com", &args)
 	assert.Equal(t, "<foo@example.com>", args.Recipient.String())
 }
 
@@ -1132,7 +1097,7 @@ func TestInvalidMailAddr(t *testing.T) {
 	var args struct {
 		Recipient mail.Address
 	}
-	err := parse("--recipient xxx", &args)
+	_, err := parseWithEnvErr(t, "--recipient xxx", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -1150,8 +1115,7 @@ func TestEmbedded(t *testing.T) {
 		B
 		Z bool
 	}
-	err := parse("--x=hello --y=321 --z", &args)
-	require.NoError(t, err)
+	parse(t, "--x=hello --y=321 --z", &args)
 	assert.Equal(t, "hello", args.X)
 	assert.Equal(t, 321, args.Y)
 	assert.Equal(t, true, args.Z)
@@ -1162,7 +1126,7 @@ func TestEmbeddedPtr(t *testing.T) {
 	var args struct {
 		*A
 	}
-	err := parse("--x=hello", &args)
+	_, err := parseWithEnvErr(t, "--x=hello", nil, &args)
 	require.Error(t, err)
 }
 
@@ -1174,8 +1138,7 @@ func TestEmbeddedPtrIgnored(t *testing.T) {
 		*A `arg:"-"`
 		B
 	}
-	err := parse("--y=321", &args)
-	require.NoError(t, err)
+	parse(t, "--y=321", &args)
 	assert.Equal(t, 321, args.Y)
 }
 
@@ -1192,8 +1155,7 @@ func TestEmbeddedWithDuplicateField(t *testing.T) {
 		U
 	}
 
-	err := parse("--cat=cat --dog=dog", &args)
-	require.NoError(t, err)
+	parse(t, "--cat=cat --dog=dog", &args)
 	assert.Equal(t, "cat", args.T.A)
 	assert.Equal(t, "dog", args.U.A)
 }
@@ -1211,8 +1173,7 @@ func TestEmbeddedWithDuplicateField2(t *testing.T) {
 		U
 	}
 
-	err := parse("--a=xyz", &args)
-	require.NoError(t, err)
+	parse(t, "--a=xyz", &args)
 	assert.Equal(t, "xyz", args.T.A)
 	assert.Equal(t, "", args.U.A)
 }
@@ -1224,8 +1185,7 @@ func TestUnexportedEmbedded(t *testing.T) {
 	var args struct {
 		embeddedArgs
 	}
-	err := parse("--foo bar", &args)
-	require.NoError(t, err)
+	parse(t, "--foo bar", &args)
 	assert.Equal(t, "bar", args.Foo)
 }
 
@@ -1236,7 +1196,7 @@ func TestIgnoredEmbedded(t *testing.T) {
 	var args struct {
 		embeddedArgs `arg:"-"`
 	}
-	err := parse("--foo bar", &args)
+	_, err := parseWithEnvErr(t, "--foo bar", nil, &args)
 	require.Error(t, err)
 }
 
@@ -1258,7 +1218,7 @@ func TestTooManyHyphens(t *testing.T) {
 	var args struct {
 		TooManyHyphens string `arg:"---x"`
 	}
-	err := parse("--foo -", &args)
+	_, err := parseWithEnvErr(t, "--foo -", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -1266,8 +1226,7 @@ func TestHyphenAsOption(t *testing.T) {
 	var args struct {
 		Foo string
 	}
-	err := parse("--foo -", &args)
-	require.NoError(t, err)
+	parse(t, "--foo -", &args)
 	assert.Equal(t, "-", args.Foo)
 }
 
@@ -1275,8 +1234,7 @@ func TestHyphenAsPositional(t *testing.T) {
 	var args struct {
 		Foo string `arg:"positional"`
 	}
-	err := parse("-", &args)
-	require.NoError(t, err)
+	parse(t, "-", &args)
 	assert.Equal(t, "-", args.Foo)
 }
 
@@ -1285,8 +1243,7 @@ func TestHyphenInMultiOption(t *testing.T) {
 		Foo []string
 		Bar int
 	}
-	err := parse("--foo --- x - y --bar 3", &args)
-	require.NoError(t, err)
+	parse(t, "--foo --- x - y --bar 3", &args)
 	assert.Equal(t, []string{"---", "x", "-", "y"}, args.Foo)
 	assert.Equal(t, 3, args.Bar)
 }
@@ -1295,8 +1252,7 @@ func TestHyphenInMultiPositional(t *testing.T) {
 	var args struct {
 		Foo []string `arg:"positional"`
 	}
-	err := parse("--- x - y", &args)
-	require.NoError(t, err)
+	parse(t, "--- x - y", &args)
 	assert.Equal(t, []string{"---", "x", "-", "y"}, args.Foo)
 }
 
@@ -1306,8 +1262,7 @@ func TestSeparate(t *testing.T) {
 			Foo []string `arg:"--foo,-f,separate"`
 		}
 
-		err := parse(val, &args)
-		require.NoError(t, err)
+		parse(t, val, &args)
 		assert.Equal(t, []string{"one"}, args.Foo)
 	}
 }
@@ -1319,8 +1274,7 @@ func TestSeparateWithDefault(t *testing.T) {
 		Foo: []string{"default"},
 	}
 
-	err := parse("-f one -f=two", &args)
-	require.NoError(t, err)
+	parse(t, "-f one -f=two", &args)
 	assert.Equal(t, []string{"default", "one", "two"}, args.Foo)
 }
 
@@ -1331,8 +1285,7 @@ func TestSeparateWithPositional(t *testing.T) {
 		Moo string   `arg:"positional"`
 	}
 
-	err := parse("zzz --foo one -f=two --foo=three -f four aaa", &args)
-	require.NoError(t, err)
+	parse(t, "zzz --foo one -f=two --foo=three -f four aaa", &args)
 	assert.Equal(t, []string{"one", "two", "three", "four"}, args.Foo)
 	assert.Equal(t, "zzz", args.Bar)
 	assert.Equal(t, "aaa", args.Moo)
@@ -1346,8 +1299,7 @@ func TestSeparatePositionalInterweaved(t *testing.T) {
 		Post []string `arg:"positional"`
 	}
 
-	err := parse("zzz -f foo1 -b=bar1 --foo=foo2 -b bar2 post1 -b bar3 post2 post3", &args)
-	require.NoError(t, err)
+	parse(t, "zzz -f foo1 -b=bar1 --foo=foo2 -b bar2 post1 -b bar3 post2 post3", &args)
 	assert.Equal(t, []string{"foo1", "foo2"}, args.Foo)
 	assert.Equal(t, []string{"bar1", "bar2", "bar3"}, args.Bar)
 	assert.Equal(t, "zzz", args.Pre)
@@ -1359,8 +1311,7 @@ func TestSpacesAllowedInTags(t *testing.T) {
 		Foo []string `arg:"--foo, -f, separate, required, help:quite nice really"`
 	}
 
-	err := parse("--foo one -f=two --foo=three -f four", &args)
-	require.NoError(t, err)
+	parse(t, "--foo one -f=two --foo=three -f four", &args)
 	assert.Equal(t, []string{"one", "two", "three", "four"}, args.Foo)
 }
 
@@ -1437,8 +1388,7 @@ func TestMultipleTerminates(t *testing.T) {
 		Y string `arg:"positional"`
 	}
 
-	err := parse("--x a b -- c", &args)
-	require.NoError(t, err)
+	parse(t, "--x a b -- c", &args)
 	assert.Equal(t, []string{"a", "b"}, args.X)
 	assert.Equal(t, "c", args.Y)
 }
@@ -1455,8 +1405,7 @@ func TestDefaultOptionValues(t *testing.T) {
 		H *bool    `default:"true"`
 	}
 
-	err := parse("--c=xyz --e=4.56", &args)
-	require.NoError(t, err)
+	parse(t, "--c=xyz --e=4.56", &args)
 
 	assert.Equal(t, 123, args.A)
 	if assert.NotNil(t, args.B) {
@@ -1481,7 +1430,7 @@ func TestDefaultUnparseable(t *testing.T) {
 		A int `default:"x"`
 	}
 
-	err := parse("", &args)
+	_, err := parseWithEnvErr(t, "", nil, &args)
 	assert.EqualError(t, err, `.A: error processing default value: strconv.ParseInt: parsing "x": invalid syntax`)
 }
 
@@ -1497,8 +1446,7 @@ func TestDefaultPositionalValues(t *testing.T) {
 		H *bool    `arg:"positional" default:"true"`
 	}
 
-	err := parse("456 789", &args)
-	require.NoError(t, err)
+	parse(t, "456 789", &args)
 
 	assert.Equal(t, 456, args.A)
 	if assert.NotNil(t, args.B) {
@@ -1523,7 +1471,7 @@ func TestDefaultValuesNotAllowedWithRequired(t *testing.T) {
 		A int `arg:"required" default:"123"` // required not allowed with default!
 	}
 
-	err := parse("", &args)
+	_, err := parseWithEnvErr(t, "", nil, &args)
 	assert.EqualError(t, err, ".A: 'required' cannot be used when a default value is specified")
 }
 
@@ -1532,7 +1480,7 @@ func TestDefaultValuesNotAllowedWithSlice(t *testing.T) {
 		A []int `default:"invalid"` // default values not allowed with slices
 	}
 
-	err := parse("", &args)
+	_, err := parseWithEnvErr(t, "", nil, &args)
 	assert.EqualError(t, err, ".A: default values are not supported for slice or map fields")
 }
 
@@ -1609,8 +1557,7 @@ func TestTextUnmarshalerEmpty(t *testing.T) {
 		Config mapWithUnmarshalText `arg:"--config"`
 	}
 
-	err := parse("", &args)
-	require.NoError(t, err)
+	parse(t, "", &args)
 	assert.Empty(t, args.Config)
 }
 
@@ -1620,8 +1567,7 @@ func TestTextUnmarshalerEmptyPointer(t *testing.T) {
 		Config *mapWithUnmarshalText `arg:"--config"`
 	}
 
-	err := parse("", &args)
-	require.NoError(t, err)
+	parse(t, "", &args)
 	assert.Nil(t, args.Config)
 }
 
@@ -1644,8 +1590,7 @@ func TestTextMarshalerUnmarshalerEmpty(t *testing.T) {
 		Config mapWithMarshalText `arg:"--config"`
 	}
 
-	err := parse("", &args)
-	require.NoError(t, err)
+	parse(t, "", &args)
 	assert.Empty(t, args.Config)
 }
 
@@ -1655,8 +1600,7 @@ func TestTextMarshalerUnmarshalerEmptyPointer(t *testing.T) {
 		Config *mapWithMarshalText `arg:"--config"`
 	}
 
-	err := parse("", &args)
-	require.NoError(t, err)
+	parse(t, "", &args)
 	assert.Nil(t, args.Config)
 }
 
diff --git a/reflect.go b/reflect.go
index 5d6acb3..19a7200 100644
--- a/reflect.go
+++ b/reflect.go
@@ -7,7 +7,7 @@ import (
 	"unicode"
 	"unicode/utf8"
 
-	scalar "github.com/alexflint/go-scalar"
+	"github.com/alexflint/go-scalar"
 )
 
 var textUnmarshalerType = reflect.TypeOf([]encoding.TextUnmarshaler{}).Elem()
diff --git a/reflect_test.go b/reflect_test.go
index 10909b3..ce39367 100644
--- a/reflect_test.go
+++ b/reflect_test.go
@@ -59,7 +59,7 @@ func TestCardinalityOf(t *testing.T) {
 
 type implementsTextUnmarshaler struct{}
 
-func (*implementsTextUnmarshaler) UnmarshalText(text []byte) error {
+func (*implementsTextUnmarshaler) UnmarshalText(_ []byte) error {
 	return nil
 }
 
diff --git a/sequence.go b/sequence.go
index 35a3614..5d01c01 100644
--- a/sequence.go
+++ b/sequence.go
@@ -5,7 +5,7 @@ import (
 	"reflect"
 	"strings"
 
-	scalar "github.com/alexflint/go-scalar"
+	"github.com/alexflint/go-scalar"
 )
 
 // setSliceOrMap parses a sequence of strings into a slice or map. If clear is
diff --git a/subcommand_test.go b/subcommand_test.go
index 2c61dd3..29b3291 100644
--- a/subcommand_test.go
+++ b/subcommand_test.go
@@ -42,8 +42,7 @@ func TestMinimalSubcommand(t *testing.T) {
 	var args struct {
 		List *listCmd `arg:"subcommand"`
 	}
-	p, err := pparse("list", &args)
-	require.NoError(t, err)
+	p := pparse(t, "list", &args)
 	assert.NotNil(t, args.List)
 	assert.Equal(t, args.List, p.Subcommand())
 	assert.Equal(t, []string{"list"}, p.SubcommandNames())
@@ -66,7 +65,7 @@ func TestNoSuchSubcommand(t *testing.T) {
 	var args struct {
 		List *listCmd `arg:"subcommand"`
 	}
-	_, err := pparse("invalid", &args)
+	_, err := parseWithEnvErr(t, "invalid", nil, &args)
 	assert.Error(t, err)
 }
 
@@ -76,8 +75,7 @@ func TestNamedSubcommand(t *testing.T) {
 	var args struct {
 		List *listCmd `arg:"subcommand:ls"`
 	}
-	p, err := pparse("ls", &args)
-	require.NoError(t, err)
+	p := pparse(t, "ls", &args)
 	assert.NotNil(t, args.List)
 	assert.Equal(t, args.List, p.Subcommand())
 	assert.Equal(t, []string{"ls"}, p.SubcommandNames())
@@ -89,8 +87,7 @@ func TestEmptySubcommand(t *testing.T) {
 	var args struct {
 		List *listCmd `arg:"subcommand"`
 	}
-	p, err := pparse("", &args)
-	require.NoError(t, err)
+	p := pparse(t, "", &args)
 	assert.Nil(t, args.List)
 	assert.Nil(t, p.Subcommand())
 	assert.Empty(t, p.SubcommandNames())
@@ -105,8 +102,7 @@ func TestTwoSubcommands(t *testing.T) {
 		Get  *getCmd  `arg:"subcommand"`
 		List *listCmd `arg:"subcommand"`
 	}
-	p, err := pparse("list", &args)
-	require.NoError(t, err)
+	p := pparse(t, "list", &args)
 	assert.Nil(t, args.Get)
 	assert.NotNil(t, args.List)
 	assert.Equal(t, args.List, p.Subcommand())
@@ -128,16 +124,14 @@ func TestSubcommandsWithOptions(t *testing.T) {
 
 	{
 		var args cmd
-		err := parse("list", &args)
-		require.NoError(t, err)
+		parse(t, "list", &args)
 		assert.Nil(t, args.Get)
 		assert.NotNil(t, args.List)
 	}
 
 	{
 		var args cmd
-		err := parse("list --limit 3", &args)
-		require.NoError(t, err)
+		parse(t, "list --limit 3", &args)
 		assert.Nil(t, args.Get)
 		assert.NotNil(t, args.List)
 		assert.Equal(t, args.List.Limit, 3)
@@ -145,8 +139,7 @@ func TestSubcommandsWithOptions(t *testing.T) {
 
 	{
 		var args cmd
-		err := parse("list --limit 3 --verbose", &args)
-		require.NoError(t, err)
+		parse(t, "list --limit 3 --verbose", &args)
 		assert.Nil(t, args.Get)
 		assert.NotNil(t, args.List)
 		assert.Equal(t, args.List.Limit, 3)
@@ -155,8 +148,7 @@ func TestSubcommandsWithOptions(t *testing.T) {
 
 	{
 		var args cmd
-		err := parse("list --verbose --limit 3", &args)
-		require.NoError(t, err)
+		parse(t, "list --verbose --limit 3", &args)
 		assert.Nil(t, args.Get)
 		assert.NotNil(t, args.List)
 		assert.Equal(t, args.List.Limit, 3)
@@ -165,8 +157,7 @@ func TestSubcommandsWithOptions(t *testing.T) {
 
 	{
 		var args cmd
-		err := parse("--verbose list --limit 3", &args)
-		require.NoError(t, err)
+		parse(t, "--verbose list --limit 3", &args)
 		assert.Nil(t, args.Get)
 		assert.NotNil(t, args.List)
 		assert.Equal(t, args.List.Limit, 3)
@@ -175,16 +166,14 @@ func TestSubcommandsWithOptions(t *testing.T) {
 
 	{
 		var args cmd
-		err := parse("get", &args)
-		require.NoError(t, err)
+		parse(t, "get", &args)
 		assert.NotNil(t, args.Get)
 		assert.Nil(t, args.List)
 	}
 
 	{
 		var args cmd
-		err := parse("get --name test", &args)
-		require.NoError(t, err)
+		parse(t, "get --name test", &args)
 		assert.NotNil(t, args.Get)
 		assert.Nil(t, args.List)
 		assert.Equal(t, args.Get.Name, "test")
@@ -207,8 +196,7 @@ func TestSubcommandsWithEnvVars(t *testing.T) {
 	{
 		var args cmd
 		setenv(t, "LIMIT", "123")
-		err := parse("list", &args)
-		require.NoError(t, err)
+		parse(t, "list", &args)
 		require.NotNil(t, args.List)
 		assert.Equal(t, 123, args.List.Limit)
 	}
@@ -216,7 +204,7 @@ func TestSubcommandsWithEnvVars(t *testing.T) {
 	{
 		var args cmd
 		setenv(t, "LIMIT", "not_an_integer")
-		err := parse("list", &args)
+		_, err := parseWithEnvErr(t, "list", nil, &args)
 		assert.Error(t, err)
 	}
 }
@@ -235,8 +223,7 @@ func TestNestedSubcommands(t *testing.T) {
 
 	{
 		var args root
-		p, err := pparse("grandparent parent child", &args)
-		require.NoError(t, err)
+		p := pparse(t, "grandparent parent child", &args)
 		require.NotNil(t, args.Grandparent)
 		require.NotNil(t, args.Grandparent.Parent)
 		require.NotNil(t, args.Grandparent.Parent.Child)
@@ -246,8 +233,7 @@ func TestNestedSubcommands(t *testing.T) {
 
 	{
 		var args root
-		p, err := pparse("grandparent parent", &args)
-		require.NoError(t, err)
+		p := pparse(t, "grandparent parent", &args)
 		require.NotNil(t, args.Grandparent)
 		require.NotNil(t, args.Grandparent.Parent)
 		require.Nil(t, args.Grandparent.Parent.Child)
@@ -257,8 +243,7 @@ func TestNestedSubcommands(t *testing.T) {
 
 	{
 		var args root
-		p, err := pparse("grandparent", &args)
-		require.NoError(t, err)
+		p := pparse(t, "grandparent", &args)
 		require.NotNil(t, args.Grandparent)
 		require.Nil(t, args.Grandparent.Parent)
 		assert.Equal(t, args.Grandparent, p.Subcommand())
@@ -267,8 +252,7 @@ func TestNestedSubcommands(t *testing.T) {
 
 	{
 		var args root
-		p, err := pparse("", &args)
-		require.NoError(t, err)
+		p := pparse(t, "", &args)
 		require.Nil(t, args.Grandparent)
 		assert.Nil(t, p.Subcommand())
 		assert.Empty(t, p.SubcommandNames())
@@ -286,16 +270,14 @@ func TestSubcommandsWithPositionals(t *testing.T) {
 
 	{
 		var args cmd
-		err := parse("list", &args)
-		require.NoError(t, err)
+		parse(t, "list", &args)
 		assert.NotNil(t, args.List)
 		assert.Equal(t, "", args.List.Pattern)
 	}
 
 	{
 		var args cmd
-		err := parse("list --format json", &args)
-		require.NoError(t, err)
+		parse(t, "list --format json", &args)
 		assert.NotNil(t, args.List)
 		assert.Equal(t, "", args.List.Pattern)
 		assert.Equal(t, "json", args.Format)
@@ -303,16 +285,14 @@ func TestSubcommandsWithPositionals(t *testing.T) {
 
 	{
 		var args cmd
-		err := parse("list somepattern", &args)
-		require.NoError(t, err)
+		parse(t, "list somepattern", &args)
 		assert.NotNil(t, args.List)
 		assert.Equal(t, "somepattern", args.List.Pattern)
 	}
 
 	{
 		var args cmd
-		err := parse("list somepattern --format json", &args)
-		require.NoError(t, err)
+		parse(t, "list somepattern --format json", &args)
 		assert.NotNil(t, args.List)
 		assert.Equal(t, "somepattern", args.List.Pattern)
 		assert.Equal(t, "json", args.Format)
@@ -320,8 +300,7 @@ func TestSubcommandsWithPositionals(t *testing.T) {
 
 	{
 		var args cmd
-		err := parse("list --format json somepattern", &args)
-		require.NoError(t, err)
+		parse(t, "list --format json somepattern", &args)
 		assert.NotNil(t, args.List)
 		assert.Equal(t, "somepattern", args.List.Pattern)
 		assert.Equal(t, "json", args.Format)
@@ -329,8 +308,7 @@ func TestSubcommandsWithPositionals(t *testing.T) {
 
 	{
 		var args cmd
-		err := parse("--format json list somepattern", &args)
-		require.NoError(t, err)
+		parse(t, "--format json list somepattern", &args)
 		assert.NotNil(t, args.List)
 		assert.Equal(t, "somepattern", args.List.Pattern)
 		assert.Equal(t, "json", args.Format)
@@ -338,8 +316,7 @@ func TestSubcommandsWithPositionals(t *testing.T) {
 
 	{
 		var args cmd
-		err := parse("--format json", &args)
-		require.NoError(t, err)
+		parse(t, "--format json", &args)
 		assert.Nil(t, args.List)
 		assert.Equal(t, "json", args.Format)
 	}
@@ -355,16 +332,14 @@ func TestSubcommandsWithMultiplePositionals(t *testing.T) {
 
 	{
 		var args cmd
-		err := parse("get", &args)
-		require.NoError(t, err)
+		parse(t, "get", &args)
 		assert.NotNil(t, args.Get)
 		assert.Empty(t, args.Get.Items)
 	}
 
 	{
 		var args cmd
-		err := parse("get --limit 5", &args)
-		require.NoError(t, err)
+		parse(t, "get --limit 5", &args)
 		assert.NotNil(t, args.Get)
 		assert.Empty(t, args.Get.Items)
 		assert.Equal(t, 5, args.Limit)
@@ -372,24 +347,21 @@ func TestSubcommandsWithMultiplePositionals(t *testing.T) {
 
 	{
 		var args cmd
-		err := parse("get item1", &args)
-		require.NoError(t, err)
+		parse(t, "get item1", &args)
 		assert.NotNil(t, args.Get)
 		assert.Equal(t, []string{"item1"}, args.Get.Items)
 	}
 
 	{
 		var args cmd
-		err := parse("get item1 item2 item3", &args)
-		require.NoError(t, err)
+		parse(t, "get item1 item2 item3", &args)
 		assert.NotNil(t, args.Get)
 		assert.Equal(t, []string{"item1", "item2", "item3"}, args.Get.Items)
 	}
 
 	{
 		var args cmd
-		err := parse("get item1 --limit 5 item2", &args)
-		require.NoError(t, err)
+		parse(t, "get item1 --limit 5 item2", &args)
 		assert.NotNil(t, args.Get)
 		assert.Equal(t, []string{"item1", "item2"}, args.Get.Items)
 		assert.Equal(t, 5, args.Limit)
diff --git a/usage.go b/usage.go
index a9f9844..c64e9a0 100644
--- a/usage.go
+++ b/usage.go
@@ -32,7 +32,7 @@ func (p *Parser) FailSubcommand(msg string, subcommand ...string) error {
 // failWithSubcommand prints usage information for the given subcommand to stderr and exits with non-zero status
 func (p *Parser) failWithSubcommand(msg string, cmd *command) {
 	p.writeUsageForSubcommand(p.config.Out, cmd)
-	fmt.Fprintln(p.config.Out, "error:", msg)
+	_, _ = fmt.Fprintln(p.config.Out, "error:", msg)
 	p.config.Exit(-1)
 }
 
@@ -74,7 +74,7 @@ func (p *Parser) writeUsageForSubcommand(w io.Writer, cmd *command) {
 	}
 
 	if p.version != "" {
-		fmt.Fprintln(w, p.version)
+		_, _ = fmt.Fprintln(w, p.version)
 	}
 
 	// make a list of ancestor commands so that we print with full context
@@ -86,33 +86,33 @@ func (p *Parser) writeUsageForSubcommand(w io.Writer, cmd *command) {
 	}
 
 	// print the beginning of the usage string
-	fmt.Fprint(w, "Usage:")
+	_, _ = fmt.Fprint(w, "Usage:")
 	for i := len(ancestors) - 1; i >= 0; i-- {
-		fmt.Fprint(w, " "+ancestors[i])
+		_, _ = fmt.Fprint(w, " "+ancestors[i])
 	}
 
 	// write the option component of the usage message
 	for _, spec := range shortOptions {
 		// prefix with a space
-		fmt.Fprint(w, " ")
+		_, _ = fmt.Fprint(w, " ")
 		if !spec.required {
-			fmt.Fprint(w, "[")
+			_, _ = fmt.Fprint(w, "[")
 		}
-		fmt.Fprint(w, synopsis(spec, "-"+spec.short))
+		_, _ = fmt.Fprint(w, synopsis(spec, "-"+spec.short))
 		if !spec.required {
-			fmt.Fprint(w, "]")
+			_, _ = fmt.Fprint(w, "]")
 		}
 	}
 
 	for _, spec := range longOptions {
 		// prefix with a space
-		fmt.Fprint(w, " ")
+		_, _ = fmt.Fprint(w, " ")
 		if !spec.required {
-			fmt.Fprint(w, "[")
+			_, _ = fmt.Fprint(w, "[")
 		}
-		fmt.Fprint(w, synopsis(spec, "--"+spec.long))
+		_, _ = fmt.Fprint(w, synopsis(spec, "--"+spec.long))
 		if !spec.required {
-			fmt.Fprint(w, "]")
+			_, _ = fmt.Fprint(w, "]")
 		}
 	}
 
@@ -130,40 +130,40 @@ func (p *Parser) writeUsageForSubcommand(w io.Writer, cmd *command) {
 	//    REQUIRED1 REQUIRED2 [OPTIONAL1 [REPEATEDOPTIONAL [REPEATEDOPTIONAL ...]]]
 	var closeBrackets int
 	for _, spec := range positionals {
-		fmt.Fprint(w, " ")
+		_, _ = fmt.Fprint(w, " ")
 		if !spec.required {
-			fmt.Fprint(w, "[")
+			_, _ = fmt.Fprint(w, "[")
 			closeBrackets += 1
 		}
 		if spec.cardinality == multiple {
-			fmt.Fprintf(w, "%s [%s ...]", spec.placeholder, spec.placeholder)
+			_, _ = fmt.Fprintf(w, "%s [%s ...]", spec.placeholder, spec.placeholder)
 		} else {
-			fmt.Fprint(w, spec.placeholder)
+			_, _ = fmt.Fprint(w, spec.placeholder)
 		}
 	}
-	fmt.Fprint(w, strings.Repeat("]", closeBrackets))
+	_, _ = fmt.Fprint(w, strings.Repeat("]", closeBrackets))
 
 	// if the program supports subcommands, give a hint to the user about their existence
 	if len(cmd.subcommands) > 0 {
-		fmt.Fprint(w, " <command> [<args>]")
+		_, _ = fmt.Fprint(w, " <command> [<args>]")
 	}
 
-	fmt.Fprint(w, "\n")
+	_, _ = fmt.Fprint(w, "\n")
 }
 
 func printTwoCols(w io.Writer, left, help string, defaultVal string, envVal string) {
 	lhs := "  " + left
-	fmt.Fprint(w, lhs)
+	_, _ = fmt.Fprint(w, lhs)
 	if help != "" {
 		if len(lhs)+2 < colWidth {
-			fmt.Fprint(w, strings.Repeat(" ", colWidth-len(lhs)))
+			_, _ = fmt.Fprint(w, strings.Repeat(" ", colWidth-len(lhs)))
 		} else {
-			fmt.Fprint(w, "\n"+strings.Repeat(" ", colWidth))
+			_, _ = fmt.Fprint(w, "\n"+strings.Repeat(" ", colWidth))
 		}
-		fmt.Fprint(w, help)
+		_, _ = fmt.Fprint(w, help)
 	}
 
-	bracketsContent := []string{}
+	var bracketsContent []string
 
 	if defaultVal != "" {
 		bracketsContent = append(bracketsContent,
@@ -178,9 +178,9 @@ func printTwoCols(w io.Writer, left, help string, defaultVal string, envVal stri
 	}
 
 	if len(bracketsContent) > 0 {
-		fmt.Fprintf(w, " [%s]", strings.Join(bracketsContent, ", "))
+		_, _ = fmt.Fprintf(w, " [%s]", strings.Join(bracketsContent, ", "))
 	}
-	fmt.Fprint(w, "\n")
+	_, _ = fmt.Fprint(w, "\n")
 }
 
 // WriteHelp writes the usage string followed by the full help string for each option
@@ -224,13 +224,13 @@ func (p *Parser) writeHelpForSubcommand(w io.Writer, cmd *command) {
 	}
 
 	if p.description != "" {
-		fmt.Fprintln(w, p.description)
+		_, _ = fmt.Fprintln(w, p.description)
 	}
 	p.writeUsageForSubcommand(w, cmd)
 
 	// write the list of positionals
 	if len(positionals) > 0 {
-		fmt.Fprint(w, "\nPositional arguments:\n")
+		_, _ = fmt.Fprint(w, "\nPositional arguments:\n")
 		for _, spec := range positionals {
 			printTwoCols(w, spec.placeholder, spec.help, "", "")
 		}
@@ -238,7 +238,7 @@ func (p *Parser) writeHelpForSubcommand(w io.Writer, cmd *command) {
 
 	// write the list of options with the short-only ones first to match the usage string
 	if len(shortOptions)+len(longOptions) > 0 || cmd.parent == nil {
-		fmt.Fprint(w, "\nOptions:\n")
+		_, _ = fmt.Fprint(w, "\nOptions:\n")
 		for _, spec := range shortOptions {
 			p.printOption(w, spec)
 		}
@@ -260,7 +260,7 @@ func (p *Parser) writeHelpForSubcommand(w io.Writer, cmd *command) {
 
 	// write the list of global options
 	if len(globals) > 0 {
-		fmt.Fprint(w, "\nGlobal options:\n")
+		_, _ = fmt.Fprint(w, "\nGlobal options:\n")
 		for _, spec := range globals {
 			p.printOption(w, spec)
 			if spec.long == "version" {
@@ -286,7 +286,7 @@ func (p *Parser) writeHelpForSubcommand(w io.Writer, cmd *command) {
 
 	// write the list of environment only variables
 	if len(envOnlyOptions) > 0 {
-		fmt.Fprint(w, "\nEnvironment variables:\n")
+		_, _ = fmt.Fprint(w, "\nEnvironment variables:\n")
 		for _, spec := range envOnlyOptions {
 			p.printEnvOnlyVar(w, spec)
 		}
@@ -294,14 +294,14 @@ func (p *Parser) writeHelpForSubcommand(w io.Writer, cmd *command) {
 
 	// write the list of subcommands
 	if len(cmd.subcommands) > 0 {
-		fmt.Fprint(w, "\nCommands:\n")
+		_, _ = fmt.Fprint(w, "\nCommands:\n")
 		for _, subcmd := range cmd.subcommands {
 			printTwoCols(w, subcmd.name, subcmd.help, "", "")
 		}
 	}
 
 	if p.epilogue != "" {
-		fmt.Fprintln(w, "\n"+p.epilogue)
+		_, _ = fmt.Fprintln(w, "\n"+p.epilogue)
 	}
 }
 
diff --git a/usage_test.go b/usage_test.go
index 1a64ad4..f32aa36 100644
--- a/usage_test.go
+++ b/usage_test.go
@@ -97,12 +97,12 @@ Environment variables:
 
 type MyEnum int
 
-func (n *MyEnum) UnmarshalText(b []byte) error {
+func (n *MyEnum) UnmarshalText(_ []byte) error {
 	return nil
 }
 
 func (n *MyEnum) MarshalText() ([]byte, error) {
-	return nil, errors.New("There was a problem")
+	return nil, errors.New("there was a problem")
 }
 
 func TestUsageWithDefaults(t *testing.T) {
@@ -142,7 +142,7 @@ func TestUsageCannotMarshalToString(t *testing.T) {
 	v := MyEnum(42)
 	args.Name = &v
 	_, err := NewParser(Config{Program: "example"}, &args)
-	assert.EqualError(t, err, `args.Name: error marshaling default value to string: There was a problem`)
+	assert.EqualError(t, err, `args.Name: error marshaling default value to string: there was a problem`)
 }
 
 func TestUsageLongPositionalWithHelp_legacyForm(t *testing.T) {
@@ -455,7 +455,8 @@ Global options:
 	assert.Equal(t, expectedHelp[1:], help.String())
 
 	var help2 bytes.Buffer
-	p.WriteHelpForSubcommand(&help2, "child", "nested")
+	err = p.WriteHelpForSubcommand(&help2, "child", "nested")
+	require.NoError(t, err)
 	assert.Equal(t, expectedHelp[1:], help2.String())
 
 	var usage bytes.Buffer
@@ -463,7 +464,8 @@ Global options:
 	assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String()))
 
 	var usage2 bytes.Buffer
-	p.WriteUsageForSubcommand(&usage2, "child", "nested")
+	err = p.WriteUsageForSubcommand(&usage2, "child", "nested")
+	require.NoError(t, err)
 	assert.Equal(t, expectedUsage, strings.TrimSpace(usage2.String()))
 }