common/recordio: Add zero-copy buffer split.

common/recordio/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 recordio
 
 import (
         "bytes"
         "encoding/binary"
         "errors"
+        "fmt"
         "io"
         "io/ioutil"
         "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 {
@@ skipping 30 matching lines @@
                 return 0, r.readByteErr
         }
 
         b, err = r.buf.ReadByte()
         if err == nil {
                 r.readBytes++
         }
         return
 }
 
+func btos(b ...[]byte) []string {
+        s := make([]string, len(b))
+        for i, v := range b {
+                s[i] = string(v)
+        }
+        return s
+}
+
 // 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 := int64(1024 * 1024)
                 tr := plainReader{}
                 r := NewReader(&tr, maxSize)
 
                 Convey(`Will return io.EOF with an empty reader.`, func() {
@@ skipping 127 matching lines @@
 
                         // Have "ReadByte()" calls ignore the configured error. This will cause
                         // the frame size to be read without incident, but the frame data to still
                         // return an error.
                         tr.err = errors.New("test: test-induced error")
                         data, err := r.ReadFrameAll()
                         So(err, ShouldEqual, tr.err)
                 })
         })
 }
+
+func TestSplit(t *testing.T) {
+        t.Parallel()
+
+        Convey(`Testing Split`, t, func() {
+                for _, v := range [][]string{
+                        {},
+                        {""},
+                        {"", "foo", ""},
+                        {"foo", "bar", "baz"},
+                } {
+                        Convey(fmt.Sprintf(`Can Split stream: %#v`, v), func() {
+                                // Write frames to "buf".
+                                var buf bytes.Buffer
+                                for _, s := range v {
+                                        _, err := WriteFrame(&buf, []byte(s))
+                                        if err != nil {
+                                                panic(err)
+                                        }
+                                }
+
+                                // Confirm that Split works.
+                                sp, err := Split(buf.Bytes())
+                                So(err, ShouldBeNil)
+                                So(btos(sp...), ShouldResemble, v)
+                        })
+                }
+
+                Convey(`Will refuse to split a frame that is too large.`, func() {
+                        _, err := Split([]byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00})
+                        So(err, ShouldEqual, ErrFrameTooLarge)
+                })
+
+                Convey(`Will fail to split if there aren't enough bytes.`, func() {
+                        sp, err := Split([]byte{0x01, 0xAA, 0x02}) // 1-byte {0xAA}, 2-bytes ... EOF!
+                        So(sp, ShouldResemble, [][]byte{{0xAA}})
+                        So(err, ShouldEqual, ErrFrameTooLarge)
+                })
+        })
+}