libgo/go/fmt/scan_test.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package fmt_test
   6
   7 import (
   8         "bufio"
   9         "bytes"
  10         "errors"
  11         . "fmt"
  12         "io"
  13         "math"
  14         "reflect"
  15         "regexp"
  16         "strings"
  17         "testing"
  18         "testing/iotest"
  19         "unicode/utf8"
  20 )
  21
  22 type ScanTest struct {
  23         text string
  24         in   interface{}
  25         out  interface{}
  26 }
  27
  28 type ScanfTest struct {
  29         format string
  30         text   string
  31         in     interface{}
  32         out    interface{}
  33 }
  34
  35 type ScanfMultiTest struct {
  36         format string
  37         text   string
  38         in     []interface{}
  39         out    []interface{}
  40         err    string
  41 }
  42
  43 var (
  44         boolVal              bool
  45         intVal               int
  46         int8Val              int8
  47         int16Val             int16
  48         int32Val             int32
  49         int64Val             int64
  50         uintVal              uint
  51         uint8Val             uint8
  52         uint16Val            uint16
  53         uint32Val            uint32
  54         uint64Val            uint64
  55         float32Val           float32
  56         float64Val           float64
  57         stringVal            string
  58         bytesVal             []byte
  59         runeVal              rune
  60         complex64Val         complex64
  61         complex128Val        complex128
  62         renamedBoolVal       renamedBool
  63         renamedIntVal        renamedInt
  64         renamedInt8Val       renamedInt8
  65         renamedInt16Val      renamedInt16
  66         renamedInt32Val      renamedInt32
  67         renamedInt64Val      renamedInt64
  68         renamedUintVal       renamedUint
  69         renamedUint8Val      renamedUint8
  70         renamedUint16Val     renamedUint16
  71         renamedUint32Val     renamedUint32
  72         renamedUint64Val     renamedUint64
  73         renamedUintptrVal    renamedUintptr
  74         renamedStringVal     renamedString
  75         renamedBytesVal      renamedBytes
  76         renamedFloat32Val    renamedFloat32
  77         renamedFloat64Val    renamedFloat64
  78         renamedComplex64Val  renamedComplex64
  79         renamedComplex128Val renamedComplex128
  80 )
  81
  82 // Xs accepts any non-empty run of the verb character
  83 type Xs string
  84
  85 func (x *Xs) Scan(state ScanState, verb rune) error {
  86         tok, err := state.Token(true, func(r rune) bool { return r == verb })
  87         if err != nil {
  88                 return err
  89         }
  90         s := string(tok)
  91         if !regexp.MustCompile("^" + string(verb) + "+$").MatchString(s) {
  92                 return errors.New("syntax error for xs")
  93         }
  94         *x = Xs(s)
  95         return nil
  96 }
  97
  98 var xVal Xs
  99
 100 // IntString accepts an integer followed immediately by a string.
 101 // It tests the embedding of a scan within a scan.
 102 type IntString struct {
 103         i int
 104         s string
 105 }
 106
 107 func (s *IntString) Scan(state ScanState, verb rune) error {
 108         if _, err := Fscan(state, &s.i); err != nil {
 109                 return err
 110         }
 111
 112         tok, err := state.Token(true, nil)
 113         if err != nil {
 114                 return err
 115         }
 116         s.s = string(tok)
 117         return nil
 118 }
 119
 120 var intStringVal IntString
 121
 122 var scanTests = []ScanTest{
 123         // Basic types
 124         {"T\n", &boolVal, true},  // boolean test vals toggle to be sure they are written
 125         {"F\n", &boolVal, false}, // restored to zero value
 126         {"21\n", &intVal, 21},
 127         {"0\n", &intVal, 0},
 128         {"000\n", &intVal, 0},
 129         {"0x10\n", &intVal, 0x10},
 130         {"-0x10\n", &intVal, -0x10},
 131         {"0377\n", &intVal, 0377},
 132         {"-0377\n", &intVal, -0377},
 133         {"0\n", &uintVal, uint(0)},
 134         {"000\n", &uintVal, uint(0)},
 135         {"0x10\n", &uintVal, uint(0x10)},
 136         {"0377\n", &uintVal, uint(0377)},
 137         {"22\n", &int8Val, int8(22)},
 138         {"23\n", &int16Val, int16(23)},
 139         {"24\n", &int32Val, int32(24)},
 140         {"25\n", &int64Val, int64(25)},
 141         {"127\n", &int8Val, int8(127)},
 142         {"-21\n", &intVal, -21},
 143         {"-22\n", &int8Val, int8(-22)},
 144         {"-23\n", &int16Val, int16(-23)},
 145         {"-24\n", &int32Val, int32(-24)},
 146         {"-25\n", &int64Val, int64(-25)},
 147         {"-128\n", &int8Val, int8(-128)},
 148         {"+21\n", &intVal, +21},
 149         {"+22\n", &int8Val, int8(+22)},
 150         {"+23\n", &int16Val, int16(+23)},
 151         {"+24\n", &int32Val, int32(+24)},
 152         {"+25\n", &int64Val, int64(+25)},
 153         {"+127\n", &int8Val, int8(+127)},
 154         {"26\n", &uintVal, uint(26)},
 155         {"27\n", &uint8Val, uint8(27)},
 156         {"28\n", &uint16Val, uint16(28)},
 157         {"29\n", &uint32Val, uint32(29)},
 158         {"30\n", &uint64Val, uint64(30)},
 159         {"255\n", &uint8Val, uint8(255)},
 160         {"32767\n", &int16Val, int16(32767)},
 161         {"2.3\n", &float64Val, 2.3},
 162         {"2.3e1\n", &float32Val, float32(2.3e1)},
 163         {"2.3e2\n", &float64Val, 2.3e2},
 164         {"2.3p2\n", &float64Val, 2.3 * 4},
 165         {"2.3p+2\n", &float64Val, 2.3 * 4},
 166         {"2.3p+66\n", &float64Val, 2.3 * (1 << 32) * (1 << 32) * 4},
 167         {"2.3p-66\n", &float64Val, 2.3 / ((1 << 32) * (1 << 32) * 4)},
 168         {"2.35\n", &stringVal, "2.35"},
 169         {"2345678\n", &bytesVal, []byte("2345678")},
 170         {"(3.4e1-2i)\n", &complex128Val, 3.4e1 - 2i},
 171         {"-3.45e1-3i\n", &complex64Val, complex64(-3.45e1 - 3i)},
 172         {"-.45e1-1e2i\n", &complex128Val, complex128(-.45e1 - 100i)},
 173         {"hello\n", &stringVal, "hello"},
 174
 175         // Carriage-return followed by newline. (We treat \r\n as \n always.)
 176         {"hello\r\n", &stringVal, "hello"},
 177         {"27\r\n", &uint8Val, uint8(27)},
 178
 179         // Renamed types
 180         {"true\n", &renamedBoolVal, renamedBool(true)},
 181         {"F\n", &renamedBoolVal, renamedBool(false)},
 182         {"101\n", &renamedIntVal, renamedInt(101)},
 183         {"102\n", &renamedIntVal, renamedInt(102)},
 184         {"103\n", &renamedUintVal, renamedUint(103)},
 185         {"104\n", &renamedUintVal, renamedUint(104)},
 186         {"105\n", &renamedInt8Val, renamedInt8(105)},
 187         {"106\n", &renamedInt16Val, renamedInt16(106)},
 188         {"107\n", &renamedInt32Val, renamedInt32(107)},
 189         {"108\n", &renamedInt64Val, renamedInt64(108)},
 190         {"109\n", &renamedUint8Val, renamedUint8(109)},
 191         {"110\n", &renamedUint16Val, renamedUint16(110)},
 192         {"111\n", &renamedUint32Val, renamedUint32(111)},
 193         {"112\n", &renamedUint64Val, renamedUint64(112)},
 194         {"113\n", &renamedUintptrVal, renamedUintptr(113)},
 195         {"114\n", &renamedStringVal, renamedString("114")},
 196         {"115\n", &renamedBytesVal, renamedBytes([]byte("115"))},
 197
 198         // Custom scanners.
 199         {"  vvv ", &xVal, Xs("vvv")},
 200         {" 1234hello", &intStringVal, IntString{1234, "hello"}},
 201
 202         // Fixed bugs
 203         {"2147483648\n", &int64Val, int64(2147483648)}, // was: integer overflow
 204 }
 205
 206 var scanfTests = []ScanfTest{
 207         {"%v", "TRUE\n", &boolVal, true},
 208         {"%t", "false\n", &boolVal, false},
 209         {"%v", "-71\n", &intVal, -71},
 210         {"%v", "0377\n", &intVal, 0377},
 211         {"%v", "0x44\n", &intVal, 0x44},
 212         {"%d", "72\n", &intVal, 72},
 213         {"%c", "a\n", &runeVal, 'a'},
 214         {"%c", "\u5072\n", &runeVal, '\u5072'},
 215         {"%c", "\u1234\n", &runeVal, '\u1234'},
 216         {"%d", "73\n", &int8Val, int8(73)},
 217         {"%d", "+74\n", &int16Val, int16(74)},
 218         {"%d", "75\n", &int32Val, int32(75)},
 219         {"%d", "76\n", &int64Val, int64(76)},
 220         {"%b", "1001001\n", &intVal, 73},
 221         {"%o", "075\n", &intVal, 075},
 222         {"%x", "a75\n", &intVal, 0xa75},
 223         {"%v", "71\n", &uintVal, uint(71)},
 224         {"%d", "72\n", &uintVal, uint(72)},
 225         {"%d", "73\n", &uint8Val, uint8(73)},
 226         {"%d", "74\n", &uint16Val, uint16(74)},
 227         {"%d", "75\n", &uint32Val, uint32(75)},
 228         {"%d", "76\n", &uint64Val, uint64(76)},
 229         {"%b", "1001001\n", &uintVal, uint(73)},
 230         {"%o", "075\n", &uintVal, uint(075)},
 231         {"%x", "a75\n", &uintVal, uint(0xa75)},
 232         {"%x", "A75\n", &uintVal, uint(0xa75)},
 233         {"%U", "U+1234\n", &intVal, int(0x1234)},
 234         {"%U", "U+4567\n", &uintVal, uint(0x4567)},
 235
 236         // Strings
 237         {"%s", "using-%s\n", &stringVal, "using-%s"},
 238         {"%x", "7573696e672d2578\n", &stringVal, "using-%x"},
 239         {"%X", "7573696E672D2558\n", &stringVal, "using-%X"},
 240         {"%q", `"quoted\twith\\do\u0075bl\x65s"` + "\n", &stringVal, "quoted\twith\\doubles"},
 241         {"%q", "`quoted with backs`\n", &stringVal, "quoted with backs"},
 242
 243         // Byte slices
 244         {"%s", "bytes-%s\n", &bytesVal, []byte("bytes-%s")},
 245         {"%x", "62797465732d2578\n", &bytesVal, []byte("bytes-%x")},
 246         {"%X", "62797465732D2558\n", &bytesVal, []byte("bytes-%X")},
 247         {"%q", `"bytes\rwith\vdo\u0075bl\x65s"` + "\n", &bytesVal, []byte("bytes\rwith\vdoubles")},
 248         {"%q", "`bytes with backs`\n", &bytesVal, []byte("bytes with backs")},
 249
 250         // Renamed types
 251         {"%v\n", "true\n", &renamedBoolVal, renamedBool(true)},
 252         {"%t\n", "F\n", &renamedBoolVal, renamedBool(false)},
 253         {"%v", "101\n", &renamedIntVal, renamedInt(101)},
 254         {"%c", "\u0101\n", &renamedIntVal, renamedInt('\u0101')},
 255         {"%o", "0146\n", &renamedIntVal, renamedInt(102)},
 256         {"%v", "103\n", &renamedUintVal, renamedUint(103)},
 257         {"%d", "104\n", &renamedUintVal, renamedUint(104)},
 258         {"%d", "105\n", &renamedInt8Val, renamedInt8(105)},
 259         {"%d", "106\n", &renamedInt16Val, renamedInt16(106)},
 260         {"%d", "107\n", &renamedInt32Val, renamedInt32(107)},
 261         {"%d", "108\n", &renamedInt64Val, renamedInt64(108)},
 262         {"%x", "6D\n", &renamedUint8Val, renamedUint8(109)},
 263         {"%o", "0156\n", &renamedUint16Val, renamedUint16(110)},
 264         {"%d", "111\n", &renamedUint32Val, renamedUint32(111)},
 265         {"%d", "112\n", &renamedUint64Val, renamedUint64(112)},
 266         {"%d", "113\n", &renamedUintptrVal, renamedUintptr(113)},
 267         {"%s", "114\n", &renamedStringVal, renamedString("114")},
 268         {"%q", "\"1155\"\n", &renamedBytesVal, renamedBytes([]byte("1155"))},
 269         {"%g", "116e1\n", &renamedFloat32Val, renamedFloat32(116e1)},
 270         {"%g", "-11.7e+1", &renamedFloat64Val, renamedFloat64(-11.7e+1)},
 271         {"%g", "11+6e1i\n", &renamedComplex64Val, renamedComplex64(11 + 6e1i)},
 272         {"%g", "-11.+7e+1i", &renamedComplex128Val, renamedComplex128(-11. + 7e+1i)},
 273
 274         // Interesting formats
 275         {"here is\tthe value:%d", "here is   the\tvalue:118\n", &intVal, 118},
 276         {"%% %%:%d", "% %:119\n", &intVal, 119},
 277         {"%d%%", "42%", &intVal, 42}, // %% at end of string.
 278
 279         // Corner cases
 280         {"%x", "FFFFFFFF\n", &uint32Val, uint32(0xFFFFFFFF)},
 281
 282         // Custom scanner.
 283         {"%s", "  sss ", &xVal, Xs("sss")},
 284         {"%2s", "sssss", &xVal, Xs("ss")},
 285
 286         // Fixed bugs
 287         {"%d\n", "27\n", &intVal, 27},      // ok
 288         {"%d\n", "28 \n", &intVal, 28},     // was: "unexpected newline"
 289         {"%v", "0", &intVal, 0},            // was: "EOF"; 0 was taken as base prefix and not counted.
 290         {"%v", "0", &uintVal, uint(0)},     // was: "EOF"; 0 was taken as base prefix and not counted.
 291         {"%c", " ", &uintVal, uint(' ')},   // %c must accept a blank.
 292         {"%c", "\t", &uintVal, uint('\t')}, // %c must accept any space.
 293         {"%c", "\n", &uintVal, uint('\n')}, // %c must accept any space.
 294
 295         // space handling
 296         {"%d", "27", &intVal, 27},
 297         {"%d", "27 ", &intVal, 27},
 298         {"%d", " 27", &intVal, 27},
 299         {"%d", " 27 ", &intVal, 27},
 300
 301         {"X%d", "X27", &intVal, 27},
 302         {"X%d", "X27 ", &intVal, 27},
 303         {"X%d", "X 27", &intVal, 27},
 304         {"X%d", "X 27 ", &intVal, 27},
 305
 306         {"X %d", "X27", &intVal, nil},  // expected space in input to match format
 307         {"X %d", "X27 ", &intVal, nil}, // expected space in input to match format
 308         {"X %d", "X 27", &intVal, 27},
 309         {"X %d", "X 27 ", &intVal, 27},
 310
 311         {"%dX", "27X", &intVal, 27},
 312         {"%dX", "27 X", &intVal, nil}, // input does not match format
 313         {"%dX", " 27X", &intVal, 27},
 314         {"%dX", " 27 X", &intVal, nil}, // input does not match format
 315
 316         {"%d X", "27X", &intVal, nil}, // expected space in input to match format
 317         {"%d X", "27 X", &intVal, 27},
 318         {"%d X", " 27X", &intVal, nil}, // expected space in input to match format
 319         {"%d X", " 27 X", &intVal, 27},
 320
 321         {"X %d X", "X27X", &intVal, nil},  // expected space in input to match format
 322         {"X %d X", "X27 X", &intVal, nil}, // expected space in input to match format
 323         {"X %d X", "X 27X", &intVal, nil}, // expected space in input to match format
 324         {"X %d X", "X 27 X", &intVal, 27},
 325
 326         {"X %s X", "X27X", &stringVal, nil},  // expected space in input to match format
 327         {"X %s X", "X27 X", &stringVal, nil}, // expected space in input to match format
 328         {"X %s X", "X 27X", &stringVal, nil}, // unexpected EOF
 329         {"X %s X", "X 27 X", &stringVal, "27"},
 330
 331         {"X%sX", "X27X", &stringVal, nil},   // unexpected EOF
 332         {"X%sX", "X27 X", &stringVal, nil},  // input does not match format
 333         {"X%sX", "X 27X", &stringVal, nil},  // unexpected EOF
 334         {"X%sX", "X 27 X", &stringVal, nil}, // input does not match format
 335
 336         {"X%s", "X27", &stringVal, "27"},
 337         {"X%s", "X27 ", &stringVal, "27"},
 338         {"X%s", "X 27", &stringVal, "27"},
 339         {"X%s", "X 27 ", &stringVal, "27"},
 340
 341         {"X%dX", "X27X", &intVal, 27},
 342         {"X%dX", "X27 X", &intVal, nil}, // input does not match format
 343         {"X%dX", "X 27X", &intVal, 27},
 344         {"X%dX", "X 27 X", &intVal, nil}, // input does not match format
 345
 346         {"X%dX", "X27X", &intVal, 27},
 347         {"X%dX", "X27X ", &intVal, 27},
 348         {"X%dX", " X27X", &intVal, nil},  // input does not match format
 349         {"X%dX", " X27X ", &intVal, nil}, // input does not match format
 350
 351         {"X%dX\n", "X27X", &intVal, 27},
 352         {"X%dX \n", "X27X ", &intVal, 27},
 353         {"X%dX\n", "X27X\n", &intVal, 27},
 354         {"X%dX\n", "X27X \n", &intVal, 27},
 355
 356         {"X%dX \n", "X27X", &intVal, 27},
 357         {"X%dX \n", "X27X ", &intVal, 27},
 358         {"X%dX \n", "X27X\n", &intVal, 27},
 359         {"X%dX \n", "X27X \n", &intVal, 27},
 360
 361         {"X%c", "X\n", &runeVal, '\n'},
 362         {"X%c", "X \n", &runeVal, ' '},
 363         {"X %c", "X!", &runeVal, nil},  // expected space in input to match format
 364         {"X %c", "X\n", &runeVal, nil}, // newline in input does not match format
 365         {"X %c", "X !", &runeVal, '!'},
 366         {"X %c", "X \n", &runeVal, '\n'},
 367
 368         {" X%dX", "X27X", &intVal, nil},  // expected space in input to match format
 369         {" X%dX", "X27X ", &intVal, nil}, // expected space in input to match format
 370         {" X%dX", " X27X", &intVal, 27},
 371         {" X%dX", " X27X ", &intVal, 27},
 372
 373         {"X%dX ", "X27X", &intVal, 27},
 374         {"X%dX ", "X27X ", &intVal, 27},
 375         {"X%dX ", " X27X", &intVal, nil},  // input does not match format
 376         {"X%dX ", " X27X ", &intVal, nil}, // input does not match format
 377
 378         {" X%dX ", "X27X", &intVal, nil},  // expected space in input to match format
 379         {" X%dX ", "X27X ", &intVal, nil}, // expected space in input to match format
 380         {" X%dX ", " X27X", &intVal, 27},
 381         {" X%dX ", " X27X ", &intVal, 27},
 382
 383         {"%d\nX", "27\nX", &intVal, 27},
 384         {"%dX\n X", "27X\n X", &intVal, 27},
 385 }
 386
 387 var overflowTests = []ScanTest{
 388         {"128", &int8Val, 0},
 389         {"32768", &int16Val, 0},
 390         {"-129", &int8Val, 0},
 391         {"-32769", &int16Val, 0},
 392         {"256", &uint8Val, 0},
 393         {"65536", &uint16Val, 0},
 394         {"1e100", &float32Val, 0},
 395         {"1e500", &float64Val, 0},
 396         {"(1e100+0i)", &complex64Val, 0},
 397         {"(1+1e100i)", &complex64Val, 0},
 398         {"(1-1e500i)", &complex128Val, 0},
 399 }
 400
 401 var truth bool
 402 var i, j, k int
 403 var f float64
 404 var s, t string
 405 var c complex128
 406 var x, y Xs
 407 var z IntString
 408 var r1, r2, r3 rune
 409
 410 var multiTests = []ScanfMultiTest{
 411         {"", "", []interface{}{}, []interface{}{}, ""},
 412         {"%d", "23", args(&i), args(23), ""},
 413         {"%2s%3s", "22333", args(&s, &t), args("22", "333"), ""},
 414         {"%2d%3d", "44555", args(&i, &j), args(44, 555), ""},
 415         {"%2d.%3d", "66.777", args(&i, &j), args(66, 777), ""},
 416         {"%d, %d", "23, 18", args(&i, &j), args(23, 18), ""},
 417         {"%3d22%3d", "33322333", args(&i, &j), args(333, 333), ""},
 418         {"%6vX=%3fY", "3+2iX=2.5Y", args(&c, &f), args((3 + 2i), 2.5), ""},
 419         {"%d%s", "123abc", args(&i, &s), args(123, "abc"), ""},
 420         {"%c%c%c", "2\u50c2X", args(&r1, &r2, &r3), args('2', '\u50c2', 'X'), ""},
 421         {"%5s%d", " 1234567 ", args(&s, &i), args("12345", 67), ""},
 422         {"%5s%d", " 12 34 567 ", args(&s, &i), args("12", 34), ""},
 423
 424         // Custom scanners.
 425         {"%e%f", "eefffff", args(&x, &y), args(Xs("ee"), Xs("fffff")), ""},
 426         {"%4v%s", "12abcd", args(&z, &s), args(IntString{12, "ab"}, "cd"), ""},
 427
 428         // Errors
 429         {"%t", "23 18", args(&i), nil, "bad verb"},
 430         {"%d %d %d", "23 18", args(&i, &j), args(23, 18), "too few operands"},
 431         {"%d %d", "23 18 27", args(&i, &j, &k), args(23, 18), "too many operands"},
 432         {"%c", "\u0100", args(&int8Val), nil, "overflow"},
 433         {"X%d", "10X", args(&intVal), nil, "input does not match format"},
 434         {"%d%", "42%", args(&intVal), args(42), "missing verb: % at end of format string"},
 435         {"%d% ", "42%", args(&intVal), args(42), "too few operands for format '% '"}, // Slightly odd error, but correct.
 436
 437         // Bad UTF-8: should see every byte.
 438         {"%c%c%c", "\xc2X\xc2", args(&r1, &r2, &r3), args(utf8.RuneError, 'X', utf8.RuneError), ""},
 439
 440         // Fixed bugs
 441         {"%v%v", "FALSE23", args(&truth, &i), args(false, 23), ""},
 442 }
 443
 444 var readers = []struct {
 445         name string
 446         f    func(string) io.Reader
 447 }{
 448         {"StringReader", func(s string) io.Reader {
 449                 return strings.NewReader(s)
 450         }},
 451         {"ReaderOnly", func(s string) io.Reader {
 452                 return struct{ io.Reader }{strings.NewReader(s)}
 453         }},
 454         {"OneByteReader", func(s string) io.Reader {
 455                 return iotest.OneByteReader(strings.NewReader(s))
 456         }},
 457         {"DataErrReader", func(s string) io.Reader {
 458                 return iotest.DataErrReader(strings.NewReader(s))
 459         }},
 460 }
 461
 462 func testScan(t *testing.T, f func(string) io.Reader, scan func(r io.Reader, a ...interface{}) (int, error)) {
 463         for _, test := range scanTests {
 464                 r := f(test.text)
 465                 n, err := scan(r, test.in)
 466                 if err != nil {
 467                         m := ""
 468                         if n > 0 {
 469                                 m = Sprintf(" (%d fields ok)", n)
 470                         }
 471                         t.Errorf("got error scanning %q: %s%s", test.text, err, m)
 472                         continue
 473                 }
 474                 if n != 1 {
 475                         t.Errorf("count error on entry %q: got %d", test.text, n)
 476                         continue
 477                 }
 478                 // The incoming value may be a pointer
 479                 v := reflect.ValueOf(test.in)
 480                 if p := v; p.Kind() == reflect.Ptr {
 481                         v = p.Elem()
 482                 }
 483                 val := v.Interface()
 484                 if !reflect.DeepEqual(val, test.out) {
 485                         t.Errorf("scanning %q: expected %#v got %#v, type %T", test.text, test.out, val, val)
 486                 }
 487         }
 488 }
 489
 490 func TestScan(t *testing.T) {
 491         for _, r := range readers {
 492                 t.Run(r.name, func(t *testing.T) {
 493                         testScan(t, r.f, Fscan)
 494                 })
 495         }
 496 }
 497
 498 func TestScanln(t *testing.T) {
 499         for _, r := range readers {
 500                 t.Run(r.name, func(t *testing.T) {
 501                         testScan(t, r.f, Fscanln)
 502                 })
 503         }
 504 }
 505
 506 func TestScanf(t *testing.T) {
 507         for _, test := range scanfTests {
 508                 n, err := Sscanf(test.text, test.format, test.in)
 509                 if err != nil {
 510                         if test.out != nil {
 511                                 t.Errorf("Sscanf(%q, %q): unexpected error: %v", test.text, test.format, err)
 512                         }
 513                         continue
 514                 }
 515                 if test.out == nil {
 516                         t.Errorf("Sscanf(%q, %q): unexpected success", test.text, test.format)
 517                         continue
 518                 }
 519                 if n != 1 {
 520                         t.Errorf("Sscanf(%q, %q): parsed %d field, want 1", test.text, test.format, n)
 521                         continue
 522                 }
 523                 // The incoming value may be a pointer
 524                 v := reflect.ValueOf(test.in)
 525                 if p := v; p.Kind() == reflect.Ptr {
 526                         v = p.Elem()
 527                 }
 528                 val := v.Interface()
 529                 if !reflect.DeepEqual(val, test.out) {
 530                         t.Errorf("Sscanf(%q, %q): parsed value %T(%#v), want %T(%#v)", test.text, test.format, val, val, test.out, test.out)
 531                 }
 532         }
 533 }
 534
 535 func TestScanOverflow(t *testing.T) {
 536         // different machines and different types report errors with different strings.
 537         re := regexp.MustCompile("overflow|too large|out of range|not representable")
 538         for _, test := range overflowTests {
 539                 _, err := Sscan(test.text, test.in)
 540                 if err == nil {
 541                         t.Errorf("expected overflow scanning %q", test.text)
 542                         continue
 543                 }
 544                 if !re.MatchString(err.Error()) {
 545                         t.Errorf("expected overflow error scanning %q: %s", test.text, err)
 546                 }
 547         }
 548 }
 549
 550 func verifyNaN(str string, t *testing.T) {
 551         var f float64
 552         var f32 float32
 553         var f64 float64
 554         text := str + " " + str + " " + str
 555         n, err := Fscan(strings.NewReader(text), &f, &f32, &f64)
 556         if err != nil {
 557                 t.Errorf("got error scanning %q: %s", text, err)
 558         }
 559         if n != 3 {
 560                 t.Errorf("count error scanning %q: got %d", text, n)
 561         }
 562         if !math.IsNaN(float64(f)) || !math.IsNaN(float64(f32)) || !math.IsNaN(f64) {
 563                 t.Errorf("didn't get NaNs scanning %q: got %g %g %g", text, f, f32, f64)
 564         }
 565 }
 566
 567 func TestNaN(t *testing.T) {
 568         for _, s := range []string{"nan", "NAN", "NaN"} {
 569                 verifyNaN(s, t)
 570         }
 571 }
 572
 573 func verifyInf(str string, t *testing.T) {
 574         var f float64
 575         var f32 float32
 576         var f64 float64
 577         text := str + " " + str + " " + str
 578         n, err := Fscan(strings.NewReader(text), &f, &f32, &f64)
 579         if err != nil {
 580                 t.Errorf("got error scanning %q: %s", text, err)
 581         }
 582         if n != 3 {
 583                 t.Errorf("count error scanning %q: got %d", text, n)
 584         }
 585         sign := 1
 586         if str[0] == '-' {
 587                 sign = -1
 588         }
 589         if !math.IsInf(float64(f), sign) || !math.IsInf(float64(f32), sign) || !math.IsInf(f64, sign) {
 590                 t.Errorf("didn't get right Infs scanning %q: got %g %g %g", text, f, f32, f64)
 591         }
 592 }
 593
 594 func TestInf(t *testing.T) {
 595         for _, s := range []string{"inf", "+inf", "-inf", "INF", "-INF", "+INF", "Inf", "-Inf", "+Inf"} {
 596                 verifyInf(s, t)
 597         }
 598 }
 599
 600 func testScanfMulti(t *testing.T, f func(string) io.Reader) {
 601         sliceType := reflect.TypeOf(make([]interface{}, 1))
 602         for _, test := range multiTests {
 603                 r := f(test.text)
 604                 n, err := Fscanf(r, test.format, test.in...)
 605                 if err != nil {
 606                         if test.err == "" {
 607                                 t.Errorf("got error scanning (%q, %q): %q", test.format, test.text, err)
 608                         } else if !strings.Contains(err.Error(), test.err) {
 609                                 t.Errorf("got wrong error scanning (%q, %q): %q; expected %q", test.format, test.text, err, test.err)
 610                         }
 611                         continue
 612                 }
 613                 if test.err != "" {
 614                         t.Errorf("expected error %q error scanning (%q, %q)", test.err, test.format, test.text)
 615                 }
 616                 if n != len(test.out) {
 617                         t.Errorf("count error on entry (%q, %q): expected %d got %d", test.format, test.text, len(test.out), n)
 618                         continue
 619                 }
 620                 // Convert the slice of pointers into a slice of values
 621                 resultVal := reflect.MakeSlice(sliceType, n, n)
 622                 for i := 0; i < n; i++ {
 623                         v := reflect.ValueOf(test.in[i]).Elem()
 624                         resultVal.Index(i).Set(v)
 625                 }
 626                 result := resultVal.Interface()
 627                 if !reflect.DeepEqual(result, test.out) {
 628                         t.Errorf("scanning (%q, %q): expected %#v got %#v", test.format, test.text, test.out, result)
 629                 }
 630         }
 631 }
 632
 633 func TestScanfMulti(t *testing.T) {
 634         for _, r := range readers {
 635                 t.Run(r.name, func(t *testing.T) {
 636                         testScanfMulti(t, r.f)
 637                 })
 638         }
 639 }
 640
 641 func TestScanMultiple(t *testing.T) {
 642         var a int
 643         var s string
 644         n, err := Sscan("123abc", &a, &s)
 645         if n != 2 {
 646                 t.Errorf("Sscan count error: expected 2: got %d", n)
 647         }
 648         if err != nil {
 649                 t.Errorf("Sscan expected no error; got %s", err)
 650         }
 651         if a != 123 || s != "abc" {
 652                 t.Errorf("Sscan wrong values: got (%d %q) expected (123 \"abc\")", a, s)
 653         }
 654         n, err = Sscan("asdf", &s, &a)
 655         if n != 1 {
 656                 t.Errorf("Sscan count error: expected 1: got %d", n)
 657         }
 658         if err == nil {
 659                 t.Errorf("Sscan expected error; got none: %s", err)
 660         }
 661         if s != "asdf" {
 662                 t.Errorf("Sscan wrong values: got %q expected \"asdf\"", s)
 663         }
 664 }
 665
 666 // Empty strings are not valid input when scanning a string.
 667 func TestScanEmpty(t *testing.T) {
 668         var s1, s2 string
 669         n, err := Sscan("abc", &s1, &s2)
 670         if n != 1 {
 671                 t.Errorf("Sscan count error: expected 1: got %d", n)
 672         }
 673         if err == nil {
 674                 t.Error("Sscan <one item> expected error; got none")
 675         }
 676         if s1 != "abc" {
 677                 t.Errorf("Sscan wrong values: got %q expected \"abc\"", s1)
 678         }
 679         n, err = Sscan("", &s1, &s2)
 680         if n != 0 {
 681                 t.Errorf("Sscan count error: expected 0: got %d", n)
 682         }
 683         if err == nil {
 684                 t.Error("Sscan <empty> expected error; got none")
 685         }
 686         // Quoted empty string is OK.
 687         n, err = Sscanf(`""`, "%q", &s1)
 688         if n != 1 {
 689                 t.Errorf("Sscanf count error: expected 1: got %d", n)
 690         }
 691         if err != nil {
 692                 t.Errorf("Sscanf <empty> expected no error with quoted string; got %s", err)
 693         }
 694 }
 695
 696 func TestScanNotPointer(t *testing.T) {
 697         r := strings.NewReader("1")
 698         var a int
 699         _, err := Fscan(r, a)
 700         if err == nil {
 701                 t.Error("expected error scanning non-pointer")
 702         } else if !strings.Contains(err.Error(), "pointer") {
 703                 t.Errorf("expected pointer error scanning non-pointer, got: %s", err)
 704         }
 705 }
 706
 707 func TestScanlnNoNewline(t *testing.T) {
 708         var a int
 709         _, err := Sscanln("1 x\n", &a)
 710         if err == nil {
 711                 t.Error("expected error scanning string missing newline")
 712         } else if !strings.Contains(err.Error(), "newline") {
 713                 t.Errorf("expected newline error scanning string missing newline, got: %s", err)
 714         }
 715 }
 716
 717 func TestScanlnWithMiddleNewline(t *testing.T) {
 718         r := strings.NewReader("123\n456\n")
 719         var a, b int
 720         _, err := Fscanln(r, &a, &b)
 721         if err == nil {
 722                 t.Error("expected error scanning string with extra newline")
 723         } else if !strings.Contains(err.Error(), "newline") {
 724                 t.Errorf("expected newline error scanning string with extra newline, got: %s", err)
 725         }
 726 }
 727
 728 // eofCounter is a special Reader that counts reads at end of file.
 729 type eofCounter struct {
 730         reader   *strings.Reader
 731         eofCount int
 732 }
 733
 734 func (ec *eofCounter) Read(b []byte) (n int, err error) {
 735         n, err = ec.reader.Read(b)
 736         if n == 0 {
 737                 ec.eofCount++
 738         }
 739         return
 740 }
 741
 742 // TestEOF verifies that when we scan, we see at most EOF once per call to a
 743 // Scan function, and then only when it's really an EOF.
 744 func TestEOF(t *testing.T) {
 745         ec := &eofCounter{strings.NewReader("123\n"), 0}
 746         var a int
 747         n, err := Fscanln(ec, &a)
 748         if err != nil {
 749                 t.Error("unexpected error", err)
 750         }
 751         if n != 1 {
 752                 t.Error("expected to scan one item, got", n)
 753         }
 754         if ec.eofCount != 0 {
 755                 t.Error("expected zero EOFs", ec.eofCount)
 756                 ec.eofCount = 0 // reset for next test
 757         }
 758         n, err = Fscanln(ec, &a)
 759         if err == nil {
 760                 t.Error("expected error scanning empty string")
 761         }
 762         if n != 0 {
 763                 t.Error("expected to scan zero items, got", n)
 764         }
 765         if ec.eofCount != 1 {
 766                 t.Error("expected one EOF, got", ec.eofCount)
 767         }
 768 }
 769
 770 // TestEOFAtEndOfInput verifies that we see an EOF error if we run out of input.
 771 // This was a buglet: we used to get "expected integer".
 772 func TestEOFAtEndOfInput(t *testing.T) {
 773         var i, j int
 774         n, err := Sscanf("23", "%d %d", &i, &j)
 775         if n != 1 || i != 23 {
 776                 t.Errorf("Sscanf expected one value of 23; got %d %d", n, i)
 777         }
 778         if err != io.EOF {
 779                 t.Errorf("Sscanf expected EOF; got %q", err)
 780         }
 781         n, err = Sscan("234", &i, &j)
 782         if n != 1 || i != 234 {
 783                 t.Errorf("Sscan expected one value of 234; got %d %d", n, i)
 784         }
 785         if err != io.EOF {
 786                 t.Errorf("Sscan expected EOF; got %q", err)
 787         }
 788         // Trailing space is tougher.
 789         n, err = Sscan("234 ", &i, &j)
 790         if n != 1 || i != 234 {
 791                 t.Errorf("Sscan expected one value of 234; got %d %d", n, i)
 792         }
 793         if err != io.EOF {
 794                 t.Errorf("Sscan expected EOF; got %q", err)
 795         }
 796 }
 797
 798 var eofTests = []struct {
 799         format string
 800         v      interface{}
 801 }{
 802         {"%s", &stringVal},
 803         {"%q", &stringVal},
 804         {"%x", &stringVal},
 805         {"%v", &stringVal},
 806         {"%v", &bytesVal},
 807         {"%v", &intVal},
 808         {"%v", &uintVal},
 809         {"%v", &boolVal},
 810         {"%v", &float32Val},
 811         {"%v", &complex64Val},
 812         {"%v", &renamedStringVal},
 813         {"%v", &renamedBytesVal},
 814         {"%v", &renamedIntVal},
 815         {"%v", &renamedUintVal},
 816         {"%v", &renamedBoolVal},
 817         {"%v", &renamedFloat32Val},
 818         {"%v", &renamedComplex64Val},
 819 }
 820
 821 func TestEOFAllTypes(t *testing.T) {
 822         for i, test := range eofTests {
 823                 if _, err := Sscanf("", test.format, test.v); err != io.EOF {
 824                         t.Errorf("#%d: %s %T not eof on empty string: %s", i, test.format, test.v, err)
 825                 }
 826                 if _, err := Sscanf("   ", test.format, test.v); err != io.EOF {
 827                         t.Errorf("#%d: %s %T not eof on trailing blanks: %s", i, test.format, test.v, err)
 828                 }
 829         }
 830 }
 831
 832 // TestUnreadRuneWithBufio verifies that, at least when using bufio, successive
 833 // calls to Fscan do not lose runes.
 834 func TestUnreadRuneWithBufio(t *testing.T) {
 835         r := bufio.NewReader(strings.NewReader("123αb"))
 836         var i int
 837         var a string
 838         n, err := Fscanf(r, "%d", &i)
 839         if n != 1 || err != nil {
 840                 t.Errorf("reading int expected one item, no errors; got %d %q", n, err)
 841         }
 842         if i != 123 {
 843                 t.Errorf("expected 123; got %d", i)
 844         }
 845         n, err = Fscanf(r, "%s", &a)
 846         if n != 1 || err != nil {
 847                 t.Errorf("reading string expected one item, no errors; got %d %q", n, err)
 848         }
 849         if a != "αb" {
 850                 t.Errorf("expected αb; got %q", a)
 851         }
 852 }
 853
 854 type TwoLines string
 855
 856 // Scan attempts to read two lines into the object. Scanln should prevent this
 857 // because it stops at newline; Scan and Scanf should be fine.
 858 func (t *TwoLines) Scan(state ScanState, verb rune) error {
 859         chars := make([]rune, 0, 100)
 860         for nlCount := 0; nlCount < 2; {
 861                 c, _, err := state.ReadRune()
 862                 if err != nil {
 863                         return err
 864                 }
 865                 chars = append(chars, c)
 866                 if c == '\n' {
 867                         nlCount++
 868                 }
 869         }
 870         *t = TwoLines(string(chars))
 871         return nil
 872 }
 873
 874 func TestMultiLine(t *testing.T) {
 875         input := "abc\ndef\n"
 876         // Sscan should work
 877         var tscan TwoLines
 878         n, err := Sscan(input, &tscan)
 879         if n != 1 {
 880                 t.Errorf("Sscan: expected 1 item; got %d", n)
 881         }
 882         if err != nil {
 883                 t.Errorf("Sscan: expected no error; got %s", err)
 884         }
 885         if string(tscan) != input {
 886                 t.Errorf("Sscan: expected %q; got %q", input, tscan)
 887         }
 888         // Sscanf should work
 889         var tscanf TwoLines
 890         n, err = Sscanf(input, "%s", &tscanf)
 891         if n != 1 {
 892                 t.Errorf("Sscanf: expected 1 item; got %d", n)
 893         }
 894         if err != nil {
 895                 t.Errorf("Sscanf: expected no error; got %s", err)
 896         }
 897         if string(tscanf) != input {
 898                 t.Errorf("Sscanf: expected %q; got %q", input, tscanf)
 899         }
 900         // Sscanln should not work
 901         var tscanln TwoLines
 902         n, err = Sscanln(input, &tscanln)
 903         if n != 0 {
 904                 t.Errorf("Sscanln: expected 0 items; got %d: %q", n, tscanln)
 905         }
 906         if err == nil {
 907                 t.Error("Sscanln: expected error; got none")
 908         } else if err != io.ErrUnexpectedEOF {
 909                 t.Errorf("Sscanln: expected io.ErrUnexpectedEOF (ha!); got %s", err)
 910         }
 911 }
 912
 913 // TestLineByLineFscanf tests that Fscanf does not read past newline. Issue
 914 // 3481.
 915 func TestLineByLineFscanf(t *testing.T) {
 916         r := struct{ io.Reader }{strings.NewReader("1\n2\n")}
 917         var i, j int
 918         n, err := Fscanf(r, "%v\n", &i)
 919         if n != 1 || err != nil {
 920                 t.Fatalf("first read: %d %q", n, err)
 921         }
 922         n, err = Fscanf(r, "%v\n", &j)
 923         if n != 1 || err != nil {
 924                 t.Fatalf("second read: %d %q", n, err)
 925         }
 926         if i != 1 || j != 2 {
 927                 t.Errorf("wrong values; wanted 1 2 got %d %d", i, j)
 928         }
 929 }
 930
 931 // TestScanStateCount verifies the correct byte count is returned. Issue 8512.
 932
 933 // runeScanner implements the Scanner interface for TestScanStateCount.
 934 type runeScanner struct {
 935         rune rune
 936         size int
 937 }
 938
 939 func (rs *runeScanner) Scan(state ScanState, verb rune) error {
 940         r, size, err := state.ReadRune()
 941         rs.rune = r
 942         rs.size = size
 943         return err
 944 }
 945
 946 func TestScanStateCount(t *testing.T) {
 947         var a, b, c runeScanner
 948         n, err := Sscanf("12➂", "%c%c%c", &a, &b, &c)
 949         if err != nil {
 950                 t.Fatal(err)
 951         }
 952         if n != 3 {
 953                 t.Fatalf("expected 3 items consumed, got %d", n)
 954         }
 955         if a.rune != '1' || b.rune != '2' || c.rune != '➂' {
 956                 t.Errorf("bad scan rune: %q %q %q should be '1' '2' '➂'", a.rune, b.rune, c.rune)
 957         }
 958         if a.size != 1 || b.size != 1 || c.size != 3 {
 959                 t.Errorf("bad scan size: %q %q %q should be 1 1 3", a.size, b.size, c.size)
 960         }
 961 }
 962
 963 // RecursiveInt accepts a string matching %d.%d.%d....
 964 // and parses it into a linked list.
 965 // It allows us to benchmark recursive descent style scanners.
 966 type RecursiveInt struct {
 967         i    int
 968         next *RecursiveInt
 969 }
 970
 971 func (r *RecursiveInt) Scan(state ScanState, verb rune) (err error) {
 972         _, err = Fscan(state, &r.i)
 973         if err != nil {
 974                 return
 975         }
 976         next := new(RecursiveInt)
 977         _, err = Fscanf(state, ".%v", next)
 978         if err != nil {
 979                 if err == io.ErrUnexpectedEOF {
 980                         err = nil
 981                 }
 982                 return
 983         }
 984         r.next = next
 985         return
 986 }
 987
 988 // scanInts performs the same scanning task as RecursiveInt.Scan
 989 // but without recurring through scanner, so we can compare
 990 // performance more directly.
 991 func scanInts(r *RecursiveInt, b *bytes.Buffer) (err error) {
 992         r.next = nil
 993         _, err = Fscan(b, &r.i)
 994         if err != nil {
 995                 return
 996         }
 997         c, _, err := b.ReadRune()
 998         if err != nil {
 999                 if err == io.EOF {
1000                         err = nil
1001                 }
1002                 return
1003         }
1004         if c != '.' {
1005                 return
1006         }
1007         next := new(RecursiveInt)
1008         err = scanInts(next, b)
1009         if err == nil {
1010                 r.next = next
1011         }
1012         return
1013 }
1014
1015 func makeInts(n int) []byte {
1016         var buf bytes.Buffer
1017         Fprintf(&buf, "1")
1018         for i := 1; i < n; i++ {
1019                 Fprintf(&buf, ".%d", i+1)
1020         }
1021         return buf.Bytes()
1022 }
1023
1024 func TestScanInts(t *testing.T) {
1025         testScanInts(t, scanInts)
1026         testScanInts(t, func(r *RecursiveInt, b *bytes.Buffer) (err error) {
1027                 _, err = Fscan(b, r)
1028                 return
1029         })
1030 }
1031
1032 // 800 is small enough to not overflow the stack when using gccgo on a
1033 // platform that does not support split stack.
1034 const intCount = 800
1035
1036 func testScanInts(t *testing.T, scan func(*RecursiveInt, *bytes.Buffer) error) {
1037         r := new(RecursiveInt)
1038         ints := makeInts(intCount)
1039         buf := bytes.NewBuffer(ints)
1040         err := scan(r, buf)
1041         if err != nil {
1042                 t.Error("unexpected error", err)
1043         }
1044         i := 1
1045         for ; r != nil; r = r.next {
1046                 if r.i != i {
1047                         t.Fatalf("bad scan: expected %d got %d", i, r.i)
1048                 }
1049                 i++
1050         }
1051         if i-1 != intCount {
1052                 t.Fatalf("bad scan count: expected %d got %d", intCount, i-1)
1053         }
1054 }
1055
1056 func BenchmarkScanInts(b *testing.B) {
1057         b.ResetTimer()
1058         ints := makeInts(intCount)
1059         var r RecursiveInt
1060         for i := b.N - 1; i >= 0; i-- {
1061                 buf := bytes.NewBuffer(ints)
1062                 b.StartTimer()
1063                 scanInts(&r, buf)
1064                 b.StopTimer()
1065         }
1066 }
1067
1068 func BenchmarkScanRecursiveInt(b *testing.B) {
1069         b.ResetTimer()
1070         ints := makeInts(intCount)
1071         var r RecursiveInt
1072         for i := b.N - 1; i >= 0; i-- {
1073                 buf := bytes.NewBuffer(ints)
1074                 b.StartTimer()
1075                 Fscan(buf, &r)
1076                 b.StopTimer()
1077         }
1078 }
1079
1080 func BenchmarkScanRecursiveIntReaderWrapper(b *testing.B) {
1081         b.ResetTimer()
1082         ints := makeInts(intCount)
1083         var r RecursiveInt
1084         for i := b.N - 1; i >= 0; i-- {
1085                 buf := struct{ io.Reader }{strings.NewReader(string(ints))}
1086                 b.StartTimer()
1087                 Fscan(buf, &r)
1088                 b.StopTimer()
1089         }
1090 }
1091
1092 // Issue 9124.
1093 // %x on bytes couldn't handle non-space bytes terminating the scan.
1094 func TestHexBytes(t *testing.T) {
1095         var a, b []byte
1096         n, err := Sscanf("00010203", "%x", &a)
1097         if n != 1 || err != nil {
1098                 t.Errorf("simple: got count, err = %d, %v; expected 1, nil", n, err)
1099         }
1100         check := func(msg string, x []byte) {
1101                 if len(x) != 4 {
1102                         t.Errorf("%s: bad length %d", msg, len(x))
1103                 }
1104                 for i, b := range x {
1105                         if int(b) != i {
1106                                 t.Errorf("%s: bad x[%d] = %x", msg, i, x[i])
1107                         }
1108                 }
1109         }
1110         check("simple", a)
1111         a = nil
1112
1113         n, err = Sscanf("00010203 00010203", "%x %x", &a, &b)
1114         if n != 2 || err != nil {
1115                 t.Errorf("simple pair: got count, err = %d, %v; expected 2, nil", n, err)
1116         }
1117         check("simple pair a", a)
1118         check("simple pair b", b)
1119         a = nil
1120         b = nil
1121
1122         n, err = Sscanf("00010203:", "%x", &a)
1123         if n != 1 || err != nil {
1124                 t.Errorf("colon: got count, err = %d, %v; expected 1, nil", n, err)
1125         }
1126         check("colon", a)
1127         a = nil
1128
1129         n, err = Sscanf("00010203:00010203", "%x:%x", &a, &b)
1130         if n != 2 || err != nil {
1131                 t.Errorf("colon pair: got count, err = %d, %v; expected 2, nil", n, err)
1132         }
1133         check("colon pair a", a)
1134         check("colon pair b", b)
1135         a = nil
1136         b = nil
1137
1138         // This one fails because there is a hex byte after the data,
1139         // that is, an odd number of hex input bytes.
1140         n, err = Sscanf("000102034:", "%x", &a)
1141         if n != 0 || err == nil {
1142                 t.Errorf("odd count: got count, err = %d, %v; expected 0, error", n, err)
1143         }
1144 }
1145
1146 func TestScanNewlinesAreSpaces(t *testing.T) {
1147         var a, b int
1148         var tests = []struct {
1149                 name  string
1150                 text  string
1151                 count int
1152         }{
1153                 {"newlines", "1\n2\n", 2},
1154                 {"no final newline", "1\n2", 2},
1155                 {"newlines with spaces ", "1  \n  2  \n", 2},
1156                 {"no final newline with spaces", "1  \n  2", 2},
1157         }
1158         for _, test := range tests {
1159                 n, err := Sscan(test.text, &a, &b)
1160                 if n != test.count {
1161                         t.Errorf("%s: expected to scan %d item(s), scanned %d", test.name, test.count, n)
1162                 }
1163                 if err != nil {
1164                         t.Errorf("%s: unexpected error: %s", test.name, err)
1165                 }
1166         }
1167 }
1168
1169 func TestScanlnNewlinesTerminate(t *testing.T) {
1170         var a, b int
1171         var tests = []struct {
1172                 name  string
1173                 text  string
1174                 count int
1175                 ok    bool
1176         }{
1177                 {"one line one item", "1\n", 1, false},
1178                 {"one line two items with spaces ", "   1 2    \n", 2, true},
1179                 {"one line two items no newline", "   1 2", 2, true},
1180                 {"two lines two items", "1\n2\n", 1, false},
1181         }
1182         for _, test := range tests {
1183                 n, err := Sscanln(test.text, &a, &b)
1184                 if n != test.count {
1185                         t.Errorf("%s: expected to scan %d item(s), scanned %d", test.name, test.count, n)
1186                 }
1187                 if test.ok && err != nil {
1188                         t.Errorf("%s: unexpected error: %s", test.name, err)
1189                 }
1190                 if !test.ok && err == nil {
1191                         t.Errorf("%s: expected error; got none", test.name)
1192                 }
1193         }
1194 }
1195
1196 func TestScanfNewlineMatchFormat(t *testing.T) {
1197         var a, b int
1198         var tests = []struct {
1199                 name   string
1200                 text   string
1201                 format string
1202                 count  int
1203                 ok     bool
1204         }{
1205                 {"newline in both", "1\n2", "%d\n%d\n", 2, true},
1206                 {"newline in input", "1\n2", "%d %d", 1, false},
1207                 {"space-newline in input", "1 \n2", "%d %d", 1, false},
1208                 {"newline in format", "1 2", "%d\n%d", 1, false},
1209                 {"space-newline in format", "1 2", "%d \n%d", 1, false},
1210                 {"space-newline in both", "1 \n2", "%d \n%d", 2, true},
1211                 {"extra space in format", "1\n2", "%d\n %d", 2, true},
1212                 {"two extra spaces in format", "1\n2", "%d \n %d", 2, true},
1213                 {"space vs newline 0000", "1\n2", "%d\n%d", 2, true},
1214                 {"space vs newline 0001", "1\n2", "%d\n %d", 2, true},
1215                 {"space vs newline 0010", "1\n2", "%d \n%d", 2, true},
1216                 {"space vs newline 0011", "1\n2", "%d \n %d", 2, true},
1217                 {"space vs newline 0100", "1\n 2", "%d\n%d", 2, true},
1218                 {"space vs newline 0101", "1\n 2", "%d\n%d ", 2, true},
1219                 {"space vs newline 0110", "1\n 2", "%d \n%d", 2, true},
1220                 {"space vs newline 0111", "1\n 2", "%d \n %d", 2, true},
1221                 {"space vs newline 1000", "1 \n2", "%d\n%d", 2, true},
1222                 {"space vs newline 1001", "1 \n2", "%d\n %d", 2, true},
1223                 {"space vs newline 1010", "1 \n2", "%d \n%d", 2, true},
1224                 {"space vs newline 1011", "1 \n2", "%d \n %d", 2, true},
1225                 {"space vs newline 1100", "1 \n 2", "%d\n%d", 2, true},
1226                 {"space vs newline 1101", "1 \n 2", "%d\n %d", 2, true},
1227                 {"space vs newline 1110", "1 \n 2", "%d \n%d", 2, true},
1228                 {"space vs newline 1111", "1 \n 2", "%d \n %d", 2, true},
1229                 {"space vs newline no-percent 0000", "1\n2", "1\n2", 0, true},
1230                 {"space vs newline no-percent 0001", "1\n2", "1\n 2", 0, true},
1231                 {"space vs newline no-percent 0010", "1\n2", "1 \n2", 0, true},
1232                 {"space vs newline no-percent 0011", "1\n2", "1 \n 2", 0, true},
1233                 {"space vs newline no-percent 0100", "1\n 2", "1\n2", 0, false},  // fails: space after nl in input but not pattern
1234                 {"space vs newline no-percent 0101", "1\n 2", "1\n2 ", 0, false}, // fails: space after nl in input but not pattern
1235                 {"space vs newline no-percent 0110", "1\n 2", "1 \n2", 0, false}, // fails: space after nl in input but not pattern
1236                 {"space vs newline no-percent 0111", "1\n 2", "1 \n 2", 0, true},
1237                 {"space vs newline no-percent 1000", "1 \n2", "1\n2", 0, true},
1238                 {"space vs newline no-percent 1001", "1 \n2", "1\n 2", 0, true},
1239                 {"space vs newline no-percent 1010", "1 \n2", "1 \n2", 0, true},
1240                 {"space vs newline no-percent 1011", "1 \n2", "1 \n 2", 0, true},
1241                 {"space vs newline no-percent 1100", "1 \n 2", "1\n2", 0, false}, // fails: space after nl in input but not pattern
1242                 {"space vs newline no-percent 1101", "1 \n 2", "1\n 2", 0, true},
1243                 {"space vs newline no-percent 1110", "1 \n 2", "1 \n2", 0, false}, // fails: space after nl in input but not pattern
1244                 {"space vs newline no-percent 1111", "1 \n 2", "1 \n 2", 0, true},
1245         }
1246         for _, test := range tests {
1247                 var n int
1248                 var err error
1249                 if strings.Contains(test.format, "%") {
1250                         n, err = Sscanf(test.text, test.format, &a, &b)
1251                 } else {
1252                         n, err = Sscanf(test.text, test.format)
1253                 }
1254                 if n != test.count {
1255                         t.Errorf("%s: expected to scan %d item(s), scanned %d", test.name, test.count, n)
1256                 }
1257                 if test.ok && err != nil {
1258                         t.Errorf("%s: unexpected error: %s", test.name, err)
1259                 }
1260                 if !test.ok && err == nil {
1261                         t.Errorf("%s: expected error; got none", test.name)
1262                 }
1263         }
1264 }
1265
1266 // Test for issue 12090: Was unreading at EOF, double-scanning a byte.
1267
1268 type hexBytes [2]byte
1269
1270 func (h *hexBytes) Scan(ss ScanState, verb rune) error {
1271         var b []byte
1272         _, err := Fscanf(ss, "%4x", &b)
1273         if err != nil {
1274                 panic(err) // Really shouldn't happen.
1275         }
1276         copy((*h)[:], b)
1277         return err
1278 }
1279
1280 func TestHexByte(t *testing.T) {
1281         var h hexBytes
1282         n, err := Sscanln("0123\n", &h)
1283         if err != nil {
1284                 t.Fatal(err)
1285         }
1286         if n != 1 {
1287                 t.Fatalf("expected 1 item; scanned %d", n)
1288         }
1289         if h[0] != 0x01 || h[1] != 0x23 {
1290                 t.Fatalf("expected 0123 got %x", h)
1291         }
1292 }