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

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