github.com/hoffie/larasync@v0.0.0-20151025221940-0384d2bddcef/helpers/bincontainer/common_test.go (about)

     1  package bincontainer
     2  
     3  import (
     4  	"bytes"
     5  	"io"
     6  	"testing"
     7  
     8  	. "gopkg.in/check.v1"
     9  )
    10  
    11  func Test(t *testing.T) {
    12  	TestingT(t)
    13  }
    14  
    15  type Tests struct{}
    16  
    17  var _ = Suite(&Tests{})
    18  
    19  func (t *Tests) TestEncodeDecode(c *C) {
    20  	buf := &bytes.Buffer{}
    21  	testChunk1 := []byte("foo")
    22  	testChunk2 := []byte("bar")
    23  
    24  	e := NewEncoder(buf)
    25  	err := e.WriteChunk(testChunk1)
    26  	c.Assert(err, IsNil)
    27  
    28  	err = e.WriteChunk(testChunk2)
    29  	c.Assert(err, IsNil)
    30  
    31  	r := NewDecoder(buf)
    32  	chunk, err := r.ReadChunk()
    33  	c.Assert(err, IsNil)
    34  	c.Assert(chunk, DeepEquals, testChunk1)
    35  
    36  	chunk, err = r.ReadChunk()
    37  	c.Assert(err, IsNil)
    38  	c.Assert(chunk, DeepEquals, testChunk2)
    39  
    40  	chunk, err = r.ReadChunk()
    41  	c.Assert(err, Equals, io.EOF)
    42  }
    43  
    44  func (t *Tests) TestDecodeEmpty(c *C) {
    45  	d := NewDecoder(&bytes.Buffer{})
    46  	_, err := d.ReadChunk()
    47  	c.Assert(err, Equals, io.EOF)
    48  }
    49  
    50  func (t *Tests) TestDecodeEmptyChunk(c *C) {
    51  	d := NewDecoder(bytes.NewBufferString("\x00\x00\x00\x00"))
    52  	chunk, err := d.ReadChunk()
    53  	c.Assert(err, IsNil)
    54  	c.Assert(chunk, DeepEquals, []byte{})
    55  }
    56  
    57  func (t *Tests) TestDecodeTruncatedLength(c *C) {
    58  	d := NewDecoder(bytes.NewBufferString("\x01"))
    59  	_, err := d.ReadChunk()
    60  	c.Assert(err, Equals, ErrIncomplete)
    61  }
    62  
    63  func (t *Tests) TestDecodeTruncatedContent(c *C) {
    64  	d := NewDecoder(bytes.NewBufferString("\x01\x01\x01\x01"))
    65  	_, err := d.ReadChunk()
    66  	c.Assert(err, Equals, ErrIncomplete)
    67  }
    68  
    69  type eofReader4ZeroBytes struct {
    70  	state int
    71  }
    72  
    73  func (r *eofReader4ZeroBytes) Read(buf []byte) (int, error) {
    74  	r.state++
    75  	switch r.state {
    76  	case 1:
    77  		buf[0] = 0
    78  		buf[1] = 0
    79  		buf[2] = 0
    80  		buf[3] = 0
    81  		return 4, io.EOF
    82  	}
    83  	return 0, io.EOF
    84  }
    85  
    86  type eofReaderLength1Data1 struct {
    87  	state int
    88  }
    89  
    90  func (r *eofReaderLength1Data1) Read(buf []byte) (int, error) {
    91  	r.state++
    92  	switch r.state {
    93  	case 1:
    94  		buf[0] = 1
    95  		buf[1] = 0
    96  		buf[2] = 0
    97  		buf[3] = 0
    98  		return 4, nil
    99  	}
   100  	buf[0] = 97
   101  	return 1, io.EOF
   102  }
   103  
   104  func (t *Tests) TestDecodeLengthWithEOF(c *C) {
   105  	r := &eofReader4ZeroBytes{}
   106  	d := NewDecoder(r)
   107  	chunk, err := d.ReadChunk()
   108  	c.Assert(err, IsNil)
   109  	c.Assert(chunk, DeepEquals, []byte{})
   110  }
   111  
   112  func (t *Tests) TestDecodeDataWithEOF(c *C) {
   113  	r := &eofReaderLength1Data1{}
   114  	d := NewDecoder(r)
   115  	chunk, err := d.ReadChunk()
   116  	c.Assert(err, IsNil)
   117  	c.Assert(chunk, DeepEquals, []byte{'a'})
   118  }