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