Source file src/github.com/goccy/go-json/test/cover/cover_bytes_test.go

Documentation: github.com/goccy/go-json/test/cover

     1  package json_test
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"testing"
     7  
     8  	"github.com/goccy/go-json"
     9  )
    10  
    11  func TestCoverBytes(t *testing.T) {
    12  	type structBytes struct {
    13  		A []byte `json:"a"`
    14  	}
    15  	type structBytesOmitEmpty struct {
    16  		A []byte `json:"a,omitempty"`
    17  	}
    18  	type structBytesBytes struct {
    19  		A []byte `json:"a,bytes"`
    20  	}
    21  
    22  	type structBytesPtr struct {
    23  		A *[]byte `json:"a"`
    24  	}
    25  	type structBytesPtrOmitEmpty struct {
    26  		A *[]byte `json:"a,omitempty"`
    27  	}
    28  	type structBytesPtrBytes struct {
    29  		A *[]byte `json:"a,bytes"`
    30  	}
    31  
    32  	tests := []struct {
    33  		name string
    34  		data interface{}
    35  	}{
    36  		{
    37  			name: "Bytes",
    38  			data: []byte("a"),
    39  		},
    40  		{
    41  			name: "BytesPtr",
    42  			data: []byte("a"),
    43  		},
    44  		{
    45  			name: "BytesPtr3",
    46  			data: bytesptr3([]byte("a")),
    47  		},
    48  		{
    49  			name: "BytesPtrNil",
    50  			data: (*[]byte)(nil),
    51  		},
    52  		{
    53  			name: "BytesPtr3Nil",
    54  			data: (***[]byte)(nil),
    55  		},
    56  
    57  		// HeadBytesZero
    58  		{
    59  			name: "HeadBytesZero",
    60  			data: struct {
    61  				A []byte `json:"a"`
    62  			}{},
    63  		},
    64  		{
    65  			name: "HeadBytesZeroOmitEmpty",
    66  			data: struct {
    67  				A []byte `json:"a,omitempty"`
    68  			}{},
    69  		},
    70  		{
    71  			name: "HeadBytesZeroString",
    72  			data: struct {
    73  				A []byte `json:"a,string"`
    74  			}{},
    75  		},
    76  
    77  		// HeadBytes
    78  		{
    79  			name: "HeadString",
    80  			data: struct {
    81  				A []byte `json:"a"`
    82  			}{A: []byte("foo")},
    83  		},
    84  		{
    85  			name: "HeadBytesOmitEmpty",
    86  			data: struct {
    87  				A []byte `json:"a,omitempty"`
    88  			}{A: []byte("foo")},
    89  		},
    90  		{
    91  			name: "HeadBytesString",
    92  			data: struct {
    93  				A []byte `json:"a,string"`
    94  			}{A: []byte("foo")},
    95  		},
    96  
    97  		// HeadBytesPtr
    98  		{
    99  			name: "HeadBytesPtr",
   100  			data: struct {
   101  				A *[]byte `json:"a"`
   102  			}{A: bytesptr([]byte("foo"))},
   103  		},
   104  		{
   105  			name: "HeadBytesPtrOmitEmpty",
   106  			data: struct {
   107  				A *[]byte `json:"a,omitempty"`
   108  			}{A: bytesptr([]byte("foo"))},
   109  		},
   110  		{
   111  			name: "HeadBytesPtrString",
   112  			data: struct {
   113  				A *[]byte `json:"a,string"`
   114  			}{A: bytesptr([]byte("foo"))},
   115  		},
   116  
   117  		// HeadBytesPtrNil
   118  		{
   119  			name: "HeadBytesPtrNil",
   120  			data: struct {
   121  				A *[]byte `json:"a"`
   122  			}{A: nil},
   123  		},
   124  		{
   125  			name: "HeadBytesPtrNilOmitEmpty",
   126  			data: struct {
   127  				A *[]byte `json:"a,omitempty"`
   128  			}{A: nil},
   129  		},
   130  		{
   131  			name: "HeadBytesPtrNilString",
   132  			data: struct {
   133  				A *[]byte `json:"a,string"`
   134  			}{A: nil},
   135  		},
   136  
   137  		// PtrHeadBytesZero
   138  		{
   139  			name: "PtrHeadBytesZero",
   140  			data: &struct {
   141  				A []byte `json:"a"`
   142  			}{},
   143  		},
   144  		{
   145  			name: "PtrHeadBytesZeroOmitEmpty",
   146  			data: &struct {
   147  				A []byte `json:"a,omitempty"`
   148  			}{},
   149  		},
   150  		{
   151  			name: "PtrHeadBytesZeroString",
   152  			data: &struct {
   153  				A []byte `json:"a,string"`
   154  			}{},
   155  		},
   156  
   157  		// PtrHeadBytes
   158  		{
   159  			name: "PtrHeadString",
   160  			data: &struct {
   161  				A []byte `json:"a"`
   162  			}{A: []byte("foo")},
   163  		},
   164  		{
   165  			name: "PtrHeadBytesOmitEmpty",
   166  			data: &struct {
   167  				A []byte `json:"a,omitempty"`
   168  			}{A: []byte("foo")},
   169  		},
   170  		{
   171  			name: "PtrHeadBytesString",
   172  			data: &struct {
   173  				A []byte `json:"a,string"`
   174  			}{A: []byte("foo")},
   175  		},
   176  
   177  		// PtrHeadBytesPtr
   178  		{
   179  			name: "PtrHeadBytesPtr",
   180  			data: &struct {
   181  				A *[]byte `json:"a"`
   182  			}{A: bytesptr([]byte("foo"))},
   183  		},
   184  		{
   185  			name: "PtrHeadBytesPtrOmitEmpty",
   186  			data: &struct {
   187  				A *[]byte `json:"a,omitempty"`
   188  			}{A: bytesptr([]byte("foo"))},
   189  		},
   190  		{
   191  			name: "PtrHeadBytesPtrString",
   192  			data: &struct {
   193  				A *[]byte `json:"a,string"`
   194  			}{A: bytesptr([]byte("foo"))},
   195  		},
   196  
   197  		// PtrHeadBytesPtrNil
   198  		{
   199  			name: "PtrHeadBytesPtrNil",
   200  			data: &struct {
   201  				A *[]byte `json:"a"`
   202  			}{A: nil},
   203  		},
   204  		{
   205  			name: "PtrHeadBytesPtrNilOmitEmpty",
   206  			data: &struct {
   207  				A *[]byte `json:"a,omitempty"`
   208  			}{A: nil},
   209  		},
   210  		{
   211  			name: "PtrHeadBytesPtrNilString",
   212  			data: &struct {
   213  				A *[]byte `json:"a,string"`
   214  			}{A: nil},
   215  		},
   216  
   217  		// PtrHeadBytesNil
   218  		{
   219  			name: "PtrHeadBytesNil",
   220  			data: (*struct {
   221  				A *[]byte `json:"a"`
   222  			})(nil),
   223  		},
   224  		{
   225  			name: "PtrHeadBytesNilOmitEmpty",
   226  			data: (*struct {
   227  				A *[]byte `json:"a,omitempty"`
   228  			})(nil),
   229  		},
   230  		{
   231  			name: "PtrHeadBytesNilString",
   232  			data: (*struct {
   233  				A *[]byte `json:"a,string"`
   234  			})(nil),
   235  		},
   236  
   237  		// HeadBytesZeroMultiFields
   238  		{
   239  			name: "HeadBytesZeroMultiFields",
   240  			data: struct {
   241  				A []byte `json:"a"`
   242  				B []byte `json:"b"`
   243  				C []byte `json:"c"`
   244  			}{},
   245  		},
   246  		{
   247  			name: "HeadBytesZeroMultiFieldsOmitEmpty",
   248  			data: struct {
   249  				A []byte `json:"a,omitempty"`
   250  				B []byte `json:"b,omitempty"`
   251  				C []byte `json:"c,omitempty"`
   252  			}{},
   253  		},
   254  		{
   255  			name: "HeadBytesZeroMultiFieldsString",
   256  			data: struct {
   257  				A []byte `json:"a,string"`
   258  				B []byte `json:"b,string"`
   259  				C []byte `json:"c,string"`
   260  			}{},
   261  		},
   262  
   263  		// HeadBytesMultiFields
   264  		{
   265  			name: "HeadBytesMultiFields",
   266  			data: struct {
   267  				A []byte `json:"a"`
   268  				B []byte `json:"b"`
   269  				C []byte `json:"c"`
   270  			}{A: []byte("foo"), B: []byte("bar"), C: []byte([]byte("baz"))},
   271  		},
   272  		{
   273  			name: "HeadBytesMultiFieldsOmitEmpty",
   274  			data: struct {
   275  				A []byte `json:"a,omitempty"`
   276  				B []byte `json:"b,omitempty"`
   277  				C []byte `json:"c,omitempty"`
   278  			}{A: []byte("foo"), B: []byte("bar"), C: []byte([]byte("baz"))},
   279  		},
   280  		{
   281  			name: "HeadBytesMultiFieldsString",
   282  			data: struct {
   283  				A []byte `json:"a,string"`
   284  				B []byte `json:"b,string"`
   285  				C []byte `json:"c,string"`
   286  			}{A: []byte("foo"), B: []byte("bar"), C: []byte([]byte("baz"))},
   287  		},
   288  
   289  		// HeadBytesPtrMultiFields
   290  		{
   291  			name: "HeadBytesPtrMultiFields",
   292  			data: struct {
   293  				A *[]byte `json:"a"`
   294  				B *[]byte `json:"b"`
   295  				C *[]byte `json:"c"`
   296  			}{A: bytesptr([]byte("foo")), B: bytesptr([]byte("bar")), C: bytesptr([]byte([]byte("baz")))},
   297  		},
   298  		{
   299  			name: "HeadBytesPtrMultiFieldsOmitEmpty",
   300  			data: struct {
   301  				A *[]byte `json:"a,omitempty"`
   302  				B *[]byte `json:"b,omitempty"`
   303  				C *[]byte `json:"c,omitempty"`
   304  			}{A: bytesptr([]byte("foo")), B: bytesptr([]byte("bar")), C: bytesptr([]byte([]byte("baz")))},
   305  		},
   306  		{
   307  			name: "HeadBytesPtrMultiFieldsString",
   308  			data: struct {
   309  				A *[]byte `json:"a,string"`
   310  				B *[]byte `json:"b,string"`
   311  				C *[]byte `json:"c,string"`
   312  			}{A: bytesptr([]byte("foo")), B: bytesptr([]byte("bar")), C: bytesptr([]byte([]byte("baz")))},
   313  		},
   314  
   315  		// HeadBytesPtrNilMultiFields
   316  		{
   317  			name: "HeadBytesPtrNilMultiFields",
   318  			data: struct {
   319  				A *[]byte `json:"a"`
   320  				B *[]byte `json:"b"`
   321  				C *[]byte `json:"c"`
   322  			}{A: nil, B: nil, C: nil},
   323  		},
   324  		{
   325  			name: "HeadBytesPtrNilMultiFieldsOmitEmpty",
   326  			data: struct {
   327  				A *[]byte `json:"a,omitempty"`
   328  				B *[]byte `json:"b,omitempty"`
   329  				C *[]byte `json:"c,omitempty"`
   330  			}{A: nil, B: nil, C: nil},
   331  		},
   332  		{
   333  			name: "HeadBytesPtrNilMultiFieldsString",
   334  			data: struct {
   335  				A *[]byte `json:"a,string"`
   336  				B *[]byte `json:"b,string"`
   337  				C *[]byte `json:"c,string"`
   338  			}{A: nil, B: nil, C: nil},
   339  		},
   340  
   341  		// PtrHeadBytesZeroMultiFields
   342  		{
   343  			name: "PtrHeadBytesZeroMultiFields",
   344  			data: &struct {
   345  				A []byte `json:"a"`
   346  				B []byte `json:"b"`
   347  				C []byte `json:"c"`
   348  			}{},
   349  		},
   350  		{
   351  			name: "PtrHeadBytesZeroMultiFieldsOmitEmpty",
   352  			data: &struct {
   353  				A []byte `json:"a,omitempty"`
   354  				B []byte `json:"b,omitempty"`
   355  				C []byte `json:"c,omitempty"`
   356  			}{},
   357  		},
   358  		{
   359  			name: "PtrHeadBytesZeroMultiFieldsString",
   360  			data: &struct {
   361  				A []byte `json:"a,string"`
   362  				B []byte `json:"b,string"`
   363  				C []byte `json:"c,string"`
   364  			}{},
   365  		},
   366  
   367  		// PtrHeadBytesMultiFields
   368  		{
   369  			name: "PtrHeadBytesMultiFields",
   370  			data: &struct {
   371  				A []byte `json:"a"`
   372  				B []byte `json:"b"`
   373  				C []byte `json:"c"`
   374  			}{A: []byte("foo"), B: []byte("bar"), C: []byte("baz")},
   375  		},
   376  		{
   377  			name: "PtrHeadBytesMultiFieldsOmitEmpty",
   378  			data: &struct {
   379  				A []byte `json:"a,omitempty"`
   380  				B []byte `json:"b,omitempty"`
   381  				C []byte `json:"c,omitempty"`
   382  			}{A: []byte("foo"), B: []byte("bar"), C: []byte("baz")},
   383  		},
   384  		{
   385  			name: "PtrHeadBytesMultiFieldsString",
   386  			data: &struct {
   387  				A []byte `json:"a,string"`
   388  				B []byte `json:"b,string"`
   389  				C []byte `json:"c,string"`
   390  			}{A: []byte("foo"), B: []byte("bar"), C: []byte("baz")},
   391  		},
   392  
   393  		// PtrHeadBytesPtrMultiFields
   394  		{
   395  			name: "PtrHeadBytesPtrMultiFields",
   396  			data: &struct {
   397  				A *[]byte `json:"a"`
   398  				B *[]byte `json:"b"`
   399  				C *[]byte `json:"c"`
   400  			}{A: bytesptr([]byte("foo")), B: bytesptr([]byte("bar")), C: bytesptr([]byte("baz"))},
   401  		},
   402  		{
   403  			name: "PtrHeadBytesPtrMultiFieldsOmitEmpty",
   404  			data: &struct {
   405  				A *[]byte `json:"a,omitempty"`
   406  				B *[]byte `json:"b,omitempty"`
   407  				C *[]byte `json:"c,omitempty"`
   408  			}{A: bytesptr([]byte("foo")), B: bytesptr([]byte("bar")), C: bytesptr([]byte("baz"))},
   409  		},
   410  		{
   411  			name: "PtrHeadBytesPtrMultiFieldsString",
   412  			data: &struct {
   413  				A *[]byte `json:"a,string"`
   414  				B *[]byte `json:"b,string"`
   415  				C *[]byte `json:"c,string"`
   416  			}{A: bytesptr([]byte("foo")), B: bytesptr([]byte("bar")), C: bytesptr([]byte("baz"))},
   417  		},
   418  
   419  		// PtrHeadBytesPtrNilMultiFields
   420  		{
   421  			name: "PtrHeadBytesPtrNilMultiFields",
   422  			data: &struct {
   423  				A *[]byte `json:"a"`
   424  				B *[]byte `json:"b"`
   425  				C *[]byte `json:"c"`
   426  			}{A: nil, B: nil, C: nil},
   427  		},
   428  		{
   429  			name: "PtrHeadBytesPtrNilMultiFieldsOmitEmpty",
   430  			data: &struct {
   431  				A *[]byte `json:"a,omitempty"`
   432  				B *[]byte `json:"b,omitempty"`
   433  				C *[]byte `json:"c,omitempty"`
   434  			}{A: nil, B: nil, C: nil},
   435  		},
   436  		{
   437  			name: "PtrHeadBytesPtrNilMultiFieldsString",
   438  			data: &struct {
   439  				A *[]byte `json:"a,string"`
   440  				B *[]byte `json:"b,string"`
   441  				C *[]byte `json:"c,string"`
   442  			}{A: nil, B: nil, C: nil},
   443  		},
   444  
   445  		// PtrHeadBytesNilMultiFields
   446  		{
   447  			name: "PtrHeadBytesNilMultiFields",
   448  			data: (*struct {
   449  				A *[]byte `json:"a"`
   450  				B *[]byte `json:"b"`
   451  				C *[]byte `json:"c"`
   452  			})(nil),
   453  		},
   454  		{
   455  			name: "PtrHeadBytesNilMultiFieldsOmitEmpty",
   456  			data: (*struct {
   457  				A *[]byte `json:"a,omitempty"`
   458  				B *[]byte `json:"b,omitempty"`
   459  				C *[]byte `json:"c,omitempty"`
   460  			})(nil),
   461  		},
   462  		{
   463  			name: "PtrHeadBytesNilMultiFieldsString",
   464  			data: (*struct {
   465  				A *[]byte `json:"a,string"`
   466  				B *[]byte `json:"b,string"`
   467  				C *[]byte `json:"c,string"`
   468  			})(nil),
   469  		},
   470  
   471  		// HeadBytesZeroNotRoot
   472  		{
   473  			name: "HeadBytesZeroNotRoot",
   474  			data: struct {
   475  				A struct {
   476  					A []byte `json:"a"`
   477  				}
   478  			}{},
   479  		},
   480  		{
   481  			name: "HeadBytesZeroNotRootOmitEmpty",
   482  			data: struct {
   483  				A struct {
   484  					A []byte `json:"a,omitempty"`
   485  				}
   486  			}{},
   487  		},
   488  		{
   489  			name: "HeadBytesZeroNotRootString",
   490  			data: struct {
   491  				A struct {
   492  					A []byte `json:"a,string"`
   493  				}
   494  			}{},
   495  		},
   496  
   497  		// HeadBytesNotRoot
   498  		{
   499  			name: "HeadBytesNotRoot",
   500  			data: struct {
   501  				A struct {
   502  					A []byte `json:"a"`
   503  				}
   504  			}{A: struct {
   505  				A []byte `json:"a"`
   506  			}{A: []byte("foo")}},
   507  		},
   508  		{
   509  			name: "HeadBytesNotRootOmitEmpty",
   510  			data: struct {
   511  				A struct {
   512  					A []byte `json:"a,omitempty"`
   513  				}
   514  			}{A: struct {
   515  				A []byte `json:"a,omitempty"`
   516  			}{A: []byte("foo")}},
   517  		},
   518  		{
   519  			name: "HeadBytesNotRootString",
   520  			data: struct {
   521  				A struct {
   522  					A []byte `json:"a,string"`
   523  				}
   524  			}{A: struct {
   525  				A []byte `json:"a,string"`
   526  			}{A: []byte("foo")}},
   527  		},
   528  
   529  		// HeadBytesPtrNotRoot
   530  		{
   531  			name: "HeadBytesPtrNotRoot",
   532  			data: struct {
   533  				A struct {
   534  					A *[]byte `json:"a"`
   535  				}
   536  			}{A: struct {
   537  				A *[]byte `json:"a"`
   538  			}{bytesptr([]byte("foo"))}},
   539  		},
   540  		{
   541  			name: "HeadBytesPtrNotRootOmitEmpty",
   542  			data: struct {
   543  				A struct {
   544  					A *[]byte `json:"a,omitempty"`
   545  				}
   546  			}{A: struct {
   547  				A *[]byte `json:"a,omitempty"`
   548  			}{bytesptr([]byte("foo"))}},
   549  		},
   550  		{
   551  			name: "HeadBytesPtrNotRootString",
   552  			data: struct {
   553  				A struct {
   554  					A *[]byte `json:"a,string"`
   555  				}
   556  			}{A: struct {
   557  				A *[]byte `json:"a,string"`
   558  			}{bytesptr([]byte("foo"))}},
   559  		},
   560  
   561  		// HeadBytesPtrNilNotRoot
   562  		{
   563  			name: "HeadBytesPtrNilNotRoot",
   564  			data: struct {
   565  				A struct {
   566  					A *[]byte `json:"a"`
   567  				}
   568  			}{},
   569  		},
   570  		{
   571  			name: "HeadBytesPtrNilNotRootOmitEmpty",
   572  			data: struct {
   573  				A struct {
   574  					A *[]byte `json:"a,omitempty"`
   575  				}
   576  			}{},
   577  		},
   578  		{
   579  			name: "HeadBytesPtrNilNotRootString",
   580  			data: struct {
   581  				A struct {
   582  					A *[]byte `json:"a,string"`
   583  				}
   584  			}{},
   585  		},
   586  
   587  		// PtrHeadBytesZeroNotRoot
   588  		{
   589  			name: "PtrHeadBytesZeroNotRoot",
   590  			data: struct {
   591  				A *struct {
   592  					A []byte `json:"a"`
   593  				}
   594  			}{A: new(struct {
   595  				A []byte `json:"a"`
   596  			})},
   597  		},
   598  		{
   599  			name: "PtrHeadBytesZeroNotRootOmitEmpty",
   600  			data: struct {
   601  				A *struct {
   602  					A []byte `json:"a,omitempty"`
   603  				}
   604  			}{A: new(struct {
   605  				A []byte `json:"a,omitempty"`
   606  			})},
   607  		},
   608  		{
   609  			name: "PtrHeadBytesZeroNotRootString",
   610  			data: struct {
   611  				A *struct {
   612  					A []byte `json:"a,string"`
   613  				}
   614  			}{A: new(struct {
   615  				A []byte `json:"a,string"`
   616  			})},
   617  		},
   618  
   619  		// PtrHeadBytesNotRoot
   620  		{
   621  			name: "PtrHeadBytesNotRoot",
   622  			data: struct {
   623  				A *struct {
   624  					A []byte `json:"a"`
   625  				}
   626  			}{A: &(struct {
   627  				A []byte `json:"a"`
   628  			}{A: []byte("foo")})},
   629  		},
   630  		{
   631  			name: "PtrHeadBytesNotRootOmitEmpty",
   632  			data: struct {
   633  				A *struct {
   634  					A []byte `json:"a,omitempty"`
   635  				}
   636  			}{A: &(struct {
   637  				A []byte `json:"a,omitempty"`
   638  			}{A: []byte("foo")})},
   639  		},
   640  		{
   641  			name: "PtrHeadBytesNotRootString",
   642  			data: struct {
   643  				A *struct {
   644  					A []byte `json:"a,string"`
   645  				}
   646  			}{A: &(struct {
   647  				A []byte `json:"a,string"`
   648  			}{A: []byte("foo")})},
   649  		},
   650  
   651  		// PtrHeadBytesPtrNotRoot
   652  		{
   653  			name: "PtrHeadBytesPtrNotRoot",
   654  			data: struct {
   655  				A *struct {
   656  					A *[]byte `json:"a"`
   657  				}
   658  			}{A: &(struct {
   659  				A *[]byte `json:"a"`
   660  			}{A: bytesptr([]byte("foo"))})},
   661  		},
   662  		{
   663  			name: "PtrHeadBytesPtrNotRootOmitEmpty",
   664  			data: struct {
   665  				A *struct {
   666  					A *[]byte `json:"a,omitempty"`
   667  				}
   668  			}{A: &(struct {
   669  				A *[]byte `json:"a,omitempty"`
   670  			}{A: bytesptr([]byte("foo"))})},
   671  		},
   672  		{
   673  			name: "PtrHeadBytesPtrNotRootString",
   674  			data: struct {
   675  				A *struct {
   676  					A *[]byte `json:"a,string"`
   677  				}
   678  			}{A: &(struct {
   679  				A *[]byte `json:"a,string"`
   680  			}{A: bytesptr([]byte("foo"))})},
   681  		},
   682  
   683  		// PtrHeadBytesPtrNilNotRoot
   684  		{
   685  			name: "PtrHeadBytesPtrNilNotRoot",
   686  			data: struct {
   687  				A *struct {
   688  					A *[]byte `json:"a"`
   689  				}
   690  			}{A: &(struct {
   691  				A *[]byte `json:"a"`
   692  			}{A: nil})},
   693  		},
   694  		{
   695  			name: "PtrHeadBytesPtrNilNotRootOmitEmpty",
   696  			data: struct {
   697  				A *struct {
   698  					A *[]byte `json:"a,omitempty"`
   699  				}
   700  			}{A: &(struct {
   701  				A *[]byte `json:"a,omitempty"`
   702  			}{A: nil})},
   703  		},
   704  		{
   705  			name: "PtrHeadBytesPtrNilNotRootString",
   706  			data: struct {
   707  				A *struct {
   708  					A *[]byte `json:"a,string"`
   709  				}
   710  			}{A: &(struct {
   711  				A *[]byte `json:"a,string"`
   712  			}{A: nil})},
   713  		},
   714  
   715  		// PtrHeadBytesNilNotRoot
   716  		{
   717  			name: "PtrHeadBytesNilNotRoot",
   718  			data: struct {
   719  				A *struct {
   720  					A *[]byte `json:"a"`
   721  				}
   722  			}{A: nil},
   723  		},
   724  		{
   725  			name: "PtrHeadBytesNilNotRootOmitEmpty",
   726  			data: struct {
   727  				A *struct {
   728  					A *[]byte `json:"a,omitempty"`
   729  				} `json:",omitempty"`
   730  			}{A: nil},
   731  		},
   732  		{
   733  			name: "PtrHeadBytesNilNotRootString",
   734  			data: struct {
   735  				A *struct {
   736  					A *[]byte `json:"a,string"`
   737  				} `json:",string"`
   738  			}{A: nil},
   739  		},
   740  
   741  		// HeadBytesZeroMultiFieldsNotRoot
   742  		{
   743  			name: "HeadBytesZeroMultiFieldsNotRoot",
   744  			data: struct {
   745  				A struct {
   746  					A []byte `json:"a"`
   747  				}
   748  				B struct {
   749  					B []byte `json:"b"`
   750  				}
   751  			}{},
   752  		},
   753  		{
   754  			name: "HeadBytesZeroMultiFieldsNotRootOmitEmpty",
   755  			data: struct {
   756  				A struct {
   757  					A []byte `json:"a,omitempty"`
   758  				}
   759  				B struct {
   760  					B []byte `json:"b,omitempty"`
   761  				}
   762  			}{},
   763  		},
   764  		{
   765  			name: "HeadBytesZeroMultiFieldsNotRootString",
   766  			data: struct {
   767  				A struct {
   768  					A []byte `json:"a,string"`
   769  				}
   770  				B struct {
   771  					B []byte `json:"b,string"`
   772  				}
   773  			}{},
   774  		},
   775  
   776  		// HeadBytesMultiFieldsNotRoot
   777  		{
   778  			name: "HeadBytesMultiFieldsNotRoot",
   779  			data: struct {
   780  				A struct {
   781  					A []byte `json:"a"`
   782  				}
   783  				B struct {
   784  					B []byte `json:"b"`
   785  				}
   786  			}{A: struct {
   787  				A []byte `json:"a"`
   788  			}{A: []byte("foo")}, B: struct {
   789  				B []byte `json:"b"`
   790  			}{B: []byte("bar")}},
   791  		},
   792  		{
   793  			name: "HeadBytesMultiFieldsNotRootOmitEmpty",
   794  			data: struct {
   795  				A struct {
   796  					A []byte `json:"a,omitempty"`
   797  				}
   798  				B struct {
   799  					B []byte `json:"b,omitempty"`
   800  				}
   801  			}{A: struct {
   802  				A []byte `json:"a,omitempty"`
   803  			}{A: []byte("foo")}, B: struct {
   804  				B []byte `json:"b,omitempty"`
   805  			}{B: []byte("bar")}},
   806  		},
   807  		{
   808  			name: "HeadBytesMultiFieldsNotRootString",
   809  			data: struct {
   810  				A struct {
   811  					A []byte `json:"a,string"`
   812  				}
   813  				B struct {
   814  					B []byte `json:"b,string"`
   815  				}
   816  			}{A: struct {
   817  				A []byte `json:"a,string"`
   818  			}{A: []byte("foo")}, B: struct {
   819  				B []byte `json:"b,string"`
   820  			}{B: []byte("bar")}},
   821  		},
   822  
   823  		// HeadBytesPtrMultiFieldsNotRoot
   824  		{
   825  			name: "HeadBytesPtrMultiFieldsNotRoot",
   826  			data: struct {
   827  				A struct {
   828  					A *[]byte `json:"a"`
   829  				}
   830  				B struct {
   831  					B *[]byte `json:"b"`
   832  				}
   833  			}{A: struct {
   834  				A *[]byte `json:"a"`
   835  			}{A: bytesptr([]byte("foo"))}, B: struct {
   836  				B *[]byte `json:"b"`
   837  			}{B: bytesptr([]byte("bar"))}},
   838  		},
   839  		{
   840  			name: "HeadBytesPtrMultiFieldsNotRootOmitEmpty",
   841  			data: struct {
   842  				A struct {
   843  					A *[]byte `json:"a,omitempty"`
   844  				}
   845  				B struct {
   846  					B *[]byte `json:"b,omitempty"`
   847  				}
   848  			}{A: struct {
   849  				A *[]byte `json:"a,omitempty"`
   850  			}{A: bytesptr([]byte("foo"))}, B: struct {
   851  				B *[]byte `json:"b,omitempty"`
   852  			}{B: bytesptr([]byte("bar"))}},
   853  		},
   854  		{
   855  			name: "HeadBytesPtrMultiFieldsNotRootString",
   856  			data: struct {
   857  				A struct {
   858  					A *[]byte `json:"a,string"`
   859  				}
   860  				B struct {
   861  					B *[]byte `json:"b,string"`
   862  				}
   863  			}{A: struct {
   864  				A *[]byte `json:"a,string"`
   865  			}{A: bytesptr([]byte("foo"))}, B: struct {
   866  				B *[]byte `json:"b,string"`
   867  			}{B: bytesptr([]byte("bar"))}},
   868  		},
   869  
   870  		// HeadBytesPtrNilMultiFieldsNotRoot
   871  		{
   872  			name: "HeadBytesPtrNilMultiFieldsNotRoot",
   873  			data: struct {
   874  				A struct {
   875  					A *[]byte `json:"a"`
   876  				}
   877  				B struct {
   878  					B *[]byte `json:"b"`
   879  				}
   880  			}{A: struct {
   881  				A *[]byte `json:"a"`
   882  			}{A: nil}, B: struct {
   883  				B *[]byte `json:"b"`
   884  			}{B: nil}},
   885  		},
   886  		{
   887  			name: "HeadBytesPtrNilMultiFieldsNotRootOmitEmpty",
   888  			data: struct {
   889  				A struct {
   890  					A *[]byte `json:"a,omitempty"`
   891  				}
   892  				B struct {
   893  					B *[]byte `json:"b,omitempty"`
   894  				}
   895  			}{A: struct {
   896  				A *[]byte `json:"a,omitempty"`
   897  			}{A: nil}, B: struct {
   898  				B *[]byte `json:"b,omitempty"`
   899  			}{B: nil}},
   900  		},
   901  		{
   902  			name: "HeadBytesPtrNilMultiFieldsNotRootString",
   903  			data: struct {
   904  				A struct {
   905  					A *[]byte `json:"a,string"`
   906  				}
   907  				B struct {
   908  					B *[]byte `json:"b,string"`
   909  				}
   910  			}{A: struct {
   911  				A *[]byte `json:"a,string"`
   912  			}{A: nil}, B: struct {
   913  				B *[]byte `json:"b,string"`
   914  			}{B: nil}},
   915  		},
   916  
   917  		// PtrHeadBytesZeroMultiFieldsNotRoot
   918  		{
   919  			name: "PtrHeadBytesZeroMultiFieldsNotRoot",
   920  			data: &struct {
   921  				A struct {
   922  					A []byte `json:"a"`
   923  				}
   924  				B struct {
   925  					B []byte `json:"b"`
   926  				}
   927  			}{},
   928  		},
   929  		{
   930  			name: "PtrHeadBytesZeroMultiFieldsNotRootOmitEmpty",
   931  			data: &struct {
   932  				A struct {
   933  					A []byte `json:"a,omitempty"`
   934  				}
   935  				B struct {
   936  					B []byte `json:"b,omitempty"`
   937  				}
   938  			}{},
   939  		},
   940  		{
   941  			name: "PtrHeadBytesZeroMultiFieldsNotRootString",
   942  			data: &struct {
   943  				A struct {
   944  					A []byte `json:"a,string"`
   945  				}
   946  				B struct {
   947  					B []byte `json:"b,string"`
   948  				}
   949  			}{},
   950  		},
   951  
   952  		// PtrHeadBytesMultiFieldsNotRoot
   953  		{
   954  			name: "PtrHeadBytesMultiFieldsNotRoot",
   955  			data: &struct {
   956  				A struct {
   957  					A []byte `json:"a"`
   958  				}
   959  				B struct {
   960  					B []byte `json:"b"`
   961  				}
   962  			}{A: struct {
   963  				A []byte `json:"a"`
   964  			}{A: []byte("foo")}, B: struct {
   965  				B []byte `json:"b"`
   966  			}{B: []byte("bar")}},
   967  		},
   968  		{
   969  			name: "PtrHeadBytesMultiFieldsNotRootOmitEmpty",
   970  			data: &struct {
   971  				A struct {
   972  					A []byte `json:"a,omitempty"`
   973  				}
   974  				B struct {
   975  					B []byte `json:"b,omitempty"`
   976  				}
   977  			}{A: struct {
   978  				A []byte `json:"a,omitempty"`
   979  			}{A: []byte("foo")}, B: struct {
   980  				B []byte `json:"b,omitempty"`
   981  			}{B: []byte("bar")}},
   982  		},
   983  		{
   984  			name: "PtrHeadBytesMultiFieldsNotRootString",
   985  			data: &struct {
   986  				A struct {
   987  					A []byte `json:"a,string"`
   988  				}
   989  				B struct {
   990  					B []byte `json:"b,string"`
   991  				}
   992  			}{A: struct {
   993  				A []byte `json:"a,string"`
   994  			}{A: []byte("foo")}, B: struct {
   995  				B []byte `json:"b,string"`
   996  			}{B: []byte("bar")}},
   997  		},
   998  
   999  		// PtrHeadBytesPtrMultiFieldsNotRoot
  1000  		{
  1001  			name: "PtrHeadBytesPtrMultiFieldsNotRoot",
  1002  			data: &struct {
  1003  				A *struct {
  1004  					A *[]byte `json:"a"`
  1005  				}
  1006  				B *struct {
  1007  					B *[]byte `json:"b"`
  1008  				}
  1009  			}{A: &(struct {
  1010  				A *[]byte `json:"a"`
  1011  			}{A: bytesptr([]byte("foo"))}), B: &(struct {
  1012  				B *[]byte `json:"b"`
  1013  			}{B: bytesptr([]byte("bar"))})},
  1014  		},
  1015  		{
  1016  			name: "PtrHeadBytesPtrMultiFieldsNotRootOmitEmpty",
  1017  			data: &struct {
  1018  				A *struct {
  1019  					A *[]byte `json:"a,omitempty"`
  1020  				}
  1021  				B *struct {
  1022  					B *[]byte `json:"b,omitempty"`
  1023  				}
  1024  			}{A: &(struct {
  1025  				A *[]byte `json:"a,omitempty"`
  1026  			}{A: bytesptr([]byte("foo"))}), B: &(struct {
  1027  				B *[]byte `json:"b,omitempty"`
  1028  			}{B: bytesptr([]byte("bar"))})},
  1029  		},
  1030  		{
  1031  			name: "PtrHeadBytesPtrMultiFieldsNotRootString",
  1032  			data: &struct {
  1033  				A *struct {
  1034  					A *[]byte `json:"a,string"`
  1035  				}
  1036  				B *struct {
  1037  					B *[]byte `json:"b,string"`
  1038  				}
  1039  			}{A: &(struct {
  1040  				A *[]byte `json:"a,string"`
  1041  			}{A: bytesptr([]byte("foo"))}), B: &(struct {
  1042  				B *[]byte `json:"b,string"`
  1043  			}{B: bytesptr([]byte("bar"))})},
  1044  		},
  1045  
  1046  		// PtrHeadBytesPtrNilMultiFieldsNotRoot
  1047  		{
  1048  			name: "PtrHeadBytesPtrNilMultiFieldsNotRoot",
  1049  			data: &struct {
  1050  				A *struct {
  1051  					A *[]byte `json:"a"`
  1052  				}
  1053  				B *struct {
  1054  					B *[]byte `json:"b"`
  1055  				}
  1056  			}{A: nil, B: nil},
  1057  		},
  1058  		{
  1059  			name: "PtrHeadBytesPtrNilMultiFieldsNotRootOmitEmpty",
  1060  			data: &struct {
  1061  				A *struct {
  1062  					A *[]byte `json:"a,omitempty"`
  1063  				}
  1064  				B *struct {
  1065  					B *[]byte `json:"b,omitempty"`
  1066  				}
  1067  			}{A: nil, B: nil},
  1068  		},
  1069  		{
  1070  			name: "PtrHeadBytesPtrNilMultiFieldsNotRootString",
  1071  			data: &struct {
  1072  				A *struct {
  1073  					A *[]byte `json:"a,string"`
  1074  				}
  1075  				B *struct {
  1076  					B *[]byte `json:"b,string"`
  1077  				}
  1078  			}{A: nil, B: nil},
  1079  		},
  1080  
  1081  		// PtrHeadBytesNilMultiFieldsNotRoot
  1082  		{
  1083  			name: "PtrHeadBytesNilMultiFieldsNotRoot",
  1084  			data: (*struct {
  1085  				A *struct {
  1086  					A *[]byte `json:"a"`
  1087  				}
  1088  				B *struct {
  1089  					B *[]byte `json:"b"`
  1090  				}
  1091  			})(nil),
  1092  		},
  1093  		{
  1094  			name: "PtrHeadBytesNilMultiFieldsNotRootOmitEmpty",
  1095  			data: (*struct {
  1096  				A *struct {
  1097  					A *[]byte `json:"a,omitempty"`
  1098  				}
  1099  				B *struct {
  1100  					B *[]byte `json:"b,omitempty"`
  1101  				}
  1102  			})(nil),
  1103  		},
  1104  		{
  1105  			name: "PtrHeadBytesNilMultiFieldsNotRootString",
  1106  			data: (*struct {
  1107  				A *struct {
  1108  					A *[]byte `json:"a,string"`
  1109  				}
  1110  				B *struct {
  1111  					B *[]byte `json:"b,string"`
  1112  				}
  1113  			})(nil),
  1114  		},
  1115  
  1116  		// PtrHeadBytesDoubleMultiFieldsNotRoot
  1117  		{
  1118  			name: "PtrHeadBytesDoubleMultiFieldsNotRoot",
  1119  			data: &struct {
  1120  				A *struct {
  1121  					A []byte `json:"a"`
  1122  					B []byte `json:"b"`
  1123  					C []byte `json:"c"`
  1124  				}
  1125  				B *struct {
  1126  					A []byte `json:"a"`
  1127  					B []byte `json:"b"`
  1128  					C []byte `json:"c"`
  1129  				}
  1130  			}{A: &(struct {
  1131  				A []byte `json:"a"`
  1132  				B []byte `json:"b"`
  1133  				C []byte `json:"c"`
  1134  			}{A: []byte("foo"), B: []byte("bar"), C: []byte("baz")}), B: &(struct {
  1135  				A []byte `json:"a"`
  1136  				B []byte `json:"b"`
  1137  				C []byte `json:"c"`
  1138  			}{A: []byte("foo"), B: []byte("bar"), C: []byte("baz")})},
  1139  		},
  1140  		{
  1141  			name: "PtrHeadBytesDoubleMultiFieldsNotRootOmitEmpty",
  1142  			data: &struct {
  1143  				A *struct {
  1144  					A []byte `json:"a,omitempty"`
  1145  					B []byte `json:"b,omitempty"`
  1146  				}
  1147  				B *struct {
  1148  					A []byte `json:"a,omitempty"`
  1149  					B []byte `json:"b,omitempty"`
  1150  				}
  1151  			}{A: &(struct {
  1152  				A []byte `json:"a,omitempty"`
  1153  				B []byte `json:"b,omitempty"`
  1154  			}{A: []byte("foo"), B: []byte("bar")}), B: &(struct {
  1155  				A []byte `json:"a,omitempty"`
  1156  				B []byte `json:"b,omitempty"`
  1157  			}{A: []byte("foo"), B: []byte("bar")})},
  1158  		},
  1159  		{
  1160  			name: "PtrHeadBytesDoubleMultiFieldsNotRootString",
  1161  			data: &struct {
  1162  				A *struct {
  1163  					A []byte `json:"a,string"`
  1164  					B []byte `json:"b,string"`
  1165  				}
  1166  				B *struct {
  1167  					A []byte `json:"a,string"`
  1168  					B []byte `json:"b,string"`
  1169  				}
  1170  			}{A: &(struct {
  1171  				A []byte `json:"a,string"`
  1172  				B []byte `json:"b,string"`
  1173  			}{A: []byte("foo"), B: []byte("bar")}), B: &(struct {
  1174  				A []byte `json:"a,string"`
  1175  				B []byte `json:"b,string"`
  1176  			}{A: []byte("foo"), B: []byte("bar")})},
  1177  		},
  1178  
  1179  		// PtrHeadBytesNilDoubleMultiFieldsNotRoot
  1180  		{
  1181  			name: "PtrHeadBytesNilDoubleMultiFieldsNotRoot",
  1182  			data: &struct {
  1183  				A *struct {
  1184  					A []byte `json:"a"`
  1185  					B []byte `json:"b"`
  1186  				}
  1187  				B *struct {
  1188  					A []byte `json:"a"`
  1189  					B []byte `json:"b"`
  1190  				}
  1191  			}{A: nil, B: nil},
  1192  		},
  1193  		{
  1194  			name: "PtrHeadBytesNilDoubleMultiFieldsNotRootOmitEmpty",
  1195  			data: &struct {
  1196  				A *struct {
  1197  					A []byte `json:"a,omitempty"`
  1198  					B []byte `json:"b,omitempty"`
  1199  				}
  1200  				B *struct {
  1201  					A []byte `json:"a,omitempty"`
  1202  					B []byte `json:"b,omitempty"`
  1203  				}
  1204  			}{A: nil, B: nil},
  1205  		},
  1206  		{
  1207  			name: "PtrHeadBytesNilDoubleMultiFieldsNotRootString",
  1208  			data: &struct {
  1209  				A *struct {
  1210  					A []byte `json:"a,string"`
  1211  					B []byte `json:"b,string"`
  1212  				}
  1213  				B *struct {
  1214  					A []byte `json:"a,string"`
  1215  					B []byte `json:"b,string"`
  1216  				}
  1217  			}{A: nil, B: nil},
  1218  		},
  1219  
  1220  		// PtrHeadBytesNilDoubleMultiFieldsNotRoot
  1221  		{
  1222  			name: "PtrHeadBytesNilDoubleMultiFieldsNotRoot",
  1223  			data: (*struct {
  1224  				A *struct {
  1225  					A []byte `json:"a"`
  1226  					B []byte `json:"b"`
  1227  				}
  1228  				B *struct {
  1229  					A []byte `json:"a"`
  1230  					B []byte `json:"b"`
  1231  				}
  1232  			})(nil),
  1233  		},
  1234  		{
  1235  			name: "PtrHeadBytesNilDoubleMultiFieldsNotRootOmitEmpty",
  1236  			data: (*struct {
  1237  				A *struct {
  1238  					A []byte `json:"a,omitempty"`
  1239  					B []byte `json:"b,omitempty"`
  1240  				}
  1241  				B *struct {
  1242  					A []byte `json:"a,omitempty"`
  1243  					B []byte `json:"b,omitempty"`
  1244  				}
  1245  			})(nil),
  1246  		},
  1247  		{
  1248  			name: "PtrHeadBytesNilDoubleMultiFieldsNotRootString",
  1249  			data: (*struct {
  1250  				A *struct {
  1251  					A []byte `json:"a,string"`
  1252  					B []byte `json:"b,string"`
  1253  				}
  1254  				B *struct {
  1255  					A []byte `json:"a,string"`
  1256  					B []byte `json:"b,string"`
  1257  				}
  1258  			})(nil),
  1259  		},
  1260  
  1261  		// PtrHeadBytesPtrDoubleMultiFieldsNotRoot
  1262  		{
  1263  			name: "PtrHeadBytesPtrDoubleMultiFieldsNotRoot",
  1264  			data: &struct {
  1265  				A *struct {
  1266  					A *[]byte `json:"a"`
  1267  					B *[]byte `json:"b"`
  1268  				}
  1269  				B *struct {
  1270  					A *[]byte `json:"a"`
  1271  					B *[]byte `json:"b"`
  1272  				}
  1273  			}{A: &(struct {
  1274  				A *[]byte `json:"a"`
  1275  				B *[]byte `json:"b"`
  1276  			}{A: bytesptr([]byte("foo")), B: bytesptr([]byte("bar"))}), B: &(struct {
  1277  				A *[]byte `json:"a"`
  1278  				B *[]byte `json:"b"`
  1279  			}{A: bytesptr([]byte("foo")), B: bytesptr([]byte("bar"))})},
  1280  		},
  1281  		{
  1282  			name: "PtrHeadBytesPtrDoubleMultiFieldsNotRootOmitEmpty",
  1283  			data: &struct {
  1284  				A *struct {
  1285  					A *[]byte `json:"a,omitempty"`
  1286  					B *[]byte `json:"b,omitempty"`
  1287  				}
  1288  				B *struct {
  1289  					A *[]byte `json:"a,omitempty"`
  1290  					B *[]byte `json:"b,omitempty"`
  1291  				}
  1292  			}{A: &(struct {
  1293  				A *[]byte `json:"a,omitempty"`
  1294  				B *[]byte `json:"b,omitempty"`
  1295  			}{A: bytesptr([]byte("foo")), B: bytesptr([]byte("bar"))}), B: &(struct {
  1296  				A *[]byte `json:"a,omitempty"`
  1297  				B *[]byte `json:"b,omitempty"`
  1298  			}{A: bytesptr([]byte("foo")), B: bytesptr([]byte("bar"))})},
  1299  		},
  1300  		{
  1301  			name: "PtrHeadBytesPtrDoubleMultiFieldsNotRootString",
  1302  			data: &struct {
  1303  				A *struct {
  1304  					A *[]byte `json:"a,string"`
  1305  					B *[]byte `json:"b,string"`
  1306  				}
  1307  				B *struct {
  1308  					A *[]byte `json:"a,string"`
  1309  					B *[]byte `json:"b,string"`
  1310  				}
  1311  			}{A: &(struct {
  1312  				A *[]byte `json:"a,string"`
  1313  				B *[]byte `json:"b,string"`
  1314  			}{A: bytesptr([]byte("foo")), B: bytesptr([]byte("bar"))}), B: &(struct {
  1315  				A *[]byte `json:"a,string"`
  1316  				B *[]byte `json:"b,string"`
  1317  			}{A: bytesptr([]byte("foo")), B: bytesptr([]byte("bar"))})},
  1318  		},
  1319  
  1320  		// PtrHeadBytesPtrNilDoubleMultiFieldsNotRoot
  1321  		{
  1322  			name: "PtrHeadBytesPtrNilDoubleMultiFieldsNotRoot",
  1323  			data: &struct {
  1324  				A *struct {
  1325  					A *[]byte `json:"a"`
  1326  					B *[]byte `json:"b"`
  1327  				}
  1328  				B *struct {
  1329  					A *[]byte `json:"a"`
  1330  					B *[]byte `json:"b"`
  1331  				}
  1332  			}{A: nil, B: nil},
  1333  		},
  1334  		{
  1335  			name: "PtrHeadBytesPtrNilDoubleMultiFieldsNotRootOmitEmpty",
  1336  			data: &struct {
  1337  				A *struct {
  1338  					A *[]byte `json:"a,omitempty"`
  1339  					B *[]byte `json:"b,omitempty"`
  1340  				}
  1341  				B *struct {
  1342  					A *[]byte `json:"a,omitempty"`
  1343  					B *[]byte `json:"b,omitempty"`
  1344  				}
  1345  			}{A: nil, B: nil},
  1346  		},
  1347  		{
  1348  			name: "PtrHeadBytesPtrNilDoubleMultiFieldsNotRootString",
  1349  			data: &struct {
  1350  				A *struct {
  1351  					A *[]byte `json:"a,string"`
  1352  					B *[]byte `json:"b,string"`
  1353  				}
  1354  				B *struct {
  1355  					A *[]byte `json:"a,string"`
  1356  					B *[]byte `json:"b,string"`
  1357  				}
  1358  			}{A: nil, B: nil},
  1359  		},
  1360  
  1361  		// PtrHeadBytesPtrNilDoubleMultiFieldsNotRoot
  1362  		{
  1363  			name: "PtrHeadBytesPtrNilDoubleMultiFieldsNotRoot",
  1364  			data: (*struct {
  1365  				A *struct {
  1366  					A *[]byte `json:"a"`
  1367  					B *[]byte `json:"b"`
  1368  				}
  1369  				B *struct {
  1370  					A *[]byte `json:"a"`
  1371  					B *[]byte `json:"b"`
  1372  				}
  1373  			})(nil),
  1374  		},
  1375  		{
  1376  			name: "PtrHeadBytesPtrNilDoubleMultiFieldsNotRootOmitEmpty",
  1377  			data: (*struct {
  1378  				A *struct {
  1379  					A *[]byte `json:"a,omitempty"`
  1380  					B *[]byte `json:"b,omitempty"`
  1381  				}
  1382  				B *struct {
  1383  					A *[]byte `json:"a,omitempty"`
  1384  					B *[]byte `json:"b,omitempty"`
  1385  				}
  1386  			})(nil),
  1387  		},
  1388  		{
  1389  			name: "PtrHeadBytesPtrNilDoubleMultiFieldsNotRootString",
  1390  			data: (*struct {
  1391  				A *struct {
  1392  					A *[]byte `json:"a,string"`
  1393  					B *[]byte `json:"b,string"`
  1394  				}
  1395  				B *struct {
  1396  					A *[]byte `json:"a,string"`
  1397  					B *[]byte `json:"b,string"`
  1398  				}
  1399  			})(nil),
  1400  		},
  1401  
  1402  		// AnonymousHeadBytes
  1403  		{
  1404  			name: "AnonymousHeadString",
  1405  			data: struct {
  1406  				structBytes
  1407  				B []byte `json:"b"`
  1408  			}{
  1409  				structBytes: structBytes{A: []byte("foo")},
  1410  				B:           []byte("bar"),
  1411  			},
  1412  		},
  1413  		{
  1414  			name: "AnonymousHeadBytesOmitEmpty",
  1415  			data: struct {
  1416  				structBytesOmitEmpty
  1417  				B []byte `json:"b,omitempty"`
  1418  			}{
  1419  				structBytesOmitEmpty: structBytesOmitEmpty{A: []byte("foo")},
  1420  				B:                    []byte("bar"),
  1421  			},
  1422  		},
  1423  		{
  1424  			name: "AnonymousHeadBytesString",
  1425  			data: struct {
  1426  				structBytesBytes
  1427  				B []byte `json:"b,string"`
  1428  			}{
  1429  				structBytesBytes: structBytesBytes{A: []byte("foo")},
  1430  				B:                []byte("bar"),
  1431  			},
  1432  		},
  1433  
  1434  		// PtrAnonymousHeadBytes
  1435  		{
  1436  			name: "PtrAnonymousHeadString",
  1437  			data: struct {
  1438  				*structBytes
  1439  				B []byte `json:"b"`
  1440  			}{
  1441  				structBytes: &structBytes{A: []byte("foo")},
  1442  				B:           []byte("bar"),
  1443  			},
  1444  		},
  1445  		{
  1446  			name: "PtrAnonymousHeadBytesOmitEmpty",
  1447  			data: struct {
  1448  				*structBytesOmitEmpty
  1449  				B []byte `json:"b,omitempty"`
  1450  			}{
  1451  				structBytesOmitEmpty: &structBytesOmitEmpty{A: []byte("foo")},
  1452  				B:                    []byte("bar"),
  1453  			},
  1454  		},
  1455  		{
  1456  			name: "PtrAnonymousHeadBytesString",
  1457  			data: struct {
  1458  				*structBytesBytes
  1459  				B []byte `json:"b,string"`
  1460  			}{
  1461  				structBytesBytes: &structBytesBytes{A: []byte("foo")},
  1462  				B:                []byte("bar"),
  1463  			},
  1464  		},
  1465  
  1466  		// NilPtrAnonymousHeadBytes
  1467  		{
  1468  			name: "NilPtrAnonymousHeadString",
  1469  			data: struct {
  1470  				*structBytes
  1471  				B []byte `json:"b"`
  1472  			}{
  1473  				structBytes: nil,
  1474  				B:           []byte("baz"),
  1475  			},
  1476  		},
  1477  		{
  1478  			name: "NilPtrAnonymousHeadBytesOmitEmpty",
  1479  			data: struct {
  1480  				*structBytesOmitEmpty
  1481  				B []byte `json:"b,omitempty"`
  1482  			}{
  1483  				structBytesOmitEmpty: nil,
  1484  				B:                    []byte("baz"),
  1485  			},
  1486  		},
  1487  		{
  1488  			name: "NilPtrAnonymousHeadBytesString",
  1489  			data: struct {
  1490  				*structBytesBytes
  1491  				B []byte `json:"b,string"`
  1492  			}{
  1493  				structBytesBytes: nil,
  1494  				B:                []byte("baz"),
  1495  			},
  1496  		},
  1497  
  1498  		// AnonymousHeadBytesPtr
  1499  		{
  1500  			name: "AnonymousHeadBytesPtr",
  1501  			data: struct {
  1502  				structBytesPtr
  1503  				B *[]byte `json:"b"`
  1504  			}{
  1505  				structBytesPtr: structBytesPtr{A: bytesptr([]byte("foo"))},
  1506  				B:              bytesptr([]byte("bar")),
  1507  			},
  1508  		},
  1509  		{
  1510  			name: "AnonymousHeadBytesPtrOmitEmpty",
  1511  			data: struct {
  1512  				structBytesPtrOmitEmpty
  1513  				B *[]byte `json:"b,omitempty"`
  1514  			}{
  1515  				structBytesPtrOmitEmpty: structBytesPtrOmitEmpty{A: bytesptr([]byte("foo"))},
  1516  				B:                       bytesptr([]byte("bar")),
  1517  			},
  1518  		},
  1519  		{
  1520  			name: "AnonymousHeadBytesPtrString",
  1521  			data: struct {
  1522  				structBytesPtrBytes
  1523  				B *[]byte `json:"b,string"`
  1524  			}{
  1525  				structBytesPtrBytes: structBytesPtrBytes{A: bytesptr([]byte("foo"))},
  1526  				B:                   bytesptr([]byte("bar")),
  1527  			},
  1528  		},
  1529  
  1530  		// AnonymousHeadBytesPtrNil
  1531  		{
  1532  			name: "AnonymousHeadBytesPtrNil",
  1533  			data: struct {
  1534  				structBytesPtr
  1535  				B *[]byte `json:"b"`
  1536  			}{
  1537  				structBytesPtr: structBytesPtr{A: nil},
  1538  				B:              bytesptr([]byte("foo")),
  1539  			},
  1540  		},
  1541  		{
  1542  			name: "AnonymousHeadBytesPtrNilOmitEmpty",
  1543  			data: struct {
  1544  				structBytesPtrOmitEmpty
  1545  				B *[]byte `json:"b,omitempty"`
  1546  			}{
  1547  				structBytesPtrOmitEmpty: structBytesPtrOmitEmpty{A: nil},
  1548  				B:                       bytesptr([]byte("foo")),
  1549  			},
  1550  		},
  1551  		{
  1552  			name: "AnonymousHeadBytesPtrNilString",
  1553  			data: struct {
  1554  				structBytesPtrBytes
  1555  				B *[]byte `json:"b,string"`
  1556  			}{
  1557  				structBytesPtrBytes: structBytesPtrBytes{A: nil},
  1558  				B:                   bytesptr([]byte("foo")),
  1559  			},
  1560  		},
  1561  
  1562  		// PtrAnonymousHeadBytesPtr
  1563  		{
  1564  			name: "PtrAnonymousHeadBytesPtr",
  1565  			data: struct {
  1566  				*structBytesPtr
  1567  				B *[]byte `json:"b"`
  1568  			}{
  1569  				structBytesPtr: &structBytesPtr{A: bytesptr([]byte("foo"))},
  1570  				B:              bytesptr([]byte("bar")),
  1571  			},
  1572  		},
  1573  		{
  1574  			name: "PtrAnonymousHeadBytesPtrOmitEmpty",
  1575  			data: struct {
  1576  				*structBytesPtrOmitEmpty
  1577  				B *[]byte `json:"b,omitempty"`
  1578  			}{
  1579  				structBytesPtrOmitEmpty: &structBytesPtrOmitEmpty{A: bytesptr([]byte("foo"))},
  1580  				B:                       bytesptr([]byte("bar")),
  1581  			},
  1582  		},
  1583  		{
  1584  			name: "PtrAnonymousHeadBytesPtrString",
  1585  			data: struct {
  1586  				*structBytesPtrBytes
  1587  				B *[]byte `json:"b,string"`
  1588  			}{
  1589  				structBytesPtrBytes: &structBytesPtrBytes{A: bytesptr([]byte("foo"))},
  1590  				B:                   bytesptr([]byte("bar")),
  1591  			},
  1592  		},
  1593  
  1594  		// NilPtrAnonymousHeadBytesPtr
  1595  		{
  1596  			name: "NilPtrAnonymousHeadBytesPtr",
  1597  			data: struct {
  1598  				*structBytesPtr
  1599  				B *[]byte `json:"b"`
  1600  			}{
  1601  				structBytesPtr: nil,
  1602  				B:              bytesptr([]byte("foo")),
  1603  			},
  1604  		},
  1605  		{
  1606  			name: "NilPtrAnonymousHeadBytesPtrOmitEmpty",
  1607  			data: struct {
  1608  				*structBytesPtrOmitEmpty
  1609  				B *[]byte `json:"b,omitempty"`
  1610  			}{
  1611  				structBytesPtrOmitEmpty: nil,
  1612  				B:                       bytesptr([]byte("foo")),
  1613  			},
  1614  		},
  1615  		{
  1616  			name: "NilPtrAnonymousHeadBytesPtrString",
  1617  			data: struct {
  1618  				*structBytesPtrBytes
  1619  				B *[]byte `json:"b,string"`
  1620  			}{
  1621  				structBytesPtrBytes: nil,
  1622  				B:                   bytesptr([]byte("foo")),
  1623  			},
  1624  		},
  1625  
  1626  		// AnonymousHeadBytesOnly
  1627  		{
  1628  			name: "AnonymousHeadBytesOnly",
  1629  			data: struct {
  1630  				structBytes
  1631  			}{
  1632  				structBytes: structBytes{A: []byte("foo")},
  1633  			},
  1634  		},
  1635  		{
  1636  			name: "AnonymousHeadBytesOnlyOmitEmpty",
  1637  			data: struct {
  1638  				structBytesOmitEmpty
  1639  			}{
  1640  				structBytesOmitEmpty: structBytesOmitEmpty{A: []byte("foo")},
  1641  			},
  1642  		},
  1643  		{
  1644  			name: "AnonymousHeadBytesOnlyString",
  1645  			data: struct {
  1646  				structBytesBytes
  1647  			}{
  1648  				structBytesBytes: structBytesBytes{A: []byte("foo")},
  1649  			},
  1650  		},
  1651  
  1652  		// PtrAnonymousHeadBytesOnly
  1653  		{
  1654  			name: "PtrAnonymousHeadBytesOnly",
  1655  			data: struct {
  1656  				*structBytes
  1657  			}{
  1658  				structBytes: &structBytes{A: []byte("foo")},
  1659  			},
  1660  		},
  1661  		{
  1662  			name: "PtrAnonymousHeadBytesOnlyOmitEmpty",
  1663  			data: struct {
  1664  				*structBytesOmitEmpty
  1665  			}{
  1666  				structBytesOmitEmpty: &structBytesOmitEmpty{A: []byte("foo")},
  1667  			},
  1668  		},
  1669  		{
  1670  			name: "PtrAnonymousHeadBytesOnlyString",
  1671  			data: struct {
  1672  				*structBytesBytes
  1673  			}{
  1674  				structBytesBytes: &structBytesBytes{A: []byte("foo")},
  1675  			},
  1676  		},
  1677  
  1678  		// NilPtrAnonymousHeadBytesOnly
  1679  		{
  1680  			name: "NilPtrAnonymousHeadBytesOnly",
  1681  			data: struct {
  1682  				*structBytes
  1683  			}{
  1684  				structBytes: nil,
  1685  			},
  1686  		},
  1687  		{
  1688  			name: "NilPtrAnonymousHeadBytesOnlyOmitEmpty",
  1689  			data: struct {
  1690  				*structBytesOmitEmpty
  1691  			}{
  1692  				structBytesOmitEmpty: nil,
  1693  			},
  1694  		},
  1695  		{
  1696  			name: "NilPtrAnonymousHeadBytesOnlyString",
  1697  			data: struct {
  1698  				*structBytesBytes
  1699  			}{
  1700  				structBytesBytes: nil,
  1701  			},
  1702  		},
  1703  
  1704  		// AnonymousHeadBytesPtrOnly
  1705  		{
  1706  			name: "AnonymousHeadBytesPtrOnly",
  1707  			data: struct {
  1708  				structBytesPtr
  1709  			}{
  1710  				structBytesPtr: structBytesPtr{A: bytesptr([]byte("foo"))},
  1711  			},
  1712  		},
  1713  		{
  1714  			name: "AnonymousHeadBytesPtrOnlyOmitEmpty",
  1715  			data: struct {
  1716  				structBytesPtrOmitEmpty
  1717  			}{
  1718  				structBytesPtrOmitEmpty: structBytesPtrOmitEmpty{A: bytesptr([]byte("foo"))},
  1719  			},
  1720  		},
  1721  		{
  1722  			name: "AnonymousHeadBytesPtrOnlyString",
  1723  			data: struct {
  1724  				structBytesPtrBytes
  1725  			}{
  1726  				structBytesPtrBytes: structBytesPtrBytes{A: bytesptr([]byte("foo"))},
  1727  			},
  1728  		},
  1729  
  1730  		// AnonymousHeadBytesPtrNilOnly
  1731  		{
  1732  			name: "AnonymousHeadBytesPtrNilOnly",
  1733  			data: struct {
  1734  				structBytesPtr
  1735  			}{
  1736  				structBytesPtr: structBytesPtr{A: nil},
  1737  			},
  1738  		},
  1739  		{
  1740  			name: "AnonymousHeadBytesPtrNilOnlyOmitEmpty",
  1741  			data: struct {
  1742  				structBytesPtrOmitEmpty
  1743  			}{
  1744  				structBytesPtrOmitEmpty: structBytesPtrOmitEmpty{A: nil},
  1745  			},
  1746  		},
  1747  		{
  1748  			name: "AnonymousHeadBytesPtrNilOnlyString",
  1749  			data: struct {
  1750  				structBytesPtrBytes
  1751  			}{
  1752  				structBytesPtrBytes: structBytesPtrBytes{A: nil},
  1753  			},
  1754  		},
  1755  
  1756  		// PtrAnonymousHeadBytesPtrOnly
  1757  		{
  1758  			name: "PtrAnonymousHeadBytesPtrOnly",
  1759  			data: struct {
  1760  				*structBytesPtr
  1761  			}{
  1762  				structBytesPtr: &structBytesPtr{A: bytesptr([]byte("foo"))},
  1763  			},
  1764  		},
  1765  		{
  1766  			name: "PtrAnonymousHeadBytesPtrOnlyOmitEmpty",
  1767  			data: struct {
  1768  				*structBytesPtrOmitEmpty
  1769  			}{
  1770  				structBytesPtrOmitEmpty: &structBytesPtrOmitEmpty{A: bytesptr([]byte("foo"))},
  1771  			},
  1772  		},
  1773  		{
  1774  			name: "PtrAnonymousHeadBytesPtrOnlyString",
  1775  			data: struct {
  1776  				*structBytesPtrBytes
  1777  			}{
  1778  				structBytesPtrBytes: &structBytesPtrBytes{A: bytesptr([]byte("foo"))},
  1779  			},
  1780  		},
  1781  
  1782  		// NilPtrAnonymousHeadBytesPtrOnly
  1783  		{
  1784  			name: "NilPtrAnonymousHeadBytesPtrOnly",
  1785  			data: struct {
  1786  				*structBytesPtr
  1787  			}{
  1788  				structBytesPtr: nil,
  1789  			},
  1790  		},
  1791  		{
  1792  			name: "NilPtrAnonymousHeadBytesPtrOnlyOmitEmpty",
  1793  			data: struct {
  1794  				*structBytesPtrOmitEmpty
  1795  			}{
  1796  				structBytesPtrOmitEmpty: nil,
  1797  			},
  1798  		},
  1799  		{
  1800  			name: "NilPtrAnonymousHeadBytesPtrOnlyString",
  1801  			data: struct {
  1802  				*structBytesPtrBytes
  1803  			}{
  1804  				structBytesPtrBytes: nil,
  1805  			},
  1806  		},
  1807  	}
  1808  	for _, test := range tests {
  1809  		for _, indent := range []bool{true, false} {
  1810  			for _, htmlEscape := range []bool{true, false} {
  1811  				t.Run(fmt.Sprintf("%s_indent_%t_escape_%t", test.name, indent, htmlEscape), func(t *testing.T) {
  1812  					var buf bytes.Buffer
  1813  					enc := json.NewEncoder(&buf)
  1814  					enc.SetEscapeHTML(htmlEscape)
  1815  					if indent {
  1816  						enc.SetIndent("", "  ")
  1817  					}
  1818  					if err := enc.Encode(test.data); err != nil {
  1819  						t.Fatalf("%s(htmlEscape:%v,indent:%v): %v: %s", test.name, htmlEscape, indent, test.data, err)
  1820  					}
  1821  					stdresult := encodeByEncodingJSON(test.data, indent, htmlEscape)
  1822  					if buf.String() != stdresult {
  1823  						t.Errorf("%s(htmlEscape:%v,indent:%v): doesn't compatible with encoding/json. expected %q but got %q", test.name, htmlEscape, indent, stdresult, buf.String())
  1824  					}
  1825  				})
  1826  			}
  1827  		}
  1828  	}
  1829  }
  1830  

View as plain text