github.com/2lambda123/git-lfs@v2.5.2+incompatible/git/pkt_line_reader_test.go (about)

     1  package git
     2  
     3  import (
     4  	"bytes"
     5  	"io"
     6  	"io/ioutil"
     7  	"testing"
     8  
     9  	"github.com/stretchr/testify/assert"
    10  	"github.com/stretchr/testify/require"
    11  )
    12  
    13  // writePackets
    14  func writePacket(t *testing.T, w io.Writer, datas ...[]byte) {
    15  	pl := newPktline(nil, w)
    16  
    17  	for _, data := range datas {
    18  		require.Nil(t, pl.writePacket(data))
    19  	}
    20  
    21  	require.Nil(t, pl.writeFlush())
    22  }
    23  
    24  func TestPktlineReaderReadsSinglePacketsInOneCall(t *testing.T) {
    25  	var buf bytes.Buffer
    26  
    27  	writePacket(t, &buf, []byte("asdf"))
    28  
    29  	pr := &pktlineReader{pl: newPktline(&buf, nil)}
    30  
    31  	data, err := ioutil.ReadAll(pr)
    32  
    33  	assert.Nil(t, err)
    34  	assert.Equal(t, []byte("asdf"), data)
    35  }
    36  
    37  func TestPktlineReaderReadsManyPacketsInOneCall(t *testing.T) {
    38  	var buf bytes.Buffer
    39  
    40  	writePacket(t, &buf, []byte("first\n"), []byte("second"))
    41  
    42  	pr := &pktlineReader{pl: newPktline(&buf, nil)}
    43  
    44  	data, err := ioutil.ReadAll(pr)
    45  
    46  	assert.Nil(t, err)
    47  	assert.Equal(t, []byte("first\nsecond"), data)
    48  }
    49  
    50  func TestPktlineReaderReadsSinglePacketsInMultipleCallsWithUnevenBuffering(t *testing.T) {
    51  	var buf bytes.Buffer
    52  
    53  	writePacket(t, &buf, []byte("asdf"))
    54  
    55  	pr := &pktlineReader{pl: newPktline(&buf, nil)}
    56  
    57  	var p1 [3]byte
    58  	var p2 [1]byte
    59  
    60  	n1, e1 := pr.Read(p1[:])
    61  	assert.Equal(t, 3, n1)
    62  	assert.Equal(t, []byte("asd"), p1[:])
    63  	assert.Nil(t, e1)
    64  
    65  	n2, e2 := pr.Read(p2[:])
    66  	assert.Equal(t, 1, n2)
    67  	assert.Equal(t, []byte("f"), p2[:])
    68  	assert.Equal(t, io.EOF, e2)
    69  }
    70  
    71  func TestPktlineReaderReadsManyPacketsInMultipleCallsWithUnevenBuffering(t *testing.T) {
    72  	var buf bytes.Buffer
    73  
    74  	writePacket(t, &buf, []byte("first"), []byte("second"))
    75  
    76  	pr := &pktlineReader{pl: newPktline(&buf, nil)}
    77  
    78  	var p1 [4]byte
    79  	var p2 [7]byte
    80  	var p3 []byte
    81  
    82  	n1, e1 := pr.Read(p1[:])
    83  	assert.Equal(t, 4, n1)
    84  	assert.Equal(t, []byte("firs"), p1[:])
    85  	assert.Nil(t, e1)
    86  
    87  	n2, e2 := pr.Read(p2[:])
    88  	assert.Equal(t, 7, n2)
    89  	assert.Equal(t, []byte("tsecond"), p2[:])
    90  	assert.Equal(t, io.EOF, e2)
    91  
    92  	n3, e3 := pr.Read(p3[:])
    93  	assert.Equal(t, 0, n3)
    94  	assert.Empty(t, p3)
    95  	assert.Equal(t, io.EOF, e3)
    96  }
    97  
    98  func TestPktlineReaderReadsSinglePacketsInMultipleCallsWithEvenBuffering(t *testing.T) {
    99  	var buf bytes.Buffer
   100  
   101  	writePacket(t, &buf, []byte("firstother"))
   102  
   103  	pr := &pktlineReader{pl: newPktline(&buf, nil)}
   104  
   105  	var p1 [5]byte
   106  	var p2 [5]byte
   107  
   108  	n1, e1 := pr.Read(p1[:])
   109  	assert.Equal(t, 5, n1)
   110  	assert.Equal(t, []byte("first"), p1[:])
   111  	assert.Nil(t, e1)
   112  
   113  	n2, e2 := pr.Read(p2[:])
   114  	assert.Equal(t, 5, n2)
   115  	assert.Equal(t, []byte("other"), p2[:])
   116  	assert.Equal(t, io.EOF, e2)
   117  }
   118  
   119  func TestPktlineReaderReadsManyPacketsInMultipleCallsWithEvenBuffering(t *testing.T) {
   120  	var buf bytes.Buffer
   121  
   122  	writePacket(t, &buf, []byte("first"), []byte("other"))
   123  
   124  	pr := &pktlineReader{pl: newPktline(&buf, nil)}
   125  
   126  	var p1 [5]byte
   127  	var p2 [5]byte
   128  	var p3 []byte
   129  
   130  	n1, e1 := pr.Read(p1[:])
   131  	assert.Equal(t, 5, n1)
   132  	assert.Equal(t, []byte("first"), p1[:])
   133  	assert.Nil(t, e1)
   134  
   135  	n2, e2 := pr.Read(p2[:])
   136  	assert.Equal(t, 5, n2)
   137  	assert.Equal(t, []byte("other"), p2[:])
   138  	assert.Equal(t, io.EOF, e2)
   139  
   140  	n3, e3 := pr.Read(p3)
   141  	assert.Equal(t, 0, n3)
   142  	assert.Equal(t, io.EOF, e3)
   143  }