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 pflag
6
7import (
8	"fmt"
9	"strings"
10	"testing"
11)
12
13func setUpSSFlagSet(ssp *[]string) *FlagSet {
14	f := NewFlagSet("test", ContinueOnError)
15	f.StringSliceVar(ssp, "ss", []string{}, "Command separated list!")
16	return f
17}
18
19func setUpSSFlagSetWithDefault(ssp *[]string) *FlagSet {
20	f := NewFlagSet("test", ContinueOnError)
21	f.StringSliceVar(ssp, "ss", []string{"default", "values"}, "Command separated list!")
22	return f
23}
24
25func TestEmptySS(t *testing.T) {
26	var ss []string
27	f := setUpSSFlagSet(&ss)
28	err := f.Parse([]string{})
29	if err != nil {
30		t.Fatal("expected no error; got", err)
31	}
32
33	getSS, err := f.GetStringSlice("ss")
34	if err != nil {
35		t.Fatal("got an error from GetStringSlice():", err)
36	}
37	if len(getSS) != 0 {
38		t.Fatalf("got ss %v with len=%d but expected length=0", getSS, len(getSS))
39	}
40}
41
42func TestEmptySSValue(t *testing.T) {
43	var ss []string
44	f := setUpSSFlagSet(&ss)
45	err := f.Parse([]string{"--ss="})
46	if err != nil {
47		t.Fatal("expected no error; got", err)
48	}
49
50	getSS, err := f.GetStringSlice("ss")
51	if err != nil {
52		t.Fatal("got an error from GetStringSlice():", err)
53	}
54	if len(getSS) != 0 {
55		t.Fatalf("got ss %v with len=%d but expected length=0", getSS, len(getSS))
56	}
57}
58
59func TestSS(t *testing.T) {
60	var ss []string
61	f := setUpSSFlagSet(&ss)
62
63	vals := []string{"one", "two", "4", "3"}
64	arg := fmt.Sprintf("--ss=%s", strings.Join(vals, ","))
65	err := f.Parse([]string{arg})
66	if err != nil {
67		t.Fatal("expected no error; got", err)
68	}
69	for i, v := range ss {
70		if vals[i] != v {
71			t.Fatalf("expected ss[%d] to be %s but got: %s", i, vals[i], v)
72		}
73	}
74
75	getSS, err := f.GetStringSlice("ss")
76	if err != nil {
77		t.Fatal("got an error from GetStringSlice():", err)
78	}
79	for i, v := range getSS {
80		if vals[i] != v {
81			t.Fatalf("expected ss[%d] to be %s from GetStringSlice but got: %s", i, vals[i], v)
82		}
83	}
84}
85
86func TestSSDefault(t *testing.T) {
87	var ss []string
88	f := setUpSSFlagSetWithDefault(&ss)
89
90	vals := []string{"default", "values"}
91
92	err := f.Parse([]string{})
93	if err != nil {
94		t.Fatal("expected no error; got", err)
95	}
96	for i, v := range ss {
97		if vals[i] != v {
98			t.Fatalf("expected ss[%d] to be %s but got: %s", i, vals[i], v)
99		}
100	}
101
102	getSS, err := f.GetStringSlice("ss")
103	if err != nil {
104		t.Fatal("got an error from GetStringSlice():", err)
105	}
106	for i, v := range getSS {
107		if vals[i] != v {
108			t.Fatalf("expected ss[%d] to be %s from GetStringSlice but got: %s", i, vals[i], v)
109		}
110	}
111}
112
113func TestSSWithDefault(t *testing.T) {
114	var ss []string
115	f := setUpSSFlagSetWithDefault(&ss)
116
117	vals := []string{"one", "two", "4", "3"}
118	arg := fmt.Sprintf("--ss=%s", strings.Join(vals, ","))
119	err := f.Parse([]string{arg})
120	if err != nil {
121		t.Fatal("expected no error; got", err)
122	}
123	for i, v := range ss {
124		if vals[i] != v {
125			t.Fatalf("expected ss[%d] to be %s but got: %s", i, vals[i], v)
126		}
127	}
128
129	getSS, err := f.GetStringSlice("ss")
130	if err != nil {
131		t.Fatal("got an error from GetStringSlice():", err)
132	}
133	for i, v := range getSS {
134		if vals[i] != v {
135			t.Fatalf("expected ss[%d] to be %s from GetStringSlice but got: %s", i, vals[i], v)
136		}
137	}
138}
139
140func TestSSCalledTwice(t *testing.T) {
141	var ss []string
142	f := setUpSSFlagSet(&ss)
143
144	in := []string{"one,two", "three"}
145	expected := []string{"one", "two", "three"}
146	argfmt := "--ss=%s"
147	arg1 := fmt.Sprintf(argfmt, in[0])
148	arg2 := fmt.Sprintf(argfmt, in[1])
149	err := f.Parse([]string{arg1, arg2})
150	if err != nil {
151		t.Fatal("expected no error; got", err)
152	}
153
154	if len(expected) != len(ss) {
155		t.Fatalf("expected number of ss to be %d but got: %d", len(expected), len(ss))
156	}
157	for i, v := range ss {
158		if expected[i] != v {
159			t.Fatalf("expected ss[%d] to be %s but got: %s", i, expected[i], v)
160		}
161	}
162
163	values, err := f.GetStringSlice("ss")
164	if err != nil {
165		t.Fatal("expected no error; got", err)
166	}
167
168	if len(expected) != len(values) {
169		t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(ss))
170	}
171	for i, v := range values {
172		if expected[i] != v {
173			t.Fatalf("expected got ss[%d] to be %s but got: %s", i, expected[i], v)
174		}
175	}
176}
177
178func TestSSWithComma(t *testing.T) {
179	var ss []string
180	f := setUpSSFlagSet(&ss)
181
182	in := []string{`"one,two"`, `"three"`, `"four,five",six`}
183	expected := []string{"one,two", "three", "four,five", "six"}
184	argfmt := "--ss=%s"
185	arg1 := fmt.Sprintf(argfmt, in[0])
186	arg2 := fmt.Sprintf(argfmt, in[1])
187	arg3 := fmt.Sprintf(argfmt, in[2])
188	err := f.Parse([]string{arg1, arg2, arg3})
189	if err != nil {
190		t.Fatal("expected no error; got", err)
191	}
192
193	if len(expected) != len(ss) {
194		t.Fatalf("expected number of ss to be %d but got: %d", len(expected), len(ss))
195	}
196	for i, v := range ss {
197		if expected[i] != v {
198			t.Fatalf("expected ss[%d] to be %s but got: %s", i, expected[i], v)
199		}
200	}
201
202	values, err := f.GetStringSlice("ss")
203	if err != nil {
204		t.Fatal("expected no error; got", err)
205	}
206
207	if len(expected) != len(values) {
208		t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(values))
209	}
210	for i, v := range values {
211		if expected[i] != v {
212			t.Fatalf("expected got ss[%d] to be %s but got: %s", i, expected[i], v)
213		}
214	}
215}
216
217func TestSSWithSquareBrackets(t *testing.T) {
218	var ss []string
219	f := setUpSSFlagSet(&ss)
220
221	in := []string{`"[a-z]"`, `"[a-z]+"`}
222	expected := []string{"[a-z]", "[a-z]+"}
223	argfmt := "--ss=%s"
224	arg1 := fmt.Sprintf(argfmt, in[0])
225	arg2 := fmt.Sprintf(argfmt, in[1])
226	err := f.Parse([]string{arg1, arg2})
227	if err != nil {
228		t.Fatal("expected no error; got", err)
229	}
230
231	if len(expected) != len(ss) {
232		t.Fatalf("expected number of ss to be %d but got: %d", len(expected), len(ss))
233	}
234	for i, v := range ss {
235		if expected[i] != v {
236			t.Fatalf("expected ss[%d] to be %s but got: %s", i, expected[i], v)
237		}
238	}
239
240	values, err := f.GetStringSlice("ss")
241	if err != nil {
242		t.Fatal("expected no error; got", err)
243	}
244
245	if len(expected) != len(values) {
246		t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(values))
247	}
248	for i, v := range values {
249		if expected[i] != v {
250			t.Fatalf("expected got ss[%d] to be %s but got: %s", i, expected[i], v)
251		}
252	}
253}
254
255func TestSSAsSliceValue(t *testing.T) {
256	var ss []string
257	f := setUpSSFlagSet(&ss)
258
259	in := []string{"one", "two"}
260	argfmt := "--ss=%s"
261	arg1 := fmt.Sprintf(argfmt, in[0])
262	arg2 := fmt.Sprintf(argfmt, in[1])
263	err := f.Parse([]string{arg1, arg2})
264	if err != nil {
265		t.Fatal("expected no error; got", err)
266	}
267
268	f.VisitAll(func(f *Flag) {
269		if val, ok := f.Value.(SliceValue); ok {
270			_ = val.Replace([]string{"three"})
271		}
272	})
273	if len(ss) != 1 || ss[0] != "three" {
274		t.Fatalf("Expected ss to be overwritten with 'three', but got: %s", ss)
275	}
276}
277