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 }