logdog: Add frame read/write library.

common/logdog/frame/reader_test.go

+// 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)
+                })
+        })
+}