libgo/go/bufio/bufio_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 bufio
   6
   7 import (
   8         "bytes"
   9         "fmt"
  10         "io"
  11         "os"
  12         "strings"
  13         "testing"
  14         "testing/iotest"
  15         "utf8"
  16 )
  17
  18 // Reads from a reader and rot13s the result.
  19 type rot13Reader struct {
  20         r io.Reader
  21 }
  22
  23 func newRot13Reader(r io.Reader) *rot13Reader {
  24         r13 := new(rot13Reader)
  25         r13.r = r
  26         return r13
  27 }
  28
  29 func (r13 *rot13Reader) Read(p []byte) (int, os.Error) {
  30         n, e := r13.r.Read(p)
  31         if e != nil {
  32                 return n, e
  33         }
  34         for i := 0; i < n; i++ {
  35                 c := p[i] | 0x20 // lowercase byte
  36                 if 'a' <= c && c <= 'm' {
  37                         p[i] += 13
  38                 } else if 'n' <= c && c <= 'z' {
  39                         p[i] -= 13
  40                 }
  41         }
  42         return n, nil
  43 }
  44
  45 // Call ReadByte to accumulate the text of a file
  46 func readBytes(buf *Reader) string {
  47         var b [1000]byte
  48         nb := 0
  49         for {
  50                 c, e := buf.ReadByte()
  51                 if e == os.EOF {
  52                         break
  53                 }
  54                 if e != nil {
  55                         panic("Data: " + e.String())
  56                 }
  57                 b[nb] = c
  58                 nb++
  59         }
  60         return string(b[0:nb])
  61 }
  62
  63 func TestReaderSimple(t *testing.T) {
  64         data := "hello world"
  65         b := NewReader(bytes.NewBufferString(data))
  66         if s := readBytes(b); s != "hello world" {
  67                 t.Errorf("simple hello world test failed: got %q", s)
  68         }
  69
  70         b = NewReader(newRot13Reader(bytes.NewBufferString(data)))
  71         if s := readBytes(b); s != "uryyb jbeyq" {
  72                 t.Errorf("rot13 hello world test failed: got %q", s)
  73         }
  74 }
  75
  76
  77 type readMaker struct {
  78         name string
  79         fn   func(io.Reader) io.Reader
  80 }
  81
  82 var readMakers = []readMaker{
  83         {"full", func(r io.Reader) io.Reader { return r }},
  84         {"byte", iotest.OneByteReader},
  85         {"half", iotest.HalfReader},
  86         {"data+err", iotest.DataErrReader},
  87 }
  88
  89 // Call ReadString (which ends up calling everything else)
  90 // to accumulate the text of a file.
  91 func readLines(b *Reader) string {
  92         s := ""
  93         for {
  94                 s1, e := b.ReadString('\n')
  95                 if e == os.EOF {
  96                         break
  97                 }
  98                 if e != nil {
  99                         panic("GetLines: " + e.String())
 100                 }
 101                 s += s1
 102         }
 103         return s
 104 }
 105
 106 // Call Read to accumulate the text of a file
 107 func reads(buf *Reader, m int) string {
 108         var b [1000]byte
 109         nb := 0
 110         for {
 111                 n, e := buf.Read(b[nb : nb+m])
 112                 nb += n
 113                 if e == os.EOF {
 114                         break
 115                 }
 116         }
 117         return string(b[0:nb])
 118 }
 119
 120 type bufReader struct {
 121         name string
 122         fn   func(*Reader) string
 123 }
 124
 125 var bufreaders = []bufReader{
 126         {"1", func(b *Reader) string { return reads(b, 1) }},
 127         {"2", func(b *Reader) string { return reads(b, 2) }},
 128         {"3", func(b *Reader) string { return reads(b, 3) }},
 129         {"4", func(b *Reader) string { return reads(b, 4) }},
 130         {"5", func(b *Reader) string { return reads(b, 5) }},
 131         {"7", func(b *Reader) string { return reads(b, 7) }},
 132         {"bytes", readBytes},
 133         {"lines", readLines},
 134 }
 135
 136 var bufsizes = []int{
 137         1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
 138         23, 32, 46, 64, 93, 128, 1024, 4096,
 139 }
 140
 141 func TestReader(t *testing.T) {
 142         var texts [31]string
 143         str := ""
 144         all := ""
 145         for i := 0; i < len(texts)-1; i++ {
 146                 texts[i] = str + "\n"
 147                 all += texts[i]
 148                 str += string(i%26 + 'a')
 149         }
 150         texts[len(texts)-1] = all
 151
 152         for h := 0; h < len(texts); h++ {
 153                 text := texts[h]
 154                 for i := 0; i < len(readMakers); i++ {
 155                         for j := 0; j < len(bufreaders); j++ {
 156                                 for k := 0; k < len(bufsizes); k++ {
 157                                         readmaker := readMakers[i]
 158                                         bufreader := bufreaders[j]
 159                                         bufsize := bufsizes[k]
 160                                         read := readmaker.fn(bytes.NewBufferString(text))
 161                                         buf, _ := NewReaderSize(read, bufsize)
 162                                         s := bufreader.fn(buf)
 163                                         if s != text {
 164                                                 t.Errorf("reader=%s fn=%s bufsize=%d want=%q got=%q",
 165                                                         readmaker.name, bufreader.name, bufsize, text, s)
 166                                         }
 167                                 }
 168                         }
 169                 }
 170         }
 171 }
 172
 173 // A StringReader delivers its data one string segment at a time via Read.
 174 type StringReader struct {
 175         data []string
 176         step int
 177 }
 178
 179 func (r *StringReader) Read(p []byte) (n int, err os.Error) {
 180         if r.step < len(r.data) {
 181                 s := r.data[r.step]
 182                 n = copy(p, s)
 183                 r.step++
 184         } else {
 185                 err = os.EOF
 186         }
 187         return
 188 }
 189
 190 func readRuneSegments(t *testing.T, segments []string) {
 191         got := ""
 192         want := strings.Join(segments, "")
 193         r := NewReader(&StringReader{data: segments})
 194         for {
 195                 rune, _, err := r.ReadRune()
 196                 if err != nil {
 197                         if err != os.EOF {
 198                                 return
 199                         }
 200                         break
 201                 }
 202                 got += string(rune)
 203         }
 204         if got != want {
 205                 t.Errorf("segments=%v got=%s want=%s", segments, got, want)
 206         }
 207 }
 208
 209 var segmentList = [][]string{
 210         {},
 211         {""},
 212         {"日", "本語"},
 213         {"\u65e5", "\u672c", "\u8a9e"},
 214         {"\U000065e5", "\U0000672c", "\U00008a9e"},
 215         {"\xe6", "\x97\xa5\xe6", "\x9c\xac\xe8\xaa\x9e"},
 216         {"Hello", ", ", "World", "!"},
 217         {"Hello", ", ", "", "World", "!"},
 218 }
 219
 220 func TestReadRune(t *testing.T) {
 221         for _, s := range segmentList {
 222                 readRuneSegments(t, s)
 223         }
 224 }
 225
 226 func TestUnreadRune(t *testing.T) {
 227         got := ""
 228         segments := []string{"Hello, world:", "日本語"}
 229         data := strings.Join(segments, "")
 230         r := NewReader(&StringReader{data: segments})
 231         // Normal execution.
 232         for {
 233                 rune, _, err := r.ReadRune()
 234                 if err != nil {
 235                         if err != os.EOF {
 236                                 t.Error("unexpected EOF")
 237                         }
 238                         break
 239                 }
 240                 got += string(rune)
 241                 // Put it back and read it again
 242                 if err = r.UnreadRune(); err != nil {
 243                         t.Error("unexpected error on UnreadRune:", err)
 244                 }
 245                 rune1, _, err := r.ReadRune()
 246                 if err != nil {
 247                         t.Error("unexpected error reading after unreading:", err)
 248                 }
 249                 if rune != rune1 {
 250                         t.Errorf("incorrect rune after unread: got %c wanted %c", rune1, rune)
 251                 }
 252         }
 253         if got != data {
 254                 t.Errorf("want=%q got=%q", data, got)
 255         }
 256 }
 257
 258 // Test that UnreadRune fails if the preceding operation was not a ReadRune.
 259 func TestUnreadRuneError(t *testing.T) {
 260         buf := make([]byte, 3) // All runes in this test are 3 bytes long
 261         r := NewReader(&StringReader{data: []string{"日本語日本語日本語"}})
 262         if r.UnreadRune() == nil {
 263                 t.Error("expected error on UnreadRune from fresh buffer")
 264         }
 265         _, _, err := r.ReadRune()
 266         if err != nil {
 267                 t.Error("unexpected error on ReadRune (1):", err)
 268         }
 269         if err = r.UnreadRune(); err != nil {
 270                 t.Error("unexpected error on UnreadRune (1):", err)
 271         }
 272         if r.UnreadRune() == nil {
 273                 t.Error("expected error after UnreadRune (1)")
 274         }
 275         // Test error after Read.
 276         _, _, err = r.ReadRune() // reset state
 277         if err != nil {
 278                 t.Error("unexpected error on ReadRune (2):", err)
 279         }
 280         _, err = r.Read(buf)
 281         if err != nil {
 282                 t.Error("unexpected error on Read (2):", err)
 283         }
 284         if r.UnreadRune() == nil {
 285                 t.Error("expected error after Read (2)")
 286         }
 287         // Test error after ReadByte.
 288         _, _, err = r.ReadRune() // reset state
 289         if err != nil {
 290                 t.Error("unexpected error on ReadRune (2):", err)
 291         }
 292         for _ = range buf {
 293                 _, err = r.ReadByte()
 294                 if err != nil {
 295                         t.Error("unexpected error on ReadByte (2):", err)
 296                 }
 297         }
 298         if r.UnreadRune() == nil {
 299                 t.Error("expected error after ReadByte")
 300         }
 301         // Test error after UnreadByte.
 302         _, _, err = r.ReadRune() // reset state
 303         if err != nil {
 304                 t.Error("unexpected error on ReadRune (3):", err)
 305         }
 306         _, err = r.ReadByte()
 307         if err != nil {
 308                 t.Error("unexpected error on ReadByte (3):", err)
 309         }
 310         err = r.UnreadByte()
 311         if err != nil {
 312                 t.Error("unexpected error on UnreadByte (3):", err)
 313         }
 314         if r.UnreadRune() == nil {
 315                 t.Error("expected error after UnreadByte (3)")
 316         }
 317 }
 318
 319 func TestUnreadRuneAtEOF(t *testing.T) {
 320         // UnreadRune/ReadRune should error at EOF (was a bug; used to panic)
 321         r := NewReader(strings.NewReader("x"))
 322         r.ReadRune()
 323         r.ReadRune()
 324         r.UnreadRune()
 325         _, _, err := r.ReadRune()
 326         if err == nil {
 327                 t.Error("expected error at EOF")
 328         } else if err != os.EOF {
 329                 t.Error("expected EOF; got", err)
 330         }
 331 }
 332
 333 func TestReadWriteRune(t *testing.T) {
 334         const NRune = 1000
 335         byteBuf := new(bytes.Buffer)
 336         w := NewWriter(byteBuf)
 337         // Write the runes out using WriteRune
 338         buf := make([]byte, utf8.UTFMax)
 339         for rune := 0; rune < NRune; rune++ {
 340                 size := utf8.EncodeRune(rune, buf)
 341                 nbytes, err := w.WriteRune(rune)
 342                 if err != nil {
 343                         t.Fatalf("WriteRune(0x%x) error: %s", rune, err)
 344                 }
 345                 if nbytes != size {
 346                         t.Fatalf("WriteRune(0x%x) expected %d, got %d", rune, size, nbytes)
 347                 }
 348         }
 349         w.Flush()
 350
 351         r := NewReader(byteBuf)
 352         // Read them back with ReadRune
 353         for rune := 0; rune < NRune; rune++ {
 354                 size := utf8.EncodeRune(rune, buf)
 355                 nr, nbytes, err := r.ReadRune()
 356                 if nr != rune || nbytes != size || err != nil {
 357                         t.Fatalf("ReadRune(0x%x) got 0x%x,%d not 0x%x,%d (err=%s)", r, nr, nbytes, r, size, err)
 358                 }
 359         }
 360 }
 361
 362 func TestWriter(t *testing.T) {
 363         var data [8192]byte
 364
 365         for i := 0; i < len(data); i++ {
 366                 data[i] = byte(' ' + i%('~'-' '))
 367         }
 368         w := new(bytes.Buffer)
 369         for i := 0; i < len(bufsizes); i++ {
 370                 for j := 0; j < len(bufsizes); j++ {
 371                         nwrite := bufsizes[i]
 372                         bs := bufsizes[j]
 373
 374                         // Write nwrite bytes using buffer size bs.
 375                         // Check that the right amount makes it out
 376                         // and that the data is correct.
 377
 378                         w.Reset()
 379                         buf, e := NewWriterSize(w, bs)
 380                         context := fmt.Sprintf("nwrite=%d bufsize=%d", nwrite, bs)
 381                         if e != nil {
 382                                 t.Errorf("%s: NewWriterSize %d: %v", context, bs, e)
 383                                 continue
 384                         }
 385                         n, e1 := buf.Write(data[0:nwrite])
 386                         if e1 != nil || n != nwrite {
 387                                 t.Errorf("%s: buf.Write %d = %d, %v", context, nwrite, n, e1)
 388                                 continue
 389                         }
 390                         if e = buf.Flush(); e != nil {
 391                                 t.Errorf("%s: buf.Flush = %v", context, e)
 392                         }
 393
 394                         written := w.Bytes()
 395                         if len(written) != nwrite {
 396                                 t.Errorf("%s: %d bytes written", context, len(written))
 397                         }
 398                         for l := 0; l < len(written); l++ {
 399                                 if written[i] != data[i] {
 400                                         t.Errorf("%s: wrong bytes written")
 401                                         t.Errorf("want=%s", data[0:len(written)])
 402                                         t.Errorf("have=%s", written)
 403                                 }
 404                         }
 405                 }
 406         }
 407 }
 408
 409 // Check that write errors are returned properly.
 410
 411 type errorWriterTest struct {
 412         n, m   int
 413         err    os.Error
 414         expect os.Error
 415 }
 416
 417 func (w errorWriterTest) Write(p []byte) (int, os.Error) {
 418         return len(p) * w.n / w.m, w.err
 419 }
 420
 421 var errorWriterTests = []errorWriterTest{
 422         {0, 1, nil, io.ErrShortWrite},
 423         {1, 2, nil, io.ErrShortWrite},
 424         {1, 1, nil, nil},
 425         {0, 1, os.EPIPE, os.EPIPE},
 426         {1, 2, os.EPIPE, os.EPIPE},
 427         {1, 1, os.EPIPE, os.EPIPE},
 428 }
 429
 430 func TestWriteErrors(t *testing.T) {
 431         for _, w := range errorWriterTests {
 432                 buf := NewWriter(w)
 433                 _, e := buf.Write([]byte("hello world"))
 434                 if e != nil {
 435                         t.Errorf("Write hello to %v: %v", w, e)
 436                         continue
 437                 }
 438                 e = buf.Flush()
 439                 if e != w.expect {
 440                         t.Errorf("Flush %v: got %v, wanted %v", w, e, w.expect)
 441                 }
 442         }
 443 }
 444
 445 func TestNewReaderSizeIdempotent(t *testing.T) {
 446         const BufSize = 1000
 447         b, err := NewReaderSize(bytes.NewBufferString("hello world"), BufSize)
 448         if err != nil {
 449                 t.Error("NewReaderSize create fail", err)
 450         }
 451         // Does it recognize itself?
 452         b1, err2 := NewReaderSize(b, BufSize)
 453         if err2 != nil {
 454                 t.Error("NewReaderSize #2 create fail", err2)
 455         }
 456         if b1 != b {
 457                 t.Error("NewReaderSize did not detect underlying Reader")
 458         }
 459         // Does it wrap if existing buffer is too small?
 460         b2, err3 := NewReaderSize(b, 2*BufSize)
 461         if err3 != nil {
 462                 t.Error("NewReaderSize #3 create fail", err3)
 463         }
 464         if b2 == b {
 465                 t.Error("NewReaderSize did not enlarge buffer")
 466         }
 467 }
 468
 469 func TestNewWriterSizeIdempotent(t *testing.T) {
 470         const BufSize = 1000
 471         b, err := NewWriterSize(new(bytes.Buffer), BufSize)
 472         if err != nil {
 473                 t.Error("NewWriterSize create fail", err)
 474         }
 475         // Does it recognize itself?
 476         b1, err2 := NewWriterSize(b, BufSize)
 477         if err2 != nil {
 478                 t.Error("NewWriterSize #2 create fail", err2)
 479         }
 480         if b1 != b {
 481                 t.Error("NewWriterSize did not detect underlying Writer")
 482         }
 483         // Does it wrap if existing buffer is too small?
 484         b2, err3 := NewWriterSize(b, 2*BufSize)
 485         if err3 != nil {
 486                 t.Error("NewWriterSize #3 create fail", err3)
 487         }
 488         if b2 == b {
 489                 t.Error("NewWriterSize did not enlarge buffer")
 490         }
 491 }
 492
 493 func TestWriteString(t *testing.T) {
 494         const BufSize = 8
 495         buf := new(bytes.Buffer)
 496         b, err := NewWriterSize(buf, BufSize)
 497         if err != nil {
 498                 t.Error("NewWriterSize create fail", err)
 499         }
 500         b.WriteString("0")                         // easy
 501         b.WriteString("123456")                    // still easy
 502         b.WriteString("7890")                      // easy after flush
 503         b.WriteString("abcdefghijklmnopqrstuvwxy") // hard
 504         b.WriteString("z")
 505         b.Flush()
 506         if b.err != nil {
 507                 t.Error("WriteString", b.err)
 508         }
 509         s := "01234567890abcdefghijklmnopqrstuvwxyz"
 510         if string(buf.Bytes()) != s {
 511                 t.Errorf("WriteString wants %q gets %q", s, string(buf.Bytes()))
 512         }
 513 }
 514
 515 func TestBufferFull(t *testing.T) {
 516         buf, _ := NewReaderSize(strings.NewReader("hello, world"), 5)
 517         line, err := buf.ReadSlice(',')
 518         if string(line) != "hello" || err != ErrBufferFull {
 519                 t.Errorf("first ReadSlice(,) = %q, %v", line, err)
 520         }
 521         line, err = buf.ReadSlice(',')
 522         if string(line) != "," || err != nil {
 523                 t.Errorf("second ReadSlice(,) = %q, %v", line, err)
 524         }
 525 }
 526
 527 func TestPeek(t *testing.T) {
 528         p := make([]byte, 10)
 529         buf, _ := NewReaderSize(strings.NewReader("abcdefghij"), 4)
 530         if s, err := buf.Peek(1); string(s) != "a" || err != nil {
 531                 t.Fatalf("want %q got %q, err=%v", "a", string(s), err)
 532         }
 533         if s, err := buf.Peek(4); string(s) != "abcd" || err != nil {
 534                 t.Fatalf("want %q got %q, err=%v", "abcd", string(s), err)
 535         }
 536         if _, err := buf.Peek(5); err != ErrBufferFull {
 537                 t.Fatalf("want ErrBufFull got %v", err)
 538         }
 539         if _, err := buf.Read(p[0:3]); string(p[0:3]) != "abc" || err != nil {
 540                 t.Fatalf("want %q got %q, err=%v", "abc", string(p[0:3]), err)
 541         }
 542         if s, err := buf.Peek(1); string(s) != "d" || err != nil {
 543                 t.Fatalf("want %q got %q, err=%v", "d", string(s), err)
 544         }
 545         if s, err := buf.Peek(2); string(s) != "de" || err != nil {
 546                 t.Fatalf("want %q got %q, err=%v", "de", string(s), err)
 547         }
 548         if _, err := buf.Read(p[0:3]); string(p[0:3]) != "def" || err != nil {
 549                 t.Fatalf("want %q got %q, err=%v", "def", string(p[0:3]), err)
 550         }
 551         if s, err := buf.Peek(4); string(s) != "ghij" || err != nil {
 552                 t.Fatalf("want %q got %q, err=%v", "ghij", string(s), err)
 553         }
 554         if _, err := buf.Read(p[0:4]); string(p[0:4]) != "ghij" || err != nil {
 555                 t.Fatalf("want %q got %q, err=%v", "ghij", string(p[0:3]), err)
 556         }
 557         if s, err := buf.Peek(0); string(s) != "" || err != nil {
 558                 t.Fatalf("want %q got %q, err=%v", "", string(s), err)
 559         }
 560         if _, err := buf.Peek(1); err != os.EOF {
 561                 t.Fatalf("want EOF got %v", err)
 562         }
 563 }
 564
 565 func TestPeekThenUnreadRune(t *testing.T) {
 566         // This sequence used to cause a crash.
 567         r := NewReader(strings.NewReader("x"))
 568         r.ReadRune()
 569         r.Peek(1)
 570         r.UnreadRune()
 571         r.ReadRune() // Used to panic here
 572 }