logdog: Add frame read/write library.

common/logdog/frame/reader_test.go

Index: common/logdog/frame/reader_test.go
diff --git a/common/logdog/frame/reader_test.go b/common/logdog/frame/reader_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..ba80fe90c175c56850871395e8be6f58807adc20
--- /dev/null
+++ b/common/logdog/frame/reader_test.go
@@ -0,0 +1,138 @@
+// Copyright 2015 The Chromium 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 frame
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"io"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+// plainReader implements the io.Reader interface on top of a bytes.Buffer;
+// however, it does not also implement io.ByteReader.
+type plainReader struct {
+	buf bytes.Buffer
+	err error
+}
+
+func (r *plainReader) loadFrame(data []byte) {
+	_, err := WriteFrame(&r.buf, data)
+	if err != nil {
+		panic(err)
+	}
+}
+
+func (r *plainReader) Read(data []byte) (int, error) {
+	if r.err != nil {
+		return 0, r.err
+	}
+	return r.buf.Read(data)
+}
+
+type testByteReader struct {
+	plainReader
+	readBytes int
+}
+
+func (r *testByteReader) ReadByte() (byte, error) {
+	b, err := r.buf.ReadByte()
+	if err == nil {
+		r.readBytes++
+	}
+	return b, err
+}
+
+// TestReader tests the default Reader implementation, "reader".
+func TestReader(t *testing.T) {
+	t.Parallel()
+
+	Convey(`A frame reader with max size 1MB using a plain io.Reader`, t, func() {
+		maxSize := 1024 * 1024
+		tr := plainReader{}
+		r := NewReader(&tr, maxSize)
+
+		Convey(`Will return io.EOF with an empty reader.`, func() {
+			_, err := r.ReadFrame()
+			So(err, ShouldEqual, io.EOF)
+		})
+
+		Convey(`Can successfully read a frame.`, func() {
+			data := []byte{0x13, 0x37, 0xd0, 0x65}
+			tr.loadFrame(data)
+
+			f, err := r.ReadFrame()
+			So(err, ShouldBeNil)
+			So(f, ShouldResemble, data)
+		})
+
+		Convey(`Will fail if the underlying frame exceeds the maximum size.`, func() {
+			var sizeBuf [binary.MaxVarintLen64]byte
+			tr.buf.Write(sizeBuf[:binary.PutUvarint(sizeBuf[:], uint64(maxSize+1))])
+
+			_, err := r.ReadFrame()
+			So(err, ShouldEqual, ErrFrameTooLarge)
+		})
+
+		Convey(`Will fail if the frame contains an invalid size header.`, func() {
+			tr.buf.Write([]byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF})
+			_, err := r.ReadFrame()
+			So(err, ShouldNotBeNil)
+		})
+
+		Convey(`Can read conscutive frames, then io.EOF.`, func() {
+			data := [][]byte{}
+			for _, size := range []int{
+				0,
+				14,
+				1024 * 1024,
+				0,
+				511,
+			} {
+				data = append(data, bytes.Repeat([]byte{0x5A}, size))
+				tr.loadFrame(data[len(data)-1])
+			}
+
+			for _, expected := range data {
+				f, err := r.ReadFrame()
+				So(err, ShouldBeNil)
+				So(f, ShouldResemble, expected)
+			}
+
+			_, err := r.ReadFrame()
+			So(err, ShouldEqual, io.EOF)
+		})
+	})
+
+	Convey(`A frame reader with max size 1MB using an io.Reader+io.ByteReader`, t, func() {
+		tr := testByteReader{}
+		r := NewReader(&tr, 1024*1024)
+
+		Convey(`Will return io.EOF with an empty reader.`, func() {
+			_, err := r.ReadFrame()
+			So(err, ShouldEqual, io.EOF)
+		})
+
+		Convey(`Will use io.ByteReader to read the frame header.`, func() {
+			data := []byte{0x13, 0x37, 0xd0, 0x65}
+			tr.loadFrame(data)
+
+			f, err := r.ReadFrame()
+			So(err, ShouldBeNil)
+			So(f, ShouldResemble, data)
+			So(tr.readBytes, ShouldEqual, 1)
+		})
+
+		Convey(`Will fail if the underlying io.Reader returns an error.`, func() {
+			tr.loadFrame([]byte{})
+			tr.err = errors.New("test: test-induced error")
+			_, err := r.ReadFrame()
+			So(err, ShouldEqual, tr.err)
+		})
+	})
+}