Update Go library to r60.

[pf3gnuchains/gcc-fork.git] / libgo / go / fmt / scan_test.go

diff --git a/libgo/go/fmt/scan_test.go b/libgo/go/fmt/scan_test.go
index da13eb2..3f06e57 100644 (file)
--- a/libgo/go/fmt/scan_test.go
+++ b/libgo/go/fmt/scan_test.go
@@ -94,7 +94,7 @@ func (x *Xs) Scan(state ScanState, verb int) os.Error {
        }
        s := string(tok)
        if !regexp.MustCompile("^" + string(verb) + "+$").MatchString(s) {
-               return os.ErrorString("syntax error for xs")
+               return os.NewError("syntax error for xs")
        }
        *x = Xs(s)
        return nil
@@ -298,6 +298,8 @@ var scanfTests = []ScanfTest{
        // Fixed bugs
        {"%d\n", "27\n", &intVal, 27},  // ok
        {"%d\n", "28 \n", &intVal, 28}, // was: "unexpected newline"
+       {"%v", "0", &intVal, 0},        // was: "EOF"; 0 was taken as base prefix and not counted.
+       {"%v", "0", &uintVal, uint(0)}, // was: "EOF"; 0 was taken as base prefix and not counted.
 }
 
 var overflowTests = []ScanTest{
@@ -660,6 +662,68 @@ func TestEOF(t *testing.T) {
        }
 }
 
+// Verify that we see an EOF error if we run out of input.
+// This was a buglet: we used to get "expected integer".
+func TestEOFAtEndOfInput(t *testing.T) {
+       var i, j int
+       n, err := Sscanf("23", "%d %d", &i, &j)
+       if n != 1 || i != 23 {
+               t.Errorf("Sscanf expected one value of 23; got %d %d", n, i)
+       }
+       if err != os.EOF {
+               t.Errorf("Sscanf expected EOF; got %q", err)
+       }
+       n, err = Sscan("234", &i, &j)
+       if n != 1 || i != 234 {
+               t.Errorf("Sscan expected one value of 234; got %d %d", n, i)
+       }
+       if err != os.EOF {
+               t.Errorf("Sscan expected EOF; got %q", err)
+       }
+       // Trailing space is tougher.
+       n, err = Sscan("234 ", &i, &j)
+       if n != 1 || i != 234 {
+               t.Errorf("Sscan expected one value of 234; got %d %d", n, i)
+       }
+       if err != os.EOF {
+               t.Errorf("Sscan expected EOF; got %q", err)
+       }
+}
+
+var eofTests = []struct {
+       format string
+       v      interface{}
+}{
+       {"%s", &stringVal},
+       {"%q", &stringVal},
+       {"%x", &stringVal},
+       {"%v", &stringVal},
+       {"%v", &bytesVal},
+       {"%v", &intVal},
+       {"%v", &uintVal},
+       {"%v", &boolVal},
+       {"%v", &float32Val},
+       {"%v", &complex64Val},
+       {"%v", &renamedStringVal},
+       {"%v", &renamedBytesVal},
+       {"%v", &renamedIntVal},
+       {"%v", &renamedUintVal},
+       {"%v", &renamedBoolVal},
+       {"%v", &renamedFloat32Val},
+       {"%v", &renamedComplex64Val},
+}
+
+func TestEOFAllTypes(t *testing.T) {
+       for i, test := range eofTests {
+               if _, err := Sscanf("", test.format, test.v); err != os.EOF {
+                       t.Errorf("#%d: %s %T not eof on empty string: %s", i, test.format, test.v, err)
+               }
+               if _, err := Sscanf("   ", test.format, test.v); err != os.EOF {
+                       t.Errorf("#%d: %s %T not eof on trailing blanks: %s", i, test.format, test.v, err)
+               }
+       }
+}
+
 // Verify that, at least when using bufio, successive calls to Fscan do not lose runes.
 func TestUnreadRuneWithBufio(t *testing.T) {
        r := bufio.NewReader(strings.NewReader("123αb"))
@@ -756,7 +820,7 @@ func (r *RecursiveInt) Scan(state ScanState, verb int) (err os.Error) {
        next := new(RecursiveInt)
        _, err = Fscanf(state, ".%v", next)
        if err != nil {
-               if err == os.ErrorString("input does not match format") || err == io.ErrUnexpectedEOF {
+               if err == os.NewError("input does not match format") || err == io.ErrUnexpectedEOF {
                        err = nil
                }
                return