1
2
3
4
5 package pflag
6
7 import (
8 "fmt"
9 "strconv"
10 "strings"
11 "testing"
12 )
13
14 func setUpF64SFlagSet(f64sp *[]float64) *FlagSet {
15 f := NewFlagSet("test", ContinueOnError)
16 f.Float64SliceVar(f64sp, "f64s", []float64{}, "Command separated list!")
17 return f
18 }
19
20 func setUpF64SFlagSetWithDefault(f64sp *[]float64) *FlagSet {
21 f := NewFlagSet("test", ContinueOnError)
22 f.Float64SliceVar(f64sp, "f64s", []float64{0.0, 1.0}, "Command separated list!")
23 return f
24 }
25
26 func TestEmptyF64S(t *testing.T) {
27 var f64s []float64
28 f := setUpF64SFlagSet(&f64s)
29 err := f.Parse([]string{})
30 if err != nil {
31 t.Fatal("expected no error; got", err)
32 }
33
34 getF64S, err := f.GetFloat64Slice("f64s")
35 if err != nil {
36 t.Fatal("got an error from GetFloat64Slice():", err)
37 }
38 if len(getF64S) != 0 {
39 t.Fatalf("got f64s %v with len=%d but expected length=0", getF64S, len(getF64S))
40 }
41 }
42
43 func TestF64S(t *testing.T) {
44 var f64s []float64
45 f := setUpF64SFlagSet(&f64s)
46
47 vals := []string{"1.0", "2.0", "4.0", "3.0"}
48 arg := fmt.Sprintf("--f64s=%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 f64s {
54 d, err := strconv.ParseFloat(vals[i], 64)
55 if err != nil {
56 t.Fatalf("got error: %v", err)
57 }
58 if d != v {
59 t.Fatalf("expected f64s[%d] to be %s but got: %f", i, vals[i], v)
60 }
61 }
62 getF64S, err := f.GetFloat64Slice("f64s")
63 if err != nil {
64 t.Fatalf("got error: %v", err)
65 }
66 for i, v := range getF64S {
67 d, err := strconv.ParseFloat(vals[i], 64)
68 if err != nil {
69 t.Fatalf("got error: %v", err)
70 }
71 if d != v {
72 t.Fatalf("expected f64s[%d] to be %s but got: %f from GetFloat64Slice", i, vals[i], v)
73 }
74 }
75 }
76
77 func TestF64SDefault(t *testing.T) {
78 var f64s []float64
79 f := setUpF64SFlagSetWithDefault(&f64s)
80
81 vals := []string{"0.0", "1.0"}
82
83 err := f.Parse([]string{})
84 if err != nil {
85 t.Fatal("expected no error; got", err)
86 }
87 for i, v := range f64s {
88 d, err := strconv.ParseFloat(vals[i], 64)
89 if err != nil {
90 t.Fatalf("got error: %v", err)
91 }
92 if d != v {
93 t.Fatalf("expected f64s[%d] to be %f but got: %f", i, d, v)
94 }
95 }
96
97 getF64S, err := f.GetFloat64Slice("f64s")
98 if err != nil {
99 t.Fatal("got an error from GetFloat64Slice():", err)
100 }
101 for i, v := range getF64S {
102 d, err := strconv.ParseFloat(vals[i], 64)
103 if err != nil {
104 t.Fatal("got an error from GetFloat64Slice():", err)
105 }
106 if d != v {
107 t.Fatalf("expected f64s[%d] to be %f from GetFloat64Slice but got: %f", i, d, v)
108 }
109 }
110 }
111
112 func TestF64SWithDefault(t *testing.T) {
113 var f64s []float64
114 f := setUpF64SFlagSetWithDefault(&f64s)
115
116 vals := []string{"1.0", "2.0"}
117 arg := fmt.Sprintf("--f64s=%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 f64s {
123 d, err := strconv.ParseFloat(vals[i], 64)
124 if err != nil {
125 t.Fatalf("got error: %v", err)
126 }
127 if d != v {
128 t.Fatalf("expected f64s[%d] to be %f but got: %f", i, d, v)
129 }
130 }
131
132 getF64S, err := f.GetFloat64Slice("f64s")
133 if err != nil {
134 t.Fatal("got an error from GetFloat64Slice():", err)
135 }
136 for i, v := range getF64S {
137 d, err := strconv.ParseFloat(vals[i], 64)
138 if err != nil {
139 t.Fatalf("got error: %v", err)
140 }
141 if d != v {
142 t.Fatalf("expected f64s[%d] to be %f from GetFloat64Slice but got: %f", i, d, v)
143 }
144 }
145 }
146
147 func TestF64SAsSliceValue(t *testing.T) {
148 var f64s []float64
149 f := setUpF64SFlagSet(&f64s)
150
151 in := []string{"1.0", "2.0"}
152 argfmt := "--f64s=%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.1"})
163 }
164 })
165 if len(f64s) != 1 || f64s[0] != 3.1 {
166 t.Fatalf("Expected ss to be overwritten with '3.1', but got: %v", f64s)
167 }
168 }
169
170 func TestF64SCalledTwice(t *testing.T) {
171 var f64s []float64
172 f := setUpF64SFlagSet(&f64s)
173
174 in := []string{"1.0,2.0", "3.0"}
175 expected := []float64{1.0, 2.0, 3.0}
176 argfmt := "--f64s=%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 f64s {
184 if expected[i] != v {
185 t.Fatalf("expected f64s[%d] to be %f but got: %f", i, expected[i], v)
186 }
187 }
188 }
189
View as plain text