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

View as plain text