1
2
3
4
5
6
7 package json
8
9 import (
10 "bytes"
11 "encoding"
12 "encoding/base32"
13 "encoding/base64"
14 "encoding/hex"
15 "errors"
16 "fmt"
17 "io"
18 "math"
19 "net"
20 "net/netip"
21 "reflect"
22 "strconv"
23 "strings"
24 "testing"
25 "time"
26
27 "encoding/json/internal"
28 "encoding/json/internal/jsonflags"
29 "encoding/json/internal/jsonopts"
30 "encoding/json/internal/jsontest"
31 "encoding/json/internal/jsonwire"
32 "encoding/json/jsontext"
33 )
34
35 func newNonStringNameError(offset int64, pointer jsontext.Pointer) error {
36 return &jsontext.SyntacticError{ByteOffset: offset, JSONPointer: pointer, Err: jsontext.ErrNonStringName}
37 }
38
39 func newInvalidCharacterError(prefix, where string, offset int64, pointer jsontext.Pointer) error {
40 return &jsontext.SyntacticError{ByteOffset: offset, JSONPointer: pointer, Err: jsonwire.NewInvalidCharacterError(prefix, where)}
41 }
42
43 func newInvalidUTF8Error(offset int64, pointer jsontext.Pointer) error {
44 return &jsontext.SyntacticError{ByteOffset: offset, JSONPointer: pointer, Err: jsonwire.ErrInvalidUTF8}
45 }
46
47 func newParseTimeError(layout, value, layoutElem, valueElem, message string) error {
48 return &time.ParseError{Layout: layout, Value: value, LayoutElem: layoutElem, ValueElem: valueElem, Message: message}
49 }
50
51 func EM(err error) *SemanticError {
52 return &SemanticError{action: "marshal", Err: err}
53 }
54
55 func EU(err error) *SemanticError {
56 return &SemanticError{action: "unmarshal", Err: err}
57 }
58
59 func (e *SemanticError) withVal(val string) *SemanticError {
60 e.JSONValue = jsontext.Value(val)
61 return e
62 }
63
64 func (e *SemanticError) withPos(prefix string, pointer jsontext.Pointer) *SemanticError {
65 e.ByteOffset = int64(len(prefix))
66 e.JSONPointer = pointer
67 return e
68 }
69
70 func (e *SemanticError) withType(k jsontext.Kind, t reflect.Type) *SemanticError {
71 e.JSONKind = k
72 e.GoType = t
73 return e
74 }
75
76 var (
77 errInvalidFormatFlag = errors.New(`invalid format flag "invalid"`)
78 errSomeError = errors.New("some error")
79 errMustNotCall = errors.New("must not call")
80 )
81
82 func T[T any]() reflect.Type { return reflect.TypeFor[T]() }
83
84 type (
85 jsonObject = map[string]any
86 jsonArray = []any
87
88 namedAny any
89 namedBool bool
90 namedString string
91 NamedString string
92 namedBytes []byte
93 namedInt64 int64
94 namedUint64 uint64
95 namedFloat64 float64
96 namedByte byte
97 netipAddr = netip.Addr
98
99 recursiveMap map[string]recursiveMap
100 recursiveSlice []recursiveSlice
101 recursivePointer struct{ P *recursivePointer }
102
103 structEmpty struct{}
104 structConflicting struct {
105 A string `json:"conflict"`
106 B string `json:"conflict"`
107 }
108 structNoneExported struct {
109 unexported string
110 }
111 structUnexportedIgnored struct {
112 ignored string `json:"-"`
113 }
114 structMalformedTag struct {
115 Malformed string `json:"\""`
116 }
117 structUnexportedTag struct {
118 unexported string `json:"name"`
119 }
120 structExportedEmbedded struct {
121 NamedString
122 }
123 structExportedEmbeddedTag struct {
124 NamedString `json:"name"`
125 }
126 structUnexportedEmbedded struct {
127 namedString
128 }
129 structUnexportedEmbeddedTag struct {
130 namedString `json:"name"`
131 }
132 structUnexportedEmbeddedMethodTag struct {
133
134
135 netipAddr `json:"name"`
136
137
138
139
140 }
141 structUnexportedEmbeddedStruct struct {
142 structOmitZeroAll
143 FizzBuzz int
144 structNestedAddr
145 }
146 structUnexportedEmbeddedStructPointer struct {
147 *structOmitZeroAll
148 FizzBuzz int
149 *structNestedAddr
150 }
151 structNestedAddr struct {
152 Addr netip.Addr
153 }
154 structIgnoredUnexportedEmbedded struct {
155 namedString `json:"-"`
156 }
157 structNoCase struct {
158 Aaa string `json:",case:strict"`
159 AA_A string
160 AaA string `json:",case:ignore"`
161 AAa string `json:",case:ignore"`
162 AAA string
163 }
164 structScalars struct {
165 unexported bool
166 Ignored bool `json:"-"`
167
168 Bool bool
169 String string
170 Bytes []byte
171 Int int64
172 Uint uint64
173 Float float64
174 }
175 structSlices struct {
176 unexported bool
177 Ignored bool `json:"-"`
178
179 SliceBool []bool
180 SliceString []string
181 SliceBytes [][]byte
182 SliceInt []int64
183 SliceUint []uint64
184 SliceFloat []float64
185 }
186 structMaps struct {
187 unexported bool
188 Ignored bool `json:"-"`
189
190 MapBool map[string]bool
191 MapString map[string]string
192 MapBytes map[string][]byte
193 MapInt map[string]int64
194 MapUint map[string]uint64
195 MapFloat map[string]float64
196 }
197 structAll struct {
198 Bool bool
199 String string
200 Bytes []byte
201 Int int64
202 Uint uint64
203 Float float64
204 Map map[string]string
205 StructScalars structScalars
206 StructMaps structMaps
207 StructSlices structSlices
208 Slice []string
209 Array [1]string
210 Pointer *structAll
211 Interface any
212 }
213 structOmitZeroAll struct {
214 Bool bool `json:",omitzero"`
215 String string `json:",omitzero"`
216 Bytes []byte `json:",omitzero"`
217 Int int64 `json:",omitzero"`
218 Uint uint64 `json:",omitzero"`
219 Float float64 `json:",omitzero"`
220 Map map[string]string `json:",omitzero"`
221 StructScalars structScalars `json:",omitzero"`
222 StructMaps structMaps `json:",omitzero"`
223 StructSlices structSlices `json:",omitzero"`
224 Slice []string `json:",omitzero"`
225 Array [1]string `json:",omitzero"`
226 Pointer *structOmitZeroAll `json:",omitzero"`
227 Interface any `json:",omitzero"`
228 }
229 structOmitZeroMethodAll struct {
230 ValueAlwaysZero valueAlwaysZero `json:",omitzero"`
231 ValueNeverZero valueNeverZero `json:",omitzero"`
232 PointerAlwaysZero pointerAlwaysZero `json:",omitzero"`
233 PointerNeverZero pointerNeverZero `json:",omitzero"`
234 PointerValueAlwaysZero *valueAlwaysZero `json:",omitzero"`
235 PointerValueNeverZero *valueNeverZero `json:",omitzero"`
236 PointerPointerAlwaysZero *pointerAlwaysZero `json:",omitzero"`
237 PointerPointerNeverZero *pointerNeverZero `json:",omitzero"`
238 PointerPointerValueAlwaysZero **valueAlwaysZero `json:",omitzero"`
239 PointerPointerValueNeverZero **valueNeverZero `json:",omitzero"`
240 PointerPointerPointerAlwaysZero **pointerAlwaysZero `json:",omitzero"`
241 PointerPointerPointerNeverZero **pointerNeverZero `json:",omitzero"`
242 }
243 structOmitZeroMethodInterfaceAll struct {
244 ValueAlwaysZero isZeroer `json:",omitzero"`
245 ValueNeverZero isZeroer `json:",omitzero"`
246 PointerValueAlwaysZero isZeroer `json:",omitzero"`
247 PointerValueNeverZero isZeroer `json:",omitzero"`
248 PointerPointerAlwaysZero isZeroer `json:",omitzero"`
249 PointerPointerNeverZero isZeroer `json:",omitzero"`
250 }
251 structOmitEmptyAll struct {
252 Bool bool `json:",omitempty"`
253 PointerBool *bool `json:",omitempty"`
254 String string `json:",omitempty"`
255 StringEmpty stringMarshalEmpty `json:",omitempty"`
256 StringNonEmpty stringMarshalNonEmpty `json:",omitempty"`
257 PointerString *string `json:",omitempty"`
258 PointerStringEmpty *stringMarshalEmpty `json:",omitempty"`
259 PointerStringNonEmpty *stringMarshalNonEmpty `json:",omitempty"`
260 Bytes []byte `json:",omitempty"`
261 BytesEmpty bytesMarshalEmpty `json:",omitempty"`
262 BytesNonEmpty bytesMarshalNonEmpty `json:",omitempty"`
263 PointerBytes *[]byte `json:",omitempty"`
264 PointerBytesEmpty *bytesMarshalEmpty `json:",omitempty"`
265 PointerBytesNonEmpty *bytesMarshalNonEmpty `json:",omitempty"`
266 Float float64 `json:",omitempty"`
267 PointerFloat *float64 `json:",omitempty"`
268 Map map[string]string `json:",omitempty"`
269 MapEmpty mapMarshalEmpty `json:",omitempty"`
270 MapNonEmpty mapMarshalNonEmpty `json:",omitempty"`
271 PointerMap *map[string]string `json:",omitempty"`
272 PointerMapEmpty *mapMarshalEmpty `json:",omitempty"`
273 PointerMapNonEmpty *mapMarshalNonEmpty `json:",omitempty"`
274 Slice []string `json:",omitempty"`
275 SliceEmpty sliceMarshalEmpty `json:",omitempty"`
276 SliceNonEmpty sliceMarshalNonEmpty `json:",omitempty"`
277 PointerSlice *[]string `json:",omitempty"`
278 PointerSliceEmpty *sliceMarshalEmpty `json:",omitempty"`
279 PointerSliceNonEmpty *sliceMarshalNonEmpty `json:",omitempty"`
280 Pointer *structOmitZeroEmptyAll `json:",omitempty"`
281 Interface any `json:",omitempty"`
282 }
283 structOmitZeroEmptyAll struct {
284 Bool bool `json:",omitzero,omitempty"`
285 String string `json:",omitzero,omitempty"`
286 Bytes []byte `json:",omitzero,omitempty"`
287 Int int64 `json:",omitzero,omitempty"`
288 Uint uint64 `json:",omitzero,omitempty"`
289 Float float64 `json:",omitzero,omitempty"`
290 Map map[string]string `json:",omitzero,omitempty"`
291 Slice []string `json:",omitzero,omitempty"`
292 Array [1]string `json:",omitzero,omitempty"`
293 Pointer *structOmitZeroEmptyAll `json:",omitzero,omitempty"`
294 Interface any `json:",omitzero,omitempty"`
295 }
296 structStringifiedLegacy struct {
297 Bool bool `json:",string"`
298 String string `json:",string"`
299 Int int64 `json:",string"`
300 Uint uint64 `json:",string"`
301 Float float64 `json:",string"`
302 PointerBool *bool `json:",string"`
303 PointerString *string `json:",string"`
304 PointerInt *int64 `json:",string"`
305 PointerUint *uint64 `json:",string"`
306 PointerFloat *float64 `json:",string"`
307 }
308 structStringified struct {
309 Int int64 `json:",string"`
310 Uint uint64 `json:",string"`
311 Float float64 `json:",string"`
312 PointerInt *int64 `json:",string"`
313 PointerUint *uint64 `json:",string"`
314 PointerFloat *float64 `json:",string"`
315 }
316 structStringifiedBool struct {
317 Bool bool `json:",string"`
318 }
319 structStringifiedString struct {
320 String string `json:",string"`
321 }
322 structStringifiedBytes struct {
323 Bytes []byte `json:",string"`
324 }
325 structStringifiedMap struct {
326 Map map[string]string `json:",string"`
327 }
328 structStringifiedSlice struct {
329 Slice []string `json:",string"`
330 }
331 structStringifiedArray struct {
332 Array [1]string `json:",string"`
333 }
334 structStringifiedStruct struct {
335 Struct structAll `json:",string"`
336 }
337 structStringifiedPointer struct {
338 Pointer *structAll `json:",string"`
339 }
340 structStringifiedPointerPointerInt struct {
341 Pointer **int `json:",string"`
342 }
343 structStringifiedInterface struct {
344 Interface any `json:",string"`
345 }
346 structFormatBytes struct {
347 Base16 []byte `json:",format:base16"`
348 Base32 []byte `json:",format:base32"`
349 Base32Hex []byte `json:",format:base32hex"`
350 Base64 []byte `json:",format:base64"`
351 Base64URL []byte `json:",format:base64url"`
352 Array []byte `json:",format:array"`
353 }
354 structFormatArrayBytes struct {
355 Base16 [4]byte `json:",format:base16"`
356 Base32 [4]byte `json:",format:base32"`
357 Base32Hex [4]byte `json:",format:base32hex"`
358 Base64 [4]byte `json:",format:base64"`
359 Base64URL [4]byte `json:",format:base64url"`
360 Array [4]byte `json:",format:array"`
361 Default [4]byte
362 }
363 structFormatFloats struct {
364 NonFinite float64 `json:",format:nonfinite"`
365 PointerNonFinite *float64 `json:",format:nonfinite"`
366 }
367 structFormatMaps struct {
368 EmitNull map[string]string `json:",format:emitnull"`
369 PointerEmitNull *map[string]string `json:",format:emitnull"`
370 EmitEmpty map[string]string `json:",format:emitempty"`
371 PointerEmitEmpty *map[string]string `json:",format:emitempty"`
372 EmitDefault map[string]string
373 PointerEmitDefault *map[string]string
374 }
375 structFormatSlices struct {
376 EmitNull []string `json:",format:emitnull"`
377 PointerEmitNull *[]string `json:",format:emitnull"`
378 EmitEmpty []string `json:",format:emitempty"`
379 PointerEmitEmpty *[]string `json:",format:emitempty"`
380 EmitDefault []string
381 PointerEmitDefault *[]string
382 }
383 structFormatInvalid struct {
384 Bool bool `json:",omitzero,format:invalid"`
385 String string `json:",omitzero,format:invalid"`
386 Bytes []byte `json:",omitzero,format:invalid"`
387 Int int64 `json:",omitzero,format:invalid"`
388 Uint uint64 `json:",omitzero,format:invalid"`
389 Float float64 `json:",omitzero,format:invalid"`
390 Map map[string]string `json:",omitzero,format:invalid"`
391 Struct structAll `json:",omitzero,format:invalid"`
392 Slice []string `json:",omitzero,format:invalid"`
393 Array [1]string `json:",omitzero,format:invalid"`
394 Interface any `json:",omitzero,format:invalid"`
395 }
396 structDurationFormat struct {
397 D1 time.Duration `json:",format:units"`
398 D2 time.Duration `json:",format:units"`
399 D3 time.Duration `json:",format:sec"`
400 D4 time.Duration `json:",string,format:sec"`
401 D5 time.Duration `json:",format:milli"`
402 D6 time.Duration `json:",string,format:milli"`
403 D7 time.Duration `json:",format:micro"`
404 D8 time.Duration `json:",string,format:micro"`
405 D9 time.Duration `json:",format:nano"`
406 D10 time.Duration `json:",string,format:nano"`
407 D11 time.Duration `json:",format:iso8601"`
408 }
409 structTimeFormat struct {
410 T1 time.Time
411 T2 time.Time `json:",format:ANSIC"`
412 T3 time.Time `json:",format:UnixDate"`
413 T4 time.Time `json:",format:RubyDate"`
414 T5 time.Time `json:",format:RFC822"`
415 T6 time.Time `json:",format:RFC822Z"`
416 T7 time.Time `json:",format:RFC850"`
417 T8 time.Time `json:",format:RFC1123"`
418 T9 time.Time `json:",format:RFC1123Z"`
419 T10 time.Time `json:",format:RFC3339"`
420 T11 time.Time `json:",format:RFC3339Nano"`
421 T12 time.Time `json:",format:Kitchen"`
422 T13 time.Time `json:",format:Stamp"`
423 T14 time.Time `json:",format:StampMilli"`
424 T15 time.Time `json:",format:StampMicro"`
425 T16 time.Time `json:",format:StampNano"`
426 T17 time.Time `json:",format:DateTime"`
427 T18 time.Time `json:",format:DateOnly"`
428 T19 time.Time `json:",format:TimeOnly"`
429 T20 time.Time `json:",format:'2006-01-02'"`
430 T21 time.Time `json:",format:'\"weird\"2006'"`
431 T22 time.Time `json:",format:unix"`
432 T23 time.Time `json:",string,format:unix"`
433 T24 time.Time `json:",format:unixmilli"`
434 T25 time.Time `json:",string,format:unixmilli"`
435 T26 time.Time `json:",format:unixmicro"`
436 T27 time.Time `json:",string,format:unixmicro"`
437 T28 time.Time `json:",format:unixnano"`
438 T29 time.Time `json:",string,format:unixnano"`
439 }
440 structTimeFormatStringInvalid struct {
441 T time.Time `json:",string,format:RFC3339"`
442 }
443 structEmbedded struct {
444 X structEmbeddedL1 `json:",embed"`
445 *StructEmbed2
446 }
447 structEmbeddedL1 struct {
448 X *structEmbeddedL2 `json:",embed"`
449 StructEmbed1 `json:",embed"`
450 }
451 structEmbeddedL2 struct{ A, B, C string }
452 StructEmbed1 struct{ C, D, E string }
453 StructEmbed2 struct{ E, F, G string }
454 structEmbedTextValue struct {
455 A int `json:",omitzero"`
456 X jsontext.Value `json:",embed"`
457 B int `json:",omitzero"`
458 }
459 structEmbedPointerTextValue struct {
460 A int `json:",omitzero"`
461 X *jsontext.Value `json:",embed"`
462 B int `json:",omitzero"`
463 }
464 structEmbedPointerEmbedTextValue struct {
465 X *struct {
466 A int
467 X jsontext.Value `json:",embed"`
468 } `json:",embed"`
469 }
470 structEmbedEmbedPointerTextValue struct {
471 X struct {
472 X *jsontext.Value `json:",embed"`
473 } `json:",embed"`
474 }
475 structEmbedMapStringAny struct {
476 A int `json:",omitzero"`
477 X jsonObject `json:",embed"`
478 B int `json:",omitzero"`
479 }
480 structEmbedPointerMapStringAny struct {
481 A int `json:",omitzero"`
482 X *jsonObject `json:",embed"`
483 B int `json:",omitzero"`
484 }
485 structEmbedPointerEmbedMapStringAny struct {
486 X *struct {
487 A int
488 X jsonObject `json:",embed"`
489 } `json:",embed"`
490 }
491 structEmbedEmbedPointerMapStringAny struct {
492 X struct {
493 X *jsonObject `json:",embed"`
494 } `json:",embed"`
495 }
496 structEmbedMapStringInt struct {
497 X map[string]int `json:",embed"`
498 }
499 structEmbedMapNamedStringInt struct {
500 X map[namedString]int `json:",embed"`
501 }
502 structEmbedMapNamedStringAny struct {
503 A int `json:",omitzero"`
504 X map[namedString]any `json:",embed"`
505 B int `json:",omitzero"`
506 }
507 structNoCaseEmbedTextValue struct {
508 AAA string `json:",omitempty,case:strict"`
509 AA_b string `json:",omitempty"`
510 AaA string `json:",omitempty,case:ignore"`
511 AAa string `json:",omitempty,case:ignore"`
512 Aaa string `json:",omitempty"`
513 X jsontext.Value `json:",embed"`
514 }
515 structNoCaseEmbedMapStringAny struct {
516 AAA string `json:",omitempty"`
517 AaA string `json:",omitempty,case:ignore"`
518 AAa string `json:",omitempty,case:ignore"`
519 Aaa string `json:",omitempty"`
520 X jsonObject `json:",embed"`
521 }
522
523 allMethods struct {
524 method string
525 value []byte
526 }
527 allMethodsExceptJSONv2 struct {
528 allMethods
529 MarshalJSONTo struct{}
530 UnmarshalJSONFrom struct{}
531 }
532 allMethodsExceptJSONv1 struct {
533 allMethods
534 MarshalJSON struct{}
535 UnmarshalJSON struct{}
536 }
537 allMethodsExceptText struct {
538 allMethods
539 MarshalText struct{}
540 UnmarshalText struct{}
541 }
542 onlyMethodJSONv2 struct {
543 allMethods
544 MarshalJSON struct{}
545 UnmarshalJSON struct{}
546 MarshalText struct{}
547 UnmarshalText struct{}
548 }
549 onlyMethodJSONv1 struct {
550 allMethods
551 MarshalJSONTo struct{}
552 UnmarshalJSONFrom struct{}
553 MarshalText struct{}
554 UnmarshalText struct{}
555 }
556 onlyMethodText struct {
557 allMethods
558 MarshalJSONTo struct{}
559 UnmarshalJSONFrom struct{}
560 MarshalJSON struct{}
561 UnmarshalJSON struct{}
562 }
563
564 unsupportedMethodJSONv2 map[string]int
565
566 structMethodJSONv2 struct{ value string }
567 structMethodJSONv1 struct{ value string }
568 structMethodText struct{ value string }
569
570 marshalJSONv2Func func(*jsontext.Encoder) error
571 marshalJSONv1Func func() ([]byte, error)
572 appendTextFunc func([]byte) ([]byte, error)
573 marshalTextFunc func() ([]byte, error)
574 unmarshalJSONv2Func func(*jsontext.Decoder) error
575 unmarshalJSONv1Func func([]byte) error
576 unmarshalTextFunc func([]byte) error
577
578 nocaseString string
579
580 stringMarshalEmpty string
581 stringMarshalNonEmpty string
582 bytesMarshalEmpty []byte
583 bytesMarshalNonEmpty []byte
584 mapMarshalEmpty map[string]string
585 mapMarshalNonEmpty map[string]string
586 sliceMarshalEmpty []string
587 sliceMarshalNonEmpty []string
588
589 valueAlwaysZero string
590 valueNeverZero string
591 pointerAlwaysZero string
592 pointerNeverZero string
593
594 valueStringer struct{}
595 pointerStringer struct{}
596
597 cyclicA struct {
598 B1 cyclicB `json:",embed"`
599 B2 cyclicB `json:",embed"`
600 }
601 cyclicB struct {
602 F int
603 A *cyclicA `json:",embed"`
604 }
605 )
606
607 func (structUnexportedEmbeddedMethodTag) MarshalText() {}
608 func (structUnexportedEmbeddedMethodTag) AppendText() {}
609
610 func (p *allMethods) MarshalJSONTo(enc *jsontext.Encoder) error {
611 if got, want := "MarshalJSONTo", p.method; got != want {
612 return fmt.Errorf("called wrong method: got %v, want %v", got, want)
613 }
614 return enc.WriteValue(p.value)
615 }
616 func (p *allMethods) MarshalJSON() ([]byte, error) {
617 if got, want := "MarshalJSON", p.method; got != want {
618 return nil, fmt.Errorf("called wrong method: got %v, want %v", got, want)
619 }
620 return p.value, nil
621 }
622 func (p *allMethods) MarshalText() ([]byte, error) {
623 if got, want := "MarshalText", p.method; got != want {
624 return nil, fmt.Errorf("called wrong method: got %v, want %v", got, want)
625 }
626 return p.value, nil
627 }
628
629 func (p *allMethods) UnmarshalJSONFrom(dec *jsontext.Decoder) error {
630 p.method = "UnmarshalJSONFrom"
631 val, err := dec.ReadValue()
632 p.value = val
633 return err
634 }
635 func (p *allMethods) UnmarshalJSON(val []byte) error {
636 p.method = "UnmarshalJSON"
637 p.value = val
638 return nil
639 }
640 func (p *allMethods) UnmarshalText(val []byte) error {
641 p.method = "UnmarshalText"
642 p.value = val
643 return nil
644 }
645
646 func (s *unsupportedMethodJSONv2) MarshalJSONTo(enc *jsontext.Encoder) error {
647 (*s)["called"] += 1
648 return errors.ErrUnsupported
649 }
650 func (s *unsupportedMethodJSONv2) UnmarshalJSONFrom(dec *jsontext.Decoder) error {
651 (*s)["called"] += 1
652 return errors.ErrUnsupported
653 }
654
655 func (s structMethodJSONv2) MarshalJSONTo(enc *jsontext.Encoder) error {
656 return enc.WriteToken(jsontext.String(s.value))
657 }
658 func (s *structMethodJSONv2) UnmarshalJSONFrom(dec *jsontext.Decoder) error {
659 tok, err := dec.ReadToken()
660 if err != nil {
661 return err
662 }
663 if k := tok.Kind(); k != '"' {
664 return EU(nil).withType(k, T[structMethodJSONv2]())
665 }
666 s.value = tok.String()
667 return nil
668 }
669
670 func (s structMethodJSONv1) MarshalJSON() ([]byte, error) {
671 return jsontext.AppendQuote(nil, s.value)
672 }
673 func (s *structMethodJSONv1) UnmarshalJSON(b []byte) error {
674 if k := jsontext.Value(b).Kind(); k != '"' {
675 return EU(nil).withType(k, T[structMethodJSONv1]())
676 }
677 b, _ = jsontext.AppendUnquote(nil, b)
678 s.value = string(b)
679 return nil
680 }
681
682 func (s structMethodText) MarshalText() ([]byte, error) {
683 return []byte(s.value), nil
684 }
685 func (s *structMethodText) UnmarshalText(b []byte) error {
686 s.value = string(b)
687 return nil
688 }
689
690 func (f marshalJSONv2Func) MarshalJSONTo(enc *jsontext.Encoder) error {
691 return f(enc)
692 }
693 func (f marshalJSONv1Func) MarshalJSON() ([]byte, error) {
694 return f()
695 }
696 func (f appendTextFunc) AppendText(b []byte) ([]byte, error) {
697 return f(b)
698 }
699 func (f marshalTextFunc) MarshalText() ([]byte, error) {
700 return f()
701 }
702 func (f unmarshalJSONv2Func) UnmarshalJSONFrom(dec *jsontext.Decoder) error {
703 return f(dec)
704 }
705 func (f unmarshalJSONv1Func) UnmarshalJSON(b []byte) error {
706 return f(b)
707 }
708 func (f unmarshalTextFunc) UnmarshalText(b []byte) error {
709 return f(b)
710 }
711
712 func (k nocaseString) MarshalText() ([]byte, error) {
713 return []byte(strings.ToLower(string(k))), nil
714 }
715 func (k *nocaseString) UnmarshalText(b []byte) error {
716 *k = nocaseString(strings.ToLower(string(b)))
717 return nil
718 }
719
720 func (stringMarshalEmpty) MarshalJSON() ([]byte, error) { return []byte(`""`), nil }
721 func (stringMarshalNonEmpty) MarshalJSON() ([]byte, error) { return []byte(`"value"`), nil }
722 func (bytesMarshalEmpty) MarshalJSON() ([]byte, error) { return []byte(`[]`), nil }
723 func (bytesMarshalNonEmpty) MarshalJSON() ([]byte, error) { return []byte(`["value"]`), nil }
724 func (mapMarshalEmpty) MarshalJSON() ([]byte, error) { return []byte(`{}`), nil }
725 func (mapMarshalNonEmpty) MarshalJSON() ([]byte, error) { return []byte(`{"key":"value"}`), nil }
726 func (sliceMarshalEmpty) MarshalJSON() ([]byte, error) { return []byte(`[]`), nil }
727 func (sliceMarshalNonEmpty) MarshalJSON() ([]byte, error) { return []byte(`["value"]`), nil }
728
729 func (valueAlwaysZero) IsZero() bool { return true }
730 func (valueNeverZero) IsZero() bool { return false }
731 func (*pointerAlwaysZero) IsZero() bool { return true }
732 func (*pointerNeverZero) IsZero() bool { return false }
733
734 func (valueStringer) String() string { return "" }
735 func (*pointerStringer) String() string { return "" }
736
737 func addr[T any](v T) *T {
738 return &v
739 }
740
741 func mustParseTime(layout, value string) time.Time {
742 t, err := time.Parse(layout, value)
743 if err != nil {
744 panic(err)
745 }
746 return t
747 }
748
749
750
751
752 var invalidFormatOption = &jsonopts.Struct{
753 ArshalValues: jsonopts.ArshalValues{Format: "invalid"},
754 }
755
756 func TestMarshal(t *testing.T) {
757 tests := []struct {
758 name jsontest.CaseName
759 opts []Options
760 in any
761 want string
762 wantErr error
763
764 canonicalize bool
765 useWriter bool
766 }{{
767 name: jsontest.Name("Nil"),
768 in: nil,
769 want: `null`,
770 }, {
771 name: jsontest.Name("Bools"),
772 in: []bool{false, true},
773 want: `[false,true]`,
774 }, {
775 name: jsontest.Name("Bools/Named"),
776 in: []namedBool{false, true},
777 want: `[false,true]`,
778 }, {
779 name: jsontest.Name("Bools/NotStringified"),
780 opts: []Options{StringifyNumbers(true)},
781 in: []bool{false, true},
782 want: `[false,true]`,
783 }, {
784 name: jsontest.Name("Bools/StringifiedBool/False"),
785 opts: []Options{jsonflags.StringTag | jsonflags.StringifyWithLegacySemantics | 1},
786 in: false,
787 want: `"false"`,
788 }, {
789 name: jsontest.Name("Bools/StringifiedBool/True"),
790 opts: []Options{jsonflags.StringTag | jsonflags.StringifyWithLegacySemantics | 1},
791 in: true,
792 want: `"true"`,
793 }, {
794 name: jsontest.Name("Bools/IgnoreInvalidFormat"),
795 opts: []Options{invalidFormatOption},
796 in: true,
797 want: `true`,
798 }, {
799 name: jsontest.Name("Strings"),
800 in: []string{"", "hello", "世界"},
801 want: `["","hello","世界"]`,
802 }, {
803 name: jsontest.Name("Strings/Named"),
804 in: []namedString{"", "hello", "世界"},
805 want: `["","hello","世界"]`,
806 }, {
807 name: jsontest.Name("Strings/StringifiedString"),
808 opts: []Options{jsonflags.StringTag | jsonflags.StringifyWithLegacySemantics | 1},
809 in: "hello",
810 want: `"\"hello\""`,
811 }, {
812 name: jsontest.Name("Strings/IgnoreInvalidFormat"),
813 opts: []Options{invalidFormatOption},
814 in: "string",
815 want: `"string"`,
816 }, {
817 name: jsontest.Name("Bytes"),
818 in: [][]byte{nil, {}, {1}, {1, 2}, {1, 2, 3}},
819 want: `["","","AQ==","AQI=","AQID"]`,
820 }, {
821 name: jsontest.Name("Bytes/FormatNilSliceAsNull"),
822 opts: []Options{FormatNilSliceAsNull(true)},
823 in: [][]byte{nil, {}},
824 want: `[null,""]`,
825 }, {
826 name: jsontest.Name("Bytes/Large"),
827 in: []byte("the quick brown fox jumped over the lazy dog and ate the homework that I spent so much time on."),
828 want: `"dGhlIHF1aWNrIGJyb3duIGZveCBqdW1wZWQgb3ZlciB0aGUgbGF6eSBkb2cgYW5kIGF0ZSB0aGUgaG9tZXdvcmsgdGhhdCBJIHNwZW50IHNvIG11Y2ggdGltZSBvbi4="`,
829 }, {
830 name: jsontest.Name("Bytes/Named"),
831 in: []namedBytes{nil, {}, {1}, {1, 2}, {1, 2, 3}},
832 want: `["","","AQ==","AQI=","AQID"]`,
833 }, {
834 name: jsontest.Name("Bytes/NotStringified"),
835 opts: []Options{StringifyNumbers(true)},
836 in: [][]byte{nil, {}, {1}, {1, 2}, {1, 2, 3}},
837 want: `["","","AQ==","AQI=","AQID"]`,
838 }, {
839
840
841 name: jsontest.Name("Bytes/Invariant"),
842 in: [][]namedByte{nil, {}, {1}, {1, 2}, {1, 2, 3}},
843 want: `[[],[],[1],[1,2],[1,2,3]]`,
844 }, {
845
846
847 name: jsontest.Name("Bytes/ByteArray"),
848 in: [5]byte{'h', 'e', 'l', 'l', 'o'},
849 want: `"aGVsbG8="`,
850 }, {
851
852
853 name: jsontest.Name("Bytes/NamedByteArray"),
854 in: [5]namedByte{'h', 'e', 'l', 'l', 'o'},
855 want: `[104,101,108,108,111]`,
856 }, {
857 name: jsontest.Name("Bytes/IgnoreInvalidFormat"),
858 opts: []Options{invalidFormatOption},
859 in: []byte("hello"),
860 want: `"aGVsbG8="`,
861 }, {
862 name: jsontest.Name("Ints"),
863 in: []any{
864 int(0), int8(math.MinInt8), int16(math.MinInt16), int32(math.MinInt32), int64(math.MinInt64), namedInt64(-6464),
865 },
866 want: `[0,-128,-32768,-2147483648,-9223372036854775808,-6464]`,
867 }, {
868 name: jsontest.Name("Ints/Stringified"),
869 opts: []Options{StringifyNumbers(true)},
870 in: []any{
871 int(0), int8(math.MinInt8), int16(math.MinInt16), int32(math.MinInt32), int64(math.MinInt64), namedInt64(-6464),
872 },
873 want: `["0","-128","-32768","-2147483648","-9223372036854775808","-6464"]`,
874 }, {
875 name: jsontest.Name("Ints/IgnoreInvalidFormat"),
876 opts: []Options{invalidFormatOption},
877 in: int(0),
878 want: `0`,
879 }, {
880 name: jsontest.Name("Uints"),
881 in: []any{
882 uint(0), uint8(math.MaxUint8), uint16(math.MaxUint16), uint32(math.MaxUint32), uint64(math.MaxUint64), namedUint64(6464), uintptr(1234),
883 },
884 want: `[0,255,65535,4294967295,18446744073709551615,6464,1234]`,
885 }, {
886 name: jsontest.Name("Uints/Stringified"),
887 opts: []Options{StringifyNumbers(true)},
888 in: []any{
889 uint(0), uint8(math.MaxUint8), uint16(math.MaxUint16), uint32(math.MaxUint32), uint64(math.MaxUint64), namedUint64(6464),
890 },
891 want: `["0","255","65535","4294967295","18446744073709551615","6464"]`,
892 }, {
893 name: jsontest.Name("Uints/IgnoreInvalidFormat"),
894 opts: []Options{invalidFormatOption},
895 in: uint(0),
896 want: `0`,
897 }, {
898 name: jsontest.Name("Floats"),
899 in: []any{
900 float32(math.MaxFloat32), float64(math.MaxFloat64), namedFloat64(64.64),
901 },
902 want: `[3.4028235e+38,1.7976931348623157e+308,64.64]`,
903 }, {
904 name: jsontest.Name("Floats/Stringified"),
905 opts: []Options{StringifyNumbers(true)},
906 in: []any{
907 float32(math.MaxFloat32), float64(math.MaxFloat64), namedFloat64(64.64),
908 },
909 want: `["3.4028235e+38","1.7976931348623157e+308","64.64"]`,
910 }, {
911 name: jsontest.Name("Floats/Invalid/NaN"),
912 opts: []Options{StringifyNumbers(true)},
913 in: math.NaN(),
914 wantErr: EM(fmt.Errorf("unsupported value: %v", math.NaN())).withType(0, float64Type),
915 }, {
916 name: jsontest.Name("Floats/Invalid/PositiveInfinity"),
917 in: math.Inf(+1),
918 wantErr: EM(fmt.Errorf("unsupported value: %v", math.Inf(+1))).withType(0, float64Type),
919 }, {
920 name: jsontest.Name("Floats/Invalid/NegativeInfinity"),
921 in: math.Inf(-1),
922 wantErr: EM(fmt.Errorf("unsupported value: %v", math.Inf(-1))).withType(0, float64Type),
923 }, {
924 name: jsontest.Name("Floats/IgnoreInvalidFormat"),
925 opts: []Options{invalidFormatOption},
926 in: float64(0),
927 want: `0`,
928 }, {
929 name: jsontest.Name("Maps/InvalidKey/Bool"),
930 in: map[bool]string{false: "value"},
931 want: `{`,
932 wantErr: EM(newNonStringNameError(len64(`{`), "")).withPos(`{`, "").withType(0, boolType),
933 }, {
934 name: jsontest.Name("Maps/InvalidKey/NamedBool"),
935 in: map[namedBool]string{false: "value"},
936 want: `{`,
937 wantErr: EM(newNonStringNameError(len64(`{`), "")).withPos(`{`, "").withType(0, T[namedBool]()),
938 }, {
939 name: jsontest.Name("Maps/InvalidKey/Array"),
940 in: map[[1]string]string{{"key"}: "value"},
941 want: `{`,
942 wantErr: EM(newNonStringNameError(len64(`{`), "")).withPos(`{`, "").withType(0, T[[1]string]()),
943 }, {
944 name: jsontest.Name("Maps/InvalidKey/Channel"),
945 in: map[chan string]string{make(chan string): "value"},
946 want: `{`,
947 wantErr: EM(nil).withPos(`{`, "").withType(0, T[chan string]()),
948 }, {
949 name: jsontest.Name("Maps/ValidKey/Int"),
950 in: map[int64]string{math.MinInt64: "MinInt64", 0: "Zero", math.MaxInt64: "MaxInt64"},
951 canonicalize: true,
952 want: `{"-9223372036854775808":"MinInt64","0":"Zero","9223372036854775807":"MaxInt64"}`,
953 }, {
954 name: jsontest.Name("Maps/ValidKey/PointerInt"),
955 in: map[*int64]string{addr(int64(math.MinInt64)): "MinInt64", addr(int64(0)): "Zero", addr(int64(math.MaxInt64)): "MaxInt64"},
956 canonicalize: true,
957 want: `{"-9223372036854775808":"MinInt64","0":"Zero","9223372036854775807":"MaxInt64"}`,
958 }, {
959 name: jsontest.Name("Maps/DuplicateName/PointerInt"),
960 in: map[*int64]string{addr(int64(0)): "0", addr(int64(0)): "0"},
961 canonicalize: true,
962 want: `{"0":"0"`,
963 wantErr: newDuplicateNameError("", []byte(`"0"`), len64(`{"0":"0",`)),
964 }, {
965 name: jsontest.Name("Maps/ValidKey/NamedInt"),
966 in: map[namedInt64]string{math.MinInt64: "MinInt64", 0: "Zero", math.MaxInt64: "MaxInt64"},
967 canonicalize: true,
968 want: `{"-9223372036854775808":"MinInt64","0":"Zero","9223372036854775807":"MaxInt64"}`,
969 }, {
970 name: jsontest.Name("Maps/ValidKey/Uint"),
971 in: map[uint64]string{0: "Zero", math.MaxUint64: "MaxUint64"},
972 canonicalize: true,
973 want: `{"0":"Zero","18446744073709551615":"MaxUint64"}`,
974 }, {
975 name: jsontest.Name("Maps/ValidKey/NamedUint"),
976 in: map[namedUint64]string{0: "Zero", math.MaxUint64: "MaxUint64"},
977 canonicalize: true,
978 want: `{"0":"Zero","18446744073709551615":"MaxUint64"}`,
979 }, {
980 name: jsontest.Name("Maps/ValidKey/Float"),
981 in: map[float64]string{3.14159: "value"},
982 want: `{"3.14159":"value"}`,
983 }, {
984 name: jsontest.Name("Maps/InvalidKey/Float/NaN"),
985 in: map[float64]string{math.NaN(): "NaN", math.NaN(): "NaN"},
986 want: `{`,
987 wantErr: EM(errors.New("unsupported value: NaN")).withPos(`{`, "").withType(0, float64Type),
988 }, {
989 name: jsontest.Name("Maps/ValidKey/Interface"),
990 in: map[any]any{
991 "key": "key",
992 namedInt64(-64): int32(-32),
993 namedUint64(+64): uint32(+32),
994 namedFloat64(64.64): float32(32.32),
995 },
996 canonicalize: true,
997 want: `{"-64":-32,"64":32,"64.64":32.32,"key":"key"}`,
998 }, {
999 name: jsontest.Name("Maps/DuplicateName/String/AllowInvalidUTF8+AllowDuplicateNames"),
1000 opts: []Options{jsontext.AllowInvalidUTF8(true), jsontext.AllowDuplicateNames(true)},
1001 in: map[string]string{"\x80": "", "\x81": ""},
1002 want: `{"�":"","�":""}`,
1003 }, {
1004 name: jsontest.Name("Maps/DuplicateName/String/AllowInvalidUTF8"),
1005 opts: []Options{jsontext.AllowInvalidUTF8(true)},
1006 in: map[string]string{"\x80": "", "\x81": ""},
1007 want: `{"�":""`,
1008 wantErr: newDuplicateNameError("", []byte(`"�"`), len64(`{"�":"",`)),
1009 }, {
1010 name: jsontest.Name("Maps/DuplicateName/NoCaseString/AllowDuplicateNames"),
1011 opts: []Options{jsontext.AllowDuplicateNames(true)},
1012 in: map[nocaseString]string{"hello": "", "HELLO": ""},
1013 want: `{"hello":"","hello":""}`,
1014 }, {
1015 name: jsontest.Name("Maps/DuplicateName/NoCaseString"),
1016 in: map[nocaseString]string{"hello": "", "HELLO": ""},
1017 want: `{"hello":""`,
1018 wantErr: EM(newDuplicateNameError("", []byte(`"hello"`), len64(`{"hello":"",`))).withPos(`{"hello":"",`, "").withType(0, T[nocaseString]()),
1019 }, {
1020 name: jsontest.Name("Maps/DuplicateName/NaNs/Deterministic+AllowDuplicateNames"),
1021 opts: []Options{
1022 WithMarshalers(
1023 MarshalFunc(func(v float64) ([]byte, error) { return []byte(`"NaN"`), nil }),
1024 ),
1025 Deterministic(true),
1026 jsontext.AllowDuplicateNames(true),
1027 },
1028 in: map[float64]string{math.NaN(): "NaN", math.NaN(): "NaN"},
1029 want: `{"NaN":"NaN","NaN":"NaN"}`,
1030 }, {
1031 name: jsontest.Name("Maps/InvalidValue/Channel"),
1032 in: map[string]chan string{
1033 "key": nil,
1034 },
1035 want: `{"key"`,
1036 wantErr: EM(nil).withPos(`{"key":`, "/key").withType(0, T[chan string]()),
1037 }, {
1038 name: jsontest.Name("Maps/String/Deterministic"),
1039 opts: []Options{Deterministic(true)},
1040 in: map[string]int{"a": 0, "b": 1, "c": 2},
1041 want: `{"a":0,"b":1,"c":2}`,
1042 }, {
1043 name: jsontest.Name("Maps/String/Deterministic+AllowInvalidUTF8+RejectDuplicateNames"),
1044 opts: []Options{
1045 Deterministic(true),
1046 jsontext.AllowInvalidUTF8(true),
1047 jsontext.AllowDuplicateNames(false),
1048 },
1049 in: map[string]int{"\xff": 0, "\xfe": 1},
1050 want: `{"�":1`,
1051 wantErr: newDuplicateNameError("", []byte(`"�"`), len64(`{"�":1,`)),
1052 }, {
1053 name: jsontest.Name("Maps/String/Deterministic+AllowInvalidUTF8+AllowDuplicateNames"),
1054 opts: []Options{
1055 Deterministic(true),
1056 jsontext.AllowInvalidUTF8(true),
1057 jsontext.AllowDuplicateNames(true),
1058 },
1059 in: map[string]int{"\xff": 0, "\xfe": 1},
1060 want: `{"�":1,"�":0}`,
1061 }, {
1062 name: jsontest.Name("Maps/String/Deterministic+MarshalFuncs"),
1063 opts: []Options{
1064 Deterministic(true),
1065 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v string) error {
1066 if p := enc.StackPointer(); p != "/X" {
1067 return fmt.Errorf("invalid stack pointer: got %s, want /X", p)
1068 }
1069 switch v {
1070 case "a":
1071 return enc.WriteToken(jsontext.String("b"))
1072 case "b":
1073 return enc.WriteToken(jsontext.String("a"))
1074 default:
1075 return fmt.Errorf("invalid value: %q", v)
1076 }
1077 })),
1078 },
1079 in: map[namedString]map[string]int{"X": {"a": -1, "b": 1}},
1080 want: `{"X":{"a":1,"b":-1}}`,
1081 }, {
1082 name: jsontest.Name("Maps/String/Deterministic+MarshalFuncs+RejectDuplicateNames"),
1083 opts: []Options{
1084 Deterministic(true),
1085 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v string) error {
1086 if p := enc.StackPointer(); p != "/X" {
1087 return fmt.Errorf("invalid stack pointer: got %s, want /X", p)
1088 }
1089 switch v {
1090 case "a", "b":
1091 return enc.WriteToken(jsontext.String("x"))
1092 default:
1093 return fmt.Errorf("invalid value: %q", v)
1094 }
1095 })),
1096 jsontext.AllowDuplicateNames(false),
1097 },
1098 in: map[namedString]map[string]int{"X": {"a": 1, "b": 1}},
1099 want: `{"X":{"x":1`,
1100 wantErr: newDuplicateNameError("/X/x", nil, len64(`{"X":{"x":1,`)),
1101 }, {
1102 name: jsontest.Name("Maps/String/Deterministic+MarshalFuncs+AllowDuplicateNames"),
1103 opts: []Options{
1104 Deterministic(true),
1105 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v string) error {
1106 if p := enc.StackPointer(); p != "/X" {
1107 return fmt.Errorf("invalid stack pointer: got %s, want /0", p)
1108 }
1109 switch v {
1110 case "a", "b":
1111 return enc.WriteToken(jsontext.String("x"))
1112 default:
1113 return fmt.Errorf("invalid value: %q", v)
1114 }
1115 })),
1116 jsontext.AllowDuplicateNames(true),
1117 },
1118 in: map[namedString]map[string]int{"X": {"a": 1, "b": 1}},
1119
1120
1121 want: `{"X":{"x":1,"x":1}}`,
1122 }, {
1123 name: jsontest.Name("Maps/RecursiveMap"),
1124 in: recursiveMap{
1125 "fizz": {
1126 "foo": {},
1127 "bar": nil,
1128 },
1129 "buzz": nil,
1130 },
1131 canonicalize: true,
1132 want: `{"buzz":{},"fizz":{"bar":{},"foo":{}}}`,
1133 }, {
1134 name: jsontest.Name("Maps/CyclicMap"),
1135 in: func() recursiveMap {
1136 m := recursiveMap{"k": nil}
1137 m["k"] = m
1138 return m
1139 }(),
1140 want: strings.Repeat(`{"k":`, startDetectingCyclesAfter) + `{"k"`,
1141 wantErr: EM(internal.ErrCycle).withPos(strings.Repeat(`{"k":`, startDetectingCyclesAfter+1), jsontext.Pointer(strings.Repeat("/k", startDetectingCyclesAfter+1))).withType(0, T[recursiveMap]()),
1142 }, {
1143 name: jsontest.Name("Maps/IgnoreInvalidFormat"),
1144 opts: []Options{invalidFormatOption},
1145 in: map[string]string{},
1146 want: `{}`,
1147 }, {
1148 name: jsontest.Name("Structs/Empty"),
1149 in: structEmpty{},
1150 want: `{}`,
1151 }, {
1152 name: jsontest.Name("Structs/UnexportedIgnored"),
1153 in: structUnexportedIgnored{ignored: "ignored"},
1154 want: `{}`,
1155 }, {
1156 name: jsontest.Name("Structs/IgnoredUnexportedEmbedded"),
1157 in: structIgnoredUnexportedEmbedded{namedString: "ignored"},
1158 want: `{}`,
1159 }, {
1160 name: jsontest.Name("Structs/NoCase"),
1161 in: structNoCase{AaA: "AaA", AAa: "AAa", Aaa: "Aaa", AAA: "AAA", AA_A: "AA_A"},
1162 want: `{"Aaa":"Aaa","AA_A":"AA_A","AaA":"AaA","AAa":"AAa","AAA":"AAA"}`,
1163 }, {
1164 name: jsontest.Name("Structs/NoCase/MatchCaseInsensitiveNames"),
1165 opts: []Options{MatchCaseInsensitiveNames(true)},
1166 in: structNoCase{AaA: "AaA", AAa: "AAa", Aaa: "Aaa", AAA: "AAA", AA_A: "AA_A"},
1167 want: `{"Aaa":"Aaa","AA_A":"AA_A","AaA":"AaA","AAa":"AAa","AAA":"AAA"}`,
1168 }, {
1169 name: jsontest.Name("Structs/NoCase/MatchCaseInsensitiveNames+MatchCaseSensitiveDelimiter"),
1170 opts: []Options{MatchCaseInsensitiveNames(true), jsonflags.MatchCaseSensitiveDelimiter | 1},
1171 in: structNoCase{AaA: "AaA", AAa: "AAa", Aaa: "Aaa", AAA: "AAA", AA_A: "AA_A"},
1172 want: `{"Aaa":"Aaa","AA_A":"AA_A","AaA":"AaA","AAa":"AAa","AAA":"AAA"}`,
1173 }, {
1174 name: jsontest.Name("Structs/Normal"),
1175 opts: []Options{jsontext.Multiline(true)},
1176 in: structAll{
1177 Bool: true,
1178 String: "hello",
1179 Bytes: []byte{1, 2, 3},
1180 Int: -64,
1181 Uint: +64,
1182 Float: 3.14159,
1183 Map: map[string]string{"key": "value"},
1184 StructScalars: structScalars{
1185 Bool: true,
1186 String: "hello",
1187 Bytes: []byte{1, 2, 3},
1188 Int: -64,
1189 Uint: +64,
1190 Float: 3.14159,
1191 },
1192 StructMaps: structMaps{
1193 MapBool: map[string]bool{"": true},
1194 MapString: map[string]string{"": "hello"},
1195 MapBytes: map[string][]byte{"": {1, 2, 3}},
1196 MapInt: map[string]int64{"": -64},
1197 MapUint: map[string]uint64{"": +64},
1198 MapFloat: map[string]float64{"": 3.14159},
1199 },
1200 StructSlices: structSlices{
1201 SliceBool: []bool{true},
1202 SliceString: []string{"hello"},
1203 SliceBytes: [][]byte{{1, 2, 3}},
1204 SliceInt: []int64{-64},
1205 SliceUint: []uint64{+64},
1206 SliceFloat: []float64{3.14159},
1207 },
1208 Slice: []string{"fizz", "buzz"},
1209 Array: [1]string{"goodbye"},
1210 Pointer: new(structAll),
1211 Interface: (*structAll)(nil),
1212 },
1213 want: `{
1214 "Bool": true,
1215 "String": "hello",
1216 "Bytes": "AQID",
1217 "Int": -64,
1218 "Uint": 64,
1219 "Float": 3.14159,
1220 "Map": {
1221 "key": "value"
1222 },
1223 "StructScalars": {
1224 "Bool": true,
1225 "String": "hello",
1226 "Bytes": "AQID",
1227 "Int": -64,
1228 "Uint": 64,
1229 "Float": 3.14159
1230 },
1231 "StructMaps": {
1232 "MapBool": {
1233 "": true
1234 },
1235 "MapString": {
1236 "": "hello"
1237 },
1238 "MapBytes": {
1239 "": "AQID"
1240 },
1241 "MapInt": {
1242 "": -64
1243 },
1244 "MapUint": {
1245 "": 64
1246 },
1247 "MapFloat": {
1248 "": 3.14159
1249 }
1250 },
1251 "StructSlices": {
1252 "SliceBool": [
1253 true
1254 ],
1255 "SliceString": [
1256 "hello"
1257 ],
1258 "SliceBytes": [
1259 "AQID"
1260 ],
1261 "SliceInt": [
1262 -64
1263 ],
1264 "SliceUint": [
1265 64
1266 ],
1267 "SliceFloat": [
1268 3.14159
1269 ]
1270 },
1271 "Slice": [
1272 "fizz",
1273 "buzz"
1274 ],
1275 "Array": [
1276 "goodbye"
1277 ],
1278 "Pointer": {
1279 "Bool": false,
1280 "String": "",
1281 "Bytes": "",
1282 "Int": 0,
1283 "Uint": 0,
1284 "Float": 0,
1285 "Map": {},
1286 "StructScalars": {
1287 "Bool": false,
1288 "String": "",
1289 "Bytes": "",
1290 "Int": 0,
1291 "Uint": 0,
1292 "Float": 0
1293 },
1294 "StructMaps": {
1295 "MapBool": {},
1296 "MapString": {},
1297 "MapBytes": {},
1298 "MapInt": {},
1299 "MapUint": {},
1300 "MapFloat": {}
1301 },
1302 "StructSlices": {
1303 "SliceBool": [],
1304 "SliceString": [],
1305 "SliceBytes": [],
1306 "SliceInt": [],
1307 "SliceUint": [],
1308 "SliceFloat": []
1309 },
1310 "Slice": [],
1311 "Array": [
1312 ""
1313 ],
1314 "Pointer": null,
1315 "Interface": null
1316 },
1317 "Interface": null
1318 }`,
1319 }, {
1320 name: jsontest.Name("Structs/SpaceAfterColonAndComma"),
1321 opts: []Options{jsontext.SpaceAfterColon(true), jsontext.SpaceAfterComma(true)},
1322 in: structOmitZeroAll{Int: 1, Uint: 1},
1323 want: `{"Int": 1, "Uint": 1}`,
1324 }, {
1325 name: jsontest.Name("Structs/SpaceAfterColon"),
1326 opts: []Options{jsontext.SpaceAfterColon(true)},
1327 in: structOmitZeroAll{Int: 1, Uint: 1},
1328 want: `{"Int": 1,"Uint": 1}`,
1329 }, {
1330 name: jsontest.Name("Structs/SpaceAfterComma"),
1331 opts: []Options{jsontext.SpaceAfterComma(true)},
1332 in: structOmitZeroAll{Int: 1, Uint: 1, Slice: []string{"a", "b"}},
1333 want: `{"Int":1, "Uint":1, "Slice":["a", "b"]}`,
1334 }, {
1335 name: jsontest.Name("Structs/Stringified"),
1336 opts: []Options{jsontext.Multiline(true)},
1337 in: structStringified{
1338 Int: -64,
1339 Uint: +64,
1340 Float: 3.14159,
1341 PointerInt: new(int64(-64)),
1342 PointerUint: new(uint64(+64)),
1343 PointerFloat: new(float64(3.14159)),
1344 },
1345 want: `{
1346 "Int": "-64",
1347 "Uint": "64",
1348 "Float": "3.14159",
1349 "PointerInt": "-64",
1350 "PointerUint": "64",
1351 "PointerFloat": "3.14159"
1352 }`,
1353 }, {
1354 name: jsontest.Name("Structs/LegacyStringified"),
1355 opts: []Options{jsontext.Multiline(true), jsonflags.StringifyWithLegacySemantics | 1},
1356 in: structStringifiedLegacy{
1357 Bool: true,
1358 String: "hello",
1359 Int: -64,
1360 Uint: +64,
1361 Float: 3.14159,
1362 PointerBool: new(true),
1363 PointerString: new("hello"),
1364 PointerInt: new(int64(-64)),
1365 PointerUint: new(uint64(+64)),
1366 PointerFloat: new(float64(3.14159)),
1367 },
1368 want: `{
1369 "Bool": "true",
1370 "String": "\"hello\"",
1371 "Int": "-64",
1372 "Uint": "64",
1373 "Float": "3.14159",
1374 "PointerBool": "true",
1375 "PointerString": "\"hello\"",
1376 "PointerInt": "-64",
1377 "PointerUint": "64",
1378 "PointerFloat": "3.14159"
1379 }`,
1380 }, {
1381 name: jsontest.Name("Structs/Stringified/Invalid/Bool"),
1382 in: structStringifiedBool{},
1383 want: `{"Bool"`,
1384 wantErr: EM(errInvalidStringTag).withPos(`{"Bool":`, "/Bool").withType(0, boolType),
1385 }, {
1386 name: jsontest.Name("Structs/Stringified/Ignored/Bool"),
1387 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
1388 in: structStringifiedBool{},
1389 want: `{"Bool":false}`,
1390 }, {
1391 name: jsontest.Name("Structs/Stringified/Invalid/String"),
1392 in: structStringifiedString{},
1393 want: `{"String"`,
1394 wantErr: EM(errInvalidStringTag).withPos(`{"String":`, "/String").withType(0, stringType),
1395 }, {
1396 name: jsontest.Name("Structs/Stringified/Ignored/String"),
1397 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
1398 in: structStringifiedString{},
1399 want: `{"String":""}`,
1400 }, {
1401 name: jsontest.Name("Structs/Stringified/Invalid/Bytes"),
1402 in: structStringifiedBytes{},
1403 want: `{"Bytes"`,
1404 wantErr: EM(errInvalidStringTag).withPos(`{"Bytes":`, "/Bytes").withType(0, bytesType),
1405 }, {
1406 name: jsontest.Name("Structs/Stringified/Ignored/Bytes"),
1407 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
1408 in: structStringifiedBytes{},
1409 want: `{"Bytes":""}`,
1410 }, {
1411 name: jsontest.Name("Structs/Stringified/Invalid/Map"),
1412 in: structStringifiedMap{},
1413 want: `{"Map"`,
1414 wantErr: EM(errInvalidStringTag).withPos(`{"Map":`, "/Map").withType(0, reflect.TypeFor[map[string]string]()),
1415 }, {
1416 name: jsontest.Name("Structs/Stringified/Ignored/Map"),
1417 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
1418 in: structStringifiedMap{},
1419 want: `{"Map":{}}`,
1420 }, {
1421 name: jsontest.Name("Structs/Stringified/Invalid/Slice"),
1422 in: structStringifiedSlice{},
1423 want: `{"Slice"`,
1424 wantErr: EM(errInvalidStringTag).withPos(`{"Slice":`, "/Slice").withType(0, reflect.TypeFor[[]string]()),
1425 }, {
1426 name: jsontest.Name("Structs/Stringified/Ignored/Slice"),
1427 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
1428 in: structStringifiedSlice{},
1429 want: `{"Slice":[]}`,
1430 }, {
1431 name: jsontest.Name("Structs/Stringified/Invalid/Array"),
1432 in: structStringifiedArray{},
1433 want: `{"Array"`,
1434 wantErr: EM(errInvalidStringTag).withPos(`{"Array":`, "/Array").withType(0, reflect.TypeFor[[1]string]()),
1435 }, {
1436 name: jsontest.Name("Structs/Stringified/Ignored/Array"),
1437 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
1438 in: structStringifiedArray{},
1439 want: `{"Array":[""]}`,
1440 }, {
1441 name: jsontest.Name("Structs/Stringified/Invalid/Struct"),
1442 in: structStringifiedStruct{},
1443 want: `{"Struct"`,
1444 wantErr: EM(errInvalidStringTag).withPos(`{"Struct":`, "/Struct").withType(0, reflect.TypeFor[structAll]()),
1445 }, {
1446 name: jsontest.Name("Structs/Stringified/Ignored/Struct"),
1447 opts: []Options{jsontext.Multiline(true), jsonflags.ReportErrorsWithLegacySemantics | 1},
1448 in: structStringifiedStruct{},
1449 want: `{
1450 "Struct": {
1451 "Bool": false,
1452 "String": "",
1453 "Bytes": "",
1454 "Int": 0,
1455 "Uint": 0,
1456 "Float": 0,
1457 "Map": {},
1458 "StructScalars": {
1459 "Bool": false,
1460 "String": "",
1461 "Bytes": "",
1462 "Int": 0,
1463 "Uint": 0,
1464 "Float": 0
1465 },
1466 "StructMaps": {
1467 "MapBool": {},
1468 "MapString": {},
1469 "MapBytes": {},
1470 "MapInt": {},
1471 "MapUint": {},
1472 "MapFloat": {}
1473 },
1474 "StructSlices": {
1475 "SliceBool": [],
1476 "SliceString": [],
1477 "SliceBytes": [],
1478 "SliceInt": [],
1479 "SliceUint": [],
1480 "SliceFloat": []
1481 },
1482 "Slice": [],
1483 "Array": [
1484 ""
1485 ],
1486 "Pointer": null,
1487 "Interface": null
1488 }
1489 }`,
1490 }, {
1491 name: jsontest.Name("Structs/Stringified/Invalid/Pointer"),
1492 in: structStringifiedPointer{},
1493 want: `{"Pointer":null}`,
1494 }, {
1495 name: jsontest.Name("Structs/Stringified/Ignored/Pointer"),
1496 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
1497 in: structStringifiedPointer{},
1498 want: `{"Pointer":null}`,
1499 }, {
1500 name: jsontest.Name("Structs/Stringified/PointerPointerInt"),
1501 in: structStringifiedPointerPointerInt{Pointer: new(new(5))},
1502 want: `{"Pointer":"5"}`,
1503 }, {
1504 name: jsontest.Name("Structs/Stringified/Invalid/Interface"),
1505 in: structStringifiedInterface{Interface: 1000},
1506 want: `{"Interface"`,
1507 wantErr: EM(errInvalidStringTag).withPos(`{"Interface":`, "/Interface").withType(0, anyType),
1508 }, {
1509 name: jsontest.Name("Structs/Stringified/Ignored/Interface"),
1510 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
1511 in: structStringifiedInterface{Interface: 1000},
1512 want: `{"Interface":"1000"}`,
1513 }, {
1514 name: jsontest.Name("Structs/LegacyStringified/Invalid/Bytes"),
1515 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
1516 want: `{"Bytes"`,
1517 wantErr: EM(errInvalidStringTag).withPos(`{"Bytes":`, "/Bytes").withType(0, bytesType),
1518 in: structStringifiedBytes{},
1519 }, {
1520 name: jsontest.Name("Structs/LegacyStringified/Ignored/Bytes"),
1521 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1, jsonflags.ReportErrorsWithLegacySemantics | 1},
1522 in: structStringifiedBytes{},
1523 want: `{"Bytes":""}`,
1524 }, {
1525 name: jsontest.Name("Structs/LegacyStringified/Invalid/Map"),
1526 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
1527 in: structStringifiedMap{},
1528 want: `{"Map"`,
1529 wantErr: EM(errInvalidStringTag).withPos(`{"Map":`, "/Map").withType(0, reflect.TypeFor[map[string]string]()),
1530 }, {
1531 name: jsontest.Name("Structs/LegacyStringified/Ignored/Map"),
1532 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1, jsonflags.ReportErrorsWithLegacySemantics | 1},
1533 in: structStringifiedMap{},
1534 want: `{"Map":{}}`,
1535 }, {
1536 name: jsontest.Name("Structs/LegacyStringified/Invalid/Slice"),
1537 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
1538 in: structStringifiedSlice{},
1539 want: `{"Slice"`,
1540 wantErr: EM(errInvalidStringTag).withPos(`{"Slice":`, "/Slice").withType(0, reflect.TypeFor[[]string]()),
1541 }, {
1542 name: jsontest.Name("Structs/LegacyStringified/Ignored/Slice"),
1543 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1, jsonflags.ReportErrorsWithLegacySemantics | 1},
1544 in: structStringifiedSlice{},
1545 want: `{"Slice":[]}`,
1546 }, {
1547 name: jsontest.Name("Structs/LegacyStringified/Invalid/Array"),
1548 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
1549 in: structStringifiedArray{},
1550 want: `{"Array"`,
1551 wantErr: EM(errInvalidStringTag).withPos(`{"Array":`, "/Array").withType(0, reflect.TypeFor[[1]string]()),
1552 }, {
1553 name: jsontest.Name("Structs/LegacyStringified/Ignored/Array"),
1554 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1, jsonflags.ReportErrorsWithLegacySemantics | 1},
1555 in: structStringifiedArray{},
1556 want: `{"Array":[""]}`,
1557 }, {
1558 name: jsontest.Name("Structs/LegacyStringified/Invalid/Struct"),
1559 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
1560 in: structStringifiedStruct{},
1561 want: `{"Struct"`,
1562 wantErr: EM(errInvalidStringTag).withPos(`{"Struct":`, "/Struct").withType(0, reflect.TypeFor[structAll]()),
1563 }, {
1564 name: jsontest.Name("Structs/LegacyStringified/Ignored/Struct"),
1565 opts: []Options{jsontext.Multiline(true), jsonflags.StringifyWithLegacySemantics | 1, jsonflags.ReportErrorsWithLegacySemantics | 1},
1566 in: structStringifiedStruct{},
1567 want: `{
1568 "Struct": {
1569 "Bool": false,
1570 "String": "",
1571 "Bytes": "",
1572 "Int": 0,
1573 "Uint": 0,
1574 "Float": 0,
1575 "Map": {},
1576 "StructScalars": {
1577 "Bool": false,
1578 "String": "",
1579 "Bytes": "",
1580 "Int": 0,
1581 "Uint": 0,
1582 "Float": 0
1583 },
1584 "StructMaps": {
1585 "MapBool": {},
1586 "MapString": {},
1587 "MapBytes": {},
1588 "MapInt": {},
1589 "MapUint": {},
1590 "MapFloat": {}
1591 },
1592 "StructSlices": {
1593 "SliceBool": [],
1594 "SliceString": [],
1595 "SliceBytes": [],
1596 "SliceInt": [],
1597 "SliceUint": [],
1598 "SliceFloat": []
1599 },
1600 "Slice": [],
1601 "Array": [
1602 ""
1603 ],
1604 "Pointer": null,
1605 "Interface": null
1606 }
1607 }`,
1608 }, {
1609 name: jsontest.Name("Structs/LegacyStringified/Invalid/Pointer"),
1610 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
1611 in: structStringifiedPointer{Pointer: new(structAll)},
1612 want: `{"Pointer"`,
1613 wantErr: EM(errInvalidStringTag).withPos(`{"Pointer":`, "/Pointer").withType(0, reflect.TypeFor[structAll]()),
1614 }, {
1615 name: jsontest.Name("Structs/LegacyStringified/Ignored/Pointer"),
1616 opts: []Options{jsontext.Multiline(true), jsonflags.StringifyWithLegacySemantics | 1, jsonflags.ReportErrorsWithLegacySemantics | 1},
1617 in: structStringifiedPointer{Pointer: new(structAll)},
1618 want: `{
1619 "Pointer": {
1620 "Bool": false,
1621 "String": "",
1622 "Bytes": "",
1623 "Int": 0,
1624 "Uint": 0,
1625 "Float": 0,
1626 "Map": {},
1627 "StructScalars": {
1628 "Bool": false,
1629 "String": "",
1630 "Bytes": "",
1631 "Int": 0,
1632 "Uint": 0,
1633 "Float": 0
1634 },
1635 "StructMaps": {
1636 "MapBool": {},
1637 "MapString": {},
1638 "MapBytes": {},
1639 "MapInt": {},
1640 "MapUint": {},
1641 "MapFloat": {}
1642 },
1643 "StructSlices": {
1644 "SliceBool": [],
1645 "SliceString": [],
1646 "SliceBytes": [],
1647 "SliceInt": [],
1648 "SliceUint": [],
1649 "SliceFloat": []
1650 },
1651 "Slice": [],
1652 "Array": [
1653 ""
1654 ],
1655 "Pointer": null,
1656 "Interface": null
1657 }
1658 }`,
1659 }, {
1660 name: jsontest.Name("Structs/LegacyStringified/Invalid/PointerPointerInt"),
1661 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
1662 in: structStringifiedPointerPointerInt{Pointer: new(new(5))},
1663 want: `{"Pointer"`,
1664 wantErr: EM(errInvalidStringTag).withPos(`{"Pointer":`, "/Pointer").withType(0, reflect.TypeFor[**int]()),
1665 }, {
1666 name: jsontest.Name("Structs/LegacyStringified/Ignored/PointerPointerInt"),
1667 opts: []Options{jsonflags.StringifyWithLegacySemantics | jsonflags.ReportErrorsWithLegacySemantics | 1},
1668 in: structStringifiedPointerPointerInt{Pointer: new(new(5))},
1669 want: `{"Pointer":5}`,
1670 }, {
1671 name: jsontest.Name("Structs/LegacyStringified/Invalid/Interface"),
1672 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
1673 in: structStringifiedInterface{},
1674 want: `{"Interface"`,
1675 wantErr: EM(errInvalidStringTag).withPos(`{"Interface":`, "/Interface").withType(0, anyType),
1676 }, {
1677 name: jsontest.Name("Structs/LegacyStringified/Ignored/Interface"),
1678 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1, jsonflags.ReportErrorsWithLegacySemantics | 1},
1679 in: structStringifiedInterface{Interface: 1000},
1680 want: `{"Interface":1000}`,
1681 }, {
1682 name: jsontest.Name("Structs/OmitZero/Zero"),
1683 in: structOmitZeroAll{},
1684 want: `{}`,
1685 }, {
1686 name: jsontest.Name("Structs/OmitZeroOption/Zero"),
1687 opts: []Options{OmitZeroStructFields(true)},
1688 in: structAll{},
1689 want: `{}`,
1690 }, {
1691 name: jsontest.Name("Structs/OmitZero/NonZero"),
1692 opts: []Options{jsontext.Multiline(true)},
1693 in: structOmitZeroAll{
1694 Bool: true,
1695 String: " ",
1696 Bytes: []byte{},
1697 Int: 1,
1698 Uint: 1,
1699 Float: math.SmallestNonzeroFloat64,
1700 Map: map[string]string{},
1701 StructScalars: structScalars{unexported: true},
1702 StructSlices: structSlices{Ignored: true},
1703 StructMaps: structMaps{MapBool: map[string]bool{}},
1704 Slice: []string{},
1705 Array: [1]string{" "},
1706 Pointer: new(structOmitZeroAll),
1707 Interface: (*structOmitZeroAll)(nil),
1708 },
1709 want: `{
1710 "Bool": true,
1711 "String": " ",
1712 "Bytes": "",
1713 "Int": 1,
1714 "Uint": 1,
1715 "Float": 5e-324,
1716 "Map": {},
1717 "StructScalars": {
1718 "Bool": false,
1719 "String": "",
1720 "Bytes": "",
1721 "Int": 0,
1722 "Uint": 0,
1723 "Float": 0
1724 },
1725 "StructMaps": {
1726 "MapBool": {},
1727 "MapString": {},
1728 "MapBytes": {},
1729 "MapInt": {},
1730 "MapUint": {},
1731 "MapFloat": {}
1732 },
1733 "StructSlices": {
1734 "SliceBool": [],
1735 "SliceString": [],
1736 "SliceBytes": [],
1737 "SliceInt": [],
1738 "SliceUint": [],
1739 "SliceFloat": []
1740 },
1741 "Slice": [],
1742 "Array": [
1743 " "
1744 ],
1745 "Pointer": {},
1746 "Interface": null
1747 }`,
1748 }, {
1749 name: jsontest.Name("Structs/OmitZeroOption/NonZero"),
1750 opts: []Options{OmitZeroStructFields(true), jsontext.Multiline(true)},
1751 in: structAll{
1752 Bool: true,
1753 String: " ",
1754 Bytes: []byte{},
1755 Int: 1,
1756 Uint: 1,
1757 Float: math.SmallestNonzeroFloat64,
1758 Map: map[string]string{},
1759 StructScalars: structScalars{unexported: true},
1760 StructSlices: structSlices{Ignored: true},
1761 StructMaps: structMaps{MapBool: map[string]bool{}},
1762 Slice: []string{},
1763 Array: [1]string{" "},
1764 Pointer: new(structAll),
1765 Interface: (*structAll)(nil),
1766 },
1767 want: `{
1768 "Bool": true,
1769 "String": " ",
1770 "Bytes": "",
1771 "Int": 1,
1772 "Uint": 1,
1773 "Float": 5e-324,
1774 "Map": {},
1775 "StructScalars": {},
1776 "StructMaps": {
1777 "MapBool": {}
1778 },
1779 "StructSlices": {},
1780 "Slice": [],
1781 "Array": [
1782 " "
1783 ],
1784 "Pointer": {},
1785 "Interface": null
1786 }`,
1787 }, {
1788 name: jsontest.Name("Structs/OmitZeroMethod/Zero"),
1789 in: structOmitZeroMethodAll{},
1790 want: `{"ValueNeverZero":"","PointerNeverZero":""}`,
1791 }, {
1792 name: jsontest.Name("Structs/OmitZeroMethod/NonZero"),
1793 opts: []Options{jsontext.Multiline(true)},
1794 in: structOmitZeroMethodAll{
1795 ValueAlwaysZero: valueAlwaysZero("nonzero"),
1796 ValueNeverZero: valueNeverZero("nonzero"),
1797 PointerAlwaysZero: pointerAlwaysZero("nonzero"),
1798 PointerNeverZero: pointerNeverZero("nonzero"),
1799 PointerValueAlwaysZero: addr(valueAlwaysZero("nonzero")),
1800 PointerValueNeverZero: addr(valueNeverZero("nonzero")),
1801 PointerPointerAlwaysZero: addr(pointerAlwaysZero("nonzero")),
1802 PointerPointerNeverZero: addr(pointerNeverZero("nonzero")),
1803 PointerPointerValueAlwaysZero: addr(addr(valueAlwaysZero("nonzero"))),
1804 PointerPointerValueNeverZero: addr(addr(valueNeverZero("nonzero"))),
1805 PointerPointerPointerAlwaysZero: addr(addr(pointerAlwaysZero("nonzero"))),
1806 PointerPointerPointerNeverZero: addr(addr(pointerNeverZero("nonzero"))),
1807 },
1808 want: `{
1809 "ValueNeverZero": "nonzero",
1810 "PointerNeverZero": "nonzero",
1811 "PointerValueNeverZero": "nonzero",
1812 "PointerPointerNeverZero": "nonzero",
1813 "PointerPointerValueAlwaysZero": "nonzero",
1814 "PointerPointerValueNeverZero": "nonzero",
1815 "PointerPointerPointerAlwaysZero": "nonzero",
1816 "PointerPointerPointerNeverZero": "nonzero"
1817 }`,
1818 }, {
1819 name: jsontest.Name("Structs/OmitZeroMethod/Interface/Zero"),
1820 opts: []Options{jsontext.Multiline(true)},
1821 in: structOmitZeroMethodInterfaceAll{},
1822 want: `{}`,
1823 }, {
1824 name: jsontest.Name("Structs/OmitZeroMethod/Interface/PartialZero"),
1825 opts: []Options{jsontext.Multiline(true)},
1826 in: structOmitZeroMethodInterfaceAll{
1827 ValueAlwaysZero: valueAlwaysZero(""),
1828 ValueNeverZero: valueNeverZero(""),
1829 PointerValueAlwaysZero: (*valueAlwaysZero)(nil),
1830 PointerValueNeverZero: (*valueNeverZero)(nil),
1831 PointerPointerAlwaysZero: (*pointerAlwaysZero)(nil),
1832 PointerPointerNeverZero: (*pointerNeverZero)(nil),
1833 },
1834 want: `{
1835 "ValueNeverZero": ""
1836 }`,
1837 }, {
1838 name: jsontest.Name("Structs/OmitZeroMethod/Interface/NonZero"),
1839 opts: []Options{jsontext.Multiline(true)},
1840 in: structOmitZeroMethodInterfaceAll{
1841 ValueAlwaysZero: valueAlwaysZero("nonzero"),
1842 ValueNeverZero: valueNeverZero("nonzero"),
1843 PointerValueAlwaysZero: addr(valueAlwaysZero("nonzero")),
1844 PointerValueNeverZero: addr(valueNeverZero("nonzero")),
1845 PointerPointerAlwaysZero: addr(pointerAlwaysZero("nonzero")),
1846 PointerPointerNeverZero: addr(pointerNeverZero("nonzero")),
1847 },
1848 want: `{
1849 "ValueNeverZero": "nonzero",
1850 "PointerValueNeverZero": "nonzero",
1851 "PointerPointerNeverZero": "nonzero"
1852 }`,
1853 }, {
1854 name: jsontest.Name("Structs/OmitEmpty/Zero"),
1855 opts: []Options{jsontext.Multiline(true)},
1856 in: structOmitEmptyAll{},
1857 want: `{
1858 "Bool": false,
1859 "StringNonEmpty": "value",
1860 "BytesNonEmpty": [
1861 "value"
1862 ],
1863 "Float": 0,
1864 "MapNonEmpty": {
1865 "key": "value"
1866 },
1867 "SliceNonEmpty": [
1868 "value"
1869 ]
1870 }`,
1871 }, {
1872 name: jsontest.Name("Structs/OmitEmpty/EmptyNonZero"),
1873 opts: []Options{jsontext.Multiline(true)},
1874 in: structOmitEmptyAll{
1875 String: string(""),
1876 StringEmpty: stringMarshalEmpty(""),
1877 StringNonEmpty: stringMarshalNonEmpty(""),
1878 PointerString: addr(string("")),
1879 PointerStringEmpty: addr(stringMarshalEmpty("")),
1880 PointerStringNonEmpty: addr(stringMarshalNonEmpty("")),
1881 Bytes: []byte(""),
1882 BytesEmpty: bytesMarshalEmpty([]byte("")),
1883 BytesNonEmpty: bytesMarshalNonEmpty([]byte("")),
1884 PointerBytes: addr([]byte("")),
1885 PointerBytesEmpty: addr(bytesMarshalEmpty([]byte(""))),
1886 PointerBytesNonEmpty: addr(bytesMarshalNonEmpty([]byte(""))),
1887 Map: map[string]string{},
1888 MapEmpty: mapMarshalEmpty{},
1889 MapNonEmpty: mapMarshalNonEmpty{},
1890 PointerMap: addr(map[string]string{}),
1891 PointerMapEmpty: addr(mapMarshalEmpty{}),
1892 PointerMapNonEmpty: addr(mapMarshalNonEmpty{}),
1893 Slice: []string{},
1894 SliceEmpty: sliceMarshalEmpty{},
1895 SliceNonEmpty: sliceMarshalNonEmpty{},
1896 PointerSlice: addr([]string{}),
1897 PointerSliceEmpty: addr(sliceMarshalEmpty{}),
1898 PointerSliceNonEmpty: addr(sliceMarshalNonEmpty{}),
1899 Pointer: &structOmitZeroEmptyAll{},
1900 Interface: []string{},
1901 },
1902 want: `{
1903 "Bool": false,
1904 "StringNonEmpty": "value",
1905 "PointerStringNonEmpty": "value",
1906 "BytesNonEmpty": [
1907 "value"
1908 ],
1909 "PointerBytesNonEmpty": [
1910 "value"
1911 ],
1912 "Float": 0,
1913 "MapNonEmpty": {
1914 "key": "value"
1915 },
1916 "PointerMapNonEmpty": {
1917 "key": "value"
1918 },
1919 "SliceNonEmpty": [
1920 "value"
1921 ],
1922 "PointerSliceNonEmpty": [
1923 "value"
1924 ]
1925 }`,
1926 }, {
1927 name: jsontest.Name("Structs/OmitEmpty/NonEmpty"),
1928 opts: []Options{jsontext.Multiline(true)},
1929 in: structOmitEmptyAll{
1930 Bool: true,
1931 PointerBool: addr(true),
1932 String: string("value"),
1933 StringEmpty: stringMarshalEmpty("value"),
1934 StringNonEmpty: stringMarshalNonEmpty("value"),
1935 PointerString: addr(string("value")),
1936 PointerStringEmpty: addr(stringMarshalEmpty("value")),
1937 PointerStringNonEmpty: addr(stringMarshalNonEmpty("value")),
1938 Bytes: []byte("value"),
1939 BytesEmpty: bytesMarshalEmpty([]byte("value")),
1940 BytesNonEmpty: bytesMarshalNonEmpty([]byte("value")),
1941 PointerBytes: addr([]byte("value")),
1942 PointerBytesEmpty: addr(bytesMarshalEmpty([]byte("value"))),
1943 PointerBytesNonEmpty: addr(bytesMarshalNonEmpty([]byte("value"))),
1944 Float: math.Copysign(0, -1),
1945 PointerFloat: addr(math.Copysign(0, -1)),
1946 Map: map[string]string{"": ""},
1947 MapEmpty: mapMarshalEmpty{"key": "value"},
1948 MapNonEmpty: mapMarshalNonEmpty{"key": "value"},
1949 PointerMap: addr(map[string]string{"": ""}),
1950 PointerMapEmpty: addr(mapMarshalEmpty{"key": "value"}),
1951 PointerMapNonEmpty: addr(mapMarshalNonEmpty{"key": "value"}),
1952 Slice: []string{""},
1953 SliceEmpty: sliceMarshalEmpty{"value"},
1954 SliceNonEmpty: sliceMarshalNonEmpty{"value"},
1955 PointerSlice: addr([]string{""}),
1956 PointerSliceEmpty: addr(sliceMarshalEmpty{"value"}),
1957 PointerSliceNonEmpty: addr(sliceMarshalNonEmpty{"value"}),
1958 Pointer: &structOmitZeroEmptyAll{Float: math.SmallestNonzeroFloat64},
1959 Interface: []string{""},
1960 },
1961 want: `{
1962 "Bool": true,
1963 "PointerBool": true,
1964 "String": "value",
1965 "StringNonEmpty": "value",
1966 "PointerString": "value",
1967 "PointerStringNonEmpty": "value",
1968 "Bytes": "dmFsdWU=",
1969 "BytesNonEmpty": [
1970 "value"
1971 ],
1972 "PointerBytes": "dmFsdWU=",
1973 "PointerBytesNonEmpty": [
1974 "value"
1975 ],
1976 "Float": -0,
1977 "PointerFloat": -0,
1978 "Map": {
1979 "": ""
1980 },
1981 "MapNonEmpty": {
1982 "key": "value"
1983 },
1984 "PointerMap": {
1985 "": ""
1986 },
1987 "PointerMapNonEmpty": {
1988 "key": "value"
1989 },
1990 "Slice": [
1991 ""
1992 ],
1993 "SliceNonEmpty": [
1994 "value"
1995 ],
1996 "PointerSlice": [
1997 ""
1998 ],
1999 "PointerSliceNonEmpty": [
2000 "value"
2001 ],
2002 "Pointer": {
2003 "Float": 5e-324
2004 },
2005 "Interface": [
2006 ""
2007 ]
2008 }`,
2009 }, {
2010 name: jsontest.Name("Structs/OmitEmpty/Legacy/Zero"),
2011 opts: []Options{jsonflags.OmitEmptyWithLegacySemantics | 1},
2012 in: structOmitEmptyAll{},
2013 want: `{}`,
2014 }, {
2015 name: jsontest.Name("Structs/OmitEmpty/Legacy/NonEmpty"),
2016 opts: []Options{jsontext.Multiline(true), jsonflags.OmitEmptyWithLegacySemantics | 1},
2017 in: structOmitEmptyAll{
2018 Bool: true,
2019 PointerBool: addr(true),
2020 String: string("value"),
2021 StringEmpty: stringMarshalEmpty("value"),
2022 StringNonEmpty: stringMarshalNonEmpty("value"),
2023 PointerString: addr(string("value")),
2024 PointerStringEmpty: addr(stringMarshalEmpty("value")),
2025 PointerStringNonEmpty: addr(stringMarshalNonEmpty("value")),
2026 Bytes: []byte("value"),
2027 BytesEmpty: bytesMarshalEmpty([]byte("value")),
2028 BytesNonEmpty: bytesMarshalNonEmpty([]byte("value")),
2029 PointerBytes: addr([]byte("value")),
2030 PointerBytesEmpty: addr(bytesMarshalEmpty([]byte("value"))),
2031 PointerBytesNonEmpty: addr(bytesMarshalNonEmpty([]byte("value"))),
2032 Float: math.Copysign(0, -1),
2033 PointerFloat: addr(math.Copysign(0, -1)),
2034 Map: map[string]string{"": ""},
2035 MapEmpty: mapMarshalEmpty{"key": "value"},
2036 MapNonEmpty: mapMarshalNonEmpty{"key": "value"},
2037 PointerMap: addr(map[string]string{"": ""}),
2038 PointerMapEmpty: addr(mapMarshalEmpty{"key": "value"}),
2039 PointerMapNonEmpty: addr(mapMarshalNonEmpty{"key": "value"}),
2040 Slice: []string{""},
2041 SliceEmpty: sliceMarshalEmpty{"value"},
2042 SliceNonEmpty: sliceMarshalNonEmpty{"value"},
2043 PointerSlice: addr([]string{""}),
2044 PointerSliceEmpty: addr(sliceMarshalEmpty{"value"}),
2045 PointerSliceNonEmpty: addr(sliceMarshalNonEmpty{"value"}),
2046 Pointer: &structOmitZeroEmptyAll{Float: math.Copysign(0, -1)},
2047 Interface: []string{""},
2048 },
2049 want: `{
2050 "Bool": true,
2051 "PointerBool": true,
2052 "String": "value",
2053 "StringEmpty": "",
2054 "StringNonEmpty": "value",
2055 "PointerString": "value",
2056 "PointerStringEmpty": "",
2057 "PointerStringNonEmpty": "value",
2058 "Bytes": "dmFsdWU=",
2059 "BytesEmpty": [],
2060 "BytesNonEmpty": [
2061 "value"
2062 ],
2063 "PointerBytes": "dmFsdWU=",
2064 "PointerBytesEmpty": [],
2065 "PointerBytesNonEmpty": [
2066 "value"
2067 ],
2068 "PointerFloat": -0,
2069 "Map": {
2070 "": ""
2071 },
2072 "MapEmpty": {},
2073 "MapNonEmpty": {
2074 "key": "value"
2075 },
2076 "PointerMap": {
2077 "": ""
2078 },
2079 "PointerMapEmpty": {},
2080 "PointerMapNonEmpty": {
2081 "key": "value"
2082 },
2083 "Slice": [
2084 ""
2085 ],
2086 "SliceEmpty": [],
2087 "SliceNonEmpty": [
2088 "value"
2089 ],
2090 "PointerSlice": [
2091 ""
2092 ],
2093 "PointerSliceEmpty": [],
2094 "PointerSliceNonEmpty": [
2095 "value"
2096 ],
2097 "Pointer": {},
2098 "Interface": [
2099 ""
2100 ]
2101 }`,
2102 }, {
2103 name: jsontest.Name("Structs/OmitEmpty/NonEmptyString"),
2104 in: struct {
2105 X string `json:",omitempty"`
2106 }{`"`},
2107 want: `{"X":"\""}`,
2108 }, {
2109 name: jsontest.Name("Structs/OmitZeroEmpty/Zero"),
2110 in: structOmitZeroEmptyAll{},
2111 want: `{}`,
2112 }, {
2113 name: jsontest.Name("Structs/OmitZeroEmpty/Empty"),
2114 in: structOmitZeroEmptyAll{
2115 Bytes: []byte{},
2116 Map: map[string]string{},
2117 Slice: []string{},
2118 Pointer: &structOmitZeroEmptyAll{},
2119 Interface: []string{},
2120 },
2121 want: `{}`,
2122 }, {
2123 name: jsontest.Name("Structs/OmitEmpty/PathologicalDepth"),
2124 in: func() any {
2125 type X struct {
2126 X *X `json:",omitempty"`
2127 }
2128 var make func(int) *X
2129 make = func(n int) *X {
2130 if n == 0 {
2131 return nil
2132 }
2133 return &X{make(n - 1)}
2134 }
2135 return make(100)
2136 }(),
2137 want: `{}`,
2138 useWriter: true,
2139 }, {
2140 name: jsontest.Name("Structs/OmitEmpty/PathologicalBreadth"),
2141 in: func() any {
2142 var fields []reflect.StructField
2143 for i := range 100 {
2144 fields = append(fields, reflect.StructField{
2145 Name: fmt.Sprintf("X%d", i),
2146 Type: T[stringMarshalEmpty](),
2147 Tag: `json:",omitempty"`,
2148 })
2149 }
2150 return reflect.New(reflect.StructOf(fields)).Interface()
2151 }(),
2152 want: `{}`,
2153 useWriter: true,
2154 }, {
2155 name: jsontest.Name("Structs/OmitEmpty/PathologicalTree"),
2156 in: func() any {
2157 type X struct {
2158 XL, XR *X `json:",omitempty"`
2159 }
2160 var make func(int) *X
2161 make = func(n int) *X {
2162 if n == 0 {
2163 return nil
2164 }
2165 return &X{make(n - 1), make(n - 1)}
2166 }
2167 return make(8)
2168 }(),
2169 want: `{}`,
2170 useWriter: true,
2171 }, {
2172 name: jsontest.Name("Structs/OmitZeroEmpty/NonEmpty"),
2173 in: structOmitZeroEmptyAll{
2174 Bytes: []byte("value"),
2175 Map: map[string]string{"": ""},
2176 Slice: []string{""},
2177 Pointer: &structOmitZeroEmptyAll{Bool: true},
2178 Interface: []string{""},
2179 },
2180 want: `{"Bytes":"dmFsdWU=","Map":{"":""},"Slice":[""],"Pointer":{"Bool":true},"Interface":[""]}`,
2181 }, {
2182 name: jsontest.Name("Structs/Format/Bytes/Unsupported"),
2183 opts: []Options{jsontext.Multiline(true)},
2184 in: structFormatBytes{},
2185 wantErr: EM(errors.New("Go struct field Base16 has unsupported `format` tag option")).withType(0, T[structFormatBytes]()),
2186 }, {
2187 name: jsontest.Name("Structs/Format/Bytes"),
2188 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true), jsontext.Multiline(true)},
2189 in: structFormatBytes{
2190 Base16: []byte("\x01\x23\x45\x67\x89\xab\xcd\xef"),
2191 Base32: []byte("\x00D2\x14\xc7BT\xb65τe:V\xd7\xc6u\xbew\xdf"),
2192 Base32Hex: []byte("\x00D2\x14\xc7BT\xb65τe:V\xd7\xc6u\xbew\xdf"),
2193 Base64: []byte("\x00\x10\x83\x10Q\x87 \x92\x8b0ӏA\x14\x93QU\x97a\x96\x9bqן\x82\x18\xa3\x92Y\xa7\xa2\x9a\xab\xb2ۯ\xc3\x1c\xb3\xd3]\xb7㞻\xf3߿"),
2194 Base64URL: []byte("\x00\x10\x83\x10Q\x87 \x92\x8b0ӏA\x14\x93QU\x97a\x96\x9bqן\x82\x18\xa3\x92Y\xa7\xa2\x9a\xab\xb2ۯ\xc3\x1c\xb3\xd3]\xb7㞻\xf3߿"),
2195 Array: []byte{1, 2, 3, 4},
2196 },
2197 want: `{
2198 "Base16": "0123456789abcdef",
2199 "Base32": "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
2200 "Base32Hex": "0123456789ABCDEFGHIJKLMNOPQRSTUV",
2201 "Base64": "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
2202 "Base64URL": "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
2203 "Array": [
2204 1,
2205 2,
2206 3,
2207 4
2208 ]
2209 }`,
2210 }, {
2211 name: jsontest.Name("Structs/Format/ArrayBytes"),
2212 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true), jsontext.Multiline(true)},
2213 in: structFormatArrayBytes{
2214 Base16: [4]byte{1, 2, 3, 4},
2215 Base32: [4]byte{1, 2, 3, 4},
2216 Base32Hex: [4]byte{1, 2, 3, 4},
2217 Base64: [4]byte{1, 2, 3, 4},
2218 Base64URL: [4]byte{1, 2, 3, 4},
2219 Array: [4]byte{1, 2, 3, 4},
2220 Default: [4]byte{1, 2, 3, 4},
2221 },
2222 want: `{
2223 "Base16": "01020304",
2224 "Base32": "AEBAGBA=",
2225 "Base32Hex": "0410610=",
2226 "Base64": "AQIDBA==",
2227 "Base64URL": "AQIDBA==",
2228 "Array": [
2229 1,
2230 2,
2231 3,
2232 4
2233 ],
2234 "Default": "AQIDBA=="
2235 }`,
2236 }, {
2237 name: jsontest.Name("Structs/Format/ArrayBytes/Legacy"),
2238 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true), jsontext.Multiline(true), jsonflags.FormatByteArrayAsArray | jsonflags.FormatBytesWithLegacySemantics | 1},
2239 in: structFormatArrayBytes{
2240 Base16: [4]byte{1, 2, 3, 4},
2241 Base32: [4]byte{1, 2, 3, 4},
2242 Base32Hex: [4]byte{1, 2, 3, 4},
2243 Base64: [4]byte{1, 2, 3, 4},
2244 Base64URL: [4]byte{1, 2, 3, 4},
2245 Array: [4]byte{1, 2, 3, 4},
2246 Default: [4]byte{1, 2, 3, 4},
2247 },
2248 want: `{
2249 "Base16": "01020304",
2250 "Base32": "AEBAGBA=",
2251 "Base32Hex": "0410610=",
2252 "Base64": "AQIDBA==",
2253 "Base64URL": "AQIDBA==",
2254 "Array": [
2255 1,
2256 2,
2257 3,
2258 4
2259 ],
2260 "Default": [
2261 1,
2262 2,
2263 3,
2264 4
2265 ]
2266 }`,
2267 }, {
2268 name: jsontest.Name("Structs/Format/Bytes/Array"),
2269 opts: []Options{
2270 jsonopts.ExperimentalSupportFormatTag(true),
2271 WithMarshalers(MarshalFunc(func(in byte) ([]byte, error) {
2272 if in > 3 {
2273 return []byte("true"), nil
2274 } else {
2275 return []byte("false"), nil
2276 }
2277 })),
2278 },
2279 in: struct {
2280 Array []byte `json:",format:array"`
2281 }{
2282 Array: []byte{1, 6, 2, 5, 3, 4},
2283 },
2284 want: `{"Array":[false,true,false,true,false,true]}`,
2285 }, {
2286 name: jsontest.Name("Structs/Format/Floats"),
2287 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true), jsontext.Multiline(true)},
2288 in: []structFormatFloats{
2289 {NonFinite: math.Pi, PointerNonFinite: addr(math.Pi)},
2290 {NonFinite: math.NaN(), PointerNonFinite: addr(math.NaN())},
2291 {NonFinite: math.Inf(-1), PointerNonFinite: addr(math.Inf(-1))},
2292 {NonFinite: math.Inf(+1), PointerNonFinite: addr(math.Inf(+1))},
2293 },
2294 want: `[
2295 {
2296 "NonFinite": 3.141592653589793,
2297 "PointerNonFinite": 3.141592653589793
2298 },
2299 {
2300 "NonFinite": "NaN",
2301 "PointerNonFinite": "NaN"
2302 },
2303 {
2304 "NonFinite": "-Infinity",
2305 "PointerNonFinite": "-Infinity"
2306 },
2307 {
2308 "NonFinite": "Infinity",
2309 "PointerNonFinite": "Infinity"
2310 }
2311 ]`,
2312 }, {
2313 name: jsontest.Name("Structs/Format/Maps"),
2314 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true), jsontext.Multiline(true)},
2315 in: []structFormatMaps{{
2316 EmitNull: map[string]string(nil), PointerEmitNull: addr(map[string]string(nil)),
2317 EmitEmpty: map[string]string(nil), PointerEmitEmpty: addr(map[string]string(nil)),
2318 EmitDefault: map[string]string(nil), PointerEmitDefault: addr(map[string]string(nil)),
2319 }, {
2320 EmitNull: map[string]string{}, PointerEmitNull: addr(map[string]string{}),
2321 EmitEmpty: map[string]string{}, PointerEmitEmpty: addr(map[string]string{}),
2322 EmitDefault: map[string]string{}, PointerEmitDefault: addr(map[string]string{}),
2323 }, {
2324 EmitNull: map[string]string{"k": "v"}, PointerEmitNull: addr(map[string]string{"k": "v"}),
2325 EmitEmpty: map[string]string{"k": "v"}, PointerEmitEmpty: addr(map[string]string{"k": "v"}),
2326 EmitDefault: map[string]string{"k": "v"}, PointerEmitDefault: addr(map[string]string{"k": "v"}),
2327 }},
2328 want: `[
2329 {
2330 "EmitNull": null,
2331 "PointerEmitNull": null,
2332 "EmitEmpty": {},
2333 "PointerEmitEmpty": {},
2334 "EmitDefault": {},
2335 "PointerEmitDefault": {}
2336 },
2337 {
2338 "EmitNull": {},
2339 "PointerEmitNull": {},
2340 "EmitEmpty": {},
2341 "PointerEmitEmpty": {},
2342 "EmitDefault": {},
2343 "PointerEmitDefault": {}
2344 },
2345 {
2346 "EmitNull": {
2347 "k": "v"
2348 },
2349 "PointerEmitNull": {
2350 "k": "v"
2351 },
2352 "EmitEmpty": {
2353 "k": "v"
2354 },
2355 "PointerEmitEmpty": {
2356 "k": "v"
2357 },
2358 "EmitDefault": {
2359 "k": "v"
2360 },
2361 "PointerEmitDefault": {
2362 "k": "v"
2363 }
2364 }
2365 ]`,
2366 }, {
2367 name: jsontest.Name("Structs/Format/Maps/FormatNilMapAsNull"),
2368 opts: []Options{
2369 jsonopts.ExperimentalSupportFormatTag(true),
2370 FormatNilMapAsNull(true),
2371 jsontext.Multiline(true),
2372 },
2373 in: []structFormatMaps{{
2374 EmitNull: map[string]string(nil), PointerEmitNull: addr(map[string]string(nil)),
2375 EmitEmpty: map[string]string(nil), PointerEmitEmpty: addr(map[string]string(nil)),
2376 EmitDefault: map[string]string(nil), PointerEmitDefault: addr(map[string]string(nil)),
2377 }, {
2378 EmitNull: map[string]string{}, PointerEmitNull: addr(map[string]string{}),
2379 EmitEmpty: map[string]string{}, PointerEmitEmpty: addr(map[string]string{}),
2380 EmitDefault: map[string]string{}, PointerEmitDefault: addr(map[string]string{}),
2381 }, {
2382 EmitNull: map[string]string{"k": "v"}, PointerEmitNull: addr(map[string]string{"k": "v"}),
2383 EmitEmpty: map[string]string{"k": "v"}, PointerEmitEmpty: addr(map[string]string{"k": "v"}),
2384 EmitDefault: map[string]string{"k": "v"}, PointerEmitDefault: addr(map[string]string{"k": "v"}),
2385 }},
2386 want: `[
2387 {
2388 "EmitNull": null,
2389 "PointerEmitNull": null,
2390 "EmitEmpty": {},
2391 "PointerEmitEmpty": {},
2392 "EmitDefault": null,
2393 "PointerEmitDefault": null
2394 },
2395 {
2396 "EmitNull": {},
2397 "PointerEmitNull": {},
2398 "EmitEmpty": {},
2399 "PointerEmitEmpty": {},
2400 "EmitDefault": {},
2401 "PointerEmitDefault": {}
2402 },
2403 {
2404 "EmitNull": {
2405 "k": "v"
2406 },
2407 "PointerEmitNull": {
2408 "k": "v"
2409 },
2410 "EmitEmpty": {
2411 "k": "v"
2412 },
2413 "PointerEmitEmpty": {
2414 "k": "v"
2415 },
2416 "EmitDefault": {
2417 "k": "v"
2418 },
2419 "PointerEmitDefault": {
2420 "k": "v"
2421 }
2422 }
2423 ]`,
2424 }, {
2425 name: jsontest.Name("Structs/Format/Slices"),
2426 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true), jsontext.Multiline(true)},
2427 in: []structFormatSlices{{
2428 EmitNull: []string(nil), PointerEmitNull: addr([]string(nil)),
2429 EmitEmpty: []string(nil), PointerEmitEmpty: addr([]string(nil)),
2430 EmitDefault: []string(nil), PointerEmitDefault: addr([]string(nil)),
2431 }, {
2432 EmitNull: []string{}, PointerEmitNull: addr([]string{}),
2433 EmitEmpty: []string{}, PointerEmitEmpty: addr([]string{}),
2434 EmitDefault: []string{}, PointerEmitDefault: addr([]string{}),
2435 }, {
2436 EmitNull: []string{"v"}, PointerEmitNull: addr([]string{"v"}),
2437 EmitEmpty: []string{"v"}, PointerEmitEmpty: addr([]string{"v"}),
2438 EmitDefault: []string{"v"}, PointerEmitDefault: addr([]string{"v"}),
2439 }},
2440 want: `[
2441 {
2442 "EmitNull": null,
2443 "PointerEmitNull": null,
2444 "EmitEmpty": [],
2445 "PointerEmitEmpty": [],
2446 "EmitDefault": [],
2447 "PointerEmitDefault": []
2448 },
2449 {
2450 "EmitNull": [],
2451 "PointerEmitNull": [],
2452 "EmitEmpty": [],
2453 "PointerEmitEmpty": [],
2454 "EmitDefault": [],
2455 "PointerEmitDefault": []
2456 },
2457 {
2458 "EmitNull": [
2459 "v"
2460 ],
2461 "PointerEmitNull": [
2462 "v"
2463 ],
2464 "EmitEmpty": [
2465 "v"
2466 ],
2467 "PointerEmitEmpty": [
2468 "v"
2469 ],
2470 "EmitDefault": [
2471 "v"
2472 ],
2473 "PointerEmitDefault": [
2474 "v"
2475 ]
2476 }
2477 ]`,
2478 }, {
2479 name: jsontest.Name("Structs/Format/Invalid/Bool"),
2480 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
2481 in: structFormatInvalid{Bool: true},
2482 want: `{"Bool"`,
2483 wantErr: EM(errInvalidFormatFlag).withPos(`{"Bool":`, "/Bool").withType(0, boolType),
2484 }, {
2485 name: jsontest.Name("Structs/Format/Invalid/String"),
2486 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
2487 in: structFormatInvalid{String: "string"},
2488 want: `{"String"`,
2489 wantErr: EM(errInvalidFormatFlag).withPos(`{"String":`, "/String").withType(0, stringType),
2490 }, {
2491 name: jsontest.Name("Structs/Format/Invalid/Bytes"),
2492 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
2493 in: structFormatInvalid{Bytes: []byte("bytes")},
2494 want: `{"Bytes"`,
2495 wantErr: EM(errInvalidFormatFlag).withPos(`{"Bytes":`, "/Bytes").withType(0, bytesType),
2496 }, {
2497 name: jsontest.Name("Structs/Format/Invalid/Int"),
2498 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
2499 in: structFormatInvalid{Int: 1},
2500 want: `{"Int"`,
2501 wantErr: EM(errInvalidFormatFlag).withPos(`{"Int":`, "/Int").withType(0, T[int64]()),
2502 }, {
2503 name: jsontest.Name("Structs/Format/Invalid/Uint"),
2504 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
2505 in: structFormatInvalid{Uint: 1},
2506 want: `{"Uint"`,
2507 wantErr: EM(errInvalidFormatFlag).withPos(`{"Uint":`, "/Uint").withType(0, T[uint64]()),
2508 }, {
2509 name: jsontest.Name("Structs/Format/Invalid/Float"),
2510 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
2511 in: structFormatInvalid{Float: 1},
2512 want: `{"Float"`,
2513 wantErr: EM(errInvalidFormatFlag).withPos(`{"Float":`, "/Float").withType(0, T[float64]()),
2514 }, {
2515 name: jsontest.Name("Structs/Format/Invalid/Map"),
2516 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
2517 in: structFormatInvalid{Map: map[string]string{}},
2518 want: `{"Map"`,
2519 wantErr: EM(errInvalidFormatFlag).withPos(`{"Map":`, "/Map").withType(0, T[map[string]string]()),
2520 }, {
2521 name: jsontest.Name("Structs/Format/Invalid/Struct"),
2522 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
2523 in: structFormatInvalid{Struct: structAll{Bool: true}},
2524 want: `{"Struct"`,
2525 wantErr: EM(errInvalidFormatFlag).withPos(`{"Struct":`, "/Struct").withType(0, T[structAll]()),
2526 }, {
2527 name: jsontest.Name("Structs/Format/Invalid/Slice"),
2528 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
2529 in: structFormatInvalid{Slice: []string{}},
2530 want: `{"Slice"`,
2531 wantErr: EM(errInvalidFormatFlag).withPos(`{"Slice":`, "/Slice").withType(0, T[[]string]()),
2532 }, {
2533 name: jsontest.Name("Structs/Format/Invalid/Array"),
2534 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
2535 in: structFormatInvalid{Array: [1]string{"string"}},
2536 want: `{"Array"`,
2537 wantErr: EM(errInvalidFormatFlag).withPos(`{"Array":`, "/Array").withType(0, T[[1]string]()),
2538 }, {
2539 name: jsontest.Name("Structs/Format/Invalid/Interface"),
2540 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
2541 in: structFormatInvalid{Interface: "anything"},
2542 want: `{"Interface"`,
2543 wantErr: EM(errInvalidFormatFlag).withPos(`{"Interface":`, "/Interface").withType(0, T[any]()),
2544 }, {
2545 name: jsontest.Name("Structs/Embed/Zero"),
2546 in: structEmbedded{},
2547 want: `{"D":""}`,
2548 }, {
2549 name: jsontest.Name("Structs/Embed/Alloc"),
2550 in: structEmbedded{
2551 X: structEmbeddedL1{
2552 X: &structEmbeddedL2{},
2553 StructEmbed1: StructEmbed1{},
2554 },
2555 StructEmbed2: &StructEmbed2{},
2556 },
2557 want: `{"A":"","B":"","D":"","E":"","F":"","G":""}`,
2558 }, {
2559 name: jsontest.Name("Structs/Embed/NonZero"),
2560 in: structEmbedded{
2561 X: structEmbeddedL1{
2562 X: &structEmbeddedL2{A: "A1", B: "B1", C: "C1"},
2563 StructEmbed1: StructEmbed1{C: "C2", D: "D2", E: "E2"},
2564 },
2565 StructEmbed2: &StructEmbed2{E: "E3", F: "F3", G: "G3"},
2566 },
2567 want: `{"A":"A1","B":"B1","D":"D2","E":"E3","F":"F3","G":"G3"}`,
2568 }, {
2569 name: jsontest.Name("Structs/Embed/DualCycle"),
2570 in: cyclicA{
2571 B1: cyclicB{F: 1},
2572 B2: cyclicB{F: 2},
2573 },
2574 want: `{}`,
2575 }, {
2576 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/Nil"),
2577 in: structEmbedTextValue{X: jsontext.Value(nil)},
2578 want: `{}`,
2579 }, {
2580 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/Empty"),
2581 in: structEmbedTextValue{X: jsontext.Value("")},
2582 want: `{}`,
2583 }, {
2584 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/NonEmptyN1"),
2585 in: structEmbedTextValue{X: jsontext.Value(` { "fizz" : "buzz" } `)},
2586 want: `{"fizz":"buzz"}`,
2587 }, {
2588 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/NonEmptyN2"),
2589 in: structEmbedTextValue{X: jsontext.Value(` { "fizz" : "buzz" , "foo" : "bar" } `)},
2590 want: `{"fizz":"buzz","foo":"bar"}`,
2591 }, {
2592 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/NonEmptyWithOthers"),
2593 in: structEmbedTextValue{
2594 A: 1,
2595 X: jsontext.Value(` { "fizz" : "buzz" , "foo" : "bar" } `),
2596 B: 2,
2597 },
2598
2599 want: `{"A":1,"B":2,"fizz":"buzz","foo":"bar"}`,
2600 }, {
2601 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/RejectDuplicateNames"),
2602 opts: []Options{jsontext.AllowDuplicateNames(false)},
2603 in: structEmbedTextValue{X: jsontext.Value(` { "fizz" : "buzz" , "fizz" : "buzz" } `)},
2604 want: `{"fizz":"buzz"`,
2605 wantErr: newDuplicateNameError("/fizz", nil, len64(`{"fizz":"buzz"`)),
2606 }, {
2607 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/AllowDuplicateNames"),
2608 opts: []Options{jsontext.AllowDuplicateNames(true)},
2609 in: structEmbedTextValue{X: jsontext.Value(` { "fizz" : "buzz" , "fizz" : "buzz" } `)},
2610 want: `{"fizz":"buzz","fizz":"buzz"}`,
2611 }, {
2612 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/RejectInvalidUTF8"),
2613 opts: []Options{jsontext.AllowInvalidUTF8(false)},
2614 in: structEmbedTextValue{X: jsontext.Value(`{"` + "\xde\xad\xbe\xef" + `":"value"}`)},
2615 want: `{`,
2616 wantErr: newInvalidUTF8Error(len64(`{"`+"\xde\xad"), ""),
2617 }, {
2618 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/AllowInvalidUTF8"),
2619 opts: []Options{jsontext.AllowInvalidUTF8(true)},
2620 in: structEmbedTextValue{X: jsontext.Value(`{"` + "\xde\xad\xbe\xef" + `":"value"}`)},
2621 want: `{"ޭ��":"value"}`,
2622 }, {
2623 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/InvalidWhitespace"),
2624 in: structEmbedTextValue{X: jsontext.Value("\n\r\t ")},
2625 want: `{`,
2626 wantErr: EM(io.ErrUnexpectedEOF).withPos(`{`, "").withType(0, T[jsontext.Value]()),
2627 }, {
2628 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/InvalidObject"),
2629 in: structEmbedTextValue{X: jsontext.Value(` true `)},
2630 want: `{`,
2631 wantErr: EM(errRawEmbedNotObject).withPos(`{`, "").withType(0, T[jsontext.Value]()),
2632 }, {
2633 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/InvalidObjectName"),
2634 in: structEmbedTextValue{X: jsontext.Value(` { true : false } `)},
2635 want: `{`,
2636 wantErr: EM(newNonStringNameError(len64(" { "), "")).withPos(`{`, "").withType(0, T[jsontext.Value]()),
2637 }, {
2638 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/InvalidEndObject"),
2639 in: structEmbedTextValue{X: jsontext.Value(` { "name" : false , } `)},
2640 want: `{"name":false`,
2641 wantErr: EM(newInvalidCharacterError(",", "at start of value", len64(` { "name" : false `), "")).withPos(`{"name":false,`, "").withType(0, T[jsontext.Value]()),
2642 }, {
2643 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/InvalidDualObject"),
2644 in: structEmbedTextValue{X: jsontext.Value(`{}{}`)},
2645 want: `{`,
2646 wantErr: EM(newInvalidCharacterError("{", "after top-level value", len64(`{}`), "")).withPos(`{`, "").withType(0, T[jsontext.Value]()),
2647 }, {
2648 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/Nested/Nil"),
2649 in: structEmbedPointerEmbedTextValue{},
2650 want: `{}`,
2651 }, {
2652 name: jsontest.Name("Structs/EmbeddedFallback/PointerTextValue/Nil"),
2653 in: structEmbedPointerTextValue{},
2654 want: `{}`,
2655 }, {
2656 name: jsontest.Name("Structs/EmbeddedFallback/PointerTextValue/NonEmpty"),
2657 in: structEmbedPointerTextValue{X: addr(jsontext.Value(` { "fizz" : "buzz" } `))},
2658 want: `{"fizz":"buzz"}`,
2659 }, {
2660 name: jsontest.Name("Structs/EmbeddedFallback/PointerTextValue/Nested/Nil"),
2661 in: structEmbedEmbedPointerTextValue{},
2662 want: `{}`,
2663 }, {
2664 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/Nil"),
2665 in: structEmbedMapStringAny{X: nil},
2666 want: `{}`,
2667 }, {
2668 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/Empty"),
2669 in: structEmbedMapStringAny{X: make(jsonObject)},
2670 want: `{}`,
2671 }, {
2672 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/NonEmptyN1"),
2673 in: structEmbedMapStringAny{X: jsonObject{"fizz": nil}},
2674 want: `{"fizz":null}`,
2675 }, {
2676 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/NonEmptyN2"),
2677 in: structEmbedMapStringAny{X: jsonObject{"fizz": time.Time{}, "buzz": math.Pi}},
2678 want: `{"buzz":3.141592653589793,"fizz":"0001-01-01T00:00:00Z"}`,
2679 canonicalize: true,
2680 }, {
2681 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/NonEmptyWithOthers"),
2682 in: structEmbedMapStringAny{
2683 A: 1,
2684 X: jsonObject{"fizz": nil},
2685 B: 2,
2686 },
2687
2688 want: `{"A":1,"B":2,"fizz":null}`,
2689 }, {
2690 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/RejectInvalidUTF8"),
2691 opts: []Options{jsontext.AllowInvalidUTF8(false)},
2692 in: structEmbedMapStringAny{X: jsonObject{"\xde\xad\xbe\xef": nil}},
2693 want: `{`,
2694 wantErr: EM(jsonwire.ErrInvalidUTF8).withPos(`{`, "").withType(0, stringType),
2695 }, {
2696 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/AllowInvalidUTF8"),
2697 opts: []Options{jsontext.AllowInvalidUTF8(true)},
2698 in: structEmbedMapStringAny{X: jsonObject{"\xde\xad\xbe\xef": nil}},
2699 want: `{"ޭ��":null}`,
2700 }, {
2701 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/InvalidValue"),
2702 opts: []Options{jsontext.AllowInvalidUTF8(true)},
2703 in: structEmbedMapStringAny{X: jsonObject{"name": make(chan string)}},
2704 want: `{"name"`,
2705 wantErr: EM(nil).withPos(`{"name":`, "/name").withType(0, T[chan string]()),
2706 }, {
2707 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/Nested/Nil"),
2708 in: structEmbedPointerEmbedMapStringAny{},
2709 want: `{}`,
2710 }, {
2711 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/MarshalFunc"),
2712 opts: []Options{
2713 WithMarshalers(MarshalFunc(func(v float64) ([]byte, error) {
2714 return []byte(fmt.Sprintf(`"%v"`, v)), nil
2715 })),
2716 },
2717 in: structEmbedMapStringAny{X: jsonObject{"fizz": 3.14159}},
2718 want: `{"fizz":"3.14159"}`,
2719 }, {
2720 name: jsontest.Name("Structs/EmbeddedFallback/PointerMapStringAny/Nil"),
2721 in: structEmbedPointerMapStringAny{X: nil},
2722 want: `{}`,
2723 }, {
2724 name: jsontest.Name("Structs/EmbeddedFallback/PointerMapStringAny/NonEmpty"),
2725 in: structEmbedPointerMapStringAny{X: addr(jsonObject{"name": "value"})},
2726 want: `{"name":"value"}`,
2727 }, {
2728 name: jsontest.Name("Structs/EmbeddedFallback/PointerMapStringAny/Nested/Nil"),
2729 in: structEmbedEmbedPointerMapStringAny{},
2730 want: `{}`,
2731 }, {
2732 name: jsontest.Name("Structs/EmbeddedFallback/MapStringInt"),
2733 in: structEmbedMapStringInt{
2734 X: map[string]int{"zero": 0, "one": 1, "two": 2},
2735 },
2736 want: `{"one":1,"two":2,"zero":0}`,
2737 canonicalize: true,
2738 }, {
2739 name: jsontest.Name("Structs/EmbeddedFallback/MapStringInt/Deterministic"),
2740 opts: []Options{Deterministic(true)},
2741 in: structEmbedMapStringInt{
2742 X: map[string]int{"zero": 0, "one": 1, "two": 2},
2743 },
2744 want: `{"one":1,"two":2,"zero":0}`,
2745 }, {
2746 name: jsontest.Name("Structs/EmbeddedFallback/MapStringInt/Deterministic+AllowInvalidUTF8+RejectDuplicateNames"),
2747 opts: []Options{Deterministic(true), jsontext.AllowInvalidUTF8(true), jsontext.AllowDuplicateNames(false)},
2748 in: structEmbedMapStringInt{
2749 X: map[string]int{"\xff": 0, "\xfe": 1},
2750 },
2751 want: `{"�":1`,
2752 wantErr: newDuplicateNameError("", []byte(`"�"`), len64(`{"�":1`)),
2753 }, {
2754 name: jsontest.Name("Structs/EmbeddedFallback/MapStringInt/Deterministic+AllowInvalidUTF8+AllowDuplicateNames"),
2755 opts: []Options{Deterministic(true), jsontext.AllowInvalidUTF8(true), jsontext.AllowDuplicateNames(true)},
2756 in: structEmbedMapStringInt{
2757 X: map[string]int{"\xff": 0, "\xfe": 1},
2758 },
2759 want: `{"�":1,"�":0}`,
2760 }, {
2761 name: jsontest.Name("Structs/EmbeddedFallback/MapStringInt/StringifiedNumbers"),
2762 opts: []Options{StringifyNumbers(true)},
2763 in: structEmbedMapStringInt{
2764 X: map[string]int{"zero": 0, "one": 1, "two": 2},
2765 },
2766 want: `{"one":"1","two":"2","zero":"0"}`,
2767 canonicalize: true,
2768 }, {
2769 name: jsontest.Name("Structs/EmbeddedFallback/MapStringInt/MarshalFunc"),
2770 opts: []Options{
2771 WithMarshalers(JoinMarshalers(
2772
2773 MarshalFunc(func(v string) ([]byte, error) {
2774 return []byte(fmt.Sprintf(`"%q"`, strings.ToUpper(v))), nil
2775 }),
2776 MarshalFunc(func(v int) ([]byte, error) {
2777 return []byte(fmt.Sprintf(`"%v"`, v)), nil
2778 }),
2779 )),
2780 },
2781 in: structEmbedMapStringInt{
2782 X: map[string]int{"zero": 0, "one": 1, "two": 2},
2783 },
2784 want: `{"one":"1","two":"2","zero":"0"}`,
2785 canonicalize: true,
2786 }, {
2787 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringInt"),
2788 in: structEmbedMapNamedStringInt{
2789 X: map[namedString]int{"zero": 0, "one": 1, "two": 2},
2790 },
2791 want: `{"one":1,"two":2,"zero":0}`,
2792 canonicalize: true,
2793 }, {
2794 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringInt/Deterministic"),
2795 opts: []Options{Deterministic(true)},
2796 in: structEmbedMapNamedStringInt{
2797 X: map[namedString]int{"zero": 0, "one": 1, "two": 2},
2798 },
2799 want: `{"one":1,"two":2,"zero":0}`,
2800 }, {
2801 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringAny/Nil"),
2802 in: structEmbedMapNamedStringAny{X: nil},
2803 want: `{}`,
2804 }, {
2805 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringAny/Empty"),
2806 in: structEmbedMapNamedStringAny{X: make(map[namedString]any)},
2807 want: `{}`,
2808 }, {
2809 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringAny/NonEmptyN1"),
2810 in: structEmbedMapNamedStringAny{X: map[namedString]any{"fizz": nil}},
2811 want: `{"fizz":null}`,
2812 }, {
2813 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringAny/NonEmptyN2"),
2814 in: structEmbedMapNamedStringAny{X: map[namedString]any{"fizz": time.Time{}, "buzz": math.Pi}},
2815 want: `{"buzz":3.141592653589793,"fizz":"0001-01-01T00:00:00Z"}`,
2816 canonicalize: true,
2817 }, {
2818 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringAny/NonEmptyWithOthers"),
2819 in: structEmbedMapNamedStringAny{
2820 A: 1,
2821 X: map[namedString]any{"fizz": nil},
2822 B: 2,
2823 },
2824
2825 want: `{"A":1,"B":2,"fizz":null}`,
2826 }, {
2827 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringAny/RejectInvalidUTF8"),
2828 opts: []Options{jsontext.AllowInvalidUTF8(false)},
2829 in: structEmbedMapNamedStringAny{X: map[namedString]any{"\xde\xad\xbe\xef": nil}},
2830 want: `{`,
2831 wantErr: EM(jsonwire.ErrInvalidUTF8).withPos(`{`, "").withType(0, T[namedString]()),
2832 }, {
2833 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringAny/AllowInvalidUTF8"),
2834 opts: []Options{jsontext.AllowInvalidUTF8(true)},
2835 in: structEmbedMapNamedStringAny{X: map[namedString]any{"\xde\xad\xbe\xef": nil}},
2836 want: `{"ޭ��":null}`,
2837 }, {
2838 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringAny/InvalidValue"),
2839 opts: []Options{jsontext.AllowInvalidUTF8(true)},
2840 in: structEmbedMapNamedStringAny{X: map[namedString]any{"name": make(chan string)}},
2841 want: `{"name"`,
2842 wantErr: EM(nil).withPos(`{"name":`, "/name").withType(0, T[chan string]()),
2843 }, {
2844 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringAny/MarshalFunc"),
2845 opts: []Options{
2846 WithMarshalers(MarshalFunc(func(v float64) ([]byte, error) {
2847 return []byte(fmt.Sprintf(`"%v"`, v)), nil
2848 })),
2849 },
2850 in: structEmbedMapNamedStringAny{X: map[namedString]any{"fizz": 3.14159}},
2851 want: `{"fizz":"3.14159"}`,
2852 }, {
2853 name: jsontest.Name("Structs/DuplicateName/NoCaseEmbedTextValue/Other"),
2854 in: structNoCaseEmbedTextValue{
2855 X: jsontext.Value(`{"dupe":"","dupe":""}`),
2856 },
2857 want: `{"dupe":""`,
2858 wantErr: newDuplicateNameError("", []byte(`"dupe"`), len64(`{"dupe":""`)),
2859 }, {
2860 name: jsontest.Name("Structs/DuplicateName/NoCaseEmbedTextValue/Other/AllowDuplicateNames"),
2861 opts: []Options{jsontext.AllowDuplicateNames(true)},
2862 in: structNoCaseEmbedTextValue{
2863 X: jsontext.Value(`{"dupe": "", "dupe": ""}`),
2864 },
2865 want: `{"dupe":"","dupe":""}`,
2866 }, {
2867 name: jsontest.Name("Structs/DuplicateName/NoCaseEmbedTextValue/ExactDifferent"),
2868 in: structNoCaseEmbedTextValue{
2869 X: jsontext.Value(`{"Aaa": "", "AaA": "", "AAa": "", "AAA": ""}`),
2870 },
2871 want: `{"Aaa":"","AaA":"","AAa":"","AAA":""}`,
2872 }, {
2873 name: jsontest.Name("Structs/DuplicateName/NoCaseEmbedTextValue/ExactConflict"),
2874 in: structNoCaseEmbedTextValue{
2875 X: jsontext.Value(`{"Aaa": "", "Aaa": ""}`),
2876 },
2877 want: `{"Aaa":""`,
2878 wantErr: newDuplicateNameError("", []byte(`"Aaa"`), len64(`{"Aaa":""`)),
2879 }, {
2880 name: jsontest.Name("Structs/DuplicateName/NoCaseEmbedTextValue/ExactConflict/AllowDuplicateNames"),
2881 opts: []Options{jsontext.AllowDuplicateNames(true)},
2882 in: structNoCaseEmbedTextValue{
2883 X: jsontext.Value(`{"Aaa": "", "Aaa": ""}`),
2884 },
2885 want: `{"Aaa":"","Aaa":""}`,
2886 }, {
2887 name: jsontest.Name("Structs/DuplicateName/NoCaseEmbedTextValue/NoCaseConflict"),
2888 in: structNoCaseEmbedTextValue{
2889 X: jsontext.Value(`{"Aaa": "", "AaA": "", "aaa": ""}`),
2890 },
2891 want: `{"Aaa":"","AaA":""`,
2892 wantErr: newDuplicateNameError("", []byte(`"aaa"`), len64(`{"Aaa":"","AaA":""`)),
2893 }, {
2894 name: jsontest.Name("Structs/DuplicateName/NoCaseEmbedTextValue/NoCaseConflict/AllowDuplicateNames"),
2895 opts: []Options{jsontext.AllowDuplicateNames(true)},
2896 in: structNoCaseEmbedTextValue{
2897 X: jsontext.Value(`{"Aaa": "", "AaA": "", "aaa": ""}`),
2898 },
2899 want: `{"Aaa":"","AaA":"","aaa":""}`,
2900 }, {
2901 name: jsontest.Name("Structs/DuplicateName/NoCaseEmbedTextValue/ExactDifferentWithField"),
2902 in: structNoCaseEmbedTextValue{
2903 AAA: "x",
2904 AaA: "x",
2905 X: jsontext.Value(`{"Aaa": ""}`),
2906 },
2907 want: `{"AAA":"x","AaA":"x","Aaa":""}`,
2908 }, {
2909 name: jsontest.Name("Structs/DuplicateName/NoCaseEmbedTextValue/ExactConflictWithField"),
2910 in: structNoCaseEmbedTextValue{
2911 AAA: "x",
2912 AaA: "x",
2913 X: jsontext.Value(`{"AAA": ""}`),
2914 },
2915 want: `{"AAA":"x","AaA":"x"`,
2916 wantErr: newDuplicateNameError("", []byte(`"AAA"`), len64(`{"AAA":"x","AaA":"x"`)),
2917 }, {
2918 name: jsontest.Name("Structs/DuplicateName/NoCaseEmbedTextValue/NoCaseConflictWithField"),
2919 in: structNoCaseEmbedTextValue{
2920 AAA: "x",
2921 AaA: "x",
2922 X: jsontext.Value(`{"aaa": ""}`),
2923 },
2924 want: `{"AAA":"x","AaA":"x"`,
2925 wantErr: newDuplicateNameError("", []byte(`"aaa"`), len64(`{"AAA":"x","AaA":"x"`)),
2926 }, {
2927 name: jsontest.Name("Structs/DuplicateName/MatchCaseInsensitiveDelimiter"),
2928 in: structNoCaseEmbedTextValue{
2929 AaA: "x",
2930 X: jsontext.Value(`{"aa_a": ""}`),
2931 },
2932 want: `{"AaA":"x"`,
2933 wantErr: newDuplicateNameError("", []byte(`"aa_a"`), len64(`{"AaA":"x"`)),
2934 }, {
2935 name: jsontest.Name("Structs/DuplicateName/MatchCaseSensitiveDelimiter"),
2936 opts: []Options{jsonflags.MatchCaseSensitiveDelimiter | 1},
2937 in: structNoCaseEmbedTextValue{
2938 AaA: "x",
2939 X: jsontext.Value(`{"aa_a": ""}`),
2940 },
2941 want: `{"AaA":"x","aa_a":""}`,
2942 }, {
2943 name: jsontest.Name("Structs/DuplicateName/MatchCaseInsensitiveNames+MatchCaseSensitiveDelimiter"),
2944 opts: []Options{MatchCaseInsensitiveNames(true), jsonflags.MatchCaseSensitiveDelimiter | 1},
2945 in: structNoCaseEmbedTextValue{
2946 AaA: "x",
2947 X: jsontext.Value(`{"aa_a": ""}`),
2948 },
2949 want: `{"AaA":"x","aa_a":""}`,
2950 }, {
2951 name: jsontest.Name("Structs/DuplicateName/MatchCaseInsensitiveNames+MatchCaseSensitiveDelimiter"),
2952 opts: []Options{MatchCaseInsensitiveNames(true), jsonflags.MatchCaseSensitiveDelimiter | 1},
2953 in: structNoCaseEmbedTextValue{
2954 AA_b: "x",
2955 X: jsontext.Value(`{"aa_b": ""}`),
2956 },
2957 want: `{"AA_b":"x"`,
2958 wantErr: newDuplicateNameError("", []byte(`"aa_b"`), len64(`{"AA_b":"x"`)),
2959 }, {
2960 name: jsontest.Name("Structs/DuplicateName/NoCaseEmbedMapStringAny/ExactDifferent"),
2961 in: structNoCaseEmbedMapStringAny{
2962 X: jsonObject{"Aaa": "", "AaA": "", "AAa": "", "AAA": ""},
2963 },
2964 want: `{"AAA":"","AAa":"","AaA":"","Aaa":""}`,
2965 canonicalize: true,
2966 }, {
2967 name: jsontest.Name("Structs/DuplicateName/NoCaseEmbedMapStringAny/ExactDifferentWithField"),
2968 in: structNoCaseEmbedMapStringAny{
2969 AAA: "x",
2970 AaA: "x",
2971 X: jsonObject{"Aaa": ""},
2972 },
2973 want: `{"AAA":"x","AaA":"x","Aaa":""}`,
2974 }, {
2975 name: jsontest.Name("Structs/DuplicateName/NoCaseEmbedMapStringAny/ExactConflictWithField"),
2976 in: structNoCaseEmbedMapStringAny{
2977 AAA: "x",
2978 AaA: "x",
2979 X: jsonObject{"AAA": ""},
2980 },
2981 want: `{"AAA":"x","AaA":"x"`,
2982 wantErr: newDuplicateNameError("", []byte(`"AAA"`), len64(`{"AAA":"x","AaA":"x"`)),
2983 }, {
2984 name: jsontest.Name("Structs/DuplicateName/NoCaseEmbedMapStringAny/NoCaseConflictWithField"),
2985 in: structNoCaseEmbedMapStringAny{
2986 AAA: "x",
2987 AaA: "x",
2988 X: jsonObject{"aaa": ""},
2989 },
2990 want: `{"AAA":"x","AaA":"x"`,
2991 wantErr: newDuplicateNameError("", []byte(`"aaa"`), len64(`{"AAA":"x","AaA":"x"`)),
2992 }, {
2993 name: jsontest.Name("Structs/Invalid/Conflicting"),
2994 in: structConflicting{},
2995 want: ``,
2996 wantErr: EM(errors.New("Go struct fields A and B conflict over JSON object name \"conflict\"")).withType(0, T[structConflicting]()),
2997 }, {
2998 name: jsontest.Name("Structs/Invalid/NoneExported"),
2999 in: structNoneExported{},
3000 want: ``,
3001 wantErr: EM(errNoExportedFields).withType(0, T[structNoneExported]()),
3002 }, {
3003 name: jsontest.Name("Structs/Invalid/MalformedTag"),
3004 in: structMalformedTag{},
3005 want: ``,
3006 wantErr: EM(errors.New("Go struct field Malformed has malformed `json` tag: invalid character '\"' at start of option (expecting Unicode letter)")).withType(0, T[structMalformedTag]()),
3007 }, {
3008 name: jsontest.Name("Structs/Invalid/UnexportedTag"),
3009 in: structUnexportedTag{},
3010 want: ``,
3011 wantErr: EM(errors.New("unexported Go struct field unexported cannot have non-ignored `json:\"name\"` tag")).withType(0, T[structUnexportedTag]()),
3012 }, {
3013 name: jsontest.Name("Structs/Invalid/ExportedEmbedded"),
3014 in: structExportedEmbedded{"hello"},
3015 want: ``,
3016 wantErr: EM(errors.New("embedded Go struct field NamedString of non-struct type must be explicitly given a JSON name")).withType(0, T[structExportedEmbedded]()),
3017 }, {
3018 name: jsontest.Name("Structs/Valid/ExportedEmbedded"),
3019 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
3020 in: structExportedEmbedded{"hello"},
3021 want: `{"NamedString":"hello"}`,
3022 }, {
3023 name: jsontest.Name("Structs/Valid/ExportedEmbeddedTag"),
3024 in: structExportedEmbeddedTag{"hello"},
3025 want: `{"name":"hello"}`,
3026 }, {
3027 name: jsontest.Name("Structs/Invalid/UnexportedEmbedded"),
3028 in: structUnexportedEmbedded{},
3029 want: ``,
3030 wantErr: EM(errors.New("embedded Go struct field namedString of non-struct type must be explicitly given a JSON name")).withType(0, T[structUnexportedEmbedded]()),
3031 }, {
3032 name: jsontest.Name("Structs/Valid/UnexportedEmbedded"),
3033 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
3034 in: structUnexportedEmbedded{},
3035 want: `{}`,
3036 }, {
3037 name: jsontest.Name("Structs/Invalid/UnexportedEmbeddedTag"),
3038 in: structUnexportedEmbeddedTag{},
3039 wantErr: EM(errors.New("Go struct field namedString is not exported")).withType(0, T[structUnexportedEmbeddedTag]()),
3040 }, {
3041 name: jsontest.Name("Structs/Valid/UnexportedEmbeddedTag"),
3042 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
3043 in: structUnexportedEmbeddedTag{},
3044 want: `{}`,
3045 }, {
3046 name: jsontest.Name("Structs/Invalid/UnexportedEmbeddedMethodTag"),
3047 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
3048 in: structUnexportedEmbeddedMethodTag{},
3049 want: `{}`,
3050 }, {
3051 name: jsontest.Name("Structs/UnexportedEmbeddedStruct/Zero"),
3052 in: structUnexportedEmbeddedStruct{},
3053 want: `{"FizzBuzz":0,"Addr":""}`,
3054 }, {
3055 name: jsontest.Name("Structs/UnexportedEmbeddedStruct/NonZero"),
3056 in: structUnexportedEmbeddedStruct{structOmitZeroAll{Bool: true}, 5, structNestedAddr{netip.AddrFrom4([4]byte{192, 168, 0, 1})}},
3057 want: `{"Bool":true,"FizzBuzz":5,"Addr":"192.168.0.1"}`,
3058 }, {
3059 name: jsontest.Name("Structs/UnexportedEmbeddedStructPointer/Nil"),
3060 in: structUnexportedEmbeddedStructPointer{},
3061 want: `{"FizzBuzz":0}`,
3062 }, {
3063 name: jsontest.Name("Structs/UnexportedEmbeddedStructPointer/Zero"),
3064 in: structUnexportedEmbeddedStructPointer{&structOmitZeroAll{}, 0, &structNestedAddr{}},
3065 want: `{"FizzBuzz":0,"Addr":""}`,
3066 }, {
3067 name: jsontest.Name("Structs/UnexportedEmbeddedStructPointer/NonZero"),
3068 in: structUnexportedEmbeddedStructPointer{&structOmitZeroAll{Bool: true}, 5, &structNestedAddr{netip.AddrFrom4([4]byte{192, 168, 0, 1})}},
3069 want: `{"Bool":true,"FizzBuzz":5,"Addr":"192.168.0.1"}`,
3070 }, {
3071 name: jsontest.Name("Structs/IgnoreInvalidFormat"),
3072 opts: []Options{invalidFormatOption},
3073 in: struct{}{},
3074 want: `{}`,
3075 }, {
3076 name: jsontest.Name("Slices/Interface"),
3077 in: []any{
3078 false, true,
3079 "hello", []byte("world"),
3080 int32(-32), namedInt64(-64),
3081 uint32(+32), namedUint64(+64),
3082 float32(32.32), namedFloat64(64.64),
3083 },
3084 want: `[false,true,"hello","d29ybGQ=",-32,-64,32,64,32.32,64.64]`,
3085 }, {
3086 name: jsontest.Name("Slices/Invalid/Channel"),
3087 in: [](chan string){nil},
3088 want: `[`,
3089 wantErr: EM(nil).withPos(`[`, "/0").withType(0, T[chan string]()),
3090 }, {
3091 name: jsontest.Name("Slices/RecursiveSlice"),
3092 in: recursiveSlice{
3093 nil,
3094 {},
3095 {nil},
3096 {nil, {}},
3097 },
3098 want: `[[],[],[[]],[[],[]]]`,
3099 }, {
3100 name: jsontest.Name("Slices/CyclicSlice"),
3101 in: func() recursiveSlice {
3102 s := recursiveSlice{{}}
3103 s[0] = s
3104 return s
3105 }(),
3106 want: strings.Repeat(`[`, startDetectingCyclesAfter) + `[`,
3107 wantErr: EM(internal.ErrCycle).withPos(strings.Repeat("[", startDetectingCyclesAfter+1), jsontext.Pointer(strings.Repeat("/0", startDetectingCyclesAfter+1))).withType(0, T[recursiveSlice]()),
3108 }, {
3109 name: jsontest.Name("Slices/NonCyclicSlice"),
3110 in: func() []any {
3111 v := []any{nil, nil}
3112 v[1] = v[:1]
3113 for i := 1000; i > 0; i-- {
3114 v = []any{v}
3115 }
3116 return v
3117 }(),
3118 want: strings.Repeat(`[`, startDetectingCyclesAfter) + `[null,[null]]` + strings.Repeat(`]`, startDetectingCyclesAfter),
3119 }, {
3120 name: jsontest.Name("Slices/IgnoreInvalidFormat"),
3121 opts: []Options{invalidFormatOption},
3122 in: []string{"hello", "goodbye"},
3123 want: `["hello","goodbye"]`,
3124 }, {
3125 name: jsontest.Name("Arrays/Empty"),
3126 in: [0]struct{}{},
3127 want: `[]`,
3128 }, {
3129 name: jsontest.Name("Arrays/Bool"),
3130 in: [2]bool{false, true},
3131 want: `[false,true]`,
3132 }, {
3133 name: jsontest.Name("Arrays/String"),
3134 in: [2]string{"hello", "goodbye"},
3135 want: `["hello","goodbye"]`,
3136 }, {
3137 name: jsontest.Name("Arrays/Bytes"),
3138 in: [2][]byte{[]byte("hello"), []byte("goodbye")},
3139 want: `["aGVsbG8=","Z29vZGJ5ZQ=="]`,
3140 }, {
3141 name: jsontest.Name("Arrays/Int"),
3142 in: [2]int64{math.MinInt64, math.MaxInt64},
3143 want: `[-9223372036854775808,9223372036854775807]`,
3144 }, {
3145 name: jsontest.Name("Arrays/Uint"),
3146 in: [2]uint64{0, math.MaxUint64},
3147 want: `[0,18446744073709551615]`,
3148 }, {
3149 name: jsontest.Name("Arrays/Float"),
3150 in: [2]float64{-math.MaxFloat64, +math.MaxFloat64},
3151 want: `[-1.7976931348623157e+308,1.7976931348623157e+308]`,
3152 }, {
3153 name: jsontest.Name("Arrays/Invalid/Channel"),
3154 in: new([1]chan string),
3155 want: `[`,
3156 wantErr: EM(nil).withPos(`[`, "/0").withType(0, T[chan string]()),
3157 }, {
3158 name: jsontest.Name("Arrays/IgnoreInvalidFormat"),
3159 opts: []Options{invalidFormatOption},
3160 in: [2]string{"hello", "goodbye"},
3161 want: `["hello","goodbye"]`,
3162 }, {
3163 name: jsontest.Name("Pointers/NilL0"),
3164 in: (*int)(nil),
3165 want: `null`,
3166 }, {
3167 name: jsontest.Name("Pointers/NilL1"),
3168 in: new(*int),
3169 want: `null`,
3170 }, {
3171 name: jsontest.Name("Pointers/Bool"),
3172 in: addr(addr(bool(true))),
3173 want: `true`,
3174 }, {
3175 name: jsontest.Name("Pointers/String"),
3176 in: addr(addr(string("string"))),
3177 want: `"string"`,
3178 }, {
3179 name: jsontest.Name("Pointers/Bytes"),
3180 in: addr(addr([]byte("bytes"))),
3181 want: `"Ynl0ZXM="`,
3182 }, {
3183 name: jsontest.Name("Pointers/Int"),
3184 in: addr(addr(int(-100))),
3185 want: `-100`,
3186 }, {
3187 name: jsontest.Name("Pointers/Uint"),
3188 in: addr(addr(uint(100))),
3189 want: `100`,
3190 }, {
3191 name: jsontest.Name("Pointers/Float"),
3192 in: addr(addr(float64(3.14159))),
3193 want: `3.14159`,
3194 }, {
3195 name: jsontest.Name("Pointers/CyclicPointer"),
3196 in: func() *recursivePointer {
3197 p := new(recursivePointer)
3198 p.P = p
3199 return p
3200 }(),
3201 want: strings.Repeat(`{"P":`, startDetectingCyclesAfter) + `{"P"`,
3202 wantErr: EM(internal.ErrCycle).withPos(strings.Repeat(`{"P":`, startDetectingCyclesAfter+1), jsontext.Pointer(strings.Repeat("/P", startDetectingCyclesAfter+1))).withType(0, T[*recursivePointer]()),
3203 }, {
3204 name: jsontest.Name("Pointers/IgnoreInvalidFormat"),
3205 opts: []Options{invalidFormatOption},
3206 in: addr(addr(bool(true))),
3207 want: `true`,
3208 }, {
3209 name: jsontest.Name("Interfaces/Nil/Empty"),
3210 in: [1]any{nil},
3211 want: `[null]`,
3212 }, {
3213 name: jsontest.Name("Interfaces/Nil/NonEmpty"),
3214 in: [1]io.Reader{nil},
3215 want: `[null]`,
3216 }, {
3217 name: jsontest.Name("Interfaces/IgnoreInvalidFormat"),
3218 opts: []Options{invalidFormatOption},
3219 in: [1]io.Reader{nil},
3220 want: `[null]`,
3221 }, {
3222 name: jsontest.Name("Interfaces/Any"),
3223 in: struct{ X any }{[]any{nil, false, "", 0.0, map[string]any{}, []any{}, [8]byte{}}},
3224 want: `{"X":[null,false,"",0,{},[],"AAAAAAAAAAA="]}`,
3225 }, {
3226 name: jsontest.Name("Interfaces/Any/Named"),
3227 in: struct{ X namedAny }{[]namedAny{nil, false, "", 0.0, map[string]namedAny{}, []namedAny{}, [8]byte{}}},
3228 want: `{"X":[null,false,"",0,{},[],"AAAAAAAAAAA="]}`,
3229 }, {
3230 name: jsontest.Name("Interfaces/Any/Stringified"),
3231 opts: []Options{StringifyNumbers(true)},
3232 in: struct{ X any }{0.0},
3233 want: `{"X":"0"}`,
3234 }, {
3235 name: jsontest.Name("Interfaces/Any/MarshalFunc/Any"),
3236 opts: []Options{
3237 WithMarshalers(MarshalFunc(func(v any) ([]byte, error) {
3238 return []byte(`"called"`), nil
3239 })),
3240 },
3241 in: struct{ X any }{[]any{nil, false, "", 0.0, map[string]any{}, []any{}}},
3242 want: `"called"`,
3243 }, {
3244 name: jsontest.Name("Interfaces/Any/MarshalFunc/Bool"),
3245 opts: []Options{
3246 WithMarshalers(MarshalFunc(func(v bool) ([]byte, error) {
3247 return []byte(`"called"`), nil
3248 })),
3249 },
3250 in: struct{ X any }{[]any{nil, false, "", 0.0, map[string]any{}, []any{}}},
3251 want: `{"X":[null,"called","",0,{},[]]}`,
3252 }, {
3253 name: jsontest.Name("Interfaces/Any/MarshalFunc/String"),
3254 opts: []Options{
3255 WithMarshalers(MarshalFunc(func(v string) ([]byte, error) {
3256 return []byte(`"called"`), nil
3257 })),
3258 },
3259 in: struct{ X any }{[]any{nil, false, "", 0.0, map[string]any{}, []any{}}},
3260 want: `{"X":[null,false,"called",0,{},[]]}`,
3261 }, {
3262 name: jsontest.Name("Interfaces/Any/MarshalFunc/Float64"),
3263 opts: []Options{
3264 WithMarshalers(MarshalFunc(func(v float64) ([]byte, error) {
3265 return []byte(`"called"`), nil
3266 })),
3267 },
3268 in: struct{ X any }{[]any{nil, false, "", 0.0, map[string]any{}, []any{}}},
3269 want: `{"X":[null,false,"","called",{},[]]}`,
3270 }, {
3271 name: jsontest.Name("Interfaces/Any/MarshalFunc/MapStringAny"),
3272 opts: []Options{
3273 WithMarshalers(MarshalFunc(func(v map[string]any) ([]byte, error) {
3274 return []byte(`"called"`), nil
3275 })),
3276 },
3277 in: struct{ X any }{[]any{nil, false, "", 0.0, map[string]any{}, []any{}}},
3278 want: `{"X":[null,false,"",0,"called",[]]}`,
3279 }, {
3280 name: jsontest.Name("Interfaces/Any/MarshalFunc/SliceAny"),
3281 opts: []Options{
3282 WithMarshalers(MarshalFunc(func(v []any) ([]byte, error) {
3283 return []byte(`"called"`), nil
3284 })),
3285 },
3286 in: struct{ X any }{[]any{nil, false, "", 0.0, map[string]any{}, []any{}}},
3287 want: `{"X":"called"}`,
3288 }, {
3289 name: jsontest.Name("Interfaces/Any/MarshalFunc/Bytes"),
3290 opts: []Options{
3291 WithMarshalers(MarshalFunc(func(v [8]byte) ([]byte, error) {
3292 return []byte(`"called"`), nil
3293 })),
3294 },
3295 in: struct{ X any }{[8]byte{}},
3296 want: `{"X":"called"}`,
3297 }, {
3298 name: jsontest.Name("Interfaces/Any/Float/NaN"),
3299 in: struct{ X any }{math.NaN()},
3300 want: `{"X"`,
3301 wantErr: EM(fmt.Errorf("unsupported value: %v", math.NaN())).withType(0, reflect.TypeFor[float64]()).withPos(`{"X":`, "/X"),
3302 }, {
3303 name: jsontest.Name("Interfaces/Any/Maps/Nil"),
3304 in: struct{ X any }{map[string]any(nil)},
3305 want: `{"X":{}}`,
3306 }, {
3307 name: jsontest.Name("Interfaces/Any/Maps/Nil/FormatNilMapAsNull"),
3308 opts: []Options{FormatNilMapAsNull(true)},
3309 in: struct{ X any }{map[string]any(nil)},
3310 want: `{"X":null}`,
3311 }, {
3312 name: jsontest.Name("Interfaces/Any/Maps/Empty"),
3313 in: struct{ X any }{map[string]any{}},
3314 want: `{"X":{}}`,
3315 }, {
3316 name: jsontest.Name("Interfaces/Any/Maps/Empty/Multiline"),
3317 opts: []Options{jsontext.Multiline(true), jsontext.WithIndent("")},
3318 in: struct{ X any }{map[string]any{}},
3319 want: "{\n\"X\": {}\n}",
3320 }, {
3321 name: jsontest.Name("Interfaces/Any/Maps/NonEmpty"),
3322 in: struct{ X any }{map[string]any{"fizz": "buzz"}},
3323 want: `{"X":{"fizz":"buzz"}}`,
3324 }, {
3325 name: jsontest.Name("Interfaces/Any/Maps/Deterministic"),
3326 opts: []Options{Deterministic(true)},
3327 in: struct{ X any }{map[string]any{"alpha": "", "bravo": ""}},
3328 want: `{"X":{"alpha":"","bravo":""}}`,
3329 }, {
3330 name: jsontest.Name("Interfaces/Any/Maps/Deterministic+AllowInvalidUTF8+RejectDuplicateNames"),
3331 opts: []Options{Deterministic(true), jsontext.AllowInvalidUTF8(true), jsontext.AllowDuplicateNames(false)},
3332 in: struct{ X any }{map[string]any{"\xff": "", "\xfe": ""}},
3333 want: `{"X":{"�":""`,
3334 wantErr: newDuplicateNameError("/X", []byte(`"�"`), len64(`{"X":{"�":"",`)),
3335 }, {
3336 name: jsontest.Name("Interfaces/Any/Maps/Deterministic+AllowInvalidUTF8+AllowDuplicateNames"),
3337 opts: []Options{Deterministic(true), jsontext.AllowInvalidUTF8(true), jsontext.AllowDuplicateNames(true)},
3338 in: struct{ X any }{map[string]any{"\xff": "alpha", "\xfe": "bravo"}},
3339 want: `{"X":{"�":"bravo","�":"alpha"}}`,
3340 }, {
3341 name: jsontest.Name("Interfaces/Any/Maps/RejectInvalidUTF8"),
3342 in: struct{ X any }{map[string]any{"\xff": "", "\xfe": ""}},
3343 want: `{"X":{`,
3344 wantErr: newInvalidUTF8Error(len64(`{"X":{`), "/X"),
3345 }, {
3346 name: jsontest.Name("Interfaces/Any/Maps/AllowInvalidUTF8+RejectDuplicateNames"),
3347 opts: []Options{jsontext.AllowInvalidUTF8(true)},
3348 in: struct{ X any }{map[string]any{"\xff": "", "\xfe": ""}},
3349 want: `{"X":{"�":""`,
3350 wantErr: newDuplicateNameError("/X", []byte(`"�"`), len64(`{"X":{"�":"",`)),
3351 }, {
3352 name: jsontest.Name("Interfaces/Any/Maps/AllowInvalidUTF8+AllowDuplicateNames"),
3353 opts: []Options{jsontext.AllowInvalidUTF8(true), jsontext.AllowDuplicateNames(true)},
3354 in: struct{ X any }{map[string]any{"\xff": "", "\xfe": ""}},
3355 want: `{"X":{"�":"","�":""}}`,
3356 }, {
3357 name: jsontest.Name("Interfaces/Any/Maps/Cyclic"),
3358 in: func() any {
3359 m := map[string]any{}
3360 m[""] = m
3361 return struct{ X any }{m}
3362 }(),
3363 want: `{"X"` + strings.Repeat(`:{""`, startDetectingCyclesAfter),
3364 wantErr: EM(internal.ErrCycle).withPos(`{"X":`+strings.Repeat(`{"":`, startDetectingCyclesAfter), "/X"+jsontext.Pointer(strings.Repeat("/", startDetectingCyclesAfter))).withType(0, T[map[string]any]()),
3365 }, {
3366 name: jsontest.Name("Interfaces/Any/Slices/Nil"),
3367 in: struct{ X any }{[]any(nil)},
3368 want: `{"X":[]}`,
3369 }, {
3370 name: jsontest.Name("Interfaces/Any/Slices/Nil/FormatNilSliceAsNull"),
3371 opts: []Options{FormatNilSliceAsNull(true)},
3372 in: struct{ X any }{[]any(nil)},
3373 want: `{"X":null}`,
3374 }, {
3375 name: jsontest.Name("Interfaces/Any/Slices/Empty"),
3376 in: struct{ X any }{[]any{}},
3377 want: `{"X":[]}`,
3378 }, {
3379 name: jsontest.Name("Interfaces/Any/Slices/Empty/Multiline"),
3380 opts: []Options{jsontext.Multiline(true), jsontext.WithIndent("")},
3381 in: struct{ X any }{[]any{}},
3382 want: "{\n\"X\": []\n}",
3383 }, {
3384 name: jsontest.Name("Interfaces/Any/Slices/NonEmpty"),
3385 in: struct{ X any }{[]any{"fizz", "buzz"}},
3386 want: `{"X":["fizz","buzz"]}`,
3387 }, {
3388 name: jsontest.Name("Interfaces/Any/Slices/Cyclic"),
3389 in: func() any {
3390 s := make([]any, 1)
3391 s[0] = s
3392 return struct{ X any }{s}
3393 }(),
3394 want: `{"X":` + strings.Repeat(`[`, startDetectingCyclesAfter),
3395 wantErr: EM(internal.ErrCycle).withPos(`{"X":`+strings.Repeat(`[`, startDetectingCyclesAfter), "/X"+jsontext.Pointer(strings.Repeat("/0", startDetectingCyclesAfter))).withType(0, T[[]any]()),
3396 }, {
3397 name: jsontest.Name("Methods/NilPointer"),
3398 in: struct{ X *allMethods }{X: (*allMethods)(nil)},
3399 want: `{"X":null}`,
3400 }, {
3401
3402 name: jsontest.Name("Methods/NilInterface"),
3403 in: struct{ X MarshalerTo }{X: (*allMethods)(nil)},
3404 want: `{"X":null}`,
3405 }, {
3406 name: jsontest.Name("Methods/AllMethods"),
3407 in: struct{ X *allMethods }{X: &allMethods{method: "MarshalJSONTo", value: []byte(`"hello"`)}},
3408 want: `{"X":"hello"}`,
3409 }, {
3410 name: jsontest.Name("Methods/AllMethodsExceptJSONv2"),
3411 in: struct{ X *allMethodsExceptJSONv2 }{X: &allMethodsExceptJSONv2{allMethods: allMethods{method: "MarshalJSON", value: []byte(`"hello"`)}}},
3412 want: `{"X":"hello"}`,
3413 }, {
3414 name: jsontest.Name("Methods/AllMethodsExceptJSONv1"),
3415 in: struct{ X *allMethodsExceptJSONv1 }{X: &allMethodsExceptJSONv1{allMethods: allMethods{method: "MarshalJSONTo", value: []byte(`"hello"`)}}},
3416 want: `{"X":"hello"}`,
3417 }, {
3418 name: jsontest.Name("Methods/AllMethodsExceptText"),
3419 in: struct{ X *allMethodsExceptText }{X: &allMethodsExceptText{allMethods: allMethods{method: "MarshalJSONTo", value: []byte(`"hello"`)}}},
3420 want: `{"X":"hello"}`,
3421 }, {
3422 name: jsontest.Name("Methods/OnlyMethodJSONv2"),
3423 in: struct{ X *onlyMethodJSONv2 }{X: &onlyMethodJSONv2{allMethods: allMethods{method: "MarshalJSONTo", value: []byte(`"hello"`)}}},
3424 want: `{"X":"hello"}`,
3425 }, {
3426 name: jsontest.Name("Methods/OnlyMethodJSONv1"),
3427 in: struct{ X *onlyMethodJSONv1 }{X: &onlyMethodJSONv1{allMethods: allMethods{method: "MarshalJSON", value: []byte(`"hello"`)}}},
3428 want: `{"X":"hello"}`,
3429 }, {
3430 name: jsontest.Name("Methods/OnlyMethodText"),
3431 in: struct{ X *onlyMethodText }{X: &onlyMethodText{allMethods: allMethods{method: "MarshalText", value: []byte(`hello`)}}},
3432 want: `{"X":"hello"}`,
3433 }, {
3434 name: jsontest.Name("Methods/IP"),
3435 in: net.IPv4(192, 168, 0, 100),
3436 want: `"192.168.0.100"`,
3437 }, {
3438 name: jsontest.Name("Methods/NetIP"),
3439 in: struct {
3440 Addr netip.Addr
3441 AddrPort netip.AddrPort
3442 Prefix netip.Prefix
3443 }{
3444 Addr: netip.AddrFrom4([4]byte{1, 2, 3, 4}),
3445 AddrPort: netip.AddrPortFrom(netip.AddrFrom4([4]byte{1, 2, 3, 4}), 1234),
3446 Prefix: netip.PrefixFrom(netip.AddrFrom4([4]byte{1, 2, 3, 4}), 24),
3447 },
3448 want: `{"Addr":"1.2.3.4","AddrPort":"1.2.3.4:1234","Prefix":"1.2.3.4/24"}`,
3449 }, {
3450
3451 name: jsontest.Name("Methods/Anonymous"),
3452 in: struct{ X struct{ allMethods } }{X: struct{ allMethods }{allMethods{method: "MarshalJSONTo", value: []byte(`"hello"`)}}},
3453 want: `{"X":"hello"}`,
3454 }, {
3455
3456 name: jsontest.Name("Methods/Addressable"),
3457 in: struct {
3458 V allMethods
3459 M map[string]allMethods
3460 I any
3461 }{
3462 V: allMethods{method: "MarshalJSONTo", value: []byte(`"hello"`)},
3463 M: map[string]allMethods{"K": {method: "MarshalJSONTo", value: []byte(`"hello"`)}},
3464 I: allMethods{method: "MarshalJSONTo", value: []byte(`"hello"`)},
3465 },
3466 want: `{"V":"hello","M":{"K":"hello"},"I":"hello"}`,
3467 }, {
3468
3469 name: jsontest.Name("Methods/MapKey/JSONv2"),
3470 in: map[structMethodJSONv2]string{{"k1"}: "v1", {"k2"}: "v2"},
3471 want: `{"k1":"v1","k2":"v2"}`,
3472 canonicalize: true,
3473 }, {
3474
3475 name: jsontest.Name("Methods/MapKey/JSONv1"),
3476 in: map[structMethodJSONv1]string{{"k1"}: "v1", {"k2"}: "v2"},
3477 want: `{"k1":"v1","k2":"v2"}`,
3478 canonicalize: true,
3479 }, {
3480 name: jsontest.Name("Methods/MapKey/Text"),
3481 in: map[structMethodText]string{{"k1"}: "v1", {"k2"}: "v2"},
3482 want: `{"k1":"v1","k2":"v2"}`,
3483 canonicalize: true,
3484 }, {
3485 name: jsontest.Name("Methods/JSONv2/ErrUnsupported"),
3486 opts: []Options{Deterministic(true)},
3487 in: unsupportedMethodJSONv2{"fizz": 123},
3488 want: `{"called":1,"fizz":123}`,
3489 }, {
3490 name: jsontest.Name("Methods/Invalid/JSONv2/Error"),
3491 in: marshalJSONv2Func(func(*jsontext.Encoder) error {
3492 return errSomeError
3493 }),
3494 wantErr: EM(errSomeError).withType(0, T[marshalJSONv2Func]()),
3495 }, {
3496 name: jsontest.Name("Methods/Invalid/JSONv2/TooFew"),
3497 in: marshalJSONv2Func(func(*jsontext.Encoder) error {
3498 return nil
3499 }),
3500 wantErr: EM(errNonSingularValue).withType(0, T[marshalJSONv2Func]()),
3501 }, {
3502 name: jsontest.Name("Methods/Invalid/JSONv2/TooMany"),
3503 in: marshalJSONv2Func(func(enc *jsontext.Encoder) error {
3504 enc.WriteToken(jsontext.Null)
3505 enc.WriteToken(jsontext.Null)
3506 return nil
3507 }),
3508 want: `nullnull`,
3509 wantErr: EM(errNonSingularValue).withPos(`nullnull`, "").withType(0, T[marshalJSONv2Func]()),
3510 }, {
3511 name: jsontest.Name("Methods/Invalid/JSONv2/ErrUnsupported"),
3512 in: marshalJSONv2Func(func(enc *jsontext.Encoder) error {
3513 return errors.ErrUnsupported
3514 }),
3515 wantErr: EM(nil).withType(0, T[marshalJSONv2Func]()),
3516 }, {
3517 name: jsontest.Name("Methods/Invalid/JSONv1/Error"),
3518 in: marshalJSONv1Func(func() ([]byte, error) {
3519 return nil, errSomeError
3520 }),
3521 wantErr: EM(errSomeError).withType(0, T[marshalJSONv1Func]()),
3522 }, {
3523 name: jsontest.Name("Methods/Invalid/JSONv1/Syntax"),
3524 in: marshalJSONv1Func(func() ([]byte, error) {
3525 return []byte("invalid"), nil
3526 }),
3527 wantErr: EM(newInvalidCharacterError("i", "at start of value", 0, "")).withType(0, T[marshalJSONv1Func]()),
3528 }, {
3529 name: jsontest.Name("Methods/Invalid/JSONv1/ErrUnsupported"),
3530 in: marshalJSONv1Func(func() ([]byte, error) {
3531 return nil, errors.ErrUnsupported
3532 }),
3533 wantErr: EM(errors.New("MarshalJSON method may not return errors.ErrUnsupported")).withType(0, T[marshalJSONv1Func]()),
3534 }, {
3535 name: jsontest.Name("Methods/AppendText"),
3536 in: appendTextFunc(func(b []byte) ([]byte, error) { return append(b, "hello"...), nil }),
3537 want: `"hello"`,
3538 }, {
3539 name: jsontest.Name("Methods/AppendText/Error"),
3540 in: appendTextFunc(func(b []byte) ([]byte, error) { return append(b, "hello"...), errSomeError }),
3541 wantErr: EM(errSomeError).withType(0, T[appendTextFunc]()),
3542 }, {
3543 name: jsontest.Name("Methods/AppendText/NeedEscape"),
3544 in: appendTextFunc(func(b []byte) ([]byte, error) { return append(b, `"`...), nil }),
3545 want: `"\""`,
3546 }, {
3547 name: jsontest.Name("Methods/AppendText/RejectInvalidUTF8"),
3548 in: appendTextFunc(func(b []byte) ([]byte, error) { return append(b, "\xde\xad\xbe\xef"...), nil }),
3549 wantErr: EM(newInvalidUTF8Error(0, "")).withType(0, T[appendTextFunc]()),
3550 }, {
3551 name: jsontest.Name("Methods/AppendText/AllowInvalidUTF8"),
3552 opts: []Options{jsontext.AllowInvalidUTF8(true)},
3553 in: appendTextFunc(func(b []byte) ([]byte, error) { return append(b, "\xde\xad\xbe\xef"...), nil }),
3554 want: "\"\xde\xad\ufffd\ufffd\"",
3555 }, {
3556 name: jsontest.Name("Methods/Invalid/Text/Error"),
3557 in: marshalTextFunc(func() ([]byte, error) {
3558 return nil, errSomeError
3559 }),
3560 wantErr: EM(errSomeError).withType(0, T[marshalTextFunc]()),
3561 }, {
3562 name: jsontest.Name("Methods/Text/RejectInvalidUTF8"),
3563 in: marshalTextFunc(func() ([]byte, error) {
3564 return []byte("\xde\xad\xbe\xef"), nil
3565 }),
3566 wantErr: EM(newInvalidUTF8Error(0, "")).withType(0, T[marshalTextFunc]()),
3567 }, {
3568 name: jsontest.Name("Methods/Text/AllowInvalidUTF8"),
3569 opts: []Options{jsontext.AllowInvalidUTF8(true)},
3570 in: marshalTextFunc(func() ([]byte, error) {
3571 return []byte("\xde\xad\xbe\xef"), nil
3572 }),
3573 want: "\"\xde\xad\ufffd\ufffd\"",
3574 }, {
3575 name: jsontest.Name("Methods/Invalid/Text/ErrUnsupported"),
3576 in: marshalTextFunc(func() ([]byte, error) {
3577 return nil, errors.ErrUnsupported
3578 }),
3579 wantErr: EM(wrapErrUnsupported(errors.ErrUnsupported, "MarshalText method")).withType(0, T[marshalTextFunc]()),
3580 }, {
3581 name: jsontest.Name("Methods/Invalid/MapKey/JSONv2/Syntax"),
3582 in: map[any]string{
3583 addr(marshalJSONv2Func(func(enc *jsontext.Encoder) error {
3584 return enc.WriteToken(jsontext.Null)
3585 })): "invalid",
3586 },
3587 want: `{`,
3588 wantErr: EM(newNonStringNameError(len64(`{`), "")).withPos(`{`, "").withType(0, T[marshalJSONv2Func]()),
3589 }, {
3590 name: jsontest.Name("Methods/Invalid/MapKey/JSONv1/Syntax"),
3591 in: map[any]string{
3592 addr(marshalJSONv1Func(func() ([]byte, error) {
3593 return []byte(`null`), nil
3594 })): "invalid",
3595 },
3596 want: `{`,
3597 wantErr: EM(newNonStringNameError(len64(`{`), "")).withPos(`{`, "").withType(0, T[marshalJSONv1Func]()),
3598 }, {
3599 name: jsontest.Name("Functions/Bool/V1"),
3600 opts: []Options{
3601 WithMarshalers(MarshalFunc(func(bool) ([]byte, error) {
3602 return []byte(`"called"`), nil
3603 })),
3604 },
3605 in: true,
3606 want: `"called"`,
3607 }, {
3608 name: jsontest.Name("Functions/Bool/Empty"),
3609 opts: []Options{WithMarshalers(nil)},
3610 in: true,
3611 want: `true`,
3612 }, {
3613 name: jsontest.Name("Functions/NamedBool/V1/NoMatch"),
3614 opts: []Options{
3615 WithMarshalers(MarshalFunc(func(namedBool) ([]byte, error) {
3616 return nil, errMustNotCall
3617 })),
3618 },
3619 in: true,
3620 want: `true`,
3621 }, {
3622 name: jsontest.Name("Functions/NamedBool/V1/Match"),
3623 opts: []Options{
3624 WithMarshalers(MarshalFunc(func(namedBool) ([]byte, error) {
3625 return []byte(`"called"`), nil
3626 })),
3627 },
3628 in: namedBool(true),
3629 want: `"called"`,
3630 }, {
3631 name: jsontest.Name("Functions/PointerBool/V1/Match"),
3632 opts: []Options{
3633 WithMarshalers(MarshalFunc(func(v *bool) ([]byte, error) {
3634 _ = *v
3635 return []byte(`"called"`), nil
3636 })),
3637 },
3638 in: true,
3639 want: `"called"`,
3640 }, {
3641 name: jsontest.Name("Functions/Bool/V2"),
3642 opts: []Options{
3643 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v bool) error {
3644 return enc.WriteToken(jsontext.String("called"))
3645 })),
3646 },
3647 in: true,
3648 want: `"called"`,
3649 }, {
3650 name: jsontest.Name("Functions/NamedBool/V2/NoMatch"),
3651 opts: []Options{
3652 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v namedBool) error {
3653 return errMustNotCall
3654 })),
3655 },
3656 in: true,
3657 want: `true`,
3658 }, {
3659 name: jsontest.Name("Functions/NamedBool/V2/Match"),
3660 opts: []Options{
3661 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v namedBool) error {
3662 return enc.WriteToken(jsontext.String("called"))
3663 })),
3664 },
3665 in: namedBool(true),
3666 want: `"called"`,
3667 }, {
3668 name: jsontest.Name("Functions/PointerBool/V2/Match"),
3669 opts: []Options{
3670 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v *bool) error {
3671 _ = *v
3672 return enc.WriteToken(jsontext.String("called"))
3673 })),
3674 },
3675 in: true,
3676 want: `"called"`,
3677 }, {
3678 name: jsontest.Name("Functions/Bool/Empty1/NoMatch"),
3679 opts: []Options{
3680 WithMarshalers(new(Marshalers)),
3681 },
3682 in: true,
3683 want: `true`,
3684 }, {
3685 name: jsontest.Name("Functions/Bool/Empty2/NoMatch"),
3686 opts: []Options{
3687 WithMarshalers(JoinMarshalers()),
3688 },
3689 in: true,
3690 want: `true`,
3691 }, {
3692 name: jsontest.Name("Functions/Bool/V1/DirectError"),
3693 opts: []Options{
3694 WithMarshalers(MarshalFunc(func(bool) ([]byte, error) {
3695 return nil, errSomeError
3696 })),
3697 },
3698 in: true,
3699 wantErr: EM(errSomeError).withType(0, T[bool]()),
3700 }, {
3701 name: jsontest.Name("Functions/Bool/V1/SkipError"),
3702 opts: []Options{
3703 WithMarshalers(MarshalFunc(func(bool) ([]byte, error) {
3704 return nil, errors.ErrUnsupported
3705 })),
3706 },
3707 in: true,
3708 wantErr: EM(wrapErrUnsupported(errors.ErrUnsupported, "marshal function of type func(T) ([]byte, error)")).withType(0, T[bool]()),
3709 }, {
3710 name: jsontest.Name("Functions/Bool/V1/InvalidValue"),
3711 opts: []Options{
3712 WithMarshalers(MarshalFunc(func(bool) ([]byte, error) {
3713 return []byte("invalid"), nil
3714 })),
3715 },
3716 in: true,
3717 wantErr: EM(newInvalidCharacterError("i", "at start of value", 0, "")).withType(0, T[bool]()),
3718 }, {
3719 name: jsontest.Name("Functions/Bool/V2/DirectError"),
3720 opts: []Options{
3721 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v bool) error {
3722 return errSomeError
3723 })),
3724 },
3725 in: true,
3726 wantErr: EM(errSomeError).withType(0, T[bool]()),
3727 }, {
3728 name: jsontest.Name("Functions/Bool/V2/TooFew"),
3729 opts: []Options{
3730 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v bool) error {
3731 return nil
3732 })),
3733 },
3734 in: true,
3735 wantErr: EM(errNonSingularValue).withType(0, T[bool]()),
3736 }, {
3737 name: jsontest.Name("Functions/Bool/V2/TooMany"),
3738 opts: []Options{
3739 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v bool) error {
3740 enc.WriteValue([]byte(`"hello"`))
3741 enc.WriteValue([]byte(`"world"`))
3742 return nil
3743 })),
3744 },
3745 in: true,
3746 want: `"hello""world"`,
3747 wantErr: EM(errNonSingularValue).withPos(`"hello""world"`, "").withType(0, T[bool]()),
3748 }, {
3749 name: jsontest.Name("Functions/Bool/V2/Skipped"),
3750 opts: []Options{
3751 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v bool) error {
3752 return errors.ErrUnsupported
3753 })),
3754 },
3755 in: true,
3756 want: `true`,
3757 }, {
3758 name: jsontest.Name("Functions/Bool/V2/ProcessBeforeSkip"),
3759 opts: []Options{
3760 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v bool) error {
3761 enc.WriteValue([]byte(`"hello"`))
3762 return errors.ErrUnsupported
3763 })),
3764 },
3765 in: true,
3766 want: `"hello"`,
3767 wantErr: EM(errUnsupportedMutation).withPos(`"hello"`, "").withType(0, T[bool]()),
3768 }, {
3769 name: jsontest.Name("Functions/Bool/V2/WrappedUnsupportedError"),
3770 opts: []Options{
3771 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v bool) error {
3772 return fmt.Errorf("wrap: %w", errors.ErrUnsupported)
3773 })),
3774 },
3775 in: true,
3776 want: `true`,
3777 }, {
3778 name: jsontest.Name("Functions/Map/Key/NoCaseString/V1"),
3779 opts: []Options{
3780 WithMarshalers(MarshalFunc(func(v nocaseString) ([]byte, error) {
3781 return []byte(`"called"`), nil
3782 })),
3783 },
3784 in: map[nocaseString]string{"hello": "world"},
3785 want: `{"called":"world"}`,
3786 }, {
3787 name: jsontest.Name("Functions/Map/Key/PointerNoCaseString/V1"),
3788 opts: []Options{
3789 WithMarshalers(MarshalFunc(func(v *nocaseString) ([]byte, error) {
3790 _ = *v
3791 return []byte(`"called"`), nil
3792 })),
3793 },
3794 in: map[nocaseString]string{"hello": "world"},
3795 want: `{"called":"world"}`,
3796 }, {
3797 name: jsontest.Name("Functions/Map/Key/TextMarshaler/V1"),
3798 opts: []Options{
3799 WithMarshalers(MarshalFunc(func(v encoding.TextMarshaler) ([]byte, error) {
3800 _ = *v.(*nocaseString)
3801 return []byte(`"called"`), nil
3802 })),
3803 },
3804 in: map[nocaseString]string{"hello": "world"},
3805 want: `{"called":"world"}`,
3806 }, {
3807 name: jsontest.Name("Functions/Map/Key/NoCaseString/V1/InvalidValue"),
3808 opts: []Options{
3809 WithMarshalers(MarshalFunc(func(v nocaseString) ([]byte, error) {
3810 return []byte(`null`), nil
3811 })),
3812 },
3813 in: map[nocaseString]string{"hello": "world"},
3814 want: `{`,
3815 wantErr: EM(newNonStringNameError(len64(`{`), "")).withPos(`{`, "").withType(0, T[nocaseString]()),
3816 }, {
3817 name: jsontest.Name("Functions/Map/Key/NoCaseString/V2/InvalidKind"),
3818 opts: []Options{
3819 WithMarshalers(MarshalFunc(func(v nocaseString) ([]byte, error) {
3820 return []byte(`null`), nil
3821 })),
3822 },
3823 in: map[nocaseString]string{"hello": "world"},
3824 want: `{`,
3825 wantErr: EM(newNonStringNameError(len64(`{`), "")).withPos(`{`, "").withType(0, T[nocaseString]()),
3826 }, {
3827 name: jsontest.Name("Functions/Map/Key/String/V1/DuplicateName"),
3828 opts: []Options{
3829 WithMarshalers(MarshalFunc(func(v string) ([]byte, error) {
3830 return []byte(`"name"`), nil
3831 })),
3832 },
3833 in: map[string]string{"name1": "value", "name2": "value"},
3834 want: `{"name":"name"`,
3835 wantErr: EM(newDuplicateNameError("", []byte(`"name"`), len64(`{"name":"name",`))).
3836 withPos(`{"name":"name",`, "").withType(0, T[string]()),
3837 }, {
3838 name: jsontest.Name("Functions/Map/Key/NoCaseString/V2"),
3839 opts: []Options{
3840 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v nocaseString) error {
3841 return enc.WriteValue([]byte(`"called"`))
3842 })),
3843 },
3844 in: map[nocaseString]string{"hello": "world"},
3845 want: `{"called":"world"}`,
3846 }, {
3847 name: jsontest.Name("Functions/Map/Key/PointerNoCaseString/V2"),
3848 opts: []Options{
3849 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v *nocaseString) error {
3850 _ = *v
3851 return enc.WriteValue([]byte(`"called"`))
3852 })),
3853 },
3854 in: map[nocaseString]string{"hello": "world"},
3855 want: `{"called":"world"}`,
3856 }, {
3857 name: jsontest.Name("Functions/Map/Key/TextMarshaler/V2"),
3858 opts: []Options{
3859 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v encoding.TextMarshaler) error {
3860 _ = *v.(*nocaseString)
3861 return enc.WriteValue([]byte(`"called"`))
3862 })),
3863 },
3864 in: map[nocaseString]string{"hello": "world"},
3865 want: `{"called":"world"}`,
3866 }, {
3867 name: jsontest.Name("Functions/Map/Key/NoCaseString/V2/InvalidToken"),
3868 opts: []Options{
3869 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v nocaseString) error {
3870 return enc.WriteToken(jsontext.Null)
3871 })),
3872 },
3873 in: map[nocaseString]string{"hello": "world"},
3874 want: `{`,
3875 wantErr: EM(newNonStringNameError(len64(`{`), "")).withPos(`{`, "").withType(0, T[nocaseString]()),
3876 }, {
3877 name: jsontest.Name("Functions/Map/Key/NoCaseString/V2/InvalidValue"),
3878 opts: []Options{
3879 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v nocaseString) error {
3880 return enc.WriteValue([]byte(`null`))
3881 })),
3882 },
3883 in: map[nocaseString]string{"hello": "world"},
3884 want: `{`,
3885 wantErr: EM(newNonStringNameError(len64(`{`), "")).withPos(`{`, "").withType(0, T[nocaseString]()),
3886 }, {
3887 name: jsontest.Name("Functions/Map/Value/NoCaseString/V1"),
3888 opts: []Options{
3889 WithMarshalers(MarshalFunc(func(v nocaseString) ([]byte, error) {
3890 return []byte(`"called"`), nil
3891 })),
3892 },
3893 in: map[string]nocaseString{"hello": "world"},
3894 want: `{"hello":"called"}`,
3895 }, {
3896 name: jsontest.Name("Functions/Map/Value/PointerNoCaseString/V1"),
3897 opts: []Options{
3898 WithMarshalers(MarshalFunc(func(v *nocaseString) ([]byte, error) {
3899 _ = *v
3900 return []byte(`"called"`), nil
3901 })),
3902 },
3903 in: map[string]nocaseString{"hello": "world"},
3904 want: `{"hello":"called"}`,
3905 }, {
3906 name: jsontest.Name("Functions/Map/Value/TextMarshaler/V1"),
3907 opts: []Options{
3908 WithMarshalers(MarshalFunc(func(v encoding.TextMarshaler) ([]byte, error) {
3909 _ = *v.(*nocaseString)
3910 return []byte(`"called"`), nil
3911 })),
3912 },
3913 in: map[string]nocaseString{"hello": "world"},
3914 want: `{"hello":"called"}`,
3915 }, {
3916 name: jsontest.Name("Functions/Map/Value/NoCaseString/V2"),
3917 opts: []Options{
3918 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v nocaseString) error {
3919 return enc.WriteValue([]byte(`"called"`))
3920 })),
3921 },
3922 in: map[string]nocaseString{"hello": "world"},
3923 want: `{"hello":"called"}`,
3924 }, {
3925 name: jsontest.Name("Functions/Map/Value/PointerNoCaseString/V2"),
3926 opts: []Options{
3927 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v *nocaseString) error {
3928 _ = *v
3929 return enc.WriteValue([]byte(`"called"`))
3930 })),
3931 },
3932 in: map[string]nocaseString{"hello": "world"},
3933 want: `{"hello":"called"}`,
3934 }, {
3935 name: jsontest.Name("Functions/Map/Value/TextMarshaler/V2"),
3936 opts: []Options{
3937 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v encoding.TextMarshaler) error {
3938 _ = *v.(*nocaseString)
3939 return enc.WriteValue([]byte(`"called"`))
3940 })),
3941 },
3942 in: map[string]nocaseString{"hello": "world"},
3943 want: `{"hello":"called"}`,
3944 }, {
3945 name: jsontest.Name("Funtions/Struct/Fields"),
3946 opts: []Options{
3947 WithMarshalers(JoinMarshalers(
3948 MarshalFunc(func(v bool) ([]byte, error) {
3949 return []byte(`"called1"`), nil
3950 }),
3951 MarshalFunc(func(v *string) ([]byte, error) {
3952 return []byte(`"called2"`), nil
3953 }),
3954 MarshalToFunc(func(enc *jsontext.Encoder, v []byte) error {
3955 return enc.WriteValue([]byte(`"called3"`))
3956 }),
3957 MarshalToFunc(func(enc *jsontext.Encoder, v *int64) error {
3958 return enc.WriteValue([]byte(`"called4"`))
3959 }),
3960 )),
3961 },
3962 in: structScalars{},
3963 want: `{"Bool":"called1","String":"called2","Bytes":"called3","Int":"called4","Uint":0,"Float":0}`,
3964 }, {
3965 name: jsontest.Name("Functions/Struct/OmitEmpty"),
3966 opts: []Options{
3967 WithMarshalers(JoinMarshalers(
3968 MarshalFunc(func(v bool) ([]byte, error) {
3969 return []byte(`null`), nil
3970 }),
3971 MarshalFunc(func(v string) ([]byte, error) {
3972 return []byte(`"called1"`), nil
3973 }),
3974 MarshalFunc(func(v *stringMarshalNonEmpty) ([]byte, error) {
3975 return []byte(`""`), nil
3976 }),
3977 MarshalToFunc(func(enc *jsontext.Encoder, v bytesMarshalNonEmpty) error {
3978 return enc.WriteValue([]byte(`{}`))
3979 }),
3980 MarshalToFunc(func(enc *jsontext.Encoder, v *float64) error {
3981 return enc.WriteValue([]byte(`[]`))
3982 }),
3983 MarshalFunc(func(v mapMarshalNonEmpty) ([]byte, error) {
3984 return []byte(`"called2"`), nil
3985 }),
3986 MarshalFunc(func(v []string) ([]byte, error) {
3987 return []byte(`"called3"`), nil
3988 }),
3989 MarshalToFunc(func(enc *jsontext.Encoder, v *sliceMarshalNonEmpty) error {
3990 return enc.WriteValue([]byte(`"called4"`))
3991 }),
3992 )),
3993 },
3994 in: structOmitEmptyAll{},
3995 want: `{"String":"called1","MapNonEmpty":"called2","Slice":"called3","SliceNonEmpty":"called4"}`,
3996 }, {
3997 name: jsontest.Name("Functions/Struct/OmitZero"),
3998 opts: []Options{
3999 WithMarshalers(JoinMarshalers(
4000 MarshalFunc(func(v bool) ([]byte, error) {
4001 panic("should not be called")
4002 }),
4003 MarshalFunc(func(v *string) ([]byte, error) {
4004 panic("should not be called")
4005 }),
4006 MarshalToFunc(func(enc *jsontext.Encoder, v []byte) error {
4007 panic("should not be called")
4008 }),
4009 MarshalToFunc(func(enc *jsontext.Encoder, v *int64) error {
4010 panic("should not be called")
4011 }),
4012 )),
4013 },
4014 in: structOmitZeroAll{},
4015 want: `{}`,
4016 }, {
4017 name: jsontest.Name("Functions/Struct/Embedded"),
4018 opts: []Options{
4019 WithMarshalers(JoinMarshalers(
4020 MarshalFunc(func(v structEmbeddedL1) ([]byte, error) {
4021 panic("should not be called")
4022 }),
4023 MarshalToFunc(func(enc *jsontext.Encoder, v *StructEmbed2) error {
4024 panic("should not be called")
4025 }),
4026 )),
4027 },
4028 in: structEmbedded{},
4029 want: `{"D":""}`,
4030 }, {
4031 name: jsontest.Name("Functions/Slice/Elem"),
4032 opts: []Options{
4033 WithMarshalers(MarshalFunc(func(v bool) ([]byte, error) {
4034 return []byte(`"` + strconv.FormatBool(v) + `"`), nil
4035 })),
4036 },
4037 in: []bool{true, false},
4038 want: `["true","false"]`,
4039 }, {
4040 name: jsontest.Name("Functions/Array/Elem"),
4041 opts: []Options{
4042 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v *bool) error {
4043 return enc.WriteValue([]byte(`"` + strconv.FormatBool(*v) + `"`))
4044 })),
4045 },
4046 in: [2]bool{true, false},
4047 want: `["true","false"]`,
4048 }, {
4049 name: jsontest.Name("Functions/Pointer/Nil"),
4050 opts: []Options{
4051 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v *bool) error {
4052 panic("should not be called")
4053 })),
4054 },
4055 in: struct{ X *bool }{nil},
4056 want: `{"X":null}`,
4057 }, {
4058 name: jsontest.Name("Functions/Pointer/NonNil"),
4059 opts: []Options{
4060 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v *bool) error {
4061 return enc.WriteValue([]byte(`"called"`))
4062 })),
4063 },
4064 in: struct{ X *bool }{addr(false)},
4065 want: `{"X":"called"}`,
4066 }, {
4067 name: jsontest.Name("Functions/Interface/Nil"),
4068 opts: []Options{
4069 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v fmt.Stringer) error {
4070 panic("should not be called")
4071 })),
4072 },
4073 in: struct{ X fmt.Stringer }{nil},
4074 want: `{"X":null}`,
4075 }, {
4076 name: jsontest.Name("Functions/Interface/NonNil/MatchInterface"),
4077 opts: []Options{
4078 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v fmt.Stringer) error {
4079 return enc.WriteValue([]byte(`"called"`))
4080 })),
4081 },
4082 in: struct{ X fmt.Stringer }{valueStringer{}},
4083 want: `{"X":"called"}`,
4084 }, {
4085 name: jsontest.Name("Functions/Interface/NonNil/MatchConcrete"),
4086 opts: []Options{
4087 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v valueStringer) error {
4088 return enc.WriteValue([]byte(`"called"`))
4089 })),
4090 },
4091 in: struct{ X fmt.Stringer }{valueStringer{}},
4092 want: `{"X":"called"}`,
4093 }, {
4094 name: jsontest.Name("Functions/Interface/NonNil/MatchPointer"),
4095 opts: []Options{
4096 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, v *valueStringer) error {
4097 return enc.WriteValue([]byte(`"called"`))
4098 })),
4099 },
4100 in: struct{ X fmt.Stringer }{valueStringer{}},
4101 want: `{"X":"called"}`,
4102 }, {
4103 name: jsontest.Name("Functions/Interface/Any"),
4104 opts: []Options{
4105 WithMarshalers(func() *Marshalers {
4106 type P struct {
4107 D int
4108 N int64
4109 }
4110 type PV struct {
4111 P P
4112 V any
4113 }
4114
4115 var lastChecks []func() error
4116 checkLast := func() error {
4117 for _, fn := range lastChecks {
4118 if err := fn(); err != nil {
4119 return err
4120 }
4121 }
4122 return errors.ErrUnsupported
4123 }
4124 makeValueChecker := func(name string, want []PV) func(e *jsontext.Encoder, v any) error {
4125 checkNext := func(e *jsontext.Encoder, v any) error {
4126 xe := export.Encoder(e)
4127 p := P{len(xe.Tokens.Stack), xe.Tokens.Last.Length()}
4128 rv := reflect.ValueOf(v)
4129 pv := PV{p, v}
4130 switch {
4131 case len(want) == 0:
4132 return fmt.Errorf("%s: %v: got more values than expected", name, p)
4133 case !rv.IsValid() || rv.Kind() != reflect.Pointer || rv.IsNil():
4134 return fmt.Errorf("%s: %v: got %#v, want non-nil pointer type", name, p, v)
4135 case !reflect.DeepEqual(pv, want[0]):
4136 return fmt.Errorf("%s:\n\tgot %#v\n\twant %#v", name, pv, want[0])
4137 default:
4138 want = want[1:]
4139 return errors.ErrUnsupported
4140 }
4141 }
4142 lastChecks = append(lastChecks, func() error {
4143 if len(want) > 0 {
4144 return fmt.Errorf("%s: did not get enough values, want %d more", name, len(want))
4145 }
4146 return nil
4147 })
4148 return checkNext
4149 }
4150 makePositionChecker := func(name string, want []P) func(e *jsontext.Encoder, v any) error {
4151 checkNext := func(e *jsontext.Encoder, v any) error {
4152 xe := export.Encoder(e)
4153 p := P{len(xe.Tokens.Stack), xe.Tokens.Last.Length()}
4154 switch {
4155 case len(want) == 0:
4156 return fmt.Errorf("%s: %v: got more values than wanted", name, p)
4157 case p != want[0]:
4158 return fmt.Errorf("%s: got %v, want %v", name, p, want[0])
4159 default:
4160 want = want[1:]
4161 return errors.ErrUnsupported
4162 }
4163 }
4164 lastChecks = append(lastChecks, func() error {
4165 if len(want) > 0 {
4166 return fmt.Errorf("%s: did not get enough values, want %d more", name, len(want))
4167 }
4168 return nil
4169 })
4170 return checkNext
4171 }
4172
4173 wantAny := []PV{
4174 {P{0, 0}, addr([]any{
4175 nil,
4176 valueStringer{},
4177 (*valueStringer)(nil),
4178 addr(valueStringer{}),
4179 (**valueStringer)(nil),
4180 addr((*valueStringer)(nil)),
4181 addr(addr(valueStringer{})),
4182 pointerStringer{},
4183 (*pointerStringer)(nil),
4184 addr(pointerStringer{}),
4185 (**pointerStringer)(nil),
4186 addr((*pointerStringer)(nil)),
4187 addr(addr(pointerStringer{})),
4188 "LAST",
4189 })},
4190 {P{1, 0}, addr(any(nil))},
4191 {P{1, 1}, addr(any(valueStringer{}))},
4192 {P{1, 1}, addr(valueStringer{})},
4193 {P{1, 2}, addr(any((*valueStringer)(nil)))},
4194 {P{1, 2}, addr((*valueStringer)(nil))},
4195 {P{1, 3}, addr(any(addr(valueStringer{})))},
4196 {P{1, 3}, addr(addr(valueStringer{}))},
4197 {P{1, 3}, addr(valueStringer{})},
4198 {P{1, 4}, addr(any((**valueStringer)(nil)))},
4199 {P{1, 4}, addr((**valueStringer)(nil))},
4200 {P{1, 5}, addr(any(addr((*valueStringer)(nil))))},
4201 {P{1, 5}, addr(addr((*valueStringer)(nil)))},
4202 {P{1, 5}, addr((*valueStringer)(nil))},
4203 {P{1, 6}, addr(any(addr(addr(valueStringer{}))))},
4204 {P{1, 6}, addr(addr(addr(valueStringer{})))},
4205 {P{1, 6}, addr(addr(valueStringer{}))},
4206 {P{1, 6}, addr(valueStringer{})},
4207 {P{1, 7}, addr(any(pointerStringer{}))},
4208 {P{1, 7}, addr(pointerStringer{})},
4209 {P{1, 8}, addr(any((*pointerStringer)(nil)))},
4210 {P{1, 8}, addr((*pointerStringer)(nil))},
4211 {P{1, 9}, addr(any(addr(pointerStringer{})))},
4212 {P{1, 9}, addr(addr(pointerStringer{}))},
4213 {P{1, 9}, addr(pointerStringer{})},
4214 {P{1, 10}, addr(any((**pointerStringer)(nil)))},
4215 {P{1, 10}, addr((**pointerStringer)(nil))},
4216 {P{1, 11}, addr(any(addr((*pointerStringer)(nil))))},
4217 {P{1, 11}, addr(addr((*pointerStringer)(nil)))},
4218 {P{1, 11}, addr((*pointerStringer)(nil))},
4219 {P{1, 12}, addr(any(addr(addr(pointerStringer{}))))},
4220 {P{1, 12}, addr(addr(addr(pointerStringer{})))},
4221 {P{1, 12}, addr(addr(pointerStringer{}))},
4222 {P{1, 12}, addr(pointerStringer{})},
4223 {P{1, 13}, addr(any("LAST"))},
4224 {P{1, 13}, addr("LAST")},
4225 }
4226 checkAny := makeValueChecker("any", wantAny)
4227 anyMarshaler := MarshalToFunc(func(enc *jsontext.Encoder, v any) error {
4228 return checkAny(enc, v)
4229 })
4230
4231 var wantPointerAny []PV
4232 for _, v := range wantAny {
4233 if _, ok := v.V.(*any); ok {
4234 wantPointerAny = append(wantPointerAny, v)
4235 }
4236 }
4237 checkPointerAny := makeValueChecker("*any", wantPointerAny)
4238 pointerAnyMarshaler := MarshalToFunc(func(enc *jsontext.Encoder, v *any) error {
4239 return checkPointerAny(enc, v)
4240 })
4241
4242 checkNamedAny := makeValueChecker("namedAny", wantAny)
4243 namedAnyMarshaler := MarshalToFunc(func(enc *jsontext.Encoder, v namedAny) error {
4244 return checkNamedAny(enc, v)
4245 })
4246
4247 checkPointerNamedAny := makeValueChecker("*namedAny", nil)
4248 pointerNamedAnyMarshaler := MarshalToFunc(func(enc *jsontext.Encoder, v *namedAny) error {
4249 return checkPointerNamedAny(enc, v)
4250 })
4251
4252 type stringer = fmt.Stringer
4253 var wantStringer []PV
4254 for _, v := range wantAny {
4255 if _, ok := v.V.(stringer); ok {
4256 wantStringer = append(wantStringer, v)
4257 }
4258 }
4259 checkStringer := makeValueChecker("stringer", wantStringer)
4260 stringerMarshaler := MarshalToFunc(func(enc *jsontext.Encoder, v stringer) error {
4261 return checkStringer(enc, v)
4262 })
4263
4264 checkPointerStringer := makeValueChecker("*stringer", nil)
4265 pointerStringerMarshaler := MarshalToFunc(func(enc *jsontext.Encoder, v *stringer) error {
4266 return checkPointerStringer(enc, v)
4267 })
4268
4269 wantValueStringer := []P{{1, 1}, {1, 3}, {1, 6}}
4270 checkValueValueStringer := makePositionChecker("valueStringer", wantValueStringer)
4271 valueValueStringerMarshaler := MarshalToFunc(func(enc *jsontext.Encoder, v valueStringer) error {
4272 return checkValueValueStringer(enc, v)
4273 })
4274
4275 checkPointerValueStringer := makePositionChecker("*valueStringer", wantValueStringer)
4276 pointerValueStringerMarshaler := MarshalToFunc(func(enc *jsontext.Encoder, v *valueStringer) error {
4277 return checkPointerValueStringer(enc, v)
4278 })
4279
4280 wantPointerStringer := []P{{1, 7}, {1, 9}, {1, 12}}
4281 checkValuePointerStringer := makePositionChecker("pointerStringer", wantPointerStringer)
4282 valuePointerStringerMarshaler := MarshalToFunc(func(enc *jsontext.Encoder, v pointerStringer) error {
4283 return checkValuePointerStringer(enc, v)
4284 })
4285
4286 checkPointerPointerStringer := makePositionChecker("*pointerStringer", wantPointerStringer)
4287 pointerPointerStringerMarshaler := MarshalToFunc(func(enc *jsontext.Encoder, v *pointerStringer) error {
4288 return checkPointerPointerStringer(enc, v)
4289 })
4290
4291 lastMarshaler := MarshalToFunc(func(enc *jsontext.Encoder, v string) error {
4292 return checkLast()
4293 })
4294
4295 return JoinMarshalers(
4296 anyMarshaler,
4297 pointerAnyMarshaler,
4298 namedAnyMarshaler,
4299 pointerNamedAnyMarshaler,
4300 stringerMarshaler,
4301 pointerStringerMarshaler,
4302 valueValueStringerMarshaler,
4303 pointerValueStringerMarshaler,
4304 valuePointerStringerMarshaler,
4305 pointerPointerStringerMarshaler,
4306 lastMarshaler,
4307 )
4308 }()),
4309 },
4310 in: []any{
4311 nil,
4312 valueStringer{},
4313 (*valueStringer)(nil),
4314 addr(valueStringer{}),
4315 (**valueStringer)(nil),
4316 addr((*valueStringer)(nil)),
4317 addr(addr(valueStringer{})),
4318 pointerStringer{},
4319 (*pointerStringer)(nil),
4320 addr(pointerStringer{}),
4321 (**pointerStringer)(nil),
4322 addr((*pointerStringer)(nil)),
4323 addr(addr(pointerStringer{})),
4324 "LAST",
4325 },
4326 want: `[null,{},null,{},null,null,{},{},null,{},null,null,{},"LAST"]`,
4327 }, {
4328 name: jsontest.Name("Functions/Precedence/V1First"),
4329 opts: []Options{
4330 WithMarshalers(JoinMarshalers(
4331 MarshalFunc(func(bool) ([]byte, error) {
4332 return []byte(`"called"`), nil
4333 }),
4334 MarshalToFunc(func(enc *jsontext.Encoder, v bool) error {
4335 panic("should not be called")
4336 }),
4337 )),
4338 },
4339 in: true,
4340 want: `"called"`,
4341 }, {
4342 name: jsontest.Name("Functions/Precedence/V2First"),
4343 opts: []Options{
4344 WithMarshalers(JoinMarshalers(
4345 MarshalToFunc(func(enc *jsontext.Encoder, v bool) error {
4346 return enc.WriteToken(jsontext.String("called"))
4347 }),
4348 MarshalFunc(func(bool) ([]byte, error) {
4349 panic("should not be called")
4350 }),
4351 )),
4352 },
4353 in: true,
4354 want: `"called"`,
4355 }, {
4356 name: jsontest.Name("Functions/Precedence/V2Skipped"),
4357 opts: []Options{
4358 WithMarshalers(JoinMarshalers(
4359 MarshalToFunc(func(enc *jsontext.Encoder, v bool) error {
4360 return errors.ErrUnsupported
4361 }),
4362 MarshalFunc(func(bool) ([]byte, error) {
4363 return []byte(`"called"`), nil
4364 }),
4365 )),
4366 },
4367 in: true,
4368 want: `"called"`,
4369 }, {
4370 name: jsontest.Name("Functions/Precedence/NestedFirst"),
4371 opts: []Options{
4372 WithMarshalers(JoinMarshalers(
4373 JoinMarshalers(
4374 MarshalFunc(func(bool) ([]byte, error) {
4375 return []byte(`"called"`), nil
4376 }),
4377 ),
4378 MarshalFunc(func(bool) ([]byte, error) {
4379 panic("should not be called")
4380 }),
4381 )),
4382 },
4383 in: true,
4384 want: `"called"`,
4385 }, {
4386 name: jsontest.Name("Functions/Precedence/NestedLast"),
4387 opts: []Options{
4388 WithMarshalers(JoinMarshalers(
4389 MarshalFunc(func(bool) ([]byte, error) {
4390 return []byte(`"called"`), nil
4391 }),
4392 JoinMarshalers(
4393 MarshalFunc(func(bool) ([]byte, error) {
4394 panic("should not be called")
4395 }),
4396 ),
4397 )),
4398 },
4399 in: true,
4400 want: `"called"`,
4401 }, {
4402 name: jsontest.Name("Duration/Zero"),
4403 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
4404 in: struct {
4405 D1 time.Duration `json:",format:units"`
4406 D2 time.Duration `json:",format:nano"`
4407 }{0, 0},
4408 want: `{"D1":"0s","D2":0}`,
4409 }, {
4410 name: jsontest.Name("Duration/Positive"),
4411 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
4412 in: struct {
4413 D1 time.Duration `json:",format:units"`
4414 D2 time.Duration `json:",format:nano"`
4415 }{
4416 123456789123456789,
4417 123456789123456789,
4418 },
4419 want: `{"D1":"34293h33m9.123456789s","D2":123456789123456789}`,
4420 }, {
4421 name: jsontest.Name("Duration/Negative"),
4422 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
4423 in: struct {
4424 D1 time.Duration `json:",format:units"`
4425 D2 time.Duration `json:",format:nano"`
4426 }{
4427 -123456789123456789,
4428 -123456789123456789,
4429 },
4430 want: `{"D1":"-34293h33m9.123456789s","D2":-123456789123456789}`,
4431 }, {
4432 name: jsontest.Name("Duration/Nanos/String"),
4433 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
4434 in: struct {
4435 D1 time.Duration `json:",string,format:nano"`
4436 D2 time.Duration `json:",string,format:nano"`
4437 D3 time.Duration `json:",string,format:nano"`
4438 }{
4439 math.MinInt64,
4440 0,
4441 math.MaxInt64,
4442 },
4443 want: `{"D1":"-9223372036854775808","D2":"0","D3":"9223372036854775807"}`,
4444 }, {
4445 name: jsontest.Name("Duration/Format/Invalid"),
4446 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
4447 in: struct {
4448 D time.Duration `json:",format:invalid"`
4449 }{},
4450 want: `{"D"`,
4451 wantErr: EM(errInvalidFormatFlag).withPos(`{"D":`, "/D").withType(0, T[time.Duration]()),
4452 }, {
4453
4459 name: jsontest.Name("Duration/Format"),
4460 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true), jsontext.Multiline(true)},
4461 in: structDurationFormat{
4462 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
4463 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
4464 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
4465 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
4466 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
4467 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
4468 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
4469 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
4470 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
4471 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
4472 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
4473 },
4474 want: `{
4475 "D1": "12h34m56.078090012s",
4476 "D2": "12h34m56.078090012s",
4477 "D3": 45296.078090012,
4478 "D4": "45296.078090012",
4479 "D5": 45296078.090012,
4480 "D6": "45296078.090012",
4481 "D7": 45296078090.012,
4482 "D8": "45296078090.012",
4483 "D9": 45296078090012,
4484 "D10": "45296078090012",
4485 "D11": "PT12H34M56.078090012S"
4486 }`,
4487 }, {
4488
4497
4502 name: jsontest.Name("Duration/MapKey/Legacy"),
4503 opts: []Options{jsonflags.FormatDurationAsNano | 1},
4504 in: map[time.Duration]string{time.Second: ""},
4505 want: `{"1000000000":""}`,
4506 }, {
4507 name: jsontest.Name("Time/Zero"),
4508 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
4509 in: struct {
4510 T1 time.Time
4511 T2 time.Time `json:",format:RFC822"`
4512 T3 time.Time `json:",format:'2006-01-02'"`
4513 T4 time.Time `json:",omitzero"`
4514 T5 time.Time `json:",omitempty"`
4515 }{
4516 time.Time{},
4517 time.Time{},
4518 time.Time{},
4519
4520
4521 time.Date(1, 1, 1, 0, 0, 0, 0, time.FixedZone("UTC", 0)),
4522 time.Time{},
4523 },
4524 want: `{"T1":"0001-01-01T00:00:00Z","T2":"01 Jan 01 00:00 UTC","T3":"0001-01-01","T5":"0001-01-01T00:00:00Z"}`,
4525 }, {
4526 name: jsontest.Name("Time/Format"),
4527 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true), jsontext.Multiline(true)},
4528 in: structTimeFormat{
4529 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4530 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4531 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4532 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4533 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4534 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4535 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4536 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4537 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4538 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4539 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4540 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4541 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4542 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4543 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4544 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4545 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4546 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4547 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4548 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4549 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4550 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4551 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4552 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4553 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4554 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4555 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4556 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4557 time.Date(1234, 1, 2, 3, 4, 5, 6, time.UTC),
4558 },
4559 want: `{
4560 "T1": "1234-01-02T03:04:05.000000006Z",
4561 "T2": "Mon Jan 2 03:04:05 1234",
4562 "T3": "Mon Jan 2 03:04:05 UTC 1234",
4563 "T4": "Mon Jan 02 03:04:05 +0000 1234",
4564 "T5": "02 Jan 34 03:04 UTC",
4565 "T6": "02 Jan 34 03:04 +0000",
4566 "T7": "Monday, 02-Jan-34 03:04:05 UTC",
4567 "T8": "Mon, 02 Jan 1234 03:04:05 UTC",
4568 "T9": "Mon, 02 Jan 1234 03:04:05 +0000",
4569 "T10": "1234-01-02T03:04:05Z",
4570 "T11": "1234-01-02T03:04:05.000000006Z",
4571 "T12": "3:04AM",
4572 "T13": "Jan 2 03:04:05",
4573 "T14": "Jan 2 03:04:05.000",
4574 "T15": "Jan 2 03:04:05.000000",
4575 "T16": "Jan 2 03:04:05.000000006",
4576 "T17": "1234-01-02 03:04:05",
4577 "T18": "1234-01-02",
4578 "T19": "03:04:05",
4579 "T20": "1234-01-02",
4580 "T21": "\"weird\"1234",
4581 "T22": -23225777754.999999994,
4582 "T23": "-23225777754.999999994",
4583 "T24": -23225777754999.999994,
4584 "T25": "-23225777754999.999994",
4585 "T26": -23225777754999999.994,
4586 "T27": "-23225777754999999.994",
4587 "T28": -23225777754999999994,
4588 "T29": "-23225777754999999994"
4589 }`,
4590 }, {
4591 name: jsontest.Name("Time/Format/Invalid"),
4592 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
4593 in: struct {
4594 T time.Time `json:",format:UndefinedConstant"`
4595 }{},
4596 want: `{"T"`,
4597 wantErr: EM(errors.New(`invalid format flag "UndefinedConstant"`)).withPos(`{"T":`, "/T").withType(0, timeTimeType),
4598 }, {
4599 name: jsontest.Name("Time/Format/String/Invalid"),
4600 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
4601 in: structTimeFormatStringInvalid{},
4602 want: `{"T"`,
4603 wantErr: EM(errInvalidStringTag).withPos(`{"T":`, "/T").withType(0, timeTimeType),
4604 }, {
4605 name: jsontest.Name("Time/Format/YearOverflow"),
4606 in: struct {
4607 T1 time.Time
4608 T2 time.Time
4609 }{
4610 time.Date(10000, 1, 1, 0, 0, 0, 0, time.UTC).Add(-time.Second),
4611 time.Date(10000, 1, 1, 0, 0, 0, 0, time.UTC),
4612 },
4613 want: `{"T1":"9999-12-31T23:59:59Z","T2"`,
4614 wantErr: EM(errors.New(`year outside of range [0,9999]`)).withPos(`{"T1":"9999-12-31T23:59:59Z","T2":`, "/T2").withType(0, timeTimeType),
4615 }, {
4616 name: jsontest.Name("Time/Format/YearUnderflow"),
4617 in: struct {
4618 T1 time.Time
4619 T2 time.Time
4620 }{
4621 time.Date(0, 1, 1, 0, 0, 0, 0, time.UTC),
4622 time.Date(0, 1, 1, 0, 0, 0, 0, time.UTC).Add(-time.Second),
4623 },
4624 want: `{"T1":"0000-01-01T00:00:00Z","T2"`,
4625 wantErr: EM(errors.New(`year outside of range [0,9999]`)).withPos(`{"T1":"0000-01-01T00:00:00Z","T2":`, "/T2").withType(0, timeTimeType),
4626 }, {
4627 name: jsontest.Name("Time/Format/YearUnderflow"),
4628 in: struct{ T time.Time }{time.Date(-998, 1, 1, 0, 0, 0, 0, time.UTC).Add(-time.Second)},
4629 want: `{"T"`,
4630 wantErr: EM(errors.New(`year outside of range [0,9999]`)).withPos(`{"T":`, "/T").withType(0, timeTimeType),
4631 }, {
4632 name: jsontest.Name("Time/Format/ZoneExact"),
4633 in: struct{ T time.Time }{time.Date(2020, 1, 1, 0, 0, 0, 0, time.FixedZone("", 23*60*60+59*60))},
4634 want: `{"T":"2020-01-01T00:00:00+23:59"}`,
4635 }, {
4636 name: jsontest.Name("Time/Format/ZoneHourOverflow"),
4637 in: struct{ T time.Time }{time.Date(2020, 1, 1, 0, 0, 0, 0, time.FixedZone("", 24*60*60))},
4638 want: `{"T"`,
4639 wantErr: EM(errors.New(`timezone hour outside of range [0,23]`)).withPos(`{"T":`, "/T").withType(0, timeTimeType),
4640 }, {
4641 name: jsontest.Name("Time/Format/ZoneHourOverflow"),
4642 in: struct{ T time.Time }{time.Date(2020, 1, 1, 0, 0, 0, 0, time.FixedZone("", 123*60*60))},
4643 want: `{"T"`,
4644 wantErr: EM(errors.New(`timezone hour outside of range [0,23]`)).withPos(`{"T":`, "/T").withType(0, timeTimeType),
4645 }, {
4646 name: jsontest.Name("Time/IgnoreInvalidFormat"),
4647 opts: []Options{invalidFormatOption},
4648 in: time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC),
4649 want: `"2000-01-01T00:00:00Z"`,
4650 }}
4651
4652 for _, tt := range tests {
4653 t.Run(tt.name.Name, func(t *testing.T) {
4654 var got []byte
4655 var gotErr error
4656 if tt.useWriter {
4657 bb := new(struct{ bytes.Buffer })
4658 gotErr = MarshalWrite(bb, tt.in, tt.opts...)
4659 got = bb.Bytes()
4660 } else {
4661 got, gotErr = Marshal(tt.in, tt.opts...)
4662 }
4663 if tt.canonicalize {
4664 (*jsontext.Value)(&got).Canonicalize()
4665 }
4666 if string(got) != tt.want {
4667 t.Errorf("%s: Marshal output mismatch:\ngot %s\nwant %s", tt.name.Where, got, tt.want)
4668 }
4669 if !reflect.DeepEqual(gotErr, tt.wantErr) {
4670 t.Errorf("%s: Marshal error mismatch:\ngot %v\nwant %v", tt.name.Where, gotErr, tt.wantErr)
4671 }
4672 })
4673 }
4674 }
4675
4676 func TestUnmarshal(t *testing.T) {
4677 tests := []struct {
4678 name jsontest.CaseName
4679 opts []Options
4680 inBuf string
4681 inVal any
4682 want any
4683 wantErr error
4684 skip bool
4685 }{{
4686 name: jsontest.Name("Nil"),
4687 inBuf: `null`,
4688 wantErr: EU(internal.ErrNonNilReference),
4689 }, {
4690 name: jsontest.Name("NilPointer"),
4691 inBuf: `null`,
4692 inVal: (*string)(nil),
4693 want: (*string)(nil),
4694 wantErr: EU(internal.ErrNonNilReference).withType(0, T[*string]()),
4695 }, {
4696 name: jsontest.Name("NonPointer"),
4697 inBuf: `null`,
4698 inVal: "unchanged",
4699 want: "unchanged",
4700 wantErr: EU(internal.ErrNonNilReference).withType(0, T[string]()),
4701 }, {
4702 name: jsontest.Name("Bools/TrailingJunk"),
4703 inBuf: `falsetrue`,
4704 inVal: addr(true),
4705 want: addr(false),
4706 wantErr: newInvalidCharacterError("t", "after top-level value", len64(`false`), ""),
4707 }, {
4708 name: jsontest.Name("Bools/Null"),
4709 inBuf: `null`,
4710 inVal: addr(true),
4711 want: addr(false),
4712 }, {
4713 name: jsontest.Name("Bools"),
4714 inBuf: `[null,false,true]`,
4715 inVal: new([]bool),
4716 want: addr([]bool{false, false, true}),
4717 }, {
4718 name: jsontest.Name("Bools/Named"),
4719 inBuf: `[null,false,true]`,
4720 inVal: new([]namedBool),
4721 want: addr([]namedBool{false, false, true}),
4722 }, {
4723 name: jsontest.Name("Bools/Invalid/StringifiedFalse"),
4724 opts: []Options{StringifyNumbers(true)},
4725 inBuf: `"false"`,
4726 inVal: addr(true),
4727 want: addr(true),
4728 wantErr: EU(nil).withType('"', boolType),
4729 }, {
4730 name: jsontest.Name("Bools/Invalid/StringifiedTrue"),
4731 opts: []Options{StringifyNumbers(true)},
4732 inBuf: `"true"`,
4733 inVal: addr(true),
4734 want: addr(true),
4735 wantErr: EU(nil).withType('"', boolType),
4736 }, {
4737 name: jsontest.Name("Bools/StringifiedBool/True"),
4738 opts: []Options{jsonflags.StringTag | jsonflags.StringifyWithLegacySemantics | 1},
4739 inBuf: `"true"`,
4740 inVal: addr(false),
4741 want: addr(true),
4742 }, {
4743 name: jsontest.Name("Bools/StringifiedBool/False"),
4744 opts: []Options{jsonflags.StringTag | jsonflags.StringifyWithLegacySemantics | 1},
4745 inBuf: `"false"`,
4746 inVal: addr(true),
4747 want: addr(false),
4748 }, {
4749 name: jsontest.Name("Bools/StringifiedBool/InvalidWhitespace"),
4750 opts: []Options{jsonflags.StringTag | jsonflags.StringifyWithLegacySemantics | 1},
4751 inBuf: `"false "`,
4752 inVal: addr(true),
4753 want: addr(true),
4754 wantErr: EU(strconv.ErrSyntax).withVal(`"false "`).withType('"', boolType),
4755 }, {
4756 name: jsontest.Name("Bools/StringifiedBool/InvalidBool"),
4757 opts: []Options{jsonflags.StringTag | jsonflags.StringifyWithLegacySemantics | 1},
4758 inBuf: `false`,
4759 inVal: addr(true),
4760 want: addr(true),
4761 wantErr: EU(nil).withType('f', boolType),
4762 }, {
4763 name: jsontest.Name("Bools/Invalid/Number"),
4764 inBuf: `0`,
4765 inVal: addr(true),
4766 want: addr(true),
4767 wantErr: EU(nil).withType('0', boolType),
4768 }, {
4769 name: jsontest.Name("Bools/Invalid/String"),
4770 inBuf: `""`,
4771 inVal: addr(true),
4772 want: addr(true),
4773 wantErr: EU(nil).withType('"', boolType),
4774 }, {
4775 name: jsontest.Name("Bools/Invalid/Object"),
4776 inBuf: `{}`,
4777 inVal: addr(true),
4778 want: addr(true),
4779 wantErr: EU(nil).withType('{', boolType),
4780 }, {
4781 name: jsontest.Name("Bools/Invalid/Array"),
4782 inBuf: `[]`,
4783 inVal: addr(true),
4784 want: addr(true),
4785 wantErr: EU(nil).withType('[', boolType),
4786 }, {
4787 name: jsontest.Name("Bools/IgnoreInvalidFormat"),
4788 opts: []Options{invalidFormatOption},
4789 inBuf: `false`,
4790 inVal: addr(true),
4791 want: addr(false),
4792 }, {
4793 name: jsontest.Name("Strings/Null"),
4794 inBuf: `null`,
4795 inVal: addr("something"),
4796 want: addr(""),
4797 }, {
4798 name: jsontest.Name("Strings"),
4799 inBuf: `[null,"","hello","世界"]`,
4800 inVal: new([]string),
4801 want: addr([]string{"", "", "hello", "世界"}),
4802 }, {
4803 name: jsontest.Name("Strings/Escaped"),
4804 inBuf: `[null,"","\u0068\u0065\u006c\u006c\u006f","\u4e16\u754c"]`,
4805 inVal: new([]string),
4806 want: addr([]string{"", "", "hello", "世界"}),
4807 }, {
4808 name: jsontest.Name("Strings/Named"),
4809 inBuf: `[null,"","hello","世界"]`,
4810 inVal: new([]namedString),
4811 want: addr([]namedString{"", "", "hello", "世界"}),
4812 }, {
4813 name: jsontest.Name("Strings/Invalid/False"),
4814 inBuf: `false`,
4815 inVal: addr("nochange"),
4816 want: addr("nochange"),
4817 wantErr: EU(nil).withType('f', stringType),
4818 }, {
4819 name: jsontest.Name("Strings/Invalid/True"),
4820 inBuf: `true`,
4821 inVal: addr("nochange"),
4822 want: addr("nochange"),
4823 wantErr: EU(nil).withType('t', stringType),
4824 }, {
4825 name: jsontest.Name("Strings/Invalid/Object"),
4826 inBuf: `{}`,
4827 inVal: addr("nochange"),
4828 want: addr("nochange"),
4829 wantErr: EU(nil).withType('{', stringType),
4830 }, {
4831 name: jsontest.Name("Strings/Invalid/Array"),
4832 inBuf: `[]`,
4833 inVal: addr("nochange"),
4834 want: addr("nochange"),
4835 wantErr: EU(nil).withType('[', stringType),
4836 }, {
4837 name: jsontest.Name("Strings/IgnoreInvalidFormat"),
4838 opts: []Options{invalidFormatOption},
4839 inBuf: `"hello"`,
4840 inVal: addr("goodbye"),
4841 want: addr("hello"),
4842 }, {
4843 name: jsontest.Name("Strings/StringifiedString"),
4844 opts: []Options{jsonflags.StringTag | jsonflags.StringifyWithLegacySemantics | 1},
4845 inBuf: `"\"foo\""`,
4846 inVal: new(string),
4847 want: addr("foo"),
4848 }, {
4849 name: jsontest.Name("Strings/StringifiedString/InvalidWhitespace"),
4850 opts: []Options{jsonflags.StringTag | jsonflags.StringifyWithLegacySemantics | 1},
4851 inBuf: `"\"foo\" "`,
4852 inVal: new(string),
4853 want: new(string),
4854 wantErr: EU(newInvalidCharacterError(" ", "after string value", 0, "")).withType('"', stringType),
4855 }, {
4856 name: jsontest.Name("Strings/StringifiedString/InvalidString"),
4857 opts: []Options{jsonflags.StringTag | jsonflags.StringifyWithLegacySemantics | 1},
4858 inBuf: `""`,
4859 inVal: new(string),
4860 want: new(string),
4861 wantErr: EU(&jsontext.SyntacticError{Err: io.ErrUnexpectedEOF}).withType('"', stringType),
4862 }, {
4863 name: jsontest.Name("Bytes/Null"),
4864 inBuf: `null`,
4865 inVal: addr([]byte("something")),
4866 want: addr([]byte(nil)),
4867 }, {
4868 name: jsontest.Name("Bytes"),
4869 inBuf: `[null,"","AQ==","AQI=","AQID"]`,
4870 inVal: new([][]byte),
4871 want: addr([][]byte{nil, {}, {1}, {1, 2}, {1, 2, 3}}),
4872 }, {
4873 name: jsontest.Name("Bytes/Large"),
4874 inBuf: `"dGhlIHF1aWNrIGJyb3duIGZveCBqdW1wZWQgb3ZlciB0aGUgbGF6eSBkb2cgYW5kIGF0ZSB0aGUgaG9tZXdvcmsgdGhhdCBJIHNwZW50IHNvIG11Y2ggdGltZSBvbi4="`,
4875 inVal: new([]byte),
4876 want: addr([]byte("the quick brown fox jumped over the lazy dog and ate the homework that I spent so much time on.")),
4877 }, {
4878 name: jsontest.Name("Bytes/Reuse"),
4879 inBuf: `"AQID"`,
4880 inVal: addr([]byte("changed")),
4881 want: addr([]byte{1, 2, 3}),
4882 }, {
4883 name: jsontest.Name("Bytes/Escaped"),
4884 inBuf: `[null,"","\u0041\u0051\u003d\u003d","\u0041\u0051\u0049\u003d","\u0041\u0051\u0049\u0044"]`,
4885 inVal: new([][]byte),
4886 want: addr([][]byte{nil, {}, {1}, {1, 2}, {1, 2, 3}}),
4887 }, {
4888 name: jsontest.Name("Bytes/Named"),
4889 inBuf: `[null,"","AQ==","AQI=","AQID"]`,
4890 inVal: new([]namedBytes),
4891 want: addr([]namedBytes{nil, {}, {1}, {1, 2}, {1, 2, 3}}),
4892 }, {
4893 name: jsontest.Name("Bytes/NotStringified"),
4894 opts: []Options{StringifyNumbers(true)},
4895 inBuf: `[null,"","AQ==","AQI=","AQID"]`,
4896 inVal: new([][]byte),
4897 want: addr([][]byte{nil, {}, {1}, {1, 2}, {1, 2, 3}}),
4898 }, {
4899
4900
4901 name: jsontest.Name("Bytes/Invariant"),
4902 inBuf: `[null,[],[1],[1,2],[1,2,3]]`,
4903 inVal: new([][]namedByte),
4904 want: addr([][]namedByte{nil, {}, {1}, {1, 2}, {1, 2, 3}}),
4905 }, {
4906
4907
4908 name: jsontest.Name("Bytes/ByteArray"),
4909 inBuf: `"aGVsbG8="`,
4910 inVal: new([5]byte),
4911 want: addr([5]byte{'h', 'e', 'l', 'l', 'o'}),
4912 }, {
4913 name: jsontest.Name("Bytes/ByteArray0/Valid"),
4914 inBuf: `""`,
4915 inVal: new([0]byte),
4916 want: addr([0]byte{}),
4917 }, {
4918 name: jsontest.Name("Bytes/ByteArray0/Invalid"),
4919 inBuf: `"A"`,
4920 inVal: new([0]byte),
4921 want: addr([0]byte{}),
4922 wantErr: EU(func() error {
4923 _, err := base64.StdEncoding.Decode(make([]byte, 0), []byte("A"))
4924 return err
4925 }()).withType('"', T[[0]byte]()),
4926 }, {
4927 name: jsontest.Name("Bytes/ByteArray0/Overflow"),
4928 inBuf: `"AA=="`,
4929 inVal: new([0]byte),
4930 want: addr([0]byte{}),
4931 wantErr: EU(errors.New("decoded length of 1 mismatches array length of 0")).withType('"', T[[0]byte]()),
4932 }, {
4933 name: jsontest.Name("Bytes/ByteArray1/Valid"),
4934 inBuf: `"AQ=="`,
4935 inVal: new([1]byte),
4936 want: addr([1]byte{1}),
4937 }, {
4938 name: jsontest.Name("Bytes/ByteArray1/Invalid"),
4939 inBuf: `"$$=="`,
4940 inVal: new([1]byte),
4941 want: addr([1]byte{}),
4942 wantErr: EU(func() error {
4943 _, err := base64.StdEncoding.Decode(make([]byte, 1), []byte("$$=="))
4944 return err
4945 }()).withType('"', T[[1]byte]()),
4946 }, {
4947 name: jsontest.Name("Bytes/ByteArray1/Underflow"),
4948 inBuf: `""`,
4949 inVal: new([1]byte),
4950 want: addr([1]byte{}),
4951 wantErr: EU(errors.New("decoded length of 0 mismatches array length of 1")).withType('"', T[[1]byte]()),
4952 }, {
4953 name: jsontest.Name("Bytes/ByteArray1/Overflow"),
4954 inBuf: `"AQI="`,
4955 inVal: new([1]byte),
4956 want: addr([1]byte{1}),
4957 wantErr: EU(errors.New("decoded length of 2 mismatches array length of 1")).withType('"', T[[1]byte]()),
4958 }, {
4959 name: jsontest.Name("Bytes/ByteArray2/Valid"),
4960 inBuf: `"AQI="`,
4961 inVal: new([2]byte),
4962 want: addr([2]byte{1, 2}),
4963 }, {
4964 name: jsontest.Name("Bytes/ByteArray2/Invalid"),
4965 inBuf: `"$$$="`,
4966 inVal: new([2]byte),
4967 want: addr([2]byte{}),
4968 wantErr: EU(func() error {
4969 _, err := base64.StdEncoding.Decode(make([]byte, 2), []byte("$$$="))
4970 return err
4971 }()).withType('"', T[[2]byte]()),
4972 }, {
4973 name: jsontest.Name("Bytes/ByteArray2/Underflow"),
4974 inBuf: `"AQ=="`,
4975 inVal: new([2]byte),
4976 want: addr([2]byte{1, 0}),
4977 wantErr: EU(errors.New("decoded length of 1 mismatches array length of 2")).withType('"', T[[2]byte]()),
4978 }, {
4979 name: jsontest.Name("Bytes/ByteArray2/Underflow/Allowed"),
4980 opts: []Options{jsonflags.UnmarshalArrayFromAnyLength | 1},
4981 inBuf: `"AQ=="`,
4982 inVal: new([2]byte),
4983 want: addr([2]byte{1, 0}),
4984 }, {
4985 name: jsontest.Name("Bytes/ByteArray2/Overflow"),
4986 inBuf: `"AQID"`,
4987 inVal: new([2]byte),
4988 want: addr([2]byte{1, 2}),
4989 wantErr: EU(errors.New("decoded length of 3 mismatches array length of 2")).withType('"', T[[2]byte]()),
4990 }, {
4991 name: jsontest.Name("Bytes/ByteArray2/Overflow/Allowed"),
4992 opts: []Options{jsonflags.UnmarshalArrayFromAnyLength | 1},
4993 inBuf: `"AQID"`,
4994 inVal: new([2]byte),
4995 want: addr([2]byte{1, 2}),
4996 }, {
4997 name: jsontest.Name("Bytes/ByteArray3/Valid"),
4998 inBuf: `"AQID"`,
4999 inVal: new([3]byte),
5000 want: addr([3]byte{1, 2, 3}),
5001 }, {
5002 name: jsontest.Name("Bytes/ByteArray3/Invalid"),
5003 inBuf: `"$$$$"`,
5004 inVal: new([3]byte),
5005 want: addr([3]byte{}),
5006 wantErr: EU(func() error {
5007 _, err := base64.StdEncoding.Decode(make([]byte, 3), []byte("$$$$"))
5008 return err
5009 }()).withType('"', T[[3]byte]()),
5010 }, {
5011 name: jsontest.Name("Bytes/ByteArray3/Underflow"),
5012 inBuf: `"AQI="`,
5013 inVal: addr([3]byte{0xff, 0xff, 0xff}),
5014 want: addr([3]byte{1, 2, 0}),
5015 wantErr: EU(errors.New("decoded length of 2 mismatches array length of 3")).withType('"', T[[3]byte]()),
5016 }, {
5017 name: jsontest.Name("Bytes/ByteArray3/Overflow"),
5018 inBuf: `"AQIDAQ=="`,
5019 inVal: new([3]byte),
5020 want: addr([3]byte{1, 2, 3}),
5021 wantErr: EU(errors.New("decoded length of 4 mismatches array length of 3")).withType('"', T[[3]byte]()),
5022 }, {
5023 name: jsontest.Name("Bytes/ByteArray4/Valid"),
5024 inBuf: `"AQIDBA=="`,
5025 inVal: new([4]byte),
5026 want: addr([4]byte{1, 2, 3, 4}),
5027 }, {
5028 name: jsontest.Name("Bytes/ByteArray4/Invalid"),
5029 inBuf: `"$$$$$$=="`,
5030 inVal: new([4]byte),
5031 want: addr([4]byte{}),
5032 wantErr: EU(func() error {
5033 _, err := base64.StdEncoding.Decode(make([]byte, 4), []byte("$$$$$$=="))
5034 return err
5035 }()).withType('"', T[[4]byte]()),
5036 }, {
5037 name: jsontest.Name("Bytes/ByteArray4/Underflow"),
5038 inBuf: `"AQID"`,
5039 inVal: new([4]byte),
5040 want: addr([4]byte{1, 2, 3, 0}),
5041 wantErr: EU(errors.New("decoded length of 3 mismatches array length of 4")).withType('"', T[[4]byte]()),
5042 }, {
5043 name: jsontest.Name("Bytes/ByteArray4/Overflow"),
5044 inBuf: `"AQIDBAU="`,
5045 inVal: new([4]byte),
5046 want: addr([4]byte{1, 2, 3, 4}),
5047 wantErr: EU(errors.New("decoded length of 5 mismatches array length of 4")).withType('"', T[[4]byte]()),
5048 }, {
5049
5050
5051 name: jsontest.Name("Bytes/NamedByteArray"),
5052 inBuf: `[104,101,108,108,111]`,
5053 inVal: new([5]namedByte),
5054 want: addr([5]namedByte{'h', 'e', 'l', 'l', 'o'}),
5055 }, {
5056 name: jsontest.Name("Bytes/Valid/Denormalized"),
5057 inBuf: `"AR=="`,
5058 inVal: new([]byte),
5059 want: addr([]byte{1}),
5060 }, {
5061 name: jsontest.Name("Bytes/Invalid/Unpadded1"),
5062 inBuf: `"AQ="`,
5063 inVal: addr([]byte("nochange")),
5064 want: addr([]byte("nochange")),
5065 wantErr: EU(func() error {
5066 _, err := base64.StdEncoding.Decode(make([]byte, 0), []byte("AQ="))
5067 return err
5068 }()).withType('"', bytesType),
5069 }, {
5070 name: jsontest.Name("Bytes/Invalid/Unpadded2"),
5071 inBuf: `"AQ"`,
5072 inVal: addr([]byte("nochange")),
5073 want: addr([]byte("nochange")),
5074 wantErr: EU(func() error {
5075 _, err := base64.StdEncoding.Decode(make([]byte, 0), []byte("AQ"))
5076 return err
5077 }()).withType('"', bytesType),
5078 }, {
5079 name: jsontest.Name("Bytes/Invalid/Character"),
5080 inBuf: `"@@@@"`,
5081 inVal: addr([]byte("nochange")),
5082 want: addr([]byte("nochange")),
5083 wantErr: EU(func() error {
5084 _, err := base64.StdEncoding.Decode(make([]byte, 3), []byte("@@@@"))
5085 return err
5086 }()).withType('"', bytesType),
5087 }, {
5088 name: jsontest.Name("Bytes/Invalid/Bool"),
5089 inBuf: `true`,
5090 inVal: addr([]byte("nochange")),
5091 want: addr([]byte("nochange")),
5092 wantErr: EU(nil).withType('t', bytesType),
5093 }, {
5094 name: jsontest.Name("Bytes/Invalid/Number"),
5095 inBuf: `0`,
5096 inVal: addr([]byte("nochange")),
5097 want: addr([]byte("nochange")),
5098 wantErr: EU(nil).withType('0', bytesType),
5099 }, {
5100 name: jsontest.Name("Bytes/Invalid/Object"),
5101 inBuf: `{}`,
5102 inVal: addr([]byte("nochange")),
5103 want: addr([]byte("nochange")),
5104 wantErr: EU(nil).withType('{', bytesType),
5105 }, {
5106 name: jsontest.Name("Bytes/Invalid/Array"),
5107 inBuf: `[]`,
5108 inVal: addr([]byte("nochange")),
5109 want: addr([]byte("nochange")),
5110 wantErr: EU(nil).withType('[', bytesType),
5111 }, {
5112 name: jsontest.Name("Bytes/IgnoreInvalidFormat"),
5113 opts: []Options{invalidFormatOption},
5114 inBuf: `"aGVsbG8="`,
5115 inVal: new([]byte),
5116 want: addr([]byte("hello")),
5117 }, {
5118 name: jsontest.Name("Ints/Null"),
5119 inBuf: `null`,
5120 inVal: addr(int(1)),
5121 want: addr(int(0)),
5122 }, {
5123 name: jsontest.Name("Ints/Int"),
5124 inBuf: `1`,
5125 inVal: addr(int(0)),
5126 want: addr(int(1)),
5127 }, {
5128 name: jsontest.Name("Ints/Int8/MinOverflow"),
5129 inBuf: `-129`,
5130 inVal: addr(int8(-1)),
5131 want: addr(int8(-1)),
5132 wantErr: EU(strconv.ErrRange).withVal(`-129`).withType('0', T[int8]()),
5133 }, {
5134 name: jsontest.Name("Ints/Int8/Min"),
5135 inBuf: `-128`,
5136 inVal: addr(int8(0)),
5137 want: addr(int8(-128)),
5138 }, {
5139 name: jsontest.Name("Ints/Int8/Max"),
5140 inBuf: `127`,
5141 inVal: addr(int8(0)),
5142 want: addr(int8(127)),
5143 }, {
5144 name: jsontest.Name("Ints/Int8/MaxOverflow"),
5145 inBuf: `128`,
5146 inVal: addr(int8(-1)),
5147 want: addr(int8(-1)),
5148 wantErr: EU(strconv.ErrRange).withVal(`128`).withType('0', T[int8]()),
5149 }, {
5150 name: jsontest.Name("Ints/Int16/MinOverflow"),
5151 inBuf: `-32769`,
5152 inVal: addr(int16(-1)),
5153 want: addr(int16(-1)),
5154 wantErr: EU(strconv.ErrRange).withVal(`-32769`).withType('0', T[int16]()),
5155 }, {
5156 name: jsontest.Name("Ints/Int16/Min"),
5157 inBuf: `-32768`,
5158 inVal: addr(int16(0)),
5159 want: addr(int16(-32768)),
5160 }, {
5161 name: jsontest.Name("Ints/Int16/Max"),
5162 inBuf: `32767`,
5163 inVal: addr(int16(0)),
5164 want: addr(int16(32767)),
5165 }, {
5166 name: jsontest.Name("Ints/Int16/MaxOverflow"),
5167 inBuf: `32768`,
5168 inVal: addr(int16(-1)),
5169 want: addr(int16(-1)),
5170 wantErr: EU(strconv.ErrRange).withVal(`32768`).withType('0', T[int16]()),
5171 }, {
5172 name: jsontest.Name("Ints/Int32/MinOverflow"),
5173 inBuf: `-2147483649`,
5174 inVal: addr(int32(-1)),
5175 want: addr(int32(-1)),
5176 wantErr: EU(strconv.ErrRange).withVal(`-2147483649`).withType('0', T[int32]()),
5177 }, {
5178 name: jsontest.Name("Ints/Int32/Min"),
5179 inBuf: `-2147483648`,
5180 inVal: addr(int32(0)),
5181 want: addr(int32(-2147483648)),
5182 }, {
5183 name: jsontest.Name("Ints/Int32/Max"),
5184 inBuf: `2147483647`,
5185 inVal: addr(int32(0)),
5186 want: addr(int32(2147483647)),
5187 }, {
5188 name: jsontest.Name("Ints/Int32/MaxOverflow"),
5189 inBuf: `2147483648`,
5190 inVal: addr(int32(-1)),
5191 want: addr(int32(-1)),
5192 wantErr: EU(strconv.ErrRange).withVal(`2147483648`).withType('0', T[int32]()),
5193 }, {
5194 name: jsontest.Name("Ints/Int64/MinOverflow"),
5195 inBuf: `-9223372036854775809`,
5196 inVal: addr(int64(-1)),
5197 want: addr(int64(-1)),
5198 wantErr: EU(strconv.ErrRange).withVal(`-9223372036854775809`).withType('0', T[int64]()),
5199 }, {
5200 name: jsontest.Name("Ints/Int64/Min"),
5201 inBuf: `-9223372036854775808`,
5202 inVal: addr(int64(0)),
5203 want: addr(int64(-9223372036854775808)),
5204 }, {
5205 name: jsontest.Name("Ints/Int64/Max"),
5206 inBuf: `9223372036854775807`,
5207 inVal: addr(int64(0)),
5208 want: addr(int64(9223372036854775807)),
5209 }, {
5210 name: jsontest.Name("Ints/Int64/MaxOverflow"),
5211 inBuf: `9223372036854775808`,
5212 inVal: addr(int64(-1)),
5213 want: addr(int64(-1)),
5214 wantErr: EU(strconv.ErrRange).withVal(`9223372036854775808`).withType('0', T[int64]()),
5215 }, {
5216 name: jsontest.Name("Ints/Named"),
5217 inBuf: `-6464`,
5218 inVal: addr(namedInt64(0)),
5219 want: addr(namedInt64(-6464)),
5220 }, {
5221 name: jsontest.Name("Ints/Stringified"),
5222 opts: []Options{StringifyNumbers(true)},
5223 inBuf: `"-6464"`,
5224 inVal: new(int),
5225 want: addr(int(-6464)),
5226 }, {
5227 name: jsontest.Name("Ints/Stringified/Invalid"),
5228 opts: []Options{StringifyNumbers(true)},
5229 inBuf: `-6464`,
5230 inVal: new(int),
5231 want: new(int),
5232 wantErr: EU(nil).withType('0', T[int]()),
5233 }, {
5234 name: jsontest.Name("Ints/Stringified/LeadingZero"),
5235 opts: []Options{StringifyNumbers(true)},
5236 inBuf: `"00"`,
5237 inVal: addr(int(-1)),
5238 want: addr(int(-1)),
5239 wantErr: EU(strconv.ErrSyntax).withVal(`"00"`).withType('"', T[int]()),
5240 }, {
5241 name: jsontest.Name("Ints/Escaped"),
5242 opts: []Options{StringifyNumbers(true)},
5243 inBuf: `"\u002d\u0036\u0034\u0036\u0034"`,
5244 inVal: new(int),
5245 want: addr(int(-6464)),
5246 }, {
5247 name: jsontest.Name("Ints/Valid/NegativeZero"),
5248 inBuf: `-0`,
5249 inVal: addr(int(1)),
5250 want: addr(int(0)),
5251 }, {
5252 name: jsontest.Name("Ints/Invalid/Fraction"),
5253 inBuf: `1.0`,
5254 inVal: addr(int(-1)),
5255 want: addr(int(-1)),
5256 wantErr: EU(strconv.ErrSyntax).withVal(`1.0`).withType('0', T[int]()),
5257 }, {
5258 name: jsontest.Name("Ints/Invalid/Exponent"),
5259 inBuf: `1e0`,
5260 inVal: addr(int(-1)),
5261 want: addr(int(-1)),
5262 wantErr: EU(strconv.ErrSyntax).withVal(`1e0`).withType('0', T[int]()),
5263 }, {
5264 name: jsontest.Name("Ints/Invalid/StringifiedFraction"),
5265 opts: []Options{StringifyNumbers(true)},
5266 inBuf: `"1.0"`,
5267 inVal: addr(int(-1)),
5268 want: addr(int(-1)),
5269 wantErr: EU(strconv.ErrSyntax).withVal(`"1.0"`).withType('"', T[int]()),
5270 }, {
5271 name: jsontest.Name("Ints/Invalid/StringifiedExponent"),
5272 opts: []Options{StringifyNumbers(true)},
5273 inBuf: `"1e0"`,
5274 inVal: addr(int(-1)),
5275 want: addr(int(-1)),
5276 wantErr: EU(strconv.ErrSyntax).withVal(`"1e0"`).withType('"', T[int]()),
5277 }, {
5278 name: jsontest.Name("Ints/Invalid/Overflow"),
5279 inBuf: `100000000000000000000000000000`,
5280 inVal: addr(int(-1)),
5281 want: addr(int(-1)),
5282 wantErr: EU(strconv.ErrRange).withVal(`100000000000000000000000000000`).withType('0', T[int]()),
5283 }, {
5284 name: jsontest.Name("Ints/Invalid/OverflowSyntax"),
5285 opts: []Options{StringifyNumbers(true)},
5286 inBuf: `"100000000000000000000000000000x"`,
5287 inVal: addr(int(-1)),
5288 want: addr(int(-1)),
5289 wantErr: EU(strconv.ErrSyntax).withVal(`"100000000000000000000000000000x"`).withType('"', T[int]()),
5290 }, {
5291 name: jsontest.Name("Ints/Invalid/Whitespace"),
5292 opts: []Options{StringifyNumbers(true)},
5293 inBuf: `"0 "`,
5294 inVal: addr(int(-1)),
5295 want: addr(int(-1)),
5296 wantErr: EU(strconv.ErrSyntax).withVal(`"0 "`).withType('"', T[int]()),
5297 }, {
5298 name: jsontest.Name("Ints/Invalid/Bool"),
5299 inBuf: `true`,
5300 inVal: addr(int(-1)),
5301 want: addr(int(-1)),
5302 wantErr: EU(nil).withType('t', T[int]()),
5303 }, {
5304 name: jsontest.Name("Ints/Invalid/String"),
5305 inBuf: `"0"`,
5306 inVal: addr(int(-1)),
5307 want: addr(int(-1)),
5308 wantErr: EU(nil).withType('"', T[int]()),
5309 }, {
5310 name: jsontest.Name("Ints/Invalid/Object"),
5311 inBuf: `{}`,
5312 inVal: addr(int(-1)),
5313 want: addr(int(-1)),
5314 wantErr: EU(nil).withType('{', T[int]()),
5315 }, {
5316 name: jsontest.Name("Ints/Invalid/Array"),
5317 inBuf: `[]`,
5318 inVal: addr(int(-1)),
5319 want: addr(int(-1)),
5320 wantErr: EU(nil).withType('[', T[int]()),
5321 }, {
5322 name: jsontest.Name("Ints/IgnoreInvalidFormat"),
5323 opts: []Options{invalidFormatOption},
5324 inBuf: `1`,
5325 inVal: addr(int(0)),
5326 want: addr(int(1)),
5327 }, {
5328 name: jsontest.Name("Uints/Null"),
5329 inBuf: `null`,
5330 inVal: addr(uint(1)),
5331 want: addr(uint(0)),
5332 }, {
5333 name: jsontest.Name("Uints/Uint"),
5334 inBuf: `1`,
5335 inVal: addr(uint(0)),
5336 want: addr(uint(1)),
5337 }, {
5338 name: jsontest.Name("Uints/Uint8/Min"),
5339 inBuf: `0`,
5340 inVal: addr(uint8(1)),
5341 want: addr(uint8(0)),
5342 }, {
5343 name: jsontest.Name("Uints/Uint8/Max"),
5344 inBuf: `255`,
5345 inVal: addr(uint8(0)),
5346 want: addr(uint8(255)),
5347 }, {
5348 name: jsontest.Name("Uints/Uint8/MaxOverflow"),
5349 inBuf: `256`,
5350 inVal: addr(uint8(1)),
5351 want: addr(uint8(1)),
5352 wantErr: EU(strconv.ErrRange).withVal(`256`).withType('0', T[uint8]()),
5353 }, {
5354 name: jsontest.Name("Uints/Uint16/Min"),
5355 inBuf: `0`,
5356 inVal: addr(uint16(1)),
5357 want: addr(uint16(0)),
5358 }, {
5359 name: jsontest.Name("Uints/Uint16/Max"),
5360 inBuf: `65535`,
5361 inVal: addr(uint16(0)),
5362 want: addr(uint16(65535)),
5363 }, {
5364 name: jsontest.Name("Uints/Uint16/MaxOverflow"),
5365 inBuf: `65536`,
5366 inVal: addr(uint16(1)),
5367 want: addr(uint16(1)),
5368 wantErr: EU(strconv.ErrRange).withVal(`65536`).withType('0', T[uint16]()),
5369 }, {
5370 name: jsontest.Name("Uints/Uint32/Min"),
5371 inBuf: `0`,
5372 inVal: addr(uint32(1)),
5373 want: addr(uint32(0)),
5374 }, {
5375 name: jsontest.Name("Uints/Uint32/Max"),
5376 inBuf: `4294967295`,
5377 inVal: addr(uint32(0)),
5378 want: addr(uint32(4294967295)),
5379 }, {
5380 name: jsontest.Name("Uints/Uint32/MaxOverflow"),
5381 inBuf: `4294967296`,
5382 inVal: addr(uint32(1)),
5383 want: addr(uint32(1)),
5384 wantErr: EU(strconv.ErrRange).withVal(`4294967296`).withType('0', T[uint32]()),
5385 }, {
5386 name: jsontest.Name("Uints/Uint64/Min"),
5387 inBuf: `0`,
5388 inVal: addr(uint64(1)),
5389 want: addr(uint64(0)),
5390 }, {
5391 name: jsontest.Name("Uints/Uint64/Max"),
5392 inBuf: `18446744073709551615`,
5393 inVal: addr(uint64(0)),
5394 want: addr(uint64(18446744073709551615)),
5395 }, {
5396 name: jsontest.Name("Uints/Uint64/MaxOverflow"),
5397 inBuf: `18446744073709551616`,
5398 inVal: addr(uint64(1)),
5399 want: addr(uint64(1)),
5400 wantErr: EU(strconv.ErrRange).withVal(`18446744073709551616`).withType('0', T[uint64]()),
5401 }, {
5402 name: jsontest.Name("Uints/Uintptr"),
5403 inBuf: `1`,
5404 inVal: addr(uintptr(0)),
5405 want: addr(uintptr(1)),
5406 }, {
5407 name: jsontest.Name("Uints/Named"),
5408 inBuf: `6464`,
5409 inVal: addr(namedUint64(0)),
5410 want: addr(namedUint64(6464)),
5411 }, {
5412 name: jsontest.Name("Uints/Stringified"),
5413 opts: []Options{StringifyNumbers(true)},
5414 inBuf: `"6464"`,
5415 inVal: new(uint),
5416 want: addr(uint(6464)),
5417 }, {
5418 name: jsontest.Name("Uints/Stringified/Invalid"),
5419 opts: []Options{StringifyNumbers(true)},
5420 inBuf: `6464`,
5421 inVal: new(uint),
5422 want: new(uint),
5423 wantErr: EU(nil).withType('0', T[uint]()),
5424 }, {
5425 name: jsontest.Name("Uints/Stringified/LeadingZero"),
5426 opts: []Options{StringifyNumbers(true)},
5427 inBuf: `"00"`,
5428 inVal: addr(uint(1)),
5429 want: addr(uint(1)),
5430 wantErr: EU(strconv.ErrSyntax).withVal(`"00"`).withType('"', T[uint]()),
5431 }, {
5432 name: jsontest.Name("Uints/Escaped"),
5433 opts: []Options{StringifyNumbers(true)},
5434 inBuf: `"\u0036\u0034\u0036\u0034"`,
5435 inVal: new(uint),
5436 want: addr(uint(6464)),
5437 }, {
5438 name: jsontest.Name("Uints/Invalid/NegativeOne"),
5439 inBuf: `-1`,
5440 inVal: addr(uint(1)),
5441 want: addr(uint(1)),
5442 wantErr: EU(strconv.ErrSyntax).withVal(`-1`).withType('0', T[uint]()),
5443 }, {
5444 name: jsontest.Name("Uints/Invalid/NegativeZero"),
5445 inBuf: `-0`,
5446 inVal: addr(uint(1)),
5447 want: addr(uint(1)),
5448 wantErr: EU(strconv.ErrSyntax).withVal(`-0`).withType('0', T[uint]()),
5449 }, {
5450 name: jsontest.Name("Uints/Invalid/Fraction"),
5451 inBuf: `1.0`,
5452 inVal: addr(uint(10)),
5453 want: addr(uint(10)),
5454 wantErr: EU(strconv.ErrSyntax).withVal(`1.0`).withType('0', T[uint]()),
5455 }, {
5456 name: jsontest.Name("Uints/Invalid/Exponent"),
5457 inBuf: `1e0`,
5458 inVal: addr(uint(10)),
5459 want: addr(uint(10)),
5460 wantErr: EU(strconv.ErrSyntax).withVal(`1e0`).withType('0', T[uint]()),
5461 }, {
5462 name: jsontest.Name("Uints/Invalid/StringifiedFraction"),
5463 opts: []Options{StringifyNumbers(true)},
5464 inBuf: `"1.0"`,
5465 inVal: addr(uint(10)),
5466 want: addr(uint(10)),
5467 wantErr: EU(strconv.ErrSyntax).withVal(`"1.0"`).withType('"', T[uint]()),
5468 }, {
5469 name: jsontest.Name("Uints/Invalid/StringifiedExponent"),
5470 opts: []Options{StringifyNumbers(true)},
5471 inBuf: `"1e0"`,
5472 inVal: addr(uint(10)),
5473 want: addr(uint(10)),
5474 wantErr: EU(strconv.ErrSyntax).withVal(`"1e0"`).withType('"', T[uint]()),
5475 }, {
5476 name: jsontest.Name("Uints/Invalid/Overflow"),
5477 inBuf: `100000000000000000000000000000`,
5478 inVal: addr(uint(1)),
5479 want: addr(uint(1)),
5480 wantErr: EU(strconv.ErrRange).withVal(`100000000000000000000000000000`).withType('0', T[uint]()),
5481 }, {
5482 name: jsontest.Name("Uints/Invalid/OverflowSyntax"),
5483 opts: []Options{StringifyNumbers(true)},
5484 inBuf: `"100000000000000000000000000000x"`,
5485 inVal: addr(uint(1)),
5486 want: addr(uint(1)),
5487 wantErr: EU(strconv.ErrSyntax).withVal(`"100000000000000000000000000000x"`).withType('"', T[uint]()),
5488 }, {
5489 name: jsontest.Name("Uints/Invalid/Whitespace"),
5490 opts: []Options{StringifyNumbers(true)},
5491 inBuf: `"0 "`,
5492 inVal: addr(uint(1)),
5493 want: addr(uint(1)),
5494 wantErr: EU(strconv.ErrSyntax).withVal(`"0 "`).withType('"', T[uint]()),
5495 }, {
5496 name: jsontest.Name("Uints/Invalid/Bool"),
5497 inBuf: `true`,
5498 inVal: addr(uint(1)),
5499 want: addr(uint(1)),
5500 wantErr: EU(nil).withType('t', T[uint]()),
5501 }, {
5502 name: jsontest.Name("Uints/Invalid/String"),
5503 inBuf: `"0"`,
5504 inVal: addr(uint(1)),
5505 want: addr(uint(1)),
5506 wantErr: EU(nil).withType('"', T[uint]()),
5507 }, {
5508 name: jsontest.Name("Uints/Invalid/Object"),
5509 inBuf: `{}`,
5510 inVal: addr(uint(1)),
5511 want: addr(uint(1)),
5512 wantErr: EU(nil).withType('{', T[uint]()),
5513 }, {
5514 name: jsontest.Name("Uints/Invalid/Array"),
5515 inBuf: `[]`,
5516 inVal: addr(uint(1)),
5517 want: addr(uint(1)),
5518 wantErr: EU(nil).withType('[', T[uint]()),
5519 }, {
5520 name: jsontest.Name("Uints/IgnoreInvalidFormat"),
5521 opts: []Options{invalidFormatOption},
5522 inBuf: `1`,
5523 inVal: addr(uint(0)),
5524 want: addr(uint(1)),
5525 }, {
5526 name: jsontest.Name("Floats/Null"),
5527 inBuf: `null`,
5528 inVal: addr(float64(64.64)),
5529 want: addr(float64(0)),
5530 }, {
5531 name: jsontest.Name("Floats/Float32/Pi"),
5532 inBuf: `3.14159265358979323846264338327950288419716939937510582097494459`,
5533 inVal: addr(float32(32.32)),
5534 want: addr(float32(math.Pi)),
5535 }, {
5536 name: jsontest.Name("Floats/Float32/Underflow"),
5537 inBuf: `1e-1000`,
5538 inVal: addr(float32(32.32)),
5539 want: addr(float32(0)),
5540 }, {
5541 name: jsontest.Name("Floats/Float32/Overflow"),
5542 inBuf: `-1e1000`,
5543 inVal: addr(float32(32.32)),
5544 want: addr(float32(32.32)),
5545 wantErr: EU(strconv.ErrRange).withVal(`-1e1000`).withType('0', T[float32]()),
5546 }, {
5547 name: jsontest.Name("Floats/Float64/Pi"),
5548 inBuf: `3.14159265358979323846264338327950288419716939937510582097494459`,
5549 inVal: addr(float64(64.64)),
5550 want: addr(float64(math.Pi)),
5551 }, {
5552 name: jsontest.Name("Floats/Float64/Underflow"),
5553 inBuf: `1e-1000`,
5554 inVal: addr(float64(64.64)),
5555 want: addr(float64(0)),
5556 }, {
5557 name: jsontest.Name("Floats/Float64/Overflow"),
5558 inBuf: `-1e1000`,
5559 inVal: addr(float64(64.64)),
5560 want: addr(float64(64.64)),
5561 wantErr: EU(strconv.ErrRange).withVal(`-1e1000`).withType('0', T[float64]()),
5562 }, {
5563 name: jsontest.Name("Floats/Any/Overflow"),
5564 inBuf: `1e1000`,
5565 inVal: new(any),
5566 want: addr(any(float64(0))),
5567 wantErr: EU(strconv.ErrRange).withVal(`1e1000`).withType('0', T[float64]()),
5568 }, {
5569 name: jsontest.Name("Floats/Any/ExistingFloat32/Overflow"),
5570 inBuf: `1e1000`,
5571 inVal: addr(any(float32(32.32))),
5572 want: addr(any(float32(32.32))),
5573 wantErr: EU(strconv.ErrRange).withVal(`1e1000`).withType('0', T[float32]()),
5574 }, {
5575 name: jsontest.Name("Floats/Any/ExistingFloat64/Overflow"),
5576 inBuf: `1e1000`,
5577 inVal: addr(any(float64(64.64))),
5578 want: addr(any(float64(64.64))),
5579 wantErr: EU(strconv.ErrRange).withVal(`1e1000`).withType('0', T[float64]()),
5580 }, {
5581 name: jsontest.Name("Floats/Named"),
5582 inBuf: `64.64`,
5583 inVal: addr(namedFloat64(0)),
5584 want: addr(namedFloat64(64.64)),
5585 }, {
5586 name: jsontest.Name("Floats/Stringified"),
5587 opts: []Options{StringifyNumbers(true)},
5588 inBuf: `"64.64"`,
5589 inVal: new(float64),
5590 want: addr(float64(64.64)),
5591 }, {
5592 name: jsontest.Name("Floats/Stringified/Invalid"),
5593 opts: []Options{StringifyNumbers(true)},
5594 inBuf: `64.64`,
5595 inVal: new(float64),
5596 want: new(float64),
5597 wantErr: EU(nil).withType('0', T[float64]()),
5598 }, {
5599 name: jsontest.Name("Floats/Escaped"),
5600 opts: []Options{StringifyNumbers(true)},
5601 inBuf: `"\u0036\u0034\u002e\u0036\u0034"`,
5602 inVal: new(float64),
5603 want: addr(float64(64.64)),
5604 }, {
5605 name: jsontest.Name("Floats/Invalid/NaN"),
5606 opts: []Options{StringifyNumbers(true)},
5607 inBuf: `"NaN"`,
5608 inVal: addr(float64(64.64)),
5609 want: addr(float64(64.64)),
5610 wantErr: EU(strconv.ErrSyntax).withVal(`"NaN"`).withType('"', float64Type),
5611 }, {
5612 name: jsontest.Name("Floats/Invalid/Infinity"),
5613 opts: []Options{StringifyNumbers(true)},
5614 inBuf: `"Infinity"`,
5615 inVal: addr(float64(64.64)),
5616 want: addr(float64(64.64)),
5617 wantErr: EU(strconv.ErrSyntax).withVal(`"Infinity"`).withType('"', float64Type),
5618 }, {
5619 name: jsontest.Name("Floats/Invalid/Whitespace"),
5620 opts: []Options{StringifyNumbers(true)},
5621 inBuf: `"1 "`,
5622 inVal: addr(float64(64.64)),
5623 want: addr(float64(64.64)),
5624 wantErr: EU(strconv.ErrSyntax).withVal(`"1 "`).withType('"', float64Type),
5625 }, {
5626 name: jsontest.Name("Floats/Invalid/GoSyntax"),
5627 opts: []Options{StringifyNumbers(true)},
5628 inBuf: `"1p-2"`,
5629 inVal: addr(float64(64.64)),
5630 want: addr(float64(64.64)),
5631 wantErr: EU(strconv.ErrSyntax).withVal(`"1p-2"`).withType('"', float64Type),
5632 }, {
5633 name: jsontest.Name("Floats/Invalid/Bool"),
5634 inBuf: `true`,
5635 inVal: addr(float64(64.64)),
5636 want: addr(float64(64.64)),
5637 wantErr: EU(nil).withType('t', float64Type),
5638 }, {
5639 name: jsontest.Name("Floats/Invalid/String"),
5640 inBuf: `"0"`,
5641 inVal: addr(float64(64.64)),
5642 want: addr(float64(64.64)),
5643 wantErr: EU(nil).withType('"', float64Type),
5644 }, {
5645 name: jsontest.Name("Floats/Invalid/Object"),
5646 inBuf: `{}`,
5647 inVal: addr(float64(64.64)),
5648 want: addr(float64(64.64)),
5649 wantErr: EU(nil).withType('{', float64Type),
5650 }, {
5651 name: jsontest.Name("Floats/Invalid/Array"),
5652 inBuf: `[]`,
5653 inVal: addr(float64(64.64)),
5654 want: addr(float64(64.64)),
5655 wantErr: EU(nil).withType('[', float64Type),
5656 }, {
5657 name: jsontest.Name("Floats/IgnoreInvalidFormat"),
5658 opts: []Options{invalidFormatOption},
5659 inBuf: `1`,
5660 inVal: addr(float64(0)),
5661 want: addr(float64(1)),
5662 }, {
5663 name: jsontest.Name("Maps/Null"),
5664 inBuf: `null`,
5665 inVal: addr(map[string]string{"key": "value"}),
5666 want: new(map[string]string),
5667 }, {
5668 name: jsontest.Name("Maps/InvalidKey/Bool"),
5669 inBuf: `{"true":"false"}`,
5670 inVal: new(map[bool]bool),
5671 want: addr(make(map[bool]bool)),
5672 wantErr: EU(nil).withPos(`{`, "/true").withType('"', boolType),
5673 }, {
5674 name: jsontest.Name("Maps/InvalidKey/NamedBool"),
5675 inBuf: `{"true":"false"}`,
5676 inVal: new(map[namedBool]bool),
5677 want: addr(make(map[namedBool]bool)),
5678 wantErr: EU(nil).withPos(`{`, "/true").withType('"', T[namedBool]()),
5679 }, {
5680 name: jsontest.Name("Maps/InvalidKey/Array"),
5681 inBuf: `{"key":"value"}`,
5682 inVal: new(map[[1]string]string),
5683 want: addr(make(map[[1]string]string)),
5684 wantErr: EU(nil).withPos(`{`, "/key").withType('"', T[[1]string]()),
5685 }, {
5686 name: jsontest.Name("Maps/InvalidKey/Channel"),
5687 inBuf: `{"key":"value"}`,
5688 inVal: new(map[chan string]string),
5689 want: addr(make(map[chan string]string)),
5690 wantErr: EU(nil).withPos(`{`, "").withType(0, T[chan string]()),
5691 }, {
5692 name: jsontest.Name("Maps/ValidKey/Int"),
5693 inBuf: `{"0":0,"-1":1,"2":2,"-3":3}`,
5694 inVal: new(map[int]int),
5695 want: addr(map[int]int{0: 0, -1: 1, 2: 2, -3: 3}),
5696 }, {
5697 name: jsontest.Name("Maps/ValidKey/NamedInt"),
5698 inBuf: `{"0":0,"-1":1,"2":2,"-3":3}`,
5699 inVal: new(map[namedInt64]int),
5700 want: addr(map[namedInt64]int{0: 0, -1: 1, 2: 2, -3: 3}),
5701 }, {
5702 name: jsontest.Name("Maps/ValidKey/Uint"),
5703 inBuf: `{"0":0,"1":1,"2":2,"3":3}`,
5704 inVal: new(map[uint]uint),
5705 want: addr(map[uint]uint{0: 0, 1: 1, 2: 2, 3: 3}),
5706 }, {
5707 name: jsontest.Name("Maps/ValidKey/NamedUint"),
5708 inBuf: `{"0":0,"1":1,"2":2,"3":3}`,
5709 inVal: new(map[namedUint64]uint),
5710 want: addr(map[namedUint64]uint{0: 0, 1: 1, 2: 2, 3: 3}),
5711 }, {
5712 name: jsontest.Name("Maps/ValidKey/Float"),
5713 inBuf: `{"1.234":1.234,"12.34":12.34,"123.4":123.4}`,
5714 inVal: new(map[float64]float64),
5715 want: addr(map[float64]float64{1.234: 1.234, 12.34: 12.34, 123.4: 123.4}),
5716 }, {
5717 name: jsontest.Name("Maps/DuplicateName/Int"),
5718 inBuf: `{"0":1,"-0":-1}`,
5719 inVal: new(map[int]int),
5720 want: addr(map[int]int{0: 1}),
5721 wantErr: newDuplicateNameError("", []byte(`"-0"`), len64(`{"0":1,`)),
5722 }, {
5723 name: jsontest.Name("Maps/DuplicateName/Int/MergeWithLegacySemantics"),
5724 opts: []Options{jsonflags.MergeWithLegacySemantics | 1},
5725 inBuf: `{"0":1,"-0":-1}`,
5726 inVal: new(map[int]int),
5727 want: addr(map[int]int{0: 1}),
5728 wantErr: newDuplicateNameError("", []byte(`"-0"`), len64(`{"0":1,`)),
5729 }, {
5730 name: jsontest.Name("Maps/DuplicateName/Int/AllowDuplicateNames"),
5731 opts: []Options{jsontext.AllowDuplicateNames(true)},
5732 inBuf: `{"0":1,"-0":-1}`,
5733 inVal: new(map[int]int),
5734 want: addr(map[int]int{0: -1}),
5735 }, {
5736 name: jsontest.Name("Maps/DuplicateName/Int/OverwriteExisting"),
5737 inBuf: `{"-0":-1}`,
5738 inVal: addr(map[int]int{0: 1}),
5739 want: addr(map[int]int{0: -1}),
5740 }, {
5741 name: jsontest.Name("Maps/DuplicateName/Float"),
5742 inBuf: `{"1.0":"1.0","1":"1","1e0":"1e0"}`,
5743 inVal: new(map[float64]string),
5744 want: addr(map[float64]string{1: "1.0"}),
5745 wantErr: newDuplicateNameError("", []byte(`"1"`), len64(`{"1.0":"1.0",`)),
5746 }, {
5747 name: jsontest.Name("Maps/DuplicateName/Float/AllowDuplicateNames"),
5748 opts: []Options{jsontext.AllowDuplicateNames(true)},
5749 inBuf: `{"1.0":"1.0","1":"1","1e0":"1e0"}`,
5750 inVal: new(map[float64]string),
5751 want: addr(map[float64]string{1: "1e0"}),
5752 }, {
5753 name: jsontest.Name("Maps/DuplicateName/Float/OverwriteExisting"),
5754 inBuf: `{"1.0":"1.0"}`,
5755 inVal: addr(map[float64]string{1: "1"}),
5756 want: addr(map[float64]string{1: "1.0"}),
5757 }, {
5758 name: jsontest.Name("Maps/DuplicateName/NoCaseString"),
5759 inBuf: `{"hello":"hello","HELLO":"HELLO"}`,
5760 inVal: new(map[nocaseString]string),
5761 want: addr(map[nocaseString]string{"hello": "hello"}),
5762 wantErr: newDuplicateNameError("", []byte(`"HELLO"`), len64(`{"hello":"hello",`)),
5763 }, {
5764 name: jsontest.Name("Maps/DuplicateName/NoCaseString/AllowDuplicateNames"),
5765 opts: []Options{jsontext.AllowDuplicateNames(true)},
5766 inBuf: `{"hello":"hello","HELLO":"HELLO"}`,
5767 inVal: new(map[nocaseString]string),
5768 want: addr(map[nocaseString]string{"hello": "HELLO"}),
5769 }, {
5770 name: jsontest.Name("Maps/DuplicateName/NoCaseString/OverwriteExisting"),
5771 opts: []Options{jsontext.AllowDuplicateNames(true)},
5772 inBuf: `{"HELLO":"HELLO"}`,
5773 inVal: addr(map[nocaseString]string{"hello": "hello"}),
5774 want: addr(map[nocaseString]string{"hello": "HELLO"}),
5775 }, {
5776 name: jsontest.Name("Maps/ValidKey/Interface"),
5777 inBuf: `{"false":"false","true":"true","string":"string","0":"0","[]":"[]","{}":"{}"}`,
5778 inVal: new(map[any]string),
5779 want: addr(map[any]string{
5780 "false": "false",
5781 "true": "true",
5782 "string": "string",
5783 "0": "0",
5784 "[]": "[]",
5785 "{}": "{}",
5786 }),
5787 }, {
5788 name: jsontest.Name("Maps/InvalidValue/Channel"),
5789 inBuf: `{"key":"value"}`,
5790 inVal: new(map[string]chan string),
5791 want: addr(map[string]chan string{
5792 "key": nil,
5793 }),
5794 wantErr: EU(nil).withPos(`{"key":`, "/key").withType(0, T[chan string]()),
5795 }, {
5796 name: jsontest.Name("Maps/RecursiveMap"),
5797 inBuf: `{"buzz":{},"fizz":{"bar":{},"foo":{}}}`,
5798 inVal: new(recursiveMap),
5799 want: addr(recursiveMap{
5800 "fizz": {
5801 "foo": {},
5802 "bar": {},
5803 },
5804 "buzz": {},
5805 }),
5806 }, {
5807
5808
5809
5810 name: jsontest.Name("Maps/Merge"),
5811 opts: []Options{jsontext.AllowDuplicateNames(true)},
5812 inBuf: `{"k1":{"k2":"v2"},"k2":{"k1":"v1"},"k2":{"k2":"v2"}}`,
5813 inVal: addr(map[string]map[string]string{
5814 "k1": {"k1": "v1"},
5815 }),
5816 want: addr(map[string]map[string]string{
5817 "k1": {"k1": "v1", "k2": "v2"},
5818 "k2": {"k1": "v1", "k2": "v2"},
5819 }),
5820 }, {
5821 name: jsontest.Name("Maps/Invalid/Bool"),
5822 inBuf: `true`,
5823 inVal: addr(map[string]string{"key": "value"}),
5824 want: addr(map[string]string{"key": "value"}),
5825 wantErr: EU(nil).withType('t', T[map[string]string]()),
5826 }, {
5827 name: jsontest.Name("Maps/Invalid/String"),
5828 inBuf: `""`,
5829 inVal: addr(map[string]string{"key": "value"}),
5830 want: addr(map[string]string{"key": "value"}),
5831 wantErr: EU(nil).withType('"', T[map[string]string]()),
5832 }, {
5833 name: jsontest.Name("Maps/Invalid/Number"),
5834 inBuf: `0`,
5835 inVal: addr(map[string]string{"key": "value"}),
5836 want: addr(map[string]string{"key": "value"}),
5837 wantErr: EU(nil).withType('0', T[map[string]string]()),
5838 }, {
5839 name: jsontest.Name("Maps/Invalid/Array"),
5840 inBuf: `[]`,
5841 inVal: addr(map[string]string{"key": "value"}),
5842 want: addr(map[string]string{"key": "value"}),
5843 wantErr: EU(nil).withType('[', T[map[string]string]()),
5844 }, {
5845 name: jsontest.Name("Maps/IgnoreInvalidFormat"),
5846 opts: []Options{invalidFormatOption},
5847 inBuf: `{"hello":"goodbye"}`,
5848 inVal: addr(map[string]string{}),
5849 want: addr(map[string]string{"hello": "goodbye"}),
5850 }, {
5851 name: jsontest.Name("Structs/Null"),
5852 inBuf: `null`,
5853 inVal: addr(structAll{String: "something"}),
5854 want: addr(structAll{}),
5855 }, {
5856 name: jsontest.Name("Structs/Empty"),
5857 inBuf: `{}`,
5858 inVal: addr(structAll{
5859 String: "hello",
5860 Map: map[string]string{},
5861 Slice: []string{},
5862 }),
5863 want: addr(structAll{
5864 String: "hello",
5865 Map: map[string]string{},
5866 Slice: []string{},
5867 }),
5868 }, {
5869 name: jsontest.Name("Structs/Normal"),
5870 inBuf: `{
5871 "Bool": true,
5872 "String": "hello",
5873 "Bytes": "AQID",
5874 "Int": -64,
5875 "Uint": 64,
5876 "Float": 3.14159,
5877 "Map": {"key": "value"},
5878 "StructScalars": {
5879 "Bool": true,
5880 "String": "hello",
5881 "Bytes": "AQID",
5882 "Int": -64,
5883 "Uint": 64,
5884 "Float": 3.14159
5885 },
5886 "StructMaps": {
5887 "MapBool": {"": true},
5888 "MapString": {"": "hello"},
5889 "MapBytes": {"": "AQID"},
5890 "MapInt": {"": -64},
5891 "MapUint": {"": 64},
5892 "MapFloat": {"": 3.14159}
5893 },
5894 "StructSlices": {
5895 "SliceBool": [true],
5896 "SliceString": ["hello"],
5897 "SliceBytes": ["AQID"],
5898 "SliceInt": [-64],
5899 "SliceUint": [64],
5900 "SliceFloat": [3.14159]
5901 },
5902 "Slice": ["fizz","buzz"],
5903 "Array": ["goodbye"],
5904 "Pointer": {},
5905 "Interface": null
5906 }`,
5907 inVal: new(structAll),
5908 want: addr(structAll{
5909 Bool: true,
5910 String: "hello",
5911 Bytes: []byte{1, 2, 3},
5912 Int: -64,
5913 Uint: +64,
5914 Float: 3.14159,
5915 Map: map[string]string{"key": "value"},
5916 StructScalars: structScalars{
5917 Bool: true,
5918 String: "hello",
5919 Bytes: []byte{1, 2, 3},
5920 Int: -64,
5921 Uint: +64,
5922 Float: 3.14159,
5923 },
5924 StructMaps: structMaps{
5925 MapBool: map[string]bool{"": true},
5926 MapString: map[string]string{"": "hello"},
5927 MapBytes: map[string][]byte{"": {1, 2, 3}},
5928 MapInt: map[string]int64{"": -64},
5929 MapUint: map[string]uint64{"": +64},
5930 MapFloat: map[string]float64{"": 3.14159},
5931 },
5932 StructSlices: structSlices{
5933 SliceBool: []bool{true},
5934 SliceString: []string{"hello"},
5935 SliceBytes: [][]byte{{1, 2, 3}},
5936 SliceInt: []int64{-64},
5937 SliceUint: []uint64{+64},
5938 SliceFloat: []float64{3.14159},
5939 },
5940 Slice: []string{"fizz", "buzz"},
5941 Array: [1]string{"goodbye"},
5942 Pointer: new(structAll),
5943 }),
5944 }, {
5945 name: jsontest.Name("Structs/Merge"),
5946 inBuf: `{
5947 "Bool": false,
5948 "String": "goodbye",
5949 "Int": -64,
5950 "Float": 3.14159,
5951 "Map": {"k2": "v2"},
5952 "StructScalars": {
5953 "Bool": true,
5954 "String": "hello",
5955 "Bytes": "AQID",
5956 "Int": -64
5957 },
5958 "StructMaps": {
5959 "MapBool": {"": true},
5960 "MapString": {"": "hello"},
5961 "MapBytes": {"": "AQID"},
5962 "MapInt": {"": -64},
5963 "MapUint": {"": 64},
5964 "MapFloat": {"": 3.14159}
5965 },
5966 "StructSlices": {
5967 "SliceString": ["hello"],
5968 "SliceBytes": ["AQID"],
5969 "SliceInt": [-64],
5970 "SliceUint": [64]
5971 },
5972 "Slice": ["fizz","buzz"],
5973 "Array": ["goodbye"],
5974 "Pointer": {},
5975 "Interface": {"k2":"v2"}
5976 }`,
5977 inVal: addr(structAll{
5978 Bool: true,
5979 String: "hello",
5980 Bytes: []byte{1, 2, 3},
5981 Uint: +64,
5982 Float: math.NaN(),
5983 Map: map[string]string{"k1": "v1"},
5984 StructScalars: structScalars{
5985 String: "hello",
5986 Bytes: make([]byte, 2, 4),
5987 Uint: +64,
5988 Float: 3.14159,
5989 },
5990 StructMaps: structMaps{
5991 MapBool: map[string]bool{"": false},
5992 MapBytes: map[string][]byte{"": {}},
5993 MapInt: map[string]int64{"": 123},
5994 MapFloat: map[string]float64{"": math.Inf(+1)},
5995 },
5996 StructSlices: structSlices{
5997 SliceBool: []bool{true},
5998 SliceBytes: [][]byte{nil, nil},
5999 SliceInt: []int64{-123},
6000 SliceUint: []uint64{+123},
6001 SliceFloat: []float64{3.14159},
6002 },
6003 Slice: []string{"buzz", "fizz", "gizz"},
6004 Array: [1]string{"hello"},
6005 Pointer: new(structAll),
6006 Interface: map[string]string{"k1": "v1"},
6007 }),
6008 want: addr(structAll{
6009 Bool: false,
6010 String: "goodbye",
6011 Bytes: []byte{1, 2, 3},
6012 Int: -64,
6013 Uint: +64,
6014 Float: 3.14159,
6015 Map: map[string]string{"k1": "v1", "k2": "v2"},
6016 StructScalars: structScalars{
6017 Bool: true,
6018 String: "hello",
6019 Bytes: []byte{1, 2, 3},
6020 Int: -64,
6021 Uint: +64,
6022 Float: 3.14159,
6023 },
6024 StructMaps: structMaps{
6025 MapBool: map[string]bool{"": true},
6026 MapString: map[string]string{"": "hello"},
6027 MapBytes: map[string][]byte{"": {1, 2, 3}},
6028 MapInt: map[string]int64{"": -64},
6029 MapUint: map[string]uint64{"": +64},
6030 MapFloat: map[string]float64{"": 3.14159},
6031 },
6032 StructSlices: structSlices{
6033 SliceBool: []bool{true},
6034 SliceString: []string{"hello"},
6035 SliceBytes: [][]byte{{1, 2, 3}},
6036 SliceInt: []int64{-64},
6037 SliceUint: []uint64{+64},
6038 SliceFloat: []float64{3.14159},
6039 },
6040 Slice: []string{"fizz", "buzz"},
6041 Array: [1]string{"goodbye"},
6042 Pointer: new(structAll),
6043 Interface: map[string]string{"k1": "v1", "k2": "v2"},
6044 }),
6045 }, {
6046 name: jsontest.Name("Structs/Stringified"),
6047 inBuf: `{
6048 "Int": "-64",
6049 "Uint": "64",
6050 "Float": "3.14159",
6051 "PointerInt": "-64",
6052 "PointerUint": "64",
6053 "PointerFloat": "3.14159"
6054 }`,
6055 inVal: new(structStringified),
6056 want: addr(structStringified{
6057 Int: -64,
6058 Uint: +64,
6059 Float: 3.14159,
6060 PointerInt: new(int64(-64)),
6061 PointerUint: new(uint64(+64)),
6062 PointerFloat: new(float64(3.14159)),
6063 }),
6064 }, {
6065 name: jsontest.Name("Structs/Stringified/Invalid/EmptyIntString"),
6066 inBuf: `{"Int":""}`,
6067 inVal: new(structStringified),
6068 want: new(structStringified),
6069 wantErr: EU(strconv.ErrSyntax).withVal(`""`).withPos(`{"Int":`, "/Int").withType('"', T[int64]()),
6070 }, {
6071 name: jsontest.Name("Structs/Stringified/Invalid/Bool"),
6072 inBuf: `{"Bool": "true"}`,
6073 inVal: new(structStringifiedBool),
6074 want: new(structStringifiedBool),
6075 wantErr: EU(errInvalidStringTag).withPos(`{"Bool": `, "/Bool").withType(0, T[bool]()),
6076 }, {
6077 name: jsontest.Name("Structs/Stringified/Ignored/Bool"),
6078 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
6079 inBuf: `{"Bool": true}`,
6080 inVal: new(structStringifiedBool),
6081 want: new(structStringifiedBool{Bool: true}),
6082 }, {
6083 name: jsontest.Name("Structs/Stringified/Invalid/String"),
6084 inBuf: `{"String": "\"hello\""}`,
6085 inVal: new(structStringifiedString),
6086 want: new(structStringifiedString),
6087 wantErr: EU(errInvalidStringTag).withPos(`{"String": `, "/String").withType(0, T[string]()),
6088 }, {
6089 name: jsontest.Name("Structs/Stringified/Ignored/String"),
6090 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
6091 inBuf: `{"String": "\"hello\""}`,
6092 inVal: new(structStringifiedString),
6093 want: new(structStringifiedString{String: `"hello"`}),
6094 }, {
6095 name: jsontest.Name("Structs/Stringified/Invalid/Bytes"),
6096 inBuf: `{"Bytes": "AQID"}`,
6097 inVal: new(structStringifiedBytes),
6098 want: new(structStringifiedBytes),
6099 wantErr: EU(errInvalidStringTag).withPos(`{"Bytes": `, "/Bytes").withType(0, T[[]byte]()),
6100 }, {
6101 name: jsontest.Name("Structs/Stringified/Ignored/Bytes"),
6102 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
6103 inBuf: `{"Bytes": "AQID"}`,
6104 inVal: new(structStringifiedBytes),
6105 want: new(structStringifiedBytes{Bytes: []byte{1, 2, 3}}),
6106 }, {
6107 name: jsontest.Name("Structs/Stringified/Invalid/Map"),
6108 inBuf: `{"Map": {"Key": "Value"}}`,
6109 inVal: new(structStringifiedMap),
6110 want: new(structStringifiedMap),
6111 wantErr: EU(errInvalidStringTag).withPos(`{"Map": `, "/Map").withType(0, T[map[string]string]()),
6112 }, {
6113 name: jsontest.Name("Structs/Stringified/Ignored/Map"),
6114 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
6115 inBuf: `{"Map": {"Key": "Value"}}`,
6116 inVal: new(structStringifiedMap),
6117 want: new(structStringifiedMap{Map: map[string]string{"Key": "Value"}}),
6118 }, {
6119 name: jsontest.Name("Structs/Stringified/Invalid/Slice"),
6120 inBuf: `{"Slice": ["hello"]}`,
6121 inVal: new(structStringifiedSlice),
6122 want: new(structStringifiedSlice),
6123 wantErr: EU(errInvalidStringTag).withPos(`{"Slice": `, "/Slice").withType(0, T[[]string]()),
6124 }, {
6125 name: jsontest.Name("Structs/Stringified/Ignored/Slice"),
6126 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
6127 inBuf: `{"Slice": ["hello"]}`,
6128 inVal: new(structStringifiedSlice),
6129 want: new(structStringifiedSlice{Slice: []string{"hello"}}),
6130 }, {
6131 name: jsontest.Name("Structs/Stringified/Invalid/Array"),
6132 inBuf: `{"Array": ["hello"]}`,
6133 inVal: new(structStringifiedArray),
6134 want: new(structStringifiedArray),
6135 wantErr: EU(errInvalidStringTag).withPos(`{"Array": `, "/Array").withType(0, T[[1]string]()),
6136 }, {
6137 name: jsontest.Name("Structs/Stringified/Ignored/Array"),
6138 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
6139 inBuf: `{"Array": ["hello"]}`,
6140 inVal: new(structStringifiedArray),
6141 want: new(structStringifiedArray{Array: [1]string{"hello"}}),
6142 }, {
6143 name: jsontest.Name("Structs/Stringified/Invalid/Struct"),
6144 inBuf: `{"Struct": {"Bool": true}}`,
6145 inVal: new(structStringifiedStruct),
6146 want: new(structStringifiedStruct),
6147 wantErr: EU(errInvalidStringTag).withPos(`{"Struct": `, "/Struct").withType(0, T[structAll]()),
6148 }, {
6149 name: jsontest.Name("Structs/Stringified/Ignored/Struct"),
6150 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
6151 inBuf: `{"Struct": {"Bool": true}}`,
6152 inVal: new(structStringifiedStruct),
6153 want: new(structStringifiedStruct{Struct: structAll{Bool: true}}),
6154 }, {
6155 name: jsontest.Name("Structs/Stringified/Invalid/Pointer"),
6156 inBuf: `{"Pointer": {"Bool": true}}`,
6157 inVal: new(structStringifiedPointer),
6158 want: new(structStringifiedPointer{Pointer: new(structAll)}),
6159 wantErr: EU(errInvalidStringTag).withPos(`{"Pointer": `, "/Pointer").withType(0, T[structAll]()),
6160 }, {
6161 name: jsontest.Name("Structs/Stringified/Ignored/Pointer"),
6162 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
6163 inBuf: `{"Pointer": {"Bool": true}}`,
6164 inVal: new(structStringifiedPointer),
6165 want: new(structStringifiedPointer{Pointer: new(structAll{Bool: true})}),
6166 }, {
6167 name: jsontest.Name("Structs/Stringified/PointerPointerInt"),
6168 inBuf: `{"Pointer": "5"}`,
6169 inVal: new(structStringifiedPointerPointerInt),
6170 want: new(structStringifiedPointerPointerInt{Pointer: new(new(5))}),
6171 }, {
6172 name: jsontest.Name("Structs/Stringified/Invalid/Interface"),
6173 inBuf: `{"Interface": null}`,
6174 inVal: new(structStringifiedInterface),
6175 want: new(structStringifiedInterface),
6176 wantErr: EU(errInvalidStringTag).withPos(`{"Interface": `, "/Interface").withType(0, T[any]()),
6177 }, {
6178 name: jsontest.Name("Structs/Stringified/Ignored/Interface"),
6179 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
6180 inBuf: `{"Interface": null}`,
6181 inVal: new(structStringifiedInterface),
6182 want: new(structStringifiedInterface),
6183 }, {
6184 name: jsontest.Name("Structs/LegacyStringified"),
6185 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
6186 inBuf: `{
6187 "Bool": "true",
6188 "String": "\"hello\"",
6189 "Int": "-64",
6190 "Uint": "64",
6191 "Float": "3.14159",
6192 "PointerBool": "true",
6193 "PointerString": "\"hello\"",
6194 "PointerInt": "-64",
6195 "PointerUint": "64",
6196 "PointerFloat": "3.14159"
6197 }`,
6198 inVal: new(structStringifiedLegacy),
6199 want: addr(structStringifiedLegacy{
6200 Bool: true,
6201 String: "hello",
6202 Int: -64,
6203 Uint: +64,
6204 Float: 3.14159,
6205 PointerBool: new(true),
6206 PointerString: new("hello"),
6207 PointerInt: new(int64(-64)),
6208 PointerUint: new(uint64(+64)),
6209 PointerFloat: new(float64(3.14159)),
6210 }),
6211 }, {
6212 name: jsontest.Name("Structs/LegacyStringified/Invalid/EmptyIntString"),
6213 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
6214 inBuf: `{"Int":""}`,
6215 inVal: new(structStringifiedLegacy),
6216 want: new(structStringifiedLegacy),
6217 wantErr: EU(strconv.ErrSyntax).withVal(`""`).withPos(`{"Int":`, "/Int").withType('"', T[int64]()),
6218 }, {
6219 name: jsontest.Name("Structs/LegacyStringified/Invalid/Bool"),
6220 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
6221 inBuf: `{"Bool": true}`,
6222 inVal: new(structStringifiedLegacy),
6223 wantErr: EU(nil).withPos(`{"Bool": `, "/Bool").withType('t', T[bool]()),
6224 }, {
6225 name: jsontest.Name("Structs/LegacyStringified/Invalid/String"),
6226 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
6227 inBuf: `{"String": "string"}`,
6228 inVal: new(structStringifiedLegacy),
6229 wantErr: EU(newInvalidCharacterError("s", "at start of string (expecting '\"')", 0, "")).
6230 withPos(`{"String": `, "/String").withType('"', T[string]()),
6231 }, {
6232 name: jsontest.Name("Structs/LegacyStringified/Invalid/Bytes"),
6233 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
6234 inBuf: `{"Bytes": "AQID"}`,
6235 inVal: new(structStringifiedBytes),
6236 want: new(structStringifiedBytes),
6237 wantErr: EU(errInvalidStringTag).withPos(`{"Bytes": `, "/Bytes").withType(0, T[[]byte]()),
6238 }, {
6239 name: jsontest.Name("Structs/LegacyStringified/Ignored/Bytes"),
6240 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1, jsonflags.ReportErrorsWithLegacySemantics | 1},
6241 inBuf: `{"Bytes": "AQID"}`,
6242 inVal: new(structStringifiedBytes),
6243 want: new(structStringifiedBytes{Bytes: []byte{1, 2, 3}}),
6244 }, {
6245 name: jsontest.Name("Structs/LegacyStringified/Invalid/Map"),
6246 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
6247 inBuf: `{"Map": {"Key": "Value"}}`,
6248 inVal: new(structStringifiedMap),
6249 want: new(structStringifiedMap),
6250 wantErr: EU(errInvalidStringTag).withPos(`{"Map": `, "/Map").withType(0, T[map[string]string]()),
6251 }, {
6252 name: jsontest.Name("Structs/LegacyStringified/Ignored/Map"),
6253 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1, jsonflags.ReportErrorsWithLegacySemantics | 1},
6254 inBuf: `{"Map": {"Key": "Value"}}`,
6255 inVal: new(structStringifiedMap),
6256 want: new(structStringifiedMap{Map: map[string]string{"Key": "Value"}}),
6257 }, {
6258 name: jsontest.Name("Structs/LegacyStringified/Invalid/Slice"),
6259 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
6260 inBuf: `{"Slice": ["hello"]}`,
6261 inVal: new(structStringifiedSlice),
6262 want: new(structStringifiedSlice),
6263 wantErr: EU(errInvalidStringTag).withPos(`{"Slice": `, "/Slice").withType(0, T[[]string]()),
6264 }, {
6265 name: jsontest.Name("Structs/LegacyStringified/Ignored/Slice"),
6266 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1, jsonflags.ReportErrorsWithLegacySemantics | 1},
6267 inBuf: `{"Slice": ["hello"]}`,
6268 inVal: new(structStringifiedSlice),
6269 want: new(structStringifiedSlice{Slice: []string{"hello"}}),
6270 }, {
6271 name: jsontest.Name("Structs/LegacyStringified/Invalid/Array"),
6272 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
6273 inBuf: `{"Array": ["hello"]}`,
6274 inVal: new(structStringifiedArray),
6275 want: new(structStringifiedArray),
6276 wantErr: EU(errInvalidStringTag).withPos(`{"Array": `, "/Array").withType(0, T[[1]string]()),
6277 }, {
6278 name: jsontest.Name("Structs/LegacyStringified/Ignored/Array"),
6279 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1, jsonflags.ReportErrorsWithLegacySemantics | 1},
6280 inBuf: `{"Array": ["hello"]}`,
6281 inVal: new(structStringifiedArray),
6282 want: new(structStringifiedArray{Array: [1]string{"hello"}}),
6283 }, {
6284 name: jsontest.Name("Structs/LegacyStringified/Invalid/Struct"),
6285 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
6286 inBuf: `{"Struct": {"Bool": true}}`,
6287 inVal: new(structStringifiedStruct),
6288 want: new(structStringifiedStruct),
6289 wantErr: EU(errInvalidStringTag).withPos(`{"Struct": `, "/Struct").withType(0, T[structAll]()),
6290 }, {
6291 name: jsontest.Name("Structs/LegacyStringified/Ignored/Struct"),
6292 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1, jsonflags.ReportErrorsWithLegacySemantics | 1},
6293 inBuf: `{"Struct": {"Bool": true}}`,
6294 inVal: new(structStringifiedStruct),
6295 want: new(structStringifiedStruct{Struct: structAll{Bool: true}}),
6296 }, {
6297 name: jsontest.Name("Structs/LegacyStringified/Invalid/Pointer"),
6298 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
6299 inBuf: `{"Pointer": {"Bool": true}}`,
6300 inVal: new(structStringifiedPointer),
6301 want: new(structStringifiedPointer{Pointer: new(structAll)}),
6302 wantErr: EU(errInvalidStringTag).withPos(`{"Pointer": `, "/Pointer").withType(0, T[structAll]()),
6303 }, {
6304 name: jsontest.Name("Structs/LegacyStringified/Ignored/Pointer"),
6305 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1, jsonflags.ReportErrorsWithLegacySemantics | 1},
6306 inBuf: `{"Pointer": {"Bool": true}}`,
6307 inVal: new(structStringifiedPointer),
6308 want: new(structStringifiedPointer{Pointer: new(structAll{Bool: true})}),
6309 }, {
6310 name: jsontest.Name("Structs/Stringified/Invalid/PointerPointerInt"),
6311 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
6312 inBuf: `{"Pointer": 5}`,
6313 inVal: new(structStringifiedPointerPointerInt),
6314 want: new(structStringifiedPointerPointerInt{}),
6315 wantErr: EU(errInvalidStringTag).withPos(`{"Pointer": `, "/Pointer").withType(0, T[**int]()),
6316 }, {
6317 name: jsontest.Name("Structs/Stringified/Ignored/PointerPointerInt"),
6318 opts: []Options{jsonflags.StringifyWithLegacySemantics | jsonflags.ReportErrorsWithLegacySemantics | 1},
6319 inBuf: `{"Pointer": 5}`,
6320 inVal: new(structStringifiedPointerPointerInt),
6321 want: new(structStringifiedPointerPointerInt{Pointer: new(new(5))}),
6322 }, {
6323 name: jsontest.Name("Structs/LegacyStringified/Invalid/Interface"),
6324 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1},
6325 inBuf: `{"Interface": null}`,
6326 inVal: new(structStringifiedInterface),
6327 want: new(structStringifiedInterface),
6328 wantErr: EU(errInvalidStringTag).withPos(`{"Interface": `, "/Interface").withType(0, T[any]()),
6329 }, {
6330 name: jsontest.Name("Structs/LegacyStringified/Ignored/Interface"),
6331 opts: []Options{jsonflags.StringifyWithLegacySemantics | 1, jsonflags.ReportErrorsWithLegacySemantics | 1},
6332 inBuf: `{"Interface": null}`,
6333 inVal: new(structStringifiedInterface),
6334 want: new(structStringifiedInterface),
6335 }, {
6336 name: jsontest.Name("Structs/Format/Bytes/Unsupported"),
6337 inBuf: `{}`,
6338 inVal: new(structFormatBytes),
6339 wantErr: EU(errors.New("Go struct field Base16 has unsupported `format` tag option")).withType('{', T[structFormatBytes]()),
6340 }, {
6341 name: jsontest.Name("Structs/Format/Bytes"),
6342 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6343 inBuf: `{
6344 "Base16": "0123456789abcdef",
6345 "Base32": "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
6346 "Base32Hex": "0123456789ABCDEFGHIJKLMNOPQRSTUV",
6347 "Base64": "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
6348 "Base64URL": "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
6349 "Array": [1, 2, 3, 4]
6350 }`,
6351 inVal: new(structFormatBytes),
6352 want: addr(structFormatBytes{
6353 Base16: []byte("\x01\x23\x45\x67\x89\xab\xcd\xef"),
6354 Base32: []byte("\x00D2\x14\xc7BT\xb65τe:V\xd7\xc6u\xbew\xdf"),
6355 Base32Hex: []byte("\x00D2\x14\xc7BT\xb65τe:V\xd7\xc6u\xbew\xdf"),
6356 Base64: []byte("\x00\x10\x83\x10Q\x87 \x92\x8b0ӏA\x14\x93QU\x97a\x96\x9bqן\x82\x18\xa3\x92Y\xa7\xa2\x9a\xab\xb2ۯ\xc3\x1c\xb3\xd3]\xb7㞻\xf3߿"),
6357 Base64URL: []byte("\x00\x10\x83\x10Q\x87 \x92\x8b0ӏA\x14\x93QU\x97a\x96\x9bqן\x82\x18\xa3\x92Y\xa7\xa2\x9a\xab\xb2ۯ\xc3\x1c\xb3\xd3]\xb7㞻\xf3߿"),
6358 Array: []byte{1, 2, 3, 4},
6359 }),
6360 }, {
6361 name: jsontest.Name("Structs/Format/ArrayBytes"),
6362 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6363 inBuf: `{
6364 "Base16": "01020304",
6365 "Base32": "AEBAGBA=",
6366 "Base32Hex": "0410610=",
6367 "Base64": "AQIDBA==",
6368 "Base64URL": "AQIDBA==",
6369 "Array": [1, 2, 3, 4],
6370 "Default": "AQIDBA=="
6371 }`,
6372 inVal: new(structFormatArrayBytes),
6373 want: addr(structFormatArrayBytes{
6374 Base16: [4]byte{1, 2, 3, 4},
6375 Base32: [4]byte{1, 2, 3, 4},
6376 Base32Hex: [4]byte{1, 2, 3, 4},
6377 Base64: [4]byte{1, 2, 3, 4},
6378 Base64URL: [4]byte{1, 2, 3, 4},
6379 Array: [4]byte{1, 2, 3, 4},
6380 Default: [4]byte{1, 2, 3, 4},
6381 }),
6382 }, {
6383 name: jsontest.Name("Structs/Format/ArrayBytes/Legacy"),
6384 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true), jsonflags.FormatBytesWithLegacySemantics | 1},
6385 inBuf: `{
6386 "Base16": "01020304",
6387 "Base32": "AEBAGBA=",
6388 "Base32Hex": "0410610=",
6389 "Base64": "AQIDBA==",
6390 "Base64URL": "AQIDBA==",
6391 "Array": [1, 2, 3, 4],
6392 "Default": [1, 2, 3, 4]
6393 }`,
6394 inVal: new(structFormatArrayBytes),
6395 want: addr(structFormatArrayBytes{
6396 Base16: [4]byte{1, 2, 3, 4},
6397 Base32: [4]byte{1, 2, 3, 4},
6398 Base32Hex: [4]byte{1, 2, 3, 4},
6399 Base64: [4]byte{1, 2, 3, 4},
6400 Base64URL: [4]byte{1, 2, 3, 4},
6401 Array: [4]byte{1, 2, 3, 4},
6402 Default: [4]byte{1, 2, 3, 4},
6403 }),
6404 }, {
6405 name: jsontest.Name("Structs/Format/Bytes/Array"),
6406 opts: []Options{
6407 jsonopts.ExperimentalSupportFormatTag(true),
6408 WithUnmarshalers(UnmarshalFunc(func(b []byte, v *byte) error {
6409 if string(b) == "true" {
6410 *v = 1
6411 } else {
6412 *v = 0
6413 }
6414 return nil
6415 })),
6416 },
6417 inBuf: `{"Array":[false,true,false,true,false,true]}`,
6418 inVal: new(struct {
6419 Array []byte `json:",format:array"`
6420 }),
6421 want: addr(struct {
6422 Array []byte `json:",format:array"`
6423 }{
6424 Array: []byte{0, 1, 0, 1, 0, 1},
6425 }),
6426 }, {
6427 name: jsontest.Name("Structs/Format/Bytes/Invalid/Base16/WrongKind"),
6428 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6429 inBuf: `{"Base16": [1,2,3,4]}`,
6430 inVal: new(structFormatBytes),
6431 wantErr: EU(nil).withPos(`{"Base16": `, "/Base16").withType('[', T[[]byte]()),
6432 }, {
6433 name: jsontest.Name("Structs/Format/Bytes/Invalid/Base16/AllPadding"),
6434 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6435 inBuf: `{"Base16": "===="}`,
6436 inVal: new(structFormatBytes),
6437 wantErr: EU(func() error {
6438 _, err := hex.Decode(make([]byte, 2), []byte("====="))
6439 return err
6440 }()).withPos(`{"Base16": `, "/Base16").withType('"', T[[]byte]()),
6441 }, {
6442 name: jsontest.Name("Structs/Format/Bytes/Invalid/Base16/EvenPadding"),
6443 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6444 inBuf: `{"Base16": "0123456789abcdef="}`,
6445 inVal: new(structFormatBytes),
6446 wantErr: EU(func() error {
6447 _, err := hex.Decode(make([]byte, 8), []byte("0123456789abcdef="))
6448 return err
6449 }()).withPos(`{"Base16": `, "/Base16").withType('"', T[[]byte]()),
6450 }, {
6451 name: jsontest.Name("Structs/Format/Bytes/Invalid/Base16/OddPadding"),
6452 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6453 inBuf: `{"Base16": "0123456789abcdef0="}`,
6454 inVal: new(structFormatBytes),
6455 wantErr: EU(func() error {
6456 _, err := hex.Decode(make([]byte, 9), []byte("0123456789abcdef0="))
6457 return err
6458 }()).withPos(`{"Base16": `, "/Base16").withType('"', T[[]byte]()),
6459 }, {
6460 name: jsontest.Name("Structs/Format/Bytes/Invalid/Base16/NonAlphabet/LineFeed"),
6461 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6462 inBuf: `{"Base16": "aa\naa"}`,
6463 inVal: new(structFormatBytes),
6464 wantErr: EU(func() error {
6465 _, err := hex.Decode(make([]byte, 9), []byte("aa\naa"))
6466 return err
6467 }()).withPos(`{"Base16": `, "/Base16").withType('"', T[[]byte]()),
6468 }, {
6469 name: jsontest.Name("Structs/Format/Bytes/Invalid/Base16/NonAlphabet/CarriageReturn"),
6470 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6471 inBuf: `{"Base16": "aa\raa"}`,
6472 inVal: new(structFormatBytes),
6473 wantErr: EU(func() error {
6474 _, err := hex.Decode(make([]byte, 9), []byte("aa\raa"))
6475 return err
6476 }()).withPos(`{"Base16": `, "/Base16").withType('"', T[[]byte]()),
6477 }, {
6478 name: jsontest.Name("Structs/Format/Bytes/Invalid/Base16/NonAlphabet/Space"),
6479 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6480 inBuf: `{"Base16": "aa aa"}`,
6481 inVal: new(structFormatBytes),
6482 wantErr: EU(func() error {
6483 _, err := hex.Decode(make([]byte, 9), []byte("aa aa"))
6484 return err
6485 }()).withPos(`{"Base16": `, "/Base16").withType('"', T[[]byte]()),
6486 }, {
6487 name: jsontest.Name("Structs/Format/Bytes/Invalid/Base32/Padding"),
6488 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6489 inBuf: `[
6490 {"Base32": "NA======"},
6491 {"Base32": "NBSQ===="},
6492 {"Base32": "NBSWY==="},
6493 {"Base32": "NBSWY3A="},
6494 {"Base32": "NBSWY3DP"}
6495 ]`,
6496 inVal: new([]structFormatBytes),
6497 want: addr([]structFormatBytes{
6498 {Base32: []byte("h")},
6499 {Base32: []byte("he")},
6500 {Base32: []byte("hel")},
6501 {Base32: []byte("hell")},
6502 {Base32: []byte("hello")},
6503 }),
6504 }, {
6505 name: jsontest.Name("Structs/Format/Bytes/Invalid/Base32/Invalid/NoPadding"),
6506 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6507 inBuf: `[
6508 {"Base32": "NA"},
6509 {"Base32": "NBSQ"},
6510 {"Base32": "NBSWY"},
6511 {"Base32": "NBSWY3A"},
6512 {"Base32": "NBSWY3DP"}
6513 ]`,
6514 inVal: new([]structFormatBytes),
6515 wantErr: EU(func() error {
6516 _, err := base32.StdEncoding.Decode(make([]byte, 1), []byte("NA"))
6517 return err
6518 }()).withPos(`[`+"\n\t\t\t\t"+`{"Base32": `, "/0/Base32").withType('"', T[[]byte]()),
6519 }, {
6520 name: jsontest.Name("Structs/Format/Bytes/Invalid/Base32/WrongAlphabet"),
6521 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6522 inBuf: `{"Base32": "0123456789ABCDEFGHIJKLMNOPQRSTUV"}`,
6523 inVal: new(structFormatBytes),
6524 wantErr: EU(func() error {
6525 _, err := base32.StdEncoding.Decode(make([]byte, 20), []byte("0123456789ABCDEFGHIJKLMNOPQRSTUV"))
6526 return err
6527 }()).withPos(`{"Base32": `, "/Base32").withType('"', T[[]byte]()),
6528 }, {
6529 name: jsontest.Name("Structs/Format/Bytes/Invalid/Base32Hex/WrongAlphabet"),
6530 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6531 inBuf: `{"Base32Hex": "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"}`,
6532 inVal: new(structFormatBytes),
6533 wantErr: EU(func() error {
6534 _, err := base32.HexEncoding.Decode(make([]byte, 20), []byte("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"))
6535 return err
6536 }()).withPos(`{"Base32Hex": `, "/Base32Hex").withType('"', T[[]byte]()),
6537 }, {
6538 name: jsontest.Name("Structs/Format/Bytes/Invalid/Base32/NonAlphabet/LineFeed"),
6539 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6540 inBuf: `{"Base32": "AAAA\nAAAA"}`,
6541 inVal: new(structFormatBytes),
6542 wantErr: EU(errors.New("illegal character '\\n' at offset 4")).withPos(`{"Base32": `, "/Base32").withType('"', T[[]byte]()),
6543 }, {
6544 name: jsontest.Name("Structs/Format/Bytes/Invalid/Base32/NonAlphabet/CarriageReturn"),
6545 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6546 inBuf: `{"Base32": "AAAA\rAAAA"}`,
6547 inVal: new(structFormatBytes),
6548 wantErr: EU(errors.New("illegal character '\\r' at offset 4")).withPos(`{"Base32": `, "/Base32").withType('"', T[[]byte]()),
6549 }, {
6550 name: jsontest.Name("Structs/Format/Bytes/Invalid/Base32/NonAlphabet/Space"),
6551 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6552 inBuf: `{"Base32": "AAAA AAAA"}`,
6553 inVal: new(structFormatBytes),
6554 wantErr: EU(base32.CorruptInputError(4)).withPos(`{"Base32": `, "/Base32").withType('"', T[[]byte]()),
6555 }, {
6556 name: jsontest.Name("Structs/Format/Bytes/Invalid/Base64/WrongAlphabet"),
6557 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6558 inBuf: `{"Base64": "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"}`,
6559 inVal: new(structFormatBytes),
6560 wantErr: EU(func() error {
6561 _, err := base64.StdEncoding.Decode(make([]byte, 48), []byte("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"))
6562 return err
6563 }()).withPos(`{"Base64": `, "/Base64").withType('"', T[[]byte]()),
6564 }, {
6565 name: jsontest.Name("Structs/Format/Bytes/Invalid/Base64URL/WrongAlphabet"),
6566 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6567 inBuf: `{"Base64URL": "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"}`,
6568 inVal: new(structFormatBytes),
6569 wantErr: EU(func() error {
6570 _, err := base64.URLEncoding.Decode(make([]byte, 48), []byte("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"))
6571 return err
6572 }()).withPos(`{"Base64URL": `, "/Base64URL").withType('"', T[[]byte]()),
6573 }, {
6574 name: jsontest.Name("Structs/Format/Bytes/Invalid/Base64/NonAlphabet/LineFeed"),
6575 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6576 inBuf: `{"Base64": "aa=\n="}`,
6577 inVal: new(structFormatBytes),
6578 wantErr: EU(errors.New("illegal character '\\n' at offset 3")).withPos(`{"Base64": `, "/Base64").withType('"', T[[]byte]()),
6579 }, {
6580 name: jsontest.Name("Structs/Format/Bytes/Invalid/Base64/NonAlphabet/CarriageReturn"),
6581 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6582 inBuf: `{"Base64": "aa=\r="}`,
6583 inVal: new(structFormatBytes),
6584 wantErr: EU(errors.New("illegal character '\\r' at offset 3")).withPos(`{"Base64": `, "/Base64").withType('"', T[[]byte]()),
6585 }, {
6586 name: jsontest.Name("Structs/Format/Bytes/Base64/NonAlphabet/Ignored"),
6587 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true), jsonflags.ParseBytesWithLooseRFC4648 | 1},
6588 inBuf: `{"Base64": "aa=\r\n="}`,
6589 inVal: new(structFormatBytes),
6590 want: &structFormatBytes{Base64: []byte{105}},
6591 }, {
6592 name: jsontest.Name("Structs/Format/Bytes/Invalid/Base64/NonAlphabet/Space"),
6593 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6594 inBuf: `{"Base64": "aa= ="}`,
6595 inVal: new(structFormatBytes),
6596 wantErr: EU(base64.CorruptInputError(2)).withPos(`{"Base64": `, "/Base64").withType('"', T[[]byte]()),
6597 }, {
6598 name: jsontest.Name("Structs/Format/Floats"),
6599 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6600 inBuf: `[
6601 {"NonFinite": 3.141592653589793, "PointerNonFinite": 3.141592653589793},
6602 {"NonFinite": "-Infinity", "PointerNonFinite": "-Infinity"},
6603 {"NonFinite": "Infinity", "PointerNonFinite": "Infinity"}
6604 ]`,
6605 inVal: new([]structFormatFloats),
6606 want: addr([]structFormatFloats{
6607 {NonFinite: math.Pi, PointerNonFinite: addr(math.Pi)},
6608 {NonFinite: math.Inf(-1), PointerNonFinite: addr(math.Inf(-1))},
6609 {NonFinite: math.Inf(+1), PointerNonFinite: addr(math.Inf(+1))},
6610 }),
6611 }, {
6612 name: jsontest.Name("Structs/Format/Floats/NaN"),
6613 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6614 inBuf: `{"NonFinite": "NaN"}`,
6615 inVal: new(structFormatFloats),
6616
6617 }, {
6618 name: jsontest.Name("Structs/Format/Floats/Invalid/NaN"),
6619 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6620 inBuf: `{"NonFinite": "nan"}`,
6621 inVal: new(structFormatFloats),
6622 wantErr: EU(nil).withPos(`{"NonFinite": `, "/NonFinite").withType('"', T[float64]()),
6623 }, {
6624 name: jsontest.Name("Structs/Format/Floats/Invalid/PositiveInfinity"),
6625 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6626 inBuf: `{"NonFinite": "+Infinity"}`,
6627 inVal: new(structFormatFloats),
6628 wantErr: EU(nil).withPos(`{"NonFinite": `, "/NonFinite").withType('"', T[float64]()),
6629 }, {
6630 name: jsontest.Name("Structs/Format/Floats/Invalid/NegativeInfinitySpace"),
6631 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6632 inBuf: `{"NonFinite": "-Infinity "}`,
6633 inVal: new(structFormatFloats),
6634 wantErr: EU(nil).withPos(`{"NonFinite": `, "/NonFinite").withType('"', T[float64]()),
6635 }, {
6636 name: jsontest.Name("Structs/Format/Maps"),
6637 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6638 inBuf: `[
6639 {"EmitNull": null, "PointerEmitNull": null, "EmitEmpty": null, "PointerEmitEmpty": null, "EmitDefault": null, "PointerEmitDefault": null},
6640 {"EmitNull": {}, "PointerEmitNull": {}, "EmitEmpty": {}, "PointerEmitEmpty": {}, "EmitDefault": {}, "PointerEmitDefault": {}},
6641 {"EmitNull": {"k": "v"}, "PointerEmitNull": {"k": "v"}, "EmitEmpty": {"k": "v"}, "PointerEmitEmpty": {"k": "v"}, "EmitDefault": {"k": "v"}, "PointerEmitDefault": {"k": "v"}}
6642 ]`,
6643 inVal: new([]structFormatMaps),
6644 want: addr([]structFormatMaps{{
6645 EmitNull: map[string]string(nil), PointerEmitNull: (*map[string]string)(nil),
6646 EmitEmpty: map[string]string(nil), PointerEmitEmpty: (*map[string]string)(nil),
6647 EmitDefault: map[string]string(nil), PointerEmitDefault: (*map[string]string)(nil),
6648 }, {
6649 EmitNull: map[string]string{}, PointerEmitNull: addr(map[string]string{}),
6650 EmitEmpty: map[string]string{}, PointerEmitEmpty: addr(map[string]string{}),
6651 EmitDefault: map[string]string{}, PointerEmitDefault: addr(map[string]string{}),
6652 }, {
6653 EmitNull: map[string]string{"k": "v"}, PointerEmitNull: addr(map[string]string{"k": "v"}),
6654 EmitEmpty: map[string]string{"k": "v"}, PointerEmitEmpty: addr(map[string]string{"k": "v"}),
6655 EmitDefault: map[string]string{"k": "v"}, PointerEmitDefault: addr(map[string]string{"k": "v"}),
6656 }}),
6657 }, {
6658 name: jsontest.Name("Structs/Format/Slices"),
6659 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6660 inBuf: `[
6661 {"EmitNull": null, "PointerEmitNull": null, "EmitEmpty": null, "PointerEmitEmpty": null, "EmitDefault": null, "PointerEmitDefault": null},
6662 {"EmitNull": [], "PointerEmitNull": [], "EmitEmpty": [], "PointerEmitEmpty": [], "EmitDefault": [], "PointerEmitDefault": []},
6663 {"EmitNull": ["v"], "PointerEmitNull": ["v"], "EmitEmpty": ["v"], "PointerEmitEmpty": ["v"], "EmitDefault": ["v"], "PointerEmitDefault": ["v"]}
6664 ]`,
6665 inVal: new([]structFormatSlices),
6666 want: addr([]structFormatSlices{{
6667 EmitNull: []string(nil), PointerEmitNull: (*[]string)(nil),
6668 EmitEmpty: []string(nil), PointerEmitEmpty: (*[]string)(nil),
6669 EmitDefault: []string(nil), PointerEmitDefault: (*[]string)(nil),
6670 }, {
6671 EmitNull: []string{}, PointerEmitNull: addr([]string{}),
6672 EmitEmpty: []string{}, PointerEmitEmpty: addr([]string{}),
6673 EmitDefault: []string{}, PointerEmitDefault: addr([]string{}),
6674 }, {
6675 EmitNull: []string{"v"}, PointerEmitNull: addr([]string{"v"}),
6676 EmitEmpty: []string{"v"}, PointerEmitEmpty: addr([]string{"v"}),
6677 EmitDefault: []string{"v"}, PointerEmitDefault: addr([]string{"v"}),
6678 }}),
6679 }, {
6680 name: jsontest.Name("Structs/Format/Invalid/Bool"),
6681 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6682 inBuf: `{"Bool":true}`,
6683 inVal: new(structFormatInvalid),
6684 wantErr: EU(errInvalidFormatFlag).withPos(`{"Bool":`, "/Bool").withType(0, T[bool]()),
6685 }, {
6686 name: jsontest.Name("Structs/Format/Invalid/String"),
6687 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6688 inBuf: `{"String": "string"}`,
6689 inVal: new(structFormatInvalid),
6690 wantErr: EU(errInvalidFormatFlag).withPos(`{"String": `, "/String").withType(0, T[string]()),
6691 }, {
6692 name: jsontest.Name("Structs/Format/Invalid/Bytes"),
6693 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6694 inBuf: `{"Bytes": "bytes"}`,
6695 inVal: new(structFormatInvalid),
6696 wantErr: EU(errInvalidFormatFlag).withPos(`{"Bytes": `, "/Bytes").withType(0, T[[]byte]()),
6697 }, {
6698 name: jsontest.Name("Structs/Format/Invalid/Int"),
6699 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6700 inBuf: `{"Int": 1}`,
6701 inVal: new(structFormatInvalid),
6702 wantErr: EU(errInvalidFormatFlag).withPos(`{"Int": `, "/Int").withType(0, T[int64]()),
6703 }, {
6704 name: jsontest.Name("Structs/Format/Invalid/Uint"),
6705 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6706 inBuf: `{"Uint": 1}`,
6707 inVal: new(structFormatInvalid),
6708 wantErr: EU(errInvalidFormatFlag).withPos(`{"Uint": `, "/Uint").withType(0, T[uint64]()),
6709 }, {
6710 name: jsontest.Name("Structs/Format/Invalid/Float"),
6711 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6712 inBuf: `{"Float" : 1}`,
6713 inVal: new(structFormatInvalid),
6714 wantErr: EU(errInvalidFormatFlag).withPos(`{"Float" : `, "/Float").withType(0, T[float64]()),
6715 }, {
6716 name: jsontest.Name("Structs/Format/Invalid/Map"),
6717 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6718 inBuf: `{"Map":{}}`,
6719 inVal: new(structFormatInvalid),
6720 wantErr: EU(errInvalidFormatFlag).withPos(`{"Map":`, "/Map").withType(0, T[map[string]string]()),
6721 }, {
6722 name: jsontest.Name("Structs/Format/Invalid/Struct"),
6723 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6724 inBuf: `{"Struct": {}}`,
6725 inVal: new(structFormatInvalid),
6726 wantErr: EU(errInvalidFormatFlag).withPos(`{"Struct": `, "/Struct").withType(0, T[structAll]()),
6727 }, {
6728 name: jsontest.Name("Structs/Format/Invalid/Slice"),
6729 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6730 inBuf: `{"Slice": {}}`,
6731 inVal: new(structFormatInvalid),
6732 wantErr: EU(errInvalidFormatFlag).withPos(`{"Slice": `, "/Slice").withType(0, T[[]string]()),
6733 }, {
6734 name: jsontest.Name("Structs/Format/Invalid/Array"),
6735 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6736 inBuf: `{"Array": []}`,
6737 inVal: new(structFormatInvalid),
6738 wantErr: EU(errInvalidFormatFlag).withPos(`{"Array": `, "/Array").withType(0, T[[1]string]()),
6739 }, {
6740 name: jsontest.Name("Structs/Format/Invalid/Interface"),
6741 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
6742 inBuf: `{"Interface": "anything"}`,
6743 inVal: new(structFormatInvalid),
6744 wantErr: EU(errInvalidFormatFlag).withPos(`{"Interface": `, "/Interface").withType(0, T[any]()),
6745 }, {
6746 name: jsontest.Name("Structs/Embed/Zero"),
6747 inBuf: `{"D":""}`,
6748 inVal: new(structEmbedded),
6749 want: new(structEmbedded),
6750 }, {
6751 name: jsontest.Name("Structs/Embed/Alloc"),
6752 inBuf: `{"E":"","F":"","G":"","A":"","B":"","D":""}`,
6753 inVal: new(structEmbedded),
6754 want: addr(structEmbedded{
6755 X: structEmbeddedL1{
6756 X: &structEmbeddedL2{},
6757 StructEmbed1: StructEmbed1{},
6758 },
6759 StructEmbed2: &StructEmbed2{},
6760 }),
6761 }, {
6762 name: jsontest.Name("Structs/Embed/NonZero"),
6763 inBuf: `{"E":"E3","F":"F3","G":"G3","A":"A1","B":"B1","D":"D2"}`,
6764 inVal: new(structEmbedded),
6765 want: addr(structEmbedded{
6766 X: structEmbeddedL1{
6767 X: &structEmbeddedL2{A: "A1", B: "B1" },
6768 StructEmbed1: StructEmbed1{ D: "D2" },
6769 },
6770 StructEmbed2: &StructEmbed2{E: "E3", F: "F3", G: "G3"},
6771 }),
6772 }, {
6773 name: jsontest.Name("Structs/Embed/Merge"),
6774 inBuf: `{"E":"E3","F":"F3","G":"G3","A":"A1","B":"B1","D":"D2"}`,
6775 inVal: addr(structEmbedded{
6776 X: structEmbeddedL1{
6777 X: &structEmbeddedL2{B: "##", C: "C1"},
6778 StructEmbed1: StructEmbed1{C: "C2", E: "E2"},
6779 },
6780 StructEmbed2: &StructEmbed2{E: "##", G: "G3"},
6781 }),
6782 want: addr(structEmbedded{
6783 X: structEmbeddedL1{
6784 X: &structEmbeddedL2{A: "A1", B: "B1", C: "C1"},
6785 StructEmbed1: StructEmbed1{C: "C2", D: "D2", E: "E2"},
6786 },
6787 StructEmbed2: &StructEmbed2{E: "E3", F: "F3", G: "G3"},
6788 }),
6789 }, {
6790 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/Noop"),
6791 inBuf: `{"A":1,"B":2}`,
6792 inVal: new(structEmbedTextValue),
6793 want: addr(structEmbedTextValue{A: 1, X: jsontext.Value(nil), B: 2}),
6794 }, {
6795 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/MergeN1/Nil"),
6796 inBuf: `{"A":1,"fizz":"buzz","B":2}`,
6797 inVal: new(structEmbedTextValue),
6798 want: addr(structEmbedTextValue{A: 1, X: jsontext.Value(`{"fizz":"buzz"}`), B: 2}),
6799 }, {
6800 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/MergeN1/Empty"),
6801 inBuf: `{"A":1,"fizz":"buzz","B":2}`,
6802 inVal: addr(structEmbedTextValue{X: jsontext.Value{}}),
6803 want: addr(structEmbedTextValue{A: 1, X: jsontext.Value(`{"fizz":"buzz"}`), B: 2}),
6804 }, {
6805 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/MergeN1/Whitespace"),
6806 inBuf: `{"A":1,"fizz":"buzz","B":2}`,
6807 inVal: addr(structEmbedTextValue{X: jsontext.Value("\n\r\t ")}),
6808 want: addr(structEmbedTextValue{A: 1, X: jsontext.Value("")}),
6809 wantErr: EU(errRawEmbedNotObject).withPos(`{"A":1,`, "/fizz").withType('"', T[jsontext.Value]()),
6810 }, {
6811 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/MergeN1/Null"),
6812 inBuf: `{"A":1,"fizz":"buzz","B":2}`,
6813 inVal: addr(structEmbedTextValue{X: jsontext.Value("null")}),
6814 want: addr(structEmbedTextValue{A: 1, X: jsontext.Value("null")}),
6815 wantErr: EU(errRawEmbedNotObject).withPos(`{"A":1,`, "/fizz").withType('"', T[jsontext.Value]()),
6816 }, {
6817 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/MergeN1/ObjectN0"),
6818 inBuf: `{"A":1,"fizz":"buzz","B":2}`,
6819 inVal: addr(structEmbedTextValue{X: jsontext.Value(` { } `)}),
6820 want: addr(structEmbedTextValue{A: 1, X: jsontext.Value(` {"fizz":"buzz"}`), B: 2}),
6821 }, {
6822 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/MergeN2/ObjectN1"),
6823 inBuf: `{"A":1,"fizz":"buzz","B":2,"foo": [ 1 , 2 , 3 ]}`,
6824 inVal: addr(structEmbedTextValue{X: jsontext.Value(` { "fizz" : "buzz" } `)}),
6825 want: addr(structEmbedTextValue{A: 1, X: jsontext.Value(` { "fizz" : "buzz","fizz":"buzz","foo":[ 1 , 2 , 3 ]}`), B: 2}),
6826 }, {
6827 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/Merge/EndObject"),
6828 inBuf: `{"A":1,"fizz":"buzz","B":2}`,
6829 inVal: addr(structEmbedTextValue{X: jsontext.Value(` } `)}),
6830
6831
6832 want: addr(structEmbedTextValue{A: 1, X: jsontext.Value(`,"fizz":"buzz"}`), B: 2}),
6833 }, {
6834 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/MergeInvalidValue"),
6835 inBuf: `{"A":1,"fizz":nil,"B":2}`,
6836 inVal: new(structEmbedTextValue),
6837 want: addr(structEmbedTextValue{A: 1, X: jsontext.Value(`{"fizz":`)}),
6838 wantErr: newInvalidCharacterError("i", "in literal null (expecting 'u')", len64(`{"A":1,"fizz":n`), "/fizz"),
6839 }, {
6840 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/CaseSensitive"),
6841 inBuf: `{"A":1,"fizz":"buzz","B":2,"a":3}`,
6842 inVal: new(structEmbedTextValue),
6843 want: addr(structEmbedTextValue{A: 1, X: jsontext.Value(`{"fizz":"buzz","a":3}`), B: 2}),
6844 }, {
6845 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/RejectDuplicateNames"),
6846 opts: []Options{jsontext.AllowDuplicateNames(false)},
6847 inBuf: `{"A":1,"fizz":"buzz","B":2,"fizz":"buzz"}`,
6848 inVal: new(structEmbedTextValue),
6849 want: addr(structEmbedTextValue{A: 1, X: jsontext.Value(`{"fizz":"buzz"}`), B: 2}),
6850 wantErr: newDuplicateNameError("", []byte(`"fizz"`), len64(`{"A":1,"fizz":"buzz","B":2,`)),
6851 }, {
6852 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/AllowDuplicateNames"),
6853 opts: []Options{jsontext.AllowDuplicateNames(true)},
6854 inBuf: `{"A":1,"fizz":"buzz","B":2,"fizz":"buzz"}`,
6855 inVal: new(structEmbedTextValue),
6856 want: addr(structEmbedTextValue{A: 1, X: jsontext.Value(`{"fizz":"buzz","fizz":"buzz"}`), B: 2}),
6857 }, {
6858 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/Nested/Noop"),
6859 inBuf: `{}`,
6860 inVal: new(structEmbedPointerEmbedTextValue),
6861 want: new(structEmbedPointerEmbedTextValue),
6862 }, {
6863 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/Nested/Alloc"),
6864 inBuf: `{"A":1,"fizz":"buzz"}`,
6865 inVal: new(structEmbedPointerEmbedTextValue),
6866 want: addr(structEmbedPointerEmbedTextValue{
6867 X: &struct {
6868 A int
6869 X jsontext.Value `json:",embed"`
6870 }{A: 1, X: jsontext.Value(`{"fizz":"buzz"}`)},
6871 }),
6872 }, {
6873 name: jsontest.Name("Structs/EmbeddedFallback/TextValue/Nested/Merge"),
6874 inBuf: `{"fizz":"buzz"}`,
6875 inVal: addr(structEmbedPointerEmbedTextValue{
6876 X: &struct {
6877 A int
6878 X jsontext.Value `json:",embed"`
6879 }{A: 1},
6880 }),
6881 want: addr(structEmbedPointerEmbedTextValue{
6882 X: &struct {
6883 A int
6884 X jsontext.Value `json:",embed"`
6885 }{A: 1, X: jsontext.Value(`{"fizz":"buzz"}`)},
6886 }),
6887 }, {
6888 name: jsontest.Name("Structs/EmbeddedFallback/PointerTextValue/Noop"),
6889 inBuf: `{"A":1,"B":2}`,
6890 inVal: new(structEmbedPointerTextValue),
6891 want: addr(structEmbedPointerTextValue{A: 1, X: nil, B: 2}),
6892 }, {
6893 name: jsontest.Name("Structs/EmbeddedFallback/PointerTextValue/Alloc"),
6894 inBuf: `{"A":1,"fizz":"buzz","B":2}`,
6895 inVal: new(structEmbedPointerTextValue),
6896 want: addr(structEmbedPointerTextValue{A: 1, X: addr(jsontext.Value(`{"fizz":"buzz"}`)), B: 2}),
6897 }, {
6898 name: jsontest.Name("Structs/EmbeddedFallback/PointerTextValue/Merge"),
6899 inBuf: `{"A":1,"fizz":"buzz","B":2}`,
6900 inVal: addr(structEmbedPointerTextValue{X: addr(jsontext.Value(`{"fizz":"buzz"}`))}),
6901 want: addr(structEmbedPointerTextValue{A: 1, X: addr(jsontext.Value(`{"fizz":"buzz","fizz":"buzz"}`)), B: 2}),
6902 }, {
6903 name: jsontest.Name("Structs/EmbeddedFallback/PointerTextValue/Nested/Nil"),
6904 inBuf: `{"fizz":"buzz"}`,
6905 inVal: new(structEmbedEmbedPointerTextValue),
6906 want: addr(structEmbedEmbedPointerTextValue{
6907 X: struct {
6908 X *jsontext.Value `json:",embed"`
6909 }{X: addr(jsontext.Value(`{"fizz":"buzz"}`))},
6910 }),
6911 }, {
6912 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/Noop"),
6913 inBuf: `{"A":1,"B":2}`,
6914 inVal: new(structEmbedMapStringAny),
6915 want: addr(structEmbedMapStringAny{A: 1, X: nil, B: 2}),
6916 }, {
6917 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/MergeN1/Nil"),
6918 inBuf: `{"A":1,"fizz":"buzz","B":2}`,
6919 inVal: new(structEmbedMapStringAny),
6920 want: addr(structEmbedMapStringAny{A: 1, X: jsonObject{"fizz": "buzz"}, B: 2}),
6921 }, {
6922 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/MergeN1/Empty"),
6923 inBuf: `{"A":1,"fizz":"buzz","B":2}`,
6924 inVal: addr(structEmbedMapStringAny{X: jsonObject{}}),
6925 want: addr(structEmbedMapStringAny{A: 1, X: jsonObject{"fizz": "buzz"}, B: 2}),
6926 }, {
6927 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/MergeN1/ObjectN1"),
6928 inBuf: `{"A":1,"fizz":{"charlie":"DELTA","echo":"foxtrot"},"B":2}`,
6929 inVal: addr(structEmbedMapStringAny{X: jsonObject{"fizz": jsonObject{
6930 "alpha": "bravo",
6931 "charlie": "delta",
6932 }}}),
6933 want: addr(structEmbedMapStringAny{A: 1, X: jsonObject{"fizz": jsonObject{
6934 "alpha": "bravo",
6935 "charlie": "DELTA",
6936 "echo": "foxtrot",
6937 }}, B: 2}),
6938 }, {
6939 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/MergeN2/ObjectN1"),
6940 inBuf: `{"A":1,"fizz":"buzz","B":2,"foo": [ 1 , 2 , 3 ]}`,
6941 inVal: addr(structEmbedMapStringAny{X: jsonObject{"fizz": "wuzz"}}),
6942 want: addr(structEmbedMapStringAny{A: 1, X: jsonObject{"fizz": "buzz", "foo": jsonArray{1.0, 2.0, 3.0}}, B: 2}),
6943 }, {
6944 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/MergeInvalidValue"),
6945 inBuf: `{"A":1,"fizz":nil,"B":2}`,
6946 inVal: new(structEmbedMapStringAny),
6947 want: addr(structEmbedMapStringAny{A: 1, X: jsonObject{"fizz": nil}}),
6948 wantErr: newInvalidCharacterError("i", "in literal null (expecting 'u')", len64(`{"A":1,"fizz":n`), "/fizz"),
6949 }, {
6950 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/MergeInvalidValue/Existing"),
6951 inBuf: `{"A":1,"fizz":nil,"B":2}`,
6952 inVal: addr(structEmbedMapStringAny{A: 1, X: jsonObject{"fizz": true}}),
6953 want: addr(structEmbedMapStringAny{A: 1, X: jsonObject{"fizz": true}}),
6954 wantErr: newInvalidCharacterError("i", "in literal null (expecting 'u')", len64(`{"A":1,"fizz":n`), "/fizz"),
6955 }, {
6956 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/CaseSensitive"),
6957 inBuf: `{"A":1,"fizz":"buzz","B":2,"a":3}`,
6958 inVal: new(structEmbedMapStringAny),
6959 want: addr(structEmbedMapStringAny{A: 1, X: jsonObject{"fizz": "buzz", "a": 3.0}, B: 2}),
6960 }, {
6961 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/RejectDuplicateNames"),
6962 opts: []Options{jsontext.AllowDuplicateNames(false)},
6963 inBuf: `{"A":1,"fizz":"buzz","B":2,"fizz":"buzz"}`,
6964 inVal: new(structEmbedMapStringAny),
6965 want: addr(structEmbedMapStringAny{A: 1, X: jsonObject{"fizz": "buzz"}, B: 2}),
6966 wantErr: newDuplicateNameError("", []byte(`"fizz"`), len64(`{"A":1,"fizz":"buzz","B":2,`)),
6967 }, {
6968 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/AllowDuplicateNames"),
6969 opts: []Options{jsontext.AllowDuplicateNames(true)},
6970 inBuf: `{"A":1,"fizz":{"one":1,"two":-2},"B":2,"fizz":{"two":2,"three":3}}`,
6971 inVal: new(structEmbedMapStringAny),
6972 want: addr(structEmbedMapStringAny{A: 1, X: jsonObject{"fizz": jsonObject{"one": 1.0, "two": 2.0, "three": 3.0}}, B: 2}),
6973 }, {
6974 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/Nested/Noop"),
6975 inBuf: `{}`,
6976 inVal: new(structEmbedPointerEmbedMapStringAny),
6977 want: new(structEmbedPointerEmbedMapStringAny),
6978 }, {
6979 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/Nested/Alloc"),
6980 inBuf: `{"A":1,"fizz":"buzz"}`,
6981 inVal: new(structEmbedPointerEmbedMapStringAny),
6982 want: addr(structEmbedPointerEmbedMapStringAny{
6983 X: &struct {
6984 A int
6985 X jsonObject `json:",embed"`
6986 }{A: 1, X: jsonObject{"fizz": "buzz"}},
6987 }),
6988 }, {
6989 name: jsontest.Name("Structs/EmbeddedFallback/MapStringAny/Nested/Merge"),
6990 inBuf: `{"fizz":"buzz"}`,
6991 inVal: addr(structEmbedPointerEmbedMapStringAny{
6992 X: &struct {
6993 A int
6994 X jsonObject `json:",embed"`
6995 }{A: 1},
6996 }),
6997 want: addr(structEmbedPointerEmbedMapStringAny{
6998 X: &struct {
6999 A int
7000 X jsonObject `json:",embed"`
7001 }{A: 1, X: jsonObject{"fizz": "buzz"}},
7002 }),
7003 }, {
7004 name: jsontest.Name("Structs/EmbeddedFallback/MapStringInt/UnmarshalFunc"),
7005 opts: []Options{
7006 WithUnmarshalers(UnmarshalFunc(func(b []byte, v *any) error {
7007 var err error
7008 *v, err = strconv.ParseFloat(string(bytes.Trim(b, `"`)), 64)
7009 return err
7010 })),
7011 },
7012 inBuf: `{"D":"1.1","E":"2.2","F":"3.3"}`,
7013 inVal: new(structEmbedMapStringAny),
7014 want: addr(structEmbedMapStringAny{X: jsonObject{"D": 1.1, "E": 2.2, "F": 3.3}}),
7015 }, {
7016 name: jsontest.Name("Structs/EmbeddedFallback/PointerMapStringAny/Noop"),
7017 inBuf: `{"A":1,"B":2}`,
7018 inVal: new(structEmbedPointerMapStringAny),
7019 want: addr(structEmbedPointerMapStringAny{A: 1, X: nil, B: 2}),
7020 }, {
7021 name: jsontest.Name("Structs/EmbeddedFallback/PointerMapStringAny/Alloc"),
7022 inBuf: `{"A":1,"fizz":"buzz","B":2}`,
7023 inVal: new(structEmbedPointerMapStringAny),
7024 want: addr(structEmbedPointerMapStringAny{A: 1, X: addr(jsonObject{"fizz": "buzz"}), B: 2}),
7025 }, {
7026 name: jsontest.Name("Structs/EmbeddedFallback/PointerMapStringAny/Merge"),
7027 inBuf: `{"A":1,"fizz":"wuzz","B":2}`,
7028 inVal: addr(structEmbedPointerMapStringAny{X: addr(jsonObject{"fizz": "buzz"})}),
7029 want: addr(structEmbedPointerMapStringAny{A: 1, X: addr(jsonObject{"fizz": "wuzz"}), B: 2}),
7030 }, {
7031 name: jsontest.Name("Structs/EmbeddedFallback/PointerMapStringAny/Nested/Nil"),
7032 inBuf: `{"fizz":"buzz"}`,
7033 inVal: new(structEmbedEmbedPointerMapStringAny),
7034 want: addr(structEmbedEmbedPointerMapStringAny{
7035 X: struct {
7036 X *jsonObject `json:",embed"`
7037 }{X: addr(jsonObject{"fizz": "buzz"})},
7038 }),
7039 }, {
7040 name: jsontest.Name("Structs/EmbeddedFallback/MapStringInt"),
7041 inBuf: `{"zero": 0, "one": 1, "two": 2}`,
7042 inVal: new(structEmbedMapStringInt),
7043 want: addr(structEmbedMapStringInt{
7044 X: map[string]int{"zero": 0, "one": 1, "two": 2},
7045 }),
7046 }, {
7047 name: jsontest.Name("Structs/EmbeddedFallback/MapStringInt/Null"),
7048 inBuf: `{"zero": 0, "one": null, "two": 2}`,
7049 inVal: new(structEmbedMapStringInt),
7050 want: addr(structEmbedMapStringInt{
7051 X: map[string]int{"zero": 0, "one": 0, "two": 2},
7052 }),
7053 }, {
7054 name: jsontest.Name("Structs/EmbeddedFallback/MapStringInt/Invalid"),
7055 inBuf: `{"zero": 0, "one": {}, "two": 2}`,
7056 inVal: new(structEmbedMapStringInt),
7057 want: addr(structEmbedMapStringInt{
7058 X: map[string]int{"zero": 0, "one": 0},
7059 }),
7060 wantErr: EU(nil).withPos(`{"zero": 0, "one": `, "/one").withType('{', T[int]()),
7061 }, {
7062 name: jsontest.Name("Structs/EmbeddedFallback/MapStringInt/StringifiedNumbers"),
7063 opts: []Options{StringifyNumbers(true)},
7064 inBuf: `{"zero": "0", "one": "1", "two": "2"}`,
7065 inVal: new(structEmbedMapStringInt),
7066 want: addr(structEmbedMapStringInt{
7067 X: map[string]int{"zero": 0, "one": 1, "two": 2},
7068 }),
7069 }, {
7070 name: jsontest.Name("Structs/EmbeddedFallback/MapStringInt/UnmarshalFunc"),
7071 opts: []Options{
7072 WithUnmarshalers(UnmarshalFunc(func(b []byte, v *int) error {
7073 i, err := strconv.ParseInt(string(bytes.Trim(b, `"`)), 10, 64)
7074 if err != nil {
7075 return err
7076 }
7077 *v = int(i)
7078 return nil
7079 })),
7080 },
7081 inBuf: `{"zero": "0", "one": "1", "two": "2"}`,
7082 inVal: new(structEmbedMapStringInt),
7083 want: addr(structEmbedMapStringInt{
7084 X: map[string]int{"zero": 0, "one": 1, "two": 2},
7085 }),
7086 }, {
7087 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringInt"),
7088 inBuf: `{"zero": 0, "one": 1, "two": 2}`,
7089 inVal: new(structEmbedMapNamedStringInt),
7090 want: addr(structEmbedMapNamedStringInt{
7091 X: map[namedString]int{"zero": 0, "one": 1, "two": 2},
7092 }),
7093 }, {
7094 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringInt/Null"),
7095 inBuf: `{"zero": 0, "one": null, "two": 2}`,
7096 inVal: new(structEmbedMapNamedStringInt),
7097 want: addr(structEmbedMapNamedStringInt{
7098 X: map[namedString]int{"zero": 0, "one": 0, "two": 2},
7099 }),
7100 }, {
7101 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringInt/Invalid"),
7102 inBuf: `{"zero": 0, "one": {}, "two": 2}`,
7103 inVal: new(structEmbedMapNamedStringInt),
7104 want: addr(structEmbedMapNamedStringInt{
7105 X: map[namedString]int{"zero": 0, "one": 0},
7106 }),
7107 wantErr: EU(nil).withPos(`{"zero": 0, "one": `, "/one").withType('{', T[int]()),
7108 }, {
7109 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringInt/StringifiedNumbers"),
7110 opts: []Options{StringifyNumbers(true)},
7111 inBuf: `{"zero": "0", "one": 1, "two": "2"}`,
7112 inVal: new(structEmbedMapNamedStringInt),
7113 want: addr(structEmbedMapNamedStringInt{
7114 X: map[namedString]int{"zero": 0, "one": 0},
7115 }),
7116 wantErr: EU(nil).withPos(`{"zero": "0", "one": `, "/one").withType('0', T[int]()),
7117 }, {
7118 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringInt/UnmarshalFunc"),
7119 opts: []Options{
7120 WithUnmarshalers(UnmarshalFunc(func(b []byte, v *int) error {
7121 i, err := strconv.ParseInt(string(bytes.Trim(b, `"`)), 10, 64)
7122 if err != nil {
7123 return err
7124 }
7125 *v = int(i)
7126 return nil
7127 })),
7128 },
7129 inBuf: `{"zero": "0", "one": "1", "two": "2"}`,
7130 inVal: new(structEmbedMapNamedStringInt),
7131 want: addr(structEmbedMapNamedStringInt{
7132 X: map[namedString]int{"zero": 0, "one": 1, "two": 2},
7133 }),
7134 }, {
7135 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringAny/Noop"),
7136 inBuf: `{"A":1,"B":2}`,
7137 inVal: new(structEmbedMapNamedStringAny),
7138 want: addr(structEmbedMapNamedStringAny{A: 1, X: nil, B: 2}),
7139 }, {
7140 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringAny/MergeN1/Nil"),
7141 inBuf: `{"A":1,"fizz":"buzz","B":2}`,
7142 inVal: new(structEmbedMapNamedStringAny),
7143 want: addr(structEmbedMapNamedStringAny{A: 1, X: map[namedString]any{"fizz": "buzz"}, B: 2}),
7144 }, {
7145 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringAny/MergeN1/Empty"),
7146 inBuf: `{"A":1,"fizz":"buzz","B":2}`,
7147 inVal: addr(structEmbedMapNamedStringAny{X: map[namedString]any{}}),
7148 want: addr(structEmbedMapNamedStringAny{A: 1, X: map[namedString]any{"fizz": "buzz"}, B: 2}),
7149 }, {
7150 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringAny/MergeN1/ObjectN1"),
7151 inBuf: `{"A":1,"fizz":{"charlie":"DELTA","echo":"foxtrot"},"B":2}`,
7152 inVal: addr(structEmbedMapNamedStringAny{X: map[namedString]any{"fizz": jsonObject{
7153 "alpha": "bravo",
7154 "charlie": "delta",
7155 }}}),
7156 want: addr(structEmbedMapNamedStringAny{A: 1, X: map[namedString]any{"fizz": jsonObject{
7157 "alpha": "bravo",
7158 "charlie": "DELTA",
7159 "echo": "foxtrot",
7160 }}, B: 2}),
7161 }, {
7162 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringAny/MergeN2/ObjectN1"),
7163 inBuf: `{"A":1,"fizz":"buzz","B":2,"foo": [ 1 , 2 , 3 ]}`,
7164 inVal: addr(structEmbedMapNamedStringAny{X: map[namedString]any{"fizz": "wuzz"}}),
7165 want: addr(structEmbedMapNamedStringAny{A: 1, X: map[namedString]any{"fizz": "buzz", "foo": jsonArray{1.0, 2.0, 3.0}}, B: 2}),
7166 }, {
7167 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringAny/MergeInvalidValue"),
7168 inBuf: `{"A":1,"fizz":nil,"B":2}`,
7169 inVal: new(structEmbedMapNamedStringAny),
7170 want: addr(structEmbedMapNamedStringAny{A: 1, X: map[namedString]any{"fizz": nil}}),
7171 wantErr: newInvalidCharacterError("i", "in literal null (expecting 'u')", len64(`{"A":1,"fizz":n`), "/fizz"),
7172 }, {
7173 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringAny/MergeInvalidValue/Existing"),
7174 inBuf: `{"A":1,"fizz":nil,"B":2}`,
7175 inVal: addr(structEmbedMapNamedStringAny{A: 1, X: map[namedString]any{"fizz": true}}),
7176 want: addr(structEmbedMapNamedStringAny{A: 1, X: map[namedString]any{"fizz": true}}),
7177 wantErr: newInvalidCharacterError("i", "in literal null (expecting 'u')", len64(`{"A":1,"fizz":n`), "/fizz"),
7178 }, {
7179 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringAny/CaseSensitive"),
7180 inBuf: `{"A":1,"fizz":"buzz","B":2,"a":3}`,
7181 inVal: new(structEmbedMapNamedStringAny),
7182 want: addr(structEmbedMapNamedStringAny{A: 1, X: map[namedString]any{"fizz": "buzz", "a": 3.0}, B: 2}),
7183 }, {
7184 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringAny/RejectDuplicateNames"),
7185 opts: []Options{jsontext.AllowDuplicateNames(false)},
7186 inBuf: `{"A":1,"fizz":"buzz","B":2,"fizz":"buzz"}`,
7187 inVal: new(structEmbedMapNamedStringAny),
7188 want: addr(structEmbedMapNamedStringAny{A: 1, X: map[namedString]any{"fizz": "buzz"}, B: 2}),
7189 wantErr: newDuplicateNameError("", []byte(`"fizz"`), len64(`{"A":1,"fizz":"buzz","B":2,`)),
7190 }, {
7191 name: jsontest.Name("Structs/EmbeddedFallback/MapNamedStringAny/AllowDuplicateNames"),
7192 opts: []Options{jsontext.AllowDuplicateNames(true)},
7193 inBuf: `{"A":1,"fizz":{"one":1,"two":-2},"B":2,"fizz":{"two":2,"three":3}}`,
7194 inVal: new(structEmbedMapNamedStringAny),
7195 want: addr(structEmbedMapNamedStringAny{A: 1, X: map[namedString]any{"fizz": map[string]any{"one": 1.0, "two": 2.0, "three": 3.0}}, B: 2}),
7196 }, {
7197 name: jsontest.Name("Structs/EmbeddedFallback/RejectUnknownMembers"),
7198 opts: []Options{RejectUnknownMembers(true)},
7199 inBuf: `{"A":1,"fizz":"buzz","B":2}`,
7200 inVal: new(structEmbedTextValue),
7201 want: addr(structEmbedTextValue{
7202 A: 1,
7203 X: jsontext.Value(`{"fizz":"buzz"}`),
7204 B: 2,
7205 }),
7206 }, {
7207 name: jsontest.Name("Structs/UnknownIgnored"),
7208 opts: []Options{RejectUnknownMembers(false)},
7209 inBuf: `{"unknown":"fizzbuzz"}`,
7210 inVal: new(structAll),
7211 want: new(structAll),
7212 }, {
7213 name: jsontest.Name("Structs/RejectUnknownMembers"),
7214 opts: []Options{RejectUnknownMembers(true)},
7215 inBuf: `{"unknown":"fizzbuzz"}`,
7216 inVal: new(structAll),
7217 want: new(structAll),
7218 wantErr: EU(ErrUnknownName).withPos(`{`, "/unknown").withType('"', T[structAll]()),
7219 }, {
7220 name: jsontest.Name("Structs/UnexportedIgnored"),
7221 inBuf: `{"ignored":"unused"}`,
7222 inVal: new(structUnexportedIgnored),
7223 want: new(structUnexportedIgnored),
7224 }, {
7225 name: jsontest.Name("Structs/IgnoredUnexportedEmbedded"),
7226 inBuf: `{"namedString":"unused"}`,
7227 inVal: new(structIgnoredUnexportedEmbedded),
7228 want: new(structIgnoredUnexportedEmbedded),
7229 }, {
7230 name: jsontest.Name("Structs/NoCase/Exact"),
7231 inBuf: `{"Aaa":"Aaa","AA_A":"AA_A","AaA":"AaA","AAa":"AAa","AAA":"AAA"}`,
7232 inVal: new(structNoCase),
7233 want: addr(structNoCase{AaA: "AaA", AAa: "AAa", Aaa: "Aaa", AAA: "AAA", AA_A: "AA_A"}),
7234 }, {
7235 name: jsontest.Name("Structs/NoCase/CaseInsensitiveDefault/Ambiguous"),
7236 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
7237 inBuf: `{"aa_a":"aa_a"}`,
7238 inVal: new(structNoCase),
7239 want: addr(structNoCase{AaA: "aa_a"}),
7240 }, {
7241 name: jsontest.Name("Structs/NoCase/CaseInsensitiveDefault/Ambiguous"),
7242 inBuf: `{"aa_a":"aa_a"}`,
7243 inVal: new(structNoCase),
7244 want: addr(structNoCase{}),
7245 wantErr: EU(errAmbiguousName).withPos(`{`, "/aa_a").withType('"', T[structNoCase]()),
7246 }, {
7247 name: jsontest.Name("Structs/NoCase/MatchCaseSensitiveDelimiter"),
7248 opts: []Options{jsonflags.MatchCaseSensitiveDelimiter | 1},
7249 inBuf: `{"aa_a":"aa_a"}`,
7250 inVal: new(structNoCase),
7251 want: addr(structNoCase{}),
7252 }, {
7253 name: jsontest.Name("Structs/NoCase/MatchCaseInsensitiveNames+MatchCaseSensitiveDelimiter"),
7254 opts: []Options{MatchCaseInsensitiveNames(true), jsonflags.MatchCaseSensitiveDelimiter | 1},
7255 inBuf: `{"aa_a":"aa_a"}`,
7256 inVal: new(structNoCase),
7257 want: addr(structNoCase{AA_A: "aa_a"}),
7258 }, {
7259 name: jsontest.Name("Structs/NoCase/Merge/AllowDuplicateNames"),
7260 opts: []Options{jsontext.AllowDuplicateNames(true), jsonflags.ReportErrorsWithLegacySemantics | 1},
7261 inBuf: `{"AaA":"AaA","aaa":"aaa","aAa":"aAa"}`,
7262 inVal: new(structNoCase),
7263 want: addr(structNoCase{AaA: "aAa"}),
7264 }, {
7265 name: jsontest.Name("Structs/NoCase/Merge/AllowDuplicateNames/Ambiguous"),
7266 opts: []Options{jsontext.AllowDuplicateNames(true)},
7267 inBuf: `{"AaA":"AaA","aaa":"aaa","aAa":"aAa"}`,
7268 inVal: new(structNoCase),
7269 want: addr(structNoCase{AaA: "AaA"}),
7270 wantErr: EU(errAmbiguousName).withPos(`{"AaA":"AaA",`, "/aaa").withType('"', T[structNoCase]()),
7271 }, {
7272 name: jsontest.Name("Structs/NoCase/Merge/RejectDuplicateNames/Ambiguous"),
7273 opts: []Options{jsontext.AllowDuplicateNames(false)},
7274 inBuf: `{"AaA":"AaA","aaa":"aaa"}`,
7275 inVal: new(structNoCase),
7276 want: addr(structNoCase{AaA: "AaA"}),
7277 wantErr: EU(errAmbiguousName).withPos(`{"AaA":"AaA",`, "/aaa").withType('"', T[structNoCase]()),
7278 }, {
7279 name: jsontest.Name("Structs/CaseSensitive"),
7280 inBuf: `{"BOOL": true, "STRING": "hello", "BYTES": "AQID", "INT": -64, "UINT": 64, "FLOAT": 3.14159}`,
7281 inVal: new(structScalars),
7282 want: addr(structScalars{}),
7283 }, {
7284 name: jsontest.Name("Structs/DuplicateName/NoCase/ExactDifferent"),
7285 inBuf: `{"AAA":"AAA","AaA":"AaA","AAa":"AAa","Aaa":"Aaa"}`,
7286 inVal: addr(structNoCaseEmbedTextValue{}),
7287 want: addr(structNoCaseEmbedTextValue{AAA: "AAA", AaA: "AaA", AAa: "AAa", Aaa: "Aaa"}),
7288 }, {
7289 name: jsontest.Name("Structs/DuplicateName/NoCase/ExactConflict"),
7290 inBuf: `{"AAA":"AAA","AAA":"AAA"}`,
7291 inVal: addr(structNoCaseEmbedTextValue{}),
7292 want: addr(structNoCaseEmbedTextValue{AAA: "AAA"}),
7293 wantErr: newDuplicateNameError("", []byte(`"AAA"`), len64(`{"AAA":"AAA",`)),
7294 }, {
7295 name: jsontest.Name("Structs/DuplicateName/NoCase/OverwriteExact"),
7296 inBuf: `{"AAA":"after"}`,
7297 inVal: addr(structNoCaseEmbedTextValue{AAA: "before"}),
7298 want: addr(structNoCaseEmbedTextValue{AAA: "after"}),
7299 }, {
7300 name: jsontest.Name("Structs/AmbiguousName/NoCase"),
7301 inBuf: `{"aaa":"aaa"}`,
7302 inVal: addr(structNoCaseEmbedTextValue{}),
7303 want: addr(structNoCaseEmbedTextValue{}),
7304 wantErr: EU(errAmbiguousName).withPos(`{`, "/aaa").withType('"', T[structNoCaseEmbedTextValue]()),
7305 }, {
7306 name: jsontest.Name("Structs/DuplicateName/Embed/Unknown"),
7307 inBuf: `{"unknown":""}`,
7308 inVal: addr(structNoCaseEmbedTextValue{}),
7309 want: addr(structNoCaseEmbedTextValue{X: jsontext.Value(`{"unknown":""}`)}),
7310 }, {
7311 name: jsontest.Name("Structs/DuplicateName/Embed/UnknownMerge"),
7312 inBuf: `{"unknown":""}`,
7313 inVal: addr(structNoCaseEmbedTextValue{X: jsontext.Value(`{"unknown":""}`)}),
7314 want: addr(structNoCaseEmbedTextValue{X: jsontext.Value(`{"unknown":"","unknown":""}`)}),
7315 }, {
7316 name: jsontest.Name("Structs/DuplicateName/Embed/NoCaseOkay"),
7317 inBuf: `{"b":"","B":""}`,
7318 inVal: addr(structNoCaseEmbedTextValue{}),
7319 want: addr(structNoCaseEmbedTextValue{X: jsontext.Value(`{"b":"","B":""}`)}),
7320 }, {
7321 name: jsontest.Name("Structs/DuplicateName/Embed/ExactConflict"),
7322 inBuf: `{"b":"","b":""}`,
7323 inVal: addr(structNoCaseEmbedTextValue{}),
7324 want: addr(structNoCaseEmbedTextValue{X: jsontext.Value(`{"b":""}`)}),
7325 wantErr: newDuplicateNameError("", []byte(`"b"`), len64(`{"b":"",`)),
7326 }, {
7327 name: jsontest.Name("Structs/Invalid/ErrUnexpectedEOF"),
7328 inBuf: ``,
7329 inVal: addr(structAll{}),
7330 want: addr(structAll{}),
7331 wantErr: &jsontext.SyntacticError{Err: io.ErrUnexpectedEOF},
7332 }, {
7333 name: jsontest.Name("Structs/Invalid/ErrUnexpectedEOF"),
7334 inBuf: " \n\r\t",
7335 inVal: addr(structAll{}),
7336 want: addr(structAll{}),
7337 wantErr: &jsontext.SyntacticError{Err: io.ErrUnexpectedEOF, ByteOffset: len64(" \n\r\t")},
7338 }, {
7339 name: jsontest.Name("Structs/Invalid/NestedErrUnexpectedEOF"),
7340 inBuf: `{"Pointer":`,
7341 inVal: addr(structAll{}),
7342 want: addr(structAll{Pointer: new(structAll)}),
7343 wantErr: &jsontext.SyntacticError{ByteOffset: len64(`{"Pointer":`), JSONPointer: "/Pointer", Err: io.ErrUnexpectedEOF},
7344 }, {
7345 name: jsontest.Name("Structs/Invalid/Conflicting"),
7346 inBuf: `{}`,
7347 inVal: addr(structConflicting{}),
7348 want: addr(structConflicting{}),
7349 wantErr: EU(errors.New(`Go struct fields A and B conflict over JSON object name "conflict"`)).withType('{', T[structConflicting]()),
7350 }, {
7351 name: jsontest.Name("Structs/Invalid/NoneExported"),
7352 inBuf: ` {}`,
7353 inVal: addr(structNoneExported{}),
7354 want: addr(structNoneExported{}),
7355 wantErr: EU(errNoExportedFields).withPos(` `, "").withType('{', T[structNoneExported]()),
7356 }, {
7357 name: jsontest.Name("Structs/Invalid/MalformedTag"),
7358 inBuf: `{}`,
7359 inVal: addr(structMalformedTag{}),
7360 want: addr(structMalformedTag{}),
7361 wantErr: EU(errors.New("Go struct field Malformed has malformed `json` tag: invalid character '\"' at start of option (expecting Unicode letter)")).withType('{', T[structMalformedTag]()),
7362 }, {
7363 name: jsontest.Name("Structs/Invalid/UnexportedTag"),
7364 inBuf: `{}`,
7365 inVal: addr(structUnexportedTag{}),
7366 want: addr(structUnexportedTag{}),
7367 wantErr: EU(errors.New("unexported Go struct field unexported cannot have non-ignored `json:\"name\"` tag")).withType('{', T[structUnexportedTag]()),
7368 }, {
7369 name: jsontest.Name("Structs/Invalid/ExportedEmbedded"),
7370 inBuf: `{"NamedString":"hello"}`,
7371 inVal: addr(structExportedEmbedded{}),
7372 want: addr(structExportedEmbedded{}),
7373 wantErr: EU(errors.New("embedded Go struct field NamedString of non-struct type must be explicitly given a JSON name")).withType('{', T[structExportedEmbedded]()),
7374 }, {
7375 name: jsontest.Name("Structs/Valid/ExportedEmbedded"),
7376 opts: []Options{jsonflags.ReportErrorsWithLegacySemantics | 1},
7377 inBuf: `{"NamedString":"hello"}`,
7378 inVal: addr(structExportedEmbedded{}),
7379 want: addr(structExportedEmbedded{"hello"}),
7380 }, {
7381 name: jsontest.Name("Structs/Valid/ExportedEmbeddedTag"),
7382 inBuf: `{"name":"hello"}`,
7383 inVal: addr(structExportedEmbeddedTag{}),
7384 want: addr(structExportedEmbeddedTag{"hello"}),
7385 }, {
7386 name: jsontest.Name("Structs/Invalid/UnexportedEmbedded"),
7387 inBuf: `{}`,
7388 inVal: addr(structUnexportedEmbedded{}),
7389 want: addr(structUnexportedEmbedded{}),
7390 wantErr: EU(errors.New("embedded Go struct field namedString of non-struct type must be explicitly given a JSON name")).withType('{', T[structUnexportedEmbedded]()),
7391 }, {
7392 name: jsontest.Name("Structs/UnexportedEmbeddedStruct"),
7393 inBuf: `{"Bool":true,"FizzBuzz":5,"Addr":"192.168.0.1"}`,
7394 inVal: addr(structUnexportedEmbeddedStruct{}),
7395 want: addr(structUnexportedEmbeddedStruct{structOmitZeroAll{Bool: true}, 5, structNestedAddr{netip.AddrFrom4([4]byte{192, 168, 0, 1})}}),
7396 }, {
7397 name: jsontest.Name("Structs/UnexportedEmbeddedStructPointer/Nil"),
7398 inBuf: `{"Bool":true,"FizzBuzz":5}`,
7399 inVal: addr(structUnexportedEmbeddedStructPointer{}),
7400 wantErr: EU(errNilField).withPos(`{"Bool":`, "/Bool").withType(0, T[structUnexportedEmbeddedStructPointer]()),
7401 }, {
7402 name: jsontest.Name("Structs/UnexportedEmbeddedStructPointer/Nil"),
7403 inBuf: `{"FizzBuzz":5,"Addr":"192.168.0.1"}`,
7404 inVal: addr(structUnexportedEmbeddedStructPointer{}),
7405 wantErr: EU(errNilField).withPos(`{"FizzBuzz":5,"Addr":`, "/Addr").withType(0, T[structUnexportedEmbeddedStructPointer]()),
7406 }, {
7407 name: jsontest.Name("Structs/UnexportedEmbeddedStructPointer/Nil"),
7408 inBuf: `{"Bool":true,"FizzBuzz":10,"Addr":"192.168.0.1"}`,
7409 inVal: addr(structUnexportedEmbeddedStructPointer{&structOmitZeroAll{Int: 5}, 5, &structNestedAddr{netip.AddrFrom4([4]byte{127, 0, 0, 1})}}),
7410 want: addr(structUnexportedEmbeddedStructPointer{&structOmitZeroAll{Bool: true, Int: 5}, 10, &structNestedAddr{netip.AddrFrom4([4]byte{192, 168, 0, 1})}}),
7411 }, {
7412 name: jsontest.Name("Structs/Unknown"),
7413 inBuf: `{
7414 "object0": {},
7415 "object1": {"key1": "value"},
7416 "object2": {"key1": "value", "key2": "value"},
7417 "objects": {"":{"":{"":{}}}},
7418 "array0": [],
7419 "array1": ["value1"],
7420 "array2": ["value1", "value2"],
7421 "array": [[[]]],
7422 "scalars": [null, false, true, "string", 12.345]
7423 }`,
7424 inVal: addr(struct{}{}),
7425 want: addr(struct{}{}),
7426 }, {
7427 name: jsontest.Name("Structs/IgnoreInvalidFormat"),
7428 opts: []Options{invalidFormatOption},
7429 inBuf: `{"Field":"Value"}`,
7430 inVal: addr(struct{ Field string }{}),
7431 want: addr(struct{ Field string }{"Value"}),
7432 }, {
7433 name: jsontest.Name("Slices/Null"),
7434 inBuf: `null`,
7435 inVal: addr([]string{"something"}),
7436 want: addr([]string(nil)),
7437 }, {
7438 name: jsontest.Name("Slices/Bool"),
7439 inBuf: `[true,false]`,
7440 inVal: new([]bool),
7441 want: addr([]bool{true, false}),
7442 }, {
7443 name: jsontest.Name("Slices/String"),
7444 inBuf: `["hello","goodbye"]`,
7445 inVal: new([]string),
7446 want: addr([]string{"hello", "goodbye"}),
7447 }, {
7448 name: jsontest.Name("Slices/Bytes"),
7449 inBuf: `["aGVsbG8=","Z29vZGJ5ZQ=="]`,
7450 inVal: new([][]byte),
7451 want: addr([][]byte{[]byte("hello"), []byte("goodbye")}),
7452 }, {
7453 name: jsontest.Name("Slices/Int"),
7454 inBuf: `[-2,-1,0,1,2]`,
7455 inVal: new([]int),
7456 want: addr([]int{-2, -1, 0, 1, 2}),
7457 }, {
7458 name: jsontest.Name("Slices/Uint"),
7459 inBuf: `[0,1,2,3,4]`,
7460 inVal: new([]uint),
7461 want: addr([]uint{0, 1, 2, 3, 4}),
7462 }, {
7463 name: jsontest.Name("Slices/Float"),
7464 inBuf: `[3.14159,12.34]`,
7465 inVal: new([]float64),
7466 want: addr([]float64{3.14159, 12.34}),
7467 }, {
7468
7469
7470
7471 name: jsontest.Name("Slices/Merge"),
7472 inBuf: `[{"k3":"v3"},{"k4":"v4"}]`,
7473 inVal: addr([]map[string]string{{"k1": "v1"}, {"k2": "v2"}}[:1]),
7474 want: addr([]map[string]string{{"k3": "v3"}, {"k4": "v4"}}),
7475 }, {
7476 name: jsontest.Name("Slices/Invalid/Channel"),
7477 inBuf: `["hello"]`,
7478 inVal: new([]chan string),
7479 want: addr([]chan string{nil}),
7480 wantErr: EU(nil).withPos(`[`, "/0").withType(0, T[chan string]()),
7481 }, {
7482 name: jsontest.Name("Slices/RecursiveSlice"),
7483 inBuf: `[[],[],[[]],[[],[]]]`,
7484 inVal: new(recursiveSlice),
7485 want: addr(recursiveSlice{
7486 {},
7487 {},
7488 {{}},
7489 {{}, {}},
7490 }),
7491 }, {
7492 name: jsontest.Name("Slices/Invalid/Bool"),
7493 inBuf: `true`,
7494 inVal: addr([]string{"nochange"}),
7495 want: addr([]string{"nochange"}),
7496 wantErr: EU(nil).withType('t', T[[]string]()),
7497 }, {
7498 name: jsontest.Name("Slices/Invalid/String"),
7499 inBuf: `""`,
7500 inVal: addr([]string{"nochange"}),
7501 want: addr([]string{"nochange"}),
7502 wantErr: EU(nil).withType('"', T[[]string]()),
7503 }, {
7504 name: jsontest.Name("Slices/Invalid/Number"),
7505 inBuf: `0`,
7506 inVal: addr([]string{"nochange"}),
7507 want: addr([]string{"nochange"}),
7508 wantErr: EU(nil).withType('0', T[[]string]()),
7509 }, {
7510 name: jsontest.Name("Slices/Invalid/Object"),
7511 inBuf: `{}`,
7512 inVal: addr([]string{"nochange"}),
7513 want: addr([]string{"nochange"}),
7514 wantErr: EU(nil).withType('{', T[[]string]()),
7515 }, {
7516 name: jsontest.Name("Slices/IgnoreInvalidFormat"),
7517 opts: []Options{invalidFormatOption},
7518 inBuf: `[false,true]`,
7519 inVal: addr([]bool{true, false}),
7520 want: addr([]bool{false, true}),
7521 }, {
7522 name: jsontest.Name("Arrays/Null"),
7523 inBuf: `null`,
7524 inVal: addr([1]string{"something"}),
7525 want: addr([1]string{}),
7526 }, {
7527 name: jsontest.Name("Arrays/Bool"),
7528 inBuf: `[true,false]`,
7529 inVal: new([2]bool),
7530 want: addr([2]bool{true, false}),
7531 }, {
7532 name: jsontest.Name("Arrays/String"),
7533 inBuf: `["hello","goodbye"]`,
7534 inVal: new([2]string),
7535 want: addr([2]string{"hello", "goodbye"}),
7536 }, {
7537 name: jsontest.Name("Arrays/Bytes"),
7538 inBuf: `["aGVsbG8=","Z29vZGJ5ZQ=="]`,
7539 inVal: new([2][]byte),
7540 want: addr([2][]byte{[]byte("hello"), []byte("goodbye")}),
7541 }, {
7542 name: jsontest.Name("Arrays/Int"),
7543 inBuf: `[-2,-1,0,1,2]`,
7544 inVal: new([5]int),
7545 want: addr([5]int{-2, -1, 0, 1, 2}),
7546 }, {
7547 name: jsontest.Name("Arrays/Uint"),
7548 inBuf: `[0,1,2,3,4]`,
7549 inVal: new([5]uint),
7550 want: addr([5]uint{0, 1, 2, 3, 4}),
7551 }, {
7552 name: jsontest.Name("Arrays/Float"),
7553 inBuf: `[3.14159,12.34]`,
7554 inVal: new([2]float64),
7555 want: addr([2]float64{3.14159, 12.34}),
7556 }, {
7557
7558
7559 name: jsontest.Name("Arrays/Merge"),
7560 inBuf: `[{"k3":"v3"},{"k4":"v4"}]`,
7561 inVal: addr([2]map[string]string{{"k1": "v1"}, {"k2": "v2"}}),
7562 want: addr([2]map[string]string{{"k3": "v3"}, {"k4": "v4"}}),
7563 }, {
7564 name: jsontest.Name("Arrays/Invalid/Channel"),
7565 inBuf: `["hello"]`,
7566 inVal: new([1]chan string),
7567 want: new([1]chan string),
7568 wantErr: EU(nil).withPos(`[`, "/0").withType(0, T[chan string]()),
7569 }, {
7570 name: jsontest.Name("Arrays/Invalid/Underflow"),
7571 inBuf: `{"F":[ ]}`,
7572 inVal: new(struct{ F [1]string }),
7573 want: addr(struct{ F [1]string }{}),
7574 wantErr: EU(errArrayUnderflow).withPos(`{"F":[ `, "/F").withType(']', T[[1]string]()),
7575 }, {
7576 name: jsontest.Name("Arrays/Invalid/Underflow/UnmarshalArrayFromAnyLength"),
7577 opts: []Options{jsonflags.UnmarshalArrayFromAnyLength | 1},
7578 inBuf: `[-1,-2]`,
7579 inVal: addr([4]int{1, 2, 3, 4}),
7580 want: addr([4]int{-1, -2, 0, 0}),
7581 }, {
7582 name: jsontest.Name("Arrays/Invalid/Overflow"),
7583 inBuf: `["1","2"]`,
7584 inVal: new([1]string),
7585 want: addr([1]string{"1"}),
7586 wantErr: EU(errArrayOverflow).withPos(`["1","2"`, "").withType(']', T[[1]string]()),
7587 }, {
7588 name: jsontest.Name("Arrays/Invalid/Overflow/UnmarshalArrayFromAnyLength"),
7589 opts: []Options{jsonflags.UnmarshalArrayFromAnyLength | 1},
7590 inBuf: `[-1,-2,-3,-4,-5,-6]`,
7591 inVal: addr([4]int{1, 2, 3, 4}),
7592 want: addr([4]int{-1, -2, -3, -4}),
7593 }, {
7594 name: jsontest.Name("Arrays/Invalid/Bool"),
7595 inBuf: `true`,
7596 inVal: addr([1]string{"nochange"}),
7597 want: addr([1]string{"nochange"}),
7598 wantErr: EU(nil).withType('t', T[[1]string]()),
7599 }, {
7600 name: jsontest.Name("Arrays/Invalid/String"),
7601 inBuf: `""`,
7602 inVal: addr([1]string{"nochange"}),
7603 want: addr([1]string{"nochange"}),
7604 wantErr: EU(nil).withType('"', T[[1]string]()),
7605 }, {
7606 name: jsontest.Name("Arrays/Invalid/Number"),
7607 inBuf: `0`,
7608 inVal: addr([1]string{"nochange"}),
7609 want: addr([1]string{"nochange"}),
7610 wantErr: EU(nil).withType('0', T[[1]string]()),
7611 }, {
7612 name: jsontest.Name("Arrays/Invalid/Object"),
7613 inBuf: `{}`,
7614 inVal: addr([1]string{"nochange"}),
7615 want: addr([1]string{"nochange"}),
7616 wantErr: EU(nil).withType('{', T[[1]string]()),
7617 }, {
7618 name: jsontest.Name("Arrays/IgnoreInvalidFormat"),
7619 opts: []Options{invalidFormatOption},
7620 inBuf: `[false,true]`,
7621 inVal: addr([2]bool{true, false}),
7622 want: addr([2]bool{false, true}),
7623 }, {
7624 name: jsontest.Name("Pointers/NullL0"),
7625 inBuf: `null`,
7626 inVal: new(*string),
7627 want: addr((*string)(nil)),
7628 }, {
7629 name: jsontest.Name("Pointers/NullL1"),
7630 inBuf: `null`,
7631 inVal: addr(new(*string)),
7632 want: addr((**string)(nil)),
7633 }, {
7634 name: jsontest.Name("Pointers/Bool"),
7635 inBuf: `true`,
7636 inVal: addr(new(bool)),
7637 want: addr(addr(true)),
7638 }, {
7639 name: jsontest.Name("Pointers/String"),
7640 inBuf: `"hello"`,
7641 inVal: addr(new(string)),
7642 want: addr(addr("hello")),
7643 }, {
7644 name: jsontest.Name("Pointers/Bytes"),
7645 inBuf: `"aGVsbG8="`,
7646 inVal: addr(new([]byte)),
7647 want: addr(addr([]byte("hello"))),
7648 }, {
7649 name: jsontest.Name("Pointers/Int"),
7650 inBuf: `-123`,
7651 inVal: addr(new(int)),
7652 want: addr(addr(int(-123))),
7653 }, {
7654 name: jsontest.Name("Pointers/Uint"),
7655 inBuf: `123`,
7656 inVal: addr(new(int)),
7657 want: addr(addr(int(123))),
7658 }, {
7659 name: jsontest.Name("Pointers/Float"),
7660 inBuf: `123.456`,
7661 inVal: addr(new(float64)),
7662 want: addr(addr(float64(123.456))),
7663 }, {
7664 name: jsontest.Name("Pointers/Allocate"),
7665 inBuf: `"hello"`,
7666 inVal: addr((*string)(nil)),
7667 want: addr(addr("hello")),
7668 }, {
7669 name: jsontest.Name("Points/IgnoreInvalidFormat"),
7670 opts: []Options{invalidFormatOption},
7671 inBuf: `true`,
7672 inVal: addr(new(bool)),
7673 want: addr(addr(true)),
7674 }, {
7675 name: jsontest.Name("Interfaces/Empty/Null"),
7676 inBuf: `null`,
7677 inVal: new(any),
7678 want: new(any),
7679 }, {
7680 name: jsontest.Name("Interfaces/NonEmpty/Null"),
7681 inBuf: `null`,
7682 inVal: new(io.Reader),
7683 want: new(io.Reader),
7684 }, {
7685 name: jsontest.Name("Interfaces/NonEmpty/Invalid"),
7686 inBuf: `"hello"`,
7687 inVal: new(io.Reader),
7688 want: new(io.Reader),
7689 wantErr: EU(internal.ErrNilInterface).withType(0, T[io.Reader]()),
7690 }, {
7691 name: jsontest.Name("Interfaces/Empty/False"),
7692 inBuf: `false`,
7693 inVal: new(any),
7694 want: func() any {
7695 var vi any = false
7696 return &vi
7697 }(),
7698 }, {
7699 name: jsontest.Name("Interfaces/Empty/True"),
7700 inBuf: `true`,
7701 inVal: new(any),
7702 want: func() any {
7703 var vi any = true
7704 return &vi
7705 }(),
7706 }, {
7707 name: jsontest.Name("Interfaces/Empty/String"),
7708 inBuf: `"string"`,
7709 inVal: new(any),
7710 want: func() any {
7711 var vi any = "string"
7712 return &vi
7713 }(),
7714 }, {
7715 name: jsontest.Name("Interfaces/Empty/Number"),
7716 inBuf: `3.14159`,
7717 inVal: new(any),
7718 want: func() any {
7719 var vi any = 3.14159
7720 return &vi
7721 }(),
7722 }, {
7723 name: jsontest.Name("Interfaces/Empty/Object"),
7724 inBuf: `{"k":"v"}`,
7725 inVal: new(any),
7726 want: func() any {
7727 var vi any = map[string]any{"k": "v"}
7728 return &vi
7729 }(),
7730 }, {
7731 name: jsontest.Name("Interfaces/Empty/Array"),
7732 inBuf: `["v"]`,
7733 inVal: new(any),
7734 want: func() any {
7735 var vi any = []any{"v"}
7736 return &vi
7737 }(),
7738 }, {
7739 name: jsontest.Name("Interfaces/NamedAny/String"),
7740 inBuf: `"string"`,
7741 inVal: new(namedAny),
7742 want: func() namedAny {
7743 var vi namedAny = "string"
7744 return &vi
7745 }(),
7746 }, {
7747 name: jsontest.Name("Interfaces/Invalid"),
7748 inBuf: `]`,
7749 inVal: new(any),
7750 want: new(any),
7751 wantErr: newInvalidCharacterError("]", "at start of value", 0, ""),
7752 }, {
7753
7754
7755
7756
7757 name: jsontest.Name("Interfaces/Merge/Map"),
7758 inBuf: `{"k2":"v2"}`,
7759 inVal: func() any {
7760 var vi any = map[string]string{"k1": "v1"}
7761 return &vi
7762 }(),
7763 want: func() any {
7764 var vi any = map[string]string{"k1": "v1", "k2": "v2"}
7765 return &vi
7766 }(),
7767 }, {
7768 name: jsontest.Name("Interfaces/Merge/Struct"),
7769 inBuf: `{"Array":["goodbye"]}`,
7770 inVal: func() any {
7771 var vi any = structAll{String: "hello"}
7772 return &vi
7773 }(),
7774 want: func() any {
7775 var vi any = structAll{String: "hello", Array: [1]string{"goodbye"}}
7776 return &vi
7777 }(),
7778 }, {
7779 name: jsontest.Name("Interfaces/Merge/NamedInt"),
7780 inBuf: `64`,
7781 inVal: func() any {
7782 var vi any = namedInt64(-64)
7783 return &vi
7784 }(),
7785 want: func() any {
7786 var vi any = namedInt64(+64)
7787 return &vi
7788 }(),
7789 }, {
7790 name: jsontest.Name("Interfaces/IgnoreInvalidFormat"),
7791 opts: []Options{invalidFormatOption},
7792 inBuf: `true`,
7793 inVal: new(any),
7794 want: func() any {
7795 var vi any = true
7796 return &vi
7797 }(),
7798 }, {
7799 name: jsontest.Name("Interfaces/Any"),
7800 inBuf: `{"X":[null,false,true,"",0,{},[]]}`,
7801 inVal: new(struct{ X any }),
7802 want: addr(struct{ X any }{[]any{nil, false, true, "", 0.0, map[string]any{}, []any{}}}),
7803 }, {
7804 name: jsontest.Name("Interfaces/Any/Named"),
7805 inBuf: `{"X":[null,false,true,"",0,{},[]]}`,
7806 inVal: new(struct{ X namedAny }),
7807 want: addr(struct{ X namedAny }{[]any{nil, false, true, "", 0.0, map[string]any{}, []any{}}}),
7808 }, {
7809 name: jsontest.Name("Interfaces/Any/Stringified"),
7810 opts: []Options{StringifyNumbers(true)},
7811 inBuf: `{"X":"0"}`,
7812 inVal: new(struct{ X any }),
7813 want: addr(struct{ X any }{"0"}),
7814 }, {
7815 name: jsontest.Name("Interfaces/Any/UnmarshalFunc/Any"),
7816 opts: []Options{
7817 WithUnmarshalers(UnmarshalFunc(func(b []byte, v *any) error {
7818 *v = "called"
7819 return nil
7820 })),
7821 },
7822 inBuf: `{"X":[null,false,true,"",0,{},[]]}`,
7823 inVal: new(struct{ X any }),
7824 want: addr(struct{ X any }{"called"}),
7825 }, {
7826 name: jsontest.Name("Interfaces/Any/UnmarshalFunc/Bool"),
7827 opts: []Options{
7828 WithUnmarshalers(UnmarshalFunc(func(b []byte, v *bool) error {
7829 *v = string(b) != "true"
7830 return nil
7831 })),
7832 },
7833 inBuf: `{"X":[null,false,true,"",0,{},[]]}`,
7834 inVal: new(struct{ X any }),
7835 want: addr(struct{ X any }{[]any{nil, true, false, "", 0.0, map[string]any{}, []any{}}}),
7836 }, {
7837 name: jsontest.Name("Interfaces/Any/UnmarshalFunc/String"),
7838 opts: []Options{
7839 WithUnmarshalers(UnmarshalFunc(func(b []byte, v *string) error {
7840 *v = "called"
7841 return nil
7842 })),
7843 },
7844 inBuf: `{"X":[null,false,true,"",0,{},[]]}`,
7845 inVal: new(struct{ X any }),
7846 want: addr(struct{ X any }{[]any{nil, false, true, "called", 0.0, map[string]any{}, []any{}}}),
7847 }, {
7848 name: jsontest.Name("Interfaces/Any/UnmarshalFunc/Float64"),
7849 opts: []Options{
7850 WithUnmarshalers(UnmarshalFunc(func(b []byte, v *float64) error {
7851 *v = 3.14159
7852 return nil
7853 })),
7854 },
7855 inBuf: `{"X":[null,false,true,"",0,{},[]]}`,
7856 inVal: new(struct{ X any }),
7857 want: addr(struct{ X any }{[]any{nil, false, true, "", 3.14159, map[string]any{}, []any{}}}),
7858 }, {
7859 name: jsontest.Name("Interfaces/Any/UnmarshalFunc/MapStringAny"),
7860 opts: []Options{
7861 WithUnmarshalers(UnmarshalFunc(func(b []byte, v *map[string]any) error {
7862 *v = map[string]any{"called": nil}
7863 return nil
7864 })),
7865 },
7866 inBuf: `{"X":[null,false,true,"",0,{},[]]}`,
7867 inVal: new(struct{ X any }),
7868 want: addr(struct{ X any }{[]any{nil, false, true, "", 0.0, map[string]any{"called": nil}, []any{}}}),
7869 }, {
7870 name: jsontest.Name("Interfaces/Any/UnmarshalFunc/SliceAny"),
7871 opts: []Options{
7872 WithUnmarshalers(UnmarshalFunc(func(b []byte, v *[]any) error {
7873 *v = []any{"called"}
7874 return nil
7875 })),
7876 },
7877 inBuf: `{"X":[null,false,true,"",0,{},[]]}`,
7878 inVal: new(struct{ X any }),
7879 want: addr(struct{ X any }{[]any{"called"}}),
7880 }, {
7881 name: jsontest.Name("Interfaces/Any/Maps/NonEmpty"),
7882 inBuf: `{"X":{"fizz":"buzz"}}`,
7883 inVal: new(struct{ X any }),
7884 want: addr(struct{ X any }{map[string]any{"fizz": "buzz"}}),
7885 }, {
7886 name: jsontest.Name("Interfaces/Any/Maps/RejectDuplicateNames"),
7887 inBuf: `{"X":{"fizz":"buzz","fizz":true}}`,
7888 inVal: new(struct{ X any }),
7889 want: addr(struct{ X any }{map[string]any{"fizz": "buzz"}}),
7890 wantErr: newDuplicateNameError("/X", []byte(`"fizz"`), len64(`{"X":{"fizz":"buzz",`)),
7891 }, {
7892 name: jsontest.Name("Interfaces/Any/Maps/AllowDuplicateNames"),
7893 opts: []Options{jsontext.AllowDuplicateNames(true)},
7894 inBuf: `{"X":{"fizz":"buzz","fizz":true}}`,
7895 inVal: new(struct{ X any }),
7896 want: addr(struct{ X any }{map[string]any{"fizz": "buzz"}}),
7897 wantErr: EU(nil).withPos(`{"X":{"fizz":"buzz","fizz":`, "/X/fizz").withType('t', T[string]()),
7898 }, {
7899 name: jsontest.Name("Interfaces/Any/Slices/NonEmpty"),
7900 inBuf: `{"X":["fizz","buzz"]}`,
7901 inVal: new(struct{ X any }),
7902 want: addr(struct{ X any }{[]any{"fizz", "buzz"}}),
7903 }, {
7904 name: jsontest.Name("Methods/NilPointer/Null"),
7905 inBuf: `{"X":null}`,
7906 inVal: addr(struct{ X *allMethods }{X: (*allMethods)(nil)}),
7907 want: addr(struct{ X *allMethods }{X: (*allMethods)(nil)}),
7908 }, {
7909 name: jsontest.Name("Methods/NilPointer/Value"),
7910 inBuf: `{"X":"value"}`,
7911 inVal: addr(struct{ X *allMethods }{X: (*allMethods)(nil)}),
7912 want: addr(struct{ X *allMethods }{X: &allMethods{method: "UnmarshalJSONFrom", value: []byte(`"value"`)}}),
7913 }, {
7914 name: jsontest.Name("Methods/NilInterface/Null"),
7915 inBuf: `{"X":null}`,
7916 inVal: addr(struct{ X MarshalerTo }{X: (*allMethods)(nil)}),
7917 want: addr(struct{ X MarshalerTo }{X: nil}),
7918 }, {
7919 name: jsontest.Name("Methods/NilInterface/Value"),
7920 inBuf: `{"X":"value"}`,
7921 inVal: addr(struct{ X MarshalerTo }{X: (*allMethods)(nil)}),
7922 want: addr(struct{ X MarshalerTo }{X: &allMethods{method: "UnmarshalJSONFrom", value: []byte(`"value"`)}}),
7923 }, {
7924 name: jsontest.Name("Methods/AllMethods"),
7925 inBuf: `{"X":"hello"}`,
7926 inVal: new(struct{ X *allMethods }),
7927 want: addr(struct{ X *allMethods }{X: &allMethods{method: "UnmarshalJSONFrom", value: []byte(`"hello"`)}}),
7928 }, {
7929 name: jsontest.Name("Methods/AllMethodsExceptJSONv2"),
7930 inBuf: `{"X":"hello"}`,
7931 inVal: new(struct{ X *allMethodsExceptJSONv2 }),
7932 want: addr(struct{ X *allMethodsExceptJSONv2 }{X: &allMethodsExceptJSONv2{allMethods: allMethods{method: "UnmarshalJSON", value: []byte(`"hello"`)}}}),
7933 }, {
7934 name: jsontest.Name("Methods/AllMethodsExceptJSONv1"),
7935 inBuf: `{"X":"hello"}`,
7936 inVal: new(struct{ X *allMethodsExceptJSONv1 }),
7937 want: addr(struct{ X *allMethodsExceptJSONv1 }{X: &allMethodsExceptJSONv1{allMethods: allMethods{method: "UnmarshalJSONFrom", value: []byte(`"hello"`)}}}),
7938 }, {
7939 name: jsontest.Name("Methods/AllMethodsExceptText"),
7940 inBuf: `{"X":"hello"}`,
7941 inVal: new(struct{ X *allMethodsExceptText }),
7942 want: addr(struct{ X *allMethodsExceptText }{X: &allMethodsExceptText{allMethods: allMethods{method: "UnmarshalJSONFrom", value: []byte(`"hello"`)}}}),
7943 }, {
7944 name: jsontest.Name("Methods/OnlyMethodJSONv2"),
7945 inBuf: `{"X":"hello"}`,
7946 inVal: new(struct{ X *onlyMethodJSONv2 }),
7947 want: addr(struct{ X *onlyMethodJSONv2 }{X: &onlyMethodJSONv2{allMethods: allMethods{method: "UnmarshalJSONFrom", value: []byte(`"hello"`)}}}),
7948 }, {
7949 name: jsontest.Name("Methods/OnlyMethodJSONv1"),
7950 inBuf: `{"X":"hello"}`,
7951 inVal: new(struct{ X *onlyMethodJSONv1 }),
7952 want: addr(struct{ X *onlyMethodJSONv1 }{X: &onlyMethodJSONv1{allMethods: allMethods{method: "UnmarshalJSON", value: []byte(`"hello"`)}}}),
7953 }, {
7954 name: jsontest.Name("Methods/OnlyMethodText"),
7955 inBuf: `{"X":"hello"}`,
7956 inVal: new(struct{ X *onlyMethodText }),
7957 want: addr(struct{ X *onlyMethodText }{X: &onlyMethodText{allMethods: allMethods{method: "UnmarshalText", value: []byte(`hello`)}}}),
7958 }, {
7959 name: jsontest.Name("Methods/Text/Null"),
7960 inBuf: `{"X":null}`,
7961 inVal: addr(struct{ X unmarshalTextFunc }{unmarshalTextFunc(func(b []byte) error {
7962 return errMustNotCall
7963 })}),
7964 want: addr(struct{ X unmarshalTextFunc }{nil}),
7965 }, {
7966 name: jsontest.Name("Methods/IP"),
7967 inBuf: `"192.168.0.100"`,
7968 inVal: new(net.IP),
7969 want: addr(net.IPv4(192, 168, 0, 100)),
7970 }, {
7971
7972 name: jsontest.Name("Methods/Anonymous"),
7973 inBuf: `{"X":"hello"}`,
7974 inVal: new(struct{ X struct{ allMethods } }),
7975 want: addr(struct{ X struct{ allMethods } }{X: struct{ allMethods }{allMethods{method: "UnmarshalJSONFrom", value: []byte(`"hello"`)}}}),
7976 }, {
7977
7978 name: jsontest.Name("Methods/Addressable"),
7979 inBuf: `{"V":"hello","M":{"K":"hello"},"I":"hello"}`,
7980 inVal: addr(struct {
7981 V allMethods
7982 M map[string]allMethods
7983 I any
7984 }{
7985 I: allMethods{},
7986 }),
7987 want: addr(struct {
7988 V allMethods
7989 M map[string]allMethods
7990 I any
7991 }{
7992 V: allMethods{method: "UnmarshalJSONFrom", value: []byte(`"hello"`)},
7993 M: map[string]allMethods{"K": {method: "UnmarshalJSONFrom", value: []byte(`"hello"`)}},
7994 I: allMethods{method: "UnmarshalJSONFrom", value: []byte(`"hello"`)},
7995 }),
7996 }, {
7997
7998 name: jsontest.Name("Methods/MapKey/JSONv2"),
7999 inBuf: `{"k1":"v1b","k2":"v2"}`,
8000 inVal: addr(map[structMethodJSONv2]string{{"k1"}: "v1a", {"k3"}: "v3"}),
8001 want: addr(map[structMethodJSONv2]string{{"k1"}: "v1b", {"k2"}: "v2", {"k3"}: "v3"}),
8002 }, {
8003
8004 name: jsontest.Name("Methods/MapKey/JSONv1"),
8005 inBuf: `{"k1":"v1b","k2":"v2"}`,
8006 inVal: addr(map[structMethodJSONv1]string{{"k1"}: "v1a", {"k3"}: "v3"}),
8007 want: addr(map[structMethodJSONv1]string{{"k1"}: "v1b", {"k2"}: "v2", {"k3"}: "v3"}),
8008 }, {
8009 name: jsontest.Name("Methods/MapKey/Text"),
8010 inBuf: `{"k1":"v1b","k2":"v2"}`,
8011 inVal: addr(map[structMethodText]string{{"k1"}: "v1a", {"k3"}: "v3"}),
8012 want: addr(map[structMethodText]string{{"k1"}: "v1b", {"k2"}: "v2", {"k3"}: "v3"}),
8013 }, {
8014 name: jsontest.Name("Methods/JSONv2/ErrUnsupported"),
8015 inBuf: `{"fizz":123}`,
8016 inVal: addr(unsupportedMethodJSONv2{}),
8017 want: addr(unsupportedMethodJSONv2{"called": 1, "fizz": 123}),
8018 }, {
8019 name: jsontest.Name("Methods/Invalid/JSONv2/Error"),
8020 inBuf: `{}`,
8021 inVal: addr(unmarshalJSONv2Func(func(*jsontext.Decoder) error {
8022 return errSomeError
8023 })),
8024 wantErr: EU(errSomeError).withType(0, T[unmarshalJSONv2Func]()),
8025 }, {
8026 name: jsontest.Name("Methods/Invalid/JSONv2/TooFew"),
8027 inBuf: `{}`,
8028 inVal: addr(unmarshalJSONv2Func(func(*jsontext.Decoder) error {
8029 return nil
8030 })),
8031 wantErr: EU(errNonSingularValue).withType(0, T[unmarshalJSONv2Func]()),
8032 }, {
8033 name: jsontest.Name("Methods/Invalid/JSONv2/TooMany"),
8034 inBuf: `{}{}`,
8035 inVal: addr(unmarshalJSONv2Func(func(dec *jsontext.Decoder) error {
8036 dec.ReadValue()
8037 dec.ReadValue()
8038 return nil
8039 })),
8040 wantErr: EU(errNonSingularValue).withPos(`{}`, "").withType(0, T[unmarshalJSONv2Func]()),
8041 }, {
8042 name: jsontest.Name("Methods/Invalid/JSONv2/ErrUnsupported"),
8043 inBuf: `{}`,
8044 inVal: addr(unmarshalJSONv2Func(func(*jsontext.Decoder) error {
8045 return errors.ErrUnsupported
8046 })),
8047 wantErr: EU(nil).withType(0, T[unmarshalJSONv2Func]()),
8048 }, {
8049 name: jsontest.Name("Methods/Invalid/JSONv1/Error"),
8050 inBuf: `{}`,
8051 inVal: addr(unmarshalJSONv1Func(func([]byte) error {
8052 return errSomeError
8053 })),
8054 wantErr: EU(errSomeError).withType('{', T[unmarshalJSONv1Func]()),
8055 }, {
8056 name: jsontest.Name("Methods/Invalid/JSONv1/ErrUnsupported"),
8057 inBuf: `{}`,
8058 inVal: addr(unmarshalJSONv1Func(func([]byte) error {
8059 return errors.ErrUnsupported
8060 })),
8061 wantErr: EU(wrapErrUnsupported(errors.ErrUnsupported, "UnmarshalJSON method")).withType('{', T[unmarshalJSONv1Func]()),
8062 }, {
8063 name: jsontest.Name("Methods/Invalid/Text/Error"),
8064 inBuf: `"value"`,
8065 inVal: addr(unmarshalTextFunc(func([]byte) error {
8066 return errSomeError
8067 })),
8068 wantErr: EU(errSomeError).withType('"', T[unmarshalTextFunc]()),
8069 }, {
8070 name: jsontest.Name("Methods/Invalid/Text/Syntax"),
8071 inBuf: `{}`,
8072 inVal: addr(unmarshalTextFunc(func([]byte) error {
8073 panic("should not be called")
8074 })),
8075 wantErr: EU(errNonStringValue).withType('{', T[unmarshalTextFunc]()),
8076 }, {
8077 name: jsontest.Name("Methods/Invalid/Text/ErrUnsupported"),
8078 inBuf: `"value"`,
8079 inVal: addr(unmarshalTextFunc(func([]byte) error {
8080 return errors.ErrUnsupported
8081 })),
8082 wantErr: EU(wrapErrUnsupported(errors.ErrUnsupported, "UnmarshalText method")).withType('"', T[unmarshalTextFunc]()),
8083 }, {
8084 name: jsontest.Name("Functions/String/V1"),
8085 opts: []Options{
8086 WithUnmarshalers(UnmarshalFunc(func(b []byte, v *string) error {
8087 if string(b) != `""` {
8088 return fmt.Errorf("got %s, want %s", b, `""`)
8089 }
8090 *v = "called"
8091 return nil
8092 })),
8093 },
8094 inBuf: `""`,
8095 inVal: addr(""),
8096 want: addr("called"),
8097 }, {
8098 name: jsontest.Name("Functions/String/Empty"),
8099 opts: []Options{WithUnmarshalers(nil)},
8100 inBuf: `"hello"`,
8101 inVal: addr(""),
8102 want: addr("hello"),
8103 }, {
8104 name: jsontest.Name("Functions/NamedString/V1/NoMatch"),
8105 opts: []Options{
8106 WithUnmarshalers(UnmarshalFunc(func(b []byte, v *namedString) error {
8107 panic("should not be called")
8108 })),
8109 },
8110 inBuf: `""`,
8111 inVal: addr(""),
8112 want: addr(""),
8113 }, {
8114 name: jsontest.Name("Functions/NamedString/V1/Match"),
8115 opts: []Options{
8116 WithUnmarshalers(UnmarshalFunc(func(b []byte, v *namedString) error {
8117 if string(b) != `""` {
8118 return fmt.Errorf("got %s, want %s", b, `""`)
8119 }
8120 *v = "called"
8121 return nil
8122 })),
8123 },
8124 inBuf: `""`,
8125 inVal: addr(namedString("")),
8126 want: addr(namedString("called")),
8127 }, {
8128 name: jsontest.Name("Functions/String/V2"),
8129 opts: []Options{
8130 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v *string) error {
8131 switch b, err := dec.ReadValue(); {
8132 case err != nil:
8133 return err
8134 case string(b) != `""`:
8135 return fmt.Errorf("got %s, want %s", b, `""`)
8136 }
8137 *v = "called"
8138 return nil
8139 })),
8140 },
8141 inBuf: `""`,
8142 inVal: addr(""),
8143 want: addr("called"),
8144 }, {
8145 name: jsontest.Name("Functions/NamedString/V2/NoMatch"),
8146 opts: []Options{
8147 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v *namedString) error {
8148 panic("should not be called")
8149 })),
8150 },
8151 inBuf: `""`,
8152 inVal: addr(""),
8153 want: addr(""),
8154 }, {
8155 name: jsontest.Name("Functions/NamedString/V2/Match"),
8156 opts: []Options{
8157 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v *namedString) error {
8158 switch t, err := dec.ReadToken(); {
8159 case err != nil:
8160 return err
8161 case t.String() != ``:
8162 return fmt.Errorf("got %q, want %q", t, ``)
8163 }
8164 *v = "called"
8165 return nil
8166 })),
8167 },
8168 inBuf: `""`,
8169 inVal: addr(namedString("")),
8170 want: addr(namedString("called")),
8171 }, {
8172 name: jsontest.Name("Functions/String/Empty1/NoMatch"),
8173 opts: []Options{
8174 WithUnmarshalers(new(Unmarshalers)),
8175 },
8176 inBuf: `""`,
8177 inVal: addr(""),
8178 want: addr(""),
8179 }, {
8180 name: jsontest.Name("Functions/String/Empty2/NoMatch"),
8181 opts: []Options{
8182 WithUnmarshalers(JoinUnmarshalers()),
8183 },
8184 inBuf: `""`,
8185 inVal: addr(""),
8186 want: addr(""),
8187 }, {
8188 name: jsontest.Name("Functions/String/V1/DirectError"),
8189 opts: []Options{
8190 WithUnmarshalers(UnmarshalFunc(func([]byte, *string) error {
8191 return errSomeError
8192 })),
8193 },
8194 inBuf: `""`,
8195 inVal: addr(""),
8196 want: addr(""),
8197 wantErr: EU(errSomeError).withType('"', reflect.PointerTo(stringType)),
8198 }, {
8199 name: jsontest.Name("Functions/String/V1/SkipError"),
8200 opts: []Options{
8201 WithUnmarshalers(UnmarshalFunc(func([]byte, *string) error {
8202 return errors.ErrUnsupported
8203 })),
8204 },
8205 inBuf: `""`,
8206 inVal: addr(""),
8207 want: addr(""),
8208 wantErr: EU(wrapErrUnsupported(errors.ErrUnsupported, "unmarshal function of type func([]byte, T) error")).withType('"', reflect.PointerTo(stringType)),
8209 }, {
8210 name: jsontest.Name("Functions/String/V2/DirectError"),
8211 opts: []Options{
8212 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v *string) error {
8213 return errSomeError
8214 })),
8215 },
8216 inBuf: `""`,
8217 inVal: addr(""),
8218 want: addr(""),
8219 wantErr: EU(errSomeError).withType(0, reflect.PointerTo(stringType)),
8220 }, {
8221 name: jsontest.Name("Functions/String/V2/TooFew"),
8222 opts: []Options{
8223 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v *string) error {
8224 return nil
8225 })),
8226 },
8227 inBuf: `""`,
8228 inVal: addr(""),
8229 want: addr(""),
8230 wantErr: EU(errNonSingularValue).withType(0, reflect.PointerTo(stringType)),
8231 }, {
8232 name: jsontest.Name("Functions/String/V2/TooMany"),
8233 opts: []Options{
8234 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v *string) error {
8235 if _, err := dec.ReadValue(); err != nil {
8236 return err
8237 }
8238 if _, err := dec.ReadValue(); err != nil {
8239 return err
8240 }
8241 return nil
8242 })),
8243 },
8244 inBuf: `{"X":["",""]}`,
8245 inVal: addr(struct{ X []string }{}),
8246 want: addr(struct{ X []string }{[]string{""}}),
8247 wantErr: EU(errNonSingularValue).withPos(`{"X":["",`, "/X").withType(0, reflect.PointerTo(stringType)),
8248 }, {
8249 name: jsontest.Name("Functions/String/V2/Skipped"),
8250 opts: []Options{
8251 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v *string) error {
8252 return errors.ErrUnsupported
8253 })),
8254 },
8255 inBuf: `""`,
8256 inVal: addr(""),
8257 want: addr(""),
8258 }, {
8259 name: jsontest.Name("Functions/String/V2/ProcessBeforeSkip"),
8260 opts: []Options{
8261 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v *string) error {
8262 if _, err := dec.ReadValue(); err != nil {
8263 return err
8264 }
8265 return errors.ErrUnsupported
8266 })),
8267 },
8268 inBuf: `""`,
8269 inVal: addr(""),
8270 want: addr(""),
8271 wantErr: EU(errUnsupportedMutation).withType(0, reflect.PointerTo(stringType)),
8272 }, {
8273 name: jsontest.Name("Functions/String/V2/WrappedUnsupported"),
8274 opts: []Options{
8275 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v *string) error {
8276 return fmt.Errorf("wrap: %w", errors.ErrUnsupported)
8277 })),
8278 },
8279 inBuf: `""`,
8280 inVal: addr(""),
8281 want: addr(""),
8282 }, {
8283 name: jsontest.Name("Functions/Map/Key/NoCaseString/V1"),
8284 opts: []Options{
8285 WithUnmarshalers(UnmarshalFunc(func(b []byte, v *nocaseString) error {
8286 if string(b) != `"hello"` {
8287 return fmt.Errorf("got %s, want %s", b, `"hello"`)
8288 }
8289 *v = "called"
8290 return nil
8291 })),
8292 },
8293 inBuf: `{"hello":"world"}`,
8294 inVal: addr(map[nocaseString]string{}),
8295 want: addr(map[nocaseString]string{"called": "world"}),
8296 }, {
8297 name: jsontest.Name("Functions/Map/Key/TextMarshaler/V1"),
8298 opts: []Options{
8299 WithUnmarshalers(UnmarshalFunc(func(b []byte, v encoding.TextMarshaler) error {
8300 if string(b) != `"hello"` {
8301 return fmt.Errorf("got %s, want %s", b, `"hello"`)
8302 }
8303 *v.(*nocaseString) = "called"
8304 return nil
8305 })),
8306 },
8307 inBuf: `{"hello":"world"}`,
8308 inVal: addr(map[nocaseString]string{}),
8309 want: addr(map[nocaseString]string{"called": "world"}),
8310 }, {
8311 name: jsontest.Name("Functions/Map/Key/NoCaseString/V2"),
8312 opts: []Options{
8313 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v *nocaseString) error {
8314 switch t, err := dec.ReadToken(); {
8315 case err != nil:
8316 return err
8317 case t.String() != "hello":
8318 return fmt.Errorf("got %q, want %q", t, "hello")
8319 }
8320 *v = "called"
8321 return nil
8322 })),
8323 },
8324 inBuf: `{"hello":"world"}`,
8325 inVal: addr(map[nocaseString]string{}),
8326 want: addr(map[nocaseString]string{"called": "world"}),
8327 }, {
8328 name: jsontest.Name("Functions/Map/Key/TextMarshaler/V2"),
8329 opts: []Options{
8330 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v encoding.TextMarshaler) error {
8331 switch b, err := dec.ReadValue(); {
8332 case err != nil:
8333 return err
8334 case string(b) != `"hello"`:
8335 return fmt.Errorf("got %s, want %s", b, `"hello"`)
8336 }
8337 *v.(*nocaseString) = "called"
8338 return nil
8339 })),
8340 },
8341 inBuf: `{"hello":"world"}`,
8342 inVal: addr(map[nocaseString]string{}),
8343 want: addr(map[nocaseString]string{"called": "world"}),
8344 }, {
8345 name: jsontest.Name("Functions/Map/Key/String/V1/DuplicateName"),
8346 opts: []Options{
8347 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v *string) error {
8348 if _, err := dec.ReadValue(); err != nil {
8349 return err
8350 }
8351 xd := export.Decoder(dec)
8352 *v = fmt.Sprintf("%d-%d", len(xd.Tokens.Stack), xd.Tokens.Last.Length())
8353 return nil
8354 })),
8355 },
8356 inBuf: `{"name":"value","name":"value"}`,
8357 inVal: addr(map[string]string{}),
8358 want: addr(map[string]string{"1-1": "1-2"}),
8359 wantErr: newDuplicateNameError("", []byte(`"name"`), len64(`{"name":"value",`)),
8360 }, {
8361 name: jsontest.Name("Functions/Map/Value/NoCaseString/V1"),
8362 opts: []Options{
8363 WithUnmarshalers(UnmarshalFunc(func(b []byte, v *nocaseString) error {
8364 if string(b) != `"world"` {
8365 return fmt.Errorf("got %s, want %s", b, `"world"`)
8366 }
8367 *v = "called"
8368 return nil
8369 })),
8370 },
8371 inBuf: `{"hello":"world"}`,
8372 inVal: addr(map[string]nocaseString{}),
8373 want: addr(map[string]nocaseString{"hello": "called"}),
8374 }, {
8375 name: jsontest.Name("Functions/Map/Value/TextMarshaler/V1"),
8376 opts: []Options{
8377 WithUnmarshalers(UnmarshalFunc(func(b []byte, v encoding.TextMarshaler) error {
8378 if string(b) != `"world"` {
8379 return fmt.Errorf("got %s, want %s", b, `"world"`)
8380 }
8381 *v.(*nocaseString) = "called"
8382 return nil
8383 })),
8384 },
8385 inBuf: `{"hello":"world"}`,
8386 inVal: addr(map[string]nocaseString{}),
8387 want: addr(map[string]nocaseString{"hello": "called"}),
8388 }, {
8389 name: jsontest.Name("Functions/Map/Value/NoCaseString/V2"),
8390 opts: []Options{
8391 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v *nocaseString) error {
8392 switch t, err := dec.ReadToken(); {
8393 case err != nil:
8394 return err
8395 case t.String() != "world":
8396 return fmt.Errorf("got %q, want %q", t, "world")
8397 }
8398 *v = "called"
8399 return nil
8400 })),
8401 },
8402 inBuf: `{"hello":"world"}`,
8403 inVal: addr(map[string]nocaseString{}),
8404 want: addr(map[string]nocaseString{"hello": "called"}),
8405 }, {
8406 name: jsontest.Name("Functions/Map/Value/TextMarshaler/V2"),
8407 opts: []Options{
8408 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v encoding.TextMarshaler) error {
8409 switch b, err := dec.ReadValue(); {
8410 case err != nil:
8411 return err
8412 case string(b) != `"world"`:
8413 return fmt.Errorf("got %s, want %s", b, `"world"`)
8414 }
8415 *v.(*nocaseString) = "called"
8416 return nil
8417 })),
8418 },
8419 inBuf: `{"hello":"world"}`,
8420 inVal: addr(map[string]nocaseString{}),
8421 want: addr(map[string]nocaseString{"hello": "called"}),
8422 }, {
8423 name: jsontest.Name("Funtions/Struct/Fields"),
8424 opts: []Options{
8425 WithUnmarshalers(JoinUnmarshalers(
8426 UnmarshalFunc(func(b []byte, v *bool) error {
8427 if string(b) != `"called1"` {
8428 return fmt.Errorf("got %s, want %s", b, `"called1"`)
8429 }
8430 *v = true
8431 return nil
8432 }),
8433 UnmarshalFunc(func(b []byte, v *string) error {
8434 if string(b) != `"called2"` {
8435 return fmt.Errorf("got %s, want %s", b, `"called2"`)
8436 }
8437 *v = "called2"
8438 return nil
8439 }),
8440 UnmarshalFromFunc(func(dec *jsontext.Decoder, v *[]byte) error {
8441 switch t, err := dec.ReadToken(); {
8442 case err != nil:
8443 return err
8444 case t.String() != "called3":
8445 return fmt.Errorf("got %q, want %q", t, "called3")
8446 }
8447 *v = []byte("called3")
8448 return nil
8449 }),
8450 UnmarshalFromFunc(func(dec *jsontext.Decoder, v *int64) error {
8451 switch b, err := dec.ReadValue(); {
8452 case err != nil:
8453 return err
8454 case string(b) != `"called4"`:
8455 return fmt.Errorf("got %s, want %s", b, `"called4"`)
8456 }
8457 *v = 123
8458 return nil
8459 }),
8460 )),
8461 },
8462 inBuf: `{"Bool":"called1","String":"called2","Bytes":"called3","Int":"called4","Uint":456,"Float":789}`,
8463 inVal: addr(structScalars{}),
8464 want: addr(structScalars{Bool: true, String: "called2", Bytes: []byte("called3"), Int: 123, Uint: 456, Float: 789}),
8465 }, {
8466 name: jsontest.Name("Functions/Struct/Embedded"),
8467 opts: []Options{
8468 WithUnmarshalers(JoinUnmarshalers(
8469 UnmarshalFunc(func([]byte, *structEmbeddedL1) error {
8470 panic("should not be called")
8471 }),
8472 UnmarshalFromFunc(func(dec *jsontext.Decoder, v *StructEmbed2) error {
8473 panic("should not be called")
8474 }),
8475 )),
8476 },
8477 inBuf: `{"E":"E3","F":"F3","G":"G3","A":"A1","B":"B1","D":"D2"}`,
8478 inVal: new(structEmbedded),
8479 want: addr(structEmbedded{
8480 X: structEmbeddedL1{
8481 X: &structEmbeddedL2{A: "A1", B: "B1" },
8482 StructEmbed1: StructEmbed1{ D: "D2" },
8483 },
8484 StructEmbed2: &StructEmbed2{E: "E3", F: "F3", G: "G3"},
8485 }),
8486 }, {
8487 name: jsontest.Name("Functions/Slice/Elem"),
8488 opts: []Options{
8489 WithUnmarshalers(UnmarshalFunc(func(b []byte, v *string) error {
8490 *v = strings.Trim(strings.ToUpper(string(b)), `"`)
8491 return nil
8492 })),
8493 },
8494 inBuf: `["hello","World"]`,
8495 inVal: addr([]string{}),
8496 want: addr([]string{"HELLO", "WORLD"}),
8497 }, {
8498 name: jsontest.Name("Functions/Array/Elem"),
8499 opts: []Options{
8500 WithUnmarshalers(UnmarshalFunc(func(b []byte, v *string) error {
8501 *v = strings.Trim(strings.ToUpper(string(b)), `"`)
8502 return nil
8503 })),
8504 },
8505 inBuf: `["hello","World"]`,
8506 inVal: addr([2]string{}),
8507 want: addr([2]string{"HELLO", "WORLD"}),
8508 }, {
8509 name: jsontest.Name("Functions/Pointer/Nil"),
8510 opts: []Options{
8511 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v *string) error {
8512 t, err := dec.ReadToken()
8513 *v = strings.ToUpper(t.String())
8514 return err
8515 })),
8516 },
8517 inBuf: `{"X":"hello"}`,
8518 inVal: addr(struct{ X *string }{nil}),
8519 want: addr(struct{ X *string }{addr("HELLO")}),
8520 }, {
8521 name: jsontest.Name("Functions/Pointer/NonNil"),
8522 opts: []Options{
8523 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v *string) error {
8524 t, err := dec.ReadToken()
8525 *v = strings.ToUpper(t.String())
8526 return err
8527 })),
8528 },
8529 inBuf: `{"X":"hello"}`,
8530 inVal: addr(struct{ X *string }{addr("")}),
8531 want: addr(struct{ X *string }{addr("HELLO")}),
8532 }, {
8533 name: jsontest.Name("Functions/Interface/Nil"),
8534 opts: []Options{
8535 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v fmt.Stringer) error {
8536 panic("should not be called")
8537 })),
8538 },
8539 inBuf: `{"X":"hello"}`,
8540 inVal: addr(struct{ X fmt.Stringer }{nil}),
8541 want: addr(struct{ X fmt.Stringer }{nil}),
8542 wantErr: EU(internal.ErrNilInterface).withPos(`{"X":`, "/X").withType(0, T[fmt.Stringer]()),
8543 }, {
8544 name: jsontest.Name("Functions/Interface/NetIP"),
8545 opts: []Options{
8546 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v *fmt.Stringer) error {
8547 *v = net.IP{}
8548 return errors.ErrUnsupported
8549 })),
8550 },
8551 inBuf: `{"X":"1.1.1.1"}`,
8552 inVal: addr(struct{ X fmt.Stringer }{nil}),
8553 want: addr(struct{ X fmt.Stringer }{net.IPv4(1, 1, 1, 1)}),
8554 }, {
8555 name: jsontest.Name("Functions/Interface/NewPointerNetIP"),
8556 opts: []Options{
8557 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v *fmt.Stringer) error {
8558 *v = new(net.IP)
8559 return errors.ErrUnsupported
8560 })),
8561 },
8562 inBuf: `{"X":"1.1.1.1"}`,
8563 inVal: addr(struct{ X fmt.Stringer }{nil}),
8564 want: addr(struct{ X fmt.Stringer }{addr(net.IPv4(1, 1, 1, 1))}),
8565 }, {
8566 name: jsontest.Name("Functions/Interface/NilPointerNetIP"),
8567 opts: []Options{
8568 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, v *fmt.Stringer) error {
8569 *v = (*net.IP)(nil)
8570 return errors.ErrUnsupported
8571 })),
8572 },
8573 inBuf: `{"X":"1.1.1.1"}`,
8574 inVal: addr(struct{ X fmt.Stringer }{nil}),
8575 want: addr(struct{ X fmt.Stringer }{addr(net.IPv4(1, 1, 1, 1))}),
8576 }, {
8577 name: jsontest.Name("Functions/Interface/NilPointerNetIP/Override"),
8578 opts: []Options{
8579 WithUnmarshalers(JoinUnmarshalers(
8580 UnmarshalFromFunc(func(dec *jsontext.Decoder, v *fmt.Stringer) error {
8581 *v = (*net.IP)(nil)
8582 return errors.ErrUnsupported
8583 }),
8584 UnmarshalFunc(func(b []byte, v *net.IP) error {
8585 b = bytes.ReplaceAll(b, []byte(`1`), []byte(`8`))
8586 return v.UnmarshalText(bytes.Trim(b, `"`))
8587 }),
8588 )),
8589 },
8590 inBuf: `{"X":"1.1.1.1"}`,
8591 inVal: addr(struct{ X fmt.Stringer }{nil}),
8592 want: addr(struct{ X fmt.Stringer }{addr(net.IPv4(8, 8, 8, 8))}),
8593 }, {
8594 name: jsontest.Name("Functions/Interface/Any"),
8595 opts: []Options{
8596 WithUnmarshalers(func() *Unmarshalers {
8597 type P struct {
8598 D int
8599 N int64
8600 }
8601 type PV struct {
8602 P P
8603 V any
8604 }
8605
8606 var lastChecks []func() error
8607 checkLast := func() error {
8608 for _, fn := range lastChecks {
8609 if err := fn(); err != nil {
8610 return err
8611 }
8612 }
8613 return errors.ErrUnsupported
8614 }
8615 makeValueChecker := func(name string, want []PV) func(d *jsontext.Decoder, v any) error {
8616 checkNext := func(d *jsontext.Decoder, v any) error {
8617 xd := export.Decoder(d)
8618 p := P{len(xd.Tokens.Stack), xd.Tokens.Last.Length()}
8619 rv := reflect.ValueOf(v)
8620 pv := PV{p, v}
8621 switch {
8622 case len(want) == 0:
8623 return fmt.Errorf("%s: %v: got more values than expected", name, p)
8624 case !rv.IsValid() || rv.Kind() != reflect.Pointer || rv.IsNil():
8625 return fmt.Errorf("%s: %v: got %#v, want non-nil pointer type", name, p, v)
8626 case !reflect.DeepEqual(pv, want[0]):
8627 return fmt.Errorf("%s:\n\tgot %#v\n\twant %#v", name, pv, want[0])
8628 default:
8629 want = want[1:]
8630 return errors.ErrUnsupported
8631 }
8632 }
8633 lastChecks = append(lastChecks, func() error {
8634 if len(want) > 0 {
8635 return fmt.Errorf("%s: did not get enough values, want %d more", name, len(want))
8636 }
8637 return nil
8638 })
8639 return checkNext
8640 }
8641 makePositionChecker := func(name string, want []P) func(d *jsontext.Decoder, v any) error {
8642 checkNext := func(d *jsontext.Decoder, v any) error {
8643 xd := export.Decoder(d)
8644 p := P{len(xd.Tokens.Stack), xd.Tokens.Last.Length()}
8645 switch {
8646 case len(want) == 0:
8647 return fmt.Errorf("%s: %v: got more values than wanted", name, p)
8648 case p != want[0]:
8649 return fmt.Errorf("%s: got %v, want %v", name, p, want[0])
8650 default:
8651 want = want[1:]
8652 return errors.ErrUnsupported
8653 }
8654 }
8655 lastChecks = append(lastChecks, func() error {
8656 if len(want) > 0 {
8657 return fmt.Errorf("%s: did not get enough values, want %d more", name, len(want))
8658 }
8659 return nil
8660 })
8661 return checkNext
8662 }
8663
8664
8665
8666 wantAny := []PV{
8667 {P{1, 0}, addr(any(nil))},
8668 {P{1, 1}, addr(any(valueStringer{}))},
8669 {P{1, 1}, addr(valueStringer{})},
8670 {P{1, 2}, addr(any((*valueStringer)(nil)))},
8671 {P{1, 2}, addr((*valueStringer)(nil))},
8672 {P{1, 2}, addr(valueStringer{})},
8673 {P{1, 3}, addr(any(addr(valueStringer{})))},
8674 {P{1, 3}, addr(addr(valueStringer{}))},
8675 {P{1, 3}, addr(valueStringer{})},
8676 {P{1, 4}, addr(any((**valueStringer)(nil)))},
8677 {P{1, 4}, addr((**valueStringer)(nil))},
8678 {P{1, 4}, addr((*valueStringer)(nil))},
8679 {P{1, 4}, addr(valueStringer{})},
8680 {P{1, 5}, addr(any(addr((*valueStringer)(nil))))},
8681 {P{1, 5}, addr(addr((*valueStringer)(nil)))},
8682 {P{1, 5}, addr((*valueStringer)(nil))},
8683 {P{1, 5}, addr(valueStringer{})},
8684 {P{1, 6}, addr(any(addr(addr(valueStringer{}))))},
8685 {P{1, 6}, addr(addr(addr(valueStringer{})))},
8686 {P{1, 6}, addr(addr(valueStringer{}))},
8687 {P{1, 6}, addr(valueStringer{})},
8688 {P{1, 7}, addr(any(pointerStringer{}))},
8689 {P{1, 7}, addr(pointerStringer{})},
8690 {P{1, 8}, addr(any((*pointerStringer)(nil)))},
8691 {P{1, 8}, addr((*pointerStringer)(nil))},
8692 {P{1, 8}, addr(pointerStringer{})},
8693 {P{1, 9}, addr(any(addr(pointerStringer{})))},
8694 {P{1, 9}, addr(addr(pointerStringer{}))},
8695 {P{1, 9}, addr(pointerStringer{})},
8696 {P{1, 10}, addr(any((**pointerStringer)(nil)))},
8697 {P{1, 10}, addr((**pointerStringer)(nil))},
8698 {P{1, 10}, addr((*pointerStringer)(nil))},
8699 {P{1, 10}, addr(pointerStringer{})},
8700 {P{1, 11}, addr(any(addr((*pointerStringer)(nil))))},
8701 {P{1, 11}, addr(addr((*pointerStringer)(nil)))},
8702 {P{1, 11}, addr((*pointerStringer)(nil))},
8703 {P{1, 11}, addr(pointerStringer{})},
8704 {P{1, 12}, addr(any(addr(addr(pointerStringer{}))))},
8705 {P{1, 12}, addr(addr(addr(pointerStringer{})))},
8706 {P{1, 12}, addr(addr(pointerStringer{}))},
8707 {P{1, 12}, addr(pointerStringer{})},
8708 {P{1, 13}, addr(any("LAST"))},
8709 {P{1, 13}, addr("LAST")},
8710 }
8711 checkAny := makeValueChecker("any", wantAny)
8712 anyUnmarshaler := UnmarshalFromFunc(func(dec *jsontext.Decoder, v any) error {
8713 return checkAny(dec, v)
8714 })
8715
8716 var wantPointerAny []PV
8717 for _, v := range wantAny {
8718 if _, ok := v.V.(*any); ok {
8719 wantPointerAny = append(wantPointerAny, v)
8720 }
8721 }
8722 checkPointerAny := makeValueChecker("*any", wantPointerAny)
8723 pointerAnyUnmarshaler := UnmarshalFromFunc(func(dec *jsontext.Decoder, v *any) error {
8724 return checkPointerAny(dec, v)
8725 })
8726
8727 checkNamedAny := makeValueChecker("namedAny", wantAny)
8728 namedAnyUnmarshaler := UnmarshalFromFunc(func(dec *jsontext.Decoder, v namedAny) error {
8729 return checkNamedAny(dec, v)
8730 })
8731
8732 checkPointerNamedAny := makeValueChecker("*namedAny", nil)
8733 pointerNamedAnyUnmarshaler := UnmarshalFromFunc(func(dec *jsontext.Decoder, v *namedAny) error {
8734 return checkPointerNamedAny(dec, v)
8735 })
8736
8737 type stringer = fmt.Stringer
8738 var wantStringer []PV
8739 for _, v := range wantAny {
8740 if _, ok := v.V.(stringer); ok {
8741 wantStringer = append(wantStringer, v)
8742 }
8743 }
8744 checkStringer := makeValueChecker("stringer", wantStringer)
8745 stringerUnmarshaler := UnmarshalFromFunc(func(dec *jsontext.Decoder, v stringer) error {
8746 return checkStringer(dec, v)
8747 })
8748
8749 checkPointerStringer := makeValueChecker("*stringer", nil)
8750 pointerStringerUnmarshaler := UnmarshalFromFunc(func(dec *jsontext.Decoder, v *stringer) error {
8751 return checkPointerStringer(dec, v)
8752 })
8753
8754 wantValueStringer := []P{{1, 1}, {1, 2}, {1, 3}, {1, 4}, {1, 5}, {1, 6}}
8755 checkPointerValueStringer := makePositionChecker("*valueStringer", wantValueStringer)
8756 pointerValueStringerUnmarshaler := UnmarshalFromFunc(func(dec *jsontext.Decoder, v *valueStringer) error {
8757 return checkPointerValueStringer(dec, v)
8758 })
8759
8760 wantPointerStringer := []P{{1, 7}, {1, 8}, {1, 9}, {1, 10}, {1, 11}, {1, 12}}
8761 checkPointerPointerStringer := makePositionChecker("*pointerStringer", wantPointerStringer)
8762 pointerPointerStringerUnmarshaler := UnmarshalFromFunc(func(dec *jsontext.Decoder, v *pointerStringer) error {
8763 return checkPointerPointerStringer(dec, v)
8764 })
8765
8766 lastUnmarshaler := UnmarshalFromFunc(func(dec *jsontext.Decoder, v *string) error {
8767 return checkLast()
8768 })
8769
8770 return JoinUnmarshalers(
8771
8772
8773 UnmarshalFromFunc(func(dec *jsontext.Decoder, v *[14]any) error {
8774 if _, err := dec.ReadToken(); err != nil {
8775 return err
8776 }
8777 for i := range len(*v) {
8778 if err := UnmarshalDecode(dec, &(*v)[i]); err != nil {
8779 return err
8780 }
8781 }
8782 if _, err := dec.ReadToken(); err != nil {
8783 return err
8784 }
8785 return nil
8786 }),
8787
8788 anyUnmarshaler,
8789 pointerAnyUnmarshaler,
8790 namedAnyUnmarshaler,
8791 pointerNamedAnyUnmarshaler,
8792 stringerUnmarshaler,
8793 pointerStringerUnmarshaler,
8794 pointerValueStringerUnmarshaler,
8795 pointerPointerStringerUnmarshaler,
8796 lastUnmarshaler,
8797 )
8798 }()),
8799 },
8800 inBuf: `[null,{},{},{},{},{},{},{},{},{},{},{},{},"LAST"]`,
8801 inVal: addr([...]any{
8802 nil,
8803 valueStringer{},
8804 (*valueStringer)(nil),
8805 addr(valueStringer{}),
8806 (**valueStringer)(nil),
8807 addr((*valueStringer)(nil)),
8808 addr(addr(valueStringer{})),
8809 pointerStringer{},
8810 (*pointerStringer)(nil),
8811 addr(pointerStringer{}),
8812 (**pointerStringer)(nil),
8813 addr((*pointerStringer)(nil)),
8814 addr(addr(pointerStringer{})),
8815 "LAST",
8816 }),
8817 }, {
8818 name: jsontest.Name("Functions/Precedence/V1First"),
8819 opts: []Options{
8820 WithUnmarshalers(JoinUnmarshalers(
8821 UnmarshalFunc(func(b []byte, v *string) error {
8822 if string(b) != `"called"` {
8823 return fmt.Errorf("got %s, want %s", b, `"called"`)
8824 }
8825 *v = "called"
8826 return nil
8827 }),
8828 UnmarshalFromFunc(func(dec *jsontext.Decoder, v *string) error {
8829 panic("should not be called")
8830 }),
8831 )),
8832 },
8833 inBuf: `"called"`,
8834 inVal: addr(""),
8835 want: addr("called"),
8836 }, {
8837 name: jsontest.Name("Functions/Precedence/V2First"),
8838 opts: []Options{
8839 WithUnmarshalers(JoinUnmarshalers(
8840 UnmarshalFromFunc(func(dec *jsontext.Decoder, v *string) error {
8841 switch t, err := dec.ReadToken(); {
8842 case err != nil:
8843 return err
8844 case t.String() != "called":
8845 return fmt.Errorf("got %q, want %q", t, "called")
8846 }
8847 *v = "called"
8848 return nil
8849 }),
8850 UnmarshalFunc(func([]byte, *string) error {
8851 panic("should not be called")
8852 }),
8853 )),
8854 },
8855 inBuf: `"called"`,
8856 inVal: addr(""),
8857 want: addr("called"),
8858 }, {
8859 name: jsontest.Name("Functions/Precedence/V2Skipped"),
8860 opts: []Options{
8861 WithUnmarshalers(JoinUnmarshalers(
8862 UnmarshalFromFunc(func(dec *jsontext.Decoder, v *string) error {
8863 return errors.ErrUnsupported
8864 }),
8865 UnmarshalFunc(func(b []byte, v *string) error {
8866 if string(b) != `"called"` {
8867 return fmt.Errorf("got %s, want %s", b, `"called"`)
8868 }
8869 *v = "called"
8870 return nil
8871 }),
8872 )),
8873 },
8874 inBuf: `"called"`,
8875 inVal: addr(""),
8876 want: addr("called"),
8877 }, {
8878 name: jsontest.Name("Functions/Precedence/NestedFirst"),
8879 opts: []Options{
8880 WithUnmarshalers(JoinUnmarshalers(
8881 JoinUnmarshalers(
8882 UnmarshalFunc(func(b []byte, v *string) error {
8883 if string(b) != `"called"` {
8884 return fmt.Errorf("got %s, want %s", b, `"called"`)
8885 }
8886 *v = "called"
8887 return nil
8888 }),
8889 ),
8890 UnmarshalFunc(func([]byte, *string) error {
8891 panic("should not be called")
8892 }),
8893 )),
8894 },
8895 inBuf: `"called"`,
8896 inVal: addr(""),
8897 want: addr("called"),
8898 }, {
8899 name: jsontest.Name("Functions/Precedence/NestedLast"),
8900 opts: []Options{
8901 WithUnmarshalers(JoinUnmarshalers(
8902 UnmarshalFunc(func(b []byte, v *string) error {
8903 if string(b) != `"called"` {
8904 return fmt.Errorf("got %s, want %s", b, `"called"`)
8905 }
8906 *v = "called"
8907 return nil
8908 }),
8909 JoinUnmarshalers(
8910 UnmarshalFunc(func([]byte, *string) error {
8911 panic("should not be called")
8912 }),
8913 ),
8914 )),
8915 },
8916 inBuf: `"called"`,
8917 inVal: addr(""),
8918 want: addr("called"),
8919 }, {
8920 name: jsontest.Name("Duration/Null"),
8921 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
8922 inBuf: `{"D1":null,"D2":null}`,
8923 inVal: addr(struct {
8924 D1 time.Duration `json:",format:units"`
8925 D2 time.Duration `json:",format:nano"`
8926 }{1, 1}),
8927 want: addr(struct {
8928 D1 time.Duration `json:",format:units"`
8929 D2 time.Duration `json:",format:nano"`
8930 }{0, 0}),
8931 }, {
8932 name: jsontest.Name("Duration/Zero"),
8933 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
8934 inBuf: `{"D1":"0s","D2":0}`,
8935 inVal: addr(struct {
8936 D1 time.Duration `json:",format:units"`
8937 D2 time.Duration `json:",format:nano"`
8938 }{1, 1}),
8939 want: addr(struct {
8940 D1 time.Duration `json:",format:units"`
8941 D2 time.Duration `json:",format:nano"`
8942 }{0, 0}),
8943 }, {
8944 name: jsontest.Name("Duration/Positive"),
8945 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
8946 inBuf: `{"D1":"34293h33m9.123456789s","D2":123456789123456789}`,
8947 inVal: new(struct {
8948 D1 time.Duration `json:",format:units"`
8949 D2 time.Duration `json:",format:nano"`
8950 }),
8951 want: addr(struct {
8952 D1 time.Duration `json:",format:units"`
8953 D2 time.Duration `json:",format:nano"`
8954 }{
8955 123456789123456789,
8956 123456789123456789,
8957 }),
8958 }, {
8959 name: jsontest.Name("Duration/Negative"),
8960 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
8961 inBuf: `{"D1":"-34293h33m9.123456789s","D2":-123456789123456789}`,
8962 inVal: new(struct {
8963 D1 time.Duration `json:",format:units"`
8964 D2 time.Duration `json:",format:nano"`
8965 }),
8966 want: addr(struct {
8967 D1 time.Duration `json:",format:units"`
8968 D2 time.Duration `json:",format:nano"`
8969 }{
8970 -123456789123456789,
8971 -123456789123456789,
8972 }),
8973 }, {
8974 name: jsontest.Name("Duration/Nanos/String"),
8975 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
8976 inBuf: `{"D":"12345"}`,
8977 inVal: addr(struct {
8978 D time.Duration `json:",string,format:nano"`
8979 }{1}),
8980 want: addr(struct {
8981 D time.Duration `json:",string,format:nano"`
8982 }{12345}),
8983 }, {
8984 name: jsontest.Name("Duration/Nanos/String/Invalid"),
8985 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
8986 inBuf: `{"D":"+12345"}`,
8987 inVal: addr(struct {
8988 D time.Duration `json:",string,format:nano"`
8989 }{1}),
8990 want: addr(struct {
8991 D time.Duration `json:",string,format:nano"`
8992 }{1}),
8993 wantErr: EU(fmt.Errorf(`invalid duration "+12345": %w`, strconv.ErrSyntax)).withPos(`{"D":`, "/D").withType('"', timeDurationType),
8994 }, {
8995 name: jsontest.Name("Duration/Nanos/Mismatch"),
8996 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
8997 inBuf: `{"D":"34293h33m9.123456789s"}`,
8998 inVal: addr(struct {
8999 D time.Duration `json:",format:nano"`
9000 }{1}),
9001 want: addr(struct {
9002 D time.Duration `json:",format:nano"`
9003 }{1}),
9004 wantErr: EU(nil).withPos(`{"D":`, "/D").withType('"', timeDurationType),
9005 }, {
9006 name: jsontest.Name("Duration/Nanos"),
9007 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
9008 inBuf: `{"D":1.324}`,
9009 inVal: addr(struct {
9010 D time.Duration `json:",format:nano"`
9011 }{-1}),
9012 want: addr(struct {
9013 D time.Duration `json:",format:nano"`
9014 }{1}),
9015 }, {
9016 name: jsontest.Name("Duration/String/Mismatch"),
9017 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
9018 inBuf: `{"D":-123456789123456789}`,
9019 inVal: addr(struct {
9020 D time.Duration `json:",format:units"`
9021 }{1}),
9022 want: addr(struct {
9023 D time.Duration `json:",format:units"`
9024 }{1}),
9025 wantErr: EU(nil).withPos(`{"D":`, "/D").withType('0', timeDurationType),
9026 }, {
9027 name: jsontest.Name("Duration/String/Invalid"),
9028 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
9029 inBuf: `{"D":"5minkutes"}`,
9030 inVal: addr(struct {
9031 D time.Duration `json:",format:units"`
9032 }{1}),
9033 want: addr(struct {
9034 D time.Duration `json:",format:units"`
9035 }{1}),
9036 wantErr: EU(func() error {
9037 _, err := time.ParseDuration("5minkutes")
9038 return err
9039 }()).withPos(`{"D":`, "/D").withType('"', timeDurationType),
9040 }, {
9041 name: jsontest.Name("Duration/Syntax/Invalid"),
9042 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
9043 inBuf: `{"D":x}`,
9044 inVal: addr(struct {
9045 D time.Duration `json:",format:units"`
9046 }{1}),
9047 want: addr(struct {
9048 D time.Duration `json:",format:units"`
9049 }{1}),
9050 wantErr: newInvalidCharacterError("x", "at start of value", len64(`{"D":`), "/D"),
9051 }, {
9052 name: jsontest.Name("Duration/Format"),
9053 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
9054 inBuf: `{
9055 "D1": "12h34m56.078090012s",
9056 "D2": "12h34m56.078090012s",
9057 "D3": 45296.078090012,
9058 "D4": "45296.078090012",
9059 "D5": 45296078.090012,
9060 "D6": "45296078.090012",
9061 "D7": 45296078090.012,
9062 "D8": "45296078090.012",
9063 "D9": 45296078090012,
9064 "D10": "45296078090012",
9065 "D11": "PT12H34M56.078090012S"
9066 }`,
9067 inVal: new(structDurationFormat),
9068 want: addr(structDurationFormat{
9069 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
9070 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
9071 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
9072 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
9073 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
9074 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
9075 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
9076 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
9077 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
9078 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
9079 12*time.Hour + 34*time.Minute + 56*time.Second + 78*time.Millisecond + 90*time.Microsecond + 12*time.Nanosecond,
9080 }),
9081 }, {
9082 name: jsontest.Name("Duration/Format/Invalid"),
9083 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
9084 inBuf: `{"D":"0s"}`,
9085 inVal: addr(struct {
9086 D time.Duration `json:",format:invalid"`
9087 }{1}),
9088 want: addr(struct {
9089 D time.Duration `json:",format:invalid"`
9090 }{1}),
9091 wantErr: EU(errInvalidFormatFlag).withPos(`{"D":`, "/D").withType(0, timeDurationType),
9092 }, {
9093
9103
9109 name: jsontest.Name("Duration/MapKey/Legacy"),
9110 opts: []Options{jsonflags.FormatDurationAsNano | 1},
9111 inBuf: `{"1000000000":""}`,
9112 inVal: new(map[time.Duration]string),
9113 want: addr(map[time.Duration]string{time.Second: ""}),
9114 }, {
9115
9122 name: jsontest.Name("Time/Zero"),
9123 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
9124 inBuf: `{"T1":"0001-01-01T00:00:00Z","T2":"01 Jan 01 00:00 UTC","T3":"0001-01-01","T4":"0001-01-01T00:00:00Z","T5":"0001-01-01T00:00:00Z"}`,
9125 inVal: new(struct {
9126 T1 time.Time
9127 T2 time.Time `json:",format:RFC822"`
9128 T3 time.Time `json:",format:'2006-01-02'"`
9129 T4 time.Time `json:",omitzero"`
9130 T5 time.Time `json:",omitempty"`
9131 }),
9132 want: addr(struct {
9133 T1 time.Time
9134 T2 time.Time `json:",format:RFC822"`
9135 T3 time.Time `json:",format:'2006-01-02'"`
9136 T4 time.Time `json:",omitzero"`
9137 T5 time.Time `json:",omitempty"`
9138 }{
9139 mustParseTime(time.RFC3339Nano, "0001-01-01T00:00:00Z"),
9140 mustParseTime(time.RFC822, "01 Jan 01 00:00 UTC"),
9141 mustParseTime("2006-01-02", "0001-01-01"),
9142 mustParseTime(time.RFC3339Nano, "0001-01-01T00:00:00Z"),
9143 mustParseTime(time.RFC3339Nano, "0001-01-01T00:00:00Z"),
9144 }),
9145 }, {
9146 name: jsontest.Name("Time/Format"),
9147 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
9148 inBuf: `{
9149 "T1": "1234-01-02T03:04:05.000000006Z",
9150 "T2": "Mon Jan 2 03:04:05 1234",
9151 "T3": "Mon Jan 2 03:04:05 UTC 1234",
9152 "T4": "Mon Jan 02 03:04:05 +0000 1234",
9153 "T5": "02 Jan 34 03:04 UTC",
9154 "T6": "02 Jan 34 03:04 +0000",
9155 "T7": "Monday, 02-Jan-34 03:04:05 UTC",
9156 "T8": "Mon, 02 Jan 1234 03:04:05 UTC",
9157 "T9": "Mon, 02 Jan 1234 03:04:05 +0000",
9158 "T10": "1234-01-02T03:04:05Z",
9159 "T11": "1234-01-02T03:04:05.000000006Z",
9160 "T12": "3:04AM",
9161 "T13": "Jan 2 03:04:05",
9162 "T14": "Jan 2 03:04:05.000",
9163 "T15": "Jan 2 03:04:05.000000",
9164 "T16": "Jan 2 03:04:05.000000006",
9165 "T17": "1234-01-02 03:04:05",
9166 "T18": "1234-01-02",
9167 "T19": "03:04:05",
9168 "T20": "1234-01-02",
9169 "T21": "\"weird\"1234",
9170 "T22": -23225777754.999999994,
9171 "T23": "-23225777754.999999994",
9172 "T24": -23225777754999.999994,
9173 "T25": "-23225777754999.999994",
9174 "T26": -23225777754999999.994,
9175 "T27": "-23225777754999999.994",
9176 "T28": -23225777754999999994,
9177 "T29": "-23225777754999999994"
9178 }`,
9179 inVal: new(structTimeFormat),
9180 want: addr(structTimeFormat{
9181 mustParseTime(time.RFC3339Nano, "1234-01-02T03:04:05.000000006Z"),
9182 mustParseTime(time.ANSIC, "Mon Jan 2 03:04:05 1234"),
9183 mustParseTime(time.UnixDate, "Mon Jan 2 03:04:05 UTC 1234"),
9184 mustParseTime(time.RubyDate, "Mon Jan 02 03:04:05 +0000 1234"),
9185 mustParseTime(time.RFC822, "02 Jan 34 03:04 UTC"),
9186 mustParseTime(time.RFC822Z, "02 Jan 34 03:04 +0000"),
9187 mustParseTime(time.RFC850, "Monday, 02-Jan-34 03:04:05 UTC"),
9188 mustParseTime(time.RFC1123, "Mon, 02 Jan 1234 03:04:05 UTC"),
9189 mustParseTime(time.RFC1123Z, "Mon, 02 Jan 1234 03:04:05 +0000"),
9190 mustParseTime(time.RFC3339, "1234-01-02T03:04:05Z"),
9191 mustParseTime(time.RFC3339Nano, "1234-01-02T03:04:05.000000006Z"),
9192 mustParseTime(time.Kitchen, "3:04AM"),
9193 mustParseTime(time.Stamp, "Jan 2 03:04:05"),
9194 mustParseTime(time.StampMilli, "Jan 2 03:04:05.000"),
9195 mustParseTime(time.StampMicro, "Jan 2 03:04:05.000000"),
9196 mustParseTime(time.StampNano, "Jan 2 03:04:05.000000006"),
9197 mustParseTime(time.DateTime, "1234-01-02 03:04:05"),
9198 mustParseTime(time.DateOnly, "1234-01-02"),
9199 mustParseTime(time.TimeOnly, "03:04:05"),
9200 mustParseTime("2006-01-02", "1234-01-02"),
9201 mustParseTime(`\"weird\"2006`, `\"weird\"1234`),
9202 time.Unix(-23225777755, 6).UTC(),
9203 time.Unix(-23225777755, 6).UTC(),
9204 time.Unix(-23225777755, 6).UTC(),
9205 time.Unix(-23225777755, 6).UTC(),
9206 time.Unix(-23225777755, 6).UTC(),
9207 time.Unix(-23225777755, 6).UTC(),
9208 time.Unix(-23225777755, 6).UTC(),
9209 time.Unix(-23225777755, 6).UTC(),
9210 }),
9211 }, {
9212 name: jsontest.Name("Time/Format/String/Invalid"),
9213 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
9214 inBuf: `{"T":"2023-01-01T00:00:00Z"}`,
9215 inVal: new(structTimeFormatStringInvalid),
9216 want: new(structTimeFormatStringInvalid),
9217 wantErr: EU(errInvalidStringTag).withPos(`{"T":`, "/T").withType(0, timeTimeType),
9218 }, {
9219 name: jsontest.Name("Time/Format/UnixString/InvalidNumber"),
9220 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
9221 inBuf: `{
9222 "T23": -23225777754.999999994,
9223 "T25": -23225777754999.999994,
9224 "T27": -23225777754999999.994,
9225 "T29": -23225777754999999994
9226 }`,
9227 inVal: new(structTimeFormat),
9228 want: new(structTimeFormat),
9229 wantErr: EU(nil).withPos(`{`+"\n\t\t\t"+`"T23": `, "/T23").withType('0', timeTimeType),
9230 }, {
9231 name: jsontest.Name("Time/Format/UnixString/InvalidString"),
9232 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
9233 inBuf: `{
9234 "T22": "-23225777754.999999994",
9235 "T24": "-23225777754999.999994",
9236 "T26": "-23225777754999999.994",
9237 "T28": "-23225777754999999994"
9238 }`,
9239 inVal: new(structTimeFormat),
9240 want: new(structTimeFormat),
9241 wantErr: EU(nil).withPos(`{`+"\n\t\t\t"+`"T22": `, "/T22").withType('"', timeTimeType),
9242 }, {
9243 name: jsontest.Name("Time/Format/Null"),
9244 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
9245 inBuf: `{"T1":null,"T2":null,"T3":null,"T4":null,"T5":null,"T6":null,"T7":null,"T8":null,"T9":null,"T10":null,"T11":null,"T12":null,"T13":null,"T14":null,"T15":null,"T16":null,"T17":null,"T18":null,"T19":null,"T20":null,"T21":null,"T22":null,"T23":null,"T24":null,"T25":null,"T26":null,"T27":null,"T28":null,"T29":null}`,
9246 inVal: addr(structTimeFormat{
9247 mustParseTime(time.RFC3339Nano, "1234-01-02T03:04:05.000000006Z"),
9248 mustParseTime(time.ANSIC, "Mon Jan 2 03:04:05 1234"),
9249 mustParseTime(time.UnixDate, "Mon Jan 2 03:04:05 UTC 1234"),
9250 mustParseTime(time.RubyDate, "Mon Jan 02 03:04:05 +0000 1234"),
9251 mustParseTime(time.RFC822, "02 Jan 34 03:04 UTC"),
9252 mustParseTime(time.RFC822Z, "02 Jan 34 03:04 +0000"),
9253 mustParseTime(time.RFC850, "Monday, 02-Jan-34 03:04:05 UTC"),
9254 mustParseTime(time.RFC1123, "Mon, 02 Jan 1234 03:04:05 UTC"),
9255 mustParseTime(time.RFC1123Z, "Mon, 02 Jan 1234 03:04:05 +0000"),
9256 mustParseTime(time.RFC3339, "1234-01-02T03:04:05Z"),
9257 mustParseTime(time.RFC3339Nano, "1234-01-02T03:04:05.000000006Z"),
9258 mustParseTime(time.Kitchen, "3:04AM"),
9259 mustParseTime(time.Stamp, "Jan 2 03:04:05"),
9260 mustParseTime(time.StampMilli, "Jan 2 03:04:05.000"),
9261 mustParseTime(time.StampMicro, "Jan 2 03:04:05.000000"),
9262 mustParseTime(time.StampNano, "Jan 2 03:04:05.000000006"),
9263 mustParseTime(time.DateTime, "1234-01-02 03:04:05"),
9264 mustParseTime(time.DateOnly, "1234-01-02"),
9265 mustParseTime(time.TimeOnly, "03:04:05"),
9266 mustParseTime("2006-01-02", "1234-01-02"),
9267 mustParseTime(`\"weird\"2006`, `\"weird\"1234`),
9268 time.Unix(-23225777755, 6).UTC(),
9269 time.Unix(-23225777755, 6).UTC(),
9270 time.Unix(-23225777755, 6).UTC(),
9271 time.Unix(-23225777755, 6).UTC(),
9272 time.Unix(-23225777755, 6).UTC(),
9273 time.Unix(-23225777755, 6).UTC(),
9274 time.Unix(-23225777755, 6).UTC(),
9275 time.Unix(-23225777755, 6).UTC(),
9276 }),
9277 want: new(structTimeFormat),
9278 }, {
9279 name: jsontest.Name("Time/RFC3339/Mismatch"),
9280 inBuf: `{"T":1234}`,
9281 inVal: new(struct {
9282 T time.Time
9283 }),
9284 wantErr: EU(nil).withPos(`{"T":`, "/T").withType('0', timeTimeType),
9285 }, {
9286 name: jsontest.Name("Time/RFC3339/ParseError"),
9287 inBuf: `{"T":"2021-09-29T12:44:52"}`,
9288 inVal: new(struct {
9289 T time.Time
9290 }),
9291 wantErr: EU(func() error {
9292 _, err := time.Parse(time.RFC3339, "2021-09-29T12:44:52")
9293 return err
9294 }()).withPos(`{"T":`, "/T").withType('"', timeTimeType),
9295 }, {
9296 name: jsontest.Name("Time/Format/Invalid"),
9297 opts: []Options{jsonopts.ExperimentalSupportFormatTag(true)},
9298 inBuf: `{"T":""}`,
9299 inVal: new(struct {
9300 T time.Time `json:",format:UndefinedConstant"`
9301 }),
9302 wantErr: EU(errors.New(`invalid format flag "UndefinedConstant"`)).withPos(`{"T":`, "/T").withType(0, timeTimeType),
9303 }, {
9304 name: jsontest.Name("Time/Format/SingleDigitHour"),
9305 inBuf: `{"T":"2000-01-01T1:12:34Z"}`,
9306 inVal: new(struct{ T time.Time }),
9307 wantErr: EU(newParseTimeError(time.RFC3339, "2000-01-01T1:12:34Z", "15", "1", "")).withPos(`{"T":`, "/T").withType('"', timeTimeType),
9308 }, {
9309 name: jsontest.Name("Time/Format/SubsecondComma"),
9310 inBuf: `{"T":"2000-01-01T00:00:00,000Z"}`,
9311 inVal: new(struct{ T time.Time }),
9312 wantErr: EU(newParseTimeError(time.RFC3339, "2000-01-01T00:00:00,000Z", ".", ",", "")).withPos(`{"T":`, "/T").withType('"', timeTimeType),
9313 }, {
9314 name: jsontest.Name("Time/Format/TimezoneHourOverflow"),
9315 inBuf: `{"T":"2000-01-01T00:00:00+24:00"}`,
9316 inVal: new(struct{ T time.Time }),
9317 wantErr: EU(newParseTimeError(time.RFC3339, "2000-01-01T00:00:00+24:00", "Z07:00", "+24:00", ": timezone hour out of range")).withPos(`{"T":`, "/T").withType('"', timeTimeType),
9318 }, {
9319 name: jsontest.Name("Time/Format/TimezoneMinuteOverflow"),
9320 inBuf: `{"T":"2000-01-01T00:00:00+00:60"}`,
9321 inVal: new(struct{ T time.Time }),
9322 wantErr: EU(newParseTimeError(time.RFC3339, "2000-01-01T00:00:00+00:60", "Z07:00", "+00:60", ": timezone minute out of range")).withPos(`{"T":`, "/T").withType('"', timeTimeType),
9323 }, {
9324 name: jsontest.Name("Time/Syntax/Invalid"),
9325 inBuf: `{"T":x}`,
9326 inVal: new(struct {
9327 T time.Time
9328 }),
9329 wantErr: newInvalidCharacterError("x", "at start of value", len64(`{"T":`), "/T"),
9330 }, {
9331 name: jsontest.Name("Time/IgnoreInvalidFormat"),
9332 opts: []Options{invalidFormatOption},
9333 inBuf: `"2000-01-01T00:00:00Z"`,
9334 inVal: addr(time.Time{}),
9335 want: addr(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
9336 }}
9337
9338 for _, tt := range tests {
9339 if tt.skip {
9340 continue
9341 }
9342 t.Run(tt.name.Name, func(t *testing.T) {
9343 got := tt.inVal
9344 gotErr := Unmarshal([]byte(tt.inBuf), got, tt.opts...)
9345 if !reflect.DeepEqual(got, tt.want) && tt.want != nil {
9346 t.Errorf("%s: Unmarshal output mismatch:\ngot %v\nwant %v", tt.name.Where, got, tt.want)
9347 }
9348 if !reflect.DeepEqual(gotErr, tt.wantErr) {
9349 t.Errorf("%s: Unmarshal error mismatch:\ngot %v\nwant %v", tt.name.Where, gotErr, tt.wantErr)
9350 }
9351 })
9352 }
9353 }
9354
9355 func TestMarshalInvalidNamespace(t *testing.T) {
9356 tests := []struct {
9357 name jsontest.CaseName
9358 val any
9359 }{
9360 {jsontest.Name("Map"), map[string]string{"X": "\xde\xad\xbe\xef"}},
9361 {jsontest.Name("Struct"), struct{ X string }{"\xde\xad\xbe\xef"}},
9362 {jsontest.Name("MapBadKey"), map[string]int{"\xde\xad\xbe\xef": 0}},
9363 }
9364 for _, tt := range tests {
9365 t.Run(tt.name.Name, func(t *testing.T) {
9366 enc := jsontext.NewEncoder(new(bytes.Buffer))
9367 if err := MarshalEncode(enc, tt.val); err == nil {
9368 t.Fatalf("%s: MarshalEncode error is nil, want non-nil", tt.name.Where)
9369 }
9370 for _, tok := range []jsontext.Token{
9371 jsontext.Null, jsontext.String(""), jsontext.Int(0), jsontext.BeginObject, jsontext.EndObject, jsontext.BeginArray, jsontext.EndArray,
9372 } {
9373 if err := enc.WriteToken(tok); err == nil {
9374 t.Fatalf("%s: WriteToken error is nil, want non-nil", tt.name.Where)
9375 }
9376 }
9377 for _, val := range []string{`null`, `""`, `0`, `{}`, `[]`} {
9378 if err := enc.WriteValue([]byte(val)); err == nil {
9379 t.Fatalf("%s: WriteToken error is nil, want non-nil", tt.name.Where)
9380 }
9381 }
9382 })
9383 }
9384 }
9385
9386
9387
9388
9389 func TestMarshalEncodeInvalidNamespaceAtName(t *testing.T) {
9390 enc := jsontext.NewEncoder(new(bytes.Buffer))
9391
9392
9393
9394
9395 if err := MarshalEncode(enc, map[string]int{"\xde\xad\xbe\xef": 0}); err == nil {
9396 t.Fatal("MarshalEncode error is nil, want non-nil")
9397 }
9398
9399 var serr *jsontext.SyntacticError
9400 if err := MarshalEncode(enc, 0); !errors.As(err, &serr) || serr.Err == nil {
9401 t.Fatalf("MarshalEncode error = %v, want *jsontext.SyntacticError wrapping a non-nil error", err)
9402 }
9403 }
9404
9405 func TestUnmarshalInvalidNamespace(t *testing.T) {
9406 tests := []struct {
9407 name jsontest.CaseName
9408 val any
9409 }{
9410 {jsontest.Name("Map"), addr(map[string]int{})},
9411 {jsontest.Name("Struct"), addr(struct{ X int }{})},
9412 }
9413 for _, tt := range tests {
9414 t.Run(tt.name.Name, func(t *testing.T) {
9415 dec := jsontext.NewDecoder(strings.NewReader(`{"X":""}`))
9416 if err := UnmarshalDecode(dec, tt.val); err == nil {
9417 t.Fatalf("%s: UnmarshalDecode error is nil, want non-nil", tt.name.Where)
9418 }
9419 if _, err := dec.ReadToken(); err == nil {
9420 t.Fatalf("%s: ReadToken error is nil, want non-nil", tt.name.Where)
9421 }
9422 if _, err := dec.ReadValue(); err == nil {
9423 t.Fatalf("%s: ReadValue error is nil, want non-nil", tt.name.Where)
9424 }
9425 })
9426 }
9427 }
9428
9429 func TestUnmarshalReuse(t *testing.T) {
9430 t.Run("Bytes", func(t *testing.T) {
9431 in := make([]byte, 3)
9432 want := &in[0]
9433 if err := Unmarshal([]byte(`"AQID"`), &in); err != nil {
9434 t.Fatalf("Unmarshal error: %v", err)
9435 }
9436 got := &in[0]
9437 if got != want {
9438 t.Errorf("input buffer was not reused")
9439 }
9440 })
9441 t.Run("Slices", func(t *testing.T) {
9442 in := make([]int, 3)
9443 want := &in[0]
9444 if err := Unmarshal([]byte(`[0,1,2]`), &in); err != nil {
9445 t.Fatalf("Unmarshal error: %v", err)
9446 }
9447 got := &in[0]
9448 if got != want {
9449 t.Errorf("input slice was not reused")
9450 }
9451 })
9452 t.Run("Maps", func(t *testing.T) {
9453 in := make(map[string]string)
9454 want := reflect.ValueOf(in).Pointer()
9455 if err := Unmarshal([]byte(`{"key":"value"}`), &in); err != nil {
9456 t.Fatalf("Unmarshal error: %v", err)
9457 }
9458 got := reflect.ValueOf(in).Pointer()
9459 if got != want {
9460 t.Errorf("input map was not reused")
9461 }
9462 })
9463 t.Run("Pointers", func(t *testing.T) {
9464 in := addr(addr(addr("hello")))
9465 want := **in
9466 if err := Unmarshal([]byte(`"goodbye"`), &in); err != nil {
9467 t.Fatalf("Unmarshal error: %v", err)
9468 }
9469 got := **in
9470 if got != want {
9471 t.Errorf("input pointer was not reused")
9472 }
9473 })
9474 }
9475
9476 type unmarshalerEOF struct{}
9477
9478 func (unmarshalerEOF) UnmarshalJSONFrom(dec *jsontext.Decoder) error {
9479 return io.EOF
9480 }
9481
9482
9483
9484 func TestUnmarshalEOF(t *testing.T) {
9485 opts := WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, _ *struct{}) error {
9486 return io.EOF
9487 }))
9488
9489 for _, in := range []string{"", "[", "[null", "[null]"} {
9490 for _, newOut := range []func() any{
9491 func() any { return new(unmarshalerEOF) },
9492 func() any { return new([]unmarshalerEOF) },
9493 func() any { return new(struct{}) },
9494 func() any { return new([]struct{}) },
9495 } {
9496 wantErr := io.ErrUnexpectedEOF
9497 if gotErr := Unmarshal([]byte(in), newOut(), opts); !errors.Is(gotErr, wantErr) {
9498 t.Errorf("Unmarshal = %v, want %v", gotErr, wantErr)
9499 }
9500 if gotErr := UnmarshalRead(strings.NewReader(in), newOut(), opts); !errors.Is(gotErr, wantErr) {
9501 t.Errorf("Unmarshal = %v, want %v", gotErr, wantErr)
9502 }
9503 switch gotErr := UnmarshalDecode(jsontext.NewDecoder(strings.NewReader(in)), newOut(), opts); {
9504 case in != "" && !errors.Is(gotErr, wantErr):
9505 t.Errorf("Unmarshal = %v, want %v", gotErr, wantErr)
9506 case in == "" && gotErr != io.EOF:
9507 t.Errorf("Unmarshal = %v, want %v", gotErr, io.EOF)
9508 }
9509 }
9510 }
9511 }
9512
9513 type ReaderFunc func([]byte) (int, error)
9514
9515 func (f ReaderFunc) Read(b []byte) (int, error) { return f(b) }
9516
9517 type WriterFunc func([]byte) (int, error)
9518
9519 func (f WriterFunc) Write(b []byte) (int, error) { return f(b) }
9520
9521 func TestCoderBufferGrowth(t *testing.T) {
9522
9523
9524 checkGrowth := func(ns []int) {
9525 t.Helper()
9526 var sumBytes, sumRates, numGrows float64
9527 prev := ns[0]
9528 for i := 1; i < len(ns)-1; i++ {
9529 n := ns[i]
9530 if n != prev {
9531 sumRates += float64(n) / float64(prev)
9532 numGrows++
9533 prev = n
9534 }
9535 if n > 1<<20 {
9536 t.Fatalf("single Read/Write too large: %d", n)
9537 }
9538 sumBytes += float64(n)
9539 }
9540 if mean := sumBytes / float64(len(ns)); mean < 1<<10 {
9541 t.Fatalf("average Read/Write too small: %0.1f", mean)
9542 }
9543 switch mean := sumRates / numGrows; {
9544 case mean < 1.25:
9545 t.Fatalf("average growth rate too slow: %0.3f", mean)
9546 case mean > 2.00:
9547 t.Fatalf("average growth rate too fast: %0.3f", mean)
9548 }
9549 }
9550
9551
9552
9553 bb := struct{ *bytes.Buffer }{new(bytes.Buffer)}
9554
9555 var writeSizes []int
9556 if err := MarshalWrite(WriterFunc(func(b []byte) (int, error) {
9557 n, err := bb.Write(b)
9558 writeSizes = append(writeSizes, n)
9559 return n, err
9560 }), make([]struct{}, 1e6)); err != nil {
9561 t.Fatalf("MarshalWrite error: %v", err)
9562 }
9563 checkGrowth(writeSizes)
9564
9565 var readSizes []int
9566 if err := UnmarshalRead(ReaderFunc(func(b []byte) (int, error) {
9567 n, err := bb.Read(b)
9568 readSizes = append(readSizes, n)
9569 return n, err
9570 }), new([]struct{})); err != nil {
9571 t.Fatalf("UnmarshalRead error: %v", err)
9572 }
9573 checkGrowth(readSizes)
9574 }
9575
9576 func TestUintSet(t *testing.T) {
9577 type operation any
9578 type has struct {
9579 in uint
9580 want bool
9581 }
9582 type insert struct {
9583 in uint
9584 want bool
9585 }
9586
9587
9588 ops := []operation{
9589 has{0, false},
9590 has{63, false},
9591 has{64, false},
9592 has{1234, false},
9593 insert{3, true},
9594 has{2, false},
9595 has{3, true},
9596 has{4, false},
9597 has{63, false},
9598 insert{3, false},
9599 insert{63, true},
9600 has{63, true},
9601 insert{64, true},
9602 insert{64, false},
9603 has{64, true},
9604 insert{3264, true},
9605 has{3264, true},
9606 insert{3, false},
9607 has{3, true},
9608 }
9609
9610 var us uintSet
9611 for i, op := range ops {
9612 switch op := op.(type) {
9613 case has:
9614 if got := us.has(op.in); got != op.want {
9615 t.Fatalf("%d: uintSet.has(%v) = %v, want %v", i, op.in, got, op.want)
9616 }
9617 case insert:
9618 if got := us.insert(op.in); got != op.want {
9619 t.Fatalf("%d: uintSet.insert(%v) = %v, want %v", i, op.in, got, op.want)
9620 }
9621 default:
9622 panic(fmt.Sprintf("unknown operation: %T", op))
9623 }
9624 }
9625 }
9626
9627 func TestUnmarshalDecodeOptions(t *testing.T) {
9628 var calledFuncs int
9629 var calledOptions Options
9630 in := strings.NewReader(strings.Repeat("\"\xde\xad\xbe\xef\"\n", 5))
9631 dec := jsontext.NewDecoder(in,
9632 jsontext.AllowInvalidUTF8(true),
9633 WithUnmarshalers(UnmarshalFromFunc(func(dec *jsontext.Decoder, _ any) error {
9634 opts := dec.Options()
9635 if v, _ := GetOption(opts, jsontext.AllowInvalidUTF8); !v {
9636 t.Errorf("nested Options.AllowInvalidUTF8 = false, want true")
9637 }
9638 calledFuncs++
9639 calledOptions = opts
9640 return errors.ErrUnsupported
9641 })),
9642 )
9643
9644 if err := UnmarshalDecode(dec, new(string)); err != nil {
9645 t.Fatalf("UnmarshalDecode: %v", err)
9646 }
9647 if calledFuncs != 1 {
9648 t.Fatalf("calledFuncs = %d, want 1", calledFuncs)
9649 }
9650 if err := UnmarshalDecode(dec, new(string), calledOptions); err != nil {
9651 t.Fatalf("UnmarshalDecode: %v", err)
9652 }
9653 if calledFuncs != 2 {
9654 t.Fatalf("calledFuncs = %d, want 2", calledFuncs)
9655 }
9656 if err := UnmarshalDecode(dec, new(string),
9657 jsontext.AllowInvalidUTF8(false),
9658 WithUnmarshalers(nil),
9659 ); !errors.Is(err, jsonwire.ErrInvalidUTF8) {
9660 t.Fatalf("UnmarshalDecode = %v, want %v", err, jsonwire.ErrInvalidUTF8)
9661 }
9662 if err := UnmarshalDecode(dec, new(string),
9663 WithUnmarshalers(nil),
9664 ); err != nil {
9665 t.Fatalf("UnmarshalDecode: %v", err)
9666 }
9667 if calledFuncs != 2 {
9668 t.Fatalf("calledFuncs = %d, want 2", calledFuncs)
9669 }
9670 if err := UnmarshalDecode(dec, new(string)); err != nil {
9671 t.Fatalf("UnmarshalDecode: %v", err)
9672 }
9673 if calledFuncs != 3 {
9674 t.Fatalf("calledFuncs = %d, want 3", calledFuncs)
9675 }
9676 if err := UnmarshalDecode(dec, new(string), JoinOptions(
9677 WithUnmarshalers(UnmarshalFromFunc(func(_ *jsontext.Decoder, _ any) error {
9678 opts := dec.Options()
9679 if v, _ := GetOption(opts, jsontext.AllowInvalidUTF8); !v {
9680 t.Errorf("nested Options.AllowInvalidUTF8 = false, want true")
9681 }
9682 calledFuncs = math.MaxInt
9683 return errors.ErrUnsupported
9684 })),
9685 )); err != nil {
9686 t.Fatalf("UnmarshalDecode: %v", err)
9687 }
9688 if calledFuncs != math.MaxInt {
9689 t.Fatalf("calledFuncs = %d, want %d", calledFuncs, math.MaxInt)
9690 }
9691
9692
9693
9694 opts := dec.Options()
9695 dec.Reset(in, jsontext.AllowInvalidUTF8(false), opts)
9696 if v, _ := GetOption(dec.Options(), jsontext.AllowInvalidUTF8); v == false {
9697 t.Errorf("Options.AllowInvalidUTF8 = false, want true")
9698 }
9699
9700
9701
9702 {
9703 dec2 := jsontext.NewDecoder(strings.NewReader(`{"name":{"dupe":"value","dupe":"value"}}`))
9704 if tok, err := dec2.ReadToken(); tok.Kind() != '{' || err != nil {
9705 t.Fatalf("ReadToken = (%v, %v), want ('{', nil)", tok.Kind(), err)
9706 }
9707 var name string
9708 if err := UnmarshalDecode(dec2, &name, jsontext.AllowDuplicateNames(true)); !errors.Is(err, errChangingDuplicateNames) {
9709 t.Errorf("UnmarshalDecode(name) = %v, want %v", err, errChangingDuplicateNames)
9710 }
9711 if err := UnmarshalDecode(dec2, &name, jsontext.AllowInvalidUTF8(true)); !errors.Is(err, errChangingInvalidUTF8) {
9712 t.Errorf("UnmarshalDecode(name) = %v, want %v", err, errChangingInvalidUTF8)
9713 }
9714
9715 if err := UnmarshalDecode(dec2, &name, jsontext.AllowDuplicateNames(false)); err != nil {
9716 t.Errorf("UnmarshalDecode(name) = %v, want nil", err)
9717 } else if name != "name" {
9718 t.Errorf("UnmarshalDecode(name) = %q, want %q", name, "name")
9719 }
9720
9721 var value jsontext.Value
9722 if err := UnmarshalDecode(dec2, &value, jsontext.AllowDuplicateNames(true)); err != nil {
9723 t.Errorf("UnmarshalDecode(value) = %v, want nil", err)
9724 }
9725 const want = `{"dupe":"value","dupe":"value"}`
9726 if string(value) != string(want) {
9727 t.Errorf("UnmarshalDecode(value) = %s, want %s", value, want)
9728 }
9729 }
9730 }
9731
9732 func TestUnmarshalDecodeStream(t *testing.T) {
9733 tests := []struct {
9734 in string
9735 want []any
9736 err error
9737 }{
9738 {in: ``, err: io.EOF},
9739 {in: `{`, err: &jsontext.SyntacticError{ByteOffset: len64(`{`), Err: io.ErrUnexpectedEOF}},
9740 {in: `{"`, err: &jsontext.SyntacticError{ByteOffset: len64(`{"`), Err: io.ErrUnexpectedEOF}},
9741 {in: `{"k"`, err: &jsontext.SyntacticError{ByteOffset: len64(`{"k"`), JSONPointer: "/k", Err: io.ErrUnexpectedEOF}},
9742 {in: `{"k":`, err: &jsontext.SyntacticError{ByteOffset: len64(`{"k":`), JSONPointer: "/k", Err: io.ErrUnexpectedEOF}},
9743 {in: `{"k",`, err: &jsontext.SyntacticError{ByteOffset: len64(`{"k"`), JSONPointer: "/k", Err: jsonwire.NewInvalidCharacterError(",", "after object name (expecting ':')")}},
9744 {in: `{"k"}`, err: &jsontext.SyntacticError{ByteOffset: len64(`{"k"`), JSONPointer: "/k", Err: jsonwire.NewInvalidCharacterError("}", "after object name (expecting ':')")}},
9745 {in: `[`, err: &jsontext.SyntacticError{ByteOffset: len64(`[`), Err: io.ErrUnexpectedEOF}},
9746 {in: `[0`, err: &jsontext.SyntacticError{ByteOffset: len64(`[0`), Err: io.ErrUnexpectedEOF}},
9747 {in: ` [0`, err: &jsontext.SyntacticError{ByteOffset: len64(` [0`), Err: io.ErrUnexpectedEOF}},
9748 {in: `[0.`, err: &jsontext.SyntacticError{ByteOffset: len64(`[`), JSONPointer: "/0", Err: io.ErrUnexpectedEOF}},
9749 {in: `[0. `, err: &jsontext.SyntacticError{ByteOffset: len64(`[0.`), JSONPointer: "/0", Err: jsonwire.NewInvalidCharacterError(" ", "in number (expecting digit)")}},
9750 {in: `[0,`, err: &jsontext.SyntacticError{ByteOffset: len64(`[0,`), Err: io.ErrUnexpectedEOF}},
9751 {in: `[0:`, err: &jsontext.SyntacticError{ByteOffset: len64(`[0`), Err: jsonwire.NewInvalidCharacterError(":", "after array element (expecting ',' or ']')")}},
9752 {in: `n`, err: &jsontext.SyntacticError{ByteOffset: len64(`n`), Err: io.ErrUnexpectedEOF}},
9753 {in: `nul`, err: &jsontext.SyntacticError{ByteOffset: len64(`nul`), Err: io.ErrUnexpectedEOF}},
9754 {in: `fal `, err: &jsontext.SyntacticError{ByteOffset: len64(`fal`), Err: jsonwire.NewInvalidCharacterError(" ", "in literal false (expecting 's')")}},
9755 {in: `false`, want: []any{false}, err: io.EOF},
9756 {in: `false0.0[]null`, want: []any{false, 0.0, []any{}, nil}, err: io.EOF},
9757 }
9758 for _, tt := range tests {
9759 d := jsontext.NewDecoder(strings.NewReader(tt.in))
9760 var got []any
9761 for {
9762 var v any
9763 if err := UnmarshalDecode(d, &v); err != nil {
9764 if !reflect.DeepEqual(err, tt.err) {
9765 t.Errorf("`%s`: UnmarshalDecode error = %v, want %v", tt.in, err, tt.err)
9766 }
9767 break
9768 }
9769 got = append(got, v)
9770 }
9771 if !reflect.DeepEqual(got, tt.want) {
9772 t.Errorf("`%s`: UnmarshalDecode = %v, want %v", tt.in, got, tt.want)
9773 }
9774 }
9775 }
9776
9777
9778
9779 func BenchmarkUnmarshalDecodeOptions(b *testing.B) {
9780 var i int
9781 in := new(bytes.Buffer)
9782 dec := jsontext.NewDecoder(in)
9783 makeBench := func(opts ...Options) func(*testing.B) {
9784 return func(b *testing.B) {
9785 for range b.N {
9786 in.WriteString("0 ")
9787 }
9788 dec.Reset(in)
9789 b.ResetTimer()
9790 for range b.N {
9791 UnmarshalDecode(dec, &i, opts...)
9792 }
9793 }
9794 }
9795 b.Run("None", makeBench())
9796 b.Run("Same", makeBench(&export.Decoder(dec).Struct))
9797 b.Run("New", makeBench(DefaultOptionsV2()))
9798 }
9799
9800 func TestMarshalEncodeOptions(t *testing.T) {
9801 var calledFuncs int
9802 var calledOptions Options
9803 out := new(bytes.Buffer)
9804 enc := jsontext.NewEncoder(
9805 out,
9806 jsontext.AllowInvalidUTF8(true),
9807 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, _ any) error {
9808 opts := enc.Options()
9809 if v, _ := GetOption(opts, jsontext.AllowInvalidUTF8); !v {
9810 t.Errorf("nested Options.AllowInvalidUTF8 = false, want true")
9811 }
9812 calledFuncs++
9813 calledOptions = opts
9814 return errors.ErrUnsupported
9815 })),
9816 )
9817
9818 if err := MarshalEncode(enc, "\xde\xad\xbe\xef"); err != nil {
9819 t.Fatalf("MarshalEncode: %v", err)
9820 }
9821 if calledFuncs != 1 {
9822 t.Fatalf("calledFuncs = %d, want 1", calledFuncs)
9823 }
9824 if err := MarshalEncode(enc, "\xde\xad\xbe\xef", calledOptions); err != nil {
9825 t.Fatalf("MarshalEncode: %v", err)
9826 }
9827 if calledFuncs != 2 {
9828 t.Fatalf("calledFuncs = %d, want 2", calledFuncs)
9829 }
9830 if err := MarshalEncode(enc, "\xde\xad\xbe\xef",
9831 jsontext.AllowInvalidUTF8(false),
9832 WithMarshalers(nil),
9833 ); !errors.Is(err, jsonwire.ErrInvalidUTF8) {
9834 t.Fatalf("MarshalEncode = %v, want %v", err, jsonwire.ErrInvalidUTF8)
9835 }
9836 if err := MarshalEncode(enc, "\xde\xad\xbe\xef",
9837 WithMarshalers(nil),
9838 ); err != nil {
9839 t.Fatalf("MarshalEncode: %v", err)
9840 }
9841 if calledFuncs != 2 {
9842 t.Fatalf("calledFuncs = %d, want 2", calledFuncs)
9843 }
9844 if err := MarshalEncode(enc, "\xde\xad\xbe\xef"); err != nil {
9845 t.Fatalf("MarshalEncode: %v", err)
9846 }
9847 if calledFuncs != 3 {
9848 t.Fatalf("calledFuncs = %d, want 3", calledFuncs)
9849 }
9850 if err := MarshalEncode(enc, "\xde\xad\xbe\xef", JoinOptions(
9851 WithMarshalers(MarshalToFunc(func(enc *jsontext.Encoder, _ any) error {
9852 opts := enc.Options()
9853 if v, _ := GetOption(opts, jsontext.AllowInvalidUTF8); !v {
9854 t.Errorf("nested Options.AllowInvalidUTF8 = false, want true")
9855 }
9856 calledFuncs = math.MaxInt
9857 return errors.ErrUnsupported
9858 })),
9859 )); err != nil {
9860 t.Fatalf("MarshalEncode: %v", err)
9861 }
9862 if calledFuncs != math.MaxInt {
9863 t.Fatalf("calledFuncs = %d, want %d", calledFuncs, math.MaxInt)
9864 }
9865 if out.String() != strings.Repeat("\"\xde\xad\ufffd\ufffd\"\n", 5) {
9866 t.Fatalf("output mismatch:\n\tgot: %s\n\twant: %s", out.String(), strings.Repeat("\"\xde\xad\xbe\xef\"\n", 5))
9867 }
9868
9869
9870
9871 opts := enc.Options()
9872 enc.Reset(out, jsontext.AllowInvalidUTF8(false), opts)
9873 if v, _ := GetOption(enc.Options(), jsontext.AllowInvalidUTF8); v == false {
9874 t.Errorf("Options.AllowInvalidUTF8 = false, want true")
9875 }
9876
9877
9878
9879 {
9880 var buf2 bytes.Buffer
9881 enc2 := jsontext.NewEncoder(&buf2)
9882 if err := enc2.WriteToken(jsontext.BeginObject); err != nil {
9883 t.Fatalf("WriteToken(BeginObject) = %v, want nil", err)
9884 }
9885
9886
9887 if err := MarshalEncode(enc2, "name", jsontext.AllowDuplicateNames(true)); !errors.Is(err, errChangingDuplicateNames) {
9888 t.Errorf("MarshalEncode(name) = %v, want %v", err, errChangingDuplicateNames)
9889 }
9890 if err := MarshalEncode(enc2, "name", jsontext.AllowInvalidUTF8(true)); !errors.Is(err, errChangingInvalidUTF8) {
9891 t.Errorf("MarshalEncode(name) = %v, want %v", err, errChangingInvalidUTF8)
9892 }
9893
9894 if err := MarshalEncode(enc2, "name", jsontext.AllowDuplicateNames(false)); err != nil {
9895 t.Errorf("MarshalEncode(name) = %v, want nil", err)
9896 }
9897
9898 if err := MarshalEncode(enc2, jsontext.Value(`{"dupe":"value","dupe":"value"}`), jsontext.AllowDuplicateNames(true)); err != nil {
9899 t.Errorf("MarshalEncode(value) = %v, want nil", err)
9900 }
9901
9902
9903 if err := MarshalEncode(enc2, "name2"); err != nil {
9904 t.Errorf("MarshalEncode(name) = %v, want nil", err)
9905 }
9906 if err := MarshalEncode(enc2, "value\xde\xad\xbe\xef"); !errors.Is(err, jsonwire.ErrInvalidUTF8) {
9907 t.Errorf("MarshalEncode(value) = %v, want %v", err, jsonwire.ErrInvalidUTF8)
9908 }
9909 if err := MarshalEncode(enc2, "value\xde\xad\xbe\xef", jsontext.AllowInvalidUTF8(true)); err != nil {
9910 t.Errorf("MarshalEncode(value) = %v, want nil", err)
9911 }
9912
9913 if err := enc2.WriteToken(jsontext.EndObject); err != nil {
9914 t.Errorf("WriteToken(EndObject) = %v, want nil", err)
9915 }
9916 }
9917
9918
9919
9920 {
9921 var buf3 bytes.Buffer
9922 enc3 := jsontext.NewEncoder(&buf3, jsontext.WithIndent("\t"))
9923 if err := MarshalEncode(enc3, "value", jsontext.Multiline(false)); !errors.Is(err, errChangingWhitespace) {
9924 t.Errorf("MarshalEncode = %v, want %v", err, errChangingWhitespace)
9925 }
9926 if err := MarshalEncode(enc3, "value", jsontext.WithIndent(" ")); !errors.Is(err, errChangingWhitespace) {
9927 t.Errorf("MarshalEncode = %v, want %v", err, errChangingWhitespace)
9928 }
9929
9930 if err := MarshalEncode(enc3, "value", enc3.Options()); err != nil {
9931 t.Errorf("MarshalEncode = %v, want nil", err)
9932 }
9933 }
9934 }
9935
9936
9937
9938 func BenchmarkMarshalEncodeOptions(b *testing.B) {
9939 var i int
9940 out := new(bytes.Buffer)
9941 enc := jsontext.NewEncoder(out)
9942 makeBench := func(opts ...Options) func(*testing.B) {
9943 return func(b *testing.B) {
9944 out.Reset()
9945 enc.Reset(out)
9946 b.ResetTimer()
9947 for range b.N {
9948 MarshalEncode(enc, &i, opts...)
9949 }
9950 }
9951 }
9952 b.Run("None", makeBench())
9953 b.Run("Same", makeBench(&export.Encoder(enc).Struct))
9954 b.Run("New", makeBench(DefaultOptionsV2()))
9955 }
9956
View as plain text