547 lines
14 KiB
Go
547 lines
14 KiB
Go
// 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"
|
|
"io/ioutil"
|
|
"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)
|
|
}
|
|
}
|
|
|
|
func TestParseError(t *testing.T) {
|
|
for _, typ := range []string{"bool", "int", "int64", "uint", "uint64", "float64", "duration"} {
|
|
fs := NewFlagSet("parse error test", ContinueOnError)
|
|
fs.SetOutput(ioutil.Discard)
|
|
_ = fs.Bool("bool", false, "")
|
|
_ = fs.Int("int", 0, "")
|
|
_ = fs.Int64("int64", 0, "")
|
|
_ = fs.Uint("uint", 0, "")
|
|
_ = fs.Uint64("uint64", 0, "")
|
|
_ = fs.Float64("float64", 0, "")
|
|
_ = fs.Duration("duration", 0, "")
|
|
// Strings cannot give errors.
|
|
args := []string{"-" + typ + "=x"}
|
|
err := fs.Parse(args) // x is not a valid setting for any flag.
|
|
if err == nil {
|
|
t.Errorf("Parse(%q)=%v; expected parse error", args, err)
|
|
continue
|
|
}
|
|
if !strings.Contains(err.Error(), "invalid") || !strings.Contains(err.Error(), "parse error") {
|
|
t.Errorf("Parse(%q)=%v; expected parse error", args, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRangeError(t *testing.T) {
|
|
bad := []string{
|
|
"-int=123456789012345678901",
|
|
"-int64=123456789012345678901",
|
|
"-uint=123456789012345678901",
|
|
"-uint64=123456789012345678901",
|
|
"-float64=1e1000",
|
|
}
|
|
for _, arg := range bad {
|
|
fs := NewFlagSet("parse error test", ContinueOnError)
|
|
fs.SetOutput(ioutil.Discard)
|
|
_ = fs.Int("int", 0, "")
|
|
_ = fs.Int64("int64", 0, "")
|
|
_ = fs.Uint("uint", 0, "")
|
|
_ = fs.Uint64("uint64", 0, "")
|
|
_ = fs.Float64("float64", 0, "")
|
|
// Strings cannot give errors, and bools and durations do not return strconv.NumError.
|
|
err := fs.Parse([]string{arg})
|
|
if err == nil {
|
|
t.Errorf("Parse(%q)=%v; expected range error", arg, err)
|
|
continue
|
|
}
|
|
if !strings.Contains(err.Error(), "invalid") || !strings.Contains(err.Error(), "value out of range") {
|
|
t.Errorf("Parse(%q)=%v; expected range error", arg, err)
|
|
}
|
|
}
|
|
}
|