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