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

     1  package avro_test
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"math"
     7  	"math/big"
     8  	"testing"
     9  
    10  	"github.com/hamba/avro/v2"
    11  	"github.com/stretchr/testify/assert"
    12  	"github.com/stretchr/testify/require"
    13  )
    14  
    15  func TestDecoder_FixedInvalidType(t *testing.T) {
    16  	defer ConfigTeardown()
    17  
    18  	data := []byte{0x66, 0x6F, 0x6F, 0x66, 0x6F, 0x6F}
    19  	schema := `{"type":"fixed", "name": "test", "size": 6}`
    20  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
    21  	require.NoError(t, err)
    22  
    23  	var i [6]int
    24  	err = dec.Decode(&i)
    25  
    26  	assert.Error(t, err)
    27  }
    28  
    29  func TestDecoder_Fixed(t *testing.T) {
    30  	defer ConfigTeardown()
    31  
    32  	data := []byte{0x66, 0x6F, 0x6F, 0x66, 0x6F, 0x6F}
    33  	schema := `{"type":"fixed", "name": "test", "size": 6}`
    34  	dec, _ := avro.NewDecoder(schema, bytes.NewReader(data))
    35  
    36  	var got [6]byte
    37  	err := dec.Decode(&got)
    38  
    39  	require.NoError(t, err)
    40  	assert.Equal(t, [6]byte{'f', 'o', 'o', 'f', 'o', 'o'}, got)
    41  }
    42  
    43  func TestDecoder_FixedRat_Positive(t *testing.T) {
    44  	defer ConfigTeardown()
    45  
    46  	data := []byte{0x00, 0x00, 0x00, 0x00, 0x87, 0x78}
    47  	schema := `{"type":"fixed", "name": "test", "size": 6,"logicalType":"decimal","precision":4,"scale":2}`
    48  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
    49  	require.NoError(t, err)
    50  
    51  	got := &big.Rat{}
    52  	err = dec.Decode(got)
    53  
    54  	require.NoError(t, err)
    55  	assert.Equal(t, big.NewRat(1734, 5), got)
    56  }
    57  
    58  func TestDecoder_FixedRat_Negative(t *testing.T) {
    59  	defer ConfigTeardown()
    60  
    61  	data := []byte{0xFF, 0xFF, 0xFF, 0xFF, 0x78, 0x88}
    62  	schema := `{"type":"fixed", "name": "test", "size": 6, "logicalType":"decimal","precision":4,"scale":2}`
    63  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
    64  	require.NoError(t, err)
    65  
    66  	got := &big.Rat{}
    67  	err = dec.Decode(got)
    68  
    69  	require.NoError(t, err)
    70  	assert.Equal(t, big.NewRat(-1734, 5), got)
    71  }
    72  
    73  func TestDecoder_FixedRat_Zero(t *testing.T) {
    74  	defer ConfigTeardown()
    75  
    76  	data := []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
    77  	schema := `{"type":"fixed", "name": "test", "size": 6,"logicalType":"decimal","precision":4,"scale":2}`
    78  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
    79  	require.NoError(t, err)
    80  
    81  	got := &big.Rat{}
    82  	err = dec.Decode(got)
    83  
    84  	require.NoError(t, err)
    85  	assert.Equal(t, big.NewRat(0, 1), got)
    86  }
    87  
    88  func TestDecoder_FixedRatInvalidLogicalSchema(t *testing.T) {
    89  	defer ConfigTeardown()
    90  
    91  	data := []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
    92  	schema := `{"type":"fixed", "name": "test", "size": 6}`
    93  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
    94  	require.NoError(t, err)
    95  
    96  	got := &big.Rat{}
    97  	err = dec.Decode(got)
    98  
    99  	assert.Error(t, err)
   100  }
   101  
   102  func TestDecoder_FixedLogicalDuration(t *testing.T) {
   103  	defer ConfigTeardown()
   104  
   105  	data := []byte{0xc, 0x0, 0x0, 0x0, 0x22, 0x0, 0x0, 0x0, 0x52, 0xaa, 0x8, 0x0}
   106  	schema := `{"name":"foo","type":"fixed","logicalType":"duration","size":12}`
   107  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   108  	require.NoError(t, err)
   109  
   110  	got := avro.LogicalDuration{}
   111  	err = dec.Decode(&got)
   112  	require.NoError(t, err)
   113  
   114  	assert.Equal(t, uint32(12), got.Months)
   115  	assert.Equal(t, uint32(34), got.Days)
   116  	assert.Equal(t, uint32(567890), got.Milliseconds)
   117  }
   118  
   119  func TestDecoder_FixedLogicalDurationSizeNot12(t *testing.T) {
   120  	defer ConfigTeardown()
   121  
   122  	data := []byte{0xc, 0x0, 0x0, 0x0, 0x22, 0x0, 0x0, 0x0, 0x52, 0xaa, 0x8}
   123  	schema := `{"name":"foo","type":"fixed","logicalType":"duration","size":11}`
   124  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   125  	require.NoError(t, err)
   126  
   127  	got := avro.LogicalDuration{}
   128  	err = dec.Decode(&got)
   129  	assert.Error(t, err)
   130  	assert.Equal(t, fmt.Errorf("avro: avro.LogicalDuration is unsupported for Avro fixed, size=11"), err)
   131  }
   132  
   133  func TestDecoder_FixedUint64_Full(t *testing.T) {
   134  	defer ConfigTeardown()
   135  
   136  	data := []byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
   137  	schema := `{"type":"fixed", "name": "test", "size": 8}`
   138  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   139  	require.NoError(t, err)
   140  
   141  	var got uint64
   142  	err = dec.Decode(&got)
   143  	require.NoError(t, err)
   144  	assert.Equal(t, uint64(math.MaxUint64), got)
   145  }
   146  func TestDecoder_FixedUint64_Simple(t *testing.T) {
   147  	defer ConfigTeardown()
   148  
   149  	data := []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00}
   150  	schema := `{"type":"fixed", "name": "test", "size": 8}`
   151  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   152  	require.NoError(t, err)
   153  
   154  	var got uint64
   155  	err = dec.Decode(&got)
   156  	require.NoError(t, err)
   157  	assert.Equal(t, uint64(256), got)
   158  }