Source file
src/strconv/atoc_test.go
1
2
3
4
5 package strconv_test
6
7 import (
8 "math"
9 "math/cmplx"
10 "reflect"
11 . "strconv"
12 "testing"
13 )
14
15 var (
16 infp0 = complex(math.Inf(+1), 0)
17 infm0 = complex(math.Inf(-1), 0)
18 inf0p = complex(0, math.Inf(+1))
19 inf0m = complex(0, math.Inf(-1))
20
21 infpp = complex(math.Inf(+1), math.Inf(+1))
22 infpm = complex(math.Inf(+1), math.Inf(-1))
23 infmp = complex(math.Inf(-1), math.Inf(+1))
24 infmm = complex(math.Inf(-1), math.Inf(-1))
25 )
26
27 type atocTest struct {
28 in string
29 out complex128
30 err error
31 }
32
33 func TestParseComplex(t *testing.T) {
34 tests := []atocTest{
35
36 {"", 0, ErrSyntax},
37 {" ", 0, ErrSyntax},
38 {"(", 0, ErrSyntax},
39 {")", 0, ErrSyntax},
40 {"i", 0, ErrSyntax},
41 {"+i", 0, ErrSyntax},
42 {"-i", 0, ErrSyntax},
43 {"1I", 0, ErrSyntax},
44 {"10 + 5i", 0, ErrSyntax},
45 {"3+", 0, ErrSyntax},
46 {"3+5", 0, ErrSyntax},
47 {"3+5+5i", 0, ErrSyntax},
48
49
50 {"()", 0, ErrSyntax},
51 {"(i)", 0, ErrSyntax},
52 {"(0)", 0, nil},
53 {"(1i)", 1i, nil},
54 {"(3.0+5.5i)", 3.0 + 5.5i, nil},
55 {"(1)+1i", 0, ErrSyntax},
56 {"(3.0+5.5i", 0, ErrSyntax},
57 {"3.0+5.5i)", 0, ErrSyntax},
58
59
60 {"NaN", complex(math.NaN(), 0), nil},
61 {"NANi", complex(0, math.NaN()), nil},
62 {"nan+nAni", complex(math.NaN(), math.NaN()), nil},
63 {"+NaN", 0, ErrSyntax},
64 {"-NaN", 0, ErrSyntax},
65 {"NaN-NaNi", 0, ErrSyntax},
66
67
68 {"Inf", infp0, nil},
69 {"+inf", infp0, nil},
70 {"-inf", infm0, nil},
71 {"Infinity", infp0, nil},
72 {"+INFINITY", infp0, nil},
73 {"-infinity", infm0, nil},
74 {"+infi", inf0p, nil},
75 {"0-infinityi", inf0m, nil},
76 {"Inf+Infi", infpp, nil},
77 {"+Inf-Infi", infpm, nil},
78 {"-Infinity+Infi", infmp, nil},
79 {"inf-inf", 0, ErrSyntax},
80
81
82 {"0", 0, nil},
83 {"0i", 0, nil},
84 {"-0.0i", 0, nil},
85 {"0+0.0i", 0, nil},
86 {"0e+0i", 0, nil},
87 {"0e-0+0i", 0, nil},
88 {"-0.0-0.0i", 0, nil},
89 {"0e+012345", 0, nil},
90 {"0x0p+012345i", 0, nil},
91 {"0x0.00p-012345i", 0, nil},
92 {"+0e-0+0e-0i", 0, nil},
93 {"0e+0+0e+0i", 0, nil},
94 {"-0e+0-0e+0i", 0, nil},
95
96
97 {"0.1", 0.1, nil},
98 {"0.1i", 0 + 0.1i, nil},
99 {"0.123", 0.123, nil},
100 {"0.123i", 0 + 0.123i, nil},
101 {"0.123+0.123i", 0.123 + 0.123i, nil},
102 {"99", 99, nil},
103 {"+99", 99, nil},
104 {"-99", -99, nil},
105 {"+1i", 1i, nil},
106 {"-1i", -1i, nil},
107 {"+3+1i", 3 + 1i, nil},
108 {"30+3i", 30 + 3i, nil},
109 {"+3e+3-3e+3i", 3e+3 - 3e+3i, nil},
110 {"+3e+3+3e+3i", 3e+3 + 3e+3i, nil},
111 {"+3e+3+3e+3i+", 0, ErrSyntax},
112
113
114 {"0.1", 0.1, nil},
115 {"0.1i", 0 + 0.1i, nil},
116 {"0.1_2_3", 0.123, nil},
117 {"+0x_3p3i", 0x3p3i, nil},
118 {"0_0+0x_0p0i", 0, nil},
119 {"0x_10.3p-8+0x3p3i", 0x10.3p-8 + 0x3p3i, nil},
120 {"+0x_1_0.3p-8+0x_3_0p3i", 0x10.3p-8 + 0x30p3i, nil},
121 {"0x1_0.3p+8-0x_3p3i", 0x10.3p+8 - 0x3p3i, nil},
122
123
124 {"0x10.3p-8+0x3p3i", 0x10.3p-8 + 0x3p3i, nil},
125 {"+0x10.3p-8+0x3p3i", 0x10.3p-8 + 0x3p3i, nil},
126 {"0x10.3p+8-0x3p3i", 0x10.3p+8 - 0x3p3i, nil},
127 {"0x1p0", 1, nil},
128 {"0x1p1", 2, nil},
129 {"0x1p-1", 0.5, nil},
130 {"0x1ep-1", 15, nil},
131 {"-0x1ep-1", -15, nil},
132 {"-0x2p3", -16, nil},
133 {"0x1e2", 0, ErrSyntax},
134 {"1p2", 0, ErrSyntax},
135 {"0x1e2i", 0, ErrSyntax},
136
137
138
139 {"+0x1p1024", infp0, ErrRange},
140 {"-0x1p1024", infm0, ErrRange},
141 {"+0x1p1024i", inf0p, ErrRange},
142 {"-0x1p1024i", inf0m, ErrRange},
143 {"+0x1p1024+0x1p1024i", infpp, ErrRange},
144 {"+0x1p1024-0x1p1024i", infpm, ErrRange},
145 {"-0x1p1024+0x1p1024i", infmp, ErrRange},
146 {"-0x1p1024-0x1p1024i", infmm, ErrRange},
147
148
149 {"+0x1.fffffffffffff7fffp1023+0x1.fffffffffffff7fffp1023i", 1.7976931348623157e+308 + 1.7976931348623157e+308i, nil},
150 {"+0x1.fffffffffffff7fffp1023-0x1.fffffffffffff7fffp1023i", 1.7976931348623157e+308 - 1.7976931348623157e+308i, nil},
151 {"-0x1.fffffffffffff7fffp1023+0x1.fffffffffffff7fffp1023i", -1.7976931348623157e+308 + 1.7976931348623157e+308i, nil},
152 {"-0x1.fffffffffffff7fffp1023-0x1.fffffffffffff7fffp1023i", -1.7976931348623157e+308 - 1.7976931348623157e+308i, nil},
153
154 {"+0x1.fffffffffffff8p1023", infp0, ErrRange},
155 {"-0x1fffffffffffff.8p+971", infm0, ErrRange},
156 {"+0x1.fffffffffffff8p1023i", inf0p, ErrRange},
157 {"-0x1fffffffffffff.8p+971i", inf0m, ErrRange},
158 {"+0x1.fffffffffffff8p1023+0x1.fffffffffffff8p1023i", infpp, ErrRange},
159 {"+0x1.fffffffffffff8p1023-0x1.fffffffffffff8p1023i", infpm, ErrRange},
160 {"-0x1fffffffffffff.8p+971+0x1fffffffffffff.8p+971i", infmp, ErrRange},
161 {"-0x1fffffffffffff8p+967-0x1fffffffffffff8p+967i", infmm, ErrRange},
162
163 {"1e308+1e308i", 1e+308 + 1e+308i, nil},
164 {"2e308+2e308i", infpp, ErrRange},
165 {"1e309+1e309i", infpp, ErrRange},
166 {"0x1p1025+0x1p1025i", infpp, ErrRange},
167 {"2e308", infp0, ErrRange},
168 {"1e309", infp0, ErrRange},
169 {"0x1p1025", infp0, ErrRange},
170 {"2e308i", inf0p, ErrRange},
171 {"1e309i", inf0p, ErrRange},
172 {"0x1p1025i", inf0p, ErrRange},
173
174 {"+1e310+1e310i", infpp, ErrRange},
175 {"+1e310-1e310i", infpm, ErrRange},
176 {"-1e310+1e310i", infmp, ErrRange},
177 {"-1e310-1e310i", infmm, ErrRange},
178
179 {"1e-4294967296", 0, nil},
180 {"1e-4294967296i", 0, nil},
181 {"1e-4294967296+1i", 1i, nil},
182 {"1+1e-4294967296i", 1, nil},
183 {"1e-4294967296+1e-4294967296i", 0, nil},
184 {"1e+4294967296", infp0, ErrRange},
185 {"1e+4294967296i", inf0p, ErrRange},
186 {"1e+4294967296+1e+4294967296i", infpp, ErrRange},
187 {"1e+4294967296-1e+4294967296i", infpm, ErrRange},
188 }
189 for i := range tests {
190 test := &tests[i]
191 if test.err != nil {
192 test.err = &NumError{Func: "ParseComplex", Num: test.in, Err: test.err}
193 }
194 got, err := ParseComplex(test.in, 128)
195 if !reflect.DeepEqual(err, test.err) {
196 t.Fatalf("ParseComplex(%q, 128) = %v, %v; want %v, %v", test.in, got, err, test.out, test.err)
197 }
198 if !(cmplx.IsNaN(test.out) && cmplx.IsNaN(got)) && got != test.out {
199 t.Fatalf("ParseComplex(%q, 128) = %v, %v; want %v, %v", test.in, got, err, test.out, test.err)
200 }
201
202 if complex128(complex64(test.out)) == test.out {
203 got, err := ParseComplex(test.in, 64)
204 if !reflect.DeepEqual(err, test.err) {
205 t.Fatalf("ParseComplex(%q, 64) = %v, %v; want %v, %v", test.in, got, err, test.out, test.err)
206 }
207 got64 := complex64(got)
208 if complex128(got64) != test.out {
209 t.Fatalf("ParseComplex(%q, 64) = %v, %v; want %v, %v", test.in, got, err, test.out, test.err)
210 }
211 }
212 }
213 }
214
215
216 func TestParseComplexIncorrectBitSize(t *testing.T) {
217 const s = "1.5e308+1.0e307i"
218 const want = 1.5e308 + 1.0e307i
219
220 for _, bitSize := range []int{0, 10, 100, 256} {
221 c, err := ParseComplex(s, bitSize)
222 if err != nil {
223 t.Fatalf("ParseComplex(%q, %d) gave error %s", s, bitSize, err)
224 }
225 if c != want {
226 t.Fatalf("ParseComplex(%q, %d) = %g (expected %g)", s, bitSize, c, want)
227 }
228 }
229 }
230
View as plain text