diff options
Diffstat (limited to 'src/pkg/fmt/scan_test.go')
| -rw-r--r-- | src/pkg/fmt/scan_test.go | 181 |
1 files changed, 181 insertions, 0 deletions
diff --git a/src/pkg/fmt/scan_test.go b/src/pkg/fmt/scan_test.go new file mode 100644 index 000000000..a49fb90a4 --- /dev/null +++ b/src/pkg/fmt/scan_test.go @@ -0,0 +1,181 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package fmt_test + +import ( + . "fmt" + "io" + "os" + "reflect" + "strings" + "testing" +) + +type ScanTest struct { + text string + in interface{} + out interface{} +} + +var boolVal bool +var intVal int +var int8Val int8 +var int16Val int16 +var int32Val int32 +var int64Val int64 +var uintVal uint +var uint8Val uint8 +var uint16Val uint16 +var uint32Val uint32 +var uint64Val uint64 +var floatVal float +var float32Val float32 +var float64Val float64 +var stringVal string +var complexVal complex +var complex64Val complex64 +var complex128Val complex128 + +var scanTests = []ScanTest{ + ScanTest{"T\n", &boolVal, true}, + ScanTest{"21\n", &intVal, 21}, + ScanTest{"22\n", &int8Val, int8(22)}, + ScanTest{"23\n", &int16Val, int16(23)}, + ScanTest{"24\n", &int32Val, int32(24)}, + ScanTest{"25\n", &int64Val, int64(25)}, + ScanTest{"127\n", &int8Val, int8(127)}, + ScanTest{"-21\n", &intVal, -21}, + ScanTest{"-22\n", &int8Val, int8(-22)}, + ScanTest{"-23\n", &int16Val, int16(-23)}, + ScanTest{"-24\n", &int32Val, int32(-24)}, + ScanTest{"-25\n", &int64Val, int64(-25)}, + ScanTest{"-128\n", &int8Val, int8(-128)}, + ScanTest{"+21\n", &intVal, +21}, + ScanTest{"+22\n", &int8Val, int8(+22)}, + ScanTest{"+23\n", &int16Val, int16(+23)}, + ScanTest{"+24\n", &int32Val, int32(+24)}, + ScanTest{"+25\n", &int64Val, int64(+25)}, + ScanTest{"+127\n", &int8Val, int8(+127)}, + ScanTest{"26\n", &uintVal, uint(26)}, + ScanTest{"27\n", &uint8Val, uint8(27)}, + ScanTest{"28\n", &uint16Val, uint16(28)}, + ScanTest{"29\n", &uint32Val, uint32(29)}, + ScanTest{"30\n", &uint64Val, uint64(30)}, + ScanTest{"255\n", &uint8Val, uint8(255)}, + ScanTest{"32767\n", &int16Val, int16(32767)}, + ScanTest{"2.3\n", &floatVal, 2.3}, + ScanTest{"2.3e1\n", &float32Val, float32(2.3e1)}, + ScanTest{"2.3e2\n", &float64Val, float64(2.3e2)}, + ScanTest{"2.35\n", &stringVal, "2.35"}, + ScanTest{"(3.4e1-2i)\n", &complexVal, 3.4e1 - 2i}, + ScanTest{"-3.45e1-3i\n", &complex64Val, complex64(-3.45e1 - 3i)}, + ScanTest{"-.45e1-1e2i\n", &complex128Val, complex128(-.45e1 - 100i)}, +} + +var overflowTests = []ScanTest{ + ScanTest{"128", &int8Val, 0}, + ScanTest{"32768", &int16Val, 0}, + ScanTest{"-129", &int8Val, 0}, + ScanTest{"-32769", &int16Val, 0}, + ScanTest{"256", &uint8Val, 0}, + ScanTest{"65536", &uint16Val, 0}, + ScanTest{"1e100", &float32Val, 0}, + ScanTest{"1e500", &float64Val, 0}, + ScanTest{"(1e100+0i)", &complexVal, 0}, + ScanTest{"(1+1e100i)", &complex64Val, 0}, + ScanTest{"(1-1e500i)", &complex128Val, 0}, +} + +func testScan(t *testing.T, scan func(r io.Reader, a ...interface{}) (int, os.Error)) { + for _, test := range scanTests { + r := strings.NewReader(test.text) + n, err := scan(r, test.in) + if err != nil { + t.Errorf("got error scanning %q: %s", test.text, err) + continue + } + if n != 1 { + t.Errorf("count error on entry %q: got %d", test.text, n) + continue + } + // The incoming value may be a pointer + v := reflect.NewValue(test.in) + if p, ok := v.(*reflect.PtrValue); ok { + v = p.Elem() + } + val := v.Interface() + if !reflect.DeepEqual(val, test.out) { + t.Errorf("scanning %q: expected %v got %v, type %T", test.text, test.out, val, val) + } + } +} + +func TestScan(t *testing.T) { + testScan(t, Scan) +} + +func TestScanln(t *testing.T) { + testScan(t, Scanln) +} + +func TestScanOverflow(t *testing.T) { + for _, test := range overflowTests { + r := strings.NewReader(test.text) + _, err := Scan(r, test.in) + if err == nil { + t.Errorf("expected overflow scanning %q", test.text) + continue + } + if strings.Index(err.String(), "overflow") < 0 && strings.Index(err.String(), "too large") < 0 { + t.Errorf("expected overflow error scanning %q: %s", test.text, err) + } + } +} + +func TestScanMultiple(t *testing.T) { + text := "1 2 3 x" + r := strings.NewReader(text) + var a, b, c, d int + n, err := Scan(r, &a, &b, &c, &d) + if n != 3 { + t.Errorf("count error: expected 3: got %d", n) + } + if err == nil { + t.Errorf("expected error scanning ", text) + } +} + +func TestScanNotPointer(t *testing.T) { + r := strings.NewReader("1") + var a int + _, err := Scan(r, a) + if err == nil { + t.Error("expected error scanning non-pointer") + } else if strings.Index(err.String(), "pointer") < 0 { + t.Errorf("expected pointer error scanning non-pointer, got: %s", err) + } +} + +func TestScanlnNoNewline(t *testing.T) { + r := strings.NewReader("1 x\n") + var a int + _, err := Scanln(r, &a) + if err == nil { + t.Error("expected error scanning string missing newline") + } else if strings.Index(err.String(), "newline") < 0 { + t.Errorf("expected newline error scanning string missing newline, got: %s", err) + } +} + +func TestScanlnWithMiddleNewline(t *testing.T) { + r := strings.NewReader("123\n456\n") + var a, b int + _, err := Scanln(r, &a, &b) + if err == nil { + t.Error("expected error scanning string with extra newline") + } else if strings.Index(err.String(), "newline") < 0 { + t.Errorf("expected newline error scanning string with extra newline, got: %s", err) + } +} |