github.com/avahowell/sia@v0.5.1-beta.0.20160524050156-83dcc3d37c94/encoding/prefix_test.go (about)

     1  package encoding
     2  
     3  import (
     4  	"bytes"
     5  	"io"
     6  	"testing"
     7  )
     8  
     9  // badReader/Writer used to test error handling
    10  
    11  type badReader struct{}
    12  
    13  func (br *badReader) Read([]byte) (int, error) { return 0, io.EOF }
    14  
    15  type badWriter struct{}
    16  
    17  func (bw *badWriter) Write([]byte) (int, error) { return 0, nil }
    18  
    19  func TestReadPrefix(t *testing.T) {
    20  	b := new(bytes.Buffer)
    21  
    22  	// standard
    23  	b.Write(append(EncUint64(3), "foo"...))
    24  	data, err := ReadPrefix(b, 3)
    25  	if err != nil {
    26  		t.Error(err)
    27  	} else if string(data) != "foo" {
    28  		t.Errorf("expected foo, got %s", data)
    29  	}
    30  
    31  	// 0-length
    32  	b.Write(EncUint64(0))
    33  	_, err = ReadPrefix(b, 0)
    34  	if err != nil {
    35  		t.Error(err)
    36  	}
    37  
    38  	// empty
    39  	b.Write([]byte{})
    40  	_, err = ReadPrefix(b, 3)
    41  	if err != io.EOF {
    42  		t.Error("expected EOF, got", err)
    43  	}
    44  
    45  	// less than 8 bytes
    46  	b.Write([]byte{1, 2, 3})
    47  	_, err = ReadPrefix(b, 3)
    48  	if err != io.ErrUnexpectedEOF {
    49  		t.Error("expected unexpected EOF, got", err)
    50  	}
    51  
    52  	// exceed maxLen
    53  	b.Write(EncUint64(4))
    54  	_, err = ReadPrefix(b, 3)
    55  	if err == nil || err.Error() != "length 4 exceeds maxLen of 3" {
    56  		t.Error("expected maxLen error, got", err)
    57  	}
    58  
    59  	// no data after length prefix
    60  	b.Write(EncUint64(3))
    61  	_, err = ReadPrefix(b, 3)
    62  	if err != io.EOF {
    63  		t.Error("expected EOF, got", err)
    64  	}
    65  }
    66  
    67  func TestReadObject(t *testing.T) {
    68  	b := new(bytes.Buffer)
    69  	var obj string
    70  
    71  	// standard
    72  	b.Write(EncUint64(11))
    73  	b.Write(append(EncUint64(3), "foo"...))
    74  	err := ReadObject(b, &obj, 11)
    75  	if err != nil {
    76  		t.Error(err)
    77  	} else if obj != "foo" {
    78  		t.Errorf("expected foo, got %s", obj)
    79  	}
    80  
    81  	// empty
    82  	b.Write([]byte{})
    83  	err = ReadObject(b, &obj, 0)
    84  	if err != io.EOF {
    85  		t.Error("expected EOF, got", err)
    86  	}
    87  
    88  	// bad object
    89  	b.Write(EncUint64(3))
    90  	b.WriteString("foo") // strings need an additional length prefix
    91  	err = ReadObject(b, &obj, 3)
    92  	if err == nil || err.Error() != "could not decode type string: "+io.ErrUnexpectedEOF.Error() {
    93  		t.Error("expected unexpected EOF, got", err)
    94  	}
    95  }
    96  
    97  func TestWritePrefix(t *testing.T) {
    98  	b := new(bytes.Buffer)
    99  
   100  	// standard
   101  	err := WritePrefix(b, []byte("foo"))
   102  	expected := append(EncUint64(3), "foo"...)
   103  	if err != nil {
   104  		t.Error(err)
   105  	} else if !bytes.Equal(b.Bytes(), expected) {
   106  		t.Errorf("WritePrefix wrote wrong data: expected %v, got %v", b.Bytes(), expected)
   107  	}
   108  
   109  	// badWriter (returns nil error, but doesn't write anything)
   110  	bw := new(badWriter)
   111  	err = WritePrefix(bw, []byte("foo"))
   112  	if err != io.ErrShortWrite {
   113  		t.Error("expected ErrShortWrite, got", err)
   114  	}
   115  }
   116  
   117  func TestWriteObject(t *testing.T) {
   118  	b := new(bytes.Buffer)
   119  
   120  	// standard
   121  	err := WriteObject(b, "foo")
   122  	expected := append(EncUint64(11), append(EncUint64(3), "foo"...)...)
   123  	if err != nil {
   124  		t.Error(err)
   125  	} else if !bytes.Equal(b.Bytes(), expected) {
   126  		t.Errorf("WritePrefix wrote wrong data: expected %v, got %v", b.Bytes(), expected)
   127  	}
   128  
   129  	// badWriter
   130  	bw := new(badWriter)
   131  	err = WriteObject(bw, "foo")
   132  	if err != io.ErrShortWrite {
   133  		t.Error("expected ErrShortWrite, got", err)
   134  	}
   135  }
   136  
   137  func TestReadWritePrefix(t *testing.T) {
   138  	b := new(bytes.Buffer)
   139  
   140  	// WritePrefix -> ReadPrefix
   141  	data := []byte("foo")
   142  	err := WritePrefix(b, data)
   143  	if err != nil {
   144  		t.Fatal(err)
   145  	}
   146  	rdata, err := ReadPrefix(b, 100)
   147  	if err != nil {
   148  		t.Error(err)
   149  	} else if !bytes.Equal(rdata, data) {
   150  		t.Errorf("read/write mismatch: wrote %s, read %s", data, rdata)
   151  	}
   152  
   153  	// WriteObject -> ReadObject
   154  	obj := "bar"
   155  	err = WriteObject(b, obj)
   156  	if err != nil {
   157  		t.Fatal(err)
   158  	}
   159  	var robj string
   160  	err = ReadObject(b, &robj, 100)
   161  	if err != nil {
   162  		t.Error(err)
   163  	} else if robj != obj {
   164  		t.Errorf("read/write mismatch: wrote %s, read %s", obj, robj)
   165  	}
   166  }