2008-09-12 17:42:53 -06:00
|
|
|
// 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.
|
|
|
|
|
2008-11-24 16:17:47 -07:00
|
|
|
package bufio
|
2008-09-12 17:42:53 -06:00
|
|
|
|
|
|
|
import (
|
|
|
|
"bufio";
|
2008-11-24 16:17:47 -07:00
|
|
|
"fmt";
|
|
|
|
"io";
|
|
|
|
"os";
|
|
|
|
"testing";
|
2008-09-12 17:42:53 -06:00
|
|
|
)
|
|
|
|
|
2008-10-07 13:31:31 -06:00
|
|
|
// Should be in language!
|
2009-01-15 17:22:57 -07:00
|
|
|
func copy(p []byte, q []byte) {
|
2008-09-12 17:42:53 -06:00
|
|
|
for i := 0; i < len(p); i++ {
|
|
|
|
p[i] = q[i]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Reads from p.
|
2009-01-15 17:22:57 -07:00
|
|
|
type byteReader struct {
|
2008-12-18 23:37:22 -07:00
|
|
|
p []byte
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
|
|
|
|
2009-01-15 17:22:57 -07:00
|
|
|
func newByteReader(p []byte) io.Read {
|
|
|
|
b := new(byteReader);
|
2008-10-07 13:31:31 -06:00
|
|
|
b.p = p;
|
2008-09-12 17:42:53 -06:00
|
|
|
return b
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:22:57 -07:00
|
|
|
func (b *byteReader) Read(p []byte) (int, *os.Error) {
|
2008-10-07 13:31:31 -06:00
|
|
|
n := len(p);
|
2008-09-12 17:42:53 -06:00
|
|
|
if n > len(b.p) {
|
|
|
|
n = len(b.p)
|
|
|
|
}
|
2009-01-15 17:22:57 -07:00
|
|
|
copy(p[0:n], b.p[0:n]);
|
2008-10-07 13:31:31 -06:00
|
|
|
b.p = b.p[n:len(b.p)];
|
2008-09-12 17:42:53 -06:00
|
|
|
return n, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Reads from p but only returns half of what you asked for.
|
2009-01-15 17:22:57 -07:00
|
|
|
type halfByteReader struct {
|
2008-12-18 23:37:22 -07:00
|
|
|
p []byte
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
|
|
|
|
2009-01-15 17:22:57 -07:00
|
|
|
func newHalfByteReader(p []byte) io.Read {
|
|
|
|
b := new(halfByteReader);
|
2008-10-07 13:31:31 -06:00
|
|
|
b.p = p;
|
2008-09-12 17:42:53 -06:00
|
|
|
return b
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:22:57 -07:00
|
|
|
func (b *halfByteReader) Read(p []byte) (int, *os.Error) {
|
2008-10-07 13:31:31 -06:00
|
|
|
n := len(p)/2;
|
2008-09-12 17:42:53 -06:00
|
|
|
if n == 0 && len(p) > 0 {
|
|
|
|
n = 1
|
|
|
|
}
|
|
|
|
if n > len(b.p) {
|
|
|
|
n = len(b.p)
|
|
|
|
}
|
2009-01-15 17:22:57 -07:00
|
|
|
copy(p[0:n], b.p[0:n]);
|
2008-10-07 13:31:31 -06:00
|
|
|
b.p = b.p[n:len(b.p)];
|
2008-09-12 17:42:53 -06:00
|
|
|
return n, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Reads from a reader and rot13s the result.
|
2009-01-15 17:22:57 -07:00
|
|
|
type rot13Reader struct {
|
2008-09-12 17:42:53 -06:00
|
|
|
r io.Read
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:22:57 -07:00
|
|
|
func newRot13Reader(r io.Read) *rot13Reader {
|
|
|
|
r13 := new(rot13Reader);
|
2008-10-07 13:31:31 -06:00
|
|
|
r13.r = r;
|
2008-09-12 17:42:53 -06:00
|
|
|
return r13
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:22:57 -07:00
|
|
|
func (r13 *rot13Reader) Read(p []byte) (int, *os.Error) {
|
2008-10-07 13:31:31 -06:00
|
|
|
n, e := r13.r.Read(p);
|
2008-09-12 17:42:53 -06:00
|
|
|
if e != nil {
|
|
|
|
return n, e
|
|
|
|
}
|
|
|
|
for i := 0; i < n; i++ {
|
|
|
|
if 'a' <= p[i] && p[i] <= 'z' || 'A' <= p[i] && p[i] <= 'Z' {
|
|
|
|
if 'a' <= p[i] && p[i] <= 'm' || 'A' <= p[i] && p[i] <= 'M' {
|
|
|
|
p[i] += 13;
|
|
|
|
} else {
|
|
|
|
p[i] -= 13;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-10-07 13:31:31 -06:00
|
|
|
return n, nil
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
|
|
|
|
2009-01-15 17:22:57 -07:00
|
|
|
type readMaker struct {
|
2008-11-24 16:17:47 -07:00
|
|
|
name string;
|
2009-01-30 15:39:31 -07:00
|
|
|
fn func([]byte) io.Read;
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
2009-03-03 09:39:12 -07:00
|
|
|
var readMakers = []readMaker {
|
|
|
|
readMaker{ "full", func(p []byte) io.Read { return newByteReader(p) } },
|
|
|
|
readMaker{ "half", func(p []byte) io.Read { return newHalfByteReader(p) } },
|
|
|
|
}
|
2008-09-12 17:42:53 -06:00
|
|
|
|
|
|
|
// Call ReadLineString (which ends up calling everything else)
|
|
|
|
// to accumulate the text of a file.
|
2009-01-15 17:22:57 -07:00
|
|
|
func readLines(b *BufRead) string {
|
2008-10-07 13:31:31 -06:00
|
|
|
s := "";
|
2008-09-12 17:42:53 -06:00
|
|
|
for {
|
2008-10-07 13:31:31 -06:00
|
|
|
s1, e := b.ReadLineString('\n', true);
|
2009-03-07 17:57:01 -07:00
|
|
|
if e == io.ErrEOF {
|
2008-09-12 17:42:53 -06:00
|
|
|
break
|
|
|
|
}
|
|
|
|
if e != nil {
|
|
|
|
panic("GetLines: "+e.String())
|
|
|
|
}
|
|
|
|
s += s1
|
|
|
|
}
|
|
|
|
return s
|
|
|
|
}
|
|
|
|
|
|
|
|
// Call ReadByte to accumulate the text of a file
|
2009-01-15 17:22:57 -07:00
|
|
|
func readBytes(buf *BufRead) string {
|
2008-09-12 17:42:53 -06:00
|
|
|
var b [1000]byte;
|
2008-10-07 13:31:31 -06:00
|
|
|
nb := 0;
|
2008-09-12 17:42:53 -06:00
|
|
|
for {
|
2008-10-07 13:31:31 -06:00
|
|
|
c, e := buf.ReadByte();
|
2009-03-07 17:57:01 -07:00
|
|
|
if e == io.ErrEOF {
|
2008-09-12 17:42:53 -06:00
|
|
|
break
|
|
|
|
}
|
|
|
|
if e != nil {
|
|
|
|
panic("GetBytes: "+e.String())
|
|
|
|
}
|
|
|
|
b[nb] = c;
|
2008-10-07 13:31:31 -06:00
|
|
|
nb++;
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
|
|
|
// BUG return string(b[0:nb]) ?
|
2009-04-06 22:14:38 -06:00
|
|
|
return string(b[0:nb])
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// Call Read to accumulate the text of a file
|
2009-01-15 17:22:57 -07:00
|
|
|
func reads(buf *BufRead, m int) string {
|
2008-09-12 17:42:53 -06:00
|
|
|
var b [1000]byte;
|
2008-10-07 13:31:31 -06:00
|
|
|
nb := 0;
|
2008-09-12 17:42:53 -06:00
|
|
|
for {
|
2008-12-18 23:37:22 -07:00
|
|
|
n, e := buf.Read(b[nb:nb+m]);
|
2008-10-07 13:31:31 -06:00
|
|
|
nb += n;
|
2009-03-07 17:57:01 -07:00
|
|
|
if e == io.ErrEOF {
|
2008-09-12 17:42:53 -06:00
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
2008-12-18 23:37:22 -07:00
|
|
|
return string(b[0:nb])
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
|
|
|
|
2009-01-15 17:22:57 -07:00
|
|
|
type bufReader struct {
|
2008-11-24 16:17:47 -07:00
|
|
|
name string;
|
2009-01-30 15:39:31 -07:00
|
|
|
fn func(*BufRead) string;
|
2008-11-24 16:17:47 -07:00
|
|
|
}
|
2009-03-03 09:39:12 -07:00
|
|
|
var bufreaders = []bufReader {
|
|
|
|
bufReader{ "1", func(b *BufRead) string { return reads(b, 1) } },
|
|
|
|
bufReader{ "2", func(b *BufRead) string { return reads(b, 2) } },
|
|
|
|
bufReader{ "3", func(b *BufRead) string { return reads(b, 3) } },
|
|
|
|
bufReader{ "4", func(b *BufRead) string { return reads(b, 4) } },
|
|
|
|
bufReader{ "5", func(b *BufRead) string { return reads(b, 5) } },
|
|
|
|
bufReader{ "7", func(b *BufRead) string { return reads(b, 7) } },
|
|
|
|
bufReader{ "bytes", readBytes },
|
|
|
|
bufReader{ "lines", readLines },
|
|
|
|
}
|
2008-09-12 17:42:53 -06:00
|
|
|
|
2009-03-03 09:39:12 -07:00
|
|
|
var bufsizes = []int {
|
2008-09-12 17:42:53 -06:00
|
|
|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
|
|
|
|
23, 32, 46, 64, 93, 128, 1024, 4096
|
2009-03-03 09:39:12 -07:00
|
|
|
}
|
2008-09-12 17:42:53 -06:00
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
func TestBufReadSimple(t *testing.T) {
|
2009-02-03 15:16:22 -07:00
|
|
|
b := NewBufRead(newByteReader(io.StringBytes("hello world")));
|
2009-01-15 17:22:57 -07:00
|
|
|
if s := readBytes(b); s != "hello world" {
|
2008-11-24 16:17:47 -07:00
|
|
|
t.Errorf("simple hello world test failed: got %q", s);
|
|
|
|
}
|
|
|
|
|
2009-02-03 15:16:22 -07:00
|
|
|
b = NewBufRead(newRot13Reader(newByteReader(io.StringBytes("hello world"))));
|
2009-01-15 17:22:57 -07:00
|
|
|
if s := readBytes(b); s != "uryyb jbeyq" {
|
2008-11-24 16:17:47 -07:00
|
|
|
t.Error("rot13 hello world test failed: got %q", s);
|
|
|
|
}
|
|
|
|
}
|
2008-10-07 13:31:31 -06:00
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
func TestBufRead(t *testing.T) {
|
2008-10-07 13:31:31 -06:00
|
|
|
var texts [31]string;
|
2008-09-12 17:42:53 -06:00
|
|
|
str := "";
|
2008-10-07 13:31:31 -06:00
|
|
|
all := "";
|
2008-09-12 17:42:53 -06:00
|
|
|
for i := 0; i < len(texts)-1; i++ {
|
|
|
|
texts[i] = str + "\n";
|
|
|
|
all += texts[i];
|
|
|
|
str += string(i%26+'a')
|
|
|
|
}
|
|
|
|
texts[len(texts)-1] = all;
|
2008-10-07 13:31:31 -06:00
|
|
|
|
2008-09-12 17:42:53 -06:00
|
|
|
for h := 0; h < len(texts); h++ {
|
|
|
|
text := texts[h];
|
2009-01-15 17:22:57 -07:00
|
|
|
textbytes := io.StringBytes(text);
|
|
|
|
for i := 0; i < len(readMakers); i++ {
|
2008-09-12 17:42:53 -06:00
|
|
|
for j := 0; j < len(bufreaders); j++ {
|
|
|
|
for k := 0; k < len(bufsizes); k++ {
|
2009-01-15 17:22:57 -07:00
|
|
|
readmaker := readMakers[i];
|
2008-11-24 16:17:47 -07:00
|
|
|
bufreader := bufreaders[j];
|
2008-09-12 17:42:53 -06:00
|
|
|
bufsize := bufsizes[k];
|
2008-11-24 16:17:47 -07:00
|
|
|
read := readmaker.fn(textbytes);
|
|
|
|
buf, e := NewBufReadSize(read, bufsize);
|
|
|
|
s := bufreader.fn(buf);
|
2008-09-12 17:42:53 -06:00
|
|
|
if s != text {
|
2008-11-24 16:17:47 -07:00
|
|
|
t.Errorf("reader=%s fn=%s bufsize=%d want=%q got=%q",
|
|
|
|
readmaker.name, bufreader.name, bufsize, text, s);
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:22:57 -07:00
|
|
|
type writeBuffer interface {
|
2008-12-18 23:37:22 -07:00
|
|
|
Write(p []byte) (int, *os.Error);
|
|
|
|
GetBytes() []byte
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// Accumulates bytes into a byte array.
|
2009-01-15 17:22:57 -07:00
|
|
|
type byteWriter struct {
|
2008-12-18 23:37:22 -07:00
|
|
|
p []byte;
|
2008-09-12 17:42:53 -06:00
|
|
|
n int
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:22:57 -07:00
|
|
|
func newByteWriter() writeBuffer {
|
|
|
|
return new(byteWriter)
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
|
|
|
|
2009-01-15 17:22:57 -07:00
|
|
|
func (w *byteWriter) Write(p []byte) (int, *os.Error) {
|
2008-09-12 17:42:53 -06:00
|
|
|
if w.p == nil {
|
2009-01-06 16:19:02 -07:00
|
|
|
w.p = make([]byte, len(p)+100)
|
2008-09-12 17:42:53 -06:00
|
|
|
} else if w.n + len(p) >= len(w.p) {
|
2009-01-06 16:19:02 -07:00
|
|
|
newp := make([]byte, len(w.p)*2 + len(p));
|
2009-01-15 17:22:57 -07:00
|
|
|
copy(newp[0:w.n], w.p[0:w.n]);
|
2008-09-12 17:42:53 -06:00
|
|
|
w.p = newp
|
|
|
|
}
|
2009-01-15 17:22:57 -07:00
|
|
|
copy(w.p[w.n:w.n+len(p)], p);
|
2008-10-07 13:31:31 -06:00
|
|
|
w.n += len(p);
|
2008-09-12 17:42:53 -06:00
|
|
|
return len(p), nil
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:22:57 -07:00
|
|
|
func (w *byteWriter) GetBytes() []byte {
|
2008-09-12 17:42:53 -06:00
|
|
|
return w.p[0:w.n]
|
|
|
|
}
|
|
|
|
|
2008-10-07 13:31:31 -06:00
|
|
|
// Accumulates bytes written into a byte array
|
2008-09-12 17:42:53 -06:00
|
|
|
// but Write only takes half of what you give it.
|
2008-11-24 16:17:47 -07:00
|
|
|
// TODO: Could toss this -- Write() is not supposed to do that.
|
2009-01-15 17:22:57 -07:00
|
|
|
type halfByteWriter struct {
|
|
|
|
bw writeBuffer
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
|
|
|
|
2009-01-15 17:22:57 -07:00
|
|
|
func newHalfByteWriter() writeBuffer {
|
|
|
|
w := new(halfByteWriter);
|
|
|
|
w.bw = newByteWriter();
|
2008-09-12 17:42:53 -06:00
|
|
|
return w
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:22:57 -07:00
|
|
|
func (w *halfByteWriter) Write(p []byte) (int, *os.Error) {
|
2008-09-12 17:42:53 -06:00
|
|
|
n := (len(p)+1) / 2;
|
|
|
|
// BUG return w.bw.Write(p[0:n])
|
2008-10-07 13:31:31 -06:00
|
|
|
r, e := w.bw.Write(p[0:n]);
|
2008-09-12 17:42:53 -06:00
|
|
|
return r, e
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:22:57 -07:00
|
|
|
func (w *halfByteWriter) GetBytes() []byte {
|
2008-09-12 17:42:53 -06:00
|
|
|
return w.bw.GetBytes()
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:22:57 -07:00
|
|
|
type writeMaker struct {
|
2008-11-24 16:17:47 -07:00
|
|
|
name string;
|
2009-01-30 15:39:31 -07:00
|
|
|
fn func()writeBuffer;
|
2008-11-24 16:17:47 -07:00
|
|
|
}
|
2009-01-20 15:40:40 -07:00
|
|
|
func TestBufWrite(t *testing.T) {
|
2008-10-07 13:31:31 -06:00
|
|
|
var data [8192]byte;
|
2008-09-12 17:42:53 -06:00
|
|
|
|
2009-03-03 09:39:12 -07:00
|
|
|
var writers = []writeMaker {
|
|
|
|
writeMaker{ "full", newByteWriter },
|
|
|
|
writeMaker{ "half", newHalfByteWriter },
|
|
|
|
};
|
2008-09-12 17:42:53 -06:00
|
|
|
|
|
|
|
for i := 0; i < len(data); i++ {
|
2008-11-24 16:17:47 -07:00
|
|
|
data[i] = byte(' '+ i%('~'-' '));
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
|
|
|
for i := 0; i < len(bufsizes); i++ {
|
|
|
|
for j := 0; j < len(bufsizes); j++ {
|
|
|
|
for k := 0; k < len(writers); k++ {
|
|
|
|
nwrite := bufsizes[i];
|
|
|
|
bs := bufsizes[j];
|
2008-10-07 13:31:31 -06:00
|
|
|
|
2008-09-12 17:42:53 -06:00
|
|
|
// Write nwrite bytes using buffer size bs.
|
|
|
|
// Check that the right amount makes it out
|
|
|
|
// and that the data is correct.
|
|
|
|
|
2008-11-24 16:17:47 -07:00
|
|
|
write := writers[k].fn();
|
|
|
|
buf, e := NewBufWriteSize(write, bs);
|
2009-01-15 14:48:11 -07:00
|
|
|
context := fmt.Sprintf("write=%s nwrite=%d bufsize=%d", writers[k].name, nwrite, bs);
|
2008-09-12 17:42:53 -06:00
|
|
|
if e != nil {
|
2008-11-24 16:17:47 -07:00
|
|
|
t.Errorf("%s: NewBufWriteSize %d: %v", context, bs, e);
|
|
|
|
continue;
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
2008-12-18 23:37:22 -07:00
|
|
|
n, e1 := buf.Write(data[0:nwrite]);
|
2008-11-24 16:17:47 -07:00
|
|
|
if e1 != nil || n != nwrite {
|
|
|
|
t.Errorf("%s: buf.Write %d = %d, %v", context, nwrite, n, e1);
|
|
|
|
continue;
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
2008-11-24 16:17:47 -07:00
|
|
|
if e = buf.Flush(); e != nil {
|
|
|
|
t.Errorf("%s: buf.Flush = %v", context, e);
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
2008-10-07 13:31:31 -06:00
|
|
|
|
2008-09-12 17:42:53 -06:00
|
|
|
written := write.GetBytes();
|
|
|
|
if len(written) != nwrite {
|
2008-11-24 16:17:47 -07:00
|
|
|
t.Errorf("%s: %d bytes written", context, len(written));
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
|
|
|
for l := 0; l < len(written); l++ {
|
|
|
|
if written[i] != data[i] {
|
2008-11-24 16:17:47 -07:00
|
|
|
t.Errorf("%s: wrong bytes written");
|
2008-12-18 23:37:22 -07:00
|
|
|
t.Errorf("want=%s", data[0:len(written)]);
|
2008-11-24 16:17:47 -07:00
|
|
|
t.Errorf("have=%s", written);
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-06 22:42:14 -06:00
|
|
|
func TestNewBufReadSizeIdempotent(t *testing.T) {
|
|
|
|
const BufSize = 1000;
|
|
|
|
b, err := NewBufReadSize(newByteReader(io.StringBytes("hello world")), BufSize);
|
|
|
|
if err != nil {
|
|
|
|
t.Error("NewBufReadSize create fail", err);
|
|
|
|
}
|
|
|
|
// Does it recognize itself?
|
|
|
|
b1, err2 := NewBufReadSize(b, BufSize);
|
|
|
|
if err2 != nil {
|
|
|
|
t.Error("NewBufReadSize #2 create fail", err2);
|
|
|
|
}
|
|
|
|
if b1 != b {
|
|
|
|
t.Error("NewBufReadSize did not detect underlying BufRead");
|
|
|
|
}
|
|
|
|
// Does it wrap if existing buffer is too small?
|
|
|
|
b2, err3 := NewBufReadSize(b, 2*BufSize);
|
|
|
|
if err3 != nil {
|
|
|
|
t.Error("NewBufReadSize #3 create fail", err3);
|
|
|
|
}
|
|
|
|
if b2 == b {
|
|
|
|
t.Error("NewBufReadSize did not enlarge buffer");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestNewBufWriteSizeIdempotent(t *testing.T) {
|
|
|
|
const BufSize = 1000;
|
|
|
|
b, err := NewBufWriteSize(newByteWriter(), BufSize);
|
|
|
|
if err != nil {
|
|
|
|
t.Error("NewBufWriteSize create fail", err);
|
|
|
|
}
|
|
|
|
// Does it recognize itself?
|
|
|
|
b1, err2 := NewBufWriteSize(b, BufSize);
|
|
|
|
if err2 != nil {
|
|
|
|
t.Error("NewBufWriteSize #2 create fail", err2);
|
|
|
|
}
|
|
|
|
if b1 != b {
|
|
|
|
t.Error("NewBufWriteSize did not detect underlying BufWrite");
|
|
|
|
}
|
|
|
|
// Does it wrap if existing buffer is too small?
|
|
|
|
b2, err3 := NewBufWriteSize(b, 2*BufSize);
|
|
|
|
if err3 != nil {
|
|
|
|
t.Error("NewBufWriteSize #3 create fail", err3);
|
|
|
|
}
|
|
|
|
if b2 == b {
|
|
|
|
t.Error("NewBufWriteSize did not enlarge buffer");
|
|
|
|
}
|
|
|
|
}
|