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