libgo/go/bytes/buffer_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 bytes_test
   6
   7 import (
   8         . "bytes"
   9         "io"
  10         "math/rand"
  11         "testing"
  12         "unicode/utf8"
  13 )
  14
  15 const N = 10000       // make this bigger for a larger (and slower) test
  16 var testString string // test data for write tests
  17 var testBytes []byte  // test data; same as testString but as a slice.
  18
  19 type negativeReader struct{}
  20
  21 func (r *negativeReader) Read([]byte) (int, error) { return -1, nil }
  22
  23 func init() {
  24         testBytes = make([]byte, N)
  25         for i := 0; i < N; i++ {
  26                 testBytes[i] = 'a' + byte(i%26)
  27         }
  28         testString = string(testBytes)
  29 }
  30
  31 // Verify that contents of buf match the string s.
  32 func check(t *testing.T, testname string, buf *Buffer, s string) {
  33         bytes := buf.Bytes()
  34         str := buf.String()
  35         if buf.Len() != len(bytes) {
  36                 t.Errorf("%s: buf.Len() == %d, len(buf.Bytes()) == %d", testname, buf.Len(), len(bytes))
  37         }
  38
  39         if buf.Len() != len(str) {
  40                 t.Errorf("%s: buf.Len() == %d, len(buf.String()) == %d", testname, buf.Len(), len(str))
  41         }
  42
  43         if buf.Len() != len(s) {
  44                 t.Errorf("%s: buf.Len() == %d, len(s) == %d", testname, buf.Len(), len(s))
  45         }
  46
  47         if string(bytes) != s {
  48                 t.Errorf("%s: string(buf.Bytes()) == %q, s == %q", testname, string(bytes), s)
  49         }
  50 }
  51
  52 // Fill buf through n writes of string fus.
  53 // The initial contents of buf corresponds to the string s;
  54 // the result is the final contents of buf returned as a string.
  55 func fillString(t *testing.T, testname string, buf *Buffer, s string, n int, fus string) string {
  56         check(t, testname+" (fill 1)", buf, s)
  57         for ; n > 0; n-- {
  58                 m, err := buf.WriteString(fus)
  59                 if m != len(fus) {
  60                         t.Errorf(testname+" (fill 2): m == %d, expected %d", m, len(fus))
  61                 }
  62                 if err != nil {
  63                         t.Errorf(testname+" (fill 3): err should always be nil, found err == %s", err)
  64                 }
  65                 s += fus
  66                 check(t, testname+" (fill 4)", buf, s)
  67         }
  68         return s
  69 }
  70
  71 // Fill buf through n writes of byte slice fub.
  72 // The initial contents of buf corresponds to the string s;
  73 // the result is the final contents of buf returned as a string.
  74 func fillBytes(t *testing.T, testname string, buf *Buffer, s string, n int, fub []byte) string {
  75         check(t, testname+" (fill 1)", buf, s)
  76         for ; n > 0; n-- {
  77                 m, err := buf.Write(fub)
  78                 if m != len(fub) {
  79                         t.Errorf(testname+" (fill 2): m == %d, expected %d", m, len(fub))
  80                 }
  81                 if err != nil {
  82                         t.Errorf(testname+" (fill 3): err should always be nil, found err == %s", err)
  83                 }
  84                 s += string(fub)
  85                 check(t, testname+" (fill 4)", buf, s)
  86         }
  87         return s
  88 }
  89
  90 func TestNewBuffer(t *testing.T) {
  91         buf := NewBuffer(testBytes)
  92         check(t, "NewBuffer", buf, testString)
  93 }
  94
  95 func TestNewBufferString(t *testing.T) {
  96         buf := NewBufferString(testString)
  97         check(t, "NewBufferString", buf, testString)
  98 }
  99
 100 // Empty buf through repeated reads into fub.
 101 // The initial contents of buf corresponds to the string s.
 102 func empty(t *testing.T, testname string, buf *Buffer, s string, fub []byte) {
 103         check(t, testname+" (empty 1)", buf, s)
 104
 105         for {
 106                 n, err := buf.Read(fub)
 107                 if n == 0 {
 108                         break
 109                 }
 110                 if err != nil {
 111                         t.Errorf(testname+" (empty 2): err should always be nil, found err == %s", err)
 112                 }
 113                 s = s[n:]
 114                 check(t, testname+" (empty 3)", buf, s)
 115         }
 116
 117         check(t, testname+" (empty 4)", buf, "")
 118 }
 119
 120 func TestBasicOperations(t *testing.T) {
 121         var buf Buffer
 122
 123         for i := 0; i < 5; i++ {
 124                 check(t, "TestBasicOperations (1)", &buf, "")
 125
 126                 buf.Reset()
 127                 check(t, "TestBasicOperations (2)", &buf, "")
 128
 129                 buf.Truncate(0)
 130                 check(t, "TestBasicOperations (3)", &buf, "")
 131
 132                 n, err := buf.Write(testBytes[0:1])
 133                 if want := 1; err != nil || n != want {
 134                         t.Errorf("Write: got (%d, %v), want (%d, %v)", n, err, want, nil)
 135                 }
 136                 check(t, "TestBasicOperations (4)", &buf, "a")
 137
 138                 buf.WriteByte(testString[1])
 139                 check(t, "TestBasicOperations (5)", &buf, "ab")
 140
 141                 n, err = buf.Write(testBytes[2:26])
 142                 if want := 24; err != nil || n != want {
 143                         t.Errorf("Write: got (%d, %v), want (%d, %v)", n, err, want, nil)
 144                 }
 145                 check(t, "TestBasicOperations (6)", &buf, testString[0:26])
 146
 147                 buf.Truncate(26)
 148                 check(t, "TestBasicOperations (7)", &buf, testString[0:26])
 149
 150                 buf.Truncate(20)
 151                 check(t, "TestBasicOperations (8)", &buf, testString[0:20])
 152
 153                 empty(t, "TestBasicOperations (9)", &buf, testString[0:20], make([]byte, 5))
 154                 empty(t, "TestBasicOperations (10)", &buf, "", make([]byte, 100))
 155
 156                 buf.WriteByte(testString[1])
 157                 c, err := buf.ReadByte()
 158                 if want := testString[1]; err != nil || c != want {
 159                         t.Errorf("ReadByte: got (%q, %v), want (%q, %v)", c, err, want, nil)
 160                 }
 161                 c, err = buf.ReadByte()
 162                 if err != io.EOF {
 163                         t.Errorf("ReadByte: got (%q, %v), want (%q, %v)", c, err, byte(0), io.EOF)
 164                 }
 165         }
 166 }
 167
 168 func TestLargeStringWrites(t *testing.T) {
 169         var buf Buffer
 170         limit := 30
 171         if testing.Short() {
 172                 limit = 9
 173         }
 174         for i := 3; i < limit; i += 3 {
 175                 s := fillString(t, "TestLargeWrites (1)", &buf, "", 5, testString)
 176                 empty(t, "TestLargeStringWrites (2)", &buf, s, make([]byte, len(testString)/i))
 177         }
 178         check(t, "TestLargeStringWrites (3)", &buf, "")
 179 }
 180
 181 func TestLargeByteWrites(t *testing.T) {
 182         var buf Buffer
 183         limit := 30
 184         if testing.Short() {
 185                 limit = 9
 186         }
 187         for i := 3; i < limit; i += 3 {
 188                 s := fillBytes(t, "TestLargeWrites (1)", &buf, "", 5, testBytes)
 189                 empty(t, "TestLargeByteWrites (2)", &buf, s, make([]byte, len(testString)/i))
 190         }
 191         check(t, "TestLargeByteWrites (3)", &buf, "")
 192 }
 193
 194 func TestLargeStringReads(t *testing.T) {
 195         var buf Buffer
 196         for i := 3; i < 30; i += 3 {
 197                 s := fillString(t, "TestLargeReads (1)", &buf, "", 5, testString[0:len(testString)/i])
 198                 empty(t, "TestLargeReads (2)", &buf, s, make([]byte, len(testString)))
 199         }
 200         check(t, "TestLargeStringReads (3)", &buf, "")
 201 }
 202
 203 func TestLargeByteReads(t *testing.T) {
 204         var buf Buffer
 205         for i := 3; i < 30; i += 3 {
 206                 s := fillBytes(t, "TestLargeReads (1)", &buf, "", 5, testBytes[0:len(testBytes)/i])
 207                 empty(t, "TestLargeReads (2)", &buf, s, make([]byte, len(testString)))
 208         }
 209         check(t, "TestLargeByteReads (3)", &buf, "")
 210 }
 211
 212 func TestMixedReadsAndWrites(t *testing.T) {
 213         var buf Buffer
 214         s := ""
 215         for i := 0; i < 50; i++ {
 216                 wlen := rand.Intn(len(testString))
 217                 if i%2 == 0 {
 218                         s = fillString(t, "TestMixedReadsAndWrites (1)", &buf, s, 1, testString[0:wlen])
 219                 } else {
 220                         s = fillBytes(t, "TestMixedReadsAndWrites (1)", &buf, s, 1, testBytes[0:wlen])
 221                 }
 222
 223                 rlen := rand.Intn(len(testString))
 224                 fub := make([]byte, rlen)
 225                 n, _ := buf.Read(fub)
 226                 s = s[n:]
 227         }
 228         empty(t, "TestMixedReadsAndWrites (2)", &buf, s, make([]byte, buf.Len()))
 229 }
 230
 231 func TestCapWithPreallocatedSlice(t *testing.T) {
 232         buf := NewBuffer(make([]byte, 10))
 233         n := buf.Cap()
 234         if n != 10 {
 235                 t.Errorf("expected 10, got %d", n)
 236         }
 237 }
 238
 239 func TestCapWithSliceAndWrittenData(t *testing.T) {
 240         buf := NewBuffer(make([]byte, 0, 10))
 241         buf.Write([]byte("test"))
 242         n := buf.Cap()
 243         if n != 10 {
 244                 t.Errorf("expected 10, got %d", n)
 245         }
 246 }
 247
 248 func TestNil(t *testing.T) {
 249         var b *Buffer
 250         if b.String() != "<nil>" {
 251                 t.Errorf("expected <nil>; got %q", b.String())
 252         }
 253 }
 254
 255 func TestReadFrom(t *testing.T) {
 256         var buf Buffer
 257         for i := 3; i < 30; i += 3 {
 258                 s := fillBytes(t, "TestReadFrom (1)", &buf, "", 5, testBytes[0:len(testBytes)/i])
 259                 var b Buffer
 260                 b.ReadFrom(&buf)
 261                 empty(t, "TestReadFrom (2)", &b, s, make([]byte, len(testString)))
 262         }
 263 }
 264
 265 type panicReader struct{ panic bool }
 266
 267 func (r panicReader) Read(p []byte) (int, error) {
 268         if r.panic {
 269                 panic(nil)
 270         }
 271         return 0, io.EOF
 272 }
 273
 274 // Make sure that an empty Buffer remains empty when
 275 // it is "grown" before a Read that panics
 276 func TestReadFromPanicReader(t *testing.T) {
 277
 278         // First verify non-panic behaviour
 279         var buf Buffer
 280         i, err := buf.ReadFrom(panicReader{})
 281         if err != nil {
 282                 t.Fatal(err)
 283         }
 284         if i != 0 {
 285                 t.Fatalf("unexpected return from bytes.ReadFrom (1): got: %d, want %d", i, 0)
 286         }
 287         check(t, "TestReadFromPanicReader (1)", &buf, "")
 288
 289         // Confirm that when Reader panics, the empty buffer remains empty
 290         var buf2 Buffer
 291         defer func() {
 292                 recover()
 293                 check(t, "TestReadFromPanicReader (2)", &buf2, "")
 294         }()
 295         buf2.ReadFrom(panicReader{panic: true})
 296 }
 297
 298 func TestReadFromNegativeReader(t *testing.T) {
 299         var b Buffer
 300         defer func() {
 301                 switch err := recover().(type) {
 302                 case nil:
 303                         t.Fatal("bytes.Buffer.ReadFrom didn't panic")
 304                 case error:
 305                         // this is the error string of errNegativeRead
 306                         wantError := "bytes.Buffer: reader returned negative count from Read"
 307                         if err.Error() != wantError {
 308                                 t.Fatalf("recovered panic: got %v, want %v", err.Error(), wantError)
 309                         }
 310                 default:
 311                         t.Fatalf("unexpected panic value: %#v", err)
 312                 }
 313         }()
 314
 315         b.ReadFrom(new(negativeReader))
 316 }
 317
 318 func TestWriteTo(t *testing.T) {
 319         var buf Buffer
 320         for i := 3; i < 30; i += 3 {
 321                 s := fillBytes(t, "TestWriteTo (1)", &buf, "", 5, testBytes[0:len(testBytes)/i])
 322                 var b Buffer
 323                 buf.WriteTo(&b)
 324                 empty(t, "TestWriteTo (2)", &b, s, make([]byte, len(testString)))
 325         }
 326 }
 327
 328 func TestRuneIO(t *testing.T) {
 329         const NRune = 1000
 330         // Built a test slice while we write the data
 331         b := make([]byte, utf8.UTFMax*NRune)
 332         var buf Buffer
 333         n := 0
 334         for r := rune(0); r < NRune; r++ {
 335                 size := utf8.EncodeRune(b[n:], r)
 336                 nbytes, err := buf.WriteRune(r)
 337                 if err != nil {
 338                         t.Fatalf("WriteRune(%U) error: %s", r, err)
 339                 }
 340                 if nbytes != size {
 341                         t.Fatalf("WriteRune(%U) expected %d, got %d", r, size, nbytes)
 342                 }
 343                 n += size
 344         }
 345         b = b[0:n]
 346
 347         // Check the resulting bytes
 348         if !Equal(buf.Bytes(), b) {
 349                 t.Fatalf("incorrect result from WriteRune: %q not %q", buf.Bytes(), b)
 350         }
 351
 352         p := make([]byte, utf8.UTFMax)
 353         // Read it back with ReadRune
 354         for r := rune(0); r < NRune; r++ {
 355                 size := utf8.EncodeRune(p, r)
 356                 nr, nbytes, err := buf.ReadRune()
 357                 if nr != r || nbytes != size || err != nil {
 358                         t.Fatalf("ReadRune(%U) got %U,%d not %U,%d (err=%s)", r, nr, nbytes, r, size, err)
 359                 }
 360         }
 361
 362         // Check that UnreadRune works
 363         buf.Reset()
 364
 365         // check at EOF
 366         if err := buf.UnreadRune(); err == nil {
 367                 t.Fatal("UnreadRune at EOF: got no error")
 368         }
 369         if _, _, err := buf.ReadRune(); err == nil {
 370                 t.Fatal("ReadRune at EOF: got no error")
 371         }
 372         if err := buf.UnreadRune(); err == nil {
 373                 t.Fatal("UnreadRune after ReadRune at EOF: got no error")
 374         }
 375
 376         // check not at EOF
 377         buf.Write(b)
 378         for r := rune(0); r < NRune; r++ {
 379                 r1, size, _ := buf.ReadRune()
 380                 if err := buf.UnreadRune(); err != nil {
 381                         t.Fatalf("UnreadRune(%U) got error %q", r, err)
 382                 }
 383                 r2, nbytes, err := buf.ReadRune()
 384                 if r1 != r2 || r1 != r || nbytes != size || err != nil {
 385                         t.Fatalf("ReadRune(%U) after UnreadRune got %U,%d not %U,%d (err=%s)", r, r2, nbytes, r, size, err)
 386                 }
 387         }
 388 }
 389
 390 func TestNext(t *testing.T) {
 391         b := []byte{0, 1, 2, 3, 4}
 392         tmp := make([]byte, 5)
 393         for i := 0; i <= 5; i++ {
 394                 for j := i; j <= 5; j++ {
 395                         for k := 0; k <= 6; k++ {
 396                                 // 0 <= i <= j <= 5; 0 <= k <= 6
 397                                 // Check that if we start with a buffer
 398                                 // of length j at offset i and ask for
 399                                 // Next(k), we get the right bytes.
 400                                 buf := NewBuffer(b[0:j])
 401                                 n, _ := buf.Read(tmp[0:i])
 402                                 if n != i {
 403                                         t.Fatalf("Read %d returned %d", i, n)
 404                                 }
 405                                 bb := buf.Next(k)
 406                                 want := k
 407                                 if want > j-i {
 408                                         want = j - i
 409                                 }
 410                                 if len(bb) != want {
 411                                         t.Fatalf("in %d,%d: len(Next(%d)) == %d", i, j, k, len(bb))
 412                                 }
 413                                 for l, v := range bb {
 414                                         if v != byte(l+i) {
 415                                                 t.Fatalf("in %d,%d: Next(%d)[%d] = %d, want %d", i, j, k, l, v, l+i)
 416                                         }
 417                                 }
 418                         }
 419                 }
 420         }
 421 }
 422
 423 var readBytesTests = []struct {
 424         buffer   string
 425         delim    byte
 426         expected []string
 427         err      error
 428 }{
 429         {"", 0, []string{""}, io.EOF},
 430         {"a\x00", 0, []string{"a\x00"}, nil},
 431         {"abbbaaaba", 'b', []string{"ab", "b", "b", "aaab"}, nil},
 432         {"hello\x01world", 1, []string{"hello\x01"}, nil},
 433         {"foo\nbar", 0, []string{"foo\nbar"}, io.EOF},
 434         {"alpha\nbeta\ngamma\n", '\n', []string{"alpha\n", "beta\n", "gamma\n"}, nil},
 435         {"alpha\nbeta\ngamma", '\n', []string{"alpha\n", "beta\n", "gamma"}, io.EOF},
 436 }
 437
 438 func TestReadBytes(t *testing.T) {
 439         for _, test := range readBytesTests {
 440                 buf := NewBufferString(test.buffer)
 441                 var err error
 442                 for _, expected := range test.expected {
 443                         var bytes []byte
 444                         bytes, err = buf.ReadBytes(test.delim)
 445                         if string(bytes) != expected {
 446                                 t.Errorf("expected %q, got %q", expected, bytes)
 447                         }
 448                         if err != nil {
 449                                 break
 450                         }
 451                 }
 452                 if err != test.err {
 453                         t.Errorf("expected error %v, got %v", test.err, err)
 454                 }
 455         }
 456 }
 457
 458 func TestReadString(t *testing.T) {
 459         for _, test := range readBytesTests {
 460                 buf := NewBufferString(test.buffer)
 461                 var err error
 462                 for _, expected := range test.expected {
 463                         var s string
 464                         s, err = buf.ReadString(test.delim)
 465                         if s != expected {
 466                                 t.Errorf("expected %q, got %q", expected, s)
 467                         }
 468                         if err != nil {
 469                                 break
 470                         }
 471                 }
 472                 if err != test.err {
 473                         t.Errorf("expected error %v, got %v", test.err, err)
 474                 }
 475         }
 476 }
 477
 478 func BenchmarkReadString(b *testing.B) {
 479         const n = 32 << 10
 480
 481         data := make([]byte, n)
 482         data[n-1] = 'x'
 483         b.SetBytes(int64(n))
 484         for i := 0; i < b.N; i++ {
 485                 buf := NewBuffer(data)
 486                 _, err := buf.ReadString('x')
 487                 if err != nil {
 488                         b.Fatal(err)
 489                 }
 490         }
 491 }
 492
 493 func TestGrow(t *testing.T) {
 494         x := []byte{'x'}
 495         y := []byte{'y'}
 496         tmp := make([]byte, 72)
 497         for _, growLen := range []int{0, 100, 1000, 10000, 100000} {
 498                 for _, startLen := range []int{0, 100, 1000, 10000, 100000} {
 499                         xBytes := Repeat(x, startLen)
 500
 501                         buf := NewBuffer(xBytes)
 502                         // If we read, this affects buf.off, which is good to test.
 503                         readBytes, _ := buf.Read(tmp)
 504                         yBytes := Repeat(y, growLen)
 505                         allocs := testing.AllocsPerRun(100, func() {
 506                                 buf.Grow(growLen)
 507                                 buf.Write(yBytes)
 508                         })
 509                         // Check no allocation occurs in write, as long as we're single-threaded.
 510                         if allocs != 0 {
 511                                 t.Errorf("allocation occurred during write")
 512                         }
 513                         // Check that buffer has correct data.
 514                         if !Equal(buf.Bytes()[0:startLen-readBytes], xBytes[readBytes:]) {
 515                                 t.Errorf("bad initial data at %d %d", startLen, growLen)
 516                         }
 517                         if !Equal(buf.Bytes()[startLen-readBytes:startLen-readBytes+growLen], yBytes) {
 518                                 t.Errorf("bad written data at %d %d", startLen, growLen)
 519                         }
 520                 }
 521         }
 522 }
 523
 524 func TestGrowOverflow(t *testing.T) {
 525         defer func() {
 526                 if err := recover(); err != ErrTooLarge {
 527                         t.Errorf("after too-large Grow, recover() = %v; want %v", err, ErrTooLarge)
 528                 }
 529         }()
 530
 531         buf := NewBuffer(make([]byte, 1))
 532         const maxInt = int(^uint(0) >> 1)
 533         buf.Grow(maxInt)
 534 }
 535
 536 // Was a bug: used to give EOF reading empty slice at EOF.
 537 func TestReadEmptyAtEOF(t *testing.T) {
 538         b := new(Buffer)
 539         slice := make([]byte, 0)
 540         n, err := b.Read(slice)
 541         if err != nil {
 542                 t.Errorf("read error: %v", err)
 543         }
 544         if n != 0 {
 545                 t.Errorf("wrong count; got %d want 0", n)
 546         }
 547 }
 548
 549 func TestUnreadByte(t *testing.T) {
 550         b := new(Buffer)
 551
 552         // check at EOF
 553         if err := b.UnreadByte(); err == nil {
 554                 t.Fatal("UnreadByte at EOF: got no error")
 555         }
 556         if _, err := b.ReadByte(); err == nil {
 557                 t.Fatal("ReadByte at EOF: got no error")
 558         }
 559         if err := b.UnreadByte(); err == nil {
 560                 t.Fatal("UnreadByte after ReadByte at EOF: got no error")
 561         }
 562
 563         // check not at EOF
 564         b.WriteString("abcdefghijklmnopqrstuvwxyz")
 565
 566         // after unsuccessful read
 567         if n, err := b.Read(nil); n != 0 || err != nil {
 568                 t.Fatalf("Read(nil) = %d,%v; want 0,nil", n, err)
 569         }
 570         if err := b.UnreadByte(); err == nil {
 571                 t.Fatal("UnreadByte after Read(nil): got no error")
 572         }
 573
 574         // after successful read
 575         if _, err := b.ReadBytes('m'); err != nil {
 576                 t.Fatalf("ReadBytes: %v", err)
 577         }
 578         if err := b.UnreadByte(); err != nil {
 579                 t.Fatalf("UnreadByte: %v", err)
 580         }
 581         c, err := b.ReadByte()
 582         if err != nil {
 583                 t.Fatalf("ReadByte: %v", err)
 584         }
 585         if c != 'm' {
 586                 t.Errorf("ReadByte = %q; want %q", c, 'm')
 587         }
 588 }
 589
 590 // Tests that we occasionally compact. Issue 5154.
 591 func TestBufferGrowth(t *testing.T) {
 592         var b Buffer
 593         buf := make([]byte, 1024)
 594         b.Write(buf[0:1])
 595         var cap0 int
 596         for i := 0; i < 5<<10; i++ {
 597                 b.Write(buf)
 598                 b.Read(buf)
 599                 if i == 0 {
 600                         cap0 = b.Cap()
 601                 }
 602         }
 603         cap1 := b.Cap()
 604         // (*Buffer).grow allows for 2x capacity slop before sliding,
 605         // so set our error threshold at 3x.
 606         if cap1 > cap0*3 {
 607                 t.Errorf("buffer cap = %d; too big (grew from %d)", cap1, cap0)
 608         }
 609 }
 610
 611 func BenchmarkWriteByte(b *testing.B) {
 612         const n = 4 << 10
 613         b.SetBytes(n)
 614         buf := NewBuffer(make([]byte, n))
 615         for i := 0; i < b.N; i++ {
 616                 buf.Reset()
 617                 for i := 0; i < n; i++ {
 618                         buf.WriteByte('x')
 619                 }
 620         }
 621 }
 622
 623 func BenchmarkWriteRune(b *testing.B) {
 624         const n = 4 << 10
 625         const r = '☺'
 626         b.SetBytes(int64(n * utf8.RuneLen(r)))
 627         buf := NewBuffer(make([]byte, n*utf8.UTFMax))
 628         for i := 0; i < b.N; i++ {
 629                 buf.Reset()
 630                 for i := 0; i < n; i++ {
 631                         buf.WriteRune(r)
 632                 }
 633         }
 634 }
 635
 636 // From Issue 5154.
 637 func BenchmarkBufferNotEmptyWriteRead(b *testing.B) {
 638         buf := make([]byte, 1024)
 639         for i := 0; i < b.N; i++ {
 640                 var b Buffer
 641                 b.Write(buf[0:1])
 642                 for i := 0; i < 5<<10; i++ {
 643                         b.Write(buf)
 644                         b.Read(buf)
 645                 }
 646         }
 647 }
 648
 649 // Check that we don't compact too often. From Issue 5154.
 650 func BenchmarkBufferFullSmallReads(b *testing.B) {
 651         buf := make([]byte, 1024)
 652         for i := 0; i < b.N; i++ {
 653                 var b Buffer
 654                 b.Write(buf)
 655                 for b.Len()+20 < b.Cap() {
 656                         b.Write(buf[:10])
 657                 }
 658                 for i := 0; i < 5<<10; i++ {
 659                         b.Read(buf[:1])
 660                         b.Write(buf[:1])
 661                 }
 662         }
 663 }