github.com/hamba/avro/v2@v2.22.1-0.20240518180522-aff3955acf7d/reader_skip_test.go (about)

     1  package avro_test
     2  
     3  import (
     4  	"bytes"
     5  	"testing"
     6  
     7  	"github.com/hamba/avro/v2"
     8  	"github.com/stretchr/testify/assert"
     9  	"github.com/stretchr/testify/require"
    10  )
    11  
    12  func TestReader_SkipNBytes(t *testing.T) {
    13  	data := []byte{0x01, 0x01, 0x01, 0x36}
    14  	r := avro.NewReader(bytes.NewReader(data), 2)
    15  
    16  	r.SkipNBytes(3)
    17  
    18  	require.NoError(t, r.Error)
    19  	assert.Equal(t, int32(27), r.ReadInt())
    20  }
    21  
    22  func TestReader_SkipNBytesEOF(t *testing.T) {
    23  	data := []byte{0x01, 0x36}
    24  	r := avro.NewReader(bytes.NewReader(data), 2)
    25  
    26  	r.SkipNBytes(3)
    27  
    28  	assert.Error(t, r.Error)
    29  }
    30  
    31  func TestReader_SkipBool(t *testing.T) {
    32  	data := []byte{0x01, 0x36}
    33  	r := avro.NewReader(bytes.NewReader(data), 10)
    34  
    35  	r.SkipBool()
    36  
    37  	require.NoError(t, r.Error)
    38  	assert.Equal(t, int32(27), r.ReadInt())
    39  }
    40  
    41  func TestReader_SkipInt(t *testing.T) {
    42  	tests := []struct {
    43  		name string
    44  		data []byte
    45  	}{
    46  		{
    47  			name: "Skipped",
    48  			data: []byte{0x38, 0x36},
    49  		},
    50  		{
    51  
    52  			name: "Overflow",
    53  			data: []byte{0xE2, 0xA2, 0xF3, 0xAD, 0xAD, 0x36},
    54  		},
    55  	}
    56  
    57  	for _, test := range tests {
    58  		test := test
    59  		t.Run(test.name, func(t *testing.T) {
    60  			r := avro.NewReader(bytes.NewReader(test.data), 10)
    61  
    62  			r.SkipInt()
    63  
    64  			require.NoError(t, r.Error)
    65  			assert.Equal(t, int32(27), r.ReadInt())
    66  		})
    67  	}
    68  }
    69  
    70  func TestReader_SkipLong(t *testing.T) {
    71  	tests := []struct {
    72  		name string
    73  		data []byte
    74  	}{
    75  		{
    76  			name: "Skipped",
    77  			data: []byte{0x38, 0x36},
    78  		},
    79  		{
    80  
    81  			name: "Overflow",
    82  			data: []byte{0xE2, 0xA2, 0xF3, 0xAD, 0xAD, 0xAD, 0xE2, 0xA2, 0xF3, 0xAD, 0x36},
    83  		},
    84  	}
    85  
    86  	for _, test := range tests {
    87  		test := test
    88  		t.Run(test.name, func(t *testing.T) {
    89  			r := avro.NewReader(bytes.NewReader(test.data), 10)
    90  
    91  			r.SkipLong()
    92  
    93  			require.NoError(t, r.Error)
    94  			assert.Equal(t, int32(27), r.ReadInt())
    95  		})
    96  	}
    97  }
    98  
    99  func TestReader_SkipFloat(t *testing.T) {
   100  	data := []byte{0x00, 0x00, 0x00, 0x00, 0x36}
   101  	r := avro.NewReader(bytes.NewReader(data), 10)
   102  
   103  	r.SkipFloat()
   104  
   105  	require.NoError(t, r.Error)
   106  	assert.Equal(t, int32(27), r.ReadInt())
   107  }
   108  
   109  func TestReader_SkipDouble(t *testing.T) {
   110  	data := []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36}
   111  	r := avro.NewReader(bytes.NewReader(data), 10)
   112  
   113  	r.SkipDouble()
   114  
   115  	require.NoError(t, r.Error)
   116  	assert.Equal(t, int32(27), r.ReadInt())
   117  }
   118  
   119  func TestReader_SkipString(t *testing.T) {
   120  	data := []byte{0x06, 0x66, 0x6F, 0x6F, 0x36}
   121  	r := avro.NewReader(bytes.NewReader(data), 10)
   122  
   123  	r.SkipString()
   124  
   125  	require.NoError(t, r.Error)
   126  	assert.Equal(t, int32(27), r.ReadInt())
   127  }
   128  
   129  func TestReader_SkipStringEmpty(t *testing.T) {
   130  	data := []byte{0x00, 0x36}
   131  	r := avro.NewReader(bytes.NewReader(data), 10)
   132  
   133  	r.SkipString()
   134  
   135  	require.NoError(t, r.Error)
   136  	assert.Equal(t, int32(27), r.ReadInt())
   137  }
   138  
   139  func TestReader_SkipBytes(t *testing.T) {
   140  	data := []byte{0x06, 0x66, 0x6F, 0x6F, 0x36}
   141  	r := avro.NewReader(bytes.NewReader(data), 10)
   142  
   143  	r.SkipBytes()
   144  
   145  	require.NoError(t, r.Error)
   146  	assert.Equal(t, int32(27), r.ReadInt())
   147  }
   148  
   149  func TestReader_SkipBytesEmpty(t *testing.T) {
   150  	data := []byte{0x00, 0x36}
   151  	r := avro.NewReader(bytes.NewReader(data), 10)
   152  
   153  	r.SkipBytes()
   154  
   155  	require.NoError(t, r.Error)
   156  	assert.Equal(t, int32(27), r.ReadInt())
   157  }