aboutsummaryrefslogtreecommitdiffstats
path: root/gcc-4.8.1/libgo/go/bytes/buffer_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'gcc-4.8.1/libgo/go/bytes/buffer_test.go')
-rw-r--r--gcc-4.8.1/libgo/go/bytes/buffer_test.go477
1 files changed, 0 insertions, 477 deletions
diff --git a/gcc-4.8.1/libgo/go/bytes/buffer_test.go b/gcc-4.8.1/libgo/go/bytes/buffer_test.go
deleted file mode 100644
index f9fb2625a..000000000
--- a/gcc-4.8.1/libgo/go/bytes/buffer_test.go
+++ /dev/null
@@ -1,477 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bytes_test
-
-import (
- . "bytes"
- "io"
- "math/rand"
- "runtime"
- "testing"
- "unicode/utf8"
-)
-
-const N = 10000 // make this bigger for a larger (and slower) test
-var data string // test data for write tests
-var testBytes []byte // test data; same as data but as a slice.
-
-func init() {
- testBytes = make([]byte, N)
- for i := 0; i < N; i++ {
- testBytes[i] = 'a' + byte(i%26)
- }
- data = string(testBytes)
-}
-
-// Verify that contents of buf match the string s.
-func check(t *testing.T, testname string, buf *Buffer, s string) {
- bytes := buf.Bytes()
- str := buf.String()
- if buf.Len() != len(bytes) {
- t.Errorf("%s: buf.Len() == %d, len(buf.Bytes()) == %d", testname, buf.Len(), len(bytes))
- }
-
- if buf.Len() != len(str) {
- t.Errorf("%s: buf.Len() == %d, len(buf.String()) == %d", testname, buf.Len(), len(str))
- }
-
- if buf.Len() != len(s) {
- t.Errorf("%s: buf.Len() == %d, len(s) == %d", testname, buf.Len(), len(s))
- }
-
- if string(bytes) != s {
- t.Errorf("%s: string(buf.Bytes()) == %q, s == %q", testname, string(bytes), s)
- }
-}
-
-// Fill buf through n writes of string fus.
-// The initial contents of buf corresponds to the string s;
-// the result is the final contents of buf returned as a string.
-func fillString(t *testing.T, testname string, buf *Buffer, s string, n int, fus string) string {
- check(t, testname+" (fill 1)", buf, s)
- for ; n > 0; n-- {
- m, err := buf.WriteString(fus)
- if m != len(fus) {
- t.Errorf(testname+" (fill 2): m == %d, expected %d", m, len(fus))
- }
- if err != nil {
- t.Errorf(testname+" (fill 3): err should always be nil, found err == %s", err)
- }
- s += fus
- check(t, testname+" (fill 4)", buf, s)
- }
- return s
-}
-
-// Fill buf through n writes of byte slice fub.
-// The initial contents of buf corresponds to the string s;
-// the result is the final contents of buf returned as a string.
-func fillBytes(t *testing.T, testname string, buf *Buffer, s string, n int, fub []byte) string {
- check(t, testname+" (fill 1)", buf, s)
- for ; n > 0; n-- {
- m, err := buf.Write(fub)
- if m != len(fub) {
- t.Errorf(testname+" (fill 2): m == %d, expected %d", m, len(fub))
- }
- if err != nil {
- t.Errorf(testname+" (fill 3): err should always be nil, found err == %s", err)
- }
- s += string(fub)
- check(t, testname+" (fill 4)", buf, s)
- }
- return s
-}
-
-func TestNewBuffer(t *testing.T) {
- buf := NewBuffer(testBytes)
- check(t, "NewBuffer", buf, data)
-}
-
-func TestNewBufferString(t *testing.T) {
- buf := NewBufferString(data)
- check(t, "NewBufferString", buf, data)
-}
-
-// Empty buf through repeated reads into fub.
-// The initial contents of buf corresponds to the string s.
-func empty(t *testing.T, testname string, buf *Buffer, s string, fub []byte) {
- check(t, testname+" (empty 1)", buf, s)
-
- for {
- n, err := buf.Read(fub)
- if n == 0 {
- break
- }
- if err != nil {
- t.Errorf(testname+" (empty 2): err should always be nil, found err == %s", err)
- }
- s = s[n:]
- check(t, testname+" (empty 3)", buf, s)
- }
-
- check(t, testname+" (empty 4)", buf, "")
-}
-
-func TestBasicOperations(t *testing.T) {
- var buf Buffer
-
- for i := 0; i < 5; i++ {
- check(t, "TestBasicOperations (1)", &buf, "")
-
- buf.Reset()
- check(t, "TestBasicOperations (2)", &buf, "")
-
- buf.Truncate(0)
- check(t, "TestBasicOperations (3)", &buf, "")
-
- n, err := buf.Write([]byte(data[0:1]))
- if n != 1 {
- t.Errorf("wrote 1 byte, but n == %d", n)
- }
- if err != nil {
- t.Errorf("err should always be nil, but err == %s", err)
- }
- check(t, "TestBasicOperations (4)", &buf, "a")
-
- buf.WriteByte(data[1])
- check(t, "TestBasicOperations (5)", &buf, "ab")
-
- n, err = buf.Write([]byte(data[2:26]))
- if n != 24 {
- t.Errorf("wrote 25 bytes, but n == %d", n)
- }
- check(t, "TestBasicOperations (6)", &buf, string(data[0:26]))
-
- buf.Truncate(26)
- check(t, "TestBasicOperations (7)", &buf, string(data[0:26]))
-
- buf.Truncate(20)
- check(t, "TestBasicOperations (8)", &buf, string(data[0:20]))
-
- empty(t, "TestBasicOperations (9)", &buf, string(data[0:20]), make([]byte, 5))
- empty(t, "TestBasicOperations (10)", &buf, "", make([]byte, 100))
-
- buf.WriteByte(data[1])
- c, err := buf.ReadByte()
- if err != nil {
- t.Error("ReadByte unexpected eof")
- }
- if c != data[1] {
- t.Errorf("ReadByte wrong value c=%v", c)
- }
- c, err = buf.ReadByte()
- if err == nil {
- t.Error("ReadByte unexpected not eof")
- }
- }
-}
-
-func TestLargeStringWrites(t *testing.T) {
- var buf Buffer
- limit := 30
- if testing.Short() {
- limit = 9
- }
- for i := 3; i < limit; i += 3 {
- s := fillString(t, "TestLargeWrites (1)", &buf, "", 5, data)
- empty(t, "TestLargeStringWrites (2)", &buf, s, make([]byte, len(data)/i))
- }
- check(t, "TestLargeStringWrites (3)", &buf, "")
-}
-
-func TestLargeByteWrites(t *testing.T) {
- var buf Buffer
- limit := 30
- if testing.Short() {
- limit = 9
- }
- for i := 3; i < limit; i += 3 {
- s := fillBytes(t, "TestLargeWrites (1)", &buf, "", 5, testBytes)
- empty(t, "TestLargeByteWrites (2)", &buf, s, make([]byte, len(data)/i))
- }
- check(t, "TestLargeByteWrites (3)", &buf, "")
-}
-
-func TestLargeStringReads(t *testing.T) {
- var buf Buffer
- for i := 3; i < 30; i += 3 {
- s := fillString(t, "TestLargeReads (1)", &buf, "", 5, data[0:len(data)/i])
- empty(t, "TestLargeReads (2)", &buf, s, make([]byte, len(data)))
- }
- check(t, "TestLargeStringReads (3)", &buf, "")
-}
-
-func TestLargeByteReads(t *testing.T) {
- var buf Buffer
- for i := 3; i < 30; i += 3 {
- s := fillBytes(t, "TestLargeReads (1)", &buf, "", 5, testBytes[0:len(testBytes)/i])
- empty(t, "TestLargeReads (2)", &buf, s, make([]byte, len(data)))
- }
- check(t, "TestLargeByteReads (3)", &buf, "")
-}
-
-func TestMixedReadsAndWrites(t *testing.T) {
- var buf Buffer
- s := ""
- for i := 0; i < 50; i++ {
- wlen := rand.Intn(len(data))
- if i%2 == 0 {
- s = fillString(t, "TestMixedReadsAndWrites (1)", &buf, s, 1, data[0:wlen])
- } else {
- s = fillBytes(t, "TestMixedReadsAndWrites (1)", &buf, s, 1, testBytes[0:wlen])
- }
-
- rlen := rand.Intn(len(data))
- fub := make([]byte, rlen)
- n, _ := buf.Read(fub)
- s = s[n:]
- }
- empty(t, "TestMixedReadsAndWrites (2)", &buf, s, make([]byte, buf.Len()))
-}
-
-func TestNil(t *testing.T) {
- var b *Buffer
- if b.String() != "<nil>" {
- t.Errorf("expected <nil>; got %q", b.String())
- }
-}
-
-func TestReadFrom(t *testing.T) {
- var buf Buffer
- for i := 3; i < 30; i += 3 {
- s := fillBytes(t, "TestReadFrom (1)", &buf, "", 5, testBytes[0:len(testBytes)/i])
- var b Buffer
- b.ReadFrom(&buf)
- empty(t, "TestReadFrom (2)", &b, s, make([]byte, len(data)))
- }
-}
-
-func TestWriteTo(t *testing.T) {
- var buf Buffer
- for i := 3; i < 30; i += 3 {
- s := fillBytes(t, "TestWriteTo (1)", &buf, "", 5, testBytes[0:len(testBytes)/i])
- var b Buffer
- buf.WriteTo(&b)
- empty(t, "TestWriteTo (2)", &b, s, make([]byte, len(data)))
- }
-}
-
-func TestRuneIO(t *testing.T) {
- const NRune = 1000
- // Built a test slice while we write the data
- b := make([]byte, utf8.UTFMax*NRune)
- var buf Buffer
- n := 0
- for r := rune(0); r < NRune; r++ {
- size := utf8.EncodeRune(b[n:], r)
- nbytes, err := buf.WriteRune(r)
- if err != nil {
- t.Fatalf("WriteRune(%U) error: %s", r, err)
- }
- if nbytes != size {
- t.Fatalf("WriteRune(%U) expected %d, got %d", r, size, nbytes)
- }
- n += size
- }
- b = b[0:n]
-
- // Check the resulting bytes
- if !Equal(buf.Bytes(), b) {
- t.Fatalf("incorrect result from WriteRune: %q not %q", buf.Bytes(), b)
- }
-
- p := make([]byte, utf8.UTFMax)
- // Read it back with ReadRune
- for r := rune(0); r < NRune; r++ {
- size := utf8.EncodeRune(p, r)
- nr, nbytes, err := buf.ReadRune()
- if nr != r || nbytes != size || err != nil {
- t.Fatalf("ReadRune(%U) got %U,%d not %U,%d (err=%s)", r, nr, nbytes, r, size, err)
- }
- }
-
- // Check that UnreadRune works
- buf.Reset()
- buf.Write(b)
- for r := rune(0); r < NRune; r++ {
- r1, size, _ := buf.ReadRune()
- if err := buf.UnreadRune(); err != nil {
- t.Fatalf("UnreadRune(%U) got error %q", r, err)
- }
- r2, nbytes, err := buf.ReadRune()
- if r1 != r2 || r1 != r || nbytes != size || err != nil {
- t.Fatalf("ReadRune(%U) after UnreadRune got %U,%d not %U,%d (err=%s)", r, r2, nbytes, r, size, err)
- }
- }
-}
-
-func TestNext(t *testing.T) {
- b := []byte{0, 1, 2, 3, 4}
- tmp := make([]byte, 5)
- for i := 0; i <= 5; i++ {
- for j := i; j <= 5; j++ {
- for k := 0; k <= 6; k++ {
- // 0 <= i <= j <= 5; 0 <= k <= 6
- // Check that if we start with a buffer
- // of length j at offset i and ask for
- // Next(k), we get the right bytes.
- buf := NewBuffer(b[0:j])
- n, _ := buf.Read(tmp[0:i])
- if n != i {
- t.Fatalf("Read %d returned %d", i, n)
- }
- bb := buf.Next(k)
- want := k
- if want > j-i {
- want = j - i
- }
- if len(bb) != want {
- t.Fatalf("in %d,%d: len(Next(%d)) == %d", i, j, k, len(bb))
- }
- for l, v := range bb {
- if v != byte(l+i) {
- t.Fatalf("in %d,%d: Next(%d)[%d] = %d, want %d", i, j, k, l, v, l+i)
- }
- }
- }
- }
- }
-}
-
-var readBytesTests = []struct {
- buffer string
- delim byte
- expected []string
- err error
-}{
- {"", 0, []string{""}, io.EOF},
- {"a\x00", 0, []string{"a\x00"}, nil},
- {"abbbaaaba", 'b', []string{"ab", "b", "b", "aaab"}, nil},
- {"hello\x01world", 1, []string{"hello\x01"}, nil},
- {"foo\nbar", 0, []string{"foo\nbar"}, io.EOF},
- {"alpha\nbeta\ngamma\n", '\n', []string{"alpha\n", "beta\n", "gamma\n"}, nil},
- {"alpha\nbeta\ngamma", '\n', []string{"alpha\n", "beta\n", "gamma"}, io.EOF},
-}
-
-func TestReadBytes(t *testing.T) {
- for _, test := range readBytesTests {
- buf := NewBufferString(test.buffer)
- var err error
- for _, expected := range test.expected {
- var bytes []byte
- bytes, err = buf.ReadBytes(test.delim)
- if string(bytes) != expected {
- t.Errorf("expected %q, got %q", expected, bytes)
- }
- if err != nil {
- break
- }
- }
- if err != test.err {
- t.Errorf("expected error %v, got %v", test.err, err)
- }
- }
-}
-
-func TestReadString(t *testing.T) {
- for _, test := range readBytesTests {
- buf := NewBufferString(test.buffer)
- var err error
- for _, expected := range test.expected {
- var s string
- s, err = buf.ReadString(test.delim)
- if s != expected {
- t.Errorf("expected %q, got %q", expected, s)
- }
- if err != nil {
- break
- }
- }
- if err != test.err {
- t.Errorf("expected error %v, got %v", test.err, err)
- }
- }
-}
-
-func BenchmarkReadString(b *testing.B) {
- const n = 32 << 10
-
- data := make([]byte, n)
- data[n-1] = 'x'
- b.SetBytes(int64(n))
- for i := 0; i < b.N; i++ {
- buf := NewBuffer(data)
- _, err := buf.ReadString('x')
- if err != nil {
- b.Fatal(err)
- }
- }
-}
-
-func TestGrow(t *testing.T) {
- x := []byte{'x'}
- y := []byte{'y'}
- tmp := make([]byte, 72)
- for _, startLen := range []int{0, 100, 1000, 10000, 100000} {
- xBytes := Repeat(x, startLen)
- for _, growLen := range []int{0, 100, 1000, 10000, 100000} {
- buf := NewBuffer(xBytes)
- // If we read, this affects buf.off, which is good to test.
- readBytes, _ := buf.Read(tmp)
- buf.Grow(growLen)
- yBytes := Repeat(y, growLen)
- // Check no allocation occurs in write, as long as we're single-threaded.
- var m1, m2 runtime.MemStats
- runtime.ReadMemStats(&m1)
- buf.Write(yBytes)
- runtime.ReadMemStats(&m2)
- if runtime.GOMAXPROCS(-1) == 1 && m1.Mallocs != m2.Mallocs {
- t.Errorf("allocation occurred during write")
- }
- // Check that buffer has correct data.
- if !Equal(buf.Bytes()[0:startLen-readBytes], xBytes[readBytes:]) {
- t.Errorf("bad initial data at %d %d", startLen, growLen)
- }
- if !Equal(buf.Bytes()[startLen-readBytes:startLen-readBytes+growLen], yBytes) {
- t.Errorf("bad written data at %d %d", startLen, growLen)
- }
- }
- }
-}
-
-// Was a bug: used to give EOF reading empty slice at EOF.
-func TestReadEmptyAtEOF(t *testing.T) {
- b := new(Buffer)
- slice := make([]byte, 0)
- n, err := b.Read(slice)
- if err != nil {
- t.Errorf("read error: %v", err)
- }
- if n != 0 {
- t.Errorf("wrong count; got %d want 0", n)
- }
-}
-
-func TestUnreadByte(t *testing.T) {
- b := new(Buffer)
- b.WriteString("abcdefghijklmnopqrstuvwxyz")
-
- _, err := b.ReadBytes('m')
- if err != nil {
- t.Fatalf("ReadBytes: %v", err)
- }
-
- err = b.UnreadByte()
- if err != nil {
- t.Fatalf("UnreadByte: %v", err)
- }
- c, err := b.ReadByte()
- if err != nil {
- t.Fatalf("ReadByte: %v", err)
- }
- if c != 'm' {
- t.Errorf("ReadByte = %q; want %q", c, 'm')
- }
-}