github.com/mtsmfm/go/src@v0.0.0-20221020090648-44bdcb9f8fde/flag/flag_test.go (about)

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package flag_test
     6  
     7  import (
     8  	"bytes"
     9  	. "flag"
    10  	"fmt"
    11  	"internal/testenv"
    12  	"io"
    13  	"os"
    14  	"os/exec"
    15  	"runtime"
    16  	"sort"
    17  	"strconv"
    18  	"strings"
    19  	"testing"
    20  	"time"
    21  )
    22  
    23  func boolString(s string) string {
    24  	if s == "0" {
    25  		return "false"
    26  	}
    27  	return "true"
    28  }
    29  
    30  func TestEverything(t *testing.T) {
    31  	ResetForTesting(nil)
    32  	Bool("test_bool", false, "bool value")
    33  	Int("test_int", 0, "int value")
    34  	Int64("test_int64", 0, "int64 value")
    35  	Uint("test_uint", 0, "uint value")
    36  	Uint64("test_uint64", 0, "uint64 value")
    37  	String("test_string", "0", "string value")
    38  	Float64("test_float64", 0, "float64 value")
    39  	Duration("test_duration", 0, "time.Duration value")
    40  	Func("test_func", "func value", func(string) error { return nil })
    41  
    42  	m := make(map[string]*Flag)
    43  	desired := "0"
    44  	visitor := func(f *Flag) {
    45  		if len(f.Name) > 5 && f.Name[0:5] == "test_" {
    46  			m[f.Name] = f
    47  			ok := false
    48  			switch {
    49  			case f.Value.String() == desired:
    50  				ok = true
    51  			case f.Name == "test_bool" && f.Value.String() == boolString(desired):
    52  				ok = true
    53  			case f.Name == "test_duration" && f.Value.String() == desired+"s":
    54  				ok = true
    55  			case f.Name == "test_func" && f.Value.String() == "":
    56  				ok = true
    57  			}
    58  			if !ok {
    59  				t.Error("Visit: bad value", f.Value.String(), "for", f.Name)
    60  			}
    61  		}
    62  	}
    63  	VisitAll(visitor)
    64  	if len(m) != 9 {
    65  		t.Error("VisitAll misses some flags")
    66  		for k, v := range m {
    67  			t.Log(k, *v)
    68  		}
    69  	}
    70  	m = make(map[string]*Flag)
    71  	Visit(visitor)
    72  	if len(m) != 0 {
    73  		t.Errorf("Visit sees unset flags")
    74  		for k, v := range m {
    75  			t.Log(k, *v)
    76  		}
    77  	}
    78  	// Now set all flags
    79  	Set("test_bool", "true")
    80  	Set("test_int", "1")
    81  	Set("test_int64", "1")
    82  	Set("test_uint", "1")
    83  	Set("test_uint64", "1")
    84  	Set("test_string", "1")
    85  	Set("test_float64", "1")
    86  	Set("test_duration", "1s")
    87  	Set("test_func", "1")
    88  	desired = "1"
    89  	Visit(visitor)
    90  	if len(m) != 9 {
    91  		t.Error("Visit fails after set")
    92  		for k, v := range m {
    93  			t.Log(k, *v)
    94  		}
    95  	}
    96  	// Now test they're visited in sort order.
    97  	var flagNames []string
    98  	Visit(func(f *Flag) { flagNames = append(flagNames, f.Name) })
    99  	if !sort.StringsAreSorted(flagNames) {
   100  		t.Errorf("flag names not sorted: %v", flagNames)
   101  	}
   102  }
   103  
   104  func TestGet(t *testing.T) {
   105  	ResetForTesting(nil)
   106  	Bool("test_bool", true, "bool value")
   107  	Int("test_int", 1, "int value")
   108  	Int64("test_int64", 2, "int64 value")
   109  	Uint("test_uint", 3, "uint value")
   110  	Uint64("test_uint64", 4, "uint64 value")
   111  	String("test_string", "5", "string value")
   112  	Float64("test_float64", 6, "float64 value")
   113  	Duration("test_duration", 7, "time.Duration value")
   114  
   115  	visitor := func(f *Flag) {
   116  		if len(f.Name) > 5 && f.Name[0:5] == "test_" {
   117  			g, ok := f.Value.(Getter)
   118  			if !ok {
   119  				t.Errorf("Visit: value does not satisfy Getter: %T", f.Value)
   120  				return
   121  			}
   122  			switch f.Name {
   123  			case "test_bool":
   124  				ok = g.Get() == true
   125  			case "test_int":
   126  				ok = g.Get() == int(1)
   127  			case "test_int64":
   128  				ok = g.Get() == int64(2)
   129  			case "test_uint":
   130  				ok = g.Get() == uint(3)
   131  			case "test_uint64":
   132  				ok = g.Get() == uint64(4)
   133  			case "test_string":
   134  				ok = g.Get() == "5"
   135  			case "test_float64":
   136  				ok = g.Get() == float64(6)
   137  			case "test_duration":
   138  				ok = g.Get() == time.Duration(7)
   139  			}
   140  			if !ok {
   141  				t.Errorf("Visit: bad value %T(%v) for %s", g.Get(), g.Get(), f.Name)
   142  			}
   143  		}
   144  	}
   145  	VisitAll(visitor)
   146  }
   147  
   148  func TestUsage(t *testing.T) {
   149  	called := false
   150  	ResetForTesting(func() { called = true })
   151  	if CommandLine.Parse([]string{"-x"}) == nil {
   152  		t.Error("parse did not fail for unknown flag")
   153  	}
   154  	if !called {
   155  		t.Error("did not call Usage for unknown flag")
   156  	}
   157  }
   158  
   159  func testParse(f *FlagSet, t *testing.T) {
   160  	if f.Parsed() {
   161  		t.Error("f.Parse() = true before Parse")
   162  	}
   163  	boolFlag := f.Bool("bool", false, "bool value")
   164  	bool2Flag := f.Bool("bool2", false, "bool2 value")
   165  	intFlag := f.Int("int", 0, "int value")
   166  	int64Flag := f.Int64("int64", 0, "int64 value")
   167  	uintFlag := f.Uint("uint", 0, "uint value")
   168  	uint64Flag := f.Uint64("uint64", 0, "uint64 value")
   169  	stringFlag := f.String("string", "0", "string value")
   170  	float64Flag := f.Float64("float64", 0, "float64 value")
   171  	durationFlag := f.Duration("duration", 5*time.Second, "time.Duration value")
   172  	extra := "one-extra-argument"
   173  	args := []string{
   174  		"-bool",
   175  		"-bool2=true",
   176  		"--int", "22",
   177  		"--int64", "0x23",
   178  		"-uint", "24",
   179  		"--uint64", "25",
   180  		"-string", "hello",
   181  		"-float64", "2718e28",
   182  		"-duration", "2m",
   183  		extra,
   184  	}
   185  	if err := f.Parse(args); err != nil {
   186  		t.Fatal(err)
   187  	}
   188  	if !f.Parsed() {
   189  		t.Error("f.Parse() = false after Parse")
   190  	}
   191  	if *boolFlag != true {
   192  		t.Error("bool flag should be true, is ", *boolFlag)
   193  	}
   194  	if *bool2Flag != true {
   195  		t.Error("bool2 flag should be true, is ", *bool2Flag)
   196  	}
   197  	if *intFlag != 22 {
   198  		t.Error("int flag should be 22, is ", *intFlag)
   199  	}
   200  	if *int64Flag != 0x23 {
   201  		t.Error("int64 flag should be 0x23, is ", *int64Flag)
   202  	}
   203  	if *uintFlag != 24 {
   204  		t.Error("uint flag should be 24, is ", *uintFlag)
   205  	}
   206  	if *uint64Flag != 25 {
   207  		t.Error("uint64 flag should be 25, is ", *uint64Flag)
   208  	}
   209  	if *stringFlag != "hello" {
   210  		t.Error("string flag should be `hello`, is ", *stringFlag)
   211  	}
   212  	if *float64Flag != 2718e28 {
   213  		t.Error("float64 flag should be 2718e28, is ", *float64Flag)
   214  	}
   215  	if *durationFlag != 2*time.Minute {
   216  		t.Error("duration flag should be 2m, is ", *durationFlag)
   217  	}
   218  	if len(f.Args()) != 1 {
   219  		t.Error("expected one argument, got", len(f.Args()))
   220  	} else if f.Args()[0] != extra {
   221  		t.Errorf("expected argument %q got %q", extra, f.Args()[0])
   222  	}
   223  }
   224  
   225  func TestParse(t *testing.T) {
   226  	ResetForTesting(func() { t.Error("bad parse") })
   227  	testParse(CommandLine, t)
   228  }
   229  
   230  func TestFlagSetParse(t *testing.T) {
   231  	testParse(NewFlagSet("test", ContinueOnError), t)
   232  }
   233  
   234  // Declare a user-defined flag type.
   235  type flagVar []string
   236  
   237  func (f *flagVar) String() string {
   238  	return fmt.Sprint([]string(*f))
   239  }
   240  
   241  func (f *flagVar) Set(value string) error {
   242  	*f = append(*f, value)
   243  	return nil
   244  }
   245  
   246  func TestUserDefined(t *testing.T) {
   247  	var flags FlagSet
   248  	flags.Init("test", ContinueOnError)
   249  	flags.SetOutput(io.Discard)
   250  	var v flagVar
   251  	flags.Var(&v, "v", "usage")
   252  	if err := flags.Parse([]string{"-v", "1", "-v", "2", "-v=3"}); err != nil {
   253  		t.Error(err)
   254  	}
   255  	if len(v) != 3 {
   256  		t.Fatal("expected 3 args; got ", len(v))
   257  	}
   258  	expect := "[1 2 3]"
   259  	if v.String() != expect {
   260  		t.Errorf("expected value %q got %q", expect, v.String())
   261  	}
   262  }
   263  
   264  func TestUserDefinedFunc(t *testing.T) {
   265  	flags := NewFlagSet("test", ContinueOnError)
   266  	flags.SetOutput(io.Discard)
   267  	var ss []string
   268  	flags.Func("v", "usage", func(s string) error {
   269  		ss = append(ss, s)
   270  		return nil
   271  	})
   272  	if err := flags.Parse([]string{"-v", "1", "-v", "2", "-v=3"}); err != nil {
   273  		t.Error(err)
   274  	}
   275  	if len(ss) != 3 {
   276  		t.Fatal("expected 3 args; got ", len(ss))
   277  	}
   278  	expect := "[1 2 3]"
   279  	if got := fmt.Sprint(ss); got != expect {
   280  		t.Errorf("expected value %q got %q", expect, got)
   281  	}
   282  	// test usage
   283  	var buf strings.Builder
   284  	flags.SetOutput(&buf)
   285  	flags.Parse([]string{"-h"})
   286  	if usage := buf.String(); !strings.Contains(usage, "usage") {
   287  		t.Errorf("usage string not included: %q", usage)
   288  	}
   289  	// test Func error
   290  	flags = NewFlagSet("test", ContinueOnError)
   291  	flags.SetOutput(io.Discard)
   292  	flags.Func("v", "usage", func(s string) error {
   293  		return fmt.Errorf("test error")
   294  	})
   295  	// flag not set, so no error
   296  	if err := flags.Parse(nil); err != nil {
   297  		t.Error(err)
   298  	}
   299  	// flag set, expect error
   300  	if err := flags.Parse([]string{"-v", "1"}); err == nil {
   301  		t.Error("expected error; got none")
   302  	} else if errMsg := err.Error(); !strings.Contains(errMsg, "test error") {
   303  		t.Errorf(`error should contain "test error"; got %q`, errMsg)
   304  	}
   305  }
   306  
   307  func TestUserDefinedForCommandLine(t *testing.T) {
   308  	const help = "HELP"
   309  	var result string
   310  	ResetForTesting(func() { result = help })
   311  	Usage()
   312  	if result != help {
   313  		t.Fatalf("got %q; expected %q", result, help)
   314  	}
   315  }
   316  
   317  // Declare a user-defined boolean flag type.
   318  type boolFlagVar struct {
   319  	count int
   320  }
   321  
   322  func (b *boolFlagVar) String() string {
   323  	return fmt.Sprintf("%d", b.count)
   324  }
   325  
   326  func (b *boolFlagVar) Set(value string) error {
   327  	if value == "true" {
   328  		b.count++
   329  	}
   330  	return nil
   331  }
   332  
   333  func (b *boolFlagVar) IsBoolFlag() bool {
   334  	return b.count < 4
   335  }
   336  
   337  func TestUserDefinedBool(t *testing.T) {
   338  	var flags FlagSet
   339  	flags.Init("test", ContinueOnError)
   340  	flags.SetOutput(io.Discard)
   341  	var b boolFlagVar
   342  	var err error
   343  	flags.Var(&b, "b", "usage")
   344  	if err = flags.Parse([]string{"-b", "-b", "-b", "-b=true", "-b=false", "-b", "barg", "-b"}); err != nil {
   345  		if b.count < 4 {
   346  			t.Error(err)
   347  		}
   348  	}
   349  
   350  	if b.count != 4 {
   351  		t.Errorf("want: %d; got: %d", 4, b.count)
   352  	}
   353  
   354  	if err == nil {
   355  		t.Error("expected error; got none")
   356  	}
   357  }
   358  
   359  func TestUserDefinedBoolUsage(t *testing.T) {
   360  	var flags FlagSet
   361  	flags.Init("test", ContinueOnError)
   362  	var buf bytes.Buffer
   363  	flags.SetOutput(&buf)
   364  	var b boolFlagVar
   365  	flags.Var(&b, "b", "X")
   366  	b.count = 0
   367  	// b.IsBoolFlag() will return true and usage will look boolean.
   368  	flags.PrintDefaults()
   369  	got := buf.String()
   370  	want := "  -b\tX\n"
   371  	if got != want {
   372  		t.Errorf("false: want %q; got %q", want, got)
   373  	}
   374  	b.count = 4
   375  	// b.IsBoolFlag() will return false and usage will look non-boolean.
   376  	flags.PrintDefaults()
   377  	got = buf.String()
   378  	want = "  -b\tX\n  -b value\n    \tX\n"
   379  	if got != want {
   380  		t.Errorf("false: want %q; got %q", want, got)
   381  	}
   382  }
   383  
   384  func TestSetOutput(t *testing.T) {
   385  	var flags FlagSet
   386  	var buf strings.Builder
   387  	flags.SetOutput(&buf)
   388  	flags.Init("test", ContinueOnError)
   389  	flags.Parse([]string{"-unknown"})
   390  	if out := buf.String(); !strings.Contains(out, "-unknown") {
   391  		t.Logf("expected output mentioning unknown; got %q", out)
   392  	}
   393  }
   394  
   395  // This tests that one can reset the flags. This still works but not well, and is
   396  // superseded by FlagSet.
   397  func TestChangingArgs(t *testing.T) {
   398  	ResetForTesting(func() { t.Fatal("bad parse") })
   399  	oldArgs := os.Args
   400  	defer func() { os.Args = oldArgs }()
   401  	os.Args = []string{"cmd", "-before", "subcmd", "-after", "args"}
   402  	before := Bool("before", false, "")
   403  	if err := CommandLine.Parse(os.Args[1:]); err != nil {
   404  		t.Fatal(err)
   405  	}
   406  	cmd := Arg(0)
   407  	os.Args = Args()
   408  	after := Bool("after", false, "")
   409  	Parse()
   410  	args := Args()
   411  
   412  	if !*before || cmd != "subcmd" || !*after || len(args) != 1 || args[0] != "args" {
   413  		t.Fatalf("expected true subcmd true [args] got %v %v %v %v", *before, cmd, *after, args)
   414  	}
   415  }
   416  
   417  // Test that -help invokes the usage message and returns ErrHelp.
   418  func TestHelp(t *testing.T) {
   419  	var helpCalled = false
   420  	fs := NewFlagSet("help test", ContinueOnError)
   421  	fs.Usage = func() { helpCalled = true }
   422  	var flag bool
   423  	fs.BoolVar(&flag, "flag", false, "regular flag")
   424  	// Regular flag invocation should work
   425  	err := fs.Parse([]string{"-flag=true"})
   426  	if err != nil {
   427  		t.Fatal("expected no error; got ", err)
   428  	}
   429  	if !flag {
   430  		t.Error("flag was not set by -flag")
   431  	}
   432  	if helpCalled {
   433  		t.Error("help called for regular flag")
   434  		helpCalled = false // reset for next test
   435  	}
   436  	// Help flag should work as expected.
   437  	err = fs.Parse([]string{"-help"})
   438  	if err == nil {
   439  		t.Fatal("error expected")
   440  	}
   441  	if err != ErrHelp {
   442  		t.Fatal("expected ErrHelp; got ", err)
   443  	}
   444  	if !helpCalled {
   445  		t.Fatal("help was not called")
   446  	}
   447  	// If we define a help flag, that should override.
   448  	var help bool
   449  	fs.BoolVar(&help, "help", false, "help flag")
   450  	helpCalled = false
   451  	err = fs.Parse([]string{"-help"})
   452  	if err != nil {
   453  		t.Fatal("expected no error for defined -help; got ", err)
   454  	}
   455  	if helpCalled {
   456  		t.Fatal("help was called; should not have been for defined help flag")
   457  	}
   458  }
   459  
   460  // zeroPanicker is a flag.Value whose String method panics if its dontPanic
   461  // field is false.
   462  type zeroPanicker struct {
   463  	dontPanic bool
   464  	v         string
   465  }
   466  
   467  func (f *zeroPanicker) Set(s string) error {
   468  	f.v = s
   469  	return nil
   470  }
   471  
   472  func (f *zeroPanicker) String() string {
   473  	if !f.dontPanic {
   474  		panic("panic!")
   475  	}
   476  	return f.v
   477  }
   478  
   479  const defaultOutput = `  -A	for bootstrapping, allow 'any' type
   480    -Alongflagname
   481      	disable bounds checking
   482    -C	a boolean defaulting to true (default true)
   483    -D path
   484      	set relative path for local imports
   485    -E string
   486      	issue 23543 (default "0")
   487    -F number
   488      	a non-zero number (default 2.7)
   489    -G float
   490      	a float that defaults to zero
   491    -M string
   492      	a multiline
   493      	help
   494      	string
   495    -N int
   496      	a non-zero int (default 27)
   497    -O	a flag
   498      	multiline help string (default true)
   499    -V list
   500      	a list of strings (default [a b])
   501    -Z int
   502      	an int that defaults to zero
   503    -ZP0 value
   504      	a flag whose String method panics when it is zero
   505    -ZP1 value
   506      	a flag whose String method panics when it is zero
   507    -maxT timeout
   508      	set timeout for dial
   509  
   510  panic calling String method on zero flag_test.zeroPanicker for flag ZP0: panic!
   511  panic calling String method on zero flag_test.zeroPanicker for flag ZP1: panic!
   512  `
   513  
   514  func TestPrintDefaults(t *testing.T) {
   515  	fs := NewFlagSet("print defaults test", ContinueOnError)
   516  	var buf strings.Builder
   517  	fs.SetOutput(&buf)
   518  	fs.Bool("A", false, "for bootstrapping, allow 'any' type")
   519  	fs.Bool("Alongflagname", false, "disable bounds checking")
   520  	fs.Bool("C", true, "a boolean defaulting to true")
   521  	fs.String("D", "", "set relative `path` for local imports")
   522  	fs.String("E", "0", "issue 23543")
   523  	fs.Float64("F", 2.7, "a non-zero `number`")
   524  	fs.Float64("G", 0, "a float that defaults to zero")
   525  	fs.String("M", "", "a multiline\nhelp\nstring")
   526  	fs.Int("N", 27, "a non-zero int")
   527  	fs.Bool("O", true, "a flag\nmultiline help string")
   528  	fs.Var(&flagVar{"a", "b"}, "V", "a `list` of strings")
   529  	fs.Int("Z", 0, "an int that defaults to zero")
   530  	fs.Var(&zeroPanicker{true, ""}, "ZP0", "a flag whose String method panics when it is zero")
   531  	fs.Var(&zeroPanicker{true, "something"}, "ZP1", "a flag whose String method panics when it is zero")
   532  	fs.Duration("maxT", 0, "set `timeout` for dial")
   533  	fs.PrintDefaults()
   534  	got := buf.String()
   535  	if got != defaultOutput {
   536  		t.Errorf("got:\n%q\nwant:\n%q", got, defaultOutput)
   537  	}
   538  }
   539  
   540  // Issue 19230: validate range of Int and Uint flag values.
   541  func TestIntFlagOverflow(t *testing.T) {
   542  	if strconv.IntSize != 32 {
   543  		return
   544  	}
   545  	ResetForTesting(nil)
   546  	Int("i", 0, "")
   547  	Uint("u", 0, "")
   548  	if err := Set("i", "2147483648"); err == nil {
   549  		t.Error("unexpected success setting Int")
   550  	}
   551  	if err := Set("u", "4294967296"); err == nil {
   552  		t.Error("unexpected success setting Uint")
   553  	}
   554  }
   555  
   556  // Issue 20998: Usage should respect CommandLine.output.
   557  func TestUsageOutput(t *testing.T) {
   558  	ResetForTesting(DefaultUsage)
   559  	var buf strings.Builder
   560  	CommandLine.SetOutput(&buf)
   561  	defer func(old []string) { os.Args = old }(os.Args)
   562  	os.Args = []string{"app", "-i=1", "-unknown"}
   563  	Parse()
   564  	const want = "flag provided but not defined: -i\nUsage of app:\n"
   565  	if got := buf.String(); got != want {
   566  		t.Errorf("output = %q; want %q", got, want)
   567  	}
   568  }
   569  
   570  func TestGetters(t *testing.T) {
   571  	expectedName := "flag set"
   572  	expectedErrorHandling := ContinueOnError
   573  	expectedOutput := io.Writer(os.Stderr)
   574  	fs := NewFlagSet(expectedName, expectedErrorHandling)
   575  
   576  	if fs.Name() != expectedName {
   577  		t.Errorf("unexpected name: got %s, expected %s", fs.Name(), expectedName)
   578  	}
   579  	if fs.ErrorHandling() != expectedErrorHandling {
   580  		t.Errorf("unexpected ErrorHandling: got %d, expected %d", fs.ErrorHandling(), expectedErrorHandling)
   581  	}
   582  	if fs.Output() != expectedOutput {
   583  		t.Errorf("unexpected output: got %#v, expected %#v", fs.Output(), expectedOutput)
   584  	}
   585  
   586  	expectedName = "gopher"
   587  	expectedErrorHandling = ExitOnError
   588  	expectedOutput = os.Stdout
   589  	fs.Init(expectedName, expectedErrorHandling)
   590  	fs.SetOutput(expectedOutput)
   591  
   592  	if fs.Name() != expectedName {
   593  		t.Errorf("unexpected name: got %s, expected %s", fs.Name(), expectedName)
   594  	}
   595  	if fs.ErrorHandling() != expectedErrorHandling {
   596  		t.Errorf("unexpected ErrorHandling: got %d, expected %d", fs.ErrorHandling(), expectedErrorHandling)
   597  	}
   598  	if fs.Output() != expectedOutput {
   599  		t.Errorf("unexpected output: got %v, expected %v", fs.Output(), expectedOutput)
   600  	}
   601  }
   602  
   603  func TestParseError(t *testing.T) {
   604  	for _, typ := range []string{"bool", "int", "int64", "uint", "uint64", "float64", "duration"} {
   605  		fs := NewFlagSet("parse error test", ContinueOnError)
   606  		fs.SetOutput(io.Discard)
   607  		_ = fs.Bool("bool", false, "")
   608  		_ = fs.Int("int", 0, "")
   609  		_ = fs.Int64("int64", 0, "")
   610  		_ = fs.Uint("uint", 0, "")
   611  		_ = fs.Uint64("uint64", 0, "")
   612  		_ = fs.Float64("float64", 0, "")
   613  		_ = fs.Duration("duration", 0, "")
   614  		// Strings cannot give errors.
   615  		args := []string{"-" + typ + "=x"}
   616  		err := fs.Parse(args) // x is not a valid setting for any flag.
   617  		if err == nil {
   618  			t.Errorf("Parse(%q)=%v; expected parse error", args, err)
   619  			continue
   620  		}
   621  		if !strings.Contains(err.Error(), "invalid") || !strings.Contains(err.Error(), "parse error") {
   622  			t.Errorf("Parse(%q)=%v; expected parse error", args, err)
   623  		}
   624  	}
   625  }
   626  
   627  func TestRangeError(t *testing.T) {
   628  	bad := []string{
   629  		"-int=123456789012345678901",
   630  		"-int64=123456789012345678901",
   631  		"-uint=123456789012345678901",
   632  		"-uint64=123456789012345678901",
   633  		"-float64=1e1000",
   634  	}
   635  	for _, arg := range bad {
   636  		fs := NewFlagSet("parse error test", ContinueOnError)
   637  		fs.SetOutput(io.Discard)
   638  		_ = fs.Int("int", 0, "")
   639  		_ = fs.Int64("int64", 0, "")
   640  		_ = fs.Uint("uint", 0, "")
   641  		_ = fs.Uint64("uint64", 0, "")
   642  		_ = fs.Float64("float64", 0, "")
   643  		// Strings cannot give errors, and bools and durations do not return strconv.NumError.
   644  		err := fs.Parse([]string{arg})
   645  		if err == nil {
   646  			t.Errorf("Parse(%q)=%v; expected range error", arg, err)
   647  			continue
   648  		}
   649  		if !strings.Contains(err.Error(), "invalid") || !strings.Contains(err.Error(), "value out of range") {
   650  			t.Errorf("Parse(%q)=%v; expected range error", arg, err)
   651  		}
   652  	}
   653  }
   654  
   655  func TestExitCode(t *testing.T) {
   656  	testenv.MustHaveExec(t)
   657  
   658  	magic := 123
   659  	if os.Getenv("GO_CHILD_FLAG") != "" {
   660  		fs := NewFlagSet("test", ExitOnError)
   661  		if os.Getenv("GO_CHILD_FLAG_HANDLE") != "" {
   662  			var b bool
   663  			fs.BoolVar(&b, os.Getenv("GO_CHILD_FLAG_HANDLE"), false, "")
   664  		}
   665  		fs.Parse([]string{os.Getenv("GO_CHILD_FLAG")})
   666  		os.Exit(magic)
   667  	}
   668  
   669  	tests := []struct {
   670  		flag       string
   671  		flagHandle string
   672  		expectExit int
   673  	}{
   674  		{
   675  			flag:       "-h",
   676  			expectExit: 0,
   677  		},
   678  		{
   679  			flag:       "-help",
   680  			expectExit: 0,
   681  		},
   682  		{
   683  			flag:       "-undefined",
   684  			expectExit: 2,
   685  		},
   686  		{
   687  			flag:       "-h",
   688  			flagHandle: "h",
   689  			expectExit: magic,
   690  		},
   691  		{
   692  			flag:       "-help",
   693  			flagHandle: "help",
   694  			expectExit: magic,
   695  		},
   696  	}
   697  
   698  	for _, test := range tests {
   699  		cmd := exec.Command(os.Args[0], "-test.run=TestExitCode")
   700  		cmd.Env = append(
   701  			os.Environ(),
   702  			"GO_CHILD_FLAG="+test.flag,
   703  			"GO_CHILD_FLAG_HANDLE="+test.flagHandle,
   704  		)
   705  		cmd.Run()
   706  		got := cmd.ProcessState.ExitCode()
   707  		// ExitCode is either 0 or 1 on Plan 9.
   708  		if runtime.GOOS == "plan9" && test.expectExit != 0 {
   709  			test.expectExit = 1
   710  		}
   711  		if got != test.expectExit {
   712  			t.Errorf("unexpected exit code for test case %+v \n: got %d, expect %d",
   713  				test, got, test.expectExit)
   714  		}
   715  	}
   716  }
   717  
   718  func mustPanic(t *testing.T, testName string, expected string, f func()) {
   719  	t.Helper()
   720  	defer func() {
   721  		switch msg := recover().(type) {
   722  		case nil:
   723  			t.Errorf("%s\n: expected panic(%q), but did not panic", testName, expected)
   724  		case string:
   725  			if msg != expected {
   726  				t.Errorf("%s\n: expected panic(%q), but got panic(%q)", testName, expected, msg)
   727  			}
   728  		default:
   729  			t.Errorf("%s\n: expected panic(%q), but got panic(%T%v)", testName, expected, msg, msg)
   730  		}
   731  	}()
   732  	f()
   733  }
   734  
   735  func TestInvalidFlags(t *testing.T) {
   736  	tests := []struct {
   737  		flag     string
   738  		errorMsg string
   739  	}{
   740  		{
   741  			flag:     "-foo",
   742  			errorMsg: "flag \"-foo\" begins with -",
   743  		},
   744  		{
   745  			flag:     "foo=bar",
   746  			errorMsg: "flag \"foo=bar\" contains =",
   747  		},
   748  	}
   749  
   750  	for _, test := range tests {
   751  		testName := fmt.Sprintf("FlagSet.Var(&v, %q, \"\")", test.flag)
   752  
   753  		fs := NewFlagSet("", ContinueOnError)
   754  		buf := &strings.Builder{}
   755  		fs.SetOutput(buf)
   756  
   757  		mustPanic(t, testName, test.errorMsg, func() {
   758  			var v flagVar
   759  			fs.Var(&v, test.flag, "")
   760  		})
   761  		if msg := test.errorMsg + "\n"; msg != buf.String() {
   762  			t.Errorf("%s\n: unexpected output: expected %q, bug got %q", testName, msg, buf)
   763  		}
   764  	}
   765  }
   766  
   767  func TestRedefinedFlags(t *testing.T) {
   768  	tests := []struct {
   769  		flagSetName string
   770  		errorMsg    string
   771  	}{
   772  		{
   773  			flagSetName: "",
   774  			errorMsg:    "flag redefined: foo",
   775  		},
   776  		{
   777  			flagSetName: "fs",
   778  			errorMsg:    "fs flag redefined: foo",
   779  		},
   780  	}
   781  
   782  	for _, test := range tests {
   783  		testName := fmt.Sprintf("flag redefined in FlagSet(%q)", test.flagSetName)
   784  
   785  		fs := NewFlagSet(test.flagSetName, ContinueOnError)
   786  		buf := &strings.Builder{}
   787  		fs.SetOutput(buf)
   788  
   789  		var v flagVar
   790  		fs.Var(&v, "foo", "")
   791  
   792  		mustPanic(t, testName, test.errorMsg, func() {
   793  			fs.Var(&v, "foo", "")
   794  		})
   795  		if msg := test.errorMsg + "\n"; msg != buf.String() {
   796  			t.Errorf("%s\n: unexpected output: expected %q, bug got %q", testName, msg, buf)
   797  		}
   798  	}
   799  }