Source file
src/strconv/number_test.go
1
2
3
4
5
6
7
8
9 package strconv_test
10
11 import (
12 "bytes"
13 "errors"
14 "math"
15 "math/cmplx"
16 "reflect"
17 . "strconv"
18 "testing"
19 )
20
21 type atobTest struct {
22 in string
23 out bool
24 err error
25 }
26
27 var atobtests = []atobTest{
28 {"", false, ErrSyntax},
29 {"asdf", false, ErrSyntax},
30 {"0", false, nil},
31 {"false", false, nil},
32 {"true", true, nil},
33 }
34
35 func TestParseBool(t *testing.T) {
36 for _, test := range atobtests {
37 b, e := ParseBool(test.in)
38 if test.err != nil {
39
40 if e == nil {
41 t.Errorf("ParseBool(%s) = nil; want %s", test.in, test.err)
42 } else {
43
44 if e.(*NumError).Err != test.err {
45 t.Errorf("ParseBool(%s) = %s; want %s", test.in, e, test.err)
46 }
47 }
48 } else {
49 if e != nil {
50 t.Errorf("ParseBool(%s) = %s; want nil", test.in, e)
51 }
52 if b != test.out {
53 t.Errorf("ParseBool(%s) = %t; want %t", test.in, b, test.out)
54 }
55 }
56 }
57 }
58
59 var boolString = map[bool]string{
60 true: "true",
61 false: "false",
62 }
63
64 func TestFormatBool(t *testing.T) {
65 for b, s := range boolString {
66 if f := FormatBool(b); f != s {
67 t.Errorf("FormatBool(%v) = %q; want %q", b, f, s)
68 }
69 }
70 }
71
72 type appendBoolTest struct {
73 b bool
74 in []byte
75 out []byte
76 }
77
78 var appendBoolTests = []appendBoolTest{
79 {true, []byte("foo "), []byte("foo true")},
80 {false, []byte("foo "), []byte("foo false")},
81 }
82
83 func TestAppendBool(t *testing.T) {
84 for _, test := range appendBoolTests {
85 b := AppendBool(test.in, test.b)
86 if !bytes.Equal(b, test.out) {
87 t.Errorf("AppendBool(%q, %v) = %q; want %q", test.in, test.b, b, test.out)
88 }
89 }
90 }
91
92 var (
93 infp0 = complex(math.Inf(+1), 0)
94 infm0 = complex(math.Inf(-1), 0)
95 inf0p = complex(0, math.Inf(+1))
96 inf0m = complex(0, math.Inf(-1))
97
98 infpp = complex(math.Inf(+1), math.Inf(+1))
99 infpm = complex(math.Inf(+1), math.Inf(-1))
100 infmp = complex(math.Inf(-1), math.Inf(+1))
101 infmm = complex(math.Inf(-1), math.Inf(-1))
102 )
103
104 type atocTest struct {
105 in string
106 out complex128
107 err error
108 }
109
110 func TestParseComplex(t *testing.T) {
111 tests := []atocTest{
112
113 {"", 0, ErrSyntax},
114 {" ", 0, ErrSyntax},
115 {"(", 0, ErrSyntax},
116 {")", 0, ErrSyntax},
117 {"i", 0, ErrSyntax},
118 {"+i", 0, ErrSyntax},
119 {"-i", 0, ErrSyntax},
120 {"1I", 0, ErrSyntax},
121 {"10 + 5i", 0, ErrSyntax},
122 {"3+", 0, ErrSyntax},
123 {"3+5", 0, ErrSyntax},
124 {"3+5+5i", 0, ErrSyntax},
125
126
127 {"()", 0, ErrSyntax},
128 {"(i)", 0, ErrSyntax},
129 {"(0)", 0, nil},
130 {"(1i)", 1i, nil},
131 {"(3.0+5.5i)", 3.0 + 5.5i, nil},
132 {"(1)+1i", 0, ErrSyntax},
133 {"(3.0+5.5i", 0, ErrSyntax},
134 {"3.0+5.5i)", 0, ErrSyntax},
135
136
137 {"NaN", complex(math.NaN(), 0), nil},
138 {"NANi", complex(0, math.NaN()), nil},
139 {"nan+nAni", complex(math.NaN(), math.NaN()), nil},
140 {"+NaN", 0, ErrSyntax},
141 {"-NaN", 0, ErrSyntax},
142 {"NaN-NaNi", 0, ErrSyntax},
143
144
145 {"Inf", infp0, nil},
146 {"+inf", infp0, nil},
147 {"-inf", infm0, nil},
148 {"Infinity", infp0, nil},
149 {"+INFINITY", infp0, nil},
150 {"-infinity", infm0, nil},
151 {"+infi", inf0p, nil},
152 {"0-infinityi", inf0m, nil},
153 {"Inf+Infi", infpp, nil},
154 {"+Inf-Infi", infpm, nil},
155 {"-Infinity+Infi", infmp, nil},
156 {"inf-inf", 0, ErrSyntax},
157
158
159 {"0", 0, nil},
160 {"0i", 0, nil},
161 {"-0.0i", 0, nil},
162 {"0+0.0i", 0, nil},
163 {"0e+0i", 0, nil},
164 {"0e-0+0i", 0, nil},
165 {"-0.0-0.0i", 0, nil},
166 {"0e+012345", 0, nil},
167 {"0x0p+012345i", 0, nil},
168 {"0x0.00p-012345i", 0, nil},
169 {"+0e-0+0e-0i", 0, nil},
170 {"0e+0+0e+0i", 0, nil},
171 {"-0e+0-0e+0i", 0, nil},
172
173
174 {"0.1", 0.1, nil},
175 {"0.1i", 0 + 0.1i, nil},
176 {"0.123", 0.123, nil},
177 {"0.123i", 0 + 0.123i, nil},
178 {"0.123+0.123i", 0.123 + 0.123i, nil},
179 {"99", 99, nil},
180 {"+99", 99, nil},
181 {"-99", -99, nil},
182 {"+1i", 1i, nil},
183 {"-1i", -1i, nil},
184 {"+3+1i", 3 + 1i, nil},
185 {"30+3i", 30 + 3i, nil},
186 {"+3e+3-3e+3i", 3e+3 - 3e+3i, nil},
187 {"+3e+3+3e+3i", 3e+3 + 3e+3i, nil},
188 {"+3e+3+3e+3i+", 0, ErrSyntax},
189
190
191 {"0.1", 0.1, nil},
192 {"0.1i", 0 + 0.1i, nil},
193 {"0.1_2_3", 0.123, nil},
194 {"+0x_3p3i", 0x3p3i, nil},
195 {"0_0+0x_0p0i", 0, nil},
196 {"0x_10.3p-8+0x3p3i", 0x10.3p-8 + 0x3p3i, nil},
197 {"+0x_1_0.3p-8+0x_3_0p3i", 0x10.3p-8 + 0x30p3i, nil},
198 {"0x1_0.3p+8-0x_3p3i", 0x10.3p+8 - 0x3p3i, nil},
199
200
201 {"0x10.3p-8+0x3p3i", 0x10.3p-8 + 0x3p3i, nil},
202 {"+0x10.3p-8+0x3p3i", 0x10.3p-8 + 0x3p3i, nil},
203 {"0x10.3p+8-0x3p3i", 0x10.3p+8 - 0x3p3i, nil},
204 {"0x1p0", 1, nil},
205 {"0x1p1", 2, nil},
206 {"0x1p-1", 0.5, nil},
207 {"0x1ep-1", 15, nil},
208 {"-0x1ep-1", -15, nil},
209 {"-0x2p3", -16, nil},
210 {"0x1e2", 0, ErrSyntax},
211 {"1p2", 0, ErrSyntax},
212 {"0x1e2i", 0, ErrSyntax},
213
214
215
216 {"+0x1p1024", infp0, ErrRange},
217 {"-0x1p1024", infm0, ErrRange},
218 {"+0x1p1024i", inf0p, ErrRange},
219 {"-0x1p1024i", inf0m, ErrRange},
220 {"+0x1p1024+0x1p1024i", infpp, ErrRange},
221 {"+0x1p1024-0x1p1024i", infpm, ErrRange},
222 {"-0x1p1024+0x1p1024i", infmp, ErrRange},
223 {"-0x1p1024-0x1p1024i", infmm, ErrRange},
224
225
226 {"+0x1.fffffffffffff7fffp1023+0x1.fffffffffffff7fffp1023i", 1.7976931348623157e+308 + 1.7976931348623157e+308i, nil},
227 {"+0x1.fffffffffffff7fffp1023-0x1.fffffffffffff7fffp1023i", 1.7976931348623157e+308 - 1.7976931348623157e+308i, nil},
228 {"-0x1.fffffffffffff7fffp1023+0x1.fffffffffffff7fffp1023i", -1.7976931348623157e+308 + 1.7976931348623157e+308i, nil},
229 {"-0x1.fffffffffffff7fffp1023-0x1.fffffffffffff7fffp1023i", -1.7976931348623157e+308 - 1.7976931348623157e+308i, nil},
230
231 {"+0x1.fffffffffffff8p1023", infp0, ErrRange},
232 {"-0x1fffffffffffff.8p+971", infm0, ErrRange},
233 {"+0x1.fffffffffffff8p1023i", inf0p, ErrRange},
234 {"-0x1fffffffffffff.8p+971i", inf0m, ErrRange},
235 {"+0x1.fffffffffffff8p1023+0x1.fffffffffffff8p1023i", infpp, ErrRange},
236 {"+0x1.fffffffffffff8p1023-0x1.fffffffffffff8p1023i", infpm, ErrRange},
237 {"-0x1fffffffffffff.8p+971+0x1fffffffffffff.8p+971i", infmp, ErrRange},
238 {"-0x1fffffffffffff8p+967-0x1fffffffffffff8p+967i", infmm, ErrRange},
239
240 {"1e308+1e308i", 1e+308 + 1e+308i, nil},
241 {"2e308+2e308i", infpp, ErrRange},
242 {"1e309+1e309i", infpp, ErrRange},
243 {"0x1p1025+0x1p1025i", infpp, ErrRange},
244 {"2e308", infp0, ErrRange},
245 {"1e309", infp0, ErrRange},
246 {"0x1p1025", infp0, ErrRange},
247 {"2e308i", inf0p, ErrRange},
248 {"1e309i", inf0p, ErrRange},
249 {"0x1p1025i", inf0p, ErrRange},
250
251 {"+1e310+1e310i", infpp, ErrRange},
252 {"+1e310-1e310i", infpm, ErrRange},
253 {"-1e310+1e310i", infmp, ErrRange},
254 {"-1e310-1e310i", infmm, ErrRange},
255
256 {"1e-4294967296", 0, nil},
257 {"1e-4294967296i", 0, nil},
258 {"1e-4294967296+1i", 1i, nil},
259 {"1+1e-4294967296i", 1, nil},
260 {"1e-4294967296+1e-4294967296i", 0, nil},
261 {"1e+4294967296", infp0, ErrRange},
262 {"1e+4294967296i", inf0p, ErrRange},
263 {"1e+4294967296+1e+4294967296i", infpp, ErrRange},
264 {"1e+4294967296-1e+4294967296i", infpm, ErrRange},
265 }
266 for i := range tests {
267 test := &tests[i]
268 if test.err != nil {
269 test.err = &NumError{Func: "ParseComplex", Num: test.in, Err: test.err}
270 }
271 got, err := ParseComplex(test.in, 128)
272 if !reflect.DeepEqual(err, test.err) {
273 t.Fatalf("ParseComplex(%q, 128) = %v, %v; want %v, %v", test.in, got, err, test.out, test.err)
274 }
275 if !(cmplx.IsNaN(test.out) && cmplx.IsNaN(got)) && got != test.out {
276 t.Fatalf("ParseComplex(%q, 128) = %v, %v; want %v, %v", test.in, got, err, test.out, test.err)
277 }
278
279 if complex128(complex64(test.out)) == test.out {
280 got, err := ParseComplex(test.in, 64)
281 if !reflect.DeepEqual(err, test.err) {
282 t.Fatalf("ParseComplex(%q, 64) = %v, %v; want %v, %v", test.in, got, err, test.out, test.err)
283 }
284 got64 := complex64(got)
285 if complex128(got64) != test.out {
286 t.Fatalf("ParseComplex(%q, 64) = %v, %v; want %v, %v", test.in, got, err, test.out, test.err)
287 }
288 }
289 }
290 }
291
292
293 func TestParseComplexIncorrectBitSize(t *testing.T) {
294 const s = "1.5e308+1.0e307i"
295 const want = 1.5e308 + 1.0e307i
296
297 for _, bitSize := range []int{0, 10, 100, 256} {
298 c, err := ParseComplex(s, bitSize)
299 if err != nil {
300 t.Fatalf("ParseComplex(%q, %d) gave error %s", s, bitSize, err)
301 }
302 if c != want {
303 t.Fatalf("ParseComplex(%q, %d) = %g (expected %g)", s, bitSize, c, want)
304 }
305 }
306 }
307
308 type atofTest struct {
309 in string
310 out string
311 err error
312 }
313
314 var atoftests = []atofTest{
315 {"", "0", ErrSyntax},
316 {"1.25", "1.25", nil},
317 {"+1", "1", nil},
318 {"1x", "0", ErrSyntax},
319 {"1.1.", "0", ErrSyntax},
320 {"1e23", "1e+23", nil},
321 {"1E23", "1e+23", nil},
322 {"0x1fFe2.p0", "131042", nil},
323 {"0x1fFe2.P0", "131042", nil},
324 {"-0x2p3", "-16", nil},
325 {"0x0.fp4", "15", nil},
326 {"0x0.fp0", "0.9375", nil},
327 {"0x1e2", "0", ErrSyntax},
328 {"1p2", "0", ErrSyntax},
329 {"0x1p1024", "+Inf", ErrRange},
330 {"-0x1p1024", "-Inf", ErrRange},
331 {"0x1.fffffffffffff7fffp1023", "1.7976931348623157e+308", nil},
332 {"-0x1.fffffffffffff7fffp1023", "-1.7976931348623157e+308", nil},
333 {"1.797693134862315808e308", "+Inf", ErrRange},
334 {"-1.797693134862315808e308", "-Inf", ErrRange},
335 }
336
337 func init() {
338
339
340 for i := range atoftests {
341 test := &atoftests[i]
342 if test.err != nil {
343 test.err = &NumError{"ParseFloat", test.in, test.err}
344 }
345 }
346 }
347
348 func TestAtof(t *testing.T) {
349 for i := 0; i < len(atoftests); i++ {
350 test := &atoftests[i]
351 out, err := ParseFloat(test.in, 64)
352 outs := FormatFloat(out, 'g', -1, 64)
353 if outs != test.out || !reflect.DeepEqual(err, test.err) {
354 t.Errorf("ParseFloat(%v, 64) = %v, %v want %v, %v",
355 test.in, out, err, test.out, test.err)
356 }
357
358 if float64(float32(out)) == out {
359 out, err := ParseFloat(test.in, 32)
360 out32 := float32(out)
361 if float64(out32) != out {
362 t.Errorf("ParseFloat(%v, 32) = %v, not a float32 (closest is %v)", test.in, out, float64(out32))
363 continue
364 }
365 outs := FormatFloat(float64(out32), 'g', -1, 32)
366 if outs != test.out || !reflect.DeepEqual(err, test.err) {
367 t.Errorf("ParseFloat(%v, 32) = %v, %v want %v, %v # %v",
368 test.in, out32, err, test.out, test.err, out)
369 }
370 }
371 }
372 }
373
374 type parseUint64Test struct {
375 in string
376 out uint64
377 err error
378 }
379
380 var parseUint64Tests = []parseUint64Test{
381 {"", 0, ErrSyntax},
382 {"0", 0, nil},
383 {"1", 1, nil},
384 {"12345", 12345, nil},
385 {"012345", 12345, nil},
386 {"18446744073709551616", 1<<64 - 1, ErrRange},
387 {"-1", 0, ErrSyntax},
388 }
389
390 type parseUint64BaseTest struct {
391 in string
392 base int
393 out uint64
394 err error
395 }
396
397 var parseUint64BaseTests = []parseUint64BaseTest{
398 {"", 0, 0, ErrSyntax},
399 {"0", 0, 0, nil},
400 {"1", 0, 1, nil},
401 {"-1", 0, 0, ErrSyntax},
402 {"12345", 0, 12345, nil},
403 {"012345", 0, 012345, nil},
404 {"18446744073709551616", 0, 1<<64 - 1, ErrRange},
405 {"0b", 0, 0, ErrSyntax},
406 {"101", 2, 5, nil},
407 {"101_", 2, 0, ErrSyntax},
408 }
409
410 type parseInt64Test struct {
411 in string
412 out int64
413 err error
414 }
415
416 var parseInt64Tests = []parseInt64Test{
417 {"", 0, ErrSyntax},
418 {"0", 0, nil},
419 {"1", 1, nil},
420 {"-1", -1, nil},
421 {"12345", 12345, nil},
422 {"9223372036854775808", 1<<63 - 1, ErrRange},
423 {"123%45", 0, ErrSyntax},
424 }
425
426 type parseInt64BaseTest struct {
427 in string
428 base int
429 out int64
430 err error
431 }
432
433 var parseInt64BaseTests = []parseInt64BaseTest{
434 {"", 0, 0, ErrSyntax},
435 {"0", 0, 0, nil},
436 {"1", 0, 1, nil},
437 {"-1", 0, -1, nil},
438 {"12345", 0, 12345, nil},
439 {"12345", 9, 8303, nil},
440 {"012345", 0, 012345, nil},
441 {"9223372036854775808", 10, 1<<63 - 1, ErrRange},
442 {"0b", 0, 0, ErrSyntax},
443 {"101", 2, 5, nil},
444 {"101_", 2, 0, ErrSyntax},
445 }
446
447 type parseUint32Test struct {
448 in string
449 out uint32
450 err error
451 }
452
453 var parseUint32Tests = []parseUint32Test{
454 {"", 0, ErrSyntax},
455 {"0", 0, nil},
456 {"1", 1, nil},
457 {"12345", 12345, nil},
458 {"12345x", 0, ErrSyntax},
459 {"987654321", 987654321, nil},
460 {"4294967296", 1<<32 - 1, ErrRange},
461 {"1_2_3_4_5", 0, ErrSyntax},
462 {"12345_", 0, ErrSyntax},
463 }
464
465 type parseInt32Test struct {
466 in string
467 out int32
468 err error
469 }
470
471 var parseInt32Tests = []parseInt32Test{
472 {"", 0, ErrSyntax},
473 {"0", 0, nil},
474 {"-0", 0, nil},
475 {"1", 1, nil},
476 {"-1", -1, nil},
477 {"12345", 12345, nil},
478 {"-12345", -12345, nil},
479 {"2147483648", 1<<31 - 1, ErrRange},
480 {"12345_", 0, ErrSyntax},
481 }
482
483 type numErrorTest struct {
484 num, want string
485 }
486
487 var numErrorTests = []numErrorTest{
488 {"0", `strconv.ParseFloat: parsing "0": failed`},
489 {"`", "strconv.ParseFloat: parsing \"`\": failed"},
490 {"1\x00.2", `strconv.ParseFloat: parsing "1\x00.2": failed`},
491 }
492
493 func init() {
494
495
496 for i := range parseUint64Tests {
497 test := &parseUint64Tests[i]
498 if test.err != nil {
499 test.err = &NumError{"ParseUint", test.in, test.err}
500 }
501 }
502 for i := range parseUint64BaseTests {
503 test := &parseUint64BaseTests[i]
504 if test.err != nil {
505 test.err = &NumError{"ParseUint", test.in, test.err}
506 }
507 }
508 for i := range parseInt64Tests {
509 test := &parseInt64Tests[i]
510 if test.err != nil {
511 test.err = &NumError{"ParseInt", test.in, test.err}
512 }
513 }
514 for i := range parseInt64BaseTests {
515 test := &parseInt64BaseTests[i]
516 if test.err != nil {
517 test.err = &NumError{"ParseInt", test.in, test.err}
518 }
519 }
520 for i := range parseUint32Tests {
521 test := &parseUint32Tests[i]
522 if test.err != nil {
523 test.err = &NumError{"ParseUint", test.in, test.err}
524 }
525 }
526 for i := range parseInt32Tests {
527 test := &parseInt32Tests[i]
528 if test.err != nil {
529 test.err = &NumError{"ParseInt", test.in, test.err}
530 }
531 }
532 }
533
534 func TestParseUint32(t *testing.T) {
535 for i := range parseUint32Tests {
536 test := &parseUint32Tests[i]
537 out, err := ParseUint(test.in, 10, 32)
538 if uint64(test.out) != out || !reflect.DeepEqual(test.err, err) {
539 t.Errorf("ParseUint(%q, 10, 32) = %v, %v want %v, %v",
540 test.in, out, err, test.out, test.err)
541 }
542 }
543 }
544
545 func TestParseUint64(t *testing.T) {
546 for i := range parseUint64Tests {
547 test := &parseUint64Tests[i]
548 out, err := ParseUint(test.in, 10, 64)
549 if test.out != out || !reflect.DeepEqual(test.err, err) {
550 t.Errorf("ParseUint(%q, 10, 64) = %v, %v want %v, %v",
551 test.in, out, err, test.out, test.err)
552 }
553 }
554 }
555
556 func TestParseUint64Base(t *testing.T) {
557 for i := range parseUint64BaseTests {
558 test := &parseUint64BaseTests[i]
559 out, err := ParseUint(test.in, test.base, 64)
560 if test.out != out || !reflect.DeepEqual(test.err, err) {
561 t.Errorf("ParseUint(%q, %v, 64) = %v, %v want %v, %v",
562 test.in, test.base, out, err, test.out, test.err)
563 }
564 }
565 }
566
567 func TestParseInt32(t *testing.T) {
568 for i := range parseInt32Tests {
569 test := &parseInt32Tests[i]
570 out, err := ParseInt(test.in, 10, 32)
571 if int64(test.out) != out || !reflect.DeepEqual(test.err, err) {
572 t.Errorf("ParseInt(%q, 10 ,32) = %v, %v want %v, %v",
573 test.in, out, err, test.out, test.err)
574 }
575 }
576 }
577
578 func TestParseInt64(t *testing.T) {
579 for i := range parseInt64Tests {
580 test := &parseInt64Tests[i]
581 out, err := ParseInt(test.in, 10, 64)
582 if test.out != out || !reflect.DeepEqual(test.err, err) {
583 t.Errorf("ParseInt(%q, 10, 64) = %v, %v want %v, %v",
584 test.in, out, err, test.out, test.err)
585 }
586 }
587 }
588
589 func TestParseInt64Base(t *testing.T) {
590 for i := range parseInt64BaseTests {
591 test := &parseInt64BaseTests[i]
592 out, err := ParseInt(test.in, test.base, 64)
593 if test.out != out || !reflect.DeepEqual(test.err, err) {
594 t.Errorf("ParseInt(%q, %v, 64) = %v, %v want %v, %v",
595 test.in, test.base, out, err, test.out, test.err)
596 }
597 }
598 }
599
600 func TestParseUint(t *testing.T) {
601 switch IntSize {
602 case 32:
603 for i := range parseUint32Tests {
604 test := &parseUint32Tests[i]
605 out, err := ParseUint(test.in, 10, 0)
606 if uint64(test.out) != out || !reflect.DeepEqual(test.err, err) {
607 t.Errorf("ParseUint(%q, 10, 0) = %v, %v want %v, %v",
608 test.in, out, err, test.out, test.err)
609 }
610 }
611 case 64:
612 for i := range parseUint64Tests {
613 test := &parseUint64Tests[i]
614 out, err := ParseUint(test.in, 10, 0)
615 if test.out != out || !reflect.DeepEqual(test.err, err) {
616 t.Errorf("ParseUint(%q, 10, 0) = %v, %v want %v, %v",
617 test.in, out, err, test.out, test.err)
618 }
619 }
620 }
621 }
622
623 func TestParseInt(t *testing.T) {
624 switch IntSize {
625 case 32:
626 for i := range parseInt32Tests {
627 test := &parseInt32Tests[i]
628 out, err := ParseInt(test.in, 10, 0)
629 if int64(test.out) != out || !reflect.DeepEqual(test.err, err) {
630 t.Errorf("ParseInt(%q, 10, 0) = %v, %v want %v, %v",
631 test.in, out, err, test.out, test.err)
632 }
633 }
634 case 64:
635 for i := range parseInt64Tests {
636 test := &parseInt64Tests[i]
637 out, err := ParseInt(test.in, 10, 0)
638 if test.out != out || !reflect.DeepEqual(test.err, err) {
639 t.Errorf("ParseInt(%q, 10, 0) = %v, %v want %v, %v",
640 test.in, out, err, test.out, test.err)
641 }
642 }
643 }
644 }
645
646 func TestAtoi(t *testing.T) {
647 switch IntSize {
648 case 32:
649 for i := range parseInt32Tests {
650 test := &parseInt32Tests[i]
651 out, err := Atoi(test.in)
652 var testErr error
653 if test.err != nil {
654 testErr = &NumError{"Atoi", test.in, test.err.(*NumError).Err}
655 }
656 if int(test.out) != out || !reflect.DeepEqual(testErr, err) {
657 t.Errorf("Atoi(%q) = %v, %v want %v, %v",
658 test.in, out, err, test.out, testErr)
659 }
660 }
661 case 64:
662 for i := range parseInt64Tests {
663 test := &parseInt64Tests[i]
664 out, err := Atoi(test.in)
665 var testErr error
666 if test.err != nil {
667 testErr = &NumError{"Atoi", test.in, test.err.(*NumError).Err}
668 }
669 if test.out != int64(out) || !reflect.DeepEqual(testErr, err) {
670 t.Errorf("Atoi(%q) = %v, %v want %v, %v",
671 test.in, out, err, test.out, testErr)
672 }
673 }
674 }
675 }
676
677 func bitSizeErrStub(name string, bitSize int) error {
678 return bitSizeError(name, "0", bitSize)
679 }
680
681 func baseErrStub(name string, base int) error {
682 return baseError(name, "0", base)
683 }
684
685 func noErrStub(name string, arg int) error {
686 return nil
687 }
688
689 type parseErrorTest struct {
690 arg int
691 errStub func(name string, arg int) error
692 }
693
694 var parseBitSizeTests = []parseErrorTest{
695 {-1, bitSizeErrStub},
696 {0, noErrStub},
697 {64, noErrStub},
698 {65, bitSizeErrStub},
699 }
700
701 var parseBaseTests = []parseErrorTest{
702 {-1, baseErrStub},
703 {0, noErrStub},
704 {1, baseErrStub},
705 {2, noErrStub},
706 {36, noErrStub},
707 {37, baseErrStub},
708 }
709
710 func equalError(a, b error) bool {
711 if a == nil {
712 return b == nil
713 }
714 if b == nil {
715 return a == nil
716 }
717 return a.Error() == b.Error()
718 }
719
720 func TestParseIntBitSize(t *testing.T) {
721 for i := range parseBitSizeTests {
722 test := &parseBitSizeTests[i]
723 testErr := test.errStub("ParseInt", test.arg)
724 _, err := ParseInt("0", 0, test.arg)
725 if !equalError(testErr, err) {
726 t.Errorf("ParseInt(\"0\", 0, %v) = 0, %v want 0, %v",
727 test.arg, err, testErr)
728 }
729 }
730 }
731
732 func TestParseUintBitSize(t *testing.T) {
733 for i := range parseBitSizeTests {
734 test := &parseBitSizeTests[i]
735 testErr := test.errStub("ParseUint", test.arg)
736 _, err := ParseUint("0", 0, test.arg)
737 if !equalError(testErr, err) {
738 t.Errorf("ParseUint(\"0\", 0, %v) = 0, %v want 0, %v",
739 test.arg, err, testErr)
740 }
741 }
742 }
743
744 func TestParseIntBase(t *testing.T) {
745 for i := range parseBaseTests {
746 test := &parseBaseTests[i]
747 testErr := test.errStub("ParseInt", test.arg)
748 _, err := ParseInt("0", test.arg, 0)
749 if !equalError(testErr, err) {
750 t.Errorf("ParseInt(\"0\", %v, 0) = 0, %v want 0, %v",
751 test.arg, err, testErr)
752 }
753 }
754 }
755
756 func TestParseUintBase(t *testing.T) {
757 for i := range parseBaseTests {
758 test := &parseBaseTests[i]
759 testErr := test.errStub("ParseUint", test.arg)
760 _, err := ParseUint("0", test.arg, 0)
761 if !equalError(testErr, err) {
762 t.Errorf("ParseUint(\"0\", %v, 0) = 0, %v want 0, %v",
763 test.arg, err, testErr)
764 }
765 }
766 }
767
768 func TestNumError(t *testing.T) {
769 for _, test := range numErrorTests {
770 err := &NumError{
771 Func: "ParseFloat",
772 Num: test.num,
773 Err: errors.New("failed"),
774 }
775 if got := err.Error(); got != test.want {
776 t.Errorf(`(&NumError{"ParseFloat", %q, "failed"}).Error() = %v, want %v`, test.num, got, test.want)
777 }
778 }
779 }
780
781 func TestNumErrorUnwrap(t *testing.T) {
782 err := &NumError{Err: ErrSyntax}
783 if !errors.Is(err, ErrSyntax) {
784 t.Error("errors.Is failed, wanted success")
785 }
786 }
787
788 func TestFormatComplex(t *testing.T) {
789 tests := []struct {
790 c complex128
791 fmt byte
792 prec int
793 bitSize int
794 out string
795 }{
796
797 {1 + 2i, 'g', -1, 128, "(1+2i)"},
798 {3 - 4i, 'g', -1, 128, "(3-4i)"},
799 {-5 + 6i, 'g', -1, 128, "(-5+6i)"},
800 {-7 - 8i, 'g', -1, 128, "(-7-8i)"},
801
802
803 {3.14159 + 0.00123i, 'e', 3, 128, "(3.142e+00+1.230e-03i)"},
804 {3.14159 + 0.00123i, 'f', 3, 128, "(3.142+0.001i)"},
805 {3.14159 + 0.00123i, 'g', 3, 128, "(3.14+0.00123i)"},
806
807
808 {1.2345678901234567 + 9.876543210987654i, 'f', -1, 128, "(1.2345678901234567+9.876543210987654i)"},
809 {1.2345678901234567 + 9.876543210987654i, 'f', -1, 64, "(1.2345679+9.876543i)"},
810
811
812 }
813 for _, test := range tests {
814 out := FormatComplex(test.c, test.fmt, test.prec, test.bitSize)
815 if out != test.out {
816 t.Fatalf("FormatComplex(%v, %q, %d, %d) = %q; want %q",
817 test.c, test.fmt, test.prec, test.bitSize, out, test.out)
818 }
819 }
820 }
821
822 func TestFormatComplexInvalidBitSize(t *testing.T) {
823 defer func() {
824 if r := recover(); r == nil {
825 t.Fatalf("expected panic due to invalid bitSize")
826 }
827 }()
828 _ = FormatComplex(1+2i, 'g', -1, 100)
829 }
830
831 type itob64Test struct {
832 in int64
833 base int
834 out string
835 }
836
837 var itob64tests = []itob64Test{
838 {0, 10, "0"},
839 {1, 10, "1"},
840 {-1, 10, "-1"},
841 {12345678, 10, "12345678"},
842 {-1 << 63, 10, "-9223372036854775808"},
843 {16, 17, "g"},
844 {25, 25, "10"},
845 {(((((17*36+24)*36+21)*36+34)*36+12)*36+24)*36 + 32, 36, "holycow"},
846 }
847
848 func TestItoa(t *testing.T) {
849 for _, test := range itob64tests {
850 s := FormatInt(test.in, test.base)
851 if s != test.out {
852 t.Errorf("FormatInt(%v, %v) = %v want %v",
853 test.in, test.base, s, test.out)
854 }
855 x := AppendInt([]byte("abc"), test.in, test.base)
856 if string(x) != "abc"+test.out {
857 t.Errorf("AppendInt(%q, %v, %v) = %q want %v",
858 "abc", test.in, test.base, x, test.out)
859 }
860
861 if test.in >= 0 {
862 s := FormatUint(uint64(test.in), test.base)
863 if s != test.out {
864 t.Errorf("FormatUint(%v, %v) = %v want %v",
865 test.in, test.base, s, test.out)
866 }
867 x := AppendUint(nil, uint64(test.in), test.base)
868 if string(x) != test.out {
869 t.Errorf("AppendUint(%q, %v, %v) = %q want %v",
870 "abc", uint64(test.in), test.base, x, test.out)
871 }
872 }
873
874 if test.base == 10 && int64(int(test.in)) == test.in {
875 s := Itoa(int(test.in))
876 if s != test.out {
877 t.Errorf("Itoa(%v) = %v want %v",
878 test.in, s, test.out)
879 }
880 }
881 }
882
883
884 defer func() {
885 if r := recover(); r == nil {
886 t.Fatalf("expected panic due to illegal base")
887 }
888 }()
889 FormatUint(12345678, 1)
890 }
891
892 type uitob64Test struct {
893 in uint64
894 base int
895 out string
896 }
897
898 var uitob64tests = []uitob64Test{
899 {1<<63 - 1, 10, "9223372036854775807"},
900 {1 << 63, 10, "9223372036854775808"},
901 {1<<63 + 1, 10, "9223372036854775809"},
902 {1<<64 - 2, 10, "18446744073709551614"},
903 {1<<64 - 1, 10, "18446744073709551615"},
904 {1<<64 - 1, 2, "1111111111111111111111111111111111111111111111111111111111111111"},
905 }
906
907 func TestUitoa(t *testing.T) {
908 for _, test := range uitob64tests {
909 s := FormatUint(test.in, test.base)
910 if s != test.out {
911 t.Errorf("FormatUint(%v, %v) = %v want %v",
912 test.in, test.base, s, test.out)
913 }
914 x := AppendUint([]byte("abc"), test.in, test.base)
915 if string(x) != "abc"+test.out {
916 t.Errorf("AppendUint(%q, %v, %v) = %q want %v",
917 "abc", test.in, test.base, x, test.out)
918 }
919
920 }
921 }
922
923 var varlenUints = []struct {
924 in uint64
925 out string
926 }{
927 {1, "1"},
928 {12, "12"},
929 {123, "123"},
930 {1234, "1234"},
931 {12345, "12345"},
932 {123456, "123456"},
933 {1234567, "1234567"},
934 {12345678, "12345678"},
935 {123456789, "123456789"},
936 {1234567890, "1234567890"},
937 {12345678901, "12345678901"},
938 {123456789012, "123456789012"},
939 {1234567890123, "1234567890123"},
940 {12345678901234, "12345678901234"},
941 {123456789012345, "123456789012345"},
942 {1234567890123456, "1234567890123456"},
943 {12345678901234567, "12345678901234567"},
944 {123456789012345678, "123456789012345678"},
945 {1234567890123456789, "1234567890123456789"},
946 {12345678901234567890, "12345678901234567890"},
947 }
948
949 func TestFormatUintVarlen(t *testing.T) {
950 for _, test := range varlenUints {
951 s := FormatUint(test.in, 10)
952 if s != test.out {
953 t.Errorf("FormatUint(%v, 10) = %v want %v", test.in, s, test.out)
954 }
955 }
956 }
957
View as plain text