summaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/Makefile10
-rw-r--r--test/example_test.go540
-rw-r--r--test/go.mod11
-rw-r--r--test/go.sum10
-rw-r--r--test/parse_test.go1739
-rw-r--r--test/reflect_test.go112
-rw-r--r--test/sequence_test.go152
-rw-r--r--test/subcommand_test.go508
-rw-r--r--test/usage_test.go717
9 files changed, 3799 insertions, 0 deletions
diff --git a/test/Makefile b/test/Makefile
new file mode 100644
index 0000000..7231daa
--- /dev/null
+++ b/test/Makefile
@@ -0,0 +1,10 @@
+all:
+ @echo
+ @echo
+
+test:
+
+redomod:
+ rm -f go.*
+ GO111MODULE= go mod init
+ GO111MODULE= go mod tidy
diff --git a/test/example_test.go b/test/example_test.go
new file mode 100644
index 0000000..4bd7632
--- /dev/null
+++ b/test/example_test.go
@@ -0,0 +1,540 @@
+package arg
+
+import (
+ "fmt"
+ "net"
+ "net/mail"
+ "net/url"
+ "os"
+ "strings"
+ "time"
+)
+
+func split(s string) []string {
+ return strings.Split(s, " ")
+}
+
+// This example demonstrates basic usage
+func Example() {
+ // These are the args you would pass in on the command line
+ os.Args = split("./example --foo=hello --bar")
+
+ var args struct {
+ Foo string
+ Bar bool
+ }
+ MustParse(&args)
+ fmt.Println(args.Foo, args.Bar)
+ // output: hello true
+}
+
+// This example demonstrates arguments that have default values
+func Example_defaultValues() {
+ // These are the args you would pass in on the command line
+ os.Args = split("./example")
+
+ var args struct {
+ Foo string `default:"abc"`
+ }
+ MustParse(&args)
+ fmt.Println(args.Foo)
+ // output: abc
+}
+
+// This example demonstrates arguments that are required
+func Example_requiredArguments() {
+ // These are the args you would pass in on the command line
+ os.Args = split("./example --foo=abc --bar")
+
+ var args struct {
+ Foo string `arg:"required"`
+ Bar bool
+ }
+ MustParse(&args)
+ fmt.Println(args.Foo, args.Bar)
+ // output: abc true
+}
+
+// This example demonstrates positional arguments
+func Example_positionalArguments() {
+ // These are the args you would pass in on the command line
+ os.Args = split("./example in out1 out2 out3")
+
+ var args struct {
+ Input string `arg:"positional"`
+ Output []string `arg:"positional"`
+ }
+ MustParse(&args)
+ fmt.Println("In:", args.Input)
+ fmt.Println("Out:", args.Output)
+ // output:
+ // In: in
+ // Out: [out1 out2 out3]
+}
+
+// This example demonstrates arguments that have multiple values
+func Example_multipleValues() {
+ // The args you would pass in on the command line
+ os.Args = split("./example --database localhost --ids 1 2 3")
+
+ var args struct {
+ Database string
+ IDs []int64
+ }
+ MustParse(&args)
+ fmt.Printf("Fetching the following IDs from %s: %v", args.Database, args.IDs)
+ // output: Fetching the following IDs from localhost: [1 2 3]
+}
+
+// This example demonstrates arguments with keys and values
+func Example_mappings() {
+ // The args you would pass in on the command line
+ os.Args = split("./example --userids john=123 mary=456")
+
+ var args struct {
+ UserIDs map[string]int
+ }
+ MustParse(&args)
+ fmt.Println(args.UserIDs)
+ // output: map[john:123 mary:456]
+}
+
+type commaSeparated struct {
+ M map[string]string
+}
+
+func (c *commaSeparated) UnmarshalText(b []byte) error {
+ c.M = make(map[string]string)
+ for _, part := range strings.Split(string(b), ",") {
+ pos := strings.Index(part, "=")
+ if pos == -1 {
+ return fmt.Errorf("error parsing %q, expected format key=value", part)
+ }
+ c.M[part[:pos]] = part[pos+1:]
+ }
+ return nil
+}
+
+// This example demonstrates arguments with keys and values separated by commas
+func Example_mappingWithCommas() {
+ // The args you would pass in on the command line
+ os.Args = split("./example --values one=two,three=four")
+
+ var args struct {
+ Values commaSeparated
+ }
+ MustParse(&args)
+ fmt.Println(args.Values.M)
+ // output: map[one:two three:four]
+}
+
+// This eample demonstrates multiple value arguments that can be mixed with
+// other arguments.
+func Example_multipleMixed() {
+ os.Args = split("./example -c cmd1 db1 -f file1 db2 -c cmd2 -f file2 -f file3 db3 -c cmd3")
+ var args struct {
+ Commands []string `arg:"-c,separate"`
+ Files []string `arg:"-f,separate"`
+ Databases []string `arg:"positional"`
+ }
+ MustParse(&args)
+ fmt.Println("Commands:", args.Commands)
+ fmt.Println("Files:", args.Files)
+ fmt.Println("Databases:", args.Databases)
+
+ // output:
+ // Commands: [cmd1 cmd2 cmd3]
+ // Files: [file1 file2 file3]
+ // Databases: [db1 db2 db3]
+}
+
+// This example shows the usage string generated by go-arg
+func Example_helpText() {
+ // These are the args you would pass in on the command line
+ os.Args = split("./example --help")
+
+ var args struct {
+ Input string `arg:"positional,required"`
+ Output []string `arg:"positional"`
+ Verbose bool `arg:"-v" help:"verbosity level"`
+ Dataset string `help:"dataset to use"`
+ Optimize int `arg:"-O,--optim" help:"optimization level"`
+ }
+
+ // This is only necessary when running inside golang's runnable example harness
+ mustParseExit = func(int) {}
+
+ MustParse(&args)
+
+ // output:
+ // Usage: example [--verbose] [--dataset DATASET] [--optim OPTIM] INPUT [OUTPUT [OUTPUT ...]]
+ //
+ // Positional arguments:
+ // INPUT
+ // OUTPUT
+ //
+ // Options:
+ // --verbose, -v verbosity level
+ // --dataset DATASET dataset to use
+ // --optim OPTIM, -O OPTIM
+ // optimization level
+ // --help, -h display this help and exit
+}
+
+// This example shows the usage string generated by go-arg with customized placeholders
+func Example_helpPlaceholder() {
+ // These are the args you would pass in on the command line
+ os.Args = split("./example --help")
+
+ var args struct {
+ Input string `arg:"positional,required" placeholder:"SRC"`
+ Output []string `arg:"positional" placeholder:"DST"`
+ Optimize int `arg:"-O" help:"optimization level" placeholder:"LEVEL"`
+ MaxJobs int `arg:"-j" help:"maximum number of simultaneous jobs" placeholder:"N"`
+ }
+
+ // This is only necessary when running inside golang's runnable example harness
+ mustParseExit = func(int) {}
+
+ MustParse(&args)
+
+ // output:
+
+ // Usage: example [--optimize LEVEL] [--maxjobs N] SRC [DST [DST ...]]
+
+ // Positional arguments:
+ // SRC
+ // DST
+
+ // Options:
+ // --optimize LEVEL, -O LEVEL
+ // optimization level
+ // --maxjobs N, -j N maximum number of simultaneous jobs
+ // --help, -h display this help and exit
+}
+
+// This example shows the usage string generated by go-arg when using subcommands
+func Example_helpTextWithSubcommand() {
+ // These are the args you would pass in on the command line
+ os.Args = split("./example --help")
+
+ type getCmd struct {
+ Item string `arg:"positional" help:"item to fetch"`
+ }
+
+ type listCmd struct {
+ Format string `help:"output format"`
+ Limit int
+ }
+
+ var args struct {
+ Verbose bool
+ Get *getCmd `arg:"subcommand" help:"fetch an item and print it"`
+ List *listCmd `arg:"subcommand" help:"list available items"`
+ }
+
+ // This is only necessary when running inside golang's runnable example harness
+ mustParseExit = func(int) {}
+
+ MustParse(&args)
+
+ // output:
+ // Usage: example [--verbose] <command> [<args>]
+ //
+ // Options:
+ // --verbose
+ // --help, -h display this help and exit
+ //
+ // Commands:
+ // get fetch an item and print it
+ // list list available items
+}
+
+// This example shows the usage string generated by go-arg when using subcommands
+func Example_helpTextWhenUsingSubcommand() {
+ // These are the args you would pass in on the command line
+ os.Args = split("./example get --help")
+
+ type getCmd struct {
+ Item string `arg:"positional,required" help:"item to fetch"`
+ }
+
+ type listCmd struct {
+ Format string `help:"output format"`
+ Limit int
+ }
+
+ var args struct {
+ Verbose bool
+ Get *getCmd `arg:"subcommand" help:"fetch an item and print it"`
+ List *listCmd `arg:"subcommand" help:"list available items"`
+ }
+
+ // This is only necessary when running inside golang's runnable example harness
+ mustParseExit = func(int) {}
+
+ MustParse(&args)
+
+ // output:
+ // Usage: example get ITEM
+ //
+ // Positional arguments:
+ // ITEM item to fetch
+ //
+ // Global options:
+ // --verbose
+ // --help, -h display this help and exit
+}
+
+// This example shows how to print help for an explicit subcommand
+func Example_writeHelpForSubcommand() {
+ // These are the args you would pass in on the command line
+ os.Args = split("./example get --help")
+
+ type getCmd struct {
+ Item string `arg:"positional" help:"item to fetch"`
+ }
+
+ type listCmd struct {
+ Format string `help:"output format"`
+ Limit int
+ }
+
+ var args struct {
+ Verbose bool
+ Get *getCmd `arg:"subcommand" help:"fetch an item and print it"`
+ List *listCmd `arg:"subcommand" help:"list available items"`
+ }
+
+ // This is only necessary when running inside golang's runnable example harness
+ exit := func(int) {}
+
+ p, err := NewParser(Config{Exit: exit}, &args)
+ if err != nil {
+ fmt.Println(err)
+ os.Exit(1)
+ }
+
+ err = p.WriteHelpForSubcommand(os.Stdout, "list")
+ if err != nil {
+ fmt.Println(err)
+ os.Exit(1)
+ }
+
+ // output:
+ // Usage: example list [--format FORMAT] [--limit LIMIT]
+ //
+ // Options:
+ // --format FORMAT output format
+ // --limit LIMIT
+ //
+ // Global options:
+ // --verbose
+ // --help, -h display this help and exit
+}
+
+// This example shows how to print help for a subcommand that is nested several levels deep
+func Example_writeHelpForSubcommandNested() {
+ // These are the args you would pass in on the command line
+ os.Args = split("./example get --help")
+
+ type mostNestedCmd struct {
+ Item string
+ }
+
+ type nestedCmd struct {
+ MostNested *mostNestedCmd `arg:"subcommand"`
+ }
+
+ type topLevelCmd struct {
+ Nested *nestedCmd `arg:"subcommand"`
+ }
+
+ var args struct {
+ TopLevel *topLevelCmd `arg:"subcommand"`
+ }
+
+ // This is only necessary when running inside golang's runnable example harness
+ exit := func(int) {}
+
+ p, err := NewParser(Config{Exit: exit}, &args)
+ if err != nil {
+ fmt.Println(err)
+ os.Exit(1)
+ }
+
+ err = p.WriteHelpForSubcommand(os.Stdout, "toplevel", "nested", "mostnested")
+ if err != nil {
+ fmt.Println(err)
+ os.Exit(1)
+ }
+
+ // output:
+ // Usage: example toplevel nested mostnested [--item ITEM]
+ //
+ // Options:
+ // --item ITEM
+ // --help, -h display this help and exit
+}
+
+// This example shows the error string generated by go-arg when an invalid option is provided
+func Example_errorText() {
+ // These are the args you would pass in on the command line
+ os.Args = split("./example --optimize INVALID")
+
+ var args struct {
+ Input string `arg:"positional,required"`
+ Output []string `arg:"positional"`
+ Verbose bool `arg:"-v" help:"verbosity level"`
+ Dataset string `help:"dataset to use"`
+ Optimize int `arg:"-O,help:optimization level"`
+ }
+
+ // This is only necessary when running inside golang's runnable example harness
+ mustParseExit = func(int) {}
+
+ MustParse(&args)
+
+ // output:
+ // Usage: example [--verbose] [--dataset DATASET] [--optimize OPTIMIZE] INPUT [OUTPUT [OUTPUT ...]]
+ // error: error processing --optimize: strconv.ParseInt: parsing "INVALID": invalid syntax
+}
+
+// This example shows the error string generated by go-arg when an invalid option is provided
+func Example_errorTextForSubcommand() {
+ // These are the args you would pass in on the command line
+ os.Args = split("./example get --count INVALID")
+
+ type getCmd struct {
+ Count int
+ }
+
+ var args struct {
+ Get *getCmd `arg:"subcommand"`
+ }
+
+ // This is only necessary when running inside golang's runnable example harness
+ mustParseExit = func(int) {}
+
+ MustParse(&args)
+
+ // output:
+ // Usage: example get [--count COUNT]
+ // error: error processing --count: strconv.ParseInt: parsing "INVALID": invalid syntax
+}
+
+// This example demonstrates use of subcommands
+func Example_subcommand() {
+ // These are the args you would pass in on the command line
+ os.Args = split("./example commit -a -m what-this-commit-is-about")
+
+ type CheckoutCmd struct {
+ Branch string `arg:"positional"`
+ Track bool `arg:"-t"`
+ }
+ type CommitCmd struct {
+ All bool `arg:"-a"`
+ Message string `arg:"-m"`
+ }
+ type PushCmd struct {
+ Remote string `arg:"positional"`
+ Branch string `arg:"positional"`
+ SetUpstream bool `arg:"-u"`
+ }
+ var args struct {
+ Checkout *CheckoutCmd `arg:"subcommand:checkout"`
+ Commit *CommitCmd `arg:"subcommand:commit"`
+ Push *PushCmd `arg:"subcommand:push"`
+ Quiet bool `arg:"-q"` // this flag is global to all subcommands
+ }
+
+ // This is only necessary when running inside golang's runnable example harness
+ mustParseExit = func(int) {}
+
+ MustParse(&args)
+
+ switch {
+ case args.Checkout != nil:
+ fmt.Printf("checkout requested for branch %s\n", args.Checkout.Branch)
+ case args.Commit != nil:
+ fmt.Printf("commit requested with message \"%s\"\n", args.Commit.Message)
+ case args.Push != nil:
+ fmt.Printf("push requested from %s to %s\n", args.Push.Branch, args.Push.Remote)
+ }
+
+ // output:
+ // commit requested with message "what-this-commit-is-about"
+}
+
+func Example_allSupportedTypes() {
+ // These are the args you would pass in on the command line
+ os.Args = []string{}
+
+ var args struct {
+ Bool bool
+ Byte byte
+ Rune rune
+ Int int
+ Int8 int8
+ Int16 int16
+ Int32 int32
+ Int64 int64
+ Float32 float32
+ Float64 float64
+ String string
+ Duration time.Duration
+ URL url.URL
+ Email mail.Address
+ MAC net.HardwareAddr
+ }
+
+ // go-arg supports each of the types above, as well as pointers to any of
+ // the above and slices of any of the above. It also supports any types that
+ // implements encoding.TextUnmarshaler.
+
+ MustParse(&args)
+
+ // output:
+}
+
+func Example_envVarOnly() {
+ os.Args = split("./example")
+ _ = os.Setenv("AUTH_KEY", "my_key")
+
+ defer os.Unsetenv("AUTH_KEY")
+
+ var args struct {
+ AuthKey string `arg:"--,env:AUTH_KEY"`
+ }
+
+ MustParse(&args)
+
+ fmt.Println(args.AuthKey)
+ // output: my_key
+}
+
+func Example_envVarOnlyShouldIgnoreFlag() {
+ os.Args = split("./example --=my_key")
+
+ var args struct {
+ AuthKey string `arg:"--,env:AUTH_KEY"`
+ }
+
+ err := Parse(&args)
+
+ fmt.Println(err)
+ // output: unknown argument --=my_key
+}
+
+func Example_envVarOnlyShouldIgnoreShortFlag() {
+ os.Args = split("./example -=my_key")
+
+ var args struct {
+ AuthKey string `arg:"--,env:AUTH_KEY"`
+ }
+
+ err := Parse(&args)
+
+ fmt.Println(err)
+ // output: unknown argument -=my_key
+}
diff --git a/test/go.mod b/test/go.mod
new file mode 100644
index 0000000..5c6cfd2
--- /dev/null
+++ b/test/go.mod
@@ -0,0 +1,11 @@
+module go.wit.com/dev/alexflint/arg/test
+
+go 1.21.4
+
+require 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.1 // indirect
+)
diff --git a/test/go.sum b/test/go.sum
new file mode 100644
index 0000000..fa4b6e6
--- /dev/null
+++ b/test/go.sum
@@ -0,0 +1,10 @@
+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/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.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/test/parse_test.go b/test/parse_test.go
new file mode 100644
index 0000000..d53b483
--- /dev/null
+++ b/test/parse_test.go
@@ -0,0 +1,1739 @@
+package arg
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "net"
+ "net/mail"
+ "net/url"
+ "os"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/stretchr/testify/assert"
+ "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 parse(cmdline string, dest interface{}) error {
+ _, err := pparse(cmdline, dest)
+ return err
+}
+
+func pparse(cmdline string, dest interface{}) (*Parser, error) {
+ return parseWithEnv(cmdline, nil, dest)
+}
+
+func parseWithEnv(cmdline string, env []string, dest interface{}) (*Parser, error) {
+ p, err := NewParser(Config{}, dest)
+ if err != nil {
+ return nil, err
+ }
+
+ // split the command line
+ var parts []string
+ if len(cmdline) > 0 {
+ parts = strings.Split(cmdline, " ")
+ }
+
+ // split the environment vars
+ for _, s := range env {
+ pos := strings.Index(s, "=")
+ 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
+ }
+ }
+
+ // execute the parser
+ return p, p.Parse(parts)
+}
+
+func TestString(t *testing.T) {
+ var args struct {
+ Foo string
+ Ptr *string
+ }
+ err := parse("--foo bar --ptr baz", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "bar", args.Foo)
+ assert.Equal(t, "baz", *args.Ptr)
+}
+
+func TestBool(t *testing.T) {
+ var args struct {
+ A bool
+ B bool
+ C *bool
+ D *bool
+ }
+ err := parse("--a --c", &args)
+ require.NoError(t, err)
+ assert.True(t, args.A)
+ assert.False(t, args.B)
+ assert.True(t, *args.C)
+ assert.Nil(t, args.D)
+}
+
+func TestInt(t *testing.T) {
+ var args struct {
+ Foo int
+ Ptr *int
+ }
+ err := parse("--foo 7 --ptr 8", &args)
+ require.NoError(t, err)
+ assert.EqualValues(t, 7, args.Foo)
+ assert.EqualValues(t, 8, *args.Ptr)
+}
+
+func TestHexOctBin(t *testing.T) {
+ var args struct {
+ Hex int
+ Oct int
+ Bin int
+ Underscored int
+ }
+ err := parse("--hex 0xA --oct 0o10 --bin 0b101 --underscored 123_456", &args)
+ require.NoError(t, err)
+ assert.EqualValues(t, 10, args.Hex)
+ assert.EqualValues(t, 8, args.Oct)
+ assert.EqualValues(t, 5, args.Bin)
+ assert.EqualValues(t, 123456, args.Underscored)
+}
+
+func TestNegativeInt(t *testing.T) {
+ var args struct {
+ Foo int
+ }
+ err := parse("-foo -100", &args)
+ require.NoError(t, err)
+ assert.EqualValues(t, args.Foo, -100)
+}
+
+func TestNegativeIntAndFloatAndTricks(t *testing.T) {
+ var args struct {
+ Foo int
+ Bar float64
+ N int `arg:"--100"`
+ }
+ err := parse("-foo -100 -bar -60.14 -100 -100", &args)
+ require.NoError(t, err)
+ assert.EqualValues(t, args.Foo, -100)
+ assert.EqualValues(t, args.Bar, -60.14)
+ assert.EqualValues(t, args.N, -100)
+}
+
+func TestUint(t *testing.T) {
+ var args struct {
+ Foo uint
+ Ptr *uint
+ }
+ err := parse("--foo 7 --ptr 8", &args)
+ require.NoError(t, err)
+ assert.EqualValues(t, 7, args.Foo)
+ assert.EqualValues(t, 8, *args.Ptr)
+}
+
+func TestFloat(t *testing.T) {
+ var args struct {
+ Foo float32
+ Ptr *float32
+ }
+ err := parse("--foo 3.4 --ptr 3.5", &args)
+ require.NoError(t, err)
+ assert.EqualValues(t, 3.4, args.Foo)
+ assert.EqualValues(t, 3.5, *args.Ptr)
+}
+
+func TestDuration(t *testing.T) {
+ var args struct {
+ Foo time.Duration
+ Ptr *time.Duration
+ }
+ err := parse("--foo 3ms --ptr 4ms", &args)
+ require.NoError(t, err)
+ assert.Equal(t, 3*time.Millisecond, args.Foo)
+ assert.Equal(t, 4*time.Millisecond, *args.Ptr)
+}
+
+func TestInvalidDuration(t *testing.T) {
+ var args struct {
+ Foo time.Duration
+ }
+ err := parse("--foo xxx", &args)
+ require.Error(t, err)
+}
+
+func TestIntPtr(t *testing.T) {
+ var args struct {
+ Foo *int
+ }
+ err := parse("--foo 123", &args)
+ require.NoError(t, err)
+ require.NotNil(t, args.Foo)
+ assert.Equal(t, 123, *args.Foo)
+}
+
+func TestIntPtrNotPresent(t *testing.T) {
+ var args struct {
+ Foo *int
+ }
+ err := parse("", &args)
+ require.NoError(t, err)
+ assert.Nil(t, args.Foo)
+}
+
+func TestMixed(t *testing.T) {
+ var args struct {
+ Foo string `arg:"-f"`
+ Bar int
+ Baz uint `arg:"positional"`
+ Ham bool
+ Spam float32
+ }
+ args.Bar = 3
+ err := parse("123 -spam=1.2 -ham -f xyz", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "xyz", args.Foo)
+ assert.Equal(t, 3, args.Bar)
+ assert.Equal(t, uint(123), args.Baz)
+ assert.Equal(t, true, args.Ham)
+ assert.EqualValues(t, 1.2, args.Spam)
+}
+
+func TestRequired(t *testing.T) {
+ var args struct {
+ Foo string `arg:"required"`
+ }
+ err := parse("", &args)
+ require.Error(t, err, "--foo is required")
+}
+
+func TestRequiredWithEnv(t *testing.T) {
+ var args struct {
+ Foo string `arg:"required,env:FOO"`
+ }
+ err := parse("", &args)
+ require.Error(t, err, "--foo is required (or environment variable FOO)")
+}
+
+func TestRequiredWithEnvOnly(t *testing.T) {
+ var args struct {
+ Foo string `arg:"required,--,-,env:FOO"`
+ }
+ _, err := parseWithEnv("", []string{}, &args)
+ require.Error(t, err, "environment variable FOO is required")
+}
+
+func TestShortFlag(t *testing.T) {
+ var args struct {
+ Foo string `arg:"-f"`
+ }
+
+ err := parse("-f xyz", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "xyz", args.Foo)
+
+ err = parse("-foo xyz", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "xyz", args.Foo)
+
+ err = parse("--foo xyz", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "xyz", args.Foo)
+}
+
+func TestInvalidShortFlag(t *testing.T) {
+ var args struct {
+ Foo string `arg:"-foo"`
+ }
+ err := parse("", &args)
+ assert.Error(t, err)
+}
+
+func TestLongFlag(t *testing.T) {
+ var args struct {
+ Foo string `arg:"--abc"`
+ }
+
+ err := parse("-abc xyz", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "xyz", args.Foo)
+
+ err = parse("--abc xyz", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "xyz", args.Foo)
+}
+
+func TestSlice(t *testing.T) {
+ var args struct {
+ Strings []string
+ }
+ err := parse("--strings a b c", &args)
+ require.NoError(t, err)
+ assert.Equal(t, []string{"a", "b", "c"}, args.Strings)
+}
+func TestSliceOfBools(t *testing.T) {
+ var args struct {
+ B []bool
+ }
+
+ err := parse("--b true false true", &args)
+ require.NoError(t, err)
+ assert.Equal(t, []bool{true, false, true}, args.B)
+}
+
+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)
+ assert.Len(t, args.Values, 3)
+ assert.Equal(t, 1, args.Values["a"])
+ assert.Equal(t, 2, args.Values["b"])
+ assert.Equal(t, 3, args.Values["c"])
+}
+
+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)
+ assert.Len(t, args.Values, 3)
+ assert.Equal(t, 1, args.Values["a"])
+ assert.Equal(t, 2, args.Values["b"])
+ assert.Equal(t, 3, args.Values["c"])
+}
+
+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)
+ assert.Len(t, args.Values, 3)
+ assert.Equal(t, 1, args.Values["a"])
+ assert.Equal(t, 2, args.Values["b"])
+ assert.Equal(t, 3, args.Values["c"])
+}
+
+func TestPlaceholder(t *testing.T) {
+ var args struct {
+ Input string `arg:"positional" placeholder:"SRC"`
+ Output []string `arg:"positional" placeholder:"DST"`
+ 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)
+}
+
+func TestNoLongName(t *testing.T) {
+ var args struct {
+ ShortOnly string `arg:"-s,--"`
+ EnvOnly string `arg:"--,env"`
+ }
+ setenv(t, "ENVONLY", "TestVal")
+ err := parse("-s TestVal2", &args)
+ assert.NoError(t, err)
+ assert.Equal(t, "TestVal", args.EnvOnly)
+ assert.Equal(t, "TestVal2", args.ShortOnly)
+}
+
+func TestCaseSensitive(t *testing.T) {
+ var args struct {
+ Lower bool `arg:"-v"`
+ Upper bool `arg:"-V"`
+ }
+
+ err := parse("-v", &args)
+ require.NoError(t, err)
+ assert.True(t, args.Lower)
+ assert.False(t, args.Upper)
+}
+
+func TestCaseSensitive2(t *testing.T) {
+ var args struct {
+ Lower bool `arg:"-v"`
+ Upper bool `arg:"-V"`
+ }
+
+ err := parse("-V", &args)
+ require.NoError(t, err)
+ assert.False(t, args.Lower)
+ assert.True(t, args.Upper)
+}
+
+func TestPositional(t *testing.T) {
+ var args struct {
+ Input string `arg:"positional"`
+ Output string `arg:"positional"`
+ }
+ err := parse("foo", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "foo", args.Input)
+ assert.Equal(t, "", args.Output)
+}
+
+func TestPositionalPointer(t *testing.T) {
+ var args struct {
+ Input string `arg:"positional"`
+ Output []*string `arg:"positional"`
+ }
+ err := parse("foo bar baz", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "foo", args.Input)
+ bar := "bar"
+ baz := "baz"
+ assert.Equal(t, []*string{&bar, &baz}, args.Output)
+}
+
+func TestRequiredPositional(t *testing.T) {
+ var args struct {
+ Input string `arg:"positional"`
+ Output string `arg:"positional,required"`
+ }
+ err := parse("foo", &args)
+ assert.Error(t, err)
+}
+
+func TestRequiredPositionalMultiple(t *testing.T) {
+ var args struct {
+ Input string `arg:"positional"`
+ Multiple []string `arg:"positional,required"`
+ }
+ err := parse("foo", &args)
+ assert.Error(t, err)
+}
+
+func TestTooManyPositional(t *testing.T) {
+ var args struct {
+ Input string `arg:"positional"`
+ Output string `arg:"positional"`
+ }
+ err := parse("foo bar baz", &args)
+ assert.Error(t, err)
+}
+
+func TestMultiple(t *testing.T) {
+ var args struct {
+ Foo []int
+ Bar []string
+ }
+ err := parse("--foo 1 2 3 --bar x y z", &args)
+ require.NoError(t, err)
+ assert.Equal(t, []int{1, 2, 3}, args.Foo)
+ assert.Equal(t, []string{"x", "y", "z"}, args.Bar)
+}
+
+func TestMultiplePositionals(t *testing.T) {
+ var args struct {
+ Input string `arg:"positional"`
+ Multiple []string `arg:"positional,required"`
+ }
+ err := parse("foo a b c", &args)
+ assert.NoError(t, err)
+ assert.Equal(t, "foo", args.Input)
+ assert.Equal(t, []string{"a", "b", "c"}, args.Multiple)
+}
+
+func TestMultipleWithEq(t *testing.T) {
+ var args struct {
+ Foo []int
+ Bar []string
+ }
+ err := parse("--foo 1 2 3 --bar=x", &args)
+ require.NoError(t, err)
+ assert.Equal(t, []int{1, 2, 3}, args.Foo)
+ assert.Equal(t, []string{"x"}, args.Bar)
+}
+
+func TestMultipleWithDefault(t *testing.T) {
+ var args struct {
+ Foo []int
+ Bar []string
+ }
+ args.Foo = []int{42}
+ args.Bar = []string{"foo"}
+ err := parse("--foo 1 2 3 --bar x y z", &args)
+ require.NoError(t, err)
+ assert.Equal(t, []int{1, 2, 3}, args.Foo)
+ assert.Equal(t, []string{"x", "y", "z"}, args.Bar)
+}
+
+func TestExemptField(t *testing.T) {
+ var args struct {
+ Foo string
+ Bar interface{} `arg:"-"`
+ }
+ err := parse("--foo xyz", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "xyz", args.Foo)
+}
+
+func TestUnknownField(t *testing.T) {
+ var args struct {
+ Foo string
+ }
+ err := parse("--bar xyz", &args)
+ assert.Error(t, err)
+}
+
+func TestMissingRequired(t *testing.T) {
+ var args struct {
+ Foo string `arg:"required"`
+ X []string `arg:"positional"`
+ }
+ err := parse("x", &args)
+ assert.Error(t, err)
+}
+
+func TestNonsenseKey(t *testing.T) {
+ var args struct {
+ X []string `arg:"positional, nonsense"`
+ }
+ err := parse("x", &args)
+ assert.Error(t, err)
+}
+
+func TestMissingValueAtEnd(t *testing.T) {
+ var args struct {
+ Foo string
+ }
+ err := parse("--foo", &args)
+ assert.Error(t, err)
+}
+
+func TestMissingValueInMiddle(t *testing.T) {
+ var args struct {
+ Foo string
+ Bar string
+ }
+ err := parse("--foo --bar=abc", &args)
+ assert.Error(t, err)
+}
+
+func TestNegativeValue(t *testing.T) {
+ var args struct {
+ Foo int
+ }
+ err := parse("--foo -123", &args)
+ require.NoError(t, err)
+ assert.Equal(t, -123, args.Foo)
+}
+
+func TestInvalidInt(t *testing.T) {
+ var args struct {
+ Foo int
+ }
+ err := parse("--foo=xyz", &args)
+ assert.Error(t, err)
+}
+
+func TestInvalidUint(t *testing.T) {
+ var args struct {
+ Foo uint
+ }
+ err := parse("--foo=xyz", &args)
+ assert.Error(t, err)
+}
+
+func TestInvalidFloat(t *testing.T) {
+ var args struct {
+ Foo float64
+ }
+ err := parse("--foo xyz", &args)
+ require.Error(t, err)
+}
+
+func TestInvalidBool(t *testing.T) {
+ var args struct {
+ Foo bool
+ }
+ err := parse("--foo=xyz", &args)
+ require.Error(t, err)
+}
+
+func TestInvalidIntSlice(t *testing.T) {
+ var args struct {
+ Foo []int
+ }
+ err := parse("--foo 1 2 xyz", &args)
+ require.Error(t, err)
+}
+
+func TestInvalidPositional(t *testing.T) {
+ var args struct {
+ Foo int `arg:"positional"`
+ }
+ err := parse("xyz", &args)
+ require.Error(t, err)
+}
+
+func TestInvalidPositionalSlice(t *testing.T) {
+ var args struct {
+ Foo []int `arg:"positional"`
+ }
+ err := parse("1 2 xyz", &args)
+ require.Error(t, err)
+}
+
+func TestNoMoreOptions(t *testing.T) {
+ var args struct {
+ Foo string
+ Bar []string `arg:"positional"`
+ }
+ err := parse("abc -- --foo xyz", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "", args.Foo)
+ assert.Equal(t, []string{"abc", "--foo", "xyz"}, args.Bar)
+}
+
+func TestNoMoreOptionsBeforeHelp(t *testing.T) {
+ var args struct {
+ Foo int
+ }
+ err := parse("not_an_integer -- --help", &args)
+ assert.NotEqual(t, ErrHelp, err)
+}
+
+func TestHelpFlag(t *testing.T) {
+ var args struct {
+ Foo string
+ Bar interface{} `arg:"-"`
+ }
+ err := parse("--help", &args)
+ assert.Equal(t, ErrHelp, err)
+}
+
+func TestPanicOnNonPointer(t *testing.T) {
+ var args struct{}
+ assert.Panics(t, func() {
+ _ = parse("", args)
+ })
+}
+
+func TestErrorOnNonStruct(t *testing.T) {
+ var args string
+ err := parse("", &args)
+ assert.Error(t, err)
+}
+
+func TestUnsupportedType(t *testing.T) {
+ var args struct {
+ Foo interface{}
+ }
+ err := parse("--foo", &args)
+ assert.Error(t, err)
+}
+
+func TestUnsupportedSliceElement(t *testing.T) {
+ var args struct {
+ Foo []interface{}
+ }
+ err := parse("--foo 3", &args)
+ assert.Error(t, err)
+}
+
+func TestUnsupportedSliceElementMissingValue(t *testing.T) {
+ var args struct {
+ Foo []interface{}
+ }
+ err := parse("--foo", &args)
+ assert.Error(t, err)
+}
+
+func TestUnknownTag(t *testing.T) {
+ var args struct {
+ Foo string `arg:"this_is_not_valid"`
+ }
+ err := parse("--foo xyz", &args)
+ assert.Error(t, err)
+}
+
+func TestParse(t *testing.T) {
+ var args struct {
+ Foo string
+ }
+ os.Args = []string{"example", "--foo", "bar"}
+ err := Parse(&args)
+ require.NoError(t, err)
+ assert.Equal(t, "bar", args.Foo)
+}
+
+func TestParseError(t *testing.T) {
+ var args struct {
+ Foo string `arg:"this_is_not_valid"`
+ }
+ os.Args = []string{"example", "--bar"}
+ err := Parse(&args)
+ assert.Error(t, err)
+}
+
+func TestMustParse(t *testing.T) {
+ var args struct {
+ Foo string
+ }
+ os.Args = []string{"example", "--foo", "bar"}
+ parser := MustParse(&args)
+ assert.Equal(t, "bar", args.Foo)
+ assert.NotNil(t, parser)
+}
+
+func TestEnvironmentVariable(t *testing.T) {
+ var args struct {
+ Foo string `arg:"env"`
+ }
+ _, err := parseWithEnv("", []string{"FOO=bar"}, &args)
+ require.NoError(t, err)
+ assert.Equal(t, "bar", args.Foo)
+}
+
+func TestEnvironmentVariableNotPresent(t *testing.T) {
+ var args struct {
+ NotPresent string `arg:"env"`
+ }
+ _, err := parseWithEnv("", nil, &args)
+ require.NoError(t, err)
+ assert.Equal(t, "", args.NotPresent)
+}
+
+func TestEnvironmentVariableOverrideName(t *testing.T) {
+ var args struct {
+ Foo string `arg:"env:BAZ"`
+ }
+ _, err := parseWithEnv("", []string{"BAZ=bar"}, &args)
+ require.NoError(t, err)
+ assert.Equal(t, "bar", args.Foo)
+}
+
+func TestEnvironmentVariableOverrideArgument(t *testing.T) {
+ var args struct {
+ Foo string `arg:"env"`
+ }
+ _, err := parseWithEnv("--foo zzz", []string{"FOO=bar"}, &args)
+ require.NoError(t, err)
+ assert.Equal(t, "zzz", args.Foo)
+}
+
+func TestEnvironmentVariableError(t *testing.T) {
+ var args struct {
+ Foo int `arg:"env"`
+ }
+ _, err := parseWithEnv("", []string{"FOO=bar"}, &args)
+ assert.Error(t, err)
+}
+
+func TestEnvironmentVariableRequired(t *testing.T) {
+ var args struct {
+ Foo string `arg:"env,required"`
+ }
+ _, err := parseWithEnv("", []string{"FOO=bar"}, &args)
+ require.NoError(t, err)
+ assert.Equal(t, "bar", args.Foo)
+}
+
+func TestEnvironmentVariableSliceArgumentString(t *testing.T) {
+ var args struct {
+ Foo []string `arg:"env"`
+ }
+ _, err := parseWithEnv("", []string{`FOO=bar,"baz, qux"`}, &args)
+ require.NoError(t, err)
+ assert.Equal(t, []string{"bar", "baz, qux"}, args.Foo)
+}
+
+func TestEnvironmentVariableSliceEmpty(t *testing.T) {
+ var args struct {
+ Foo []string `arg:"env"`
+ }
+ _, err := parseWithEnv("", []string{`FOO=`}, &args)
+ require.NoError(t, err)
+ assert.Len(t, args.Foo, 0)
+}
+
+func TestEnvironmentVariableSliceArgumentInteger(t *testing.T) {
+ var args struct {
+ Foo []int `arg:"env"`
+ }
+ _, err := parseWithEnv("", []string{`FOO=1,99`}, &args)
+ require.NoError(t, err)
+ assert.Equal(t, []int{1, 99}, args.Foo)
+}
+
+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)
+ assert.Equal(t, []float32{1.1, 99.9}, args.Foo)
+}
+
+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)
+ assert.Equal(t, []bool{true, false, false, true}, args.Foo)
+}
+
+func TestEnvironmentVariableSliceArgumentWrongCsv(t *testing.T) {
+ var args struct {
+ Foo []int `arg:"env"`
+ }
+ _, err := parseWithEnv("", []string{`FOO=1,99\"`}, &args)
+ assert.Error(t, err)
+}
+
+func TestEnvironmentVariableSliceArgumentWrongType(t *testing.T) {
+ var args struct {
+ Foo []bool `arg:"env"`
+ }
+ _, err := parseWithEnv("", []string{`FOO=one,two`}, &args)
+ assert.Error(t, err)
+}
+
+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)
+ assert.Len(t, args.Foo, 2)
+ assert.Equal(t, "one", args.Foo[1])
+ assert.Equal(t, "ninetynine", args.Foo[99])
+}
+
+func TestEnvironmentVariableEmptyMap(t *testing.T) {
+ var args struct {
+ Foo map[int]string `arg:"env"`
+ }
+ _, err := parseWithEnv("", []string{`FOO=`}, &args)
+ require.NoError(t, err)
+ assert.Len(t, args.Foo, 0)
+}
+
+func TestEnvironmentVariableIgnored(t *testing.T) {
+ var args struct {
+ Foo string `arg:"env"`
+ }
+ setenv(t, "FOO", "abc")
+
+ p, err := NewParser(Config{IgnoreEnv: true}, &args)
+ require.NoError(t, err)
+
+ err = p.Parse(nil)
+ assert.NoError(t, err)
+ assert.Equal(t, "", args.Foo)
+}
+
+func TestDefaultValuesIgnored(t *testing.T) {
+ var args struct {
+ Foo string `default:"bad"`
+ }
+
+ p, err := NewParser(Config{IgnoreDefault: true}, &args)
+ require.NoError(t, err)
+
+ err = p.Parse(nil)
+ assert.NoError(t, err)
+ assert.Equal(t, "", args.Foo)
+}
+
+func TestRequiredEnvironmentOnlyVariableIsMissing(t *testing.T) {
+ var args struct {
+ Foo string `arg:"required,--,env:FOO"`
+ }
+
+ _, err := parseWithEnv("", []string{""}, &args)
+ assert.Error(t, err)
+}
+
+func TestOptionalEnvironmentOnlyVariable(t *testing.T) {
+ var args struct {
+ Foo string `arg:"env:FOO"`
+ }
+
+ _, err := parseWithEnv("", []string{}, &args)
+ assert.NoError(t, err)
+}
+
+func TestEnvironmentVariableInSubcommandIgnored(t *testing.T) {
+ var args struct {
+ Sub *struct {
+ Foo string `arg:"env"`
+ } `arg:"subcommand"`
+ }
+ setenv(t, "FOO", "abc")
+
+ p, err := NewParser(Config{IgnoreEnv: true}, &args)
+ require.NoError(t, err)
+
+ err = p.Parse([]string{"sub"})
+ require.NoError(t, err)
+ require.NotNil(t, args.Sub)
+ assert.Equal(t, "", args.Sub.Foo)
+}
+
+func TestParserMustParseEmptyArgs(t *testing.T) {
+ // this mirrors TestEmptyArgs
+ p, err := NewParser(Config{}, &struct{}{})
+ require.NoError(t, err)
+ assert.NotNil(t, p)
+ p.MustParse(nil)
+}
+
+func TestParserMustParse(t *testing.T) {
+ tests := []struct {
+ name string
+ args versioned
+ cmdLine []string
+ code int
+ output string
+ }{
+ {name: "help", args: struct{}{}, cmdLine: []string{"--help"}, code: 0, output: "display this help and exit"},
+ {name: "version", args: versioned{}, cmdLine: []string{"--version"}, code: 0, output: "example 3.2.1"},
+ {name: "invalid", args: struct{}{}, cmdLine: []string{"invalid"}, code: -1, output: ""},
+ }
+
+ for _, tt := range tests {
+ tt := tt
+ t.Run(tt.name, func(t *testing.T) {
+ var exitCode int
+ var stdout bytes.Buffer
+ exit := func(code int) { exitCode = code }
+
+ p, err := NewParser(Config{Exit: exit, Out: &stdout}, &tt.args)
+ require.NoError(t, err)
+ assert.NotNil(t, p)
+
+ p.MustParse(tt.cmdLine)
+ assert.NotNil(t, exitCode)
+ assert.Equal(t, tt.code, exitCode)
+ assert.Contains(t, stdout.String(), tt.output)
+ })
+ }
+}
+
+type textUnmarshaler struct {
+ val int
+}
+
+func (f *textUnmarshaler) UnmarshalText(b []byte) error {
+ f.val = len(b)
+ return nil
+}
+
+func TestTextUnmarshaler(t *testing.T) {
+ // fields that implement TextUnmarshaler should be parsed using that interface
+ var args struct {
+ Foo textUnmarshaler
+ }
+ err := parse("--foo abc", &args)
+ require.NoError(t, err)
+ assert.Equal(t, 3, args.Foo.val)
+}
+
+func TestPtrToTextUnmarshaler(t *testing.T) {
+ // fields that implement TextUnmarshaler should be parsed using that interface
+ var args struct {
+ Foo *textUnmarshaler
+ }
+ err := parse("--foo abc", &args)
+ require.NoError(t, err)
+ assert.Equal(t, 3, args.Foo.val)
+}
+
+func TestRepeatedTextUnmarshaler(t *testing.T) {
+ // fields that implement TextUnmarshaler should be parsed using that interface
+ var args struct {
+ Foo []textUnmarshaler
+ }
+ err := parse("--foo abc d ef", &args)
+ require.NoError(t, err)
+ require.Len(t, args.Foo, 3)
+ assert.Equal(t, 3, args.Foo[0].val)
+ assert.Equal(t, 1, args.Foo[1].val)
+ assert.Equal(t, 2, args.Foo[2].val)
+}
+
+func TestRepeatedPtrToTextUnmarshaler(t *testing.T) {
+ // fields that implement TextUnmarshaler should be parsed using that interface
+ var args struct {
+ Foo []*textUnmarshaler
+ }
+ err := parse("--foo abc d ef", &args)
+ require.NoError(t, err)
+ require.Len(t, args.Foo, 3)
+ assert.Equal(t, 3, args.Foo[0].val)
+ assert.Equal(t, 1, args.Foo[1].val)
+ assert.Equal(t, 2, args.Foo[2].val)
+}
+
+func TestPositionalTextUnmarshaler(t *testing.T) {
+ // fields that implement TextUnmarshaler should be parsed using that interface
+ var args struct {
+ Foo []textUnmarshaler `arg:"positional"`
+ }
+ err := parse("abc d ef", &args)
+ require.NoError(t, err)
+ require.Len(t, args.Foo, 3)
+ assert.Equal(t, 3, args.Foo[0].val)
+ assert.Equal(t, 1, args.Foo[1].val)
+ assert.Equal(t, 2, args.Foo[2].val)
+}
+
+func TestPositionalPtrToTextUnmarshaler(t *testing.T) {
+ // fields that implement TextUnmarshaler should be parsed using that interface
+ var args struct {
+ Foo []*textUnmarshaler `arg:"positional"`
+ }
+ err := parse("abc d ef", &args)
+ require.NoError(t, err)
+ require.Len(t, args.Foo, 3)
+ assert.Equal(t, 3, args.Foo[0].val)
+ assert.Equal(t, 1, args.Foo[1].val)
+ assert.Equal(t, 2, args.Foo[2].val)
+}
+
+type boolUnmarshaler bool
+
+func (p *boolUnmarshaler) UnmarshalText(b []byte) error {
+ *p = len(b)%2 == 0
+ return nil
+}
+
+func TestBoolUnmarhsaler(t *testing.T) {
+ // test that a bool type that implements TextUnmarshaler is
+ // handled as a TextUnmarshaler not as a bool
+ var args struct {
+ Foo *boolUnmarshaler
+ }
+ err := parse("--foo ab", &args)
+ require.NoError(t, err)
+ assert.EqualValues(t, true, *args.Foo)
+}
+
+type sliceUnmarshaler []int
+
+func (p *sliceUnmarshaler) UnmarshalText(b []byte) error {
+ *p = sliceUnmarshaler{len(b)}
+ return nil
+}
+
+func TestSliceUnmarhsaler(t *testing.T) {
+ // test that a slice type that implements TextUnmarshaler is
+ // handled as a TextUnmarshaler not as a slice
+ var args struct {
+ Foo *sliceUnmarshaler
+ Bar string `arg:"positional"`
+ }
+ err := parse("--foo abcde xyz", &args)
+ require.NoError(t, err)
+ require.Len(t, *args.Foo, 1)
+ assert.EqualValues(t, 5, (*args.Foo)[0])
+ assert.Equal(t, "xyz", args.Bar)
+}
+
+func TestIP(t *testing.T) {
+ var args struct {
+ Host net.IP
+ }
+ err := parse("--host 192.168.0.1", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "192.168.0.1", args.Host.String())
+}
+
+func TestPtrToIP(t *testing.T) {
+ var args struct {
+ Host *net.IP
+ }
+ err := parse("--host 192.168.0.1", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "192.168.0.1", args.Host.String())
+}
+
+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)
+ assert.Equal(t, "https://example.com/get?item=xyz", args.URL.String())
+}
+
+func TestPtrToURL(t *testing.T) {
+ var args struct {
+ URL *url.URL
+ }
+ err := parse("--url http://example.com/#xyz", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "http://example.com/#xyz", args.URL.String())
+}
+
+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)
+ 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())
+}
+
+func TestInvalidIPAddress(t *testing.T) {
+ var args struct {
+ Host net.IP
+ }
+ err := parse("--host xxx", &args)
+ assert.Error(t, err)
+}
+
+func TestMAC(t *testing.T) {
+ var args struct {
+ Host net.HardwareAddr
+ }
+ err := parse("--host 0123.4567.89ab", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "01:23:45:67:89:ab", args.Host.String())
+}
+
+func TestInvalidMac(t *testing.T) {
+ var args struct {
+ Host net.HardwareAddr
+ }
+ err := parse("--host xxx", &args)
+ assert.Error(t, err)
+}
+
+func TestMailAddr(t *testing.T) {
+ var args struct {
+ Recipient mail.Address
+ }
+ err := parse("--recipient [email protected]", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "<[email protected]>", args.Recipient.String())
+}
+
+func TestInvalidMailAddr(t *testing.T) {
+ var args struct {
+ Recipient mail.Address
+ }
+ err := parse("--recipient xxx", &args)
+ assert.Error(t, err)
+}
+
+type A struct {
+ X string
+}
+
+type B struct {
+ Y int
+}
+
+func TestEmbedded(t *testing.T) {
+ var args struct {
+ A
+ B
+ Z bool
+ }
+ err := parse("--x=hello --y=321 --z", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "hello", args.X)
+ assert.Equal(t, 321, args.Y)
+ assert.Equal(t, true, args.Z)
+}
+
+func TestEmbeddedPtr(t *testing.T) {
+ // embedded pointer fields are not supported so this should return an error
+ var args struct {
+ *A
+ }
+ err := parse("--x=hello", &args)
+ require.Error(t, err)
+}
+
+func TestEmbeddedPtrIgnored(t *testing.T) {
+ // embedded pointer fields are not normally supported but here
+ // we explicitly exclude it so the non-nil embedded structs
+ // should work as expected
+ var args struct {
+ *A `arg:"-"`
+ B
+ }
+ err := parse("--y=321", &args)
+ require.NoError(t, err)
+ assert.Equal(t, 321, args.Y)
+}
+
+func TestEmbeddedWithDuplicateField(t *testing.T) {
+ // see https://github.com/alexflint/go-arg/issues/100
+ type T struct {
+ A string `arg:"--cat"`
+ }
+ type U struct {
+ A string `arg:"--dog"`
+ }
+ var args struct {
+ T
+ U
+ }
+
+ err := parse("--cat=cat --dog=dog", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "cat", args.T.A)
+ assert.Equal(t, "dog", args.U.A)
+}
+
+func TestEmbeddedWithDuplicateField2(t *testing.T) {
+ // see https://github.com/alexflint/go-arg/issues/100
+ type T struct {
+ A string
+ }
+ type U struct {
+ A string
+ }
+ var args struct {
+ T
+ U
+ }
+
+ err := parse("--a=xyz", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "xyz", args.T.A)
+ assert.Equal(t, "", args.U.A)
+}
+
+func TestUnexportedEmbedded(t *testing.T) {
+ type embeddedArgs struct {
+ Foo string
+ }
+ var args struct {
+ embeddedArgs
+ }
+ err := parse("--foo bar", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "bar", args.Foo)
+}
+
+func TestIgnoredEmbedded(t *testing.T) {
+ type embeddedArgs struct {
+ Foo string
+ }
+ var args struct {
+ embeddedArgs `arg:"-"`
+ }
+ err := parse("--foo bar", &args)
+ require.Error(t, err)
+}
+
+func TestEmptyArgs(t *testing.T) {
+ origArgs := os.Args
+
+ // test what happens if somehow os.Args is empty
+ os.Args = nil
+ var args struct {
+ Foo string
+ }
+ MustParse(&args)
+
+ // put the original arguments back
+ os.Args = origArgs
+}
+
+func TestTooManyHyphens(t *testing.T) {
+ var args struct {
+ TooManyHyphens string `arg:"---x"`
+ }
+ err := parse("--foo -", &args)
+ assert.Error(t, err)
+}
+
+func TestHyphenAsOption(t *testing.T) {
+ var args struct {
+ Foo string
+ }
+ err := parse("--foo -", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "-", args.Foo)
+}
+
+func TestHyphenAsPositional(t *testing.T) {
+ var args struct {
+ Foo string `arg:"positional"`
+ }
+ err := parse("-", &args)
+ require.NoError(t, err)
+ assert.Equal(t, "-", args.Foo)
+}
+
+func TestHyphenInMultiOption(t *testing.T) {
+ var args struct {
+ Foo []string
+ Bar int
+ }
+ err := parse("--foo --- x - y --bar 3", &args)
+ require.NoError(t, err)
+ assert.Equal(t, []string{"---", "x", "-", "y"}, args.Foo)
+ assert.Equal(t, 3, args.Bar)
+}
+
+func TestHyphenInMultiPositional(t *testing.T) {
+ var args struct {
+ Foo []string `arg:"positional"`
+ }
+ err := parse("--- x - y", &args)
+ require.NoError(t, err)
+ assert.Equal(t, []string{"---", "x", "-", "y"}, args.Foo)
+}
+
+func TestSeparate(t *testing.T) {
+ for _, val := range []string{"-f one", "-f=one", "--foo one", "--foo=one"} {
+ var args struct {
+ Foo []string `arg:"--foo,-f,separate"`
+ }
+
+ err := parse(val, &args)
+ require.NoError(t, err)
+ assert.Equal(t, []string{"one"}, args.Foo)
+ }
+}
+
+func TestSeparateWithDefault(t *testing.T) {
+ args := struct {
+ Foo []string `arg:"--foo,-f,separate"`
+ }{
+ Foo: []string{"default"},
+ }
+
+ err := parse("-f one -f=two", &args)
+ require.NoError(t, err)
+ assert.Equal(t, []string{"default", "one", "two"}, args.Foo)
+}
+
+func TestSeparateWithPositional(t *testing.T) {
+ var args struct {
+ Foo []string `arg:"--foo,-f,separate"`
+ Bar string `arg:"positional"`
+ Moo string `arg:"positional"`
+ }
+
+ err := parse("zzz --foo one -f=two --foo=three -f four aaa", &args)
+ require.NoError(t, err)
+ assert.Equal(t, []string{"one", "two", "three", "four"}, args.Foo)
+ assert.Equal(t, "zzz", args.Bar)
+ assert.Equal(t, "aaa", args.Moo)
+}
+
+func TestSeparatePositionalInterweaved(t *testing.T) {
+ var args struct {
+ Foo []string `arg:"--foo,-f,separate"`
+ Bar []string `arg:"--bar,-b,separate"`
+ Pre string `arg:"positional"`
+ 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)
+ assert.Equal(t, []string{"foo1", "foo2"}, args.Foo)
+ assert.Equal(t, []string{"bar1", "bar2", "bar3"}, args.Bar)
+ assert.Equal(t, "zzz", args.Pre)
+ assert.Equal(t, []string{"post1", "post2", "post3"}, args.Post)
+}
+
+func TestSpacesAllowedInTags(t *testing.T) {
+ var args struct {
+ 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)
+ assert.Equal(t, []string{"one", "two", "three", "four"}, args.Foo)
+}
+
+func TestReuseParser(t *testing.T) {
+ var args struct {
+ Foo string `arg:"required"`
+ }
+
+ p, err := NewParser(Config{}, &args)
+ require.NoError(t, err)
+
+ err = p.Parse([]string{"--foo=abc"})
+ require.NoError(t, err)
+ assert.Equal(t, args.Foo, "abc")
+
+ err = p.Parse([]string{})
+ assert.Error(t, err)
+}
+
+func TestNoVersion(t *testing.T) {
+ var args struct{}
+
+ p, err := NewParser(Config{}, &args)
+ require.NoError(t, err)
+
+ err = p.Parse([]string{"--version"})
+ assert.Error(t, err)
+ assert.NotEqual(t, ErrVersion, err)
+}
+
+func TestBuiltinVersion(t *testing.T) {
+ var args struct{}
+
+ p, err := NewParser(Config{}, &args)
+ require.NoError(t, err)
+
+ p.version = "example 3.2.1"
+
+ err = p.Parse([]string{"--version"})
+ assert.Equal(t, ErrVersion, err)
+}
+
+func TestArgsVersion(t *testing.T) {
+ var args struct {
+ Version bool `arg:"--version"`
+ }
+
+ p, err := NewParser(Config{}, &args)
+ require.NoError(t, err)
+
+ err = p.Parse([]string{"--version"})
+ require.NoError(t, err)
+ require.Equal(t, args.Version, true)
+}
+
+func TestArgsAndBuiltinVersion(t *testing.T) {
+ var args struct {
+ Version bool `arg:"--version"`
+ }
+
+ p, err := NewParser(Config{}, &args)
+ require.NoError(t, err)
+
+ p.version = "example 3.2.1"
+
+ err = p.Parse([]string{"--version"})
+ require.NoError(t, err)
+ require.Equal(t, args.Version, true)
+}
+
+func TestMultipleTerminates(t *testing.T) {
+ var args struct {
+ X []string
+ Y string `arg:"positional"`
+ }
+
+ err := parse("--x a b -- c", &args)
+ require.NoError(t, err)
+ assert.Equal(t, []string{"a", "b"}, args.X)
+ assert.Equal(t, "c", args.Y)
+}
+
+func TestDefaultOptionValues(t *testing.T) {
+ var args struct {
+ A int `default:"123"`
+ B *int `default:"123"`
+ C string `default:"abc"`
+ D *string `default:"abc"`
+ E float64 `default:"1.23"`
+ F *float64 `default:"1.23"`
+ G bool `default:"true"`
+ H *bool `default:"true"`
+ }
+
+ err := parse("--c=xyz --e=4.56", &args)
+ require.NoError(t, err)
+
+ assert.Equal(t, 123, args.A)
+ if assert.NotNil(t, args.B) {
+ assert.Equal(t, 123, *args.B)
+ }
+ assert.Equal(t, "xyz", args.C)
+ if assert.NotNil(t, args.D) {
+ assert.Equal(t, "abc", *args.D)
+ }
+ assert.Equal(t, 4.56, args.E)
+ if assert.NotNil(t, args.F) {
+ assert.Equal(t, 1.23, *args.F)
+ }
+ assert.True(t, args.G)
+ if assert.NotNil(t, args.H) {
+ assert.True(t, *args.H)
+ }
+}
+
+func TestDefaultUnparseable(t *testing.T) {
+ var args struct {
+ A int `default:"x"`
+ }
+
+ err := parse("", &args)
+ assert.EqualError(t, err, `.A: error processing default value: strconv.ParseInt: parsing "x": invalid syntax`)
+}
+
+func TestDefaultPositionalValues(t *testing.T) {
+ var args struct {
+ A int `arg:"positional" default:"123"`
+ B *int `arg:"positional" default:"123"`
+ C string `arg:"positional" default:"abc"`
+ D *string `arg:"positional" default:"abc"`
+ E float64 `arg:"positional" default:"1.23"`
+ F *float64 `arg:"positional" default:"1.23"`
+ G bool `arg:"positional" default:"true"`
+ H *bool `arg:"positional" default:"true"`
+ }
+
+ err := parse("456 789", &args)
+ require.NoError(t, err)
+
+ assert.Equal(t, 456, args.A)
+ if assert.NotNil(t, args.B) {
+ assert.Equal(t, 789, *args.B)
+ }
+ assert.Equal(t, "abc", args.C)
+ if assert.NotNil(t, args.D) {
+ assert.Equal(t, "abc", *args.D)
+ }
+ assert.Equal(t, 1.23, args.E)
+ if assert.NotNil(t, args.F) {
+ assert.Equal(t, 1.23, *args.F)
+ }
+ assert.True(t, args.G)
+ if assert.NotNil(t, args.H) {
+ assert.True(t, *args.H)
+ }
+}
+
+func TestDefaultValuesNotAllowedWithRequired(t *testing.T) {
+ var args struct {
+ A int `arg:"required" default:"123"` // required not allowed with default!
+ }
+
+ err := parse("", &args)
+ assert.EqualError(t, err, ".A: 'required' cannot be used when a default value is specified")
+}
+
+func TestDefaultValuesNotAllowedWithSlice(t *testing.T) {
+ var args struct {
+ A []int `default:"invalid"` // default values not allowed with slices
+ }
+
+ err := parse("", &args)
+ assert.EqualError(t, err, ".A: default values are not supported for slice or map fields")
+}
+
+func TestUnexportedFieldsSkipped(t *testing.T) {
+ var args struct {
+ unexported struct{}
+ }
+
+ _, err := NewParser(Config{}, &args)
+ require.NoError(t, err)
+}
+
+func TestMustParseInvalidParser(t *testing.T) {
+ var exitCode int
+ var stdout bytes.Buffer
+ exit := func(code int) { exitCode = code }
+
+ var args struct {
+ CannotParse struct{}
+ }
+ parser := mustParse(Config{Out: &stdout, Exit: exit}, &args)
+ assert.Nil(t, parser)
+ assert.Equal(t, -1, exitCode)
+}
+
+func TestMustParsePrintsHelp(t *testing.T) {
+ originalArgs := os.Args
+ defer func() {
+ os.Args = originalArgs
+ }()
+
+ os.Args = []string{"someprogram", "--help"}
+
+ var exitCode int
+ var stdout bytes.Buffer
+ exit := func(code int) { exitCode = code }
+
+ var args struct{}
+ parser := mustParse(Config{Out: &stdout, Exit: exit}, &args)
+ assert.NotNil(t, parser)
+ assert.Equal(t, 0, exitCode)
+}
+
+func TestMustParsePrintsVersion(t *testing.T) {
+ originalArgs := os.Args
+ defer func() {
+ os.Args = originalArgs
+ }()
+
+ var exitCode int
+ var stdout bytes.Buffer
+ exit := func(code int) { exitCode = code }
+
+ os.Args = []string{"someprogram", "--version"}
+
+ var args versioned
+ parser := mustParse(Config{Out: &stdout, Exit: exit}, &args)
+ require.NotNil(t, parser)
+ assert.Equal(t, 0, exitCode)
+ assert.Equal(t, "example 3.2.1\n", stdout.String())
+}
+
+type mapWithUnmarshalText struct {
+ val map[string]string
+}
+
+func (v *mapWithUnmarshalText) UnmarshalText(data []byte) error {
+ return json.Unmarshal(data, &v.val)
+}
+
+func TestTextUnmarshalerEmpty(t *testing.T) {
+ // based on https://github.com/alexflint/go-arg/issues/184
+ var args struct {
+ Config mapWithUnmarshalText `arg:"--config"`
+ }
+
+ err := parse("", &args)
+ require.NoError(t, err)
+ assert.Empty(t, args.Config)
+}
+
+func TestTextUnmarshalerEmptyPointer(t *testing.T) {
+ // a slight variant on https://github.com/alexflint/go-arg/issues/184
+ var args struct {
+ Config *mapWithUnmarshalText `arg:"--config"`
+ }
+
+ err := parse("", &args)
+ require.NoError(t, err)
+ assert.Nil(t, args.Config)
+}
+
+// similar to the above but also implements MarshalText
+type mapWithMarshalText struct {
+ val map[string]string
+}
+
+func (v *mapWithMarshalText) MarshalText(data []byte) error {
+ return json.Unmarshal(data, &v.val)
+}
+
+func (v *mapWithMarshalText) UnmarshalText(data []byte) error {
+ return json.Unmarshal(data, &v.val)
+}
+
+func TestTextMarshalerUnmarshalerEmpty(t *testing.T) {
+ // based on https://github.com/alexflint/go-arg/issues/184
+ var args struct {
+ Config mapWithMarshalText `arg:"--config"`
+ }
+
+ err := parse("", &args)
+ require.NoError(t, err)
+ assert.Empty(t, args.Config)
+}
+
+func TestTextMarshalerUnmarshalerEmptyPointer(t *testing.T) {
+ // a slight variant on https://github.com/alexflint/go-arg/issues/184
+ var args struct {
+ Config *mapWithMarshalText `arg:"--config"`
+ }
+
+ err := parse("", &args)
+ require.NoError(t, err)
+ assert.Nil(t, args.Config)
+}
+
+func TestSubcommandGlobalFlag_Before(t *testing.T) {
+ var args struct {
+ Global bool `arg:"-g"`
+ Sub *struct {
+ } `arg:"subcommand"`
+ }
+
+ p, err := NewParser(Config{StrictSubcommands: false}, &args)
+ require.NoError(t, err)
+
+ err = p.Parse([]string{"-g", "sub"})
+ assert.NoError(t, err)
+ assert.True(t, args.Global)
+}
+
+func TestSubcommandGlobalFlag_InCommand(t *testing.T) {
+ var args struct {
+ Global bool `arg:"-g"`
+ Sub *struct {
+ } `arg:"subcommand"`
+ }
+
+ p, err := NewParser(Config{StrictSubcommands: false}, &args)
+ require.NoError(t, err)
+
+ err = p.Parse([]string{"sub", "-g"})
+ assert.NoError(t, err)
+ assert.True(t, args.Global)
+}
+
+func TestSubcommandGlobalFlag_Before_Strict(t *testing.T) {
+ var args struct {
+ Global bool `arg:"-g"`
+ Sub *struct {
+ } `arg:"subcommand"`
+ }
+
+ p, err := NewParser(Config{StrictSubcommands: true}, &args)
+ require.NoError(t, err)
+
+ err = p.Parse([]string{"-g", "sub"})
+ assert.NoError(t, err)
+ assert.True(t, args.Global)
+}
+
+func TestSubcommandGlobalFlag_InCommand_Strict(t *testing.T) {
+ var args struct {
+ Global bool `arg:"-g"`
+ Sub *struct {
+ } `arg:"subcommand"`
+ }
+
+ p, err := NewParser(Config{StrictSubcommands: true}, &args)
+ require.NoError(t, err)
+
+ err = p.Parse([]string{"sub", "-g"})
+ assert.Error(t, err)
+}
+
+func TestSubcommandGlobalFlag_InCommand_Strict_Inner(t *testing.T) {
+ var args struct {
+ Global bool `arg:"-g"`
+ Sub *struct {
+ Guard bool `arg:"-g"`
+ } `arg:"subcommand"`
+ }
+
+ p, err := NewParser(Config{StrictSubcommands: true}, &args)
+ require.NoError(t, err)
+
+ err = p.Parse([]string{"sub", "-g"})
+ require.NoError(t, err)
+ assert.False(t, args.Global)
+ require.NotNil(t, args.Sub)
+ assert.True(t, args.Sub.Guard)
+}
diff --git a/test/reflect_test.go b/test/reflect_test.go
new file mode 100644
index 0000000..10909b3
--- /dev/null
+++ b/test/reflect_test.go
@@ -0,0 +1,112 @@
+package arg
+
+import (
+ "reflect"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+)
+
+func assertCardinality(t *testing.T, typ reflect.Type, expected cardinality) {
+ actual, err := cardinalityOf(typ)
+ assert.Equal(t, expected, actual, "expected %v to have cardinality %v but got %v", typ, expected, actual)
+ if expected == unsupported {
+ assert.Error(t, err)
+ }
+}
+
+func TestCardinalityOf(t *testing.T) {
+ var b bool
+ var i int
+ var s string
+ var f float64
+ var bs []bool
+ var is []int
+ var m map[string]int
+ var unsupported1 struct{}
+ var unsupported2 []struct{}
+ var unsupported3 map[string]struct{}
+ var unsupported4 map[struct{}]string
+
+ assertCardinality(t, reflect.TypeOf(b), zero)
+ assertCardinality(t, reflect.TypeOf(i), one)
+ assertCardinality(t, reflect.TypeOf(s), one)
+ assertCardinality(t, reflect.TypeOf(f), one)
+
+ assertCardinality(t, reflect.TypeOf(&b), zero)
+ assertCardinality(t, reflect.TypeOf(&s), one)
+ assertCardinality(t, reflect.TypeOf(&i), one)
+ assertCardinality(t, reflect.TypeOf(&f), one)
+
+ assertCardinality(t, reflect.TypeOf(bs), multiple)
+ assertCardinality(t, reflect.TypeOf(is), multiple)
+
+ assertCardinality(t, reflect.TypeOf(&bs), multiple)
+ assertCardinality(t, reflect.TypeOf(&is), multiple)
+
+ assertCardinality(t, reflect.TypeOf(m), multiple)
+ assertCardinality(t, reflect.TypeOf(&m), multiple)
+
+ assertCardinality(t, reflect.TypeOf(unsupported1), unsupported)
+ assertCardinality(t, reflect.TypeOf(&unsupported1), unsupported)
+ assertCardinality(t, reflect.TypeOf(unsupported2), unsupported)
+ assertCardinality(t, reflect.TypeOf(&unsupported2), unsupported)
+ assertCardinality(t, reflect.TypeOf(unsupported3), unsupported)
+ assertCardinality(t, reflect.TypeOf(&unsupported3), unsupported)
+ assertCardinality(t, reflect.TypeOf(unsupported4), unsupported)
+ assertCardinality(t, reflect.TypeOf(&unsupported4), unsupported)
+}
+
+type implementsTextUnmarshaler struct{}
+
+func (*implementsTextUnmarshaler) UnmarshalText(text []byte) error {
+ return nil
+}
+
+func TestCardinalityTextUnmarshaler(t *testing.T) {
+ var x implementsTextUnmarshaler
+ var s []implementsTextUnmarshaler
+ var m []implementsTextUnmarshaler
+ assertCardinality(t, reflect.TypeOf(x), one)
+ assertCardinality(t, reflect.TypeOf(&x), one)
+ assertCardinality(t, reflect.TypeOf(s), multiple)
+ assertCardinality(t, reflect.TypeOf(&s), multiple)
+ assertCardinality(t, reflect.TypeOf(m), multiple)
+ assertCardinality(t, reflect.TypeOf(&m), multiple)
+}
+
+func TestIsExported(t *testing.T) {
+ assert.True(t, isExported("Exported"))
+ assert.False(t, isExported("notExported"))
+ assert.False(t, isExported(""))
+ assert.False(t, isExported(string([]byte{255})))
+}
+
+func TestCardinalityString(t *testing.T) {
+ assert.Equal(t, "zero", zero.String())
+ assert.Equal(t, "one", one.String())
+ assert.Equal(t, "multiple", multiple.String())
+ assert.Equal(t, "unsupported", unsupported.String())
+ assert.Equal(t, "unknown(42)", cardinality(42).String())
+}
+
+func TestIsZero(t *testing.T) {
+ var zero int
+ var notZero = 3
+ var nilSlice []int
+ var nonNilSlice = []int{1, 2, 3}
+ var nilMap map[string]string
+ var nonNilMap = map[string]string{"foo": "bar"}
+ var uncomparable = func() {}
+
+ assert.True(t, isZero(reflect.ValueOf(zero)))
+ assert.False(t, isZero(reflect.ValueOf(notZero)))
+
+ assert.True(t, isZero(reflect.ValueOf(nilSlice)))
+ assert.False(t, isZero(reflect.ValueOf(nonNilSlice)))
+
+ assert.True(t, isZero(reflect.ValueOf(nilMap)))
+ assert.False(t, isZero(reflect.ValueOf(nonNilMap)))
+
+ assert.False(t, isZero(reflect.ValueOf(uncomparable)))
+}
diff --git a/test/sequence_test.go b/test/sequence_test.go
new file mode 100644
index 0000000..fde3e3a
--- /dev/null
+++ b/test/sequence_test.go
@@ -0,0 +1,152 @@
+package arg
+
+import (
+ "reflect"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+func TestSetSliceWithoutClearing(t *testing.T) {
+ xs := []int{10}
+ entries := []string{"1", "2", "3"}
+ err := setSlice(reflect.ValueOf(&xs).Elem(), entries, false)
+ require.NoError(t, err)
+ assert.Equal(t, []int{10, 1, 2, 3}, xs)
+}
+
+func TestSetSliceAfterClearing(t *testing.T) {
+ xs := []int{100}
+ entries := []string{"1", "2", "3"}
+ err := setSlice(reflect.ValueOf(&xs).Elem(), entries, true)
+ require.NoError(t, err)
+ assert.Equal(t, []int{1, 2, 3}, xs)
+}
+
+func TestSetSliceInvalid(t *testing.T) {
+ xs := []int{100}
+ entries := []string{"invalid"}
+ err := setSlice(reflect.ValueOf(&xs).Elem(), entries, true)
+ assert.Error(t, err)
+}
+
+func TestSetSlicePtr(t *testing.T) {
+ var xs []*int
+ entries := []string{"1", "2", "3"}
+ err := setSlice(reflect.ValueOf(&xs).Elem(), entries, true)
+ require.NoError(t, err)
+ require.Len(t, xs, 3)
+ assert.Equal(t, 1, *xs[0])
+ assert.Equal(t, 2, *xs[1])
+ assert.Equal(t, 3, *xs[2])
+}
+
+func TestSetSliceTextUnmarshaller(t *testing.T) {
+ // textUnmarshaler is a struct that captures the length of the string passed to it
+ var xs []*textUnmarshaler
+ entries := []string{"a", "aa", "aaa"}
+ err := setSlice(reflect.ValueOf(&xs).Elem(), entries, true)
+ require.NoError(t, err)
+ require.Len(t, xs, 3)
+ assert.Equal(t, 1, xs[0].val)
+ assert.Equal(t, 2, xs[1].val)
+ assert.Equal(t, 3, xs[2].val)
+}
+
+func TestSetMapWithoutClearing(t *testing.T) {
+ m := map[string]int{"foo": 10}
+ entries := []string{"a=1", "b=2"}
+ err := setMap(reflect.ValueOf(&m).Elem(), entries, false)
+ require.NoError(t, err)
+ require.Len(t, m, 3)
+ assert.Equal(t, 1, m["a"])
+ assert.Equal(t, 2, m["b"])
+ assert.Equal(t, 10, m["foo"])
+}
+
+func TestSetMapAfterClearing(t *testing.T) {
+ m := map[string]int{"foo": 10}
+ entries := []string{"a=1", "b=2"}
+ err := setMap(reflect.ValueOf(&m).Elem(), entries, true)
+ require.NoError(t, err)
+ require.Len(t, m, 2)
+ assert.Equal(t, 1, m["a"])
+ assert.Equal(t, 2, m["b"])
+}
+
+func TestSetMapWithKeyPointer(t *testing.T) {
+ // textUnmarshaler is a struct that captures the length of the string passed to it
+ var m map[*string]int
+ entries := []string{"abc=123"}
+ err := setMap(reflect.ValueOf(&m).Elem(), entries, true)
+ require.NoError(t, err)
+ require.Len(t, m, 1)
+}
+
+func TestSetMapWithValuePointer(t *testing.T) {
+ // textUnmarshaler is a struct that captures the length of the string passed to it
+ var m map[string]*int
+ entries := []string{"abc=123"}
+ err := setMap(reflect.ValueOf(&m).Elem(), entries, true)
+ require.NoError(t, err)
+ require.Len(t, m, 1)
+ assert.Equal(t, 123, *m["abc"])
+}
+
+func TestSetMapTextUnmarshaller(t *testing.T) {
+ // textUnmarshaler is a struct that captures the length of the string passed to it
+ var m map[textUnmarshaler]*textUnmarshaler
+ entries := []string{"a=123", "aa=12", "aaa=1"}
+ err := setMap(reflect.ValueOf(&m).Elem(), entries, true)
+ require.NoError(t, err)
+ require.Len(t, m, 3)
+ assert.Equal(t, &textUnmarshaler{3}, m[textUnmarshaler{1}])
+ assert.Equal(t, &textUnmarshaler{2}, m[textUnmarshaler{2}])
+ assert.Equal(t, &textUnmarshaler{1}, m[textUnmarshaler{3}])
+}
+
+func TestSetMapInvalidKey(t *testing.T) {
+ var m map[int]int
+ entries := []string{"invalid=123"}
+ err := setMap(reflect.ValueOf(&m).Elem(), entries, true)
+ assert.Error(t, err)
+}
+
+func TestSetMapInvalidValue(t *testing.T) {
+ var m map[int]int
+ entries := []string{"123=invalid"}
+ err := setMap(reflect.ValueOf(&m).Elem(), entries, true)
+ assert.Error(t, err)
+}
+
+func TestSetMapMalformed(t *testing.T) {
+ // textUnmarshaler is a struct that captures the length of the string passed to it
+ var m map[string]string
+ entries := []string{"missing_equals_sign"}
+ err := setMap(reflect.ValueOf(&m).Elem(), entries, true)
+ assert.Error(t, err)
+}
+
+func TestSetSliceOrMapErrors(t *testing.T) {
+ var err error
+ var dest reflect.Value
+
+ // converting a slice to a reflect.Value in this way will make it read only
+ var cannotSet []int
+ dest = reflect.ValueOf(cannotSet)
+ err = setSliceOrMap(dest, nil, false)
+ assert.Error(t, err)
+
+ // check what happens when we pass in something that is not a slice or a map
+ var notSliceOrMap string
+ dest = reflect.ValueOf(&notSliceOrMap).Elem()
+ err = setSliceOrMap(dest, nil, false)
+ assert.Error(t, err)
+
+ // check what happens when we pass in a pointer to something that is not a slice or a map
+ var stringPtr *string
+ dest = reflect.ValueOf(&stringPtr).Elem()
+ err = setSliceOrMap(dest, nil, false)
+ assert.Error(t, err)
+}
diff --git a/test/subcommand_test.go b/test/subcommand_test.go
new file mode 100644
index 0000000..00efae0
--- /dev/null
+++ b/test/subcommand_test.go
@@ -0,0 +1,508 @@
+package arg
+
+import (
+ "reflect"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+// This file contains tests for parse.go but I decided to put them here
+// since that file is getting large
+
+func TestSubcommandNotAPointer(t *testing.T) {
+ var args struct {
+ A string `arg:"subcommand"`
+ }
+ _, err := NewParser(Config{}, &args)
+ assert.Error(t, err)
+}
+
+func TestSubcommandNotAPointerToStruct(t *testing.T) {
+ var args struct {
+ A struct{} `arg:"subcommand"`
+ }
+ _, err := NewParser(Config{}, &args)
+ assert.Error(t, err)
+}
+
+func TestPositionalAndSubcommandNotAllowed(t *testing.T) {
+ var args struct {
+ A string `arg:"positional"`
+ B *struct{} `arg:"subcommand"`
+ }
+ _, err := NewParser(Config{}, &args)
+ assert.Error(t, err)
+}
+
+func TestMinimalSubcommand(t *testing.T) {
+ type listCmd struct {
+ }
+ var args struct {
+ List *listCmd `arg:"subcommand"`
+ }
+ p, err := pparse("list", &args)
+ require.NoError(t, err)
+ assert.NotNil(t, args.List)
+ assert.Equal(t, args.List, p.Subcommand())
+ assert.Equal(t, []string{"list"}, p.SubcommandNames())
+}
+
+func TestSubcommandNamesBeforeParsing(t *testing.T) {
+ type listCmd struct{}
+ var args struct {
+ List *listCmd `arg:"subcommand"`
+ }
+ p, err := NewParser(Config{}, &args)
+ require.NoError(t, err)
+ assert.Nil(t, p.Subcommand())
+ assert.Nil(t, p.SubcommandNames())
+}
+
+func TestNoSuchSubcommand(t *testing.T) {
+ type listCmd struct {
+ }
+ var args struct {
+ List *listCmd `arg:"subcommand"`
+ }
+ _, err := pparse("invalid", &args)
+ assert.Error(t, err)
+}
+
+func TestNamedSubcommand(t *testing.T) {
+ type listCmd struct {
+ }
+ var args struct {
+ List *listCmd `arg:"subcommand:ls"`
+ }
+ p, err := pparse("ls", &args)
+ require.NoError(t, err)
+ assert.NotNil(t, args.List)
+ assert.Equal(t, args.List, p.Subcommand())
+ assert.Equal(t, []string{"ls"}, p.SubcommandNames())
+}
+
+func TestSubcommandAliases(t *testing.T) {
+ type listCmd struct {
+ }
+ var args struct {
+ List *listCmd `arg:"subcommand:list|ls"`
+ }
+ p, err := pparse("ls", &args)
+ require.NoError(t, err)
+ assert.NotNil(t, args.List)
+ assert.Equal(t, args.List, p.Subcommand())
+ assert.Equal(t, []string{"ls"}, p.SubcommandNames())
+}
+
+func TestEmptySubcommand(t *testing.T) {
+ type listCmd struct {
+ }
+ var args struct {
+ List *listCmd `arg:"subcommand"`
+ }
+ p, err := pparse("", &args)
+ require.NoError(t, err)
+ assert.Nil(t, args.List)
+ assert.Nil(t, p.Subcommand())
+ assert.Empty(t, p.SubcommandNames())
+}
+
+func TestTwoSubcommands(t *testing.T) {
+ type getCmd struct {
+ }
+ type listCmd struct {
+ }
+ var args struct {
+ Get *getCmd `arg:"subcommand"`
+ List *listCmd `arg:"subcommand"`
+ }
+ p, err := pparse("list", &args)
+ require.NoError(t, err)
+ assert.Nil(t, args.Get)
+ assert.NotNil(t, args.List)
+ assert.Equal(t, args.List, p.Subcommand())
+ assert.Equal(t, []string{"list"}, p.SubcommandNames())
+}
+
+func TestTwoSubcommandsWithAliases(t *testing.T) {
+ type getCmd struct {
+ }
+ type listCmd struct {
+ }
+ var args struct {
+ Get *getCmd `arg:"subcommand:get|g"`
+ List *listCmd `arg:"subcommand:list|ls"`
+ }
+ p, err := pparse("ls", &args)
+ require.NoError(t, err)
+ assert.Nil(t, args.Get)
+ assert.NotNil(t, args.List)
+ assert.Equal(t, args.List, p.Subcommand())
+ assert.Equal(t, []string{"ls"}, p.SubcommandNames())
+}
+
+func TestSubcommandsWithOptions(t *testing.T) {
+ type getCmd struct {
+ Name string
+ }
+ type listCmd struct {
+ Limit int
+ }
+ type cmd struct {
+ Verbose bool
+ Get *getCmd `arg:"subcommand"`
+ List *listCmd `arg:"subcommand"`
+ }
+
+ {
+ var args cmd
+ err := parse("list", &args)
+ require.NoError(t, err)
+ assert.Nil(t, args.Get)
+ assert.NotNil(t, args.List)
+ }
+
+ {
+ var args cmd
+ err := parse("list --limit 3", &args)
+ require.NoError(t, err)
+ assert.Nil(t, args.Get)
+ assert.NotNil(t, args.List)
+ assert.Equal(t, args.List.Limit, 3)
+ }
+
+ {
+ var args cmd
+ err := parse("list --limit 3 --verbose", &args)
+ require.NoError(t, err)
+ assert.Nil(t, args.Get)
+ assert.NotNil(t, args.List)
+ assert.Equal(t, args.List.Limit, 3)
+ assert.True(t, args.Verbose)
+ }
+
+ {
+ var args cmd
+ err := parse("list --verbose --limit 3", &args)
+ require.NoError(t, err)
+ assert.Nil(t, args.Get)
+ assert.NotNil(t, args.List)
+ assert.Equal(t, args.List.Limit, 3)
+ assert.True(t, args.Verbose)
+ }
+
+ {
+ var args cmd
+ err := parse("--verbose list --limit 3", &args)
+ require.NoError(t, err)
+ assert.Nil(t, args.Get)
+ assert.NotNil(t, args.List)
+ assert.Equal(t, args.List.Limit, 3)
+ assert.True(t, args.Verbose)
+ }
+
+ {
+ var args cmd
+ err := parse("get", &args)
+ require.NoError(t, err)
+ assert.NotNil(t, args.Get)
+ assert.Nil(t, args.List)
+ }
+
+ {
+ var args cmd
+ err := parse("get --name test", &args)
+ require.NoError(t, err)
+ assert.NotNil(t, args.Get)
+ assert.Nil(t, args.List)
+ assert.Equal(t, args.Get.Name, "test")
+ }
+}
+
+func TestSubcommandsWithEnvVars(t *testing.T) {
+ type getCmd struct {
+ Name string `arg:"env"`
+ }
+ type listCmd struct {
+ Limit int `arg:"env"`
+ }
+ type cmd struct {
+ Verbose bool
+ Get *getCmd `arg:"subcommand"`
+ List *listCmd `arg:"subcommand"`
+ }
+
+ {
+ var args cmd
+ setenv(t, "LIMIT", "123")
+ err := parse("list", &args)
+ require.NoError(t, err)
+ require.NotNil(t, args.List)
+ assert.Equal(t, 123, args.List.Limit)
+ }
+
+ {
+ var args cmd
+ setenv(t, "LIMIT", "not_an_integer")
+ err := parse("list", &args)
+ assert.Error(t, err)
+ }
+}
+
+func TestNestedSubcommands(t *testing.T) {
+ type child struct{}
+ type parent struct {
+ Child *child `arg:"subcommand"`
+ }
+ type grandparent struct {
+ Parent *parent `arg:"subcommand"`
+ }
+ type root struct {
+ Grandparent *grandparent `arg:"subcommand"`
+ }
+
+ {
+ var args root
+ p, err := pparse("grandparent parent child", &args)
+ require.NoError(t, err)
+ require.NotNil(t, args.Grandparent)
+ require.NotNil(t, args.Grandparent.Parent)
+ require.NotNil(t, args.Grandparent.Parent.Child)
+ assert.Equal(t, args.Grandparent.Parent.Child, p.Subcommand())
+ assert.Equal(t, []string{"grandparent", "parent", "child"}, p.SubcommandNames())
+ }
+
+ {
+ var args root
+ p, err := pparse("grandparent parent", &args)
+ require.NoError(t, err)
+ require.NotNil(t, args.Grandparent)
+ require.NotNil(t, args.Grandparent.Parent)
+ require.Nil(t, args.Grandparent.Parent.Child)
+ assert.Equal(t, args.Grandparent.Parent, p.Subcommand())
+ assert.Equal(t, []string{"grandparent", "parent"}, p.SubcommandNames())
+ }
+
+ {
+ var args root
+ p, err := pparse("grandparent", &args)
+ require.NoError(t, err)
+ require.NotNil(t, args.Grandparent)
+ require.Nil(t, args.Grandparent.Parent)
+ assert.Equal(t, args.Grandparent, p.Subcommand())
+ assert.Equal(t, []string{"grandparent"}, p.SubcommandNames())
+ }
+
+ {
+ var args root
+ p, err := pparse("", &args)
+ require.NoError(t, err)
+ require.Nil(t, args.Grandparent)
+ assert.Nil(t, p.Subcommand())
+ assert.Empty(t, p.SubcommandNames())
+ }
+}
+
+func TestNestedSubcommandsWithAliases(t *testing.T) {
+ type child struct{}
+ type parent struct {
+ Child *child `arg:"subcommand:child|ch"`
+ }
+ type grandparent struct {
+ Parent *parent `arg:"subcommand:parent|pa"`
+ }
+ type root struct {
+ Grandparent *grandparent `arg:"subcommand:grandparent|gp"`
+ }
+
+ {
+ var args root
+ p, err := pparse("gp parent child", &args)
+ require.NoError(t, err)
+ require.NotNil(t, args.Grandparent)
+ require.NotNil(t, args.Grandparent.Parent)
+ require.NotNil(t, args.Grandparent.Parent.Child)
+ assert.Equal(t, args.Grandparent.Parent.Child, p.Subcommand())
+ assert.Equal(t, []string{"gp", "parent", "child"}, p.SubcommandNames())
+ }
+
+ {
+ var args root
+ p, err := pparse("grandparent pa", &args)
+ require.NoError(t, err)
+ require.NotNil(t, args.Grandparent)
+ require.NotNil(t, args.Grandparent.Parent)
+ require.Nil(t, args.Grandparent.Parent.Child)
+ assert.Equal(t, args.Grandparent.Parent, p.Subcommand())
+ assert.Equal(t, []string{"grandparent", "pa"}, p.SubcommandNames())
+ }
+
+ {
+ var args root
+ p, err := pparse("grandparent", &args)
+ require.NoError(t, err)
+ require.NotNil(t, args.Grandparent)
+ require.Nil(t, args.Grandparent.Parent)
+ assert.Equal(t, args.Grandparent, p.Subcommand())
+ assert.Equal(t, []string{"grandparent"}, p.SubcommandNames())
+ }
+
+ {
+ var args root
+ p, err := pparse("", &args)
+ require.NoError(t, err)
+ require.Nil(t, args.Grandparent)
+ assert.Nil(t, p.Subcommand())
+ assert.Empty(t, p.SubcommandNames())
+ }
+}
+
+func TestSubcommandsWithPositionals(t *testing.T) {
+ type listCmd struct {
+ Pattern string `arg:"positional"`
+ }
+ type cmd struct {
+ Format string
+ List *listCmd `arg:"subcommand"`
+ }
+
+ {
+ var args cmd
+ err := parse("list", &args)
+ require.NoError(t, err)
+ assert.NotNil(t, args.List)
+ assert.Equal(t, "", args.List.Pattern)
+ }
+
+ {
+ var args cmd
+ err := parse("list --format json", &args)
+ require.NoError(t, err)
+ assert.NotNil(t, args.List)
+ assert.Equal(t, "", args.List.Pattern)
+ assert.Equal(t, "json", args.Format)
+ }
+
+ {
+ var args cmd
+ err := parse("list somepattern", &args)
+ require.NoError(t, err)
+ 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)
+ assert.NotNil(t, args.List)
+ assert.Equal(t, "somepattern", args.List.Pattern)
+ assert.Equal(t, "json", args.Format)
+ }
+
+ {
+ var args cmd
+ err := parse("list --format json somepattern", &args)
+ require.NoError(t, err)
+ assert.NotNil(t, args.List)
+ assert.Equal(t, "somepattern", args.List.Pattern)
+ assert.Equal(t, "json", args.Format)
+ }
+
+ {
+ var args cmd
+ err := parse("--format json list somepattern", &args)
+ require.NoError(t, err)
+ assert.NotNil(t, args.List)
+ assert.Equal(t, "somepattern", args.List.Pattern)
+ assert.Equal(t, "json", args.Format)
+ }
+
+ {
+ var args cmd
+ err := parse("--format json", &args)
+ require.NoError(t, err)
+ assert.Nil(t, args.List)
+ assert.Equal(t, "json", args.Format)
+ }
+}
+func TestSubcommandsWithMultiplePositionals(t *testing.T) {
+ type getCmd struct {
+ Items []string `arg:"positional"`
+ }
+ type cmd struct {
+ Limit int
+ Get *getCmd `arg:"subcommand"`
+ }
+
+ {
+ var args cmd
+ err := parse("get", &args)
+ require.NoError(t, err)
+ assert.NotNil(t, args.Get)
+ assert.Empty(t, args.Get.Items)
+ }
+
+ {
+ var args cmd
+ err := parse("get --limit 5", &args)
+ require.NoError(t, err)
+ assert.NotNil(t, args.Get)
+ assert.Empty(t, args.Get.Items)
+ assert.Equal(t, 5, args.Limit)
+ }
+
+ {
+ var args cmd
+ err := parse("get item1", &args)
+ require.NoError(t, err)
+ 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)
+ 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)
+ assert.NotNil(t, args.Get)
+ assert.Equal(t, []string{"item1", "item2"}, args.Get.Items)
+ assert.Equal(t, 5, args.Limit)
+ }
+}
+
+func TestValForNilStruct(t *testing.T) {
+ type subcmd struct{}
+ var cmd struct {
+ Sub *subcmd `arg:"subcommand"`
+ }
+
+ p, err := NewParser(Config{}, &cmd)
+ require.NoError(t, err)
+
+ typ := reflect.TypeOf(cmd)
+ subField, _ := typ.FieldByName("Sub")
+
+ v := p.val(path{fields: []reflect.StructField{subField, subField}})
+ assert.False(t, v.IsValid())
+}
+
+func TestSubcommandInvalidInternal(t *testing.T) {
+ // this situation should never arise in practice but still good to test for it
+ var cmd struct{}
+ p, err := NewParser(Config{}, &cmd)
+ require.NoError(t, err)
+
+ p.subcommand = []string{"should", "never", "happen"}
+ sub := p.Subcommand()
+ assert.Nil(t, sub)
+}
diff --git a/test/usage_test.go b/test/usage_test.go
new file mode 100644
index 0000000..b1693a9
--- /dev/null
+++ b/test/usage_test.go
@@ -0,0 +1,717 @@
+package arg
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "os"
+ "strings"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+type NameDotName struct {
+ Head, Tail string
+}
+
+func (n *NameDotName) UnmarshalText(b []byte) error {
+ s := string(b)
+ pos := strings.Index(s, ".")
+ if pos == -1 {
+ return fmt.Errorf("missing period in %s", s)
+ }
+ n.Head = s[:pos]
+ n.Tail = s[pos+1:]
+ return nil
+}
+
+func (n *NameDotName) MarshalText() (text []byte, err error) {
+ text = []byte(fmt.Sprintf("%s.%s", n.Head, n.Tail))
+ return
+}
+
+func TestWriteUsage(t *testing.T) {
+ expectedUsage := "Usage: example [--name NAME] [--value VALUE] [--verbose] [--dataset DATASET] [--optimize OPTIMIZE] [--ids IDS] [--values VALUES] [--workers WORKERS] [--testenv TESTENV] [--file FILE] INPUT [OUTPUT [OUTPUT ...]]"
+
+ expectedHelp := `
+Usage: example [--name NAME] [--value VALUE] [--verbose] [--dataset DATASET] [--optimize OPTIMIZE] [--ids IDS] [--values VALUES] [--workers WORKERS] [--testenv TESTENV] [--file FILE] INPUT [OUTPUT [OUTPUT ...]]
+
+Positional arguments:
+ INPUT
+ OUTPUT list of outputs
+
+Options:
+ --name NAME name to use [default: Foo Bar]
+ --value VALUE secret value [default: 42]
+ --verbose, -v verbosity level
+ --dataset DATASET dataset to use
+ --optimize OPTIMIZE, -O OPTIMIZE
+ optimization level
+ --ids IDS Ids
+ --values VALUES Values
+ --workers WORKERS, -w WORKERS
+ number of workers to start [default: 10, env: WORKERS]
+ --testenv TESTENV, -a TESTENV [env: TEST_ENV]
+ --file FILE, -f FILE File with mandatory extension [default: scratch.txt]
+ --help, -h display this help and exit
+
+Environment variables:
+ API_KEY Required. Only via env-var for security reasons
+ TRACE Optional. Record low-level trace
+`
+
+ var args struct {
+ Input string `arg:"positional,required"`
+ Output []string `arg:"positional" help:"list of outputs"`
+ Name string `help:"name to use"`
+ Value int `help:"secret value"`
+ Verbose bool `arg:"-v" help:"verbosity level"`
+ Dataset string `help:"dataset to use"`
+ Optimize int `arg:"-O" help:"optimization level"`
+ Ids []int64 `help:"Ids"`
+ Values []float64 `help:"Values"`
+ Workers int `arg:"-w,env:WORKERS" help:"number of workers to start" default:"10"`
+ TestEnv string `arg:"-a,env:TEST_ENV"`
+ ApiKey string `arg:"required,-,--,env:API_KEY" help:"Only via env-var for security reasons"`
+ Trace bool `arg:"-,--,env" help:"Record low-level trace"`
+ File *NameDotName `arg:"-f" help:"File with mandatory extension"`
+ }
+ args.Name = "Foo Bar"
+ args.Value = 42
+ args.File = &NameDotName{"scratch", "txt"}
+ p, err := NewParser(Config{Program: "example"}, &args)
+ require.NoError(t, err)
+
+ os.Args[0] = "example"
+
+ var help bytes.Buffer
+ p.WriteHelp(&help)
+ assert.Equal(t, expectedHelp[1:], help.String())
+
+ var usage bytes.Buffer
+ p.WriteUsage(&usage)
+ assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String()))
+}
+
+type MyEnum int
+
+func (n *MyEnum) UnmarshalText(b []byte) error {
+ return nil
+}
+
+func (n *MyEnum) MarshalText() ([]byte, error) {
+ return nil, errors.New("There was a problem")
+}
+
+func TestUsageWithDefaults(t *testing.T) {
+ expectedUsage := "Usage: example [--label LABEL] [--content CONTENT]"
+
+ expectedHelp := `
+Usage: example [--label LABEL] [--content CONTENT]
+
+Options:
+ --label LABEL [default: cat]
+ --content CONTENT [default: dog]
+ --help, -h display this help and exit
+`
+ var args struct {
+ Label string
+ Content string `default:"dog"`
+ }
+ args.Label = "cat"
+ p, err := NewParser(Config{Program: "example"}, &args)
+ require.NoError(t, err)
+
+ args.Label = "should_ignore_this"
+
+ var help bytes.Buffer
+ p.WriteHelp(&help)
+ assert.Equal(t, expectedHelp[1:], help.String())
+
+ var usage bytes.Buffer
+ p.WriteUsage(&usage)
+ assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String()))
+}
+
+func TestUsageCannotMarshalToString(t *testing.T) {
+ var args struct {
+ Name *MyEnum
+ }
+ 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`)
+}
+
+func TestUsageLongPositionalWithHelp_legacyForm(t *testing.T) {
+ expectedUsage := "Usage: example [VERYLONGPOSITIONALWITHHELP]"
+
+ expectedHelp := `
+Usage: example [VERYLONGPOSITIONALWITHHELP]
+
+Positional arguments:
+ VERYLONGPOSITIONALWITHHELP
+ this positional argument is very long but cannot include commas
+
+Options:
+ --help, -h display this help and exit
+`
+ var args struct {
+ VeryLongPositionalWithHelp string `arg:"positional,help:this positional argument is very long but cannot include commas"`
+ }
+
+ p, err := NewParser(Config{Program: "example"}, &args)
+ require.NoError(t, err)
+
+ var help bytes.Buffer
+ p.WriteHelp(&help)
+ assert.Equal(t, expectedHelp[1:], help.String())
+
+ var usage bytes.Buffer
+ p.WriteUsage(&usage)
+ assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String()))
+}
+
+func TestUsageLongPositionalWithHelp_newForm(t *testing.T) {
+ expectedUsage := "Usage: example [VERYLONGPOSITIONALWITHHELP]"
+
+ expectedHelp := `
+Usage: example [VERYLONGPOSITIONALWITHHELP]
+
+Positional arguments:
+ VERYLONGPOSITIONALWITHHELP
+ this positional argument is very long, and includes: commas, colons etc
+
+Options:
+ --help, -h display this help and exit
+`
+ var args struct {
+ VeryLongPositionalWithHelp string `arg:"positional" help:"this positional argument is very long, and includes: commas, colons etc"`
+ }
+
+ p, err := NewParser(Config{Program: "example"}, &args)
+ require.NoError(t, err)
+
+ var help bytes.Buffer
+ p.WriteHelp(&help)
+ assert.Equal(t, expectedHelp[1:], help.String())
+
+ var usage bytes.Buffer
+ p.WriteUsage(&usage)
+ assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String()))
+}
+
+func TestUsageWithProgramName(t *testing.T) {
+ expectedUsage := "Usage: myprogram"
+
+ expectedHelp := `
+Usage: myprogram
+
+Options:
+ --help, -h display this help and exit
+`
+ config := Config{
+ Program: "myprogram",
+ }
+ p, err := NewParser(config, &struct{}{})
+ require.NoError(t, err)
+
+ os.Args[0] = "example"
+
+ var help bytes.Buffer
+ p.WriteHelp(&help)
+ assert.Equal(t, expectedHelp[1:], help.String())
+
+ var usage bytes.Buffer
+ p.WriteUsage(&usage)
+ assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String()))
+}
+
+type versioned struct{}
+
+// Version returns the version for this program
+func (versioned) Version() string {
+ return "example 3.2.1"
+}
+
+func TestUsageWithVersion(t *testing.T) {
+ expectedUsage := "example 3.2.1\nUsage: example"
+
+ expectedHelp := `
+example 3.2.1
+Usage: example
+
+Options:
+ --help, -h display this help and exit
+ --version display version and exit
+`
+ os.Args[0] = "example"
+ p, err := NewParser(Config{}, &versioned{})
+ require.NoError(t, err)
+
+ var help bytes.Buffer
+ p.WriteHelp(&help)
+ assert.Equal(t, expectedHelp[1:], help.String())
+
+ var usage bytes.Buffer
+ p.WriteUsage(&usage)
+ assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String()))
+}
+
+type described struct{}
+
+// Described returns the description for this program
+func (described) Description() string {
+ return "this program does this and that"
+}
+
+func TestUsageWithDescription(t *testing.T) {
+ expectedUsage := "Usage: example"
+
+ expectedHelp := `
+this program does this and that
+Usage: example
+
+Options:
+ --help, -h display this help and exit
+`
+ os.Args[0] = "example"
+ p, err := NewParser(Config{}, &described{})
+ require.NoError(t, err)
+
+ var help bytes.Buffer
+ p.WriteHelp(&help)
+ assert.Equal(t, expectedHelp[1:], help.String())
+
+ var usage bytes.Buffer
+ p.WriteUsage(&usage)
+ assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String()))
+}
+
+type epilogued struct{}
+
+// Epilogued returns the epilogue for this program
+func (epilogued) Epilogue() string {
+ return "For more information visit github.com/alexflint/go-arg"
+}
+
+func TestUsageWithEpilogue(t *testing.T) {
+ expectedUsage := "Usage: example"
+
+ expectedHelp := `
+Usage: example
+
+Options:
+ --help, -h display this help and exit
+
+For more information visit github.com/alexflint/go-arg
+`
+ os.Args[0] = "example"
+ p, err := NewParser(Config{}, &epilogued{})
+ require.NoError(t, err)
+
+ var help bytes.Buffer
+ p.WriteHelp(&help)
+ assert.Equal(t, expectedHelp[1:], help.String())
+
+ var usage bytes.Buffer
+ p.WriteUsage(&usage)
+ assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String()))
+}
+
+func TestUsageForRequiredPositionals(t *testing.T) {
+ expectedUsage := "Usage: example REQUIRED1 REQUIRED2\n"
+ var args struct {
+ Required1 string `arg:"positional,required"`
+ Required2 string `arg:"positional,required"`
+ }
+
+ p, err := NewParser(Config{Program: "example"}, &args)
+ require.NoError(t, err)
+
+ var usage bytes.Buffer
+ p.WriteUsage(&usage)
+ assert.Equal(t, expectedUsage, usage.String())
+}
+
+func TestUsageForMixedPositionals(t *testing.T) {
+ expectedUsage := "Usage: example REQUIRED1 REQUIRED2 [OPTIONAL1 [OPTIONAL2]]\n"
+ var args struct {
+ Required1 string `arg:"positional,required"`
+ Required2 string `arg:"positional,required"`
+ Optional1 string `arg:"positional"`
+ Optional2 string `arg:"positional"`
+ }
+
+ p, err := NewParser(Config{Program: "example"}, &args)
+ require.NoError(t, err)
+
+ var usage bytes.Buffer
+ p.WriteUsage(&usage)
+ assert.Equal(t, expectedUsage, usage.String())
+}
+
+func TestUsageForRepeatedPositionals(t *testing.T) {
+ expectedUsage := "Usage: example REQUIRED1 REQUIRED2 REPEATED [REPEATED ...]\n"
+ var args struct {
+ Required1 string `arg:"positional,required"`
+ Required2 string `arg:"positional,required"`
+ Repeated []string `arg:"positional,required"`
+ }
+
+ p, err := NewParser(Config{Program: "example"}, &args)
+ require.NoError(t, err)
+
+ var usage bytes.Buffer
+ p.WriteUsage(&usage)
+ assert.Equal(t, expectedUsage, usage.String())
+}
+
+func TestUsageForMixedAndRepeatedPositionals(t *testing.T) {
+ expectedUsage := "Usage: example REQUIRED1 REQUIRED2 [OPTIONAL1 [OPTIONAL2 [REPEATED [REPEATED ...]]]]\n"
+ var args struct {
+ Required1 string `arg:"positional,required"`
+ Required2 string `arg:"positional,required"`
+ Optional1 string `arg:"positional"`
+ Optional2 string `arg:"positional"`
+ Repeated []string `arg:"positional"`
+ }
+
+ p, err := NewParser(Config{Program: "example"}, &args)
+ require.NoError(t, err)
+
+ var usage bytes.Buffer
+ p.WriteUsage(&usage)
+ assert.Equal(t, expectedUsage, usage.String())
+}
+
+func TestRequiredMultiplePositionals(t *testing.T) {
+ expectedUsage := "Usage: example REQUIREDMULTIPLE [REQUIREDMULTIPLE ...]\n"
+
+ expectedHelp := `
+Usage: example REQUIREDMULTIPLE [REQUIREDMULTIPLE ...]
+
+Positional arguments:
+ REQUIREDMULTIPLE required multiple positional
+
+Options:
+ --help, -h display this help and exit
+`
+ var args struct {
+ RequiredMultiple []string `arg:"positional,required" help:"required multiple positional"`
+ }
+
+ p, err := NewParser(Config{Program: "example"}, &args)
+ require.NoError(t, err)
+
+ var help bytes.Buffer
+ p.WriteHelp(&help)
+ assert.Equal(t, expectedHelp[1:], help.String())
+
+ var usage bytes.Buffer
+ p.WriteUsage(&usage)
+ assert.Equal(t, expectedUsage, usage.String())
+}
+
+func TestUsageWithNestedSubcommands(t *testing.T) {
+ expectedUsage := "Usage: example child nested [--enable] OUTPUT"
+
+ expectedHelp := `
+Usage: example child nested [--enable] OUTPUT
+
+Positional arguments:
+ OUTPUT
+
+Options:
+ --enable
+
+Global options:
+ --values VALUES Values
+ --verbose, -v verbosity level
+ --help, -h display this help and exit
+`
+
+ var args struct {
+ Verbose bool `arg:"-v" help:"verbosity level"`
+ Child *struct {
+ Values []float64 `help:"Values"`
+ Nested *struct {
+ Enable bool
+ Output string `arg:"positional,required"`
+ } `arg:"subcommand:nested"`
+ } `arg:"subcommand:child"`
+ }
+
+ os.Args[0] = "example"
+ p, err := NewParser(Config{}, &args)
+ require.NoError(t, err)
+
+ _ = p.Parse([]string{"child", "nested", "value"})
+
+ assert.Equal(t, []string{"child", "nested"}, p.SubcommandNames())
+
+ var help bytes.Buffer
+ p.WriteHelp(&help)
+ assert.Equal(t, expectedHelp[1:], help.String())
+
+ var help2 bytes.Buffer
+ p.WriteHelpForSubcommand(&help2, "child", "nested")
+ assert.Equal(t, expectedHelp[1:], help2.String())
+
+ var usage bytes.Buffer
+ p.WriteUsage(&usage)
+ assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String()))
+
+ var usage2 bytes.Buffer
+ p.WriteUsageForSubcommand(&usage2, "child", "nested")
+ assert.Equal(t, expectedUsage, strings.TrimSpace(usage2.String()))
+}
+
+func TestNonexistentSubcommand(t *testing.T) {
+ var args struct {
+ sub *struct{} `arg:"subcommand"`
+ }
+ p, err := NewParser(Config{Exit: func(int) {}}, &args)
+ require.NoError(t, err)
+
+ var b bytes.Buffer
+
+ err = p.WriteUsageForSubcommand(&b, "does_not_exist")
+ assert.Error(t, err)
+
+ err = p.WriteHelpForSubcommand(&b, "does_not_exist")
+ assert.Error(t, err)
+
+ err = p.FailSubcommand("something went wrong", "does_not_exist")
+ assert.Error(t, err)
+
+ err = p.WriteUsageForSubcommand(&b, "sub", "does_not_exist")
+ assert.Error(t, err)
+
+ err = p.WriteHelpForSubcommand(&b, "sub", "does_not_exist")
+ assert.Error(t, err)
+
+ err = p.FailSubcommand("something went wrong", "sub", "does_not_exist")
+ assert.Error(t, err)
+}
+
+func TestUsageWithoutLongNames(t *testing.T) {
+ expectedUsage := "Usage: example [-a PLACEHOLDER] -b SHORTONLY2"
+
+ expectedHelp := `
+Usage: example [-a PLACEHOLDER] -b SHORTONLY2
+
+Options:
+ -a PLACEHOLDER some help [default: some val]
+ -b SHORTONLY2 some help2
+ --help, -h display this help and exit
+`
+ var args struct {
+ ShortOnly string `arg:"-a,--" help:"some help" default:"some val" placeholder:"PLACEHOLDER"`
+ ShortOnly2 string `arg:"-b,--,required" help:"some help2"`
+ }
+ p, err := NewParser(Config{Program: "example"}, &args)
+ require.NoError(t, err)
+
+ var help bytes.Buffer
+ p.WriteHelp(&help)
+ assert.Equal(t, expectedHelp[1:], help.String())
+
+ var usage bytes.Buffer
+ p.WriteUsage(&usage)
+ assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String()))
+}
+
+func TestUsageWithShortFirst(t *testing.T) {
+ expectedUsage := "Usage: example [-c CAT] [--dog DOG]"
+
+ expectedHelp := `
+Usage: example [-c CAT] [--dog DOG]
+
+Options:
+ -c CAT
+ --dog DOG
+ --help, -h display this help and exit
+`
+ var args struct {
+ Dog string
+ Cat string `arg:"-c,--"`
+ }
+ p, err := NewParser(Config{Program: "example"}, &args)
+ assert.NoError(t, err)
+
+ var help bytes.Buffer
+ p.WriteHelp(&help)
+ assert.Equal(t, expectedHelp[1:], help.String())
+
+ var usage bytes.Buffer
+ p.WriteUsage(&usage)
+ assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String()))
+}
+
+func TestUsageWithEnvOptions(t *testing.T) {
+ expectedUsage := "Usage: example [-s SHORT]"
+
+ expectedHelp := `
+Usage: example [-s SHORT]
+
+Options:
+ -s SHORT [env: SHORT]
+ --help, -h display this help and exit
+
+Environment variables:
+ ENVONLY Optional.
+ ENVONLY2 Optional.
+ CUSTOM Optional.
+`
+ var args struct {
+ Short string `arg:"--,-s,env"`
+ EnvOnly string `arg:"--,env"`
+ EnvOnly2 string `arg:"--,-,env"`
+ EnvOnlyOverriden string `arg:"--,env:CUSTOM"`
+ }
+
+ p, err := NewParser(Config{Program: "example"}, &args)
+ assert.NoError(t, err)
+
+ var help bytes.Buffer
+ p.WriteHelp(&help)
+ assert.Equal(t, expectedHelp[1:], help.String())
+
+ var usage bytes.Buffer
+ p.WriteUsage(&usage)
+ assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String()))
+}
+
+func TestEnvOnlyArgs(t *testing.T) {
+ expectedUsage := "Usage: example [--arg ARG]"
+
+ expectedHelp := `
+Usage: example [--arg ARG]
+
+Options:
+ --arg ARG, -a ARG [env: MY_ARG]
+ --help, -h display this help and exit
+
+Environment variables:
+ AUTH_KEY Required.
+`
+ var args struct {
+ ArgParam string `arg:"-a,--arg,env:MY_ARG"`
+ AuthKey string `arg:"required,--,env:AUTH_KEY"`
+ }
+ p, err := NewParser(Config{Program: "example"}, &args)
+ assert.NoError(t, err)
+
+ var help bytes.Buffer
+ p.WriteHelp(&help)
+ assert.Equal(t, expectedHelp[1:], help.String())
+
+ var usage bytes.Buffer
+ p.WriteUsage(&usage)
+ assert.Equal(t, expectedUsage, strings.TrimSpace(usage.String()))
+}
+
+func TestFail(t *testing.T) {
+ var stdout bytes.Buffer
+ var exitCode int
+ exit := func(code int) { exitCode = code }
+
+ expectedStdout := `
+Usage: example [--foo FOO]
+error: something went wrong
+`
+
+ var args struct {
+ Foo int
+ }
+ p, err := NewParser(Config{Program: "example", Exit: exit, Out: &stdout}, &args)
+ require.NoError(t, err)
+ p.Fail("something went wrong")
+
+ assert.Equal(t, expectedStdout[1:], stdout.String())
+ assert.Equal(t, -1, exitCode)
+}
+
+func TestFailSubcommand(t *testing.T) {
+ var stdout bytes.Buffer
+ var exitCode int
+ exit := func(code int) { exitCode = code }
+
+ expectedStdout := `
+Usage: example sub
+error: something went wrong
+`
+
+ var args struct {
+ Sub *struct{} `arg:"subcommand"`
+ }
+ p, err := NewParser(Config{Program: "example", Exit: exit, Out: &stdout}, &args)
+ require.NoError(t, err)
+
+ err = p.FailSubcommand("something went wrong", "sub")
+ require.NoError(t, err)
+
+ assert.Equal(t, expectedStdout[1:], stdout.String())
+ assert.Equal(t, -1, exitCode)
+}
+
+type lengthOf struct {
+ Length int
+}
+
+func (p *lengthOf) UnmarshalText(b []byte) error {
+ p.Length = len(b)
+ return nil
+}
+
+func TestHelpShowsDefaultValueFromOriginalTag(t *testing.T) {
+ // check that the usage text prints the original string from the default tag, not
+ // the serialization of the parsed value
+
+ expectedHelp := `
+Usage: example [--test TEST]
+
+Options:
+ --test TEST [default: some_default_value]
+ --help, -h display this help and exit
+`
+
+ var args struct {
+ Test *lengthOf `default:"some_default_value"`
+ }
+ p, err := NewParser(Config{Program: "example"}, &args)
+ require.NoError(t, err)
+
+ var help bytes.Buffer
+ p.WriteHelp(&help)
+ assert.Equal(t, expectedHelp[1:], help.String())
+}
+
+func TestHelpShowsSubcommandAliases(t *testing.T) {
+ expectedHelp := `
+Usage: example <command> [<args>]
+
+Options:
+ --help, -h display this help and exit
+
+Commands:
+ remove, rm, r remove something from somewhere
+ simple do something simple
+ halt, stop stop now
+`
+
+ var args struct {
+ Remove *struct{} `arg:"subcommand:remove|rm|r" help:"remove something from somewhere"`
+ Simple *struct{} `arg:"subcommand" help:"do something simple"`
+ Stop *struct{} `arg:"subcommand:halt|stop" help:"stop now"`
+ }
+ p, err := NewParser(Config{Program: "example"}, &args)
+ require.NoError(t, err)
+
+ var help bytes.Buffer
+ p.WriteHelp(&help)
+ assert.Equal(t, expectedHelp[1:], help.String())
+}
generated by cgit v1.2.3 (git 2.51.0) at 2025-11-19 01:49:26 +0000