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

     1  package avro_test
     2  
     3  import (
     4  	"bytes"
     5  	"math/big"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/hamba/avro/v2"
    10  	"github.com/stretchr/testify/assert"
    11  	"github.com/stretchr/testify/require"
    12  )
    13  
    14  func TestDecoder_NativeInvalidType(t *testing.T) {
    15  	defer ConfigTeardown()
    16  
    17  	data := []byte{0x01}
    18  	schema := "boolean"
    19  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
    20  	require.NoError(t, err)
    21  
    22  	var want *string
    23  	err = dec.Decode(&want)
    24  
    25  	assert.Error(t, err)
    26  }
    27  
    28  func TestDecoder_Bool(t *testing.T) {
    29  	defer ConfigTeardown()
    30  
    31  	data := []byte{0x01}
    32  	schema := "boolean"
    33  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
    34  	require.NoError(t, err)
    35  
    36  	var b bool
    37  	err = dec.Decode(&b)
    38  
    39  	require.NoError(t, err)
    40  	assert.True(t, b)
    41  }
    42  
    43  func TestDecoder_BoolInvalidSchema(t *testing.T) {
    44  	defer ConfigTeardown()
    45  
    46  	data := []byte{0x01}
    47  	schema := "string"
    48  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
    49  	require.NoError(t, err)
    50  
    51  	var b bool
    52  	err = dec.Decode(&b)
    53  
    54  	assert.Error(t, err)
    55  }
    56  
    57  func TestDecoder_BoolEof(t *testing.T) {
    58  	defer ConfigTeardown()
    59  
    60  	data := []byte{0x4}
    61  	schema := `{"fields":[{"name":"B","type":{"type":"int"}},{"name":"A","type":{"type":"boolean"}}],"name":"foo","type":"record"}`
    62  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
    63  	require.NoError(t, err)
    64  
    65  	var b any
    66  	err = dec.Decode(&b)
    67  
    68  	assert.Error(t, err)
    69  }
    70  
    71  func TestDecoder_Int(t *testing.T) {
    72  	defer ConfigTeardown()
    73  
    74  	data := []byte{0x36}
    75  	schema := "int"
    76  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
    77  	require.NoError(t, err)
    78  
    79  	var i int
    80  	err = dec.Decode(&i)
    81  
    82  	require.NoError(t, err)
    83  	assert.Equal(t, 27, i)
    84  }
    85  
    86  func TestDecoder_IntShortRead(t *testing.T) {
    87  	defer ConfigTeardown()
    88  
    89  	data := []byte{0xe6}
    90  	schema := "int"
    91  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
    92  	require.NoError(t, err)
    93  
    94  	var i int
    95  	err = dec.Decode(&i)
    96  
    97  	assert.Error(t, err)
    98  }
    99  
   100  func TestDecoder_IntInvalidSchema(t *testing.T) {
   101  	defer ConfigTeardown()
   102  
   103  	data := []byte{0x36}
   104  	schema := "string"
   105  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   106  	require.NoError(t, err)
   107  
   108  	var i int
   109  	err = dec.Decode(&i)
   110  
   111  	assert.Error(t, err)
   112  }
   113  
   114  func TestDecoder_Int8(t *testing.T) {
   115  	defer ConfigTeardown()
   116  
   117  	data := []byte{0x36}
   118  	schema := "int"
   119  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   120  	require.NoError(t, err)
   121  
   122  	var i int8
   123  	err = dec.Decode(&i)
   124  
   125  	require.NoError(t, err)
   126  	assert.Equal(t, int8(27), i)
   127  }
   128  
   129  func TestDecoder_Int8InvalidSchema(t *testing.T) {
   130  	defer ConfigTeardown()
   131  
   132  	data := []byte{0x36}
   133  	schema := "string"
   134  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   135  	require.NoError(t, err)
   136  
   137  	var i int8
   138  	err = dec.Decode(&i)
   139  
   140  	assert.Error(t, err)
   141  }
   142  
   143  func TestDecoder_Uint8(t *testing.T) {
   144  	defer ConfigTeardown()
   145  
   146  	data := []byte{0x36}
   147  	schema := "int"
   148  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   149  	require.NoError(t, err)
   150  
   151  	var i uint8
   152  	err = dec.Decode(&i)
   153  
   154  	require.NoError(t, err)
   155  	assert.Equal(t, uint8(27), i)
   156  }
   157  
   158  func TestDecoder_Uint8InvalidSchema(t *testing.T) {
   159  	defer ConfigTeardown()
   160  
   161  	data := []byte{0x36}
   162  	schema := "string"
   163  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   164  	require.NoError(t, err)
   165  
   166  	var i uint8
   167  	err = dec.Decode(&i)
   168  
   169  	assert.Error(t, err)
   170  }
   171  
   172  func TestDecoder_Int16(t *testing.T) {
   173  	defer ConfigTeardown()
   174  
   175  	data := []byte{0x36}
   176  	schema := "int"
   177  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   178  	require.NoError(t, err)
   179  
   180  	var i int16
   181  	err = dec.Decode(&i)
   182  
   183  	require.NoError(t, err)
   184  	assert.Equal(t, int16(27), i)
   185  }
   186  
   187  func TestDecoder_Int16InvalidSchema(t *testing.T) {
   188  	defer ConfigTeardown()
   189  
   190  	data := []byte{0x36}
   191  	schema := "string"
   192  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   193  	require.NoError(t, err)
   194  
   195  	var i int16
   196  	err = dec.Decode(&i)
   197  
   198  	assert.Error(t, err)
   199  }
   200  
   201  func TestDecoder_Uint16(t *testing.T) {
   202  	defer ConfigTeardown()
   203  
   204  	data := []byte{0x36}
   205  	schema := "int"
   206  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   207  	require.NoError(t, err)
   208  
   209  	var i uint16
   210  	err = dec.Decode(&i)
   211  
   212  	require.NoError(t, err)
   213  	assert.Equal(t, uint16(27), i)
   214  }
   215  
   216  func TestDecoder_Uint16InvalidSchema(t *testing.T) {
   217  	defer ConfigTeardown()
   218  
   219  	data := []byte{0x36}
   220  	schema := "string"
   221  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   222  	require.NoError(t, err)
   223  
   224  	var i uint16
   225  	err = dec.Decode(&i)
   226  
   227  	assert.Error(t, err)
   228  }
   229  
   230  func TestDecoder_Int32(t *testing.T) {
   231  	defer ConfigTeardown()
   232  
   233  	data := []byte{0x36}
   234  	schema := "int"
   235  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   236  	require.NoError(t, err)
   237  
   238  	var i int32
   239  	err = dec.Decode(&i)
   240  
   241  	require.NoError(t, err)
   242  	assert.Equal(t, int32(27), i)
   243  }
   244  
   245  func TestDecoder_Int32InvalidSchema(t *testing.T) {
   246  	defer ConfigTeardown()
   247  
   248  	data := []byte{0x36}
   249  	schema := "string"
   250  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   251  	require.NoError(t, err)
   252  
   253  	var i int32
   254  	err = dec.Decode(&i)
   255  
   256  	assert.Error(t, err)
   257  }
   258  
   259  func TestDecoder_Uint32(t *testing.T) {
   260  	defer ConfigTeardown()
   261  
   262  	data := []byte{0x36}
   263  	schema := "long"
   264  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   265  	require.NoError(t, err)
   266  
   267  	var i uint32
   268  	err = dec.Decode(&i)
   269  
   270  	require.NoError(t, err)
   271  	assert.Equal(t, uint32(27), i)
   272  }
   273  
   274  func TestDecoder_Uint32InvalidSchema(t *testing.T) {
   275  	defer ConfigTeardown()
   276  
   277  	data := []byte{0x36}
   278  	schema := "int"
   279  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   280  	require.NoError(t, err)
   281  
   282  	var i uint32
   283  	err = dec.Decode(&i)
   284  
   285  	assert.Error(t, err)
   286  }
   287  
   288  func TestDecoder_Int64(t *testing.T) {
   289  	defer ConfigTeardown()
   290  
   291  	data := []byte{0x36}
   292  	schema := "long"
   293  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   294  	require.NoError(t, err)
   295  
   296  	var i int64
   297  	err = dec.Decode(&i)
   298  
   299  	require.NoError(t, err)
   300  	assert.Equal(t, int64(27), i)
   301  }
   302  
   303  func TestDecoder_Int64ShortRead(t *testing.T) {
   304  	defer ConfigTeardown()
   305  
   306  	data := []byte{0xe6}
   307  	schema := "long"
   308  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   309  	require.NoError(t, err)
   310  
   311  	var i int64
   312  	err = dec.Decode(&i)
   313  
   314  	assert.Error(t, err)
   315  }
   316  
   317  func TestDecoder_Int64InvalidSchema(t *testing.T) {
   318  	defer ConfigTeardown()
   319  
   320  	data := []byte{0x36}
   321  	schema := "string"
   322  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   323  	require.NoError(t, err)
   324  
   325  	var i int64
   326  	err = dec.Decode(&i)
   327  
   328  	assert.Error(t, err)
   329  }
   330  
   331  func TestDecoder_Float32(t *testing.T) {
   332  	defer ConfigTeardown()
   333  
   334  	data := []byte{0x33, 0x33, 0x93, 0x3F}
   335  	schema := "float"
   336  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   337  	require.NoError(t, err)
   338  
   339  	var i float32
   340  	err = dec.Decode(&i)
   341  
   342  	require.NoError(t, err)
   343  	assert.Equal(t, float32(1.15), i)
   344  }
   345  
   346  func TestDecoder_Float32InvalidSchema(t *testing.T) {
   347  	defer ConfigTeardown()
   348  
   349  	data := []byte{0x33, 0x33, 0x93, 0x3F}
   350  	schema := "string"
   351  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   352  	require.NoError(t, err)
   353  
   354  	var i float32
   355  	err = dec.Decode(&i)
   356  
   357  	assert.Error(t, err)
   358  }
   359  
   360  func TestDecoder_Float64(t *testing.T) {
   361  	defer ConfigTeardown()
   362  
   363  	data := []byte{0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0xF2, 0x3F}
   364  	schema := "double"
   365  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   366  	require.NoError(t, err)
   367  
   368  	var i float64
   369  	err = dec.Decode(&i)
   370  
   371  	require.NoError(t, err)
   372  	assert.Equal(t, float64(1.15), i)
   373  }
   374  
   375  func TestDecoder_Float64InvalidSchema(t *testing.T) {
   376  	defer ConfigTeardown()
   377  
   378  	data := []byte{0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0xF2, 0x3F}
   379  	schema := "string"
   380  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   381  	require.NoError(t, err)
   382  
   383  	var i float64
   384  	err = dec.Decode(&i)
   385  
   386  	assert.Error(t, err)
   387  }
   388  
   389  func TestDecoder_String(t *testing.T) {
   390  	defer ConfigTeardown()
   391  
   392  	data := []byte{0x06, 0x66, 0x6F, 0x6F}
   393  	schema := "string"
   394  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   395  	require.NoError(t, err)
   396  
   397  	var str string
   398  	err = dec.Decode(&str)
   399  
   400  	require.NoError(t, err)
   401  	assert.Equal(t, "foo", str)
   402  }
   403  
   404  func TestDecoder_StringShortRead(t *testing.T) {
   405  	defer ConfigTeardown()
   406  
   407  	data := []byte{0x08}
   408  	schema := "string"
   409  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   410  	require.NoError(t, err)
   411  
   412  	var str string
   413  	err = dec.Decode(&str)
   414  
   415  	require.Error(t, err)
   416  }
   417  
   418  func TestDecoder_StringInvalidSchema(t *testing.T) {
   419  	defer ConfigTeardown()
   420  
   421  	data := []byte{0x06, 0x66, 0x6F, 0x6F}
   422  	schema := "int"
   423  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   424  	require.NoError(t, err)
   425  
   426  	var str string
   427  	err = dec.Decode(&str)
   428  
   429  	assert.Error(t, err)
   430  }
   431  
   432  func TestDecoder_Bytes(t *testing.T) {
   433  	defer ConfigTeardown()
   434  
   435  	data := []byte{0x08, 0xEC, 0xAB, 0x44, 0x00}
   436  	schema := "bytes"
   437  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   438  	require.NoError(t, err)
   439  
   440  	var b []byte
   441  	err = dec.Decode(&b)
   442  
   443  	require.NoError(t, err)
   444  	assert.Equal(t, []byte{0xEC, 0xAB, 0x44, 0x00}, b)
   445  }
   446  
   447  func TestDecoder_BytesShortRead(t *testing.T) {
   448  	defer ConfigTeardown()
   449  
   450  	data := []byte{0x08, 0xEC}
   451  	schema := "bytes"
   452  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   453  	require.NoError(t, err)
   454  
   455  	var b []byte
   456  	err = dec.Decode(&b)
   457  
   458  	assert.Error(t, err)
   459  }
   460  
   461  func TestDecoder_BytesInvalidSchema(t *testing.T) {
   462  	defer ConfigTeardown()
   463  
   464  	data := []byte{0x08, 0xEC, 0xAB, 0x44, 0x00}
   465  	schema := "int"
   466  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   467  	require.NoError(t, err)
   468  
   469  	var b []byte
   470  	err = dec.Decode(&b)
   471  
   472  	assert.Error(t, err)
   473  }
   474  
   475  func TestDecoder_Time_Date(t *testing.T) {
   476  	defer ConfigTeardown()
   477  
   478  	data := []byte{0xCA, 0xAD, 0x2A}
   479  	schema := `{"type":"int","logicalType":"date"}`
   480  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   481  	require.NoError(t, err)
   482  
   483  	var got time.Time
   484  	err = dec.Decode(&got)
   485  
   486  	require.NoError(t, err)
   487  	assert.Equal(t, time.Date(2920, 1, 2, 0, 0, 0, 0, time.UTC), got)
   488  }
   489  
   490  func TestDecoder_Time_TimestampMillis(t *testing.T) {
   491  	defer ConfigTeardown()
   492  
   493  	data := []byte{0x90, 0xB2, 0xAE, 0xC3, 0xEC, 0x5B}
   494  	schema := `{"type":"long","logicalType":"timestamp-millis"}`
   495  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   496  	require.NoError(t, err)
   497  
   498  	var got time.Time
   499  	err = dec.Decode(&got)
   500  
   501  	require.NoError(t, err)
   502  	assert.Equal(t, time.Date(2020, 1, 2, 3, 4, 5, 0, time.UTC), got)
   503  }
   504  
   505  func TestDecoder_Time_TimestampMillisZero(t *testing.T) {
   506  	defer ConfigTeardown()
   507  
   508  	data := []byte{0xff, 0xdf, 0xe6, 0xa2, 0xe2, 0xa0, 0x1c}
   509  	schema := `{"type":"long","logicalType":"timestamp-millis"}`
   510  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   511  	require.NoError(t, err)
   512  
   513  	var got time.Time
   514  	err = dec.Decode(&got)
   515  
   516  	require.NoError(t, err)
   517  	assert.Equal(t, time.Time{}, got)
   518  }
   519  
   520  func TestDecoder_Time_TimestampMillisOneMillis(t *testing.T) {
   521  	defer ConfigTeardown()
   522  
   523  	data := []byte{0x02}
   524  	schema := `{"type":"long","logicalType":"timestamp-millis"}`
   525  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   526  	require.NoError(t, err)
   527  
   528  	var got time.Time
   529  	err = dec.Decode(&got)
   530  
   531  	require.NoError(t, err)
   532  	assert.Equal(t, time.Date(1970, 1, 1, 0, 0, 0, 1e6, time.UTC), got)
   533  }
   534  
   535  func TestDecoder_Time_TimestampMicros(t *testing.T) {
   536  	defer ConfigTeardown()
   537  
   538  	data := []byte{0x80, 0xCD, 0xB7, 0xA2, 0xEE, 0xC7, 0xCD, 0x05}
   539  	schema := `{"type":"long","logicalType":"timestamp-micros"}`
   540  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   541  	require.NoError(t, err)
   542  
   543  	var got time.Time
   544  	err = dec.Decode(&got)
   545  
   546  	require.NoError(t, err)
   547  	assert.Equal(t, time.Date(2020, 1, 2, 3, 4, 5, 0, time.UTC), got)
   548  }
   549  
   550  func TestDecoder_Time_TimestampMicrosZero(t *testing.T) {
   551  	defer ConfigTeardown()
   552  
   553  	data := []byte{0xff, 0xff, 0xdd, 0xf2, 0xdf, 0xff, 0xdf, 0xdc, 0x1}
   554  	schema := `{"type":"long","logicalType":"timestamp-micros"}`
   555  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   556  	require.NoError(t, err)
   557  
   558  	var got time.Time
   559  	err = dec.Decode(&got)
   560  
   561  	require.NoError(t, err)
   562  	assert.Equal(t, time.Time{}, got)
   563  }
   564  
   565  func TestDecoder_Time_TimestampMillisOneMicros(t *testing.T) {
   566  	defer ConfigTeardown()
   567  
   568  	data := []byte{0x02}
   569  	schema := `{"type":"long","logicalType":"timestamp-micros"}`
   570  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   571  	require.NoError(t, err)
   572  
   573  	var got time.Time
   574  	err = dec.Decode(&got)
   575  
   576  	require.NoError(t, err)
   577  	assert.Equal(t, time.Date(1970, 1, 1, 0, 0, 0, 1e3, time.UTC), got)
   578  }
   579  
   580  func TestDecoder_Time_LocalTimestampMillis(t *testing.T) {
   581  	defer ConfigTeardown()
   582  
   583  	data := []byte{0x90, 0xB2, 0xAE, 0xC3, 0xEC, 0x5B}
   584  	schema := `{"type":"long","logicalType":"local-timestamp-millis"}`
   585  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   586  	require.NoError(t, err)
   587  
   588  	var got time.Time
   589  	err = dec.Decode(&got)
   590  
   591  	require.NoError(t, err)
   592  	assert.Equal(t, time.Date(2020, 1, 2, 3, 4, 5, 0, time.Local), got)
   593  }
   594  
   595  func TestDecoder_Time_LocalTimestampMillisZero(t *testing.T) {
   596  	defer ConfigTeardown()
   597  
   598  	data := []byte{0xff, 0xdf, 0xe6, 0xa2, 0xe2, 0xa0, 0x1c}
   599  	schema := `{"type":"long","logicalType":"local-timestamp-millis"}`
   600  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   601  	require.NoError(t, err)
   602  
   603  	var got time.Time
   604  	err = dec.Decode(&got)
   605  
   606  	require.NoError(t, err)
   607  	assert.Equal(t, time.Date(1, 1, 1, 0, 0, 0, 0, time.Local), got)
   608  }
   609  
   610  func TestDecoder_Time_LocalTimestampMillisOneMillis(t *testing.T) {
   611  	defer ConfigTeardown()
   612  
   613  	data := []byte{0x02}
   614  	schema := `{"type":"long","logicalType":"local-timestamp-millis"}`
   615  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   616  	require.NoError(t, err)
   617  
   618  	var got time.Time
   619  	err = dec.Decode(&got)
   620  
   621  	require.NoError(t, err)
   622  	assert.Equal(t, time.Date(1970, 1, 1, 0, 0, 0, 1e6, time.Local), got)
   623  }
   624  
   625  func TestDecoder_Time_LocalTimestampMicros(t *testing.T) {
   626  	defer ConfigTeardown()
   627  
   628  	data := []byte{0x80, 0xCD, 0xB7, 0xA2, 0xEE, 0xC7, 0xCD, 0x05}
   629  	schema := `{"type":"long","logicalType":"local-timestamp-micros"}`
   630  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   631  	require.NoError(t, err)
   632  
   633  	var got time.Time
   634  	err = dec.Decode(&got)
   635  
   636  	require.NoError(t, err)
   637  	assert.Equal(t, time.Date(2020, 1, 2, 3, 4, 5, 0, time.Local), got)
   638  }
   639  
   640  func TestDecoder_Time_LocalTimestampMicrosZero(t *testing.T) {
   641  	defer ConfigTeardown()
   642  
   643  	data := []byte{0xff, 0xff, 0xdd, 0xf2, 0xdf, 0xff, 0xdf, 0xdc, 0x1}
   644  	schema := `{"type":"long","logicalType":"local-timestamp-micros"}`
   645  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   646  	require.NoError(t, err)
   647  
   648  	var got time.Time
   649  	err = dec.Decode(&got)
   650  
   651  	require.NoError(t, err)
   652  	assert.Equal(t, time.Date(1, 1, 1, 0, 0, 0, 0, time.Local), got)
   653  }
   654  
   655  func TestDecoder_Time_LocalTimestampMillisOneMicros(t *testing.T) {
   656  	defer ConfigTeardown()
   657  
   658  	data := []byte{0x02}
   659  	schema := `{"type":"long","logicalType":"local-timestamp-micros"}`
   660  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   661  	require.NoError(t, err)
   662  
   663  	var got time.Time
   664  	err = dec.Decode(&got)
   665  
   666  	require.NoError(t, err)
   667  	assert.Equal(t, time.Date(1970, 1, 1, 0, 0, 0, 1e3, time.Local), got)
   668  }
   669  
   670  func TestDecoder_TimeInvalidSchema(t *testing.T) {
   671  	defer ConfigTeardown()
   672  
   673  	data := []byte{0x80, 0xCD, 0xB7, 0xA2, 0xEE, 0xC7, 0xCD, 0x05}
   674  	schema := `{"type":"long"}`
   675  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   676  	require.NoError(t, err)
   677  
   678  	var got time.Time
   679  	err = dec.Decode(&got)
   680  
   681  	assert.Error(t, err)
   682  }
   683  
   684  func TestDecoder_Duration_TimeMillis(t *testing.T) {
   685  	defer ConfigTeardown()
   686  
   687  	data := []byte{0xAA, 0xB4, 0xDE, 0x75}
   688  	schema := `{"type":"int","logicalType":"time-millis"}`
   689  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   690  	require.NoError(t, err)
   691  
   692  	var got time.Duration
   693  	err = dec.Decode(&got)
   694  
   695  	require.NoError(t, err)
   696  	assert.Equal(t, 123456789*time.Millisecond, got)
   697  }
   698  
   699  func TestDecoder_Duration_TimeMicros(t *testing.T) {
   700  	defer ConfigTeardown()
   701  
   702  	data := []byte{0x86, 0xEA, 0xC8, 0xE9, 0x97, 0x07}
   703  	schema := `{"type":"long","logicalType":"time-micros"}`
   704  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   705  	require.NoError(t, err)
   706  
   707  	var got time.Duration
   708  	err = dec.Decode(&got)
   709  
   710  	require.NoError(t, err)
   711  	assert.Equal(t, 123456789123*time.Microsecond, got)
   712  }
   713  
   714  func TestDecoder_Duration_InvalidLogicalType(t *testing.T) {
   715  	defer ConfigTeardown()
   716  
   717  	data := []byte{0x86, 0xEA, 0xC8, 0xE9, 0x97, 0x07}
   718  	schema := `{"type":"long","logicalType":"timestamp-micros"}`
   719  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   720  	require.NoError(t, err)
   721  
   722  	var got time.Duration
   723  	err = dec.Decode(&got)
   724  
   725  	assert.Error(t, err)
   726  }
   727  
   728  func TestDecoder_DurationInvalidSchema(t *testing.T) {
   729  	defer ConfigTeardown()
   730  
   731  	data := []byte{0x86, 0xEA, 0xC8, 0xE9, 0x97, 0x07}
   732  	schema := `{"type":"string"}`
   733  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   734  	require.NoError(t, err)
   735  
   736  	var got time.Duration
   737  	err = dec.Decode(&got)
   738  
   739  	assert.Error(t, err)
   740  }
   741  
   742  func TestDecoder_BytesRat_Positive(t *testing.T) {
   743  	defer ConfigTeardown()
   744  
   745  	data := []byte{0x6, 0x00, 0x87, 0x78}
   746  	schema := `{"type":"bytes","logicalType":"decimal","precision":4,"scale":2}`
   747  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   748  	require.NoError(t, err)
   749  
   750  	got := &big.Rat{}
   751  	err = dec.Decode(got)
   752  
   753  	require.NoError(t, err)
   754  	assert.Equal(t, big.NewRat(1734, 5), got)
   755  }
   756  
   757  func TestDecoder_BytesRat_Negative(t *testing.T) {
   758  	defer ConfigTeardown()
   759  
   760  	data := []byte{0x6, 0xFF, 0x78, 0x88}
   761  	schema := `{"type":"bytes","logicalType":"decimal","precision":4,"scale":2}`
   762  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   763  	require.NoError(t, err)
   764  
   765  	got := &big.Rat{}
   766  	err = dec.Decode(got)
   767  
   768  	require.NoError(t, err)
   769  	assert.Equal(t, big.NewRat(-1734, 5), got)
   770  }
   771  
   772  func TestDecoder_BytesRat_Zero(t *testing.T) {
   773  	defer ConfigTeardown()
   774  
   775  	data := []byte{0x02, 0x00}
   776  	schema := `{"type":"bytes","logicalType":"decimal","precision":4,"scale":2}`
   777  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   778  	require.NoError(t, err)
   779  
   780  	got := &big.Rat{}
   781  	err = dec.Decode(got)
   782  
   783  	require.NoError(t, err)
   784  	assert.Equal(t, big.NewRat(0, 1), got)
   785  }
   786  
   787  func TestDecoder_BytesRatInvalidSchema(t *testing.T) {
   788  	defer ConfigTeardown()
   789  
   790  	data := []byte{0x02, 0x00}
   791  	schema := `{"type":"string"}`
   792  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   793  	require.NoError(t, err)
   794  
   795  	got := &big.Rat{}
   796  	err = dec.Decode(got)
   797  
   798  	assert.Error(t, err)
   799  }
   800  
   801  func TestDecoder_BytesRatInvalidLogicalSchema(t *testing.T) {
   802  	defer ConfigTeardown()
   803  
   804  	data := []byte{0x02, 0x00}
   805  	schema := `{"type":"string","logicalType":"uuid"}`
   806  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   807  	require.NoError(t, err)
   808  
   809  	got := &big.Rat{}
   810  	err = dec.Decode(got)
   811  
   812  	assert.Error(t, err)
   813  }