1
2
3
4
5 package pflag
6
7 import (
8 "fmt"
9 "strconv"
10 "strings"
11 "testing"
12 )
13
14 func setUpI64SFlagSet(isp *[]int64) *FlagSet {
15 f := NewFlagSet("test", ContinueOnError)
16 f.Int64SliceVar(isp, "is", []int64{}, "Command separated list!")
17 return f
18 }
19
20 func setUpI64SFlagSetWithDefault(isp *[]int64) *FlagSet {
21 f := NewFlagSet("test", ContinueOnError)
22 f.Int64SliceVar(isp, "is", []int64{0, 1}, "Command separated list!")
23 return f
24 }
25
26 func TestEmptyI64S(t *testing.T) {
27 var is []int64
28 f := setUpI64SFlagSet(&is)
29 err := f.Parse([]string{})
30 if err != nil {
31 t.Fatal("expected no error; got", err)
32 }
33
34 getI64S, err := f.GetInt64Slice("is")
35 if err != nil {
36 t.Fatal("got an error from GetInt64Slice():", err)
37 }
38 if len(getI64S) != 0 {
39 t.Fatalf("got is %v with len=%d but expected length=0", getI64S, len(getI64S))
40 }
41 }
42
43 func TestI64S(t *testing.T) {
44 var is []int64
45 f := setUpI64SFlagSet(&is)
46
47 vals := []string{"1", "2", "4", "3"}
48 arg := fmt.Sprintf("--is=%s", strings.Join(vals, ","))
49 err := f.Parse([]string{arg})
50 if err != nil {
51 t.Fatal("expected no error; got", err)
52 }
53 for i, v := range is {
54 d, err := strconv.ParseInt(vals[i], 0, 64)
55 if err != nil {
56 t.Fatalf("got error: %v", err)
57 }
58 if d != v {
59 t.Fatalf("expected is[%d] to be %s but got: %d", i, vals[i], v)
60 }
61 }
62 getI64S, err := f.GetInt64Slice("is")
63 if err != nil {
64 t.Fatalf("got error: %v", err)
65 }
66 for i, v := range getI64S {
67 d, err := strconv.ParseInt(vals[i], 0, 64)
68 if err != nil {
69 t.Fatalf("got error: %v", err)
70 }
71 if d != v {
72 t.Fatalf("expected is[%d] to be %s but got: %d from GetInt64Slice", i, vals[i], v)
73 }
74 }
75 }
76
77 func TestI64SDefault(t *testing.T) {
78 var is []int64
79 f := setUpI64SFlagSetWithDefault(&is)
80
81 vals := []string{"0", "1"}
82
83 err := f.Parse([]string{})
84 if err != nil {
85 t.Fatal("expected no error; got", err)
86 }
87 for i, v := range is {
88 d, err := strconv.ParseInt(vals[i], 0, 64)
89 if err != nil {
90 t.Fatalf("got error: %v", err)
91 }
92 if d != v {
93 t.Fatalf("expected is[%d] to be %d but got: %d", i, d, v)
94 }
95 }
96
97 getI64S, err := f.GetInt64Slice("is")
98 if err != nil {
99 t.Fatal("got an error from GetInt64Slice():", err)
100 }
101 for i, v := range getI64S {
102 d, err := strconv.ParseInt(vals[i], 0, 64)
103 if err != nil {
104 t.Fatal("got an error from GetInt64Slice():", err)
105 }
106 if d != v {
107 t.Fatalf("expected is[%d] to be %d from GetInt64Slice but got: %d", i, d, v)
108 }
109 }
110 }
111
112 func TestI64SWithDefault(t *testing.T) {
113 var is []int64
114 f := setUpI64SFlagSetWithDefault(&is)
115
116 vals := []string{"1", "2"}
117 arg := fmt.Sprintf("--is=%s", strings.Join(vals, ","))
118 err := f.Parse([]string{arg})
119 if err != nil {
120 t.Fatal("expected no error; got", err)
121 }
122 for i, v := range is {
123 d, err := strconv.ParseInt(vals[i], 0, 64)
124 if err != nil {
125 t.Fatalf("got error: %v", err)
126 }
127 if d != v {
128 t.Fatalf("expected is[%d] to be %d but got: %d", i, d, v)
129 }
130 }
131
132 getI64S, err := f.GetInt64Slice("is")
133 if err != nil {
134 t.Fatal("got an error from GetInt64Slice():", err)
135 }
136 for i, v := range getI64S {
137 d, err := strconv.ParseInt(vals[i], 0, 64)
138 if err != nil {
139 t.Fatalf("got error: %v", err)
140 }
141 if d != v {
142 t.Fatalf("expected is[%d] to be %d from GetInt64Slice but got: %d", i, d, v)
143 }
144 }
145 }
146
147 func TestI64SAsSliceValue(t *testing.T) {
148 var i64s []int64
149 f := setUpI64SFlagSet(&i64s)
150
151 in := []string{"1", "2"}
152 argfmt := "--is=%s"
153 arg1 := fmt.Sprintf(argfmt, in[0])
154 arg2 := fmt.Sprintf(argfmt, in[1])
155 err := f.Parse([]string{arg1, arg2})
156 if err != nil {
157 t.Fatal("expected no error; got", err)
158 }
159
160 f.VisitAll(func(f *Flag) {
161 if val, ok := f.Value.(SliceValue); ok {
162 _ = val.Replace([]string{"3"})
163 }
164 })
165 if len(i64s) != 1 || i64s[0] != 3 {
166 t.Fatalf("Expected ss to be overwritten with '3.1', but got: %v", i64s)
167 }
168 }
169
170 func TestI64SCalledTwice(t *testing.T) {
171 var is []int64
172 f := setUpI64SFlagSet(&is)
173
174 in := []string{"1,2", "3"}
175 expected := []int64{1, 2, 3}
176 argfmt := "--is=%s"
177 arg1 := fmt.Sprintf(argfmt, in[0])
178 arg2 := fmt.Sprintf(argfmt, in[1])
179 err := f.Parse([]string{arg1, arg2})
180 if err != nil {
181 t.Fatal("expected no error; got", err)
182 }
183 for i, v := range is {
184 if expected[i] != v {
185 t.Fatalf("expected is[%d] to be %d but got: %d", i, expected[i], v)
186 }
187 }
188 }
189
View as plain text