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 65 matching lines @@
         renamedComplex64Val  renamedComplex64
         renamedComplex128Val renamedComplex128
 )
 
 type FloatTest struct {
         text string
         in   float64
         out  float64
 }
 
-// IntString accepts an integer followed immediately by a string.
-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
-
 // Xs accepts any non-empty run of the verb character
 type Xs string
 
 func (x *Xs) Scan(state ScanState, verb int) os.Error {
         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 606 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)
         }
 }