code review 4240056: fmt: allow recursive calls to Fscan etc.

src/pkg/fmt/scan_test.go

 // 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 (
         "bufio"
         . "fmt"
         "io"
@@ skipping 69 matching lines @@
 type FloatTest struct {
         text string
         in   float64
         out  float64
 }
 
 // Xs accepts any non-empty run of the verb character
 type Xs string
 
 func (x *Xs) Scan(state ScanState, verb int) os.Error {
-        var tok string
-        var c int
-        var err os.Error
-        wid, present := state.Width()
-        if !present {
-                tok, err = state.Token()
-        } else {
-                for i := 0; i < wid; i++ {
-                        c, _, err = state.ReadRune()
-                        if err != nil {
-                                break
-                        }
-                        tok += string(c)
-                }
-        }
+        tok, err := state.Token()
         if err != nil {
                 return err
         }
         if !regexp.MustCompile("^" + string(verb) + "+$").MatchString(tok) {
                 return os.ErrorString("syntax error for xs")
         }
         *x = Xs(tok)
         return nil
 }
 
 var xVal Xs
+
+// IntString accepts an integer followed immediately by a string.
+// It tests the embedding of a scan within a scan.
+type IntString struct {
+        i int
+        s string
+}
+
+func (s *IntString) Scan(state ScanState, verb int) os.Error {
+        if _, err := Fscan(state, &s.i); err != nil {
+                return err
+        }
+
+        if _, err := Fscan(state, &s.s); err != nil {
+                return err
+        }
+        return nil
+}
+
+var intStringVal IntString
 
 // myStringReader implements Read but not ReadRune, allowing us to test our readRune wrapper
 // type that creates something that can read runes given only Read().
 type myStringReader struct {
         r *strings.Reader
 }
 
 func (s *myStringReader) Read(p []byte) (n int, err os.Error) {
         return s.r.Read(p)
 }
@@ skipping 67 matching lines @@
         {"107\n", &renamedInt32Val, renamedInt32(107)},
         {"108\n", &renamedInt64Val, renamedInt64(108)},
         {"109\n", &renamedUint8Val, renamedUint8(109)},
         {"110\n", &renamedUint16Val, renamedUint16(110)},
         {"111\n", &renamedUint32Val, renamedUint32(111)},
         {"112\n", &renamedUint64Val, renamedUint64(112)},
         {"113\n", &renamedUintptrVal, renamedUintptr(113)},
         {"114\n", &renamedStringVal, renamedString("114")},
         {"115\n", &renamedBytesVal, renamedBytes([]byte("115"))},
 
-        // Custom scanner.
+        // Custom scanners.
         {"  vvv ", &xVal, Xs("vvv")},
+        {" 1234hello", &intStringVal, IntString{1234, "hello"}},
 
         // Fixed bugs
         {"2147483648\n", &int64Val, int64(2147483648)}, // was: integer overflow
 }
 
 var scanfTests = []ScanfTest{
         {"%v", "TRUE\n", &boolVal, true},
         {"%t", "false\n", &boolVal, false},
         {"%v", "-71\n", &intVal, -71},
         {"%v", "0377\n", &intVal, 0377},
@@ skipping 86 matching lines @@
         {"(1e100+0i)", &complex64Val, 0},
         {"(1+1e100i)", &complex64Val, 0},
         {"(1-1e500i)", &complex128Val, 0},
 }
 
 var i, j, k int
 var f float64
 var s, t string
 var c complex128
 var x, y Xs
+var z IntString
 
 var multiTests = []ScanfMultiTest{
         {"", "", nil, nil, ""},
         {"%d", "23", args(&i), args(23), ""},
         {"%2s%3s", "22333", args(&s, &t), args("22", "333"), ""},
         {"%2d%3d", "44555", args(&i, &j), args(44, 555), ""},
         {"%2d.%3d", "66.777", args(&i, &j), args(66, 777), ""},
         {"%d, %d", "23, 18", args(&i, &j), args(23, 18), ""},
         {"%3d22%3d", "33322333", args(&i, &j), args(333, 333), ""},
         {"%6vX=%3fY", "3+2iX=2.5Y", args(&c, &f), args((3 + 2i), 2.5), ""},
         {"%d%s", "123abc", args(&i, &s), args(123, "abc"), ""},
         {"%c%c%c", "2\u50c2X", args(&i, &j, &k), args('2', '\u50c2', 'X'), ""},
 
-        // Custom scanner.
+        // Custom scanners.
         {"%2e%f", "eefffff", args(&x, &y), args(Xs("ee"), Xs("fffff")), ""},
+        {"%4v%s", "12abcd", args(&z, &s), args(IntString{12, "ab"}, "cd"), ""},
 
         // Errors
         {"%t", "23 18", args(&i), nil, "bad verb"},
         {"%d %d %d", "23 18", args(&i, &j), args(23, 18), "too few operands"},
         {"%d %d", "23 18 27", args(&i, &j, &k), args(23, 18), "too many operands"},
         {"%c", "\u0100", args(&int8Val), nil, "overflow"},
         {"X%d", "10X", args(&intVal), nil, "input does not match format"},
 
         // Bad UTF-8: should see every byte.
         {"%c%c%c", "\xc2X\xc2", args(&i, &j, &k), args(utf8.RuneError, 'X', utf8.RuneError), ""},
 }
 
 func testScan(name string, t *testing.T, scan func(r io.Reader, a ...interface{}) (int, os.Error)) {
         for _, test := range scanTests {
                 var r io.Reader
                 if name == "StringReader" {
                         r = strings.NewReader(test.text)
                 } else {
                         r = newReader(test.text)
                 }
                 n, err := scan(r, test.in)
                 if err != nil {
-                        t.Errorf("%s got error scanning %q: %s", name, test.text, err)
+                        m := ""
+                        if n > 0 {
+                                m = Sprintf(" (%d fields ok)", n)
+                        }
+                        t.Errorf("%s got error scanning %q: %s%s", name, test.text, err, m)
                         continue
                 }
                 if n != 1 {
                         t.Errorf("%s count error on entry %q: got %d", name, 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()
@@ skipping 366 matching lines @@
         n, err = Sscanln(input, &tscanln)
         if n != 0 {
                 t.Errorf("Sscanln: expected 0 items; got %d: %q", n, tscanln)
         }
         if err == nil {
                 t.Error("Sscanln: expected error; got none")
         } else if err != io.ErrUnexpectedEOF {
                 t.Errorf("Sscanln: expected io.ErrUnexpectedEOF (ha!); got %s", err)
         }
 }