| // Copyright 2009 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package flag_test |
| |
| import ( |
| "bytes" |
| . "flag" |
| "fmt" |
| "io" |
| "os" |
| "sort" |
| "strconv" |
| "strings" |
| "testing" |
| "time" |
| ) |
| |
| func boolString(s string) string { |
| if s == "0" { |
| return "false" |
| } |
| return "true" |
| } |
| |
| func TestEverything(t *testing.T) { |
| ResetForTesting(nil) |
| Bool("test_bool", false, "bool value") |
| Int("test_int", 0, "int value") |
| Int64("test_int64", 0, "int64 value") |
| Uint("test_uint", 0, "uint value") |
| Uint64("test_uint64", 0, "uint64 value") |
| String("test_string", "0", "string value") |
| Float64("test_float64", 0, "float64 value") |
| Duration("test_duration", 0, "time.Duration value") |
| |
| m := make(map[string]*Flag) |
| desired := "0" |
| visitor := func(f *Flag) { |
| if len(f.Name) > 5 && f.Name[0:5] == "test_" { |
| m[f.Name] = f |
| ok := false |
| switch { |
| case f.Value.String() == desired: |
| ok = true |
| case f.Name == "test_bool" && f.Value.String() == boolString(desired): |
| ok = true |
| case f.Name == "test_duration" && f.Value.String() == desired+"s": |
| ok = true |
| } |
| if !ok { |
| t.Error("Visit: bad value", f.Value.String(), "for", f.Name) |
| } |
| } |
| } |
| VisitAll(visitor) |
| if len(m) != 8 { |
| t.Error("VisitAll misses some flags") |
| for k, v := range m { |
| t.Log(k, *v) |
| } |
| } |
| m = make(map[string]*Flag) |
| Visit(visitor) |
| if len(m) != 0 { |
| t.Errorf("Visit sees unset flags") |
| for k, v := range m { |
| t.Log(k, *v) |
| } |
| } |
| // Now set all flags |
| Set("test_bool", "true") |
| Set("test_int", "1") |
| Set("test_int64", "1") |
| Set("test_uint", "1") |
| Set("test_uint64", "1") |
| Set("test_string", "1") |
| Set("test_float64", "1") |
| Set("test_duration", "1s") |
| desired = "1" |
| Visit(visitor) |
| if len(m) != 8 { |
| t.Error("Visit fails after set") |
| for k, v := range m { |
| t.Log(k, *v) |
| } |
| } |
| // Now test they're visited in sort order. |
| var flagNames []string |
| Visit(func(f *Flag) { flagNames = append(flagNames, f.Name) }) |
| if !sort.StringsAreSorted(flagNames) { |
| t.Errorf("flag names not sorted: %v", flagNames) |
| } |
| } |
| |
| func TestGet(t *testing.T) { |
| ResetForTesting(nil) |
| Bool("test_bool", true, "bool value") |
| Int("test_int", 1, "int value") |
| Int64("test_int64", 2, "int64 value") |
| Uint("test_uint", 3, "uint value") |
| Uint64("test_uint64", 4, "uint64 value") |
| String("test_string", "5", "string value") |
| Float64("test_float64", 6, "float64 value") |
| Duration("test_duration", 7, "time.Duration value") |
| |
| visitor := func(f *Flag) { |
| if len(f.Name) > 5 && f.Name[0:5] == "test_" { |
| g, ok := f.Value.(Getter) |
| if !ok { |
| t.Errorf("Visit: value does not satisfy Getter: %T", f.Value) |
| return |
| } |
| switch f.Name { |
| case "test_bool": |
| ok = g.Get() == true |
| case "test_int": |
| ok = g.Get() == int(1) |
| case "test_int64": |
| ok = g.Get() == int64(2) |
| case "test_uint": |
| ok = g.Get() == uint(3) |
| case "test_uint64": |
| ok = g.Get() == uint64(4) |
| case "test_string": |
| ok = g.Get() == "5" |
| case "test_float64": |
| ok = g.Get() == float64(6) |
| case "test_duration": |
| ok = g.Get() == time.Duration(7) |
| } |
| if !ok { |
| t.Errorf("Visit: bad value %T(%v) for %s", g.Get(), g.Get(), f.Name) |
| } |
| } |
| } |
| VisitAll(visitor) |
| } |
| |
| func TestUsage(t *testing.T) { |
| called := false |
| ResetForTesting(func() { called = true }) |
| if CommandLine.Parse([]string{"-x"}) == nil { |
| t.Error("parse did not fail for unknown flag") |
| } |
| if !called { |
| t.Error("did not call Usage for unknown flag") |
| } |
| } |
| |
| func testParse(f *FlagSet, t *testing.T) { |
| if f.Parsed() { |
| t.Error("f.Parse() = true before Parse") |
| } |
| boolFlag := f.Bool("bool", false, "bool value") |
| bool2Flag := f.Bool("bool2", false, "bool2 value") |
| intFlag := f.Int("int", 0, "int value") |
| int64Flag := f.Int64("int64", 0, "int64 value") |
| uintFlag := f.Uint("uint", 0, "uint value") |
| uint64Flag := f.Uint64("uint64", 0, "uint64 value") |
| stringFlag := f.String("string", "0", "string value") |
| float64Flag := f.Float64("float64", 0, "float64 value") |
| durationFlag := f.Duration("duration", 5*time.Second, "time.Duration value") |
| extra := "one-extra-argument" |
| args := []string{ |
| "-bool", |
| "-bool2=true", |
| "--int", "22", |
| "--int64", "0x23", |
| "-uint", "24", |
| "--uint64", "25", |
| "-string", "hello", |
| "-float64", "2718e28", |
| "-duration", "2m", |
| extra, |
| } |
| if err := f.Parse(args); err != nil { |
| t.Fatal(err) |
| } |
| if !f.Parsed() { |
| t.Error("f.Parse() = false after Parse") |
| } |
| if *boolFlag != true { |
| t.Error("bool flag should be true, is ", *boolFlag) |
| } |
| if *bool2Flag != true { |
| t.Error("bool2 flag should be true, is ", *bool2Flag) |
| } |
| if *intFlag != 22 { |
| t.Error("int flag should be 22, is ", *intFlag) |
| } |
| if *int64Flag != 0x23 { |
| t.Error("int64 flag should be 0x23, is ", *int64Flag) |
| } |
| if *uintFlag != 24 { |
| t.Error("uint flag should be 24, is ", *uintFlag) |
| } |
| if *uint64Flag != 25 { |
| t.Error("uint64 flag should be 25, is ", *uint64Flag) |
| } |
| if *stringFlag != "hello" { |
| t.Error("string flag should be `hello`, is ", *stringFlag) |
| } |
| if *float64Flag != 2718e28 { |
| t.Error("float64 flag should be 2718e28, is ", *float64Flag) |
| } |
| if *durationFlag != 2*time.Minute { |
| t.Error("duration flag should be 2m, is ", *durationFlag) |
| } |
| if len(f.Args()) != 1 { |
| t.Error("expected one argument, got", len(f.Args())) |
| } else if f.Args()[0] != extra { |
| t.Errorf("expected argument %q got %q", extra, f.Args()[0]) |
| } |
| } |
| |
| func TestParse(t *testing.T) { |
| ResetForTesting(func() { t.Error("bad parse") }) |
| testParse(CommandLine, t) |
| } |
| |
| func TestFlagSetParse(t *testing.T) { |
| testParse(NewFlagSet("test", ContinueOnError), t) |
| } |
| |
| // Declare a user-defined flag type. |
| type flagVar []string |
| |
| func (f *flagVar) String() string { |
| return fmt.Sprint([]string(*f)) |
| } |
| |
| func (f *flagVar) Set(value string) error { |
| *f = append(*f, value) |
| return nil |
| } |
| |
| func TestUserDefined(t *testing.T) { |
| var flags FlagSet |
| flags.Init("test", ContinueOnError) |
| var v flagVar |
| flags.Var(&v, "v", "usage") |
| if err := flags.Parse([]string{"-v", "1", "-v", "2", "-v=3"}); err != nil { |
| t.Error(err) |
| } |
| if len(v) != 3 { |
| t.Fatal("expected 3 args; got ", len(v)) |
| } |
| expect := "[1 2 3]" |
| if v.String() != expect { |
| t.Errorf("expected value %q got %q", expect, v.String()) |
| } |
| } |
| |
| func TestUserDefinedForCommandLine(t *testing.T) { |
| const help = "HELP" |
| var result string |
| ResetForTesting(func() { result = help }) |
| Usage() |
| if result != help { |
| t.Fatalf("got %q; expected %q", result, help) |
| } |
| } |
| |
| // Declare a user-defined boolean flag type. |
| type boolFlagVar struct { |
| count int |
| } |
| |
| func (b *boolFlagVar) String() string { |
| return fmt.Sprintf("%d", b.count) |
| } |
| |
| func (b *boolFlagVar) Set(value string) error { |
| if value == "true" { |
| b.count++ |
| } |
| return nil |
| } |
| |
| func (b *boolFlagVar) IsBoolFlag() bool { |
| return b.count < 4 |
| } |
| |
| func TestUserDefinedBool(t *testing.T) { |
| var flags FlagSet |
| flags.Init("test", ContinueOnError) |
| var b boolFlagVar |
| var err error |
| flags.Var(&b, "b", "usage") |
| if err = flags.Parse([]string{"-b", "-b", "-b", "-b=true", "-b=false", "-b", "barg", "-b"}); err != nil { |
| if b.count < 4 { |
| t.Error(err) |
| } |
| } |
| |
| if b.count != 4 { |
| t.Errorf("want: %d; got: %d", 4, b.count) |
| } |
| |
| if err == nil { |
| t.Error("expected error; got none") |
| } |
| } |
| |
| func TestSetOutput(t *testing.T) { |
| var flags FlagSet |
| var buf bytes.Buffer |
| flags.SetOutput(&buf) |
| flags.Init("test", ContinueOnError) |
| flags.Parse([]string{"-unknown"}) |
| if out := buf.String(); !strings.Contains(out, "-unknown") { |
| t.Logf("expected output mentioning unknown; got %q", out) |
| } |
| } |
| |
| // This tests that one can reset the flags. This still works but not well, and is |
| // superseded by FlagSet. |
| func TestChangingArgs(t *testing.T) { |
| ResetForTesting(func() { t.Fatal("bad parse") }) |
| oldArgs := os.Args |
| defer func() { os.Args = oldArgs }() |
| os.Args = []string{"cmd", "-before", "subcmd", "-after", "args"} |
| before := Bool("before", false, "") |
| if err := CommandLine.Parse(os.Args[1:]); err != nil { |
| t.Fatal(err) |
| } |
| cmd := Arg(0) |
| os.Args = Args() |
| after := Bool("after", false, "") |
| Parse() |
| args := Args() |
| |
| if !*before || cmd != "subcmd" || !*after || len(args) != 1 || args[0] != "args" { |
| t.Fatalf("expected true subcmd true [args] got %v %v %v %v", *before, cmd, *after, args) |
| } |
| } |
| |
| // Test that -help invokes the usage message and returns ErrHelp. |
| func TestHelp(t *testing.T) { |
| var helpCalled = false |
| fs := NewFlagSet("help test", ContinueOnError) |
| fs.Usage = func() { helpCalled = true } |
| var flag bool |
| fs.BoolVar(&flag, "flag", false, "regular flag") |
| // Regular flag invocation should work |
| err := fs.Parse([]string{"-flag=true"}) |
| if err != nil { |
| t.Fatal("expected no error; got ", err) |
| } |
| if !flag { |
| t.Error("flag was not set by -flag") |
| } |
| if helpCalled { |
| t.Error("help called for regular flag") |
| helpCalled = false // reset for next test |
| } |
| // Help flag should work as expected. |
| err = fs.Parse([]string{"-help"}) |
| if err == nil { |
| t.Fatal("error expected") |
| } |
| if err != ErrHelp { |
| t.Fatal("expected ErrHelp; got ", err) |
| } |
| if !helpCalled { |
| t.Fatal("help was not called") |
| } |
| // If we define a help flag, that should override. |
| var help bool |
| fs.BoolVar(&help, "help", false, "help flag") |
| helpCalled = false |
| err = fs.Parse([]string{"-help"}) |
| if err != nil { |
| t.Fatal("expected no error for defined -help; got ", err) |
| } |
| if helpCalled { |
| t.Fatal("help was called; should not have been for defined help flag") |
| } |
| } |
| |
| const defaultOutput = ` -A for bootstrapping, allow 'any' type |
| -Alongflagname |
| disable bounds checking |
| -C a boolean defaulting to true (default true) |
| -D path |
| set relative path for local imports |
| -E string |
| issue 23543 (default "0") |
| -F number |
| a non-zero number (default 2.7) |
| -G float |
| a float that defaults to zero |
| -M string |
| a multiline |
| help |
| string |
| -N int |
| a non-zero int (default 27) |
| -O a flag |
| multiline help string (default true) |
| -Z int |
| an int that defaults to zero |
| -maxT timeout |
| set timeout for dial |
| ` |
| |
| func TestPrintDefaults(t *testing.T) { |
| fs := NewFlagSet("print defaults test", ContinueOnError) |
| var buf bytes.Buffer |
| fs.SetOutput(&buf) |
| fs.Bool("A", false, "for bootstrapping, allow 'any' type") |
| fs.Bool("Alongflagname", false, "disable bounds checking") |
| fs.Bool("C", true, "a boolean defaulting to true") |
| fs.String("D", "", "set relative `path` for local imports") |
| fs.String("E", "0", "issue 23543") |
| fs.Float64("F", 2.7, "a non-zero `number`") |
| fs.Float64("G", 0, "a float that defaults to zero") |
| fs.String("M", "", "a multiline\nhelp\nstring") |
| fs.Int("N", 27, "a non-zero int") |
| fs.Bool("O", true, "a flag\nmultiline help string") |
| fs.Int("Z", 0, "an int that defaults to zero") |
| fs.Duration("maxT", 0, "set `timeout` for dial") |
| fs.PrintDefaults() |
| got := buf.String() |
| if got != defaultOutput { |
| t.Errorf("got %q want %q\n", got, defaultOutput) |
| } |
| } |
| |
| // Issue 19230: validate range of Int and Uint flag values. |
| func TestIntFlagOverflow(t *testing.T) { |
| if strconv.IntSize != 32 { |
| return |
| } |
| ResetForTesting(nil) |
| Int("i", 0, "") |
| Uint("u", 0, "") |
| if err := Set("i", "2147483648"); err == nil { |
| t.Error("unexpected success setting Int") |
| } |
| if err := Set("u", "4294967296"); err == nil { |
| t.Error("unexpected success setting Uint") |
| } |
| } |
| |
| // Issue 20998: Usage should respect CommandLine.output. |
| func TestUsageOutput(t *testing.T) { |
| ResetForTesting(DefaultUsage) |
| var buf bytes.Buffer |
| CommandLine.SetOutput(&buf) |
| defer func(old []string) { os.Args = old }(os.Args) |
| os.Args = []string{"app", "-i=1", "-unknown"} |
| Parse() |
| const want = "flag provided but not defined: -i\nUsage of app:\n" |
| if got := buf.String(); got != want { |
| t.Errorf("output = %q; want %q", got, want) |
| } |
| } |
| |
| func TestGetters(t *testing.T) { |
| expectedName := "flag set" |
| expectedErrorHandling := ContinueOnError |
| expectedOutput := io.Writer(os.Stderr) |
| fs := NewFlagSet(expectedName, expectedErrorHandling) |
| |
| if fs.Name() != expectedName { |
| t.Errorf("unexpected name: got %s, expected %s", fs.Name(), expectedName) |
| } |
| if fs.ErrorHandling() != expectedErrorHandling { |
| t.Errorf("unexpected ErrorHandling: got %d, expected %d", fs.ErrorHandling(), expectedErrorHandling) |
| } |
| if fs.Output() != expectedOutput { |
| t.Errorf("unexpected output: got %#v, expected %#v", fs.Output(), expectedOutput) |
| } |
| |
| expectedName = "gopher" |
| expectedErrorHandling = ExitOnError |
| expectedOutput = os.Stdout |
| fs.Init(expectedName, expectedErrorHandling) |
| fs.SetOutput(expectedOutput) |
| |
| if fs.Name() != expectedName { |
| t.Errorf("unexpected name: got %s, expected %s", fs.Name(), expectedName) |
| } |
| if fs.ErrorHandling() != expectedErrorHandling { |
| t.Errorf("unexpected ErrorHandling: got %d, expected %d", fs.ErrorHandling(), expectedErrorHandling) |
| } |
| if fs.Output() != expectedOutput { |
| t.Errorf("unexpected output: got %v, expected %v", fs.Output(), expectedOutput) |
| } |
| } |