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