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 5package flag_test 6 7import ( 8 "bytes" 9 . "flag" 10 "fmt" 11 "os" 12 "sort" 13 "strings" 14 "testing" 15 "time" 16) 17 18func boolString(s string) string { 19 if s == "0" { 20 return "false" 21 } 22 return "true" 23} 24 25func TestEverything(t *testing.T) { 26 ResetForTesting(nil) 27 Bool("test_bool", false, "bool value") 28 Int("test_int", 0, "int value") 29 Int64("test_int64", 0, "int64 value") 30 Uint("test_uint", 0, "uint value") 31 Uint64("test_uint64", 0, "uint64 value") 32 String("test_string", "0", "string value") 33 Float64("test_float64", 0, "float64 value") 34 Duration("test_duration", 0, "time.Duration value") 35 36 m := make(map[string]*Flag) 37 desired := "0" 38 visitor := func(f *Flag) { 39 if len(f.Name) > 5 && f.Name[0:5] == "test_" { 40 m[f.Name] = f 41 ok := false 42 switch { 43 case f.Value.String() == desired: 44 ok = true 45 case f.Name == "test_bool" && f.Value.String() == boolString(desired): 46 ok = true 47 case f.Name == "test_duration" && f.Value.String() == desired+"s": 48 ok = true 49 } 50 if !ok { 51 t.Error("Visit: bad value", f.Value.String(), "for", f.Name) 52 } 53 } 54 } 55 VisitAll(visitor) 56 if len(m) != 8 { 57 t.Error("VisitAll misses some flags") 58 for k, v := range m { 59 t.Log(k, *v) 60 } 61 } 62 m = make(map[string]*Flag) 63 Visit(visitor) 64 if len(m) != 0 { 65 t.Errorf("Visit sees unset flags") 66 for k, v := range m { 67 t.Log(k, *v) 68 } 69 } 70 // Now set all flags 71 Set("test_bool", "true") 72 Set("test_int", "1") 73 Set("test_int64", "1") 74 Set("test_uint", "1") 75 Set("test_uint64", "1") 76 Set("test_string", "1") 77 Set("test_float64", "1") 78 Set("test_duration", "1s") 79 desired = "1" 80 Visit(visitor) 81 if len(m) != 8 { 82 t.Error("Visit fails after set") 83 for k, v := range m { 84 t.Log(k, *v) 85 } 86 } 87 // Now test they're visited in sort order. 88 var flagNames []string 89 Visit(func(f *Flag) { flagNames = append(flagNames, f.Name) }) 90 if !sort.StringsAreSorted(flagNames) { 91 t.Errorf("flag names not sorted: %v", flagNames) 92 } 93} 94 95func TestGet(t *testing.T) { 96 ResetForTesting(nil) 97 Bool("test_bool", true, "bool value") 98 Int("test_int", 1, "int value") 99 Int64("test_int64", 2, "int64 value") 100 Uint("test_uint", 3, "uint value") 101 Uint64("test_uint64", 4, "uint64 value") 102 String("test_string", "5", "string value") 103 Float64("test_float64", 6, "float64 value") 104 Duration("test_duration", 7, "time.Duration value") 105 106 visitor := func(f *Flag) { 107 if len(f.Name) > 5 && f.Name[0:5] == "test_" { 108 g, ok := f.Value.(Getter) 109 if !ok { 110 t.Errorf("Visit: value does not satisfy Getter: %T", f.Value) 111 return 112 } 113 switch f.Name { 114 case "test_bool": 115 ok = g.Get() == true 116 case "test_int": 117 ok = g.Get() == int(1) 118 case "test_int64": 119 ok = g.Get() == int64(2) 120 case "test_uint": 121 ok = g.Get() == uint(3) 122 case "test_uint64": 123 ok = g.Get() == uint64(4) 124 case "test_string": 125 ok = g.Get() == "5" 126 case "test_float64": 127 ok = g.Get() == float64(6) 128 case "test_duration": 129 ok = g.Get() == time.Duration(7) 130 } 131 if !ok { 132 t.Errorf("Visit: bad value %T(%v) for %s", g.Get(), g.Get(), f.Name) 133 } 134 } 135 } 136 VisitAll(visitor) 137} 138 139func TestUsage(t *testing.T) { 140 called := false 141 ResetForTesting(func() { called = true }) 142 if CommandLine.Parse([]string{"-x"}) == nil { 143 t.Error("parse did not fail for unknown flag") 144 } 145 if !called { 146 t.Error("did not call Usage for unknown flag") 147 } 148} 149 150func testParse(f *FlagSet, t *testing.T) { 151 if f.Parsed() { 152 t.Error("f.Parse() = true before Parse") 153 } 154 boolFlag := f.Bool("bool", false, "bool value") 155 bool2Flag := f.Bool("bool2", false, "bool2 value") 156 intFlag := f.Int("int", 0, "int value") 157 int64Flag := f.Int64("int64", 0, "int64 value") 158 uintFlag := f.Uint("uint", 0, "uint value") 159 uint64Flag := f.Uint64("uint64", 0, "uint64 value") 160 stringFlag := f.String("string", "0", "string value") 161 float64Flag := f.Float64("float64", 0, "float64 value") 162 durationFlag := f.Duration("duration", 5*time.Second, "time.Duration value") 163 extra := "one-extra-argument" 164 args := []string{ 165 "-bool", 166 "-bool2=true", 167 "--int", "22", 168 "--int64", "0x23", 169 "-uint", "24", 170 "--uint64", "25", 171 "-string", "hello", 172 "-float64", "2718e28", 173 "-duration", "2m", 174 extra, 175 } 176 if err := f.Parse(args); err != nil { 177 t.Fatal(err) 178 } 179 if !f.Parsed() { 180 t.Error("f.Parse() = false after Parse") 181 } 182 if *boolFlag != true { 183 t.Error("bool flag should be true, is ", *boolFlag) 184 } 185 if *bool2Flag != true { 186 t.Error("bool2 flag should be true, is ", *bool2Flag) 187 } 188 if *intFlag != 22 { 189 t.Error("int flag should be 22, is ", *intFlag) 190 } 191 if *int64Flag != 0x23 { 192 t.Error("int64 flag should be 0x23, is ", *int64Flag) 193 } 194 if *uintFlag != 24 { 195 t.Error("uint flag should be 24, is ", *uintFlag) 196 } 197 if *uint64Flag != 25 { 198 t.Error("uint64 flag should be 25, is ", *uint64Flag) 199 } 200 if *stringFlag != "hello" { 201 t.Error("string flag should be `hello`, is ", *stringFlag) 202 } 203 if *float64Flag != 2718e28 { 204 t.Error("float64 flag should be 2718e28, is ", *float64Flag) 205 } 206 if *durationFlag != 2*time.Minute { 207 t.Error("duration flag should be 2m, is ", *durationFlag) 208 } 209 if len(f.Args()) != 1 { 210 t.Error("expected one argument, got", len(f.Args())) 211 } else if f.Args()[0] != extra { 212 t.Errorf("expected argument %q got %q", extra, f.Args()[0]) 213 } 214} 215 216func TestParse(t *testing.T) { 217 ResetForTesting(func() { t.Error("bad parse") }) 218 testParse(CommandLine, t) 219} 220 221func TestFlagSetParse(t *testing.T) { 222 testParse(NewFlagSet("test", ContinueOnError), t) 223} 224 225// Declare a user-defined flag type. 226type flagVar []string 227 228func (f *flagVar) String() string { 229 return fmt.Sprint([]string(*f)) 230} 231 232func (f *flagVar) Set(value string) error { 233 *f = append(*f, value) 234 return nil 235} 236 237func TestUserDefined(t *testing.T) { 238 var flags FlagSet 239 flags.Init("test", ContinueOnError) 240 var v flagVar 241 flags.Var(&v, "v", "usage") 242 if err := flags.Parse([]string{"-v", "1", "-v", "2", "-v=3"}); err != nil { 243 t.Error(err) 244 } 245 if len(v) != 3 { 246 t.Fatal("expected 3 args; got ", len(v)) 247 } 248 expect := "[1 2 3]" 249 if v.String() != expect { 250 t.Errorf("expected value %q got %q", expect, v.String()) 251 } 252} 253 254// Declare a user-defined boolean flag type. 255type boolFlagVar struct { 256 count int 257} 258 259func (b *boolFlagVar) String() string { 260 return fmt.Sprintf("%d", b.count) 261} 262 263func (b *boolFlagVar) Set(value string) error { 264 if value == "true" { 265 b.count++ 266 } 267 return nil 268} 269 270func (b *boolFlagVar) IsBoolFlag() bool { 271 return b.count < 4 272} 273 274func TestUserDefinedBool(t *testing.T) { 275 var flags FlagSet 276 flags.Init("test", ContinueOnError) 277 var b boolFlagVar 278 var err error 279 flags.Var(&b, "b", "usage") 280 if err = flags.Parse([]string{"-b", "-b", "-b", "-b=true", "-b=false", "-b", "barg", "-b"}); err != nil { 281 if b.count < 4 { 282 t.Error(err) 283 } 284 } 285 286 if b.count != 4 { 287 t.Errorf("want: %d; got: %d", 4, b.count) 288 } 289 290 if err == nil { 291 t.Error("expected error; got none") 292 } 293} 294 295func TestSetOutput(t *testing.T) { 296 var flags FlagSet 297 var buf bytes.Buffer 298 flags.SetOutput(&buf) 299 flags.Init("test", ContinueOnError) 300 flags.Parse([]string{"-unknown"}) 301 if out := buf.String(); !strings.Contains(out, "-unknown") { 302 t.Logf("expected output mentioning unknown; got %q", out) 303 } 304} 305 306// This tests that one can reset the flags. This still works but not well, and is 307// superseded by FlagSet. 308func TestChangingArgs(t *testing.T) { 309 ResetForTesting(func() { t.Fatal("bad parse") }) 310 oldArgs := os.Args 311 defer func() { os.Args = oldArgs }() 312 os.Args = []string{"cmd", "-before", "subcmd", "-after", "args"} 313 before := Bool("before", false, "") 314 if err := CommandLine.Parse(os.Args[1:]); err != nil { 315 t.Fatal(err) 316 } 317 cmd := Arg(0) 318 os.Args = Args() 319 after := Bool("after", false, "") 320 Parse() 321 args := Args() 322 323 if !*before || cmd != "subcmd" || !*after || len(args) != 1 || args[0] != "args" { 324 t.Fatalf("expected true subcmd true [args] got %v %v %v %v", *before, cmd, *after, args) 325 } 326} 327 328// Test that -help invokes the usage message and returns ErrHelp. 329func TestHelp(t *testing.T) { 330 var helpCalled = false 331 fs := NewFlagSet("help test", ContinueOnError) 332 fs.Usage = func() { helpCalled = true } 333 var flag bool 334 fs.BoolVar(&flag, "flag", false, "regular flag") 335 // Regular flag invocation should work 336 err := fs.Parse([]string{"-flag=true"}) 337 if err != nil { 338 t.Fatal("expected no error; got ", err) 339 } 340 if !flag { 341 t.Error("flag was not set by -flag") 342 } 343 if helpCalled { 344 t.Error("help called for regular flag") 345 helpCalled = false // reset for next test 346 } 347 // Help flag should work as expected. 348 err = fs.Parse([]string{"-help"}) 349 if err == nil { 350 t.Fatal("error expected") 351 } 352 if err != ErrHelp { 353 t.Fatal("expected ErrHelp; got ", err) 354 } 355 if !helpCalled { 356 t.Fatal("help was not called") 357 } 358 // If we define a help flag, that should override. 359 var help bool 360 fs.BoolVar(&help, "help", false, "help flag") 361 helpCalled = false 362 err = fs.Parse([]string{"-help"}) 363 if err != nil { 364 t.Fatal("expected no error for defined -help; got ", err) 365 } 366 if helpCalled { 367 t.Fatal("help was called; should not have been for defined help flag") 368 } 369} 370