summaryrefslogtreecommitdiffstats
path: root/vendor/github.com/spf13/pflag/flag_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/spf13/pflag/flag_test.go')
-rw-r--r--vendor/github.com/spf13/pflag/flag_test.go948
1 files changed, 948 insertions, 0 deletions
diff --git a/vendor/github.com/spf13/pflag/flag_test.go b/vendor/github.com/spf13/pflag/flag_test.go
new file mode 100644
index 000000000..b294fc768
--- /dev/null
+++ b/vendor/github.com/spf13/pflag/flag_test.go
@@ -0,0 +1,948 @@
+// 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 pflag
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "net"
+ "os"
+ "reflect"
+ "sort"
+ "strconv"
+ "strings"
+ "testing"
+ "time"
+)
+
+var (
+ testBool = Bool("test_bool", false, "bool value")
+ testInt = Int("test_int", 0, "int value")
+ testInt64 = Int64("test_int64", 0, "int64 value")
+ testUint = Uint("test_uint", 0, "uint value")
+ testUint64 = Uint64("test_uint64", 0, "uint64 value")
+ testString = String("test_string", "0", "string value")
+ testFloat = Float64("test_float64", 0, "float64 value")
+ testDuration = Duration("test_duration", 0, "time.Duration value")
+ testOptionalInt = Int("test_optional_int", 0, "optional int value")
+ normalizeFlagNameInvocations = 0
+)
+
+func boolString(s string) string {
+ if s == "0" {
+ return "false"
+ }
+ return "true"
+}
+
+func TestEverything(t *testing.T) {
+ 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) != 9 {
+ 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")
+ Set("test_optional_int", "1")
+ desired = "1"
+ Visit(visitor)
+ if len(m) != 9 {
+ 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 TestUsage(t *testing.T) {
+ called := false
+ ResetForTesting(func() { called = true })
+ if GetCommandLine().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 TestAddFlagSet(t *testing.T) {
+ oldSet := NewFlagSet("old", ContinueOnError)
+ newSet := NewFlagSet("new", ContinueOnError)
+
+ oldSet.String("flag1", "flag1", "flag1")
+ oldSet.String("flag2", "flag2", "flag2")
+
+ newSet.String("flag2", "flag2", "flag2")
+ newSet.String("flag3", "flag3", "flag3")
+
+ oldSet.AddFlagSet(newSet)
+
+ if len(oldSet.formal) != 3 {
+ t.Errorf("Unexpected result adding a FlagSet to a FlagSet %v", oldSet)
+ }
+}
+
+func TestAnnotation(t *testing.T) {
+ f := NewFlagSet("shorthand", ContinueOnError)
+
+ if err := f.SetAnnotation("missing-flag", "key", nil); err == nil {
+ t.Errorf("Expected error setting annotation on non-existent flag")
+ }
+
+ f.StringP("stringa", "a", "", "string value")
+ if err := f.SetAnnotation("stringa", "key", nil); err != nil {
+ t.Errorf("Unexpected error setting new nil annotation: %v", err)
+ }
+ if annotation := f.Lookup("stringa").Annotations["key"]; annotation != nil {
+ t.Errorf("Unexpected annotation: %v", annotation)
+ }
+
+ f.StringP("stringb", "b", "", "string2 value")
+ if err := f.SetAnnotation("stringb", "key", []string{"value1"}); err != nil {
+ t.Errorf("Unexpected error setting new annotation: %v", err)
+ }
+ if annotation := f.Lookup("stringb").Annotations["key"]; !reflect.DeepEqual(annotation, []string{"value1"}) {
+ t.Errorf("Unexpected annotation: %v", annotation)
+ }
+
+ if err := f.SetAnnotation("stringb", "key", []string{"value2"}); err != nil {
+ t.Errorf("Unexpected error updating annotation: %v", err)
+ }
+ if annotation := f.Lookup("stringb").Annotations["key"]; !reflect.DeepEqual(annotation, []string{"value2"}) {
+ t.Errorf("Unexpected annotation: %v", annotation)
+ }
+}
+
+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")
+ bool3Flag := f.Bool("bool3", false, "bool3 value")
+ intFlag := f.Int("int", 0, "int value")
+ int8Flag := f.Int8("int8", 0, "int value")
+ int32Flag := f.Int32("int32", 0, "int value")
+ int64Flag := f.Int64("int64", 0, "int64 value")
+ uintFlag := f.Uint("uint", 0, "uint value")
+ uint8Flag := f.Uint8("uint8", 0, "uint value")
+ uint16Flag := f.Uint16("uint16", 0, "uint value")
+ uint32Flag := f.Uint32("uint32", 0, "uint value")
+ uint64Flag := f.Uint64("uint64", 0, "uint64 value")
+ stringFlag := f.String("string", "0", "string value")
+ float32Flag := f.Float32("float32", 0, "float32 value")
+ float64Flag := f.Float64("float64", 0, "float64 value")
+ ipFlag := f.IP("ip", net.ParseIP("127.0.0.1"), "ip value")
+ maskFlag := f.IPMask("mask", ParseIPv4Mask("0.0.0.0"), "mask value")
+ durationFlag := f.Duration("duration", 5*time.Second, "time.Duration value")
+ optionalIntNoValueFlag := f.Int("optional-int-no-value", 0, "int value")
+ f.Lookup("optional-int-no-value").NoOptDefVal = "9"
+ optionalIntWithValueFlag := f.Int("optional-int-with-value", 0, "int value")
+ f.Lookup("optional-int-no-value").NoOptDefVal = "9"
+ extra := "one-extra-argument"
+ args := []string{
+ "--bool",
+ "--bool2=true",
+ "--bool3=false",
+ "--int=22",
+ "--int8=-8",
+ "--int32=-32",
+ "--int64=0x23",
+ "--uint", "24",
+ "--uint8=8",
+ "--uint16=16",
+ "--uint32=32",
+ "--uint64=25",
+ "--string=hello",
+ "--float32=-172e12",
+ "--float64=2718e28",
+ "--ip=10.11.12.13",
+ "--mask=255.255.255.0",
+ "--duration=2m",
+ "--optional-int-no-value",
+ "--optional-int-with-value=42",
+ 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 v, err := f.GetBool("bool"); err != nil || v != *boolFlag {
+ t.Error("GetBool does not work.")
+ }
+ if *bool2Flag != true {
+ t.Error("bool2 flag should be true, is ", *bool2Flag)
+ }
+ if *bool3Flag != false {
+ t.Error("bool3 flag should be false, is ", *bool2Flag)
+ }
+ if *intFlag != 22 {
+ t.Error("int flag should be 22, is ", *intFlag)
+ }
+ if v, err := f.GetInt("int"); err != nil || v != *intFlag {
+ t.Error("GetInt does not work.")
+ }
+ if *int8Flag != -8 {
+ t.Error("int8 flag should be 0x23, is ", *int8Flag)
+ }
+ if v, err := f.GetInt8("int8"); err != nil || v != *int8Flag {
+ t.Error("GetInt8 does not work.")
+ }
+ if *int32Flag != -32 {
+ t.Error("int32 flag should be 0x23, is ", *int32Flag)
+ }
+ if v, err := f.GetInt32("int32"); err != nil || v != *int32Flag {
+ t.Error("GetInt32 does not work.")
+ }
+ if *int64Flag != 0x23 {
+ t.Error("int64 flag should be 0x23, is ", *int64Flag)
+ }
+ if v, err := f.GetInt64("int64"); err != nil || v != *int64Flag {
+ t.Error("GetInt64 does not work.")
+ }
+ if *uintFlag != 24 {
+ t.Error("uint flag should be 24, is ", *uintFlag)
+ }
+ if v, err := f.GetUint("uint"); err != nil || v != *uintFlag {
+ t.Error("GetUint does not work.")
+ }
+ if *uint8Flag != 8 {
+ t.Error("uint8 flag should be 8, is ", *uint8Flag)
+ }
+ if v, err := f.GetUint8("uint8"); err != nil || v != *uint8Flag {
+ t.Error("GetUint8 does not work.")
+ }
+ if *uint16Flag != 16 {
+ t.Error("uint16 flag should be 16, is ", *uint16Flag)
+ }
+ if v, err := f.GetUint16("uint16"); err != nil || v != *uint16Flag {
+ t.Error("GetUint16 does not work.")
+ }
+ if *uint32Flag != 32 {
+ t.Error("uint32 flag should be 32, is ", *uint32Flag)
+ }
+ if v, err := f.GetUint32("uint32"); err != nil || v != *uint32Flag {
+ t.Error("GetUint32 does not work.")
+ }
+ if *uint64Flag != 25 {
+ t.Error("uint64 flag should be 25, is ", *uint64Flag)
+ }
+ if v, err := f.GetUint64("uint64"); err != nil || v != *uint64Flag {
+ t.Error("GetUint64 does not work.")
+ }
+ if *stringFlag != "hello" {
+ t.Error("string flag should be `hello`, is ", *stringFlag)
+ }
+ if v, err := f.GetString("string"); err != nil || v != *stringFlag {
+ t.Error("GetString does not work.")
+ }
+ if *float32Flag != -172e12 {
+ t.Error("float32 flag should be -172e12, is ", *float32Flag)
+ }
+ if v, err := f.GetFloat32("float32"); err != nil || v != *float32Flag {
+ t.Errorf("GetFloat32 returned %v but float32Flag was %v", v, *float32Flag)
+ }
+ if *float64Flag != 2718e28 {
+ t.Error("float64 flag should be 2718e28, is ", *float64Flag)
+ }
+ if v, err := f.GetFloat64("float64"); err != nil || v != *float64Flag {
+ t.Errorf("GetFloat64 returned %v but float64Flag was %v", v, *float64Flag)
+ }
+ if !(*ipFlag).Equal(net.ParseIP("10.11.12.13")) {
+ t.Error("ip flag should be 10.11.12.13, is ", *ipFlag)
+ }
+ if v, err := f.GetIP("ip"); err != nil || !v.Equal(*ipFlag) {
+ t.Errorf("GetIP returned %v but ipFlag was %v", v, *ipFlag)
+ }
+ if (*maskFlag).String() != ParseIPv4Mask("255.255.255.0").String() {
+ t.Error("mask flag should be 255.255.255.0, is ", (*maskFlag).String())
+ }
+ if v, err := f.GetIPv4Mask("mask"); err != nil || v.String() != (*maskFlag).String() {
+ t.Errorf("GetIP returned %v maskFlag was %v error was %v", v, *maskFlag, err)
+ }
+ if *durationFlag != 2*time.Minute {
+ t.Error("duration flag should be 2m, is ", *durationFlag)
+ }
+ if v, err := f.GetDuration("duration"); err != nil || v != *durationFlag {
+ t.Error("GetDuration does not work.")
+ }
+ if _, err := f.GetInt("duration"); err == nil {
+ t.Error("GetInt parsed a time.Duration?!?!")
+ }
+ if *optionalIntNoValueFlag != 9 {
+ t.Error("optional int flag should be the default value, is ", *optionalIntNoValueFlag)
+ }
+ if *optionalIntWithValueFlag != 42 {
+ t.Error("optional int flag should be 42, is ", *optionalIntWithValueFlag)
+ }
+ 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 TestShorthand(t *testing.T) {
+ f := NewFlagSet("shorthand", ContinueOnError)
+ if f.Parsed() {
+ t.Error("f.Parse() = true before Parse")
+ }
+ boolaFlag := f.BoolP("boola", "a", false, "bool value")
+ boolbFlag := f.BoolP("boolb", "b", false, "bool2 value")
+ boolcFlag := f.BoolP("boolc", "c", false, "bool3 value")
+ booldFlag := f.BoolP("boold", "d", false, "bool4 value")
+ stringaFlag := f.StringP("stringa", "s", "0", "string value")
+ stringzFlag := f.StringP("stringz", "z", "0", "string value")
+ extra := "interspersed-argument"
+ notaflag := "--i-look-like-a-flag"
+ args := []string{
+ "-ab",
+ extra,
+ "-cs",
+ "hello",
+ "-z=something",
+ "-d=true",
+ "--",
+ notaflag,
+ }
+ f.SetOutput(ioutil.Discard)
+ if err := f.Parse(args); err != nil {
+ t.Error("expected no error, got ", err)
+ }
+ if !f.Parsed() {
+ t.Error("f.Parse() = false after Parse")
+ }
+ if *boolaFlag != true {
+ t.Error("boola flag should be true, is ", *boolaFlag)
+ }
+ if *boolbFlag != true {
+ t.Error("boolb flag should be true, is ", *boolbFlag)
+ }
+ if *boolcFlag != true {
+ t.Error("boolc flag should be true, is ", *boolcFlag)
+ }
+ if *booldFlag != true {
+ t.Error("boold flag should be true, is ", *booldFlag)
+ }
+ if *stringaFlag != "hello" {
+ t.Error("stringa flag should be `hello`, is ", *stringaFlag)
+ }
+ if *stringzFlag != "something" {
+ t.Error("stringz flag should be `something`, is ", *stringzFlag)
+ }
+ if len(f.Args()) != 2 {
+ 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])
+ } else if f.Args()[1] != notaflag {
+ t.Errorf("expected argument %q got %q", notaflag, f.Args()[1])
+ }
+ if f.ArgsLenAtDash() != 1 {
+ t.Errorf("expected argsLenAtDash %d got %d", f.ArgsLenAtDash(), 1)
+ }
+}
+
+func TestParse(t *testing.T) {
+ ResetForTesting(func() { t.Error("bad parse") })
+ testParse(GetCommandLine(), t)
+}
+
+func TestFlagSetParse(t *testing.T) {
+ testParse(NewFlagSet("test", ContinueOnError), t)
+}
+
+func TestChangedHelper(t *testing.T) {
+ f := NewFlagSet("changedtest", ContinueOnError)
+ _ = f.Bool("changed", false, "changed bool")
+ _ = f.Bool("settrue", true, "true to true")
+ _ = f.Bool("setfalse", false, "false to false")
+ _ = f.Bool("unchanged", false, "unchanged bool")
+
+ args := []string{"--changed", "--settrue", "--setfalse=false"}
+ if err := f.Parse(args); err != nil {
+ t.Error("f.Parse() = false after Parse")
+ }
+ if !f.Changed("changed") {
+ t.Errorf("--changed wasn't changed!")
+ }
+ if !f.Changed("settrue") {
+ t.Errorf("--settrue wasn't changed!")
+ }
+ if !f.Changed("setfalse") {
+ t.Errorf("--setfalse wasn't changed!")
+ }
+ if f.Changed("unchanged") {
+ t.Errorf("--unchanged was changed!")
+ }
+ if f.Changed("invalid") {
+ t.Errorf("--invalid was changed!")
+ }
+ if f.ArgsLenAtDash() != -1 {
+ t.Errorf("Expected argsLenAtDash: %d but got %d", -1, f.ArgsLenAtDash())
+ }
+}
+
+func replaceSeparators(name string, from []string, to string) string {
+ result := name
+ for _, sep := range from {
+ result = strings.Replace(result, sep, to, -1)
+ }
+ // Type convert to indicate normalization has been done.
+ return result
+}
+
+func wordSepNormalizeFunc(f *FlagSet, name string) NormalizedName {
+ seps := []string{"-", "_"}
+ name = replaceSeparators(name, seps, ".")
+ normalizeFlagNameInvocations++
+
+ return NormalizedName(name)
+}
+
+func testWordSepNormalizedNames(args []string, t *testing.T) {
+ f := NewFlagSet("normalized", ContinueOnError)
+ if f.Parsed() {
+ t.Error("f.Parse() = true before Parse")
+ }
+ withDashFlag := f.Bool("with-dash-flag", false, "bool value")
+ // Set this after some flags have been added and before others.
+ f.SetNormalizeFunc(wordSepNormalizeFunc)
+ withUnderFlag := f.Bool("with_under_flag", false, "bool value")
+ withBothFlag := f.Bool("with-both_flag", false, "bool value")
+ if err := f.Parse(args); err != nil {
+ t.Fatal(err)
+ }
+ if !f.Parsed() {
+ t.Error("f.Parse() = false after Parse")
+ }
+ if *withDashFlag != true {
+ t.Error("withDashFlag flag should be true, is ", *withDashFlag)
+ }
+ if *withUnderFlag != true {
+ t.Error("withUnderFlag flag should be true, is ", *withUnderFlag)
+ }
+ if *withBothFlag != true {
+ t.Error("withBothFlag flag should be true, is ", *withBothFlag)
+ }
+}
+
+func TestWordSepNormalizedNames(t *testing.T) {
+ args := []string{
+ "--with-dash-flag",
+ "--with-under-flag",
+ "--with-both-flag",
+ }
+ testWordSepNormalizedNames(args, t)
+
+ args = []string{
+ "--with_dash_flag",
+ "--with_under_flag",
+ "--with_both_flag",
+ }
+ testWordSepNormalizedNames(args, t)
+
+ args = []string{
+ "--with-dash_flag",
+ "--with-under_flag",
+ "--with-both_flag",
+ }
+ testWordSepNormalizedNames(args, t)
+}
+
+func aliasAndWordSepFlagNames(f *FlagSet, name string) NormalizedName {
+ seps := []string{"-", "_"}
+
+ oldName := replaceSeparators("old-valid_flag", seps, ".")
+ newName := replaceSeparators("valid-flag", seps, ".")
+
+ name = replaceSeparators(name, seps, ".")
+ switch name {
+ case oldName:
+ name = newName
+ break
+ }
+
+ return NormalizedName(name)
+}
+
+func TestCustomNormalizedNames(t *testing.T) {
+ f := NewFlagSet("normalized", ContinueOnError)
+ if f.Parsed() {
+ t.Error("f.Parse() = true before Parse")
+ }
+
+ validFlag := f.Bool("valid-flag", false, "bool value")
+ f.SetNormalizeFunc(aliasAndWordSepFlagNames)
+ someOtherFlag := f.Bool("some-other-flag", false, "bool value")
+
+ args := []string{"--old_valid_flag", "--some-other_flag"}
+ if err := f.Parse(args); err != nil {
+ t.Fatal(err)
+ }
+
+ if *validFlag != true {
+ t.Errorf("validFlag is %v even though we set the alias --old_valid_falg", *validFlag)
+ }
+ if *someOtherFlag != true {
+ t.Error("someOtherFlag should be true, is ", *someOtherFlag)
+ }
+}
+
+// Every flag we add, the name (displayed also in usage) should normalized
+func TestNormalizationFuncShouldChangeFlagName(t *testing.T) {
+ // Test normalization after addition
+ f := NewFlagSet("normalized", ContinueOnError)
+
+ f.Bool("valid_flag", false, "bool value")
+ if f.Lookup("valid_flag").Name != "valid_flag" {
+ t.Error("The new flag should have the name 'valid_flag' instead of ", f.Lookup("valid_flag").Name)
+ }
+
+ f.SetNormalizeFunc(wordSepNormalizeFunc)
+ if f.Lookup("valid_flag").Name != "valid.flag" {
+ t.Error("The new flag should have the name 'valid.flag' instead of ", f.Lookup("valid_flag").Name)
+ }
+
+ // Test normalization before addition
+ f = NewFlagSet("normalized", ContinueOnError)
+ f.SetNormalizeFunc(wordSepNormalizeFunc)
+
+ f.Bool("valid_flag", false, "bool value")
+ if f.Lookup("valid_flag").Name != "valid.flag" {
+ t.Error("The new flag should have the name 'valid.flag' instead of ", f.Lookup("valid_flag").Name)
+ }
+}
+
+// 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 (f *flagVar) Type() string {
+ return "flagVar"
+}
+
+func TestUserDefined(t *testing.T) {
+ var flags FlagSet
+ flags.Init("test", ContinueOnError)
+ var v flagVar
+ flags.VarP(&v, "v", "v", "usage")
+ if err := flags.Parse([]string{"--v=1", "-v2", "-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 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"}
+ before := Bool("before", false, "")
+ if err := GetCommandLine().Parse(os.Args[1:]); err != nil {
+ t.Fatal(err)
+ }
+ cmd := Arg(0)
+ os.Args = []string{"subcmd", "--after", "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")
+ }
+}
+
+func TestNoInterspersed(t *testing.T) {
+ f := NewFlagSet("test", ContinueOnError)
+ f.SetInterspersed(false)
+ f.Bool("true", true, "always true")
+ f.Bool("false", false, "always false")
+ err := f.Parse([]string{"--true", "break", "--false"})
+ if err != nil {
+ t.Fatal("expected no error; got ", err)
+ }
+ args := f.Args()
+ if len(args) != 2 || args[0] != "break" || args[1] != "--false" {
+ t.Fatal("expected interspersed options/non-options to fail")
+ }
+}
+
+func TestTermination(t *testing.T) {
+ f := NewFlagSet("termination", ContinueOnError)
+ boolFlag := f.BoolP("bool", "l", false, "bool value")
+ if f.Parsed() {
+ t.Error("f.Parse() = true before Parse")
+ }
+ arg1 := "ls"
+ arg2 := "-l"
+ args := []string{
+ "--",
+ arg1,
+ arg2,
+ }
+ f.SetOutput(ioutil.Discard)
+ if err := f.Parse(args); err != nil {
+ t.Fatal("expected no error; got ", err)
+ }
+ if !f.Parsed() {
+ t.Error("f.Parse() = false after Parse")
+ }
+ if *boolFlag {
+ t.Error("expected boolFlag=false, got true")
+ }
+ if len(f.Args()) != 2 {
+ t.Errorf("expected 2 arguments, got %d: %v", len(f.Args()), f.Args())
+ }
+ if f.Args()[0] != arg1 {
+ t.Errorf("expected argument %q got %q", arg1, f.Args()[0])
+ }
+ if f.Args()[1] != arg2 {
+ t.Errorf("expected argument %q got %q", arg2, f.Args()[1])
+ }
+ if f.ArgsLenAtDash() != 0 {
+ t.Errorf("expected argsLenAtDash %d got %d", 0, f.ArgsLenAtDash())
+ }
+}
+
+func TestDeprecatedFlagInDocs(t *testing.T) {
+ f := NewFlagSet("bob", ContinueOnError)
+ f.Bool("badflag", true, "always true")
+ f.MarkDeprecated("badflag", "use --good-flag instead")
+
+ out := new(bytes.Buffer)
+ f.SetOutput(out)
+ f.PrintDefaults()
+
+ if strings.Contains(out.String(), "badflag") {
+ t.Errorf("found deprecated flag in usage!")
+ }
+}
+
+func TestDeprecatedFlagShorthandInDocs(t *testing.T) {
+ f := NewFlagSet("bob", ContinueOnError)
+ name := "noshorthandflag"
+ f.BoolP(name, "n", true, "always true")
+ f.MarkShorthandDeprecated("noshorthandflag", fmt.Sprintf("use --%s instead", name))
+
+ out := new(bytes.Buffer)
+ f.SetOutput(out)
+ f.PrintDefaults()
+
+ if strings.Contains(out.String(), "-n,") {
+ t.Errorf("found deprecated flag shorthand in usage!")
+ }
+}
+
+func parseReturnStderr(t *testing.T, f *FlagSet, args []string) (string, error) {
+ oldStderr := os.Stderr
+ r, w, _ := os.Pipe()
+ os.Stderr = w
+
+ err := f.Parse(args)
+
+ outC := make(chan string)
+ // copy the output in a separate goroutine so printing can't block indefinitely
+ go func() {
+ var buf bytes.Buffer
+ io.Copy(&buf, r)
+ outC <- buf.String()
+ }()
+
+ w.Close()
+ os.Stderr = oldStderr
+ out := <-outC
+
+ return out, err
+}
+
+func TestDeprecatedFlagUsage(t *testing.T) {
+ f := NewFlagSet("bob", ContinueOnError)
+ f.Bool("badflag", true, "always true")
+ usageMsg := "use --good-flag instead"
+ f.MarkDeprecated("badflag", usageMsg)
+
+ args := []string{"--badflag"}
+ out, err := parseReturnStderr(t, f, args)
+ if err != nil {
+ t.Fatal("expected no error; got ", err)
+ }
+
+ if !strings.Contains(out, usageMsg) {
+ t.Errorf("usageMsg not printed when using a deprecated flag!")
+ }
+}
+
+func TestDeprecatedFlagShorthandUsage(t *testing.T) {
+ f := NewFlagSet("bob", ContinueOnError)
+ name := "noshorthandflag"
+ f.BoolP(name, "n", true, "always true")
+ usageMsg := fmt.Sprintf("use --%s instead", name)
+ f.MarkShorthandDeprecated(name, usageMsg)
+
+ args := []string{"-n"}
+ out, err := parseReturnStderr(t, f, args)
+ if err != nil {
+ t.Fatal("expected no error; got ", err)
+ }
+
+ if !strings.Contains(out, usageMsg) {
+ t.Errorf("usageMsg not printed when using a deprecated flag!")
+ }
+}
+
+func TestDeprecatedFlagUsageNormalized(t *testing.T) {
+ f := NewFlagSet("bob", ContinueOnError)
+ f.Bool("bad-double_flag", true, "always true")
+ f.SetNormalizeFunc(wordSepNormalizeFunc)
+ usageMsg := "use --good-flag instead"
+ f.MarkDeprecated("bad_double-flag", usageMsg)
+
+ args := []string{"--bad_double_flag"}
+ out, err := parseReturnStderr(t, f, args)
+ if err != nil {
+ t.Fatal("expected no error; got ", err)
+ }
+
+ if !strings.Contains(out, usageMsg) {
+ t.Errorf("usageMsg not printed when using a deprecated flag!")
+ }
+}
+
+// Name normalization function should be called only once on flag addition
+func TestMultipleNormalizeFlagNameInvocations(t *testing.T) {
+ normalizeFlagNameInvocations = 0
+
+ f := NewFlagSet("normalized", ContinueOnError)
+ f.SetNormalizeFunc(wordSepNormalizeFunc)
+ f.Bool("with_under_flag", false, "bool value")
+
+ if normalizeFlagNameInvocations != 1 {
+ t.Fatal("Expected normalizeFlagNameInvocations to be 1; got ", normalizeFlagNameInvocations)
+ }
+}
+
+//
+func TestHiddenFlagInUsage(t *testing.T) {
+ f := NewFlagSet("bob", ContinueOnError)
+ f.Bool("secretFlag", true, "shhh")
+ f.MarkHidden("secretFlag")
+
+ out := new(bytes.Buffer)
+ f.SetOutput(out)
+ f.PrintDefaults()
+
+ if strings.Contains(out.String(), "secretFlag") {
+ t.Errorf("found hidden flag in usage!")
+ }
+}
+
+//
+func TestHiddenFlagUsage(t *testing.T) {
+ f := NewFlagSet("bob", ContinueOnError)
+ f.Bool("secretFlag", true, "shhh")
+ f.MarkHidden("secretFlag")
+
+ args := []string{"--secretFlag"}
+ out, err := parseReturnStderr(t, f, args)
+ if err != nil {
+ t.Fatal("expected no error; got ", err)
+ }
+
+ if strings.Contains(out, "shhh") {
+ t.Errorf("usage message printed when using a hidden flag!")
+ }
+}
+
+const defaultOutput = ` --A for bootstrapping, allow 'any' type
+ --Alongflagname disable bounds checking
+ -C, --CCC a boolean defaulting to true (default true)
+ --D path set relative path for local imports
+ --F number a non-zero number (default 2.7)
+ --G float a float that defaults to zero
+ --IP ip IP address with no default
+ --IPMask ipMask Netmask address with no default
+ --IPNet ipNet IP network with no default
+ --Ints intSlice int slice with zero default
+ --N int a non-zero int (default 27)
+ --ND1 string[="bar"] a string with NoOptDefVal (default "foo")
+ --ND2 num[=4321] a num with NoOptDefVal (default 1234)
+ --StringArray stringArray string array with zero default
+ --StringSlice stringSlice string slice with zero default
+ --Z int an int that defaults to zero
+ --custom custom custom Value implementation
+ --customP custom a VarP with default (default 10)
+ --maxT timeout set timeout for dial
+`
+
+// Custom value that satisfies the Value interface.
+type customValue int
+
+func (cv *customValue) String() string { return fmt.Sprintf("%v", *cv) }
+
+func (cv *customValue) Set(s string) error {
+ v, err := strconv.ParseInt(s, 0, 64)
+ *cv = customValue(v)
+ return err
+}
+
+func (cv *customValue) Type() string { return "custom" }
+
+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.BoolP("CCC", "C", true, "a boolean defaulting to true")
+ fs.String("D", "", "set relative `path` for local imports")
+ fs.Float64("F", 2.7, "a non-zero `number`")
+ fs.Float64("G", 0, "a float that defaults to zero")
+ fs.Int("N", 27, "a non-zero int")
+ fs.IntSlice("Ints", []int{}, "int slice with zero default")
+ fs.IP("IP", nil, "IP address with no default")
+ fs.IPMask("IPMask", nil, "Netmask address with no default")
+ fs.IPNet("IPNet", net.IPNet{}, "IP network with no default")
+ fs.Int("Z", 0, "an int that defaults to zero")
+ fs.Duration("maxT", 0, "set `timeout` for dial")
+ fs.String("ND1", "foo", "a string with NoOptDefVal")
+ fs.Lookup("ND1").NoOptDefVal = "bar"
+ fs.Int("ND2", 1234, "a `num` with NoOptDefVal")
+ fs.Lookup("ND2").NoOptDefVal = "4321"
+ fs.StringSlice("StringSlice", []string{}, "string slice with zero default")
+ fs.StringArray("StringArray", []string{}, "string array with zero default")
+
+ var cv customValue
+ fs.Var(&cv, "custom", "custom Value implementation")
+
+ cv2 := customValue(10)
+ fs.VarP(&cv2, "customP", "", "a VarP with default")
+
+ fs.PrintDefaults()
+ got := buf.String()
+ if got != defaultOutput {
+ fmt.Println("\n" + got)
+ fmt.Println("\n" + defaultOutput)
+ t.Errorf("got %q want %q\n", got, defaultOutput)
+ }
+}
generated by cgit v1.2.3-1-g7c22 (git 2.25.1) at 2024-05-20 20:25:24 +0000