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 "os" 12 "sort" 13 "strings" 14 "testing" 15 "time" 16 ) 17 18 func boolString(s string) string { 19 if s == "0" { 20 return "false" 21 } 22 return "true" 23 } 24 25 func 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 95 func 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 139 func 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 150 func 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 216 func TestParse(t *testing.T) { 217 ResetForTesting(func() { t.Error("bad parse") }) 218 testParse(CommandLine, t) 219 } 220 221 func TestFlagSetParse(t *testing.T) { 222 testParse(NewFlagSet("test", ContinueOnError), t) 223 } 224 225 // Declare a user-defined flag type. 226 type flagVar []string 227 228 func (f *flagVar) String() string { 229 return fmt.Sprint([]string(*f)) 230 } 231 232 func (f *flagVar) Set(value string) error { 233 *f = append(*f, value) 234 return nil 235 } 236 237 func 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 func TestUserDefinedForCommandLine(t *testing.T) { 255 const help = "HELP" 256 var result string 257 ResetForTesting(func() { result = help }) 258 Usage() 259 if result != help { 260 t.Fatalf("got %q; expected %q", result, help) 261 } 262 } 263 264 // Declare a user-defined boolean flag type. 265 type boolFlagVar struct { 266 count int 267 } 268 269 func (b *boolFlagVar) String() string { 270 return fmt.Sprintf("%d", b.count) 271 } 272 273 func (b *boolFlagVar) Set(value string) error { 274 if value == "true" { 275 b.count++ 276 } 277 return nil 278 } 279 280 func (b *boolFlagVar) IsBoolFlag() bool { 281 return b.count < 4 282 } 283 284 func TestUserDefinedBool(t *testing.T) { 285 var flags FlagSet 286 flags.Init("test", ContinueOnError) 287 var b boolFlagVar 288 var err error 289 flags.Var(&b, "b", "usage") 290 if err = flags.Parse([]string{"-b", "-b", "-b", "-b=true", "-b=false", "-b", "barg", "-b"}); err != nil { 291 if b.count < 4 { 292 t.Error(err) 293 } 294 } 295 296 if b.count != 4 { 297 t.Errorf("want: %d; got: %d", 4, b.count) 298 } 299 300 if err == nil { 301 t.Error("expected error; got none") 302 } 303 } 304 305 func TestSetOutput(t *testing.T) { 306 var flags FlagSet 307 var buf bytes.Buffer 308 flags.SetOutput(&buf) 309 flags.Init("test", ContinueOnError) 310 flags.Parse([]string{"-unknown"}) 311 if out := buf.String(); !strings.Contains(out, "-unknown") { 312 t.Logf("expected output mentioning unknown; got %q", out) 313 } 314 } 315 316 // This tests that one can reset the flags. This still works but not well, and is 317 // superseded by FlagSet. 318 func TestChangingArgs(t *testing.T) { 319 ResetForTesting(func() { t.Fatal("bad parse") }) 320 oldArgs := os.Args 321 defer func() { os.Args = oldArgs }() 322 os.Args = []string{"cmd", "-before", "subcmd", "-after", "args"} 323 before := Bool("before", false, "") 324 if err := CommandLine.Parse(os.Args[1:]); err != nil { 325 t.Fatal(err) 326 } 327 cmd := Arg(0) 328 os.Args = Args() 329 after := Bool("after", false, "") 330 Parse() 331 args := Args() 332 333 if !*before || cmd != "subcmd" || !*after || len(args) != 1 || args[0] != "args" { 334 t.Fatalf("expected true subcmd true [args] got %v %v %v %v", *before, cmd, *after, args) 335 } 336 } 337 338 // Test that -help invokes the usage message and returns ErrHelp. 339 func TestHelp(t *testing.T) { 340 var helpCalled = false 341 fs := NewFlagSet("help test", ContinueOnError) 342 fs.Usage = func() { helpCalled = true } 343 var flag bool 344 fs.BoolVar(&flag, "flag", false, "regular flag") 345 // Regular flag invocation should work 346 err := fs.Parse([]string{"-flag=true"}) 347 if err != nil { 348 t.Fatal("expected no error; got ", err) 349 } 350 if !flag { 351 t.Error("flag was not set by -flag") 352 } 353 if helpCalled { 354 t.Error("help called for regular flag") 355 helpCalled = false // reset for next test 356 } 357 // Help flag should work as expected. 358 err = fs.Parse([]string{"-help"}) 359 if err == nil { 360 t.Fatal("error expected") 361 } 362 if err != ErrHelp { 363 t.Fatal("expected ErrHelp; got ", err) 364 } 365 if !helpCalled { 366 t.Fatal("help was not called") 367 } 368 // If we define a help flag, that should override. 369 var help bool 370 fs.BoolVar(&help, "help", false, "help flag") 371 helpCalled = false 372 err = fs.Parse([]string{"-help"}) 373 if err != nil { 374 t.Fatal("expected no error for defined -help; got ", err) 375 } 376 if helpCalled { 377 t.Fatal("help was called; should not have been for defined help flag") 378 } 379 } 380 381 const defaultOutput = ` -A for bootstrapping, allow 'any' type 382 -Alongflagname 383 disable bounds checking 384 -C a boolean defaulting to true (default true) 385 -D path 386 set relative path for local imports 387 -F number 388 a non-zero number (default 2.7) 389 -G float 390 a float that defaults to zero 391 -N int 392 a non-zero int (default 27) 393 -Z int 394 an int that defaults to zero 395 -maxT timeout 396 set timeout for dial 397 ` 398 399 func TestPrintDefaults(t *testing.T) { 400 fs := NewFlagSet("print defaults test", ContinueOnError) 401 var buf bytes.Buffer 402 fs.SetOutput(&buf) 403 fs.Bool("A", false, "for bootstrapping, allow 'any' type") 404 fs.Bool("Alongflagname", false, "disable bounds checking") 405 fs.Bool("C", true, "a boolean defaulting to true") 406 fs.String("D", "", "set relative `path` for local imports") 407 fs.Float64("F", 2.7, "a non-zero `number`") 408 fs.Float64("G", 0, "a float that defaults to zero") 409 fs.Int("N", 27, "a non-zero int") 410 fs.Int("Z", 0, "an int that defaults to zero") 411 fs.Duration("maxT", 0, "set `timeout` for dial") 412 fs.PrintDefaults() 413 got := buf.String() 414 if got != defaultOutput { 415 t.Errorf("got %q want %q\n", got, defaultOutput) 416 } 417 } 418
