Source file src/bytes/buffer_test.go

Documentation: bytes

     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  }
   675  

View as plain text