src/pkg/bufio/bufio_test.go - go - Git at Google

 // 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 bufio

 import (
 	"bytes";
 	"fmt";
 	"io";
 	"os";
 	"strings";
 	"testing";
 	"testing/iotest";
 )

 // Reads from a reader and rot13s the result.
 type rot13Reader struct {
 	r io.Reader;
 }

 func newRot13Reader(r io.Reader) *rot13Reader {
 	r13 := new(rot13Reader);
 	r13.r = r;
 	return r13;
 }

 func (r13 *rot13Reader) Read(p []byte) (int, os.Error) {
 	n, e := r13.r.Read(p);
 	if e != nil {
 		return n, e
 	}
 	for i := 0; i < n; i++ {
 		c := p[i] | 0x20;	// lowercase byte
 		if 'a' <= c && c <= 'm' {
 			p[i] += 13
 		} else if 'n' <= c && c <= 'z' {
 			p[i] -= 13
 		}
 	}
 	return n, nil;
 }

 // Call ReadByte to accumulate the text of a file
 func readBytes(buf *Reader) string {
 	var b [1000]byte;
 	nb := 0;
 	for {
 		c, e := buf.ReadByte();
 		if e == os.EOF {
 			break
 		}
 		if e != nil {
 			panic("Data: " + e.String())
 		}
 		b[nb] = c;
 		nb++;
 	}
 	return string(b[0:nb]);
 }

 func TestReaderSimple(t *testing.T) {
 	data := "hello world";
 	b := NewReader(bytes.NewBufferString(data));
 	if s := readBytes(b); s != "hello world" {
 		t.Errorf("simple hello world test failed: got %q", s)
 	}

 	b = NewReader(newRot13Reader(bytes.NewBufferString(data)));
 	if s := readBytes(b); s != "uryyb jbeyq" {
 		t.Error("rot13 hello world test failed: got %q", s)
 	}
 }


 type readMaker struct {
 	name	string;
 	fn	func(io.Reader) io.Reader;
 }

 var readMakers = []readMaker{
 	readMaker{"full", func(r io.Reader) io.Reader { return r }},
 	readMaker{"byte", iotest.OneByteReader},
 	readMaker{"half", iotest.HalfReader},
 	readMaker{"data+err", iotest.DataErrReader},
 }

 // Call ReadString (which ends up calling everything else)
 // to accumulate the text of a file.
 func readLines(b *Reader) string {
 	s := "";
 	for {
 		s1, e := b.ReadString('\n');
 		if e == os.EOF {
 			break
 		}
 		if e != nil {
 			panic("GetLines: " + e.String())
 		}
 		s += s1;
 	}
 	return s;
 }

 // Call Read to accumulate the text of a file
 func reads(buf *Reader, m int) string {
 	var b [1000]byte;
 	nb := 0;
 	for {
 		n, e := buf.Read(b[nb : nb+m]);
 		nb += n;
 		if e == os.EOF {
 			break
 		}
 	}
 	return string(b[0:nb]);
 }

 type bufReader struct {
 	name	string;
 	fn	func(*Reader) string;
 }

 var bufreaders = []bufReader{
 	bufReader{"1", func(b *Reader) string { return reads(b, 1) }},
 	bufReader{"2", func(b *Reader) string { return reads(b, 2) }},
 	bufReader{"3", func(b *Reader) string { return reads(b, 3) }},
 	bufReader{"4", func(b *Reader) string { return reads(b, 4) }},
 	bufReader{"5", func(b *Reader) string { return reads(b, 5) }},
 	bufReader{"7", func(b *Reader) string { return reads(b, 7) }},
 	bufReader{"bytes", readBytes},
 	bufReader{"lines", readLines},
 }

 var bufsizes = []int{
 	1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
 	23, 32, 46, 64, 93, 128, 1024, 4096,
 }

 func TestReader(t *testing.T) {
 	var texts [31]string;
 	str := "";
 	all := "";
 	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;

 	for h := 0; h < len(texts); h++ {
 		text := texts[h];
 		for i := 0; i < len(readMakers); i++ {
 			for j := 0; j < len(bufreaders); j++ {
 				for k := 0; k < len(bufsizes); k++ {
 					readmaker := readMakers[i];
 					bufreader := bufreaders[j];
 					bufsize := bufsizes[k];
 					read := readmaker.fn(bytes.NewBufferString(text));
 					buf, _ := NewReaderSize(read, bufsize);
 					s := bufreader.fn(buf);
 					if s != text {
 						t.Errorf("reader=%s fn=%s bufsize=%d want=%q got=%q",
 							readmaker.name, bufreader.name, bufsize, text, s)
 					}
 				}
 			}
 		}
 	}
 }

 // A StringReader delivers its data one string segment at a time via Read.
 type StringReader struct {
 	data	[]string;
 	step	int;
 }

 func (r *StringReader) Read(p []byte) (n int, err os.Error) {
 	if r.step < len(r.data) {
 		s := r.data[r.step];
 		for i := 0; i < len(s); i++ {
 			p[i] = s[i]
 		}
 		n = len(s);
 		r.step++;
 	} else {
 		err = os.EOF
 	}
 	return;
 }

 func readRuneSegments(t *testing.T, segments []string) {
 	got := "";
 	want := strings.Join(segments, "");
 	r := NewReader(&StringReader{data: segments});
 	for {
 		rune, _, err := r.ReadRune();
 		if err != nil {
 			if err != os.EOF {
 				return
 			}
 			break;
 		}
 		got += string(rune);
 	}
 	if got != want {
 		t.Errorf("segments=%v got=%s want=%s", segments, got, want)
 	}
 }

 var segmentList = [][]string{
 	[]string{},
 	[]string{""},
 	[]string{"日", "本語"},
 	[]string{"\u65e5", "\u672c", "\u8a9e"},
 	[]string{"\U000065e5", "\U0000672c", "\U00008a9e"},
 	[]string{"\xe6", "\x97\xa5\xe6", "\x9c\xac\xe8\xaa\x9e"},
 	[]string{"Hello", ", ", "World", "!"},
 	[]string{"Hello", ", ", "", "World", "!"},
 }

 func TestReadRune(t *testing.T) {
 	for _, s := range segmentList {
 		readRuneSegments(t, s)
 	}
 }

 func TestWriter(t *testing.T) {
 	var data [8192]byte;

 	for i := 0; i < len(data); i++ {
 		data[i] = byte(' ' + i%('~'-' '))
 	}
 	w := new(bytes.Buffer);
 	for i := 0; i < len(bufsizes); i++ {
 		for j := 0; j < len(bufsizes); j++ {
 			nwrite := bufsizes[i];
 			bs := bufsizes[j];

 			// Write nwrite bytes using buffer size bs.
 			// Check that the right amount makes it out
 			// and that the data is correct.

 			w.Reset();
 			buf, e := NewWriterSize(w, bs);
 			context := fmt.Sprintf("nwrite=%d bufsize=%d", nwrite, bs);
 			if e != nil {
 				t.Errorf("%s: NewWriterSize %d: %v", context, bs, e);
 				continue;
 			}
 			n, e1 := buf.Write(data[0:nwrite]);
 			if e1 != nil || n != nwrite {
 				t.Errorf("%s: buf.Write %d = %d, %v", context, nwrite, n, e1);
 				continue;
 			}
 			if e = buf.Flush(); e != nil {
 				t.Errorf("%s: buf.Flush = %v", context, e)
 			}

 			written := w.Bytes();
 			if len(written) != nwrite {
 				t.Errorf("%s: %d bytes written", context, len(written))
 			}
 			for l := 0; l < len(written); l++ {
 				if written[i] != data[i] {
 					t.Errorf("%s: wrong bytes written");
 					t.Errorf("want=%s", data[0:len(written)]);
 					t.Errorf("have=%s", written);
 				}
 			}
 		}
 	}
 }

 // Check that write errors are returned properly.

 type errorWriterTest struct {
 	n, m	int;
 	err	os.Error;
 	expect	os.Error;
 }

 func (w errorWriterTest) Write(p []byte) (int, os.Error) {
 	return len(p) * w.n / w.m, w.err
 }

 var errorWriterTests = []errorWriterTest{
 	errorWriterTest{0, 1, nil, io.ErrShortWrite},
 	errorWriterTest{1, 2, nil, io.ErrShortWrite},
 	errorWriterTest{1, 1, nil, nil},
 	errorWriterTest{0, 1, os.EPIPE, os.EPIPE},
 	errorWriterTest{1, 2, os.EPIPE, os.EPIPE},
 	errorWriterTest{1, 1, os.EPIPE, os.EPIPE},
 }

 func TestWriteErrors(t *testing.T) {
 	for _, w := range errorWriterTests {
 		buf := NewWriter(w);
 		_, e := buf.Write(strings.Bytes("hello world"));
 		if e != nil {
 			t.Errorf("Write hello to %v: %v", w, e);
 			continue;
 		}
 		e = buf.Flush();
 		if e != w.expect {
 			t.Errorf("Flush %v: got %v, wanted %v", w, e, w.expect)
 		}
 	}
 }

 func TestNewReaderSizeIdempotent(t *testing.T) {
 	const BufSize = 1000;
 	b, err := NewReaderSize(bytes.NewBufferString("hello world"), BufSize);
 	if err != nil {
 		t.Error("NewReaderSize create fail", err)
 	}
 	// Does it recognize itself?
 	b1, err2 := NewReaderSize(b, BufSize);
 	if err2 != nil {
 		t.Error("NewReaderSize #2 create fail", err2)
 	}
 	if b1 != b {
 		t.Error("NewReaderSize did not detect underlying Reader")
 	}
 	// Does it wrap if existing buffer is too small?
 	b2, err3 := NewReaderSize(b, 2*BufSize);
 	if err3 != nil {
 		t.Error("NewReaderSize #3 create fail", err3)
 	}
 	if b2 == b {
 		t.Error("NewReaderSize did not enlarge buffer")
 	}
 }

 func TestNewWriterSizeIdempotent(t *testing.T) {
 	const BufSize = 1000;
 	b, err := NewWriterSize(new(bytes.Buffer), BufSize);
 	if err != nil {
 		t.Error("NewWriterSize create fail", err)
 	}
 	// Does it recognize itself?
 	b1, err2 := NewWriterSize(b, BufSize);
 	if err2 != nil {
 		t.Error("NewWriterSize #2 create fail", err2)
 	}
 	if b1 != b {
 		t.Error("NewWriterSize did not detect underlying Writer")
 	}
 	// Does it wrap if existing buffer is too small?
 	b2, err3 := NewWriterSize(b, 2*BufSize);
 	if err3 != nil {
 		t.Error("NewWriterSize #3 create fail", err3)
 	}
 	if b2 == b {
 		t.Error("NewWriterSize did not enlarge buffer")
 	}
 }

 func TestWriteString(t *testing.T) {
 	const BufSize = 8;
 	buf := new(bytes.Buffer);
 	b, err := NewWriterSize(buf, BufSize);
 	if err != nil {
 		t.Error("NewWriterSize create fail", err)
 	}
 	b.WriteString("0");				// easy
 	b.WriteString("123456");			// still easy
 	b.WriteString("7890");				// easy after flush
 	b.WriteString("abcdefghijklmnopqrstuvwxy");	// hard
 	b.WriteString("z");
 	b.Flush();
 	if b.err != nil {
 		t.Error("WriteString", b.err)
 	}
 	s := "01234567890abcdefghijklmnopqrstuvwxyz";
 	if string(buf.Bytes()) != s {
 		t.Errorf("WriteString wants %q gets %q", s, string(buf.Bytes()))
 	}
 }
	// 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 bufio

	import (
	"bytes";
	"fmt";
	"io";
	"os";
	"strings";
	"testing";
	"testing/iotest";
	)

	// Reads from a reader and rot13s the result.
	type rot13Reader struct {
	r io.Reader;
	}

	func newRot13Reader(r io.Reader) *rot13Reader {
	r13 := new(rot13Reader);
	r13.r = r;
	return r13;
	}

	func (r13 *rot13Reader) Read(p []byte) (int, os.Error) {
	n, e := r13.r.Read(p);
	if e != nil {
	return n, e
	}
	for i := 0; i < n; i++ {
	c := p[i] \| 0x20; // lowercase byte
	if 'a' <= c && c <= 'm' {
	p[i] += 13
	} else if 'n' <= c && c <= 'z' {
	p[i] -= 13
	}
	}
	return n, nil;
	}

	// Call ReadByte to accumulate the text of a file
	func readBytes(buf *Reader) string {
	var b [1000]byte;
	nb := 0;
	for {
	c, e := buf.ReadByte();
	if e == os.EOF {
	break
	}
	if e != nil {
	panic("Data: " + e.String())
	}
	b[nb] = c;
	nb++;
	}
	return string(b[0:nb]);
	}

	func TestReaderSimple(t *testing.T) {
	data := "hello world";
	b := NewReader(bytes.NewBufferString(data));
	if s := readBytes(b); s != "hello world" {
	t.Errorf("simple hello world test failed: got %q", s)
	}

	b = NewReader(newRot13Reader(bytes.NewBufferString(data)));
	if s := readBytes(b); s != "uryyb jbeyq" {
	t.Error("rot13 hello world test failed: got %q", s)
	}
	}


	type readMaker struct {
	name string;
	fn func(io.Reader) io.Reader;
	}

	var readMakers = []readMaker{
	readMaker{"full", func(r io.Reader) io.Reader { return r }},
	readMaker{"byte", iotest.OneByteReader},
	readMaker{"half", iotest.HalfReader},
	readMaker{"data+err", iotest.DataErrReader},
	}

	// Call ReadString (which ends up calling everything else)
	// to accumulate the text of a file.
	func readLines(b *Reader) string {
	s := "";
	for {
	s1, e := b.ReadString('\n');
	if e == os.EOF {
	break
	}
	if e != nil {
	panic("GetLines: " + e.String())
	}
	s += s1;
	}
	return s;
	}

	// Call Read to accumulate the text of a file
	func reads(buf *Reader, m int) string {
	var b [1000]byte;
	nb := 0;
	for {
	n, e := buf.Read(b[nb : nb+m]);
	nb += n;
	if e == os.EOF {
	break
	}
	}
	return string(b[0:nb]);
	}

	type bufReader struct {
	name string;
	fn func(*Reader) string;
	}

	var bufreaders = []bufReader{
	bufReader{"1", func(b *Reader) string { return reads(b, 1) }},
	bufReader{"2", func(b *Reader) string { return reads(b, 2) }},
	bufReader{"3", func(b *Reader) string { return reads(b, 3) }},
	bufReader{"4", func(b *Reader) string { return reads(b, 4) }},
	bufReader{"5", func(b *Reader) string { return reads(b, 5) }},
	bufReader{"7", func(b *Reader) string { return reads(b, 7) }},
	bufReader{"bytes", readBytes},
	bufReader{"lines", readLines},
	}

	var bufsizes = []int{
	1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
	23, 32, 46, 64, 93, 128, 1024, 4096,
	}

	func TestReader(t *testing.T) {
	var texts [31]string;
	str := "";
	all := "";
	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;

	for h := 0; h < len(texts); h++ {
	text := texts[h];
	for i := 0; i < len(readMakers); i++ {
	for j := 0; j < len(bufreaders); j++ {
	for k := 0; k < len(bufsizes); k++ {
	readmaker := readMakers[i];
	bufreader := bufreaders[j];
	bufsize := bufsizes[k];
	read := readmaker.fn(bytes.NewBufferString(text));
	buf, _ := NewReaderSize(read, bufsize);
	s := bufreader.fn(buf);
	if s != text {
	t.Errorf("reader=%s fn=%s bufsize=%d want=%q got=%q",
	readmaker.name, bufreader.name, bufsize, text, s)
	}
	}
	}
	}
	}
	}

	// A StringReader delivers its data one string segment at a time via Read.
	type StringReader struct {
	data []string;
	step int;
	}

	func (r *StringReader) Read(p []byte) (n int, err os.Error) {
	if r.step < len(r.data) {
	s := r.data[r.step];
	for i := 0; i < len(s); i++ {
	p[i] = s[i]
	}
	n = len(s);
	r.step++;
	} else {
	err = os.EOF
	}
	return;
	}

	func readRuneSegments(t *testing.T, segments []string) {
	got := "";
	want := strings.Join(segments, "");
	r := NewReader(&StringReader{data: segments});
	for {
	rune, _, err := r.ReadRune();
	if err != nil {
	if err != os.EOF {
	return
	}
	break;
	}
	got += string(rune);
	}
	if got != want {
	t.Errorf("segments=%v got=%s want=%s", segments, got, want)
	}
	}

	var segmentList = [][]string{
	[]string{},
	[]string{""},
	[]string{"日", "本語"},
	[]string{"\u65e5", "\u672c", "\u8a9e"},
	[]string{"\U000065e5", "\U0000672c", "\U00008a9e"},
	[]string{"\xe6", "\x97\xa5\xe6", "\x9c\xac\xe8\xaa\x9e"},
	[]string{"Hello", ", ", "World", "!"},
	[]string{"Hello", ", ", "", "World", "!"},
	}

	func TestReadRune(t *testing.T) {
	for _, s := range segmentList {
	readRuneSegments(t, s)
	}
	}

	func TestWriter(t *testing.T) {
	var data [8192]byte;

	for i := 0; i < len(data); i++ {
	data[i] = byte(' ' + i%('~'-' '))
	}
	w := new(bytes.Buffer);
	for i := 0; i < len(bufsizes); i++ {
	for j := 0; j < len(bufsizes); j++ {
	nwrite := bufsizes[i];
	bs := bufsizes[j];

	// Write nwrite bytes using buffer size bs.
	// Check that the right amount makes it out
	// and that the data is correct.

	w.Reset();
	buf, e := NewWriterSize(w, bs);
	context := fmt.Sprintf("nwrite=%d bufsize=%d", nwrite, bs);
	if e != nil {
	t.Errorf("%s: NewWriterSize %d: %v", context, bs, e);
	continue;
	}
	n, e1 := buf.Write(data[0:nwrite]);
	if e1 != nil \|\| n != nwrite {
	t.Errorf("%s: buf.Write %d = %d, %v", context, nwrite, n, e1);
	continue;
	}
	if e = buf.Flush(); e != nil {
	t.Errorf("%s: buf.Flush = %v", context, e)
	}

	written := w.Bytes();
	if len(written) != nwrite {
	t.Errorf("%s: %d bytes written", context, len(written))
	}
	for l := 0; l < len(written); l++ {
	if written[i] != data[i] {
	t.Errorf("%s: wrong bytes written");
	t.Errorf("want=%s", data[0:len(written)]);
	t.Errorf("have=%s", written);
	}
	}
	}
	}
	}

	// Check that write errors are returned properly.

	type errorWriterTest struct {
	n, m int;
	err os.Error;
	expect os.Error;
	}

	func (w errorWriterTest) Write(p []byte) (int, os.Error) {
	return len(p) * w.n / w.m, w.err
	}

	var errorWriterTests = []errorWriterTest{
	errorWriterTest{0, 1, nil, io.ErrShortWrite},
	errorWriterTest{1, 2, nil, io.ErrShortWrite},
	errorWriterTest{1, 1, nil, nil},
	errorWriterTest{0, 1, os.EPIPE, os.EPIPE},
	errorWriterTest{1, 2, os.EPIPE, os.EPIPE},
	errorWriterTest{1, 1, os.EPIPE, os.EPIPE},
	}

	func TestWriteErrors(t *testing.T) {
	for _, w := range errorWriterTests {
	buf := NewWriter(w);
	_, e := buf.Write(strings.Bytes("hello world"));
	if e != nil {
	t.Errorf("Write hello to %v: %v", w, e);
	continue;
	}
	e = buf.Flush();
	if e != w.expect {
	t.Errorf("Flush %v: got %v, wanted %v", w, e, w.expect)
	}
	}
	}

	func TestNewReaderSizeIdempotent(t *testing.T) {
	const BufSize = 1000;
	b, err := NewReaderSize(bytes.NewBufferString("hello world"), BufSize);
	if err != nil {
	t.Error("NewReaderSize create fail", err)
	}
	// Does it recognize itself?
	b1, err2 := NewReaderSize(b, BufSize);
	if err2 != nil {
	t.Error("NewReaderSize #2 create fail", err2)
	}
	if b1 != b {
	t.Error("NewReaderSize did not detect underlying Reader")
	}
	// Does it wrap if existing buffer is too small?
	b2, err3 := NewReaderSize(b, 2*BufSize);
	if err3 != nil {
	t.Error("NewReaderSize #3 create fail", err3)
	}
	if b2 == b {
	t.Error("NewReaderSize did not enlarge buffer")
	}
	}

	func TestNewWriterSizeIdempotent(t *testing.T) {
	const BufSize = 1000;
	b, err := NewWriterSize(new(bytes.Buffer), BufSize);
	if err != nil {
	t.Error("NewWriterSize create fail", err)
	}
	// Does it recognize itself?
	b1, err2 := NewWriterSize(b, BufSize);
	if err2 != nil {
	t.Error("NewWriterSize #2 create fail", err2)
	}
	if b1 != b {
	t.Error("NewWriterSize did not detect underlying Writer")
	}
	// Does it wrap if existing buffer is too small?
	b2, err3 := NewWriterSize(b, 2*BufSize);
	if err3 != nil {
	t.Error("NewWriterSize #3 create fail", err3)
	}
	if b2 == b {
	t.Error("NewWriterSize did not enlarge buffer")
	}
	}

	func TestWriteString(t *testing.T) {
	const BufSize = 8;
	buf := new(bytes.Buffer);
	b, err := NewWriterSize(buf, BufSize);
	if err != nil {
	t.Error("NewWriterSize create fail", err)
	}
	b.WriteString("0"); // easy
	b.WriteString("123456"); // still easy
	b.WriteString("7890"); // easy after flush
	b.WriteString("abcdefghijklmnopqrstuvwxy"); // hard
	b.WriteString("z");
	b.Flush();
	if b.err != nil {
	t.Error("WriteString", b.err)
	}
	s := "01234567890abcdefghijklmnopqrstuvwxyz";
	if string(buf.Bytes()) != s {
	t.Errorf("WriteString wants %q gets %q", s, string(buf.Bytes()))
	}
	}