github.com/alibabacloud-go/tea@v1.3.10/tea/json_parser_test.go (about)

     1  package tea
     2  
     3  import (
     4  	"reflect"
     5  	"testing"
     6  
     7  	"github.com/alibabacloud-go/tea/utils"
     8  	jsoniter "github.com/json-iterator/go"
     9  	"github.com/modern-go/reflect2"
    10  )
    11  
    12  func TestUnmarshal(t *testing.T) {
    13  	from := []byte(`{}`)
    14  	to := &struct{}{}
    15  	// support auto json type trans
    16  
    17  	err := jsonParser.Unmarshal(from, to)
    18  	utils.AssertNil(t, err)
    19  	str, err := jsonParser.Marshal(to)
    20  	utils.AssertNil(t, err)
    21  	utils.AssertEqual(t, `{}`, string(str))
    22  }
    23  
    24  func TestUnmarshal_int(t *testing.T) {
    25  	to := &struct {
    26  		INT int
    27  	}{}
    28  	from := []byte(`{"INT":100}`)
    29  
    30  	err := jsonParser.Unmarshal(from, to)
    31  	utils.AssertNil(t, err)
    32  	utils.AssertEqual(t, 100, to.INT)
    33  	str, err := jsonParser.Marshal(to)
    34  	utils.AssertNil(t, err)
    35  	utils.AssertEqual(t, `{"INT":100}`, string(str))
    36  
    37  	from = []byte(`{"INT":100.1}`)
    38  
    39  	err = jsonParser.Unmarshal(from, to)
    40  	utils.AssertNil(t, err)
    41  	utils.AssertEqual(t, 100, to.INT)
    42  	str, err = jsonParser.Marshal(to)
    43  	utils.AssertNil(t, err)
    44  	utils.AssertEqual(t, `{"INT":100}`, string(str))
    45  
    46  	// string to int
    47  	from = []byte(`{"INT":"100"}`)
    48  
    49  	err = jsonParser.Unmarshal(from, to)
    50  	utils.AssertNil(t, err)
    51  	utils.AssertEqual(t, 100, to.INT)
    52  	str, err = jsonParser.Marshal(to)
    53  	utils.AssertNil(t, err)
    54  	utils.AssertEqual(t, `{"INT":100}`, string(str))
    55  
    56  	from = []byte(`{"INT":""}`)
    57  
    58  	err = jsonParser.Unmarshal(from, to)
    59  	utils.AssertNil(t, err)
    60  	utils.AssertEqual(t, 0, to.INT)
    61  	str, err = jsonParser.Marshal(to)
    62  	utils.AssertNil(t, err)
    63  	utils.AssertEqual(t, `{"INT":0}`, string(str))
    64  
    65  	// bool to int
    66  	from = []byte(`{"INT":true}`)
    67  
    68  	err = jsonParser.Unmarshal(from, to)
    69  	utils.AssertNil(t, err)
    70  	utils.AssertEqual(t, 1, to.INT)
    71  	str, err = jsonParser.Marshal(to)
    72  	utils.AssertNil(t, err)
    73  	utils.AssertEqual(t, `{"INT":1}`, string(str))
    74  
    75  	from = []byte(`{"INT":false}`)
    76  
    77  	err = jsonParser.Unmarshal(from, to)
    78  	utils.AssertNil(t, err)
    79  	utils.AssertEqual(t, 0, to.INT)
    80  	str, err = jsonParser.Marshal(to)
    81  	utils.AssertNil(t, err)
    82  	utils.AssertEqual(t, `{"INT":0}`, string(str))
    83  
    84  	// nil to int
    85  	from = []byte(`{"INT":null}`)
    86  
    87  	err = jsonParser.Unmarshal(from, to)
    88  	utils.AssertNil(t, err)
    89  	utils.AssertEqual(t, 0, to.INT)
    90  	str, err = jsonParser.Marshal(to)
    91  	utils.AssertNil(t, err)
    92  	utils.AssertEqual(t, `{"INT":0}`, string(str))
    93  
    94  	// fuzzy decode int
    95  	from = []byte(`{"INT":100000000000000000000000000.1}`)
    96  
    97  	err = jsonParser.Unmarshal(from, to)
    98  	utils.AssertNotNil(t, err)
    99  	utils.AssertEqual(t, "INT: fuzzy decode int: exceed range, error found in #10 byte of ...|00000000.1|..., bigger context ...|100000000000000000000000000.1|...", err.Error())
   100  
   101  	from = []byte(`{"INT":{}}`)
   102  
   103  	err = jsonParser.Unmarshal(from, to)
   104  	utils.AssertNotNil(t, err)
   105  	utils.AssertEqual(t, "INT: readUint64: unexpected character: \xff, error found in #0 byte of ...||..., bigger context ...||...", err.Error())
   106  }
   107  
   108  func TestUnmarshal_uint(t *testing.T) {
   109  	to := &struct {
   110  		UINT uint
   111  	}{}
   112  	from := []byte(`{"UINT":100}`)
   113  
   114  	err := jsonParser.Unmarshal(from, to)
   115  	utils.AssertNil(t, err)
   116  	utils.AssertEqual(t, uint(100), to.UINT)
   117  	str, err := jsonParser.Marshal(to)
   118  	utils.AssertNil(t, err)
   119  	utils.AssertEqual(t, `{"UINT":100}`, string(str))
   120  
   121  	from = []byte(`{"UINT":100.1}`)
   122  
   123  	err = jsonParser.Unmarshal(from, to)
   124  	utils.AssertNil(t, err)
   125  	utils.AssertEqual(t, uint(100), to.UINT)
   126  	str, err = jsonParser.Marshal(to)
   127  	utils.AssertNil(t, err)
   128  	utils.AssertEqual(t, `{"UINT":100}`, string(str))
   129  
   130  	// fuzzy decode uint
   131  	from = []byte(`{"UINT":100000000000000000000000000.1}`)
   132  
   133  	err = jsonParser.Unmarshal(from, to)
   134  	utils.AssertNotNil(t, err)
   135  	utils.AssertEqual(t, "UINT: fuzzy decode uint: exceed range, error found in #10 byte of ...|00000000.1|..., bigger context ...|100000000000000000000000000.1|...", err.Error())
   136  }
   137  
   138  func TestUnmarshal_int8(t *testing.T) {
   139  	to := &struct {
   140  		INT8 int8
   141  	}{}
   142  	from := []byte(`{"INT8":100}`)
   143  
   144  	err := jsonParser.Unmarshal(from, to)
   145  	utils.AssertNil(t, err)
   146  	utils.AssertEqual(t, int8(100), to.INT8)
   147  	str, err := jsonParser.Marshal(to)
   148  	utils.AssertNil(t, err)
   149  	utils.AssertEqual(t, `{"INT8":100}`, string(str))
   150  
   151  	from = []byte(`{"INT8":100.1}`)
   152  
   153  	err = jsonParser.Unmarshal(from, to)
   154  	utils.AssertNil(t, err)
   155  	utils.AssertEqual(t, int8(100), to.INT8)
   156  	str, err = jsonParser.Marshal(to)
   157  	utils.AssertNil(t, err)
   158  	utils.AssertEqual(t, `{"INT8":100}`, string(str))
   159  
   160  	// fuzzy decode uint
   161  	from = []byte(`{"INT8":100000000000000000000000000.1}`)
   162  
   163  	err = jsonParser.Unmarshal(from, to)
   164  	utils.AssertNotNil(t, err)
   165  	utils.AssertEqual(t, "INT8: fuzzy decode int8: exceed range, error found in #10 byte of ...|00000000.1|..., bigger context ...|100000000000000000000000000.1|...", err.Error())
   166  }
   167  
   168  func TestUnmarshal_uint8(t *testing.T) {
   169  	to := &struct {
   170  		UINT8 uint8
   171  	}{}
   172  	from := []byte(`{"UINT8":100}`)
   173  
   174  	err := jsonParser.Unmarshal(from, to)
   175  	utils.AssertNil(t, err)
   176  	utils.AssertEqual(t, uint8(100), to.UINT8)
   177  	str, err := jsonParser.Marshal(to)
   178  	utils.AssertNil(t, err)
   179  	utils.AssertEqual(t, `{"UINT8":100}`, string(str))
   180  
   181  	from = []byte(`{"UINT8":100.1}`)
   182  
   183  	err = jsonParser.Unmarshal(from, to)
   184  	utils.AssertNil(t, err)
   185  	utils.AssertEqual(t, uint8(100), to.UINT8)
   186  	str, err = jsonParser.Marshal(to)
   187  	utils.AssertNil(t, err)
   188  	utils.AssertEqual(t, `{"UINT8":100}`, string(str))
   189  
   190  	// fuzzy decode uint
   191  	from = []byte(`{"UINT8":100000000000000000000000000.1}`)
   192  
   193  	err = jsonParser.Unmarshal(from, to)
   194  	utils.AssertNotNil(t, err)
   195  	utils.AssertEqual(t, "UINT8: fuzzy decode uint8: exceed range, error found in #10 byte of ...|00000000.1|..., bigger context ...|100000000000000000000000000.1|...", err.Error())
   196  }
   197  
   198  func TestUnmarshal_int16(t *testing.T) {
   199  	to := &struct {
   200  		INT16 int16
   201  	}{}
   202  	from := []byte(`{"INT16":100}`)
   203  
   204  	err := jsonParser.Unmarshal(from, to)
   205  	utils.AssertNil(t, err)
   206  	utils.AssertEqual(t, int16(100), to.INT16)
   207  	str, err := jsonParser.Marshal(to)
   208  	utils.AssertNil(t, err)
   209  	utils.AssertEqual(t, `{"INT16":100}`, string(str))
   210  
   211  	from = []byte(`{"INT16":100.1}`)
   212  
   213  	err = jsonParser.Unmarshal(from, to)
   214  	utils.AssertNil(t, err)
   215  	utils.AssertEqual(t, int16(100), to.INT16)
   216  	str, err = jsonParser.Marshal(to)
   217  	utils.AssertNil(t, err)
   218  	utils.AssertEqual(t, `{"INT16":100}`, string(str))
   219  
   220  	// fuzzy decode uint
   221  	from = []byte(`{"INT16":100000000000000000000000000.1}`)
   222  
   223  	err = jsonParser.Unmarshal(from, to)
   224  	utils.AssertNotNil(t, err)
   225  	utils.AssertEqual(t, "INT16: fuzzy decode int16: exceed range, error found in #10 byte of ...|00000000.1|..., bigger context ...|100000000000000000000000000.1|...", err.Error())
   226  }
   227  
   228  func TestUnmarshal_uint16(t *testing.T) {
   229  	to := &struct {
   230  		UINT16 uint16
   231  	}{}
   232  	from := []byte(`{"UINT16":100}`)
   233  
   234  	err := jsonParser.Unmarshal(from, to)
   235  	utils.AssertNil(t, err)
   236  	utils.AssertEqual(t, uint16(100), to.UINT16)
   237  	str, err := jsonParser.Marshal(to)
   238  	utils.AssertNil(t, err)
   239  	utils.AssertEqual(t, `{"UINT16":100}`, string(str))
   240  
   241  	from = []byte(`{"UINT16":100.1}`)
   242  
   243  	err = jsonParser.Unmarshal(from, to)
   244  	utils.AssertNil(t, err)
   245  	utils.AssertEqual(t, uint16(100), to.UINT16)
   246  	str, err = jsonParser.Marshal(to)
   247  	utils.AssertNil(t, err)
   248  	utils.AssertEqual(t, `{"UINT16":100}`, string(str))
   249  
   250  	// fuzzy decode uint
   251  	from = []byte(`{"UINT16":100000000000000000000000000.1}`)
   252  
   253  	err = jsonParser.Unmarshal(from, to)
   254  	utils.AssertNotNil(t, err)
   255  	utils.AssertEqual(t, "UINT16: fuzzy decode uint16: exceed range, error found in #10 byte of ...|00000000.1|..., bigger context ...|100000000000000000000000000.1|...", err.Error())
   256  }
   257  
   258  func TestUnmarshal_int32(t *testing.T) {
   259  	to := &struct {
   260  		INT32 int32
   261  	}{}
   262  	from := []byte(`{"INT32":100}`)
   263  
   264  	err := jsonParser.Unmarshal(from, to)
   265  	utils.AssertNil(t, err)
   266  	utils.AssertEqual(t, int32(100), to.INT32)
   267  	str, err := jsonParser.Marshal(to)
   268  	utils.AssertNil(t, err)
   269  	utils.AssertEqual(t, `{"INT32":100}`, string(str))
   270  
   271  	from = []byte(`{"INT32":100.1}`)
   272  
   273  	err = jsonParser.Unmarshal(from, to)
   274  	utils.AssertNil(t, err)
   275  	utils.AssertEqual(t, int32(100), to.INT32)
   276  	str, err = jsonParser.Marshal(to)
   277  	utils.AssertNil(t, err)
   278  	utils.AssertEqual(t, `{"INT32":100}`, string(str))
   279  
   280  	// fuzzy decode uint
   281  	from = []byte(`{"INT32":100000000000000000000000000.1}`)
   282  
   283  	err = jsonParser.Unmarshal(from, to)
   284  	utils.AssertNotNil(t, err)
   285  	utils.AssertEqual(t, "INT32: fuzzy decode int32: exceed range, error found in #10 byte of ...|00000000.1|..., bigger context ...|100000000000000000000000000.1|...", err.Error())
   286  }
   287  
   288  func TestUnmarshal_uint32(t *testing.T) {
   289  	to := &struct {
   290  		UINT32 uint32
   291  	}{}
   292  	from := []byte(`{"UINT32":100}`)
   293  
   294  	err := jsonParser.Unmarshal(from, to)
   295  	utils.AssertNil(t, err)
   296  	utils.AssertEqual(t, uint32(100), to.UINT32)
   297  	str, err := jsonParser.Marshal(to)
   298  	utils.AssertNil(t, err)
   299  	utils.AssertEqual(t, `{"UINT32":100}`, string(str))
   300  
   301  	from = []byte(`{"UINT32":100.1}`)
   302  
   303  	err = jsonParser.Unmarshal(from, to)
   304  	utils.AssertNil(t, err)
   305  	utils.AssertEqual(t, uint32(100), to.UINT32)
   306  	str, err = jsonParser.Marshal(to)
   307  	utils.AssertNil(t, err)
   308  	utils.AssertEqual(t, `{"UINT32":100}`, string(str))
   309  
   310  	// fuzzy decode uint
   311  	from = []byte(`{"UINT32":100000000000000000000000000.1}`)
   312  
   313  	err = jsonParser.Unmarshal(from, to)
   314  	utils.AssertNotNil(t, err)
   315  	utils.AssertEqual(t, "UINT32: fuzzy decode uint32: exceed range, error found in #10 byte of ...|00000000.1|..., bigger context ...|100000000000000000000000000.1|...", err.Error())
   316  }
   317  
   318  func TestUnmarshal_int64(t *testing.T) {
   319  	to := &struct {
   320  		INT64 int64
   321  	}{}
   322  	from := []byte(`{"INT64":100}`)
   323  
   324  	err := jsonParser.Unmarshal(from, to)
   325  	utils.AssertNil(t, err)
   326  	utils.AssertEqual(t, int64(100), to.INT64)
   327  	str, err := jsonParser.Marshal(to)
   328  	utils.AssertNil(t, err)
   329  	utils.AssertEqual(t, `{"INT64":100}`, string(str))
   330  
   331  	from = []byte(`{"INT64":100.1}`)
   332  
   333  	err = jsonParser.Unmarshal(from, to)
   334  	utils.AssertNil(t, err)
   335  	utils.AssertEqual(t, int64(100), to.INT64)
   336  	str, err = jsonParser.Marshal(to)
   337  	utils.AssertNil(t, err)
   338  	utils.AssertEqual(t, `{"INT64":100}`, string(str))
   339  
   340  	// fuzzy decode uint
   341  	from = []byte(`{"INT64":100000000000000000000000000.1}`)
   342  
   343  	err = jsonParser.Unmarshal(from, to)
   344  	utils.AssertNotNil(t, err)
   345  	utils.AssertEqual(t, "INT64: fuzzy decode int64: exceed range, error found in #10 byte of ...|00000000.1|..., bigger context ...|100000000000000000000000000.1|...", err.Error())
   346  }
   347  
   348  func TestUnmarshal_uint64(t *testing.T) {
   349  	to := &struct {
   350  		UINT64 uint64
   351  	}{}
   352  	from := []byte(`{"UINT64":100}`)
   353  
   354  	err := jsonParser.Unmarshal(from, to)
   355  	utils.AssertNil(t, err)
   356  	utils.AssertEqual(t, uint64(100), to.UINT64)
   357  	str, err := jsonParser.Marshal(to)
   358  	utils.AssertNil(t, err)
   359  	utils.AssertEqual(t, `{"UINT64":100}`, string(str))
   360  
   361  	from = []byte(`{"UINT64":100.1}`)
   362  
   363  	err = jsonParser.Unmarshal(from, to)
   364  	utils.AssertNil(t, err)
   365  	utils.AssertEqual(t, uint64(100), to.UINT64)
   366  	str, err = jsonParser.Marshal(to)
   367  	utils.AssertNil(t, err)
   368  	utils.AssertEqual(t, `{"UINT64":100}`, string(str))
   369  
   370  	// fuzzy decode uint
   371  	from = []byte(`{"UINT64":100000000000000000000000000.1}`)
   372  
   373  	err = jsonParser.Unmarshal(from, to)
   374  	utils.AssertNotNil(t, err)
   375  	utils.AssertEqual(t, "UINT64: fuzzy decode uint64: exceed range, error found in #10 byte of ...|00000000.1|..., bigger context ...|100000000000000000000000000.1|...", err.Error())
   376  }
   377  
   378  func TestUnmarshal_string(t *testing.T) {
   379  	to := &struct {
   380  		STRING string
   381  	}{}
   382  	// string to string
   383  	from := []byte(`{"STRING":""}`)
   384  
   385  	err := jsonParser.Unmarshal(from, to)
   386  	utils.AssertNil(t, err)
   387  	utils.AssertEqual(t, "", to.STRING)
   388  	str, err := jsonParser.Marshal(to)
   389  	utils.AssertNil(t, err)
   390  	utils.AssertEqual(t, `{"STRING":""}`, string(str))
   391  
   392  	// number to string
   393  	from = []byte(`{"STRING":100}`)
   394  
   395  	err = jsonParser.Unmarshal(from, to)
   396  	utils.AssertNil(t, err)
   397  	utils.AssertEqual(t, "100", to.STRING)
   398  	str, err = jsonParser.Marshal(to)
   399  	utils.AssertNil(t, err)
   400  	utils.AssertEqual(t, `{"STRING":"100"}`, string(str))
   401  
   402  	// bool to string
   403  	from = []byte(`{"STRING":true}`)
   404  
   405  	err = jsonParser.Unmarshal(from, to)
   406  	utils.AssertNil(t, err)
   407  	utils.AssertEqual(t, "true", to.STRING)
   408  	str, err = jsonParser.Marshal(to)
   409  	utils.AssertNil(t, err)
   410  	utils.AssertEqual(t, `{"STRING":"true"}`, string(str))
   411  
   412  	// nil to string
   413  	from = []byte(`{"STRING":null}`)
   414  
   415  	err = jsonParser.Unmarshal(from, to)
   416  	utils.AssertNil(t, err)
   417  	utils.AssertEqual(t, "", to.STRING)
   418  	str, err = jsonParser.Marshal(to)
   419  	utils.AssertNil(t, err)
   420  	utils.AssertEqual(t, `{"STRING":""}`, string(str))
   421  
   422  	// other to string
   423  	from = []byte(`{"STRING":{}}`)
   424  
   425  	err = jsonParser.Unmarshal(from, to)
   426  	utils.AssertNotNil(t, err)
   427  	utils.AssertEqual(t, "STRING: fuzzyStringDecoder: not number or string or bool, error found in #10 byte of ...|{\"STRING\":{}}|..., bigger context ...|{\"STRING\":{}}|...", err.Error())
   428  }
   429  
   430  func TestUnmarshal_bool(t *testing.T) {
   431  	to := &struct {
   432  		BOOL bool
   433  	}{}
   434  	// bool to bool
   435  	from := []byte(`{"BOOL":true}`)
   436  
   437  	err := jsonParser.Unmarshal(from, to)
   438  	utils.AssertNil(t, err)
   439  	utils.AssertEqual(t, true, to.BOOL)
   440  	str, err := jsonParser.Marshal(to)
   441  	utils.AssertNil(t, err)
   442  	utils.AssertEqual(t, `{"BOOL":true}`, string(str))
   443  
   444  	// number to bool
   445  	from = []byte(`{"BOOL":100}`)
   446  
   447  	err = jsonParser.Unmarshal(from, to)
   448  	utils.AssertNil(t, err)
   449  	utils.AssertEqual(t, true, to.BOOL)
   450  	str, err = jsonParser.Marshal(to)
   451  	utils.AssertNil(t, err)
   452  	utils.AssertEqual(t, `{"BOOL":true}`, string(str))
   453  
   454  	from = []byte(`{"BOOL":0}`)
   455  
   456  	err = jsonParser.Unmarshal(from, to)
   457  	utils.AssertNil(t, err)
   458  	utils.AssertEqual(t, false, to.BOOL)
   459  	str, err = jsonParser.Marshal(to)
   460  	utils.AssertNil(t, err)
   461  	utils.AssertEqual(t, `{"BOOL":false}`, string(str))
   462  
   463  	// invalid number literal
   464  	from = []byte(`{"BOOL": 1000000000000000000000000000000000000000}`)
   465  
   466  	err = jsonParser.Unmarshal(from, to)
   467  	utils.AssertNotNil(t, err)
   468  	utils.AssertEqual(t, "BOOL: fuzzyBoolDecoder: get value from json.number failed, error found in #10 byte of ...|0000000000}|..., bigger context ...|{\"BOOL\": 1000000000000000000000000000000000000000}|...", err.Error())
   469  
   470  	// bool to string
   471  	from = []byte(`{"BOOL":"true"}`)
   472  
   473  	err = jsonParser.Unmarshal(from, to)
   474  	utils.AssertNil(t, err)
   475  	utils.AssertEqual(t, true, to.BOOL)
   476  	str, err = jsonParser.Marshal(to)
   477  	utils.AssertNil(t, err)
   478  	utils.AssertEqual(t, `{"BOOL":true}`, string(str))
   479  
   480  	from = []byte(`{"BOOL":"false"}`)
   481  
   482  	err = jsonParser.Unmarshal(from, to)
   483  	utils.AssertNil(t, err)
   484  	utils.AssertEqual(t, false, to.BOOL)
   485  	str, err = jsonParser.Marshal(to)
   486  	utils.AssertNil(t, err)
   487  	utils.AssertEqual(t, `{"BOOL":false}`, string(str))
   488  
   489  	from = []byte(`{"BOOL":"other"}`)
   490  
   491  	err = jsonParser.Unmarshal(from, to)
   492  	utils.AssertNotNil(t, err)
   493  	utils.AssertEqual(t, "BOOL: fuzzyBoolDecoder: unsupported bool value: other, error found in #10 byte of ...|L\":\"other\"}|..., bigger context ...|{\"BOOL\":\"other\"}|...", err.Error())
   494  
   495  	// nil to bool
   496  	from = []byte(`{"BOOL":null}`)
   497  
   498  	err = jsonParser.Unmarshal(from, to)
   499  	utils.AssertNil(t, err)
   500  	utils.AssertEqual(t, false, to.BOOL)
   501  	str, err = jsonParser.Marshal(to)
   502  	utils.AssertNil(t, err)
   503  	utils.AssertEqual(t, `{"BOOL":false}`, string(str))
   504  
   505  	// other to string
   506  	from = []byte(`{"BOOL":{}}`)
   507  
   508  	err = jsonParser.Unmarshal(from, to)
   509  	utils.AssertNotNil(t, err)
   510  	utils.AssertEqual(t, "BOOL: fuzzyBoolDecoder: not number or string or nil, error found in #8 byte of ...|{\"BOOL\":{}}|..., bigger context ...|{\"BOOL\":{}}|...", err.Error())
   511  }
   512  
   513  func TestUnmarshal_array(t *testing.T) {
   514  	to := &struct {
   515  		Array []string
   516  	}{}
   517  	// bool to bool
   518  	from := []byte(`{"Array":[]}`)
   519  
   520  	err := jsonParser.Unmarshal(from, to)
   521  	utils.AssertNil(t, err)
   522  	utils.AssertEqual(t, 0, len(to.Array))
   523  	str, err := jsonParser.Marshal(to)
   524  	utils.AssertNil(t, err)
   525  	utils.AssertEqual(t, `{"Array":[]}`, string(str))
   526  }
   527  
   528  func TestUnmarshal_float32(t *testing.T) {
   529  	to := &struct {
   530  		FLOAT32 float32
   531  	}{}
   532  	from := []byte(`{"FLOAT32":100}`)
   533  
   534  	err := jsonParser.Unmarshal(from, to)
   535  	utils.AssertNil(t, err)
   536  	utils.AssertEqual(t, float32(100), to.FLOAT32)
   537  	str, err := jsonParser.Marshal(to)
   538  	utils.AssertNil(t, err)
   539  	utils.AssertEqual(t, `{"FLOAT32":100}`, string(str))
   540  
   541  	from = []byte(`{"FLOAT32":100.1}`)
   542  
   543  	err = jsonParser.Unmarshal(from, to)
   544  	utils.AssertNil(t, err)
   545  	utils.AssertEqual(t, float32(100.1), to.FLOAT32)
   546  	str, err = jsonParser.Marshal(to)
   547  	utils.AssertNil(t, err)
   548  	utils.AssertEqual(t, `{"FLOAT32":100.1}`, string(str))
   549  
   550  	// string to float32
   551  	from = []byte(`{"FLOAT32":"100.1"}`)
   552  
   553  	err = jsonParser.Unmarshal(from, to)
   554  	utils.AssertNil(t, err)
   555  	utils.AssertEqual(t, float32(100.1), to.FLOAT32)
   556  	str, err = jsonParser.Marshal(to)
   557  	utils.AssertNil(t, err)
   558  	utils.AssertEqual(t, `{"FLOAT32":100.1}`, string(str))
   559  
   560  	from = []byte(`{"FLOAT32":""}`)
   561  
   562  	err = jsonParser.Unmarshal(from, to)
   563  	utils.AssertNil(t, err)
   564  	utils.AssertEqual(t, float32(0), to.FLOAT32)
   565  	str, err = jsonParser.Marshal(to)
   566  	utils.AssertNil(t, err)
   567  	utils.AssertEqual(t, `{"FLOAT32":0}`, string(str))
   568  
   569  	// error branch
   570  	from = []byte(`{"FLOAT32":"."}`)
   571  
   572  	err = jsonParser.Unmarshal(from, to)
   573  	utils.AssertNotNil(t, err)
   574  	utils.AssertEqual(t, "FLOAT32: readFloat32: leading dot is invalid, error found in #0 byte of ...|.|..., bigger context ...|.|...", err.Error())
   575  
   576  	// bool to float32
   577  	from = []byte(`{"FLOAT32":true}`)
   578  
   579  	err = jsonParser.Unmarshal(from, to)
   580  	utils.AssertNil(t, err)
   581  	utils.AssertEqual(t, float32(1), to.FLOAT32)
   582  	str, err = jsonParser.Marshal(to)
   583  	utils.AssertNil(t, err)
   584  	utils.AssertEqual(t, `{"FLOAT32":1}`, string(str))
   585  
   586  	from = []byte(`{"FLOAT32":false}`)
   587  
   588  	err = jsonParser.Unmarshal(from, to)
   589  	utils.AssertNil(t, err)
   590  	utils.AssertEqual(t, float32(0), to.FLOAT32)
   591  	str, err = jsonParser.Marshal(to)
   592  	utils.AssertNil(t, err)
   593  	utils.AssertEqual(t, `{"FLOAT32":0}`, string(str))
   594  
   595  	// nil to float32
   596  	from = []byte(`{"FLOAT32":null}`)
   597  
   598  	err = jsonParser.Unmarshal(from, to)
   599  	utils.AssertNil(t, err)
   600  	utils.AssertEqual(t, float32(0), to.FLOAT32)
   601  	str, err = jsonParser.Marshal(to)
   602  	utils.AssertNil(t, err)
   603  	utils.AssertEqual(t, `{"FLOAT32":0}`, string(str))
   604  
   605  	// others to float32
   606  	from = []byte(`{"FLOAT32":{}}`)
   607  
   608  	err = jsonParser.Unmarshal(from, to)
   609  	utils.AssertNotNil(t, err)
   610  	utils.AssertEqual(t, "FLOAT32: nullableFuzzyFloat32Decoder: not number or string, error found in #10 byte of ...|\"FLOAT32\":{}}|..., bigger context ...|{\"FLOAT32\":{}}|...", err.Error())
   611  }
   612  
   613  func TestUnmarshal_float64(t *testing.T) {
   614  	to := &struct {
   615  		FLOAT64 float64
   616  	}{}
   617  	from := []byte(`{"FLOAT64":100}`)
   618  
   619  	err := jsonParser.Unmarshal(from, to)
   620  	utils.AssertNil(t, err)
   621  	utils.AssertEqual(t, float64(100), to.FLOAT64)
   622  	str, err := jsonParser.Marshal(to)
   623  	utils.AssertNil(t, err)
   624  	utils.AssertEqual(t, `{"FLOAT64":100}`, string(str))
   625  
   626  	from = []byte(`{"FLOAT64":100.1}`)
   627  
   628  	err = jsonParser.Unmarshal(from, to)
   629  	utils.AssertNil(t, err)
   630  	utils.AssertEqual(t, float64(100.1), to.FLOAT64)
   631  	str, err = jsonParser.Marshal(to)
   632  	utils.AssertNil(t, err)
   633  	utils.AssertEqual(t, `{"FLOAT64":100.1}`, string(str))
   634  
   635  	// string to float64
   636  	from = []byte(`{"FLOAT64":"100.1"}`)
   637  
   638  	err = jsonParser.Unmarshal(from, to)
   639  	utils.AssertNil(t, err)
   640  	utils.AssertEqual(t, float64(100.1), to.FLOAT64)
   641  	str, err = jsonParser.Marshal(to)
   642  	utils.AssertNil(t, err)
   643  	utils.AssertEqual(t, `{"FLOAT64":100.1}`, string(str))
   644  
   645  	from = []byte(`{"FLOAT64":""}`)
   646  
   647  	err = jsonParser.Unmarshal(from, to)
   648  	utils.AssertNil(t, err)
   649  	utils.AssertEqual(t, float64(0), to.FLOAT64)
   650  	str, err = jsonParser.Marshal(to)
   651  	utils.AssertNil(t, err)
   652  	utils.AssertEqual(t, `{"FLOAT64":0}`, string(str))
   653  
   654  	// error branch
   655  	from = []byte(`{"FLOAT64":"."}`)
   656  
   657  	err = jsonParser.Unmarshal(from, to)
   658  	utils.AssertNotNil(t, err)
   659  	utils.AssertEqual(t, "FLOAT64: readFloat64: leading dot is invalid, error found in #0 byte of ...|.|..., bigger context ...|.|...", err.Error())
   660  
   661  	// bool to float64
   662  	from = []byte(`{"FLOAT64":true}`)
   663  
   664  	err = jsonParser.Unmarshal(from, to)
   665  	utils.AssertNil(t, err)
   666  	utils.AssertEqual(t, float64(1), to.FLOAT64)
   667  	str, err = jsonParser.Marshal(to)
   668  	utils.AssertNil(t, err)
   669  	utils.AssertEqual(t, `{"FLOAT64":1}`, string(str))
   670  
   671  	from = []byte(`{"FLOAT64":false}`)
   672  
   673  	err = jsonParser.Unmarshal(from, to)
   674  	utils.AssertNil(t, err)
   675  	utils.AssertEqual(t, float64(0), to.FLOAT64)
   676  	str, err = jsonParser.Marshal(to)
   677  	utils.AssertNil(t, err)
   678  	utils.AssertEqual(t, `{"FLOAT64":0}`, string(str))
   679  
   680  	// nil to float64
   681  	from = []byte(`{"FLOAT64":null}`)
   682  
   683  	err = jsonParser.Unmarshal(from, to)
   684  	utils.AssertNil(t, err)
   685  	utils.AssertEqual(t, float64(0), to.FLOAT64)
   686  	str, err = jsonParser.Marshal(to)
   687  	utils.AssertNil(t, err)
   688  	utils.AssertEqual(t, `{"FLOAT64":0}`, string(str))
   689  
   690  	// others to float64
   691  	from = []byte(`{"FLOAT64":{}}`)
   692  
   693  	err = jsonParser.Unmarshal(from, to)
   694  	utils.AssertNotNil(t, err)
   695  	utils.AssertEqual(t, "FLOAT64: nullableFuzzyFloat64Decoder: not number or string, error found in #10 byte of ...|\"FLOAT64\":{}}|..., bigger context ...|{\"FLOAT64\":{}}|...", err.Error())
   696  }
   697  
   698  func TestUnmarshalWithArray(t *testing.T) {
   699  	from := []byte(`[]`)
   700  	to := &struct{}{}
   701  	// TODO: Must support Array
   702  	// support auto json type trans
   703  	err := jsonParser.Unmarshal(from, to)
   704  	utils.AssertNotNil(t, err)
   705  }
   706  
   707  func TestNewBetterFuzzyExtension(t *testing.T) {
   708  	betterFuzzyExtension := newBetterFuzzyExtension()
   709  	utils.AssertNotNil(t, betterFuzzyExtension)
   710  
   711  	decoder := betterFuzzyExtension[reflect2.DefaultTypeOfKind(reflect.String)]
   712  	utils.AssertNotNil(t, decoder)
   713  
   714  	decoder = betterFuzzyExtension[reflect2.DefaultTypeOfKind(reflect.Bool)]
   715  	utils.AssertNotNil(t, decoder)
   716  
   717  	decoder = betterFuzzyExtension[reflect2.DefaultTypeOfKind(reflect.Float32)]
   718  	utils.AssertNotNil(t, decoder)
   719  
   720  	decoder = betterFuzzyExtension[reflect2.DefaultTypeOfKind(reflect.Float64)]
   721  	utils.AssertNotNil(t, decoder)
   722  
   723  	decoder = betterFuzzyExtension[reflect2.DefaultTypeOfKind(reflect.Int)]
   724  	utils.AssertNotNil(t, decoder)
   725  
   726  	decoder = betterFuzzyExtension[reflect2.DefaultTypeOfKind(reflect.Uint)]
   727  	utils.AssertNotNil(t, decoder)
   728  
   729  	decoder = betterFuzzyExtension[reflect2.DefaultTypeOfKind(reflect.Int8)]
   730  	utils.AssertNotNil(t, decoder)
   731  
   732  	decoder = betterFuzzyExtension[reflect2.DefaultTypeOfKind(reflect.Uint8)]
   733  	utils.AssertNotNil(t, decoder)
   734  
   735  	decoder = betterFuzzyExtension[reflect2.DefaultTypeOfKind(reflect.Int16)]
   736  	utils.AssertNotNil(t, decoder)
   737  
   738  	decoder = betterFuzzyExtension[reflect2.DefaultTypeOfKind(reflect.Uint16)]
   739  	utils.AssertNotNil(t, decoder)
   740  
   741  	decoder = betterFuzzyExtension[reflect2.DefaultTypeOfKind(reflect.Int32)]
   742  	utils.AssertNotNil(t, decoder)
   743  
   744  	decoder = betterFuzzyExtension[reflect2.DefaultTypeOfKind(reflect.Uint32)]
   745  	utils.AssertNotNil(t, decoder)
   746  
   747  	decoder = betterFuzzyExtension[reflect2.DefaultTypeOfKind(reflect.Int64)]
   748  	utils.AssertNotNil(t, decoder)
   749  
   750  	decoder = betterFuzzyExtension[reflect2.DefaultTypeOfKind(reflect.Uint64)]
   751  	utils.AssertNotNil(t, decoder)
   752  }
   753  
   754  func TestUnmarshalWithDefaultDecoders(t *testing.T) {
   755  	// should not be valid with default decoders
   756  	from := []byte(`{"STRING":true}`)
   757  	toString := &struct {
   758  		STRING string
   759  	}{}
   760  
   761  	err := jsoniter.Unmarshal(from, toString)
   762  	utils.AssertNotNil(t, err)
   763  
   764  	// should not be valid with default decoders
   765  	from = []byte(`{"BOOL":""}`)
   766  	toBool := &struct {
   767  		BOOL bool
   768  	}{}
   769  
   770  	err = jsoniter.Unmarshal(from, toBool)
   771  	utils.AssertNotNil(t, err)
   772  
   773  	// should not be valid with default decoders
   774  	from = []byte(`{"FLOAT32":""}`)
   775  	toFloat32 := &struct {
   776  		FLOAT32 float32
   777  	}{}
   778  
   779  	err = jsoniter.Unmarshal(from, toFloat32)
   780  	utils.AssertNotNil(t, err)
   781  
   782  	// should not be valid with default decoders
   783  	from = []byte(`{"FLOAT64":""}`)
   784  	toFloat64 := &struct {
   785  		FLOAT64 float64
   786  	}{}
   787  
   788  	err = jsoniter.Unmarshal(from, toFloat64)
   789  	utils.AssertNotNil(t, err)
   790  
   791  	// should not be valid with default decoders
   792  	from = []byte(`{"INT":""}`)
   793  	toInt := &struct {
   794  		INT int
   795  	}{}
   796  
   797  	err = jsoniter.Unmarshal(from, toInt)
   798  	utils.AssertNotNil(t, err)
   799  
   800  	// should not be valid with default decoders
   801  	from = []byte(`{"UINT":""}`)
   802  	toUint := &struct {
   803  		UINT uint
   804  	}{}
   805  
   806  	err = jsoniter.Unmarshal(from, toUint)
   807  	utils.AssertNotNil(t, err)
   808  
   809  	// should not be valid with default decoders
   810  	from = []byte(`{"INT8":""}`)
   811  	toInt8 := &struct {
   812  		INT8 int8
   813  	}{}
   814  
   815  	err = jsoniter.Unmarshal(from, toInt8)
   816  	utils.AssertNotNil(t, err)
   817  
   818  	// should not be valid with default decoders
   819  	from = []byte(`{"UINT8":""}`)
   820  	toUint8 := &struct {
   821  		UINT8 uint8
   822  	}{}
   823  
   824  	err = jsoniter.Unmarshal(from, toUint8)
   825  	utils.AssertNotNil(t, err)
   826  
   827  	// should not be valid with default decoders
   828  	from = []byte(`{"INT16":""}`)
   829  	toInt16 := &struct {
   830  		INT16 int16
   831  	}{}
   832  
   833  	err = jsoniter.Unmarshal(from, toInt16)
   834  	utils.AssertNotNil(t, err)
   835  
   836  	// should not be valid with default decoders
   837  	from = []byte(`{"UINT16":""}`)
   838  	toUint16 := &struct {
   839  		UINT16 uint16
   840  	}{}
   841  
   842  	err = jsoniter.Unmarshal(from, toUint16)
   843  	utils.AssertNotNil(t, err)
   844  
   845  	// should not be valid with default decoders
   846  	from = []byte(`{"INT32":""}`)
   847  	toInt32 := &struct {
   848  		INT32 int32
   849  	}{}
   850  
   851  	err = jsoniter.Unmarshal(from, toInt32)
   852  	utils.AssertNotNil(t, err)
   853  
   854  	// should not be valid with default decoders
   855  	from = []byte(`{"UINT32":""}`)
   856  	toUint32 := &struct {
   857  		UINT32 uint32
   858  	}{}
   859  
   860  	err = jsoniter.Unmarshal(from, toUint32)
   861  	utils.AssertNotNil(t, err)
   862  
   863  	// should not be valid with default decoders
   864  	from = []byte(`{"INT64":""}`)
   865  	toInt64 := &struct {
   866  		INT64 int64
   867  	}{}
   868  
   869  	err = jsoniter.Unmarshal(from, toInt64)
   870  	utils.AssertNotNil(t, err)
   871  
   872  	// should not be valid with default decoders
   873  	from = []byte(`{"UINT64":""}`)
   874  	toUint64 := &struct {
   875  		UINT64 uint64
   876  	}{}
   877  
   878  	err = jsoniter.Unmarshal(from, toUint64)
   879  	utils.AssertNotNil(t, err)
   880  }